@Override public Object call() { RegionInfo hri = createRegionInfo(TABLE_NAME, regionId); return stateMap.getOrCreateRegionStateNode(hri); } });
/** * Create one TransitRegionStateProcedure to assign a region w/o specifying a target server. * This method is specified for HBCK2 */ public TransitRegionStateProcedure createOneAssignProcedure(RegionInfo hri, boolean override) { RegionStateNode regionNode = regionStates.getOrCreateRegionStateNode(hri); return createAssignProcedure(regionNode, null, override); }
/** * Create one TransitRegionStateProcedure to unassign a region. * This method is specified for HBCK2 */ public TransitRegionStateProcedure createOneUnassignProcedure(RegionInfo hri, boolean override) { RegionStateNode regionNode = regionStates.getOrCreateRegionStateNode(hri); return createUnassignProcedure(regionNode, override); }
/** * @param assignments Map of assignments from which we produce an array of AssignProcedures. * @return Assignments made from the passed in <code>assignments</code> */ private TransitRegionStateProcedure[] createAssignProcedures( Map<ServerName, List<RegionInfo>> assignments) { return assignments.entrySet().stream() .flatMap(e -> e.getValue().stream().map(hri -> regionStates.getOrCreateRegionStateNode(hri)) .map(regionNode -> createAssignProcedure(regionNode, e.getKey(), false))) .sorted(AssignmentManager::compare).toArray(TransitRegionStateProcedure[]::new); }
/** * Create an array of TransitRegionStateProcedure w/o specifying a target server. * <p/> * If no target server, at assign time, we will try to use the former location of the region if * one exists. This is how we 'retain' the old location across a server restart. * <p/> * Should only be called when you can make sure that no one can touch these regions other than * you. For example, when you are creating table. */ public TransitRegionStateProcedure[] createAssignProcedures(List<RegionInfo> hris) { return hris.stream().map(hri -> regionStates.getOrCreateRegionStateNode(hri)) .map(regionNode -> createAssignProcedure(regionNode, null, false)) .sorted(AssignmentManager::compare).toArray(TransitRegionStateProcedure[]::new); }
public void updateRegionState(RegionInfo regionInfo, State state) { RegionStateNode regionNode = getOrCreateRegionStateNode(regionInfo); regionNode.lock(); try { regionNode.setState(state); } finally { regionNode.unlock(); } }
private Object createRegionNode(final RegionStates stateMap, final TableName tableName, final long regionId) { return stateMap.getOrCreateRegionStateNode(createRegionInfo(tableName, regionId)); }
public RegionStateNode getRegionState(final MasterProcedureEnv env) { return env.getAssignmentManager().getRegionStates().getOrCreateRegionStateNode(getRegionInfo()); }
private RegionStateNode getRegionStateNode(MasterProcedureEnv env) { return env.getAssignmentManager().getRegionStates().getOrCreateRegionStateNode(getRegion()); }
public void markRegionAsSplit(final RegionInfo parent, final ServerName serverName, final RegionInfo daughterA, final RegionInfo daughterB) throws IOException { // Update hbase:meta. Parent will be marked offline and split up in hbase:meta. // The parent stays in regionStates until cleared when removed by CatalogJanitor. // Update its state in regionStates to it shows as offline and split when read // later figuring what regions are in a table and what are not: see // regionStates#getRegionsOfTable final RegionStateNode node = regionStates.getOrCreateRegionStateNode(parent); node.setState(State.SPLIT); final RegionStateNode nodeA = regionStates.getOrCreateRegionStateNode(daughterA); nodeA.setState(State.SPLITTING_NEW); final RegionStateNode nodeB = regionStates.getOrCreateRegionStateNode(daughterB); nodeB.setState(State.SPLITTING_NEW); regionStateStore.splitRegion(parent, daughterA, daughterB, serverName); if (shouldAssignFavoredNodes(parent)) { List<ServerName> onlineServers = this.master.getServerManager().getOnlineServersList(); ((FavoredNodesPromoter)getBalancer()). generateFavoredNodesForDaughter(onlineServers, parent, daughterA, daughterB); } }
@SuppressWarnings("rawtypes") @Override protected Procedure[] execute(MasterProcedureEnv env) throws ProcedureSuspendedException, ProcedureYieldException, InterruptedException { RegionStateNode regionNode = env.getAssignmentManager().getRegionStates().getOrCreateRegionStateNode(getRegion()); regionNode.lock(); try { return super.execute(env); } finally { regionNode.unlock(); } }
@Override public Object call() { return stateMap.getOrCreateRegionStateNode(RegionInfoBuilder.newBuilder(tableName) .setStartKey(Bytes.toBytes(regionId)) .setEndKey(Bytes.toBytes(regionId + 1)) .setSplit(false) .setRegionId(0) .build()); } });
public void start() throws IOException, KeeperException { if (!running.compareAndSet(false, true)) { return; } LOG.trace("Starting assignment manager"); // Start the Assignment Thread startAssignmentThread(); // load meta region state ZKWatcher zkw = master.getZooKeeper(); // it could be null in some tests if (zkw != null) { RegionState regionState = MetaTableLocator.getMetaRegionState(zkw); RegionStateNode regionNode = regionStates.getOrCreateRegionStateNode(RegionInfoBuilder.FIRST_META_REGIONINFO); regionNode.lock(); try { regionNode.setRegionLocation(regionState.getServerName()); regionNode.setState(regionState.getState()); setMetaAssigned(regionState.getRegion(), regionState.getState() == State.OPEN); } finally { regionNode.unlock(); } } }
private void init(MasterProcedureEnv env){ RegionStateNode regionNode = env.getAssignmentManager().getRegionStates().getOrCreateRegionStateNode(getRegion()); regionNode.setProcedure(this); }
@Override protected RegionOpeningState execOpenRegion(ServerName server, RegionOpenInfo openReq) throws IOException { RegionInfo hri = ProtobufUtil.toRegionInfo(openReq.getRegion()); long previousOpenSeqNum = am.getRegionStates().getOrCreateRegionStateNode(hri).getOpenSeqNum(); sendTransitionReport(server, openReq.getRegion(), TransitionCode.OPENED, previousOpenSeqNum + 2); // Concurrency? // Now update the state of our cluster in regionsToRegionServers. SortedSet<byte[]> regions = regionsToRegionServers.get(server); if (regions == null) { regions = new ConcurrentSkipListSet<byte[]>(Bytes.BYTES_COMPARATOR); regionsToRegionServers.put(server, regions); } if (regions.contains(hri.getRegionName())) { throw new UnsupportedOperationException(hri.getRegionNameAsString()); } regions.add(hri.getRegionName()); return RegionOpeningState.OPENED; }
/** * When called here, the merge has happened. The two merged regions have been * unassigned and the above markRegionClosed has been called on each so they have been * disassociated from a hosting Server. The merged region will be open after this call. The * merged regions are removed from hbase:meta below> Later they are deleted from the filesystem * by the catalog janitor running against hbase:meta. It notices when the merged region no * longer holds references to the old regions. */ public void markRegionAsMerged(final RegionInfo child, final ServerName serverName, final RegionInfo mother, final RegionInfo father) throws IOException { final RegionStateNode node = regionStates.getOrCreateRegionStateNode(child); node.setState(State.MERGED); regionStates.deleteRegion(mother); regionStates.deleteRegion(father); regionStateStore.mergeRegions(child, mother, father, serverName); if (shouldAssignFavoredNodes(child)) { ((FavoredNodesPromoter)getBalancer()). generateFavoredNodesForMergedRegion(child, mother, father); } }
public long assign(RegionInfo regionInfo, ServerName sn) throws IOException { // TODO: should we use getRegionStateNode? RegionStateNode regionNode = regionStates.getOrCreateRegionStateNode(regionInfo); TransitRegionStateProcedure proc; regionNode.lock(); try { preTransitCheck(regionNode, STATES_EXPECTED_ON_ASSIGN); proc = TransitRegionStateProcedure.assign(getProcedureEnvironment(), regionInfo, sn); regionNode.setProcedure(proc); } finally { regionNode.unlock(); } ProcedureSyncWait.submitAndWaitProcedure(master.getMasterProcedureExecutor(), proc); return proc.getProcId(); }
AssignmentManager am = env.getMasterServices().getAssignmentManager(); for (RegionInfo region : regions) { RegionStateNode regionNode = am.getRegionStates().getOrCreateRegionStateNode(region); regionNode.lock(); try {
/** * Create a merged region * @param env MasterProcedureEnv */ private void createMergedRegion(final MasterProcedureEnv env) throws IOException { final MasterFileSystem mfs = env.getMasterServices().getMasterFileSystem(); final Path tabledir = FSUtils.getTableDir(mfs.getRootDir(), regionsToMerge[0].getTable()); final FileSystem fs = mfs.getFileSystem(); HRegionFileSystem regionFs = HRegionFileSystem.openRegionFromFileSystem( env.getMasterConfiguration(), fs, tabledir, regionsToMerge[0], false); regionFs.createMergesDir(); mergeStoreFiles(env, regionFs, regionFs.getMergesDir()); HRegionFileSystem regionFs2 = HRegionFileSystem.openRegionFromFileSystem( env.getMasterConfiguration(), fs, tabledir, regionsToMerge[1], false); mergeStoreFiles(env, regionFs2, regionFs.getMergesDir()); regionFs.commitMergedRegion(mergedRegion); //Prepare to create merged regions env.getAssignmentManager().getRegionStates(). getOrCreateRegionStateNode(mergedRegion).setState(State.MERGING_NEW); }
@Test public void test() throws Exception { JVMClusterUtil.RegionServerThread rsThread = null; for (JVMClusterUtil.RegionServerThread t : UTIL.getMiniHBaseCluster() .getRegionServerThreads()) { if (!t.getRegionServer().getRegions(TABLE_NAME).isEmpty()) { rsThread = t; break; } } // find the rs and hri of the table HRegionServer rs = rsThread.getRegionServer(); RegionInfo hri = rs.getRegions(TABLE_NAME).get(0).getRegionInfo(); TransitRegionStateProcedure moveRegionProcedure = TransitRegionStateProcedure.reopen( UTIL.getMiniHBaseCluster().getMaster().getMasterProcedureExecutor().getEnvironment(), hri); RegionStateNode regionNode = UTIL.getMiniHBaseCluster().getMaster().getAssignmentManager() .getRegionStates().getOrCreateRegionStateNode(hri); regionNode.setProcedure(moveRegionProcedure); UTIL.getMiniHBaseCluster().getMaster().getMasterProcedureExecutor() .submitProcedure(moveRegionProcedure); countDownLatch.await(); UTIL.getMiniHBaseCluster().stopMaster(0); UTIL.getMiniHBaseCluster().startMaster(); // wait until master initialized UTIL.waitFor(30000, () -> UTIL.getMiniHBaseCluster().getMaster() != null && UTIL.getMiniHBaseCluster().getMaster().isInitialized()); Assert.assertTrue("Should be 3 RS after master restart", UTIL.getMiniHBaseCluster().getLiveRegionServerThreads().size() == 3); }