1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18 package org.apache.hadoop.hbase.client;
19
20 import java.io.IOException;
21 import java.util.List;
22 import java.util.concurrent.ExecutorService;
23
24 import org.apache.hadoop.hbase.classification.InterfaceAudience;
25 import org.apache.hadoop.conf.Configuration;
26 import org.apache.hadoop.hbase.HRegionLocation;
27 import org.apache.hadoop.hbase.HTableDescriptor;
28 import org.apache.hadoop.hbase.MasterNotRunningException;
29 import org.apache.hadoop.hbase.RegionLocations;
30 import org.apache.hadoop.hbase.ServerName;
31 import org.apache.hadoop.hbase.TableName;
32 import org.apache.hadoop.hbase.ZooKeeperConnectionException;
33 import org.apache.hadoop.hbase.classification.InterfaceAudience;
34 import org.apache.hadoop.hbase.client.backoff.ClientBackoffPolicy;
35 import org.apache.hadoop.hbase.client.coprocessor.Batch.Callback;
36 import org.apache.hadoop.hbase.protobuf.generated.AdminProtos.AdminService;
37 import org.apache.hadoop.hbase.protobuf.generated.ClientProtos.ClientService;
38 import org.apache.hadoop.hbase.protobuf.generated.MasterProtos.MasterService;
39
40
41
42
43
44
45
46
47
48
49 @InterfaceAudience.Private
50 @SuppressWarnings("deprecation")
51
52 abstract class ConnectionAdapter implements ClusterConnection {
53
54 private final ClusterConnection wrappedConnection;
55
56 public ConnectionAdapter(Connection c) {
57 wrappedConnection = (ClusterConnection)c;
58 }
59
60 @Override
61 public void abort(String why, Throwable e) {
62 wrappedConnection.abort(why, e);
63 }
64
65 @Override
66 public boolean isAborted() {
67 return wrappedConnection.isAborted();
68 }
69
70 @Override
71 public void close() throws IOException {
72 wrappedConnection.close();
73 }
74
75 @Override
76 public Configuration getConfiguration() {
77 return wrappedConnection.getConfiguration();
78 }
79
80 @Override
81 public HTableInterface getTable(String tableName) throws IOException {
82 return wrappedConnection.getTable(tableName);
83 }
84
85 @Override
86 public HTableInterface getTable(byte[] tableName) throws IOException {
87 return wrappedConnection.getTable(tableName);
88 }
89
90 @Override
91 public HTableInterface getTable(TableName tableName) throws IOException {
92 return wrappedConnection.getTable(tableName);
93 }
94
95 @Override
96 public HTableInterface getTable(String tableName, ExecutorService pool)
97 throws IOException {
98 return wrappedConnection.getTable(tableName, pool);
99 }
100
101 @Override
102 public HTableInterface getTable(byte[] tableName, ExecutorService pool)
103 throws IOException {
104 return wrappedConnection.getTable(tableName, pool);
105 }
106
107 @Override
108 public HTableInterface getTable(TableName tableName, ExecutorService pool)
109 throws IOException {
110 return wrappedConnection.getTable(tableName, pool);
111 }
112
113 @Override
114 public BufferedMutator getBufferedMutator(BufferedMutatorParams params)
115 throws IOException {
116 return wrappedConnection.getBufferedMutator(params);
117 }
118
119 @Override
120 public BufferedMutator getBufferedMutator(TableName tableName) throws IOException {
121 return wrappedConnection.getBufferedMutator(tableName);
122 }
123
124 @Override
125 public RegionLocator getRegionLocator(TableName tableName) throws IOException {
126 return wrappedConnection.getRegionLocator(tableName);
127 }
128
129 @Override
130 public Admin getAdmin() throws IOException {
131 return wrappedConnection.getAdmin();
132 }
133
134 @Override
135 public boolean isMasterRunning() throws MasterNotRunningException,
136 ZooKeeperConnectionException {
137 return wrappedConnection.isMasterRunning();
138 }
139
140 @Override
141 public boolean isTableEnabled(TableName tableName) throws IOException {
142 return wrappedConnection.isTableEnabled(tableName);
143 }
144
145 @Override
146 public boolean isTableEnabled(byte[] tableName) throws IOException {
147 return wrappedConnection.isTableEnabled(tableName);
148 }
149
150 @Override
151 public boolean isTableDisabled(TableName tableName) throws IOException {
152 return wrappedConnection.isTableDisabled(tableName);
153 }
154
155 @Override
156 public boolean isTableDisabled(byte[] tableName) throws IOException {
157 return wrappedConnection.isTableDisabled(tableName);
158 }
159
160 @Override
161 public boolean isTableAvailable(TableName tableName) throws IOException {
162 return wrappedConnection.isTableAvailable(tableName);
163 }
164
165 @Override
166 public boolean isTableAvailable(byte[] tableName) throws IOException {
167 return wrappedConnection.isTableAvailable(tableName);
168 }
169
170 @Override
171 public boolean isTableAvailable(TableName tableName, byte[][] splitKeys)
172 throws IOException {
173 return wrappedConnection.isTableAvailable(tableName, splitKeys);
174 }
175
176 @Override
177 public boolean isTableAvailable(byte[] tableName, byte[][] splitKeys)
178 throws IOException {
179 return wrappedConnection.isTableAvailable(tableName, splitKeys);
180 }
181
182 @Override
183 public HTableDescriptor[] listTables() throws IOException {
184 return wrappedConnection.listTables();
185 }
186
187 @Override
188 public String[] getTableNames() throws IOException {
189 return wrappedConnection.getTableNames();
190 }
191
192 @Override
193 public TableName[] listTableNames() throws IOException {
194 return wrappedConnection.listTableNames();
195 }
196
197 @Override
198 public HTableDescriptor getHTableDescriptor(TableName tableName)
199 throws IOException {
200 return wrappedConnection.getHTableDescriptor(tableName);
201 }
202
203 @Override
204 public HTableDescriptor getHTableDescriptor(byte[] tableName)
205 throws IOException {
206 return wrappedConnection.getHTableDescriptor(tableName);
207 }
208
209 @Override
210 public HRegionLocation locateRegion(TableName tableName, byte[] row)
211 throws IOException {
212 return wrappedConnection.locateRegion(tableName, row);
213 }
214
215 @Override
216 public HRegionLocation locateRegion(byte[] tableName, byte[] row)
217 throws IOException {
218 return wrappedConnection.locateRegion(tableName, row);
219 }
220
221 @Override
222 public RegionLocations locateRegion(TableName tableName, byte[] row, boolean useCache,
223 boolean retry) throws IOException {
224 return wrappedConnection.locateRegion(tableName, row, useCache, retry);
225 }
226
227 @Override
228 public void clearRegionCache() {
229 wrappedConnection.clearRegionCache();
230 }
231
232 @Override
233 public void clearRegionCache(TableName tableName) {
234 wrappedConnection.clearRegionCache(tableName);
235 }
236
237 @Override
238 public void clearRegionCache(byte[] tableName) {
239 wrappedConnection.clearRegionCache(tableName);
240 }
241
242 @Override
243 public void deleteCachedRegionLocation(HRegionLocation location) {
244 wrappedConnection.deleteCachedRegionLocation(location);
245 }
246
247 @Override
248 public HRegionLocation relocateRegion(TableName tableName, byte[] row)
249 throws IOException {
250 return wrappedConnection.relocateRegion(tableName, row);
251 }
252
253 @Override
254 public HRegionLocation relocateRegion(byte[] tableName, byte[] row)
255 throws IOException {
256 return wrappedConnection.relocateRegion(tableName, row);
257 }
258
259 @Override
260 public void updateCachedLocations(TableName tableName, byte[] rowkey,
261 Object exception, HRegionLocation source) {
262 wrappedConnection.updateCachedLocations(tableName, rowkey, exception, source);
263 }
264
265 @Override
266 public void updateCachedLocations(TableName tableName, byte[] regionName, byte[] rowkey,
267 Object exception, ServerName source) {
268 wrappedConnection.updateCachedLocations(tableName, regionName, rowkey, exception, source);
269 }
270
271 @Override
272 public void updateCachedLocations(byte[] tableName, byte[] rowkey,
273 Object exception, HRegionLocation source) {
274 wrappedConnection.updateCachedLocations(tableName, rowkey, exception, source);
275 }
276
277 @Override
278 public HRegionLocation locateRegion(byte[] regionName) throws IOException {
279 return wrappedConnection.locateRegion(regionName);
280 }
281
282 @Override
283 public List<HRegionLocation> locateRegions(TableName tableName)
284 throws IOException {
285 return wrappedConnection.locateRegions(tableName);
286 }
287
288 @Override
289 public List<HRegionLocation> locateRegions(byte[] tableName)
290 throws IOException {
291 return wrappedConnection.locateRegions(tableName);
292 }
293
294 @Override
295 public List<HRegionLocation> locateRegions(TableName tableName,
296 boolean useCache, boolean offlined) throws IOException {
297 return wrappedConnection.locateRegions(tableName, useCache, offlined);
298 }
299
300 @Override
301 public List<HRegionLocation> locateRegions(byte[] tableName,
302 boolean useCache, boolean offlined) throws IOException {
303 return wrappedConnection.locateRegions(tableName, useCache, offlined);
304 }
305
306 @Override
307 public RegionLocations locateRegion(TableName tableName, byte[] row, boolean useCache,
308 boolean retry, int replicaId) throws IOException {
309 return wrappedConnection.locateRegion(tableName, row, useCache, retry, replicaId);
310 }
311
312 @Override
313 public RegionLocations relocateRegion(TableName tableName, byte[] row, int replicaId)
314 throws IOException {
315 return wrappedConnection.relocateRegion(tableName, row, replicaId);
316 }
317
318 @Override
319 public MasterService.BlockingInterface getMaster() throws IOException {
320 return wrappedConnection.getMaster();
321 }
322
323 @Override
324 public AdminService.BlockingInterface getAdmin(
325 ServerName serverName) throws IOException {
326 return wrappedConnection.getAdmin(serverName);
327 }
328
329 @Override
330 public ClientService.BlockingInterface getClient(
331 ServerName serverName) throws IOException {
332 return wrappedConnection.getClient(serverName);
333 }
334
335 @Override
336 public AdminService.BlockingInterface getAdmin(
337 ServerName serverName, boolean getMaster) throws IOException {
338 return wrappedConnection.getAdmin(serverName, getMaster);
339 }
340
341 @Override
342 public HRegionLocation getRegionLocation(TableName tableName, byte[] row,
343 boolean reload) throws IOException {
344 return wrappedConnection.getRegionLocation(tableName, row, reload);
345 }
346
347 @Override
348 public HRegionLocation getRegionLocation(byte[] tableName, byte[] row,
349 boolean reload) throws IOException {
350 return wrappedConnection.getRegionLocation(tableName, row, reload);
351 }
352
353 @Override
354 public void processBatch(List<? extends Row> actions, TableName tableName,
355 ExecutorService pool, Object[] results) throws IOException,
356 InterruptedException {
357 wrappedConnection.processBatch(actions, tableName, pool, results);
358 }
359
360 @Override
361 public void processBatch(List<? extends Row> actions, byte[] tableName,
362 ExecutorService pool, Object[] results) throws IOException,
363 InterruptedException {
364 wrappedConnection.processBatch(actions, tableName, pool, results);
365 }
366
367 @Override
368 public <R> void processBatchCallback(List<? extends Row> list,
369 TableName tableName, ExecutorService pool, Object[] results,
370 Callback<R> callback) throws IOException, InterruptedException {
371 wrappedConnection.processBatchCallback(list, tableName, pool, results, callback);
372 }
373
374 @Override
375 public <R> void processBatchCallback(List<? extends Row> list,
376 byte[] tableName, ExecutorService pool, Object[] results,
377 Callback<R> callback) throws IOException, InterruptedException {
378 wrappedConnection.processBatchCallback(list, tableName, pool, results, callback);
379 }
380
381 @Override
382 public void setRegionCachePrefetch(TableName tableName, boolean enable) {
383 wrappedConnection.setRegionCachePrefetch(tableName, enable);
384 }
385
386 @Override
387 public void setRegionCachePrefetch(byte[] tableName, boolean enable) {
388 wrappedConnection.setRegionCachePrefetch(tableName, enable);
389 }
390
391 @Override
392 public boolean getRegionCachePrefetch(TableName tableName) {
393 return wrappedConnection.getRegionCachePrefetch(tableName);
394 }
395
396 @Override
397 public boolean getRegionCachePrefetch(byte[] tableName) {
398 return wrappedConnection.getRegionCachePrefetch(tableName);
399 }
400
401 @Override
402 public int getCurrentNrHRS() throws IOException {
403 return wrappedConnection.getCurrentNrHRS();
404 }
405
406 @Override
407 public HTableDescriptor[] getHTableDescriptorsByTableName(
408 List<TableName> tableNames) throws IOException {
409 return wrappedConnection.getHTableDescriptorsByTableName(tableNames);
410 }
411
412 @Override
413 public HTableDescriptor[] getHTableDescriptors(List<String> tableNames)
414 throws IOException {
415 return wrappedConnection.getHTableDescriptors(tableNames);
416 }
417
418 @Override
419 public boolean isClosed() {
420 return wrappedConnection.isClosed();
421 }
422
423 @Override
424 public void clearCaches(ServerName sn) {
425 wrappedConnection.clearCaches(sn);
426 }
427
428 @Override
429 public MasterKeepAliveConnection getKeepAliveMasterService()
430 throws MasterNotRunningException {
431 return wrappedConnection.getKeepAliveMasterService();
432 }
433
434 @Override
435 public boolean isDeadServer(ServerName serverName) {
436 return wrappedConnection.isDeadServer(serverName);
437 }
438
439 @Override
440 public NonceGenerator getNonceGenerator() {
441 return wrappedConnection.getNonceGenerator();
442 }
443
444 @Override
445 public AsyncProcess getAsyncProcess() {
446 return wrappedConnection.getAsyncProcess();
447 }
448
449 @Override
450 public RpcRetryingCallerFactory getNewRpcRetryingCallerFactory(Configuration conf) {
451 return wrappedConnection.getNewRpcRetryingCallerFactory(conf);
452 }
453
454 @Override
455 public boolean isManaged() {
456 return wrappedConnection.isManaged();
457 }
458
459 @Override
460 public ServerStatisticTracker getStatisticsTracker() {
461 return wrappedConnection.getStatisticsTracker();
462 }
463
464 @Override
465 public ClientBackoffPolicy getBackoffPolicy() {
466 return wrappedConnection.getBackoffPolicy();
467 }
468 }