1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18 package org.apache.hadoop.hbase.procedure;
19
20 import java.io.Closeable;
21 import java.io.IOException;
22 import java.util.List;
23
24 import org.apache.commons.logging.Log;
25 import org.apache.commons.logging.LogFactory;
26 import org.apache.hadoop.classification.InterfaceAudience;
27 import org.apache.hadoop.classification.InterfaceStability;
28 import org.apache.hadoop.hbase.zookeeper.ZKUtil;
29 import org.apache.hadoop.hbase.zookeeper.ZooKeeperListener;
30 import org.apache.hadoop.hbase.zookeeper.ZooKeeperWatcher;
31 import org.apache.zookeeper.KeeperException;
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51 @InterfaceAudience.Public
52 @InterfaceStability.Evolving
53 public abstract class ZKProcedureUtil
54 extends ZooKeeperListener implements Closeable {
55
56 private static final Log LOG = LogFactory.getLog(ZKProcedureUtil.class);
57
58 public static final String ACQUIRED_BARRIER_ZNODE_DEFAULT = "acquired";
59 public static final String REACHED_BARRIER_ZNODE_DEFAULT = "reached";
60 public static final String ABORT_ZNODE_DEFAULT = "abort";
61
62 public final String baseZNode;
63 protected final String acquiredZnode;
64 protected final String reachedZnode;
65 protected final String abortZnode;
66
67
68
69
70
71
72
73
74
75
76
77 public ZKProcedureUtil(ZooKeeperWatcher watcher, String procDescription)
78 throws KeeperException {
79 super(watcher);
80
81 watcher.registerListener(this);
82
83 this.baseZNode = ZKUtil.joinZNode(watcher.baseZNode, procDescription);
84 acquiredZnode = ZKUtil.joinZNode(baseZNode, ACQUIRED_BARRIER_ZNODE_DEFAULT);
85 reachedZnode = ZKUtil.joinZNode(baseZNode, REACHED_BARRIER_ZNODE_DEFAULT);
86 abortZnode = ZKUtil.joinZNode(baseZNode, ABORT_ZNODE_DEFAULT);
87
88
89
90 ZKUtil.createWithParents(watcher, acquiredZnode);
91
92 ZKUtil.createAndFailSilent(watcher, reachedZnode);
93 ZKUtil.createAndFailSilent(watcher, abortZnode);
94 }
95
96 @Override
97 public void close() throws IOException {
98
99
100 }
101
102 public String getAcquiredBarrierNode(String opInstanceName) {
103 return ZKProcedureUtil.getAcquireBarrierNode(this, opInstanceName);
104 }
105
106 public String getReachedBarrierNode(String opInstanceName) {
107 return ZKProcedureUtil.getReachedBarrierNode(this, opInstanceName);
108 }
109
110 public String getAbortZNode(String opInstanceName) {
111 return ZKProcedureUtil.getAbortNode(this, opInstanceName);
112 }
113
114 public String getAbortZnode() {
115 return abortZnode;
116 }
117
118 public String getBaseZnode() {
119 return baseZNode;
120 }
121
122 public String getAcquiredBarrier() {
123 return acquiredZnode;
124 }
125
126
127
128
129
130
131
132
133 public static String getAcquireBarrierNode(ZKProcedureUtil controller,
134 String opInstanceName) {
135 return ZKUtil.joinZNode(controller.acquiredZnode, opInstanceName);
136 }
137
138
139
140
141
142
143
144
145 public static String getReachedBarrierNode(ZKProcedureUtil controller,
146 String opInstanceName) {
147 return ZKUtil.joinZNode(controller.reachedZnode, opInstanceName);
148 }
149
150
151
152
153
154
155
156
157 public static String getAbortNode(ZKProcedureUtil controller, String opInstanceName) {
158 return ZKUtil.joinZNode(controller.abortZnode, opInstanceName);
159 }
160
161 public ZooKeeperWatcher getWatcher() {
162 return watcher;
163 }
164
165
166
167
168
169
170
171
172
173 boolean isInProcedurePath(String path) {
174 return path.startsWith(baseZNode);
175 }
176
177
178
179
180 boolean isAcquiredNode(String path) {
181 return path.equals(acquiredZnode);
182 }
183
184
185
186
187
188 boolean isAcquiredPathNode(String path) {
189 return path.startsWith(this.acquiredZnode) && !path.equals(acquiredZnode);
190 }
191
192
193
194
195 boolean isReachedNode(String path) {
196 return path.equals(reachedZnode);
197 }
198
199
200
201
202 boolean isReachedPathNode(String path) {
203 return path.startsWith(this.reachedZnode) && !path.equals(reachedZnode);
204 }
205
206
207
208
209
210 boolean isAbortNode(String path) {
211 return path.equals(abortZnode);
212 }
213
214
215
216
217 public boolean isAbortPathNode(String path) {
218 return path.startsWith(this.abortZnode) && !path.equals(abortZnode);
219 }
220
221
222
223
224
225
226
227
228
229 void logZKTree(String root) {
230 if (!LOG.isDebugEnabled()) return;
231 LOG.debug("Current zk system:");
232 String prefix = "|-";
233 LOG.debug(prefix + root);
234 try {
235 logZKTree(root, prefix);
236 } catch (KeeperException e) {
237 throw new RuntimeException(e);
238 }
239 }
240
241
242
243
244
245
246 protected void logZKTree(String root, String prefix) throws KeeperException {
247 List<String> children = ZKUtil.listChildrenNoWatch(watcher, root);
248 if (children == null) return;
249 for (String child : children) {
250 LOG.debug(prefix + child);
251 String node = ZKUtil.joinZNode(root.equals("/") ? "" : root, child);
252 logZKTree(node, prefix + "---");
253 }
254 }
255
256 public void clearChildZNodes() throws KeeperException {
257
258 LOG.info("Clearing all procedure znodes: " + acquiredZnode + " " + reachedZnode + " "
259 + abortZnode);
260
261
262
263
264 ZKUtil.deleteChildrenRecursively(watcher, acquiredZnode);
265 ZKUtil.deleteChildrenRecursively(watcher, reachedZnode);
266 ZKUtil.deleteChildrenRecursively(watcher, abortZnode);
267 }
268
269 public void clearZNodes(String procedureName) throws KeeperException {
270
271 LOG.info("Clearing all znodes for procedure " + procedureName + "including nodes "
272 + acquiredZnode + " " + reachedZnode + " " + abortZnode);
273 ZKUtil.deleteNodeRecursively(watcher, getAcquiredBarrierNode(procedureName));
274 ZKUtil.deleteNodeRecursively(watcher, getReachedBarrierNode(procedureName));
275 ZKUtil.deleteNodeRecursively(watcher, getAbortZNode(procedureName));
276 }
277 }