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