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.conf.Configuration;
25 import org.apache.hadoop.hbase.HRegionLocation;
26 import org.apache.hadoop.hbase.HTableDescriptor;
27 import org.apache.hadoop.hbase.MasterNotRunningException;
28 import org.apache.hadoop.hbase.RegionLocations;
29 import org.apache.hadoop.hbase.ServerName;
30 import org.apache.hadoop.hbase.TableName;
31 import org.apache.hadoop.hbase.ZooKeeperConnectionException;
32 import org.apache.hadoop.hbase.classification.InterfaceAudience;
33 import org.apache.hadoop.hbase.client.backoff.ClientBackoffPolicy;
34 import org.apache.hadoop.hbase.client.coprocessor.Batch.Callback;
35 import org.apache.hadoop.hbase.protobuf.generated.AdminProtos.AdminService;
36 import org.apache.hadoop.hbase.protobuf.generated.ClientProtos.ClientService;
37 import org.apache.hadoop.hbase.protobuf.generated.MasterProtos.MasterService;
38 import org.apache.hadoop.hbase.ipc.RpcControllerFactory;
39
40
41
42
43
44
45
46
47
48
49 @InterfaceAudience.Private
50 @Deprecated
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 MetricsConnection getConnectionMetrics() {
136 return wrappedConnection.getConnectionMetrics();
137 }
138
139 @Override
140 public boolean isMasterRunning() throws MasterNotRunningException,
141 ZooKeeperConnectionException {
142 return wrappedConnection.isMasterRunning();
143 }
144
145 @Override
146 public boolean isTableEnabled(TableName tableName) throws IOException {
147 return wrappedConnection.isTableEnabled(tableName);
148 }
149
150 @Override
151 public boolean isTableEnabled(byte[] tableName) throws IOException {
152 return wrappedConnection.isTableEnabled(tableName);
153 }
154
155 @Override
156 public boolean isTableDisabled(TableName tableName) throws IOException {
157 return wrappedConnection.isTableDisabled(tableName);
158 }
159
160 @Override
161 public boolean isTableDisabled(byte[] tableName) throws IOException {
162 return wrappedConnection.isTableDisabled(tableName);
163 }
164
165 @Override
166 public boolean isTableAvailable(TableName tableName) throws IOException {
167 return wrappedConnection.isTableAvailable(tableName);
168 }
169
170 @Override
171 public boolean isTableAvailable(byte[] tableName) throws IOException {
172 return wrappedConnection.isTableAvailable(tableName);
173 }
174
175 @Override
176 public boolean isTableAvailable(TableName tableName, byte[][] splitKeys)
177 throws IOException {
178 return wrappedConnection.isTableAvailable(tableName, splitKeys);
179 }
180
181 @Override
182 public boolean isTableAvailable(byte[] tableName, byte[][] splitKeys)
183 throws IOException {
184 return wrappedConnection.isTableAvailable(tableName, splitKeys);
185 }
186
187 @Override
188 public HTableDescriptor[] listTables() throws IOException {
189 return wrappedConnection.listTables();
190 }
191
192 @Override
193 public String[] getTableNames() throws IOException {
194 return wrappedConnection.getTableNames();
195 }
196
197 @Override
198 public TableName[] listTableNames() throws IOException {
199 return wrappedConnection.listTableNames();
200 }
201
202 @Override
203 public HTableDescriptor getHTableDescriptor(TableName tableName)
204 throws IOException {
205 return wrappedConnection.getHTableDescriptor(tableName);
206 }
207
208 @Override
209 public HTableDescriptor getHTableDescriptor(byte[] tableName)
210 throws IOException {
211 return wrappedConnection.getHTableDescriptor(tableName);
212 }
213
214 @Override
215 public HRegionLocation locateRegion(TableName tableName, byte[] row)
216 throws IOException {
217 return wrappedConnection.locateRegion(tableName, row);
218 }
219
220 @Override
221 public HRegionLocation locateRegion(byte[] tableName, byte[] row)
222 throws IOException {
223 return wrappedConnection.locateRegion(tableName, row);
224 }
225
226 @Override
227 public RegionLocations locateRegion(TableName tableName, byte[] row, boolean useCache,
228 boolean retry) throws IOException {
229 return wrappedConnection.locateRegion(tableName, row, useCache, retry);
230 }
231
232 @Override
233 public void clearRegionCache() {
234 wrappedConnection.clearRegionCache();
235 }
236
237 @Override
238 public void clearRegionCache(TableName tableName) {
239 wrappedConnection.clearRegionCache(tableName);
240 }
241
242 @Override
243 public void clearRegionCache(byte[] tableName) {
244 wrappedConnection.clearRegionCache(tableName);
245 }
246
247 @Override
248 public void deleteCachedRegionLocation(HRegionLocation location) {
249 wrappedConnection.deleteCachedRegionLocation(location);
250 }
251
252 @Override
253 public HRegionLocation relocateRegion(TableName tableName, byte[] row)
254 throws IOException {
255 return wrappedConnection.relocateRegion(tableName, row);
256 }
257
258 @Override
259 public HRegionLocation relocateRegion(byte[] tableName, byte[] row)
260 throws IOException {
261 return wrappedConnection.relocateRegion(tableName, row);
262 }
263
264 @Override
265 public void updateCachedLocations(TableName tableName, byte[] rowkey,
266 Object exception, HRegionLocation source) {
267 wrappedConnection.updateCachedLocations(tableName, rowkey, exception, source);
268 }
269
270 @Override
271 public void updateCachedLocations(TableName tableName, byte[] regionName, byte[] rowkey,
272 Object exception, ServerName source) {
273 wrappedConnection.updateCachedLocations(tableName, regionName, rowkey, exception, source);
274 }
275
276 @Override
277 public void updateCachedLocations(byte[] tableName, byte[] rowkey,
278 Object exception, HRegionLocation source) {
279 wrappedConnection.updateCachedLocations(tableName, rowkey, exception, source);
280 }
281
282 @Override
283 public HRegionLocation locateRegion(byte[] regionName) throws IOException {
284 return wrappedConnection.locateRegion(regionName);
285 }
286
287 @Override
288 public List<HRegionLocation> locateRegions(TableName tableName)
289 throws IOException {
290 return wrappedConnection.locateRegions(tableName);
291 }
292
293 @Override
294 public List<HRegionLocation> locateRegions(byte[] tableName)
295 throws IOException {
296 return wrappedConnection.locateRegions(tableName);
297 }
298
299 @Override
300 public List<HRegionLocation> locateRegions(TableName tableName,
301 boolean useCache, boolean offlined) throws IOException {
302 return wrappedConnection.locateRegions(tableName, useCache, offlined);
303 }
304
305 @Override
306 public List<HRegionLocation> locateRegions(byte[] tableName,
307 boolean useCache, boolean offlined) throws IOException {
308 return wrappedConnection.locateRegions(tableName, useCache, offlined);
309 }
310
311 @Override
312 public RegionLocations locateRegion(TableName tableName, byte[] row, boolean useCache,
313 boolean retry, int replicaId) throws IOException {
314 return wrappedConnection.locateRegion(tableName, row, useCache, retry, replicaId);
315 }
316
317 @Override
318 public RegionLocations relocateRegion(TableName tableName, byte[] row, int replicaId)
319 throws IOException {
320 return wrappedConnection.relocateRegion(tableName, row, replicaId);
321 }
322
323 @Override
324 public MasterService.BlockingInterface getMaster() throws IOException {
325 return wrappedConnection.getMaster();
326 }
327
328 @Override
329 public AdminService.BlockingInterface getAdmin(
330 ServerName serverName) throws IOException {
331 return wrappedConnection.getAdmin(serverName);
332 }
333
334 @Override
335 public ClientService.BlockingInterface getClient(
336 ServerName serverName) throws IOException {
337 return wrappedConnection.getClient(serverName);
338 }
339
340 @Override
341 public AdminService.BlockingInterface getAdmin(
342 ServerName serverName, boolean getMaster) throws IOException {
343 return wrappedConnection.getAdmin(serverName, getMaster);
344 }
345
346 @Override
347 public HRegionLocation getRegionLocation(TableName tableName, byte[] row,
348 boolean reload) throws IOException {
349 return wrappedConnection.getRegionLocation(tableName, row, reload);
350 }
351
352 @Override
353 public HRegionLocation getRegionLocation(byte[] tableName, byte[] row,
354 boolean reload) throws IOException {
355 return wrappedConnection.getRegionLocation(tableName, row, reload);
356 }
357
358 @Override
359 public void processBatch(List<? extends Row> actions, TableName tableName,
360 ExecutorService pool, Object[] results) throws IOException,
361 InterruptedException {
362 wrappedConnection.processBatch(actions, tableName, pool, results);
363 }
364
365 @Override
366 public void processBatch(List<? extends Row> actions, byte[] tableName,
367 ExecutorService pool, Object[] results) throws IOException,
368 InterruptedException {
369 wrappedConnection.processBatch(actions, tableName, pool, results);
370 }
371
372 @Override
373 public <R> void processBatchCallback(List<? extends Row> list,
374 TableName tableName, ExecutorService pool, Object[] results,
375 Callback<R> callback) throws IOException, InterruptedException {
376 wrappedConnection.processBatchCallback(list, tableName, pool, results, callback);
377 }
378
379 @Override
380 public <R> void processBatchCallback(List<? extends Row> list,
381 byte[] tableName, ExecutorService pool, Object[] results,
382 Callback<R> callback) throws IOException, InterruptedException {
383 wrappedConnection.processBatchCallback(list, tableName, pool, results, callback);
384 }
385
386 @Override
387 public void setRegionCachePrefetch(TableName tableName, boolean enable) {
388 wrappedConnection.setRegionCachePrefetch(tableName, enable);
389 }
390
391 @Override
392 public void setRegionCachePrefetch(byte[] tableName, boolean enable) {
393 wrappedConnection.setRegionCachePrefetch(tableName, enable);
394 }
395
396 @Override
397 public boolean getRegionCachePrefetch(TableName tableName) {
398 return wrappedConnection.getRegionCachePrefetch(tableName);
399 }
400
401 @Override
402 public boolean getRegionCachePrefetch(byte[] tableName) {
403 return wrappedConnection.getRegionCachePrefetch(tableName);
404 }
405
406 @Override
407 public int getCurrentNrHRS() throws IOException {
408 return wrappedConnection.getCurrentNrHRS();
409 }
410
411 @Override
412 public HTableDescriptor[] getHTableDescriptorsByTableName(
413 List<TableName> tableNames) throws IOException {
414 return wrappedConnection.getHTableDescriptorsByTableName(tableNames);
415 }
416
417 @Override
418 public HTableDescriptor[] getHTableDescriptors(List<String> tableNames)
419 throws IOException {
420 return wrappedConnection.getHTableDescriptors(tableNames);
421 }
422
423 @Override
424 public boolean isClosed() {
425 return wrappedConnection.isClosed();
426 }
427
428 @Override
429 public void clearCaches(ServerName sn) {
430 wrappedConnection.clearCaches(sn);
431 }
432
433 @Override
434 public MasterKeepAliveConnection getKeepAliveMasterService()
435 throws MasterNotRunningException {
436 return wrappedConnection.getKeepAliveMasterService();
437 }
438
439 @Override
440 public boolean isDeadServer(ServerName serverName) {
441 return wrappedConnection.isDeadServer(serverName);
442 }
443
444 @Override
445 public NonceGenerator getNonceGenerator() {
446 return wrappedConnection.getNonceGenerator();
447 }
448
449 @Override
450 public AsyncProcess getAsyncProcess() {
451 return wrappedConnection.getAsyncProcess();
452 }
453
454 @Override
455 public RpcRetryingCallerFactory getNewRpcRetryingCallerFactory(Configuration conf) {
456 return wrappedConnection.getNewRpcRetryingCallerFactory(conf);
457 }
458
459 @Override
460 public boolean isManaged() {
461 return wrappedConnection.isManaged();
462 }
463
464 @Override
465 public ServerStatisticTracker getStatisticsTracker() {
466 return wrappedConnection.getStatisticsTracker();
467 }
468
469 @Override
470 public ClientBackoffPolicy getBackoffPolicy() {
471 return wrappedConnection.getBackoffPolicy();
472 }
473
474 @Override
475 public boolean hasCellBlockSupport() {
476 return wrappedConnection.hasCellBlockSupport();
477 }
478
479 @Override
480 public ConnectionConfiguration getConnectionConfiguration() {
481 return wrappedConnection.getConnectionConfiguration();
482 }
483
484 @Override
485 public RpcRetryingCallerFactory getRpcRetryingCallerFactory() {
486 return wrappedConnection.getRpcRetryingCallerFactory();
487 }
488
489 @Override
490 public RpcControllerFactory getRpcControllerFactory() {
491 return wrappedConnection.getRpcControllerFactory();
492 }
493 }