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