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.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   * An internal class that delegates to an {@link HConnection} instance.
43   * A convenience to override when customizing method implementations.
44   *
45   *
46   * @see ConnectionUtils#createShortCircuitHConnection(HConnection, ServerName,
47   * AdminService.BlockingInterface, ClientService.BlockingInterface) for case where we make
48   * Connections skip RPC if request is to local server.
49   */
50  @InterfaceAudience.Private
51  @SuppressWarnings("deprecation")
52  //NOTE: DO NOT make this class public. It was made package-private on purpose.
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 }