View Javadoc

1   /**
2    * Licensed to the Apache Software Foundation (ASF) under one
3    * or more contributor license agreements.  See the NOTICE file
4    * distributed with this work for additional information
5    * regarding copyright ownership.  The ASF licenses this file
6    * to you under the Apache License, Version 2.0 (the
7    * "License"); you may not use this file except in compliance
8    * with the License.  You may obtain a copy of the License at
9    *
10   *     http://www.apache.org/licenses/LICENSE-2.0
11   *
12   * Unless required by applicable law or agreed to in writing, software
13   * distributed under the License is distributed on an "AS IS" BASIS,
14   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15   * See the License for the specific language governing permissions and
16   * limitations under the License.
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   * An internal class that delegates to an {@link HConnection} instance.
42   * A convenience to override when customizing method implementations.
43   *
44   *
45   * @see ConnectionUtils#createShortCircuitHConnection(HConnection, ServerName,
46   * AdminService.BlockingInterface, ClientService.BlockingInterface) for case where we make
47   * Connections skip RPC if request is to local server.
48   */
49  @InterfaceAudience.Private
50  @Deprecated
51  //NOTE: DO NOT make this class public. It was made package-private on purpose.
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 }