1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19 package org.apache.hadoop.hbase.master.handler;
20
21 import java.io.IOException;
22 import java.io.InterruptedIOException;
23 import java.util.ArrayList;
24 import java.util.HashSet;
25 import java.util.List;
26 import java.util.Map;
27 import java.util.NavigableMap;
28 import java.util.Set;
29 import java.util.concurrent.locks.Lock;
30
31 import org.apache.commons.logging.Log;
32 import org.apache.commons.logging.LogFactory;
33 import org.apache.hadoop.classification.InterfaceAudience;
34 import org.apache.hadoop.hbase.HConstants;
35 import org.apache.hadoop.hbase.HRegionInfo;
36 import org.apache.hadoop.hbase.Server;
37 import org.apache.hadoop.hbase.ServerName;
38 import org.apache.hadoop.hbase.catalog.CatalogTracker;
39 import org.apache.hadoop.hbase.catalog.MetaReader;
40 import org.apache.hadoop.hbase.client.Result;
41 import org.apache.hadoop.hbase.executor.EventHandler;
42 import org.apache.hadoop.hbase.executor.EventType;
43 import org.apache.hadoop.hbase.master.AssignmentManager;
44 import org.apache.hadoop.hbase.master.DeadServer;
45 import org.apache.hadoop.hbase.master.MasterServices;
46 import org.apache.hadoop.hbase.master.RegionState;
47 import org.apache.hadoop.hbase.master.RegionState.State;
48 import org.apache.hadoop.hbase.master.RegionStates;
49 import org.apache.hadoop.hbase.master.ServerManager;
50 import org.apache.hadoop.hbase.zookeeper.ZKAssign;
51 import org.apache.zookeeper.KeeperException;
52
53
54
55
56
57
58 @InterfaceAudience.Private
59 public class ServerShutdownHandler extends EventHandler {
60 private static final Log LOG = LogFactory.getLog(ServerShutdownHandler.class);
61 protected final ServerName serverName;
62 protected final MasterServices services;
63 protected final DeadServer deadServers;
64 protected final boolean shouldSplitHlog;
65 protected final boolean distributedLogReplay;
66 protected final int regionAssignmentWaitTimeout;
67
68 public ServerShutdownHandler(final Server server, final MasterServices services,
69 final DeadServer deadServers, final ServerName serverName,
70 final boolean shouldSplitHlog) {
71 this(server, services, deadServers, serverName, EventType.M_SERVER_SHUTDOWN,
72 shouldSplitHlog);
73 }
74
75 ServerShutdownHandler(final Server server, final MasterServices services,
76 final DeadServer deadServers, final ServerName serverName, EventType type,
77 final boolean shouldSplitHlog) {
78 super(server, type);
79 this.serverName = serverName;
80 this.server = server;
81 this.services = services;
82 this.deadServers = deadServers;
83 if (!this.deadServers.isDeadServer(this.serverName)) {
84 LOG.warn(this.serverName + " is NOT in deadservers; it should be!");
85 }
86 this.shouldSplitHlog = shouldSplitHlog;
87 this.distributedLogReplay = server.getConfiguration().getBoolean(
88 HConstants.DISTRIBUTED_LOG_REPLAY_KEY,
89 HConstants.DEFAULT_DISTRIBUTED_LOG_REPLAY_CONFIG);
90 this.regionAssignmentWaitTimeout = server.getConfiguration().getInt(
91 HConstants.LOG_REPLAY_WAIT_REGION_TIMEOUT, 15000);
92 }
93
94 @Override
95 public String getInformativeName() {
96 if (serverName != null) {
97 return this.getClass().getSimpleName() + " for " + serverName;
98 } else {
99 return super.getInformativeName();
100 }
101 }
102
103
104
105
106 boolean isCarryingMeta() {
107 return false;
108 }
109
110 @Override
111 public String toString() {
112 String name = "UnknownServerName";
113 if(server != null && server.getServerName() != null) {
114 name = server.getServerName().toString();
115 }
116 return getClass().getSimpleName() + "-" + name + "-" + getSeqid();
117 }
118
119 @Override
120 public void process() throws IOException {
121 boolean hasLogReplayWork = false;
122 final ServerName serverName = this.serverName;
123 try {
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146 AssignmentManager am = services.getAssignmentManager();
147 if (isCarryingMeta()
148 || !am.isFailoverCleanupDone()) {
149 this.services.getServerManager().processDeadServer(serverName, this.shouldSplitHlog);
150 return;
151 }
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168 NavigableMap<HRegionInfo, Result> hris = null;
169 while (!this.server.isStopped()) {
170 try {
171 this.server.getCatalogTracker().waitForMeta();
172 hris = MetaReader.getServerUserRegions(this.server.getCatalogTracker(),
173 this.serverName);
174 break;
175 } catch (InterruptedException e) {
176 Thread.currentThread().interrupt();
177 throw new IOException("Interrupted", e);
178 } catch (IOException ioe) {
179 LOG.info("Received exception accessing hbase:meta during server shutdown of " +
180 serverName + ", retrying hbase:meta read", ioe);
181 }
182 }
183 if (this.server.isStopped()) {
184 throw new IOException("Server is stopped");
185 }
186
187 try {
188 if (this.shouldSplitHlog) {
189 LOG.info("Splitting logs for " + serverName + " before assignment.");
190 if (this.distributedLogReplay) {
191 LOG.info("Mark regions in recovery before assignment.");
192 Set<ServerName> serverNames = new HashSet<ServerName>();
193 serverNames.add(serverName);
194 this.services.getMasterFileSystem().prepareLogReplay(serverNames);
195 } else {
196 this.services.getMasterFileSystem().splitLog(serverName);
197 }
198 am.getRegionStates().logSplit(serverName);
199 } else {
200 LOG.info("Skipping log splitting for " + serverName);
201 }
202 } catch (IOException ioe) {
203 resubmit(serverName, ioe);
204 }
205
206
207
208
209
210 List<HRegionInfo> regionsInTransition = am.processServerShutdown(serverName);
211 LOG.info("Reassigning " + ((hris == null)? 0: hris.size()) +
212 " region(s) that " + (serverName == null? "null": serverName) +
213 " was carrying (and " + regionsInTransition.size() +
214 " regions(s) that were opening on this server)");
215
216 List<HRegionInfo> toAssignRegions = new ArrayList<HRegionInfo>();
217 toAssignRegions.addAll(regionsInTransition);
218
219
220 if (hris != null) {
221 RegionStates regionStates = am.getRegionStates();
222 for (Map.Entry<HRegionInfo, Result> e: hris.entrySet()) {
223 HRegionInfo hri = e.getKey();
224 if (regionsInTransition.contains(hri)) {
225 continue;
226 }
227 String encodedName = hri.getEncodedName();
228 Lock lock = am.acquireRegionLock(encodedName);
229 try {
230 RegionState rit = regionStates.getRegionTransitionState(hri);
231 if (processDeadRegion(hri, e.getValue(), am, server.getCatalogTracker())) {
232 ServerName addressFromAM = regionStates.getRegionServerOfRegion(hri);
233 if (addressFromAM != null && !addressFromAM.equals(this.serverName)) {
234
235
236 LOG.info("Skip assigning region " + hri.getRegionNameAsString()
237 + " because it has been opened in " + addressFromAM.getServerName());
238 continue;
239 }
240 if (rit != null) {
241 if (rit.getServerName() != null && !rit.isOnServer(serverName)) {
242
243 LOG.info("Skip assigning region in transition on other server" + rit);
244 continue;
245 }
246 try{
247
248 LOG.info("Reassigning region with rs = " + rit + " and deleting zk node if exists");
249 ZKAssign.deleteNodeFailSilent(services.getZooKeeper(), hri);
250 regionStates.updateRegionState(hri, State.OFFLINE);
251 } catch (KeeperException ke) {
252 this.server.abort("Unexpected ZK exception deleting unassigned node " + hri, ke);
253 return;
254 }
255 } else if (regionStates.isRegionInState(
256 hri, State.SPLITTING_NEW, State.MERGING_NEW)) {
257 regionStates.regionOffline(hri);
258 }
259 toAssignRegions.add(hri);
260 } else if (rit != null) {
261 if (rit.isPendingCloseOrClosing()
262 && am.getZKTable().isDisablingOrDisabledTable(hri.getTable())) {
263
264
265
266
267
268 regionStates.updateRegionState(hri, State.OFFLINE);
269 am.deleteClosingOrClosedNode(hri, rit.getServerName());
270 am.offlineDisabledRegion(hri);
271 } else {
272 LOG.warn("THIS SHOULD NOT HAPPEN: unexpected region in transition "
273 + rit + " not to be assigned by SSH of server " + serverName);
274 }
275 }
276 } finally {
277 lock.unlock();
278 }
279 }
280 }
281
282 try {
283 am.assign(toAssignRegions);
284 } catch (InterruptedException ie) {
285 LOG.error("Caught " + ie + " during round-robin assignment");
286 throw new IOException(ie);
287 }
288
289 if (this.shouldSplitHlog && this.distributedLogReplay) {
290
291 for (HRegionInfo hri : toAssignRegions) {
292 try {
293 if (!am.waitOnRegionToClearRegionsInTransition(hri, regionAssignmentWaitTimeout)) {
294
295
296 LOG.warn("Region " + hri.getEncodedName()
297 + " didn't complete assignment in time");
298 }
299 } catch (InterruptedException ie) {
300 throw new InterruptedIOException("Caught " + ie
301 + " during waitOnRegionToClearRegionsInTransition");
302 }
303 }
304
305 this.services.getExecutorService().submit(
306 new LogReplayHandler(this.server, this.services, this.deadServers, this.serverName));
307 hasLogReplayWork = true;
308 }
309 } finally {
310 this.deadServers.finish(serverName);
311 }
312
313 if (!hasLogReplayWork) {
314 LOG.info("Finished processing of shutdown of " + serverName);
315 }
316 }
317
318 private void resubmit(final ServerName serverName, IOException ex) throws IOException {
319
320
321 this.services.getExecutorService().submit((ServerShutdownHandler) this);
322 this.deadServers.add(serverName);
323 throw new IOException("failed log splitting for " + serverName + ", will retry", ex);
324 }
325
326
327
328
329
330
331
332
333
334
335
336 public static boolean processDeadRegion(HRegionInfo hri, Result result,
337 AssignmentManager assignmentManager, CatalogTracker catalogTracker)
338 throws IOException {
339 boolean tablePresent = assignmentManager.getZKTable().isTablePresent(hri.getTable());
340 if (!tablePresent) {
341 LOG.info("The table " + hri.getTable()
342 + " was deleted. Hence not proceeding.");
343 return false;
344 }
345
346 boolean disabled = assignmentManager.getZKTable().isDisabledTable(hri.getTable());
347 if (disabled){
348 LOG.info("The table " + hri.getTable()
349 + " was disabled. Hence not proceeding.");
350 return false;
351 }
352 if (hri.isOffline() && hri.isSplit()) {
353
354
355
356 return false;
357 }
358 boolean disabling = assignmentManager.getZKTable().isDisablingTable(hri.getTable());
359 if (disabling) {
360 LOG.info("The table " + hri.getTable()
361 + " is disabled. Hence not assigning region" + hri.getEncodedName());
362 return false;
363 }
364 return true;
365 }
366 }