001/* 002 * Licensed to the Apache Software Foundation (ASF) under one 003 * or more contributor license agreements. See the NOTICE file 004 * distributed with this work for additional information 005 * regarding copyright ownership. The ASF licenses this file 006 * to you under the Apache License, Version 2.0 (the 007 * "License"); you may not use this file except in compliance 008 * with the License. You may obtain a copy of the License at 009 * 010 * http://www.apache.org/licenses/LICENSE-2.0 011 * 012 * Unless required by applicable law or agreed to in writing, software 013 * distributed under the License is distributed on an "AS IS" BASIS, 014 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 015 * See the License for the specific language governing permissions and 016 * limitations under the License. 017 */ 018package org.apache.hadoop.hbase.master.procedure; 019 020import java.util.ArrayList; 021import java.util.HashMap; 022import java.util.List; 023import java.util.Map; 024import java.util.function.Function; 025import org.apache.hadoop.hbase.ServerName; 026import org.apache.hadoop.hbase.TableName; 027import org.apache.hadoop.hbase.master.locking.LockProcedure; 028import org.apache.hadoop.hbase.procedure2.LockAndQueue; 029import org.apache.hadoop.hbase.procedure2.LockType; 030import org.apache.hadoop.hbase.procedure2.LockedResource; 031import org.apache.hadoop.hbase.procedure2.LockedResourceType; 032import org.apache.hadoop.hbase.procedure2.Procedure; 033import org.apache.yetus.audience.InterfaceAudience; 034 035import org.apache.hbase.thirdparty.com.google.common.collect.ImmutableMap; 036 037/** 038 * <p> 039 * Locks on namespaces, tables, and regions. 040 * </p> 041 * <p> 042 * Since LockAndQueue implementation is NOT thread-safe, schedLock() guards all calls to these 043 * locks. 044 * </p> 045 */ 046@InterfaceAudience.Private 047class SchemaLocking { 048 049 private final Function<Long, Procedure<?>> procedureRetriever; 050 private final Map<ServerName, LockAndQueue> serverLocks = new HashMap<>(); 051 private final Map<String, LockAndQueue> namespaceLocks = new HashMap<>(); 052 private final Map<TableName, LockAndQueue> tableLocks = new HashMap<>(); 053 // Single map for all regions irrespective of tables. Key is encoded region name. 054 private final Map<String, LockAndQueue> regionLocks = new HashMap<>(); 055 private final Map<String, LockAndQueue> peerLocks = new HashMap<>(); 056 private final LockAndQueue metaLock; 057 058 public SchemaLocking(Function<Long, Procedure<?>> procedureRetriever) { 059 this.procedureRetriever = procedureRetriever; 060 this.metaLock = new LockAndQueue(procedureRetriever); 061 } 062 063 private <T> LockAndQueue getLock(Map<T, LockAndQueue> map, T key) { 064 LockAndQueue lock = map.get(key); 065 if (lock == null) { 066 lock = new LockAndQueue(procedureRetriever); 067 map.put(key, lock); 068 } 069 return lock; 070 } 071 072 LockAndQueue getTableLock(TableName tableName) { 073 return getLock(tableLocks, tableName); 074 } 075 076 LockAndQueue removeTableLock(TableName tableName) { 077 return tableLocks.remove(tableName); 078 } 079 080 LockAndQueue getNamespaceLock(String namespace) { 081 return getLock(namespaceLocks, namespace); 082 } 083 084 LockAndQueue getRegionLock(String encodedRegionName) { 085 return getLock(regionLocks, encodedRegionName); 086 } 087 088 /** 089 * @deprecated only used for {@link RecoverMetaProcedure}. Should be removed along with 090 * {@link RecoverMetaProcedure}. 091 */ 092 @Deprecated 093 LockAndQueue getMetaLock() { 094 return metaLock; 095 } 096 097 LockAndQueue removeRegionLock(String encodedRegionName) { 098 return regionLocks.remove(encodedRegionName); 099 } 100 101 LockAndQueue getServerLock(ServerName serverName) { 102 return getLock(serverLocks, serverName); 103 } 104 105 LockAndQueue removeServerLock(ServerName serverName) { 106 return serverLocks.remove(serverName); 107 } 108 109 LockAndQueue getPeerLock(String peerId) { 110 return getLock(peerLocks, peerId); 111 } 112 113 LockAndQueue removePeerLock(String peerId) { 114 return peerLocks.remove(peerId); 115 } 116 117 private LockedResource createLockedResource(LockedResourceType resourceType, String resourceName, 118 LockAndQueue queue) { 119 LockType lockType; 120 Procedure<?> exclusiveLockOwnerProcedure; 121 int sharedLockCount; 122 123 if (queue.hasExclusiveLock()) { 124 lockType = LockType.EXCLUSIVE; 125 exclusiveLockOwnerProcedure = queue.getExclusiveLockOwnerProcedure(); 126 sharedLockCount = 0; 127 } else { 128 lockType = LockType.SHARED; 129 exclusiveLockOwnerProcedure = null; 130 sharedLockCount = queue.getSharedLockCount(); 131 } 132 133 List<Procedure<?>> waitingProcedures = new ArrayList<>(); 134 135 queue.filterWaitingQueue(p -> p instanceof LockProcedure) 136 .forEachOrdered(waitingProcedures::add); 137 138 return new LockedResource(resourceType, resourceName, lockType, exclusiveLockOwnerProcedure, 139 sharedLockCount, waitingProcedures); 140 } 141 142 private <T> void addToLockedResources(List<LockedResource> lockedResources, 143 Map<T, LockAndQueue> locks, Function<T, String> keyTransformer, 144 LockedResourceType resourcesType) { 145 locks.entrySet().stream().filter(e -> e.getValue().isLocked()) 146 .map(e -> createLockedResource(resourcesType, keyTransformer.apply(e.getKey()), e.getValue())) 147 .forEachOrdered(lockedResources::add); 148 } 149 150 /** 151 * List lock queues. 152 * @return the locks 153 */ 154 List<LockedResource> getLocks() { 155 List<LockedResource> lockedResources = new ArrayList<>(); 156 addToLockedResources(lockedResources, serverLocks, sn -> sn.getServerName(), 157 LockedResourceType.SERVER); 158 addToLockedResources(lockedResources, namespaceLocks, Function.identity(), 159 LockedResourceType.NAMESPACE); 160 addToLockedResources(lockedResources, tableLocks, tn -> tn.getNameAsString(), 161 LockedResourceType.TABLE); 162 addToLockedResources(lockedResources, regionLocks, Function.identity(), 163 LockedResourceType.REGION); 164 addToLockedResources(lockedResources, peerLocks, Function.identity(), LockedResourceType.PEER); 165 addToLockedResources(lockedResources, ImmutableMap.of(TableName.META_TABLE_NAME, metaLock), 166 tn -> tn.getNameAsString(), LockedResourceType.META); 167 return lockedResources; 168 } 169 170 /** 171 * @return {@link LockedResource} for resource of specified type & name. null if resource is not 172 * locked. 173 */ 174 LockedResource getLockResource(LockedResourceType resourceType, String resourceName) { 175 LockAndQueue queue; 176 switch (resourceType) { 177 case SERVER: 178 queue = serverLocks.get(ServerName.valueOf(resourceName)); 179 break; 180 case NAMESPACE: 181 queue = namespaceLocks.get(resourceName); 182 break; 183 case TABLE: 184 queue = tableLocks.get(TableName.valueOf(resourceName)); 185 break; 186 case REGION: 187 queue = regionLocks.get(resourceName); 188 break; 189 case PEER: 190 queue = peerLocks.get(resourceName); 191 break; 192 case META: 193 queue = metaLock; 194 default: 195 queue = null; 196 } 197 return queue != null ? createLockedResource(resourceType, resourceName, queue) : null; 198 } 199 200 /** 201 * Removes all locks by clearing the maps. Used when procedure executor is stopped for failure and 202 * recovery testing. 203 */ 204 void clear() { 205 serverLocks.clear(); 206 namespaceLocks.clear(); 207 tableLocks.clear(); 208 regionLocks.clear(); 209 peerLocks.clear(); 210 } 211 212 @Override 213 public String toString() { 214 return "serverLocks=" + filterUnlocked(this.serverLocks) + ", namespaceLocks=" 215 + filterUnlocked(this.namespaceLocks) + ", tableLocks=" + filterUnlocked(this.tableLocks) 216 + ", regionLocks=" + filterUnlocked(this.regionLocks) + ", peerLocks=" 217 + filterUnlocked(this.peerLocks) + ", metaLocks=" 218 + filterUnlocked(ImmutableMap.of(TableName.META_TABLE_NAME, metaLock)); 219 } 220 221 private String filterUnlocked(Map<?, LockAndQueue> locks) { 222 StringBuilder sb = new StringBuilder("{"); 223 int initialLength = sb.length(); 224 for (Map.Entry<?, LockAndQueue> entry : locks.entrySet()) { 225 if (!entry.getValue().isLocked()) { 226 continue; 227 } 228 if (sb.length() > initialLength) { 229 sb.append(", "); 230 } 231 sb.append("{").append(entry.getKey()).append("=").append(entry.getValue()).append("}"); 232 } 233 sb.append("}"); 234 return sb.toString(); 235 } 236}