Examples with TransitRegionStateProcedure org.apache.hadoop.hbase.master.assignment.TransitRegionStateProcedure used on opensource projects

Example 1 with TransitRegionStateProcedure

use of org.apache.hadoop.hbase.master.assignment.TransitRegionStateProcedure in project hbase by apache.

the class HMaster method move.

// Public so can be accessed by tests. Blocks until move is done.
// Replace with an async implementation from which you can get
// a success/failure result.
@InterfaceAudience.Private
public void move(final byte[] encodedRegionName, byte[] destServerName) throws IOException {
    RegionState regionState = assignmentManager.getRegionStates().getRegionState(Bytes.toString(encodedRegionName));
    RegionInfo hri;
    if (regionState != null) {
        hri = regionState.getRegion();
    } else {
        throw new UnknownRegionException(Bytes.toStringBinary(encodedRegionName));
    }
    ServerName dest;
    List<ServerName> exclude = hri.getTable().isSystemTable() ? assignmentManager.getExcludedServersForSystemTable() : new ArrayList<>(1);
    if (destServerName != null && exclude.contains(ServerName.valueOf(Bytes.toString(destServerName)))) {
        LOG.info(Bytes.toString(encodedRegionName) + " can not move to " + Bytes.toString(destServerName) + " because the server is in exclude list");
        destServerName = null;
    }
    if (destServerName == null || destServerName.length == 0) {
        LOG.info("Passed destination servername is null/empty so " + "choosing a server at random");
        exclude.add(regionState.getServerName());
        final List<ServerName> destServers = this.serverManager.createDestinationServersList(exclude);
        dest = balancer.randomAssignment(hri, destServers);
        if (dest == null) {
            LOG.debug("Unable to determine a plan to assign " + hri);
            return;
        }
    } else {
        ServerName candidate = ServerName.valueOf(Bytes.toString(destServerName));
        dest = balancer.randomAssignment(hri, Lists.newArrayList(candidate));
        if (dest == null) {
            LOG.debug("Unable to determine a plan to assign " + hri);
            return;
        }
        // TODO: deal with table on master for rs group.
        if (dest.equals(serverName)) {
            // To avoid unnecessary region moving later by balancer. Don't put user
            // 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");
            return;
        }
    }
    if (dest.equals(regionState.getServerName())) {
        LOG.debug("Skipping move of region " + hri.getRegionNameAsString() + " because region already assigned to the same server " + dest + ".");
        return;
    }
    // Now we can do the move
    RegionPlan rp = new RegionPlan(hri, regionState.getServerName(), dest);
    assert rp.getDestination() != null : rp.toString() + " " + dest;
    try {
        checkInitialized();
        if (this.cpHost != null) {
            this.cpHost.preMove(hri, rp.getSource(), rp.getDestination());
        }
        TransitRegionStateProcedure proc = this.assignmentManager.createMoveRegionProcedure(rp.getRegionInfo(), rp.getDestination());
        if (conf.getBoolean(WARMUP_BEFORE_MOVE, DEFAULT_WARMUP_BEFORE_MOVE)) {
            // Warmup the region on the destination before initiating the move.
            // A region server could reject the close request because it either does not
            // have the specified region or the region is being split.
            LOG.info(getClientIdAuditPrefix() + " move " + rp + ", warming up region on " + rp.getDestination());
            warmUpRegion(rp.getDestination(), hri);
        }
        LOG.info(getClientIdAuditPrefix() + " move " + rp + ", running balancer");
        Future<byte[]> future = ProcedureSyncWait.submitProcedure(this.procedureExecutor, proc);
        try {
            // Is this going to work? Will we throw exception on error?
            // TODO: CompletableFuture rather than this stunted Future.
            future.get();
        } catch (InterruptedException | ExecutionException e) {
            throw new HBaseIOException(e);
        }
        if (this.cpHost != null) {
            this.cpHost.postMove(hri, rp.getSource(), rp.getDestination());
        }
    } catch (IOException ioe) {
        if (ioe instanceof HBaseIOException) {
            throw (HBaseIOException) ioe;
        }
        throw new HBaseIOException(ioe);
    }
}

Example 2 with TransitRegionStateProcedure

use of org.apache.hadoop.hbase.master.assignment.TransitRegionStateProcedure in project hbase by apache.

the class HMaster method finishActiveMasterInitialization.

/**
 * Finish initialization of HMaster after becoming the primary master.
 * <p/>
 * The startup order is a bit complicated but very important, do not change it unless you know
 * what you are doing.
 * <ol>
 * <li>Initialize file system based components - file system manager, wal manager, table
 * descriptors, etc</li>
 * <li>Publish cluster id</li>
 * <li>Here comes the most complicated part - initialize server manager, assignment manager and
 * region server tracker
 * <ol type='i'>
 * <li>Create server manager</li>
 * <li>Create master local region</li>
 * <li>Create procedure executor, load the procedures, but do not start workers. We will start it
 * later after we finish scheduling SCPs to avoid scheduling duplicated SCPs for the same
 * server</li>
 * <li>Create assignment manager and start it, load the meta region state, but do not load data
 * from meta region</li>
 * <li>Start region server tracker, construct the online servers set and find out dead servers and
 * schedule SCP for them. The online servers will be constructed by scanning zk, and we will also
 * scan the wal directory to find out possible live region servers, and the differences between
 * these two sets are the dead servers</li>
 * </ol>
 * </li>
 * <li>If this is a new deploy, schedule a InitMetaProcedure to initialize meta</li>
 * <li>Start necessary service threads - balancer, catalog janitor, executor services, and also
 * the procedure executor, etc. Notice that the balancer must be created first as assignment
 * manager may use it when assigning regions.</li>
 * <li>Wait for meta to be initialized if necessary, start table state manager.</li>
 * <li>Wait for enough region servers to check-in</li>
 * <li>Let assignment manager load data from meta and construct region states</li>
 * <li>Start all other things such as chore services, etc</li>
 * </ol>
 * <p/>
 * Notice that now we will not schedule a special procedure to make meta online(unless the first
 * time where meta has not been created yet), we will rely on SCP to bring meta online.
 */
private void finishActiveMasterInitialization(MonitoredTask status) throws IOException, InterruptedException, KeeperException, ReplicationException {
    /*
     * We are active master now... go initialize components we need to run.
     */
    status.setStatus("Initializing Master file system");
    this.masterActiveTime = EnvironmentEdgeManager.currentTime();
    // TODO: Do this using Dependency Injection, using PicoContainer, Guice or Spring.
    // always initialize the MemStoreLAB as we use a region to store data in master now, see
    // localStore.
    initializeMemStoreChunkCreator(null);
    this.fileSystemManager = new MasterFileSystem(conf);
    this.walManager = new MasterWalManager(this);
    // warm-up HTDs cache on master initialization
    if (preLoadTableDescriptors) {
        status.setStatus("Pre-loading table descriptors");
        this.tableDescriptors.getAll();
    }
    // Publish cluster ID; set it in Master too. The superclass RegionServer does this later but
    // only after it has checked in with the Master. At least a few tests ask Master for clusterId
    // before it has called its run method and before RegionServer has done the reportForDuty.
    ClusterId clusterId = fileSystemManager.getClusterId();
    status.setStatus("Publishing Cluster ID " + clusterId + " in ZooKeeper");
    ZKClusterId.setClusterId(this.zooKeeper, fileSystemManager.getClusterId());
    this.clusterId = clusterId.toString();
    // hbase.write.hbck1.lock.file to false.
    if (this.conf.getBoolean("hbase.write.hbck1.lock.file", true)) {
        Pair<Path, FSDataOutputStream> result = null;
        try {
            result = HBaseFsck.checkAndMarkRunningHbck(this.conf, HBaseFsck.createLockRetryCounterFactory(this.conf).create());
        } finally {
            if (result != null) {
                Closeables.close(result.getSecond(), true);
            }
        }
    }
    status.setStatus("Initialize ServerManager and schedule SCP for crash servers");
    // The below two managers must be created before loading procedures, as they will be used during
    // loading.
    this.serverManager = createServerManager(this);
    this.syncReplicationReplayWALManager = new SyncReplicationReplayWALManager(this);
    if (!conf.getBoolean(HBASE_SPLIT_WAL_COORDINATED_BY_ZK, DEFAULT_HBASE_SPLIT_COORDINATED_BY_ZK)) {
        this.splitWALManager = new SplitWALManager(this);
    }
    // initialize master local region
    masterRegion = MasterRegionFactory.create(this);
    tryMigrateMetaLocationsFromZooKeeper();
    createProcedureExecutor();
    Map<Class<?>, List<Procedure<MasterProcedureEnv>>> procsByType = procedureExecutor.getActiveProceduresNoCopy().stream().collect(Collectors.groupingBy(p -> p.getClass()));
    // Create Assignment Manager
    this.assignmentManager = createAssignmentManager(this, masterRegion);
    this.assignmentManager.start();
    // TODO: TRSP can perform as the sub procedure for other procedures, so even if it is marked as
    // completed, it could still be in the procedure list. This is a bit strange but is another
    // story, need to verify the implementation for ProcedureExecutor and ProcedureStore.
    List<TransitRegionStateProcedure> ritList = procsByType.getOrDefault(TransitRegionStateProcedure.class, Collections.emptyList()).stream().filter(p -> !p.isFinished()).map(p -> (TransitRegionStateProcedure) p).collect(Collectors.toList());
    this.assignmentManager.setupRIT(ritList);
    // Start RegionServerTracker with listing of servers found with exiting SCPs -- these should
    // be registered in the deadServers set -- and with the list of servernames out on the
    // filesystem that COULD BE 'alive' (we'll schedule SCPs for each and let SCP figure it out).
    // We also pass dirs that are already 'splitting'... so we can do some checks down in tracker.
    // TODO: Generate the splitting and live Set in one pass instead of two as we currently do.
    this.regionServerTracker.upgrade(procsByType.getOrDefault(ServerCrashProcedure.class, Collections.emptyList()).stream().map(p -> (ServerCrashProcedure) p).map(p -> p.getServerName()).collect(Collectors.toSet()), walManager.getLiveServersFromWALDir(), walManager.getSplittingServersFromWALDir());
    // This manager must be accessed AFTER hbase:meta is confirmed on line..
    this.tableStateManager = new TableStateManager(this);
    status.setStatus("Initializing ZK system trackers");
    initializeZKBasedSystemTrackers();
    status.setStatus("Loading last flushed sequence id of regions");
    try {
        this.serverManager.loadLastFlushedSequenceIds();
    } catch (IOException e) {
        LOG.info("Failed to load last flushed sequence id of regions" + " from file system", e);
    }
    // Set ourselves as active Master now our claim has succeeded up in zk.
    this.activeMaster = true;
    // Start the Zombie master detector after setting master as active, see HBASE-21535
    Thread zombieDetector = new Thread(new MasterInitializationMonitor(this), "ActiveMasterInitializationMonitor-" + EnvironmentEdgeManager.currentTime());
    zombieDetector.setDaemon(true);
    zombieDetector.start();
    if (!maintenanceMode) {
        // default with quota support, avoiding if user specifically asks to not load this Observer.
        if (QuotaUtil.isQuotaEnabled(conf)) {
            updateConfigurationForQuotasObserver(conf);
        }
        // initialize master side coprocessors before we start handling requests
        status.setStatus("Initializing master coprocessors");
        this.cpHost = new MasterCoprocessorHost(this, this.conf);
    } else {
        // start an in process region server for carrying system regions
        maintenanceRegionServer = JVMClusterUtil.createRegionServerThread(getConfiguration(), HRegionServer.class, 0);
        maintenanceRegionServer.start();
    }
    // Checking if meta needs initializing.
    status.setStatus("Initializing meta table if this is a new deploy");
    InitMetaProcedure initMetaProc = null;
    // Print out state of hbase:meta on startup; helps debugging.
    if (!this.assignmentManager.getRegionStates().hasTableRegionStates(TableName.META_TABLE_NAME)) {
        Optional<InitMetaProcedure> optProc = procedureExecutor.getProcedures().stream().filter(p -> p instanceof InitMetaProcedure).map(o -> (InitMetaProcedure) o).findAny();
        initMetaProc = optProc.orElseGet(() -> {
            // schedule an init meta procedure if meta has not been deployed yet
            InitMetaProcedure temp = new InitMetaProcedure();
            procedureExecutor.submitProcedure(temp);
            return temp;
        });
    }
    // initialize load balancer
    this.balancer.setMasterServices(this);
    this.balancer.initialize();
    this.balancer.updateClusterMetrics(getClusterMetricsWithoutCoprocessor());
    // start up all service threads.
    status.setStatus("Initializing master service threads");
    startServiceThreads();
    // wait meta to be initialized after we start procedure executor
    if (initMetaProc != null) {
        initMetaProc.await();
    }
    // Wake up this server to check in
    sleeper.skipSleepCycle();
    // Wait for region servers to report in.
    // With this as part of master initialization, it precludes our being able to start a single
    // server that is both Master and RegionServer. Needs more thought. TODO.
    String statusStr = "Wait for region servers to report in";
    status.setStatus(statusStr);
    LOG.info(Objects.toString(status));
    waitForRegionServers(status);
    // Check if master is shutting down because issue initializing regionservers or balancer.
    if (isStopped()) {
        return;
    }
    status.setStatus("Starting assignment manager");
    // available. That's what waitForMetaOnline does.
    if (!waitForMetaOnline()) {
        return;
    }
    TableDescriptor metaDescriptor = tableDescriptors.get(TableName.META_TABLE_NAME);
    final ColumnFamilyDescriptor tableFamilyDesc = metaDescriptor.getColumnFamily(HConstants.TABLE_FAMILY);
    final ColumnFamilyDescriptor replBarrierFamilyDesc = metaDescriptor.getColumnFamily(HConstants.REPLICATION_BARRIER_FAMILY);
    this.assignmentManager.joinCluster();
    // The below depends on hbase:meta being online.
    this.assignmentManager.processOfflineRegions();
    // this must be called after the above processOfflineRegions to prevent race
    this.assignmentManager.wakeMetaLoadedEvent();
    // first.
    if (conf.get(HConstants.META_REPLICAS_NUM) != null) {
        int replicasNumInConf = conf.getInt(HConstants.META_REPLICAS_NUM, HConstants.DEFAULT_META_REPLICA_NUM);
        TableDescriptor metaDesc = tableDescriptors.get(TableName.META_TABLE_NAME);
        if (metaDesc.getRegionReplication() != replicasNumInConf) {
            // it is possible that we already have some replicas before upgrading, so we must set the
            // region replication number in meta TableDescriptor directly first, without creating a
            // ModifyTableProcedure, otherwise it may cause a double assign for the meta replicas.
            int existingReplicasCount = assignmentManager.getRegionStates().getRegionsOfTable(TableName.META_TABLE_NAME).size();
            if (existingReplicasCount > metaDesc.getRegionReplication()) {
                LOG.info("Update replica count of hbase:meta from {}(in TableDescriptor)" + " to {}(existing ZNodes)", metaDesc.getRegionReplication(), existingReplicasCount);
                metaDesc = TableDescriptorBuilder.newBuilder(metaDesc).setRegionReplication(existingReplicasCount).build();
                tableDescriptors.update(metaDesc);
            }
            // check again, and issue a ModifyTableProcedure if needed
            if (metaDesc.getRegionReplication() != replicasNumInConf) {
                LOG.info("The {} config is {} while the replica count in TableDescriptor is {}" + " for hbase:meta, altering...", HConstants.META_REPLICAS_NUM, replicasNumInConf, metaDesc.getRegionReplication());
                procedureExecutor.submitProcedure(new ModifyTableProcedure(procedureExecutor.getEnvironment(), TableDescriptorBuilder.newBuilder(metaDesc).setRegionReplication(replicasNumInConf).build(), null, metaDesc, false));
            }
        }
    }
    // Initialize after meta is up as below scans meta
    FavoredNodesManager fnm = getFavoredNodesManager();
    if (fnm != null) {
        fnm.initializeFromMeta();
    }
    // set cluster status again after user regions are assigned
    this.balancer.updateClusterMetrics(getClusterMetricsWithoutCoprocessor());
    // Start balancer and meta catalog janitor after meta and regions have been assigned.
    status.setStatus("Starting balancer and catalog janitor");
    this.clusterStatusChore = new ClusterStatusChore(this, balancer);
    getChoreService().scheduleChore(clusterStatusChore);
    this.balancerChore = new BalancerChore(this);
    if (!disableBalancerChoreForTest) {
        getChoreService().scheduleChore(balancerChore);
    }
    if (regionNormalizerManager != null) {
        getChoreService().scheduleChore(regionNormalizerManager.getRegionNormalizerChore());
    }
    this.catalogJanitorChore = new CatalogJanitor(this);
    getChoreService().scheduleChore(catalogJanitorChore);
    this.hbckChore = new HbckChore(this);
    getChoreService().scheduleChore(hbckChore);
    this.serverManager.startChore();
    // Only for rolling upgrade, where we need to migrate the data in namespace table to meta table.
    if (!waitForNamespaceOnline()) {
        return;
    }
    status.setStatus("Starting cluster schema service");
    try {
        initClusterSchemaService();
    } catch (IllegalStateException e) {
        if (e.getCause() != null && e.getCause() instanceof NoSuchColumnFamilyException && tableFamilyDesc == null && replBarrierFamilyDesc == null) {
            LOG.info("ClusterSchema service could not be initialized. This is " + "expected during HBase 1 to 2 upgrade", e);
        } else {
            throw e;
        }
    }
    if (this.cpHost != null) {
        try {
            this.cpHost.preMasterInitialization();
        } catch (IOException e) {
            LOG.error("Coprocessor preMasterInitialization() hook failed", e);
        }
    }
    status.markComplete("Initialization successful");
    LOG.info(String.format("Master has completed initialization %.3fsec", (EnvironmentEdgeManager.currentTime() - masterActiveTime) / 1000.0f));
    this.masterFinishedInitializationTime = EnvironmentEdgeManager.currentTime();
    configurationManager.registerObserver(this.balancer);
    configurationManager.registerObserver(this.hfileCleanerPool);
    configurationManager.registerObserver(this.logCleanerPool);
    configurationManager.registerObserver(this.hfileCleaner);
    configurationManager.registerObserver(this.logCleaner);
    configurationManager.registerObserver(this.regionsRecoveryConfigManager);
    // Set master as 'initialized'.
    setInitialized(true);
    if (tableFamilyDesc == null && replBarrierFamilyDesc == null) {
        // create missing CFs in meta table after master is set to 'initialized'.
        createMissingCFsInMetaDuringUpgrade(metaDescriptor);
        // services will be started during master init phase.
        throw new PleaseRestartMasterException("Aborting active master after missing" + " CFs are successfully added in meta. Subsequent active master " + "initialization should be uninterrupted");
    }
    if (maintenanceMode) {
        LOG.info("Detected repair mode, skipping final initialization steps.");
        return;
    }
    assignmentManager.checkIfShouldMoveSystemRegionAsync();
    status.setStatus("Starting quota manager");
    initQuotaManager();
    if (QuotaUtil.isQuotaEnabled(conf)) {
        // Create the quota snapshot notifier
        spaceQuotaSnapshotNotifier = createQuotaSnapshotNotifier();
        spaceQuotaSnapshotNotifier.initialize(getConnection());
        this.quotaObserverChore = new QuotaObserverChore(this, getMasterMetrics());
        // Start the chore to read the region FS space reports and act on them
        getChoreService().scheduleChore(quotaObserverChore);
        this.snapshotQuotaChore = new SnapshotQuotaObserverChore(this, getMasterMetrics());
        // Start the chore to read snapshots and add their usage to table/NS quotas
        getChoreService().scheduleChore(snapshotQuotaChore);
    }
    final SlowLogMasterService slowLogMasterService = new SlowLogMasterService(conf, this);
    slowLogMasterService.init();
    // clear the dead servers with same host name and port of online server because we are not
    // removing dead server with same hostname and port of rs which is trying to check in before
    // master initialization. See HBASE-5916.
    this.serverManager.clearDeadServersWithSameHostNameAndPortOfOnlineServer();
    // Check and set the znode ACLs if needed in case we are overtaking a non-secure configuration
    status.setStatus("Checking ZNode ACLs");
    zooKeeper.checkAndSetZNodeAcls();
    status.setStatus("Initializing MOB Cleaner");
    initMobCleaner();
    status.setStatus("Calling postStartMaster coprocessors");
    if (this.cpHost != null) {
        // don't let cp initialization errors kill the master
        try {
            this.cpHost.postStartMaster();
        } catch (IOException ioe) {
            LOG.error("Coprocessor postStartMaster() hook failed", ioe);
        }
    }
    zombieDetector.interrupt();
    /*
     * After master has started up, lets do balancer post startup initialization. Since this runs
     * in activeMasterManager thread, it should be fine.
     */
    long start = EnvironmentEdgeManager.currentTime();
    this.balancer.postMasterStartupInitialize();
    if (LOG.isDebugEnabled()) {
        LOG.debug("Balancer post startup initialization complete, took " + ((EnvironmentEdgeManager.currentTime() - start) / 1000) + " seconds");
    }
    this.rollingUpgradeChore = new RollingUpgradeChore(this);
    getChoreService().scheduleChore(rollingUpgradeChore);
}

Example 3 with TransitRegionStateProcedure

use of org.apache.hadoop.hbase.master.assignment.TransitRegionStateProcedure in project hbase by apache.

the class ReopenTableRegionsProcedure method executeFromState.

@Override
protected Flow executeFromState(MasterProcedureEnv env, ReopenTableRegionsState state) throws ProcedureSuspendedException, ProcedureYieldException, InterruptedException {
    switch(state) {
        case REOPEN_TABLE_REGIONS_GET_REGIONS:
            if (!isTableEnabled(env)) {
                LOG.info("Table {} is disabled, give up reopening its regions", tableName);
                return Flow.NO_MORE_STATE;
            }
            List<HRegionLocation> tableRegions = env.getAssignmentManager().getRegionStates().getRegionsOfTableForReopen(tableName);
            regions = getRegionLocationsForReopen(tableRegions);
            setNextState(ReopenTableRegionsState.REOPEN_TABLE_REGIONS_REOPEN_REGIONS);
            return Flow.HAS_MORE_STATE;
        case REOPEN_TABLE_REGIONS_REOPEN_REGIONS:
            for (HRegionLocation loc : regions) {
                RegionStateNode regionNode = env.getAssignmentManager().getRegionStates().getRegionStateNode(loc.getRegion());
                // this possible, maybe the region has already been merged or split, see HBASE-20921
                if (regionNode == null) {
                    continue;
                }
                TransitRegionStateProcedure proc;
                regionNode.lock();
                try {
                    if (regionNode.getProcedure() != null) {
                        continue;
                    }
                    proc = TransitRegionStateProcedure.reopen(env, regionNode.getRegionInfo());
                    regionNode.setProcedure(proc);
                } finally {
                    regionNode.unlock();
                }
                addChildProcedure(proc);
            }
            setNextState(ReopenTableRegionsState.REOPEN_TABLE_REGIONS_CONFIRM_REOPENED);
            return Flow.HAS_MORE_STATE;
        case REOPEN_TABLE_REGIONS_CONFIRM_REOPENED:
            regions = regions.stream().map(env.getAssignmentManager().getRegionStates()::checkReopened).filter(l -> l != null).collect(Collectors.toList());
            if (regions.isEmpty()) {
                return Flow.NO_MORE_STATE;
            }
            if (regions.stream().anyMatch(loc -> canSchedule(env, loc))) {
                retryCounter = null;
                setNextState(ReopenTableRegionsState.REOPEN_TABLE_REGIONS_REOPEN_REGIONS);
                return Flow.HAS_MORE_STATE;
            }
            // again.
            if (retryCounter == null) {
                retryCounter = ProcedureUtil.createRetryCounter(env.getMasterConfiguration());
            }
            long backoff = retryCounter.getBackoffTimeAndIncrementAttempts();
            LOG.info("There are still {} region(s) which need to be reopened for table {} are in " + "OPENING state, suspend {}secs and try again later", regions.size(), tableName, backoff / 1000);
            setTimeout(Math.toIntExact(backoff));
            setState(ProcedureProtos.ProcedureState.WAITING_TIMEOUT);
            skipPersistence();
            throw new ProcedureSuspendedException();
        default:
            throw new UnsupportedOperationException("unhandled state=" + state);
    }
}

Example 4 with TransitRegionStateProcedure

use of org.apache.hadoop.hbase.master.assignment.TransitRegionStateProcedure in project hbase by apache.

the class ServerCrashProcedure method assignRegions.

/**
 * Assign the regions on the crashed RS to other Rses.
 * <p/>
 * In this method we will go through all the RegionStateNodes of the give regions to find out
 * whether there is already an TRSP for the region, if so we interrupt it and let it retry on
 * other server, otherwise we will schedule a TRSP to bring the region online.
 * <p/>
 * We will also check whether the table for a region is enabled, if not, we will skip assigning
 * it.
 */
private void assignRegions(MasterProcedureEnv env, List<RegionInfo> regions) throws IOException {
    AssignmentManager am = env.getMasterServices().getAssignmentManager();
    boolean retainAssignment = env.getMasterConfiguration().getBoolean(MASTER_SCP_RETAIN_ASSIGNMENT, DEFAULT_MASTER_SCP_RETAIN_ASSIGNMENT);
    for (RegionInfo region : regions) {
        RegionStateNode regionNode = am.getRegionStates().getOrCreateRegionStateNode(region);
        regionNode.lock();
        try {
            // in the way of our clearing out 'Unknown Servers'.
            if (!isMatchingRegionLocation(regionNode)) {
                // double checking here to confirm that we do not skip assignment incorrectly.
                if (!am.isRunning()) {
                    throw new DoNotRetryIOException("AssignmentManager has been stopped, can not process assignment any more");
                }
                LOG.info("{} found {} whose regionLocation no longer matches {}, skipping assign...", this, regionNode, serverName);
                continue;
            }
            if (regionNode.getProcedure() != null) {
                LOG.info("{} found RIT {}; {}", this, regionNode.getProcedure(), regionNode);
                regionNode.getProcedure().serverCrashed(env, regionNode, getServerName(), !retainAssignment);
                continue;
            }
            if (env.getMasterServices().getTableStateManager().isTableState(regionNode.getTable(), TableState.State.DISABLING)) {
                // We need to change the state here otherwise the TRSP scheduled by DTP will try to
                // close the region from a dead server and will never succeed. Please see HBASE-23636
                // for more details.
                env.getAssignmentManager().regionClosedAbnormally(regionNode);
                LOG.info("{} found table disabling for region {}, set it state to ABNORMALLY_CLOSED.", this, regionNode);
                continue;
            }
            if (env.getMasterServices().getTableStateManager().isTableState(regionNode.getTable(), TableState.State.DISABLED)) {
                // This should not happen, table disabled but has regions on server.
                LOG.warn("Found table disabled for region {}, procDetails: {}", regionNode, this);
                continue;
            }
            TransitRegionStateProcedure proc = TransitRegionStateProcedure.assign(env, region, !retainAssignment, null);
            regionNode.setProcedure(proc);
            addChildProcedure(proc);
        } finally {
            regionNode.unlock();
        }
    }
}

Example 5 with TransitRegionStateProcedure

use of org.apache.hadoop.hbase.master.assignment.TransitRegionStateProcedure in project hbase by apache.

the class TestMergeTableRegionsWhileRSCrash method test.

@Test
public void test() throws Exception {
    // write some rows to the table
    for (int i = 0; i < 10; i++) {
        byte[] row = Bytes.toBytes("row" + i);
        Put put = new Put(row);
        put.addColumn(CF, CF, CF);
        TABLE.put(put);
    }
    MasterProcedureEnv env = UTIL.getMiniHBaseCluster().getMaster().getMasterProcedureExecutor().getEnvironment();
    final ProcedureExecutor<MasterProcedureEnv> executor = UTIL.getMiniHBaseCluster().getMaster().getMasterProcedureExecutor();
    List<RegionInfo> regionInfos = admin.getRegions(TABLE_NAME);
    MergeTableRegionsProcedure mergeTableRegionsProcedure = new MergeTableRegionsProcedure(env, new RegionInfo[] { regionInfos.get(0), regionInfos.get(1) }, false);
    executor.submitProcedure(mergeTableRegionsProcedure);
    UTIL.waitFor(30000, () -> executor.getProcedures().stream().filter(p -> p instanceof TransitRegionStateProcedure).map(p -> (TransitRegionStateProcedure) p).anyMatch(p -> TABLE_NAME.equals(p.getTableName())));
    UTIL.getMiniHBaseCluster().killRegionServer(UTIL.getMiniHBaseCluster().getRegionServer(0).getServerName());
    UTIL.getMiniHBaseCluster().startRegionServer();
    UTIL.waitUntilNoRegionsInTransition();
    Scan scan = new Scan();
    ResultScanner results = TABLE.getScanner(scan);
    int count = 0;
    Result result = null;
    while ((result = results.next()) != null) {
        count++;
    }
    Assert.assertEquals("There should be 10 rows!", 10, count);
}