Return-Path: X-Original-To: archive-asf-public-internal@cust-asf2.ponee.io Delivered-To: archive-asf-public-internal@cust-asf2.ponee.io Received: from cust-asf.ponee.io (cust-asf.ponee.io [163.172.22.183]) by cust-asf2.ponee.io (Postfix) with ESMTP id 32014200D3B for ; Fri, 10 Nov 2017 16:29:57 +0100 (CET) Received: by cust-asf.ponee.io (Postfix) id 307DD160C06; Fri, 10 Nov 2017 15:29:57 +0000 (UTC) Delivered-To: archive-asf-public@cust-asf.ponee.io Received: from mail.apache.org (hermes.apache.org [140.211.11.3]) by cust-asf.ponee.io (Postfix) with SMTP id 31357160C05 for ; Fri, 10 Nov 2017 16:29:55 +0100 (CET) Received: (qmail 43030 invoked by uid 500); 10 Nov 2017 15:29:51 -0000 Mailing-List: contact commits-help@hbase.apache.org; run by ezmlm Precedence: bulk List-Help: List-Unsubscribe: List-Post: List-Id: Reply-To: dev@hbase.apache.org Delivered-To: mailing list commits@hbase.apache.org Received: (qmail 41203 invoked by uid 99); 10 Nov 2017 15:29:49 -0000 Received: from git1-us-west.apache.org (HELO git1-us-west.apache.org) (140.211.11.23) by apache.org (qpsmtpd/0.29) with ESMTP; Fri, 10 Nov 2017 15:29:49 +0000 Received: by git1-us-west.apache.org (ASF Mail Server at git1-us-west.apache.org, from userid 33) id A657FF5DAC; Fri, 10 Nov 2017 15:29:48 +0000 (UTC) Content-Type: text/plain; charset="us-ascii" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit From: git-site-role@apache.org To: commits@hbase.apache.org Date: Fri, 10 Nov 2017 15:30:10 -0000 Message-Id: <998d828d021248b29f35fea004f695d2@git.apache.org> In-Reply-To: <6d878f2976364f088768a3569569c0a0@git.apache.org> References: <6d878f2976364f088768a3569569c0a0@git.apache.org> X-Mailer: ASF-Git Admin Mailer Subject: [23/51] [partial] hbase-site git commit: Published site at . archived-at: Fri, 10 Nov 2017 15:29:57 -0000 http://git-wip-us.apache.org/repos/asf/hbase-site/blob/a108018f/devapidocs/src-html/org/apache/hadoop/hbase/master/assignment/RegionStates.RegionFailedOpen.html ---------------------------------------------------------------------- diff --git a/devapidocs/src-html/org/apache/hadoop/hbase/master/assignment/RegionStates.RegionFailedOpen.html b/devapidocs/src-html/org/apache/hadoop/hbase/master/assignment/RegionStates.RegionFailedOpen.html index 8e0a6a2..08916af 100644 --- a/devapidocs/src-html/org/apache/hadoop/hbase/master/assignment/RegionStates.RegionFailedOpen.html +++ b/devapidocs/src-html/org/apache/hadoop/hbase/master/assignment/RegionStates.RegionFailedOpen.html @@ -75,7 +75,7 @@ 067 }; 068 069 protected static final State[] STATES_EXPECTED_ON_CLOSE = new State[] { -070 State.SPLITTING, State.SPLIT, // ServerCrashProcedure +070 State.SPLITTING, State.SPLIT, State.MERGING, // ServerCrashProcedure 071 State.OPEN, // enabled/open 072 State.CLOSING // already in-progress (retrying) 073 }; @@ -550,446 +550,454 @@ 542 return !getTableRegionStates(tableName).isEmpty(); 543 } 544 -545 public List<RegionInfo> getRegionsOfTable(final TableName table) { -546 return getRegionsOfTable(table, false); -547 } -548 -549 List<RegionInfo> getRegionsOfTable(final TableName table, final boolean offline) { -550 final ArrayList<RegionStateNode> nodes = getTableRegionStateNodes(table); -551 final ArrayList<RegionInfo> hris = new ArrayList<RegionInfo>(nodes.size()); -552 for (RegionStateNode node: nodes) { -553 if (include(node, offline)) hris.add(node.getRegionInfo()); -554 } -555 return hris; -556 } -557 -558 /** -559 * Utility. Whether to include region in list of regions. Default is to -560 * weed out split and offline regions. -561 * @return True if we should include the <code>node</code> (do not include -562 * if split or offline unless <code>offline</code> is set to true. -563 */ -564 boolean include(final RegionStateNode node, final boolean offline) { -565 if (LOG.isTraceEnabled()) { -566 LOG.trace("WORKING ON " + node + " " + node.getRegionInfo()); -567 } -568 if (node.isInState(State.SPLIT)) return false; -569 if (node.isInState(State.OFFLINE) && !offline) return false; -570 final RegionInfo hri = node.getRegionInfo(); -571 return (!hri.isOffline() && !hri.isSplit()) || -572 ((hri.isOffline() || hri.isSplit()) && offline); -573 } -574 -575 /** -576 * Returns the set of regions hosted by the specified server -577 * @param serverName the server we are interested in -578 * @return set of RegionInfo hosted by the specified server -579 */ -580 public List<RegionInfo> getServerRegionInfoSet(final ServerName serverName) { -581 final ServerStateNode serverInfo = getServerNode(serverName); -582 if (serverInfo == null) return Collections.emptyList(); -583 -584 synchronized (serverInfo) { -585 return serverInfo.getRegionInfoList(); -586 } -587 } -588 -589 // ============================================================================================ -590 // TODO: split helpers -591 // ============================================================================================ -592 public void logSplit(final ServerName serverName) { -593 final ServerStateNode serverNode = getOrCreateServer(serverName); -594 synchronized (serverNode) { -595 serverNode.setState(ServerState.SPLITTING); -596 /* THIS HAS TO BE WRONG. THIS IS SPLITTING OF REGION, NOT SPLITTING WALs. -597 for (RegionStateNode regionNode: serverNode.getRegions()) { -598 synchronized (regionNode) { -599 // TODO: Abort procedure if present -600 regionNode.setState(State.SPLITTING); -601 } -602 }*/ -603 } -604 } -605 -606 public void logSplit(final RegionInfo regionInfo) { -607 final RegionStateNode regionNode = getRegionNode(regionInfo); -608 synchronized (regionNode) { -609 regionNode.setState(State.SPLIT); -610 } -611 } -612 -613 @VisibleForTesting -614 public void updateRegionState(final RegionInfo regionInfo, final State state) { -615 final RegionStateNode regionNode = getOrCreateRegionNode(regionInfo); +545 /** +546 * @return Return online regions of table; does not include OFFLINE or SPLITTING regions. +547 */ +548 public List<RegionInfo> getRegionsOfTable(final TableName table) { +549 return getRegionsOfTable(table, false); +550 } +551 +552 /** +553 * @return Return the regions of the table; does not include OFFLINE unless you set +554 * <code>offline</code> to true. Does not include regions that are in the +555 * {@link State#SPLIT} state. +556 */ +557 public List<RegionInfo> getRegionsOfTable(final TableName table, final boolean offline) { +558 final ArrayList<RegionStateNode> nodes = getTableRegionStateNodes(table); +559 final ArrayList<RegionInfo> hris = new ArrayList<RegionInfo>(nodes.size()); +560 for (RegionStateNode node: nodes) { +561 if (include(node, offline)) hris.add(node.getRegionInfo()); +562 } +563 return hris; +564 } +565 +566 /** +567 * Utility. Whether to include region in list of regions. Default is to +568 * weed out split and offline regions. +569 * @return True if we should include the <code>node</code> (do not include +570 * if split or offline unless <code>offline</code> is set to true. +571 */ +572 boolean include(final RegionStateNode node, final boolean offline) { +573 if (LOG.isTraceEnabled()) { +574 LOG.trace("WORKING ON " + node + " " + node.getRegionInfo()); +575 } +576 if (node.isInState(State.SPLIT)) return false; +577 if (node.isInState(State.OFFLINE) && !offline) return false; +578 final RegionInfo hri = node.getRegionInfo(); +579 return (!hri.isOffline() && !hri.isSplit()) || +580 ((hri.isOffline() || hri.isSplit()) && offline); +581 } +582 +583 /** +584 * Returns the set of regions hosted by the specified server +585 * @param serverName the server we are interested in +586 * @return set of RegionInfo hosted by the specified server +587 */ +588 public List<RegionInfo> getServerRegionInfoSet(final ServerName serverName) { +589 final ServerStateNode serverInfo = getServerNode(serverName); +590 if (serverInfo == null) return Collections.emptyList(); +591 +592 synchronized (serverInfo) { +593 return serverInfo.getRegionInfoList(); +594 } +595 } +596 +597 // ============================================================================================ +598 // TODO: split helpers +599 // ============================================================================================ +600 public void logSplit(final ServerName serverName) { +601 final ServerStateNode serverNode = getOrCreateServer(serverName); +602 synchronized (serverNode) { +603 serverNode.setState(ServerState.SPLITTING); +604 /* THIS HAS TO BE WRONG. THIS IS SPLITTING OF REGION, NOT SPLITTING WALs. +605 for (RegionStateNode regionNode: serverNode.getRegions()) { +606 synchronized (regionNode) { +607 // TODO: Abort procedure if present +608 regionNode.setState(State.SPLITTING); +609 } +610 }*/ +611 } +612 } +613 +614 public void logSplit(final RegionInfo regionInfo) { +615 final RegionStateNode regionNode = getRegionNode(regionInfo); 616 synchronized (regionNode) { -617 regionNode.setState(state); +617 regionNode.setState(State.SPLIT); 618 } 619 } 620 -621 // ============================================================================================ -622 // TODO: -623 // ============================================================================================ -624 public List<RegionInfo> getAssignedRegions() { -625 final List<RegionInfo> result = new ArrayList<RegionInfo>(); -626 for (RegionStateNode node: regionsMap.values()) { -627 if (!node.isInTransition()) { -628 result.add(node.getRegionInfo()); -629 } -630 } -631 return result; -632 } -633 -634 public boolean isRegionInState(final RegionInfo regionInfo, final State... state) { -635 final RegionStateNode region = getRegionNode(regionInfo); -636 if (region != null) { -637 synchronized (region) { -638 return region.isInState(state); -639 } -640 } -641 return false; -642 } -643 -644 public boolean isRegionOnline(final RegionInfo regionInfo) { -645 return isRegionInState(regionInfo, State.OPEN); -646 } -647 -648 /** -649 * @return True if region is offline (In OFFLINE or CLOSED state). -650 */ -651 public boolean isRegionOffline(final RegionInfo regionInfo) { -652 return isRegionInState(regionInfo, State.OFFLINE, State.CLOSED); -653 } -654 -655 public Map<ServerName, List<RegionInfo>> getSnapShotOfAssignment( -656 final Collection<RegionInfo> regions) { -657 final Map<ServerName, List<RegionInfo>> result = new HashMap<ServerName, List<RegionInfo>>(); -658 for (RegionInfo hri: regions) { -659 final RegionStateNode node = getRegionNode(hri); -660 if (node == null) continue; -661 -662 // TODO: State.OPEN -663 final ServerName serverName = node.getRegionLocation(); -664 if (serverName == null) continue; -665 -666 List<RegionInfo> serverRegions = result.get(serverName); -667 if (serverRegions == null) { -668 serverRegions = new ArrayList<RegionInfo>(); -669 result.put(serverName, serverRegions); -670 } -671 -672 serverRegions.add(node.getRegionInfo()); -673 } -674 return result; -675 } -676 -677 public Map<RegionInfo, ServerName> getRegionAssignments() { -678 final HashMap<RegionInfo, ServerName> assignments = new HashMap<RegionInfo, ServerName>(); -679 for (RegionStateNode node: regionsMap.values()) { -680 assignments.put(node.getRegionInfo(), node.getRegionLocation()); +621 @VisibleForTesting +622 public void updateRegionState(final RegionInfo regionInfo, final State state) { +623 final RegionStateNode regionNode = getOrCreateRegionNode(regionInfo); +624 synchronized (regionNode) { +625 regionNode.setState(state); +626 } +627 } +628 +629 // ============================================================================================ +630 // TODO: +631 // ============================================================================================ +632 public List<RegionInfo> getAssignedRegions() { +633 final List<RegionInfo> result = new ArrayList<RegionInfo>(); +634 for (RegionStateNode node: regionsMap.values()) { +635 if (!node.isInTransition()) { +636 result.add(node.getRegionInfo()); +637 } +638 } +639 return result; +640 } +641 +642 public boolean isRegionInState(final RegionInfo regionInfo, final State... state) { +643 final RegionStateNode region = getRegionNode(regionInfo); +644 if (region != null) { +645 synchronized (region) { +646 return region.isInState(state); +647 } +648 } +649 return false; +650 } +651 +652 public boolean isRegionOnline(final RegionInfo regionInfo) { +653 return isRegionInState(regionInfo, State.OPEN); +654 } +655 +656 /** +657 * @return True if region is offline (In OFFLINE or CLOSED state). +658 */ +659 public boolean isRegionOffline(final RegionInfo regionInfo) { +660 return isRegionInState(regionInfo, State.OFFLINE, State.CLOSED); +661 } +662 +663 public Map<ServerName, List<RegionInfo>> getSnapShotOfAssignment( +664 final Collection<RegionInfo> regions) { +665 final Map<ServerName, List<RegionInfo>> result = new HashMap<ServerName, List<RegionInfo>>(); +666 for (RegionInfo hri: regions) { +667 final RegionStateNode node = getRegionNode(hri); +668 if (node == null) continue; +669 +670 // TODO: State.OPEN +671 final ServerName serverName = node.getRegionLocation(); +672 if (serverName == null) continue; +673 +674 List<RegionInfo> serverRegions = result.get(serverName); +675 if (serverRegions == null) { +676 serverRegions = new ArrayList<RegionInfo>(); +677 result.put(serverName, serverRegions); +678 } +679 +680 serverRegions.add(node.getRegionInfo()); 681 } -682 return assignments; +682 return result; 683 } 684 -685 public Map<RegionState.State, List<RegionInfo>> getRegionByStateOfTable(TableName tableName) { -686 final State[] states = State.values(); -687 final Map<RegionState.State, List<RegionInfo>> tableRegions = -688 new HashMap<State, List<RegionInfo>>(states.length); -689 for (int i = 0; i < states.length; ++i) { -690 tableRegions.put(states[i], new ArrayList<RegionInfo>()); -691 } +685 public Map<RegionInfo, ServerName> getRegionAssignments() { +686 final HashMap<RegionInfo, ServerName> assignments = new HashMap<RegionInfo, ServerName>(); +687 for (RegionStateNode node: regionsMap.values()) { +688 assignments.put(node.getRegionInfo(), node.getRegionLocation()); +689 } +690 return assignments; +691 } 692 -693 for (RegionStateNode node: regionsMap.values()) { -694 if (node.getTable().equals(tableName)) { -695 tableRegions.get(node.getState()).add(node.getRegionInfo()); -696 } -697 } -698 return tableRegions; -699 } +693 public Map<RegionState.State, List<RegionInfo>> getRegionByStateOfTable(TableName tableName) { +694 final State[] states = State.values(); +695 final Map<RegionState.State, List<RegionInfo>> tableRegions = +696 new HashMap<State, List<RegionInfo>>(states.length); +697 for (int i = 0; i < states.length; ++i) { +698 tableRegions.put(states[i], new ArrayList<RegionInfo>()); +699 } 700 -701 public ServerName getRegionServerOfRegion(final RegionInfo regionInfo) { -702 final RegionStateNode region = getRegionNode(regionInfo); -703 if (region != null) { -704 synchronized (region) { -705 ServerName server = region.getRegionLocation(); -706 return server != null ? server : region.getLastHost(); -707 } -708 } -709 return null; -710 } -711 -712 /** -713 * This is an EXPENSIVE clone. Cloning though is the safest thing to do. -714 * Can't let out original since it can change and at least the load balancer -715 * wants to iterate this exported list. We need to synchronize on regions -716 * since all access to this.servers is under a lock on this.regions. -717 * @param forceByCluster a flag to force to aggregate the server-load to the cluster level -718 * @return A clone of current assignments by table. -719 */ -720 public Map<TableName, Map<ServerName, List<RegionInfo>>> getAssignmentsByTable( -721 final boolean forceByCluster) { -722 if (!forceByCluster) return getAssignmentsByTable(); -723 -724 final HashMap<ServerName, List<RegionInfo>> ensemble = -725 new HashMap<ServerName, List<RegionInfo>>(serverMap.size()); -726 for (ServerStateNode serverNode: serverMap.values()) { -727 ensemble.put(serverNode.getServerName(), serverNode.getRegionInfoList()); -728 } -729 -730 // TODO: can we use Collections.singletonMap(HConstants.ENSEMBLE_TABLE_NAME, ensemble)? -731 final Map<TableName, Map<ServerName, List<RegionInfo>>> result = -732 new HashMap<TableName, Map<ServerName, List<RegionInfo>>>(1); -733 result.put(HConstants.ENSEMBLE_TABLE_NAME, ensemble); -734 return result; -735 } -736 -737 public Map<TableName, Map<ServerName, List<RegionInfo>>> getAssignmentsByTable() { -738 final Map<TableName, Map<ServerName, List<RegionInfo>>> result = new HashMap<>(); -739 for (RegionStateNode node: regionsMap.values()) { -740 Map<ServerName, List<RegionInfo>> tableResult = result.get(node.getTable()); -741 if (tableResult == null) { -742 tableResult = new HashMap<ServerName, List<RegionInfo>>(); -743 result.put(node.getTable(), tableResult); -744 } -745 -746 final ServerName serverName = node.getRegionLocation(); -747 if (serverName == null) { -748 LOG.info("Skipping, no server for " + node); -749 continue; -750 } -751 List<RegionInfo> serverResult = tableResult.get(serverName); -752 if (serverResult == null) { -753 serverResult = new ArrayList<RegionInfo>(); -754 tableResult.put(serverName, serverResult); -755 } -756 -757 serverResult.add(node.getRegionInfo()); -758 } -759 // Add online servers with no assignment for the table. -760 for (Map<ServerName, List<RegionInfo>> table: result.values()) { -761 for (ServerName svr : serverMap.keySet()) { -762 if (!table.containsKey(svr)) { -763 table.put(svr, new ArrayList<RegionInfo>()); -764 } -765 } +701 for (RegionStateNode node: regionsMap.values()) { +702 if (node.getTable().equals(tableName)) { +703 tableRegions.get(node.getState()).add(node.getRegionInfo()); +704 } +705 } +706 return tableRegions; +707 } +708 +709 public ServerName getRegionServerOfRegion(final RegionInfo regionInfo) { +710 final RegionStateNode region = getRegionNode(regionInfo); +711 if (region != null) { +712 synchronized (region) { +713 ServerName server = region.getRegionLocation(); +714 return server != null ? server : region.getLastHost(); +715 } +716 } +717 return null; +718 } +719 +720 /** +721 * This is an EXPENSIVE clone. Cloning though is the safest thing to do. +722 * Can't let out original since it can change and at least the load balancer +723 * wants to iterate this exported list. We need to synchronize on regions +724 * since all access to this.servers is under a lock on this.regions. +725 * @param forceByCluster a flag to force to aggregate the server-load to the cluster level +726 * @return A clone of current assignments by table. +727 */ +728 public Map<TableName, Map<ServerName, List<RegionInfo>>> getAssignmentsByTable( +729 final boolean forceByCluster) { +730 if (!forceByCluster) return getAssignmentsByTable(); +731 +732 final HashMap<ServerName, List<RegionInfo>> ensemble = +733 new HashMap<ServerName, List<RegionInfo>>(serverMap.size()); +734 for (ServerStateNode serverNode: serverMap.values()) { +735 ensemble.put(serverNode.getServerName(), serverNode.getRegionInfoList()); +736 } +737 +738 // TODO: can we use Collections.singletonMap(HConstants.ENSEMBLE_TABLE_NAME, ensemble)? +739 final Map<TableName, Map<ServerName, List<RegionInfo>>> result = +740 new HashMap<TableName, Map<ServerName, List<RegionInfo>>>(1); +741 result.put(HConstants.ENSEMBLE_TABLE_NAME, ensemble); +742 return result; +743 } +744 +745 public Map<TableName, Map<ServerName, List<RegionInfo>>> getAssignmentsByTable() { +746 final Map<TableName, Map<ServerName, List<RegionInfo>>> result = new HashMap<>(); +747 for (RegionStateNode node: regionsMap.values()) { +748 Map<ServerName, List<RegionInfo>> tableResult = result.get(node.getTable()); +749 if (tableResult == null) { +750 tableResult = new HashMap<ServerName, List<RegionInfo>>(); +751 result.put(node.getTable(), tableResult); +752 } +753 +754 final ServerName serverName = node.getRegionLocation(); +755 if (serverName == null) { +756 LOG.info("Skipping, no server for " + node); +757 continue; +758 } +759 List<RegionInfo> serverResult = tableResult.get(serverName); +760 if (serverResult == null) { +761 serverResult = new ArrayList<RegionInfo>(); +762 tableResult.put(serverName, serverResult); +763 } +764 +765 serverResult.add(node.getRegionInfo()); 766 } -767 return result; -768 } -769 -770 // ========================================================================== -771 // Region in transition helpers -772 // ========================================================================== -773 protected boolean addRegionInTransition(final RegionStateNode regionNode, -774 final RegionTransitionProcedure procedure) { -775 if (procedure != null && !regionNode.setProcedure(procedure)) return false; -776 -777 regionInTransition.put(regionNode.getRegionInfo(), regionNode); -778 return true; -779 } -780 -781 protected void removeRegionInTransition(final RegionStateNode regionNode, +767 // Add online servers with no assignment for the table. +768 for (Map<ServerName, List<RegionInfo>> table: result.values()) { +769 for (ServerName svr : serverMap.keySet()) { +770 if (!table.containsKey(svr)) { +771 table.put(svr, new ArrayList<RegionInfo>()); +772 } +773 } +774 } +775 return result; +776 } +777 +778 // ========================================================================== +779 // Region in transition helpers +780 // ========================================================================== +781 protected boolean addRegionInTransition(final RegionStateNode regionNode, 782 final RegionTransitionProcedure procedure) { -783 regionInTransition.remove(regionNode.getRegionInfo()); -784 regionNode.unsetProcedure(procedure); -785 } -786 -787 public boolean hasRegionsInTransition() { -788 return !regionInTransition.isEmpty(); -789 } -790 -791 public boolean isRegionInTransition(final RegionInfo regionInfo) { -792 final RegionStateNode node = regionInTransition.get(regionInfo); -793 return node != null ? node.isInTransition() : false; -794 } -795 -796 /** -797 * @return If a procedure-in-transition for <code>hri</code>, return it else null. -798 */ -799 public RegionTransitionProcedure getRegionTransitionProcedure(final RegionInfo hri) { -800 RegionStateNode node = regionInTransition.get(hri); -801 if (node == null) return null; -802 return node.getProcedure(); -803 } -804 -805 public RegionState getRegionTransitionState(final RegionInfo hri) { -806 RegionStateNode node = regionInTransition.get(hri); -807 if (node == null) return null; -808 -809 synchronized (node) { -810 return node.isInTransition() ? createRegionState(node) : null; -811 } -812 } -813 -814 public List<RegionStateNode> getRegionsInTransition() { -815 return new ArrayList<RegionStateNode>(regionInTransition.values()); -816 } -817 -818 /** -819 * Get the number of regions in transition. -820 */ -821 public int getRegionsInTransitionCount() { -822 return regionInTransition.size(); -823 } -824 -825 public List<RegionState> getRegionsStateInTransition() { -826 final List<RegionState> rit = new ArrayList<RegionState>(regionInTransition.size()); -827 for (RegionStateNode node: regionInTransition.values()) { -828 rit.add(createRegionState(node)); -829 } -830 return rit; +783 if (procedure != null && !regionNode.setProcedure(procedure)) return false; +784 +785 regionInTransition.put(regionNode.getRegionInfo(), regionNode); +786 return true; +787 } +788 +789 protected void removeRegionInTransition(final RegionStateNode regionNode, +790 final RegionTransitionProcedure procedure) { +791 regionInTransition.remove(regionNode.getRegionInfo()); +792 regionNode.unsetProcedure(procedure); +793 } +794 +795 public boolean hasRegionsInTransition() { +796 return !regionInTransition.isEmpty(); +797 } +798 +799 public boolean isRegionInTransition(final RegionInfo regionInfo) { +800 final RegionStateNode node = regionInTransition.get(regionInfo); +801 return node != null ? node.isInTransition() : false; +802 } +803 +804 /** +805 * @return If a procedure-in-transition for <code>hri</code>, return it else null. +806 */ +807 public RegionTransitionProcedure getRegionTransitionProcedure(final RegionInfo hri) { +808 RegionStateNode node = regionInTransition.get(hri); +809 if (node == null) return null; +810 return node.getProcedure(); +811 } +812 +813 public RegionState getRegionTransitionState(final RegionInfo hri) { +814 RegionStateNode node = regionInTransition.get(hri); +815 if (node == null) return null; +816 +817 synchronized (node) { +818 return node.isInTransition() ? createRegionState(node) : null; +819 } +820 } +821 +822 public List<RegionStateNode> getRegionsInTransition() { +823 return new ArrayList<RegionStateNode>(regionInTransition.values()); +824 } +825 +826 /** +827 * Get the number of regions in transition. +828 */ +829 public int getRegionsInTransitionCount() { +830 return regionInTransition.size(); 831 } 832 -833 public SortedSet<RegionState> getRegionsInTransitionOrderedByTimestamp() { -834 final SortedSet<RegionState> rit = new TreeSet<RegionState>(REGION_STATE_STAMP_COMPARATOR); +833 public List<RegionState> getRegionsStateInTransition() { +834 final List<RegionState> rit = new ArrayList<RegionState>(regionInTransition.size()); 835 for (RegionStateNode node: regionInTransition.values()) { 836 rit.add(createRegionState(node)); 837 } 838 return rit; 839 } 840 -841 // ========================================================================== -842 // Region offline helpers -843 // ========================================================================== -844 // TODO: Populated when we read meta but regions never make it out of here. -845 public void addToOfflineRegions(final RegionStateNode regionNode) { -846 LOG.info("Added to offline, CURRENTLY NEVER CLEARED!!! " + regionNode); -847 regionOffline.put(regionNode.getRegionInfo(), regionNode); -848 } -849 -850 // TODO: Unused. -851 public void removeFromOfflineRegions(final RegionInfo regionInfo) { -852 regionOffline.remove(regionInfo); -853 } -854 -855 // ========================================================================== -856 // Region FAIL_OPEN helpers -857 // ========================================================================== -858 public static final class RegionFailedOpen { -859 private final RegionStateNode regionNode; -860 -861 private volatile Exception exception = null; -862 private volatile int retries = 0; -863 -864 public RegionFailedOpen(final RegionStateNode regionNode) { -865 this.regionNode = regionNode; -866 } -867 -868 public RegionStateNode getRegionNode() { -869 return regionNode; -870 } +841 public SortedSet<RegionState> getRegionsInTransitionOrderedByTimestamp() { +842 final SortedSet<RegionState> rit = new TreeSet<RegionState>(REGION_STATE_STAMP_COMPARATOR); +843 for (RegionStateNode node: regionInTransition.values()) { +844 rit.add(createRegionState(node)); +845 } +846 return rit; +847 } +848 +849 // ========================================================================== +850 // Region offline helpers +851 // ========================================================================== +852 // TODO: Populated when we read meta but regions never make it out of here. +853 public void addToOfflineRegions(final RegionStateNode regionNode) { +854 LOG.info("Added to offline, CURRENTLY NEVER CLEARED!!! " + regionNode); +855 regionOffline.put(regionNode.getRegionInfo(), regionNode); +856 } +857 +858 // TODO: Unused. +859 public void removeFromOfflineRegions(final RegionInfo regionInfo) { +860 regionOffline.remove(regionInfo); +861 } +862 +863 // ========================================================================== +864 // Region FAIL_OPEN helpers +865 // ========================================================================== +866 public static final class RegionFailedOpen { +867 private final RegionStateNode regionNode; +868 +869 private volatile Exception exception = null; +870 private volatile int retries = 0; 871 -872 public RegionInfo getRegionInfo() { -873 return regionNode.getRegionInfo(); +872 public RegionFailedOpen(final RegionStateNode regionNode) { +873 this.regionNode = regionNode; 874 } 875 -876 public int incrementAndGetRetries() { -877 return ++this.retries; +876 public RegionStateNode getRegionNode() { +877 return regionNode; 878 } 879 -880 public int getRetries() { -881 return retries; +880 public RegionInfo getRegionInfo() { +881 return regionNode.getRegionInfo(); 882 } 883 -884 public void setException(final Exception exception) { -885 this.exception = exception; +884 public int incrementAndGetRetries() { +885 return ++this.retries; 886 } 887 -888 public Exception getException() { -889 return this.exception; +888 public int getRetries() { +889 return retries; 890 } -891 } -892 -893 public RegionFailedOpen addToFailedOpen(final RegionStateNode regionNode) { -894 final byte[] key = regionNode.getRegionInfo().getRegionName(); -895 RegionFailedOpen node = regionFailedOpen.get(key); -896 if (node == null) { -897 RegionFailedOpen newNode = new RegionFailedOpen(regionNode); -898 RegionFailedOpen oldNode = regionFailedOpen.putIfAbsent(key, newNode); -899 node = oldNode != null ? oldNode : newNode; -900 } -901 return node; -902 } -903 -904 public RegionFailedOpen getFailedOpen(final RegionInfo regionInfo) { -905 return regionFailedOpen.get(regionInfo.getRegionName()); -906 } -907 -908 public void removeFromFailedOpen(final RegionInfo regionInfo) { -909 regionFailedOpen.remove(regionInfo.getRegionName()); +891 +892 public void setException(final Exception exception) { +893 this.exception = exception; +894 } +895 +896 public Exception getException() { +897 return this.exception; +898 } +899 } +900 +901 public RegionFailedOpen addToFailedOpen(final RegionStateNode regionNode) { +902 final byte[] key = regionNode.getRegionInfo().getRegionName(); +903 RegionFailedOpen node = regionFailedOpen.get(key); +904 if (node == null) { +905 RegionFailedOpen newNode = new RegionFailedOpen(regionNode); +906 RegionFailedOpen oldNode = regionFailedOpen.putIfAbsent(key, newNode); +907 node = oldNode != null ? oldNode : newNode; +908 } +909 return node; 910 } 911 -912 public List<RegionState> getRegionFailedOpen() { -913 if (regionFailedOpen.isEmpty()) return Collections.emptyList(); -914 -915 ArrayList<RegionState> regions = new ArrayList<RegionState>(regionFailedOpen.size()); -916 for (RegionFailedOpen r: regionFailedOpen.values()) { -917 regions.add(createRegionState(r.getRegionNode())); -918 } -919 return regions; -920 } -921 -922 // ========================================================================== -923 // Servers -924 // ========================================================================== -925 public ServerStateNode getOrCreateServer(final ServerName serverName) { -926 ServerStateNode node = serverMap.get(serverName); -927 if (node == null) { -928 node = new ServerStateNode(serverName); -929 ServerStateNode oldNode = serverMap.putIfAbsent(serverName, node); -930 node = oldNode != null ? oldNode : node; -931 } -932 return node; -933 } -934 -935 public void removeServer(final ServerName serverName) { -936 serverMap.remove(serverName); -937 } -938 -939 protected ServerStateNode getServerNode(final ServerName serverName) { -940 return serverMap.get(serverName); +912 public RegionFailedOpen getFailedOpen(final RegionInfo regionInfo) { +913 return regionFailedOpen.get(regionInfo.getRegionName()); +914 } +915 +916 public void removeFromFailedOpen(final RegionInfo regionInfo) { +917 regionFailedOpen.remove(regionInfo.getRegionName()); +918 } +919 +920 public List<RegionState> getRegionFailedOpen() { +921 if (regionFailedOpen.isEmpty()) return Collections.emptyList(); +922 +923 ArrayList<RegionState> regions = new ArrayList<RegionState>(regionFailedOpen.size()); +924 for (RegionFailedOpen r: regionFailedOpen.values()) { +925 regions.add(createRegionState(r.getRegionNode())); +926 } +927 return regions; +928 } +929 +930 // ========================================================================== +931 // Servers +932 // ========================================================================== +933 public ServerStateNode getOrCreateServer(final ServerName serverName) { +934 ServerStateNode node = serverMap.get(serverName); +935 if (node == null) { +936 node = new ServerStateNode(serverName); +937 ServerStateNode oldNode = serverMap.putIfAbsent(serverName, node); +938 node = oldNode != null ? oldNode : node; +939 } +940 return node; 941 } 942 -943 public double getAverageLoad() { -944 int numServers = 0; -945 int totalLoad = 0; -946 for (ServerStateNode node: serverMap.values()) { -947 totalLoad += node.getRegionCount(); -948 numServers++; -949 } -950 return numServers == 0 ? 0.0: (double)totalLoad / (double)numServers; -951 } -952 -953 public ServerStateNode addRegionToServer(final ServerName serverName, -954 final RegionStateNode regionNode) { -955 ServerStateNode serverNode = getOrCreateServer(serverName); -956 serverNode.addRegion(regionNode); -957 return serverNode; -958 } -959 -960 public ServerStateNode removeRegionFromServer(final ServerName serverName, -961 final RegionStateNode regionNode) { -962 ServerStateNode serverNode = getOrCreateServer(serverName); -963 serverNode.removeRegion(regionNode); -964 return serverNode; -965 } -966 -967 // ========================================================================== -968 // ToString helpers -969 // ========================================================================== -970 public static String regionNamesToString(final Collection<byte[]> regions) { -971 final StringBuilder sb = new StringBuilder(); -972 final Iterator<byte[]> it = regions.iterator(); -973 sb.append("["); -974 if (it.hasNext()) { -975 sb.append(Bytes.toStringBinary(it.next())); -976 while (it.hasNext()) { -977 sb.append(", "); -978 sb.append(Bytes.toStringBinary(it.next())); -979 } -980 } -981 sb.append("]"); -982 return sb.toString(); -983 } -984} +943 public void removeServer(final ServerName serverName) { +944 serverMap.remove(serverName); +945 } +946 +947 protected ServerStateNode getServerNode(final ServerName serverName) { +948 return serverMap.get(serverName); +949 } +950 +951 public double getAverageLoad() { +952 int numServers = 0; +953 int totalLoad = 0; +954 for (ServerStateNode node: serverMap.values()) { +955 totalLoad += node.getRegionCount(); +956 numServers++; +957 } +958 return numServers == 0 ? 0.0: (double)totalLoad / (double)numServers; +959 } +960 +961 public ServerStateNode addRegionToServer(final ServerName serverName, +962 final RegionStateNode regionNode) { +963 ServerStateNode serverNode = getOrCreateServer(serverName); +964 serverNode.addRegion(regionNode); +965 return serverNode; +966 } +967 +968 public ServerStateNode removeRegionFromServer(final ServerName serverName, +969 final RegionStateNode regionNode) { +970 ServerStateNode serverNode = getOrCreateServer(serverName); +971 serverNode.removeRegion(regionNode); +972 return serverNode; +973 } +974 +975 // ========================================================================== +976 // ToString helpers +977 // ========================================================================== +978 public static String regionNamesToString(final Collection<byte[]> regions) { +979 final StringBuilder sb = new StringBuilder(); +980 final Iterator<byte[]> it = regions.iterator(); +981 sb.append("["); +982 if (it.hasNext()) { +983 sb.append(Bytes.toStringBinary(it.next())); +984 while (it.hasNext()) { +985 sb.append(", "); +986 sb.append(Bytes.toStringBinary(it.next())); +987 } +988 } +989 sb.append("]"); +990 return sb.toString(); +991 } +992}