1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20 package org.apache.hadoop.hbase.executor;
21
22 import java.util.ArrayList;
23 import java.util.Collections;
24 import java.util.List;
25
26 import org.apache.commons.logging.Log;
27 import org.apache.commons.logging.LogFactory;
28 import org.apache.hadoop.hbase.executor.HBaseExecutorService.HBaseExecutorServiceType;
29 import org.apache.hadoop.hbase.master.ServerManager;
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50 public abstract class HBaseEventHandler implements Runnable
51 {
52 private static final Log LOG = LogFactory.getLog(HBaseEventHandler.class);
53
54 protected HBaseEventType eventType = HBaseEventType.NONE;
55
56 protected boolean isRegionServer;
57
58
59 protected String serverName;
60
61 protected static List<HBaseEventHandlerListener> eventHandlerListeners =
62 Collections.synchronizedList(new ArrayList<HBaseEventHandlerListener>());
63
64
65
66
67
68
69 public interface HBaseEventHandlerListener {
70
71
72
73 public void beforeProcess(HBaseEventHandler event);
74
75
76
77 public void afterProcess(HBaseEventHandler event);
78 }
79
80
81
82
83
84 public enum HBaseEventType {
85 NONE (-1),
86
87
88 RS2ZK_REGION_CLOSING (1),
89 RS2ZK_REGION_CLOSED (2),
90 RS2ZK_REGION_OPENING (3),
91 RS2ZK_REGION_OPENED (4),
92
93
94
95 M2ZK_REGION_OFFLINE (50);
96
97 private final byte value;
98
99
100
101
102
103
104
105 public HBaseExecutorServiceType getMasterExecutorForEvent() {
106 HBaseExecutorServiceType executorServiceType = null;
107 switch(this) {
108
109 case RS2ZK_REGION_CLOSING:
110 case RS2ZK_REGION_CLOSED:
111 executorServiceType = HBaseExecutorServiceType.MASTER_CLOSEREGION;
112 break;
113
114 case RS2ZK_REGION_OPENING:
115 case RS2ZK_REGION_OPENED:
116 executorServiceType = HBaseExecutorServiceType.MASTER_OPENREGION;
117 break;
118
119 case M2ZK_REGION_OFFLINE:
120 executorServiceType = HBaseExecutorServiceType.NONE;
121 break;
122
123 default:
124 throw new RuntimeException("Unhandled event type in the master.");
125 }
126
127 return executorServiceType;
128 }
129
130
131
132
133
134
135
136 public static String getRSExecutorForEvent(String serverName) {
137 throw new RuntimeException("Unsupported operation.");
138 }
139
140
141
142
143
144
145 public void startMasterExecutorService(String serverName) {
146 HBaseExecutorServiceType serviceType = getMasterExecutorForEvent();
147 if(serviceType == HBaseExecutorServiceType.NONE) {
148 throw new RuntimeException("Event type " + toString() + " not handled on master.");
149 }
150 serviceType.startExecutorService(serverName);
151 }
152
153 public static void startRSExecutorService() {
154
155 }
156
157 HBaseEventType(int intValue) {
158 this.value = (byte)intValue;
159 }
160
161 public byte getByteValue() {
162 return value;
163 }
164
165 public static HBaseEventType fromByte(byte value) {
166 switch(value) {
167 case -1: return HBaseEventType.NONE;
168 case 1 : return HBaseEventType.RS2ZK_REGION_CLOSING;
169 case 2 : return HBaseEventType.RS2ZK_REGION_CLOSED;
170 case 3 : return HBaseEventType.RS2ZK_REGION_OPENING;
171 case 4 : return HBaseEventType.RS2ZK_REGION_OPENED;
172 case 50: return HBaseEventType.M2ZK_REGION_OFFLINE;
173
174 default:
175 throw new RuntimeException("Invalid byte value for conversion to HBaseEventType");
176 }
177 }
178 }
179
180
181
182
183
184
185
186
187 public HBaseEventHandler(boolean isRegionServer, String serverName, HBaseEventType eventType) {
188 this.isRegionServer = isRegionServer;
189 this.eventType = eventType;
190 this.serverName = serverName;
191 }
192
193
194
195
196
197 public void run() {
198
199 for(HBaseEventHandlerListener listener : eventHandlerListeners) {
200 listener.beforeProcess(this);
201 }
202
203
204 try {
205 process();
206 } catch(Throwable t) {
207 LOG.error("Caught throwable while processing event " + eventType, t);
208 }
209
210
211 for(HBaseEventHandlerListener listener : eventHandlerListeners) {
212 LOG.debug("Firing " + listener.getClass().getName() +
213 ".afterProcess event listener for event " + eventType);
214 listener.afterProcess(this);
215 }
216 }
217
218
219
220
221
222 public abstract void process();
223
224
225
226
227 public static void registerListener(HBaseEventHandlerListener listener) {
228 eventHandlerListeners.add(listener);
229 }
230
231
232
233
234 public static void unregisterListener(HBaseEventHandlerListener listener) {
235 eventHandlerListeners.remove(listener);
236 }
237
238 public boolean isRegionServer() {
239 return isRegionServer;
240 }
241
242
243
244
245
246 public HBaseExecutorServiceType getEventHandlerName() {
247
248 return eventType.getMasterExecutorForEvent();
249 }
250
251
252
253
254
255 public HBaseEventType getHBEvent() {
256 return eventType;
257 }
258
259
260
261
262
263 public void submit() {
264 HBaseExecutorServiceType serviceType = getEventHandlerName();
265 if(serviceType == null) {
266 throw new RuntimeException("Event " + eventType + " not handled on this server " + serverName);
267 }
268 serviceType.getExecutor(serverName).submit(this);
269 }
270
271
272
273
274
275 public void execute() {
276 this.run();
277 }
278 }