Java tutorial
/* * Copyright 2018 NAVER Corp. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package com.navercorp.pinpoint.common.hbase; import com.google.common.collect.Lists; import com.navercorp.pinpoint.common.hbase.parallel.ParallelResultScanner; import com.navercorp.pinpoint.common.hbase.parallel.ScanTaskException; import com.navercorp.pinpoint.common.util.ExecutorFactory; import com.navercorp.pinpoint.common.util.PinpointThreadFactory; import com.navercorp.pinpoint.common.util.StopWatch; import com.sematext.hbase.wd.AbstractRowKeyDistributor; import com.sematext.hbase.wd.DistributedScanner; import org.apache.hadoop.conf.Configuration; import org.apache.hadoop.hbase.TableName; import org.apache.hadoop.hbase.client.Delete; import org.apache.hadoop.hbase.client.Durability; import org.apache.hadoop.hbase.client.Get; import org.apache.hadoop.hbase.client.Increment; import org.apache.hadoop.hbase.client.Put; import org.apache.hadoop.hbase.client.Result; import org.apache.hadoop.hbase.client.ResultScanner; import org.apache.hadoop.hbase.client.Scan; import org.apache.hadoop.hbase.client.Table; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.beans.factory.DisposableBean; import org.springframework.beans.factory.InitializingBean; import org.springframework.util.Assert; import java.io.IOException; import java.util.ArrayList; import java.util.Collections; import java.util.List; import java.util.concurrent.Callable; import java.util.concurrent.ExecutionException; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.Future; import java.util.concurrent.TimeUnit; import java.util.concurrent.atomic.AtomicBoolean; /** * @author emeroad * @author HyunGil Jeong * @author minwoo.jung */ public class HbaseTemplate2 extends HbaseAccessor implements HbaseOperations2, InitializingBean, DisposableBean { private static final int DEFAULT_MAX_THREADS_FOR_PARALLEL_SCANNER = 128; private static final int DEFAULT_MAX_THREADS_PER_PARALLEL_SCAN = 1; private static final long DEFAULT_DESTORY_TIMEOUT = 2000; private final Logger logger = LoggerFactory.getLogger(this.getClass()); private final boolean debugEnabled = this.logger.isDebugEnabled(); private final AtomicBoolean isClose = new AtomicBoolean(false); private ExecutorService executor; private boolean enableParallelScan = false; private int maxThreads = DEFAULT_MAX_THREADS_FOR_PARALLEL_SCANNER; private int maxThreadsPerParallelScan = DEFAULT_MAX_THREADS_PER_PARALLEL_SCAN; private HBaseAsyncOperation asyncOperation = DisabledHBaseAsyncOperation.INSTANCE; public HbaseTemplate2() { } private Table getTable(TableName tableName) { return getTableFactory().getTable(tableName); } public void setEnableParallelScan(boolean enableParallelScan) { this.enableParallelScan = enableParallelScan; } public void setMaxThreads(int maxThreads) { this.maxThreads = maxThreads; } public void setMaxThreadsPerParallelScan(int maxThreadsPerParallelScan) { this.maxThreadsPerParallelScan = maxThreadsPerParallelScan; } public void setAsyncOperation(HBaseAsyncOperation asyncOperation) { if (asyncOperation == null) { throw new NullPointerException("asyncOperation"); } this.asyncOperation = asyncOperation; } @Override public void afterPropertiesSet() { Configuration configuration = getConfiguration(); Assert.notNull(configuration, "configuration is required"); Assert.notNull(getTableFactory(), "tableFactory is required"); PinpointThreadFactory parallelScannerThreadFactory = new PinpointThreadFactory("Pinpoint-parallel-scanner", true); if (this.maxThreadsPerParallelScan <= 1) { this.enableParallelScan = false; this.executor = Executors.newSingleThreadExecutor(parallelScannerThreadFactory); } else { this.executor = ExecutorFactory.newFixedThreadPool(this.maxThreads, 1024, parallelScannerThreadFactory); } } @Override public void destroy() throws Exception { StopWatch stopWatch = new StopWatch(); stopWatch.start(); if (isClose.compareAndSet(false, true)) { logger.info("HBaseTemplate2.destroy()"); final ExecutorService executor = this.executor; if (executor != null) { executor.shutdown(); try { executor.awaitTermination(DEFAULT_DESTORY_TIMEOUT, TimeUnit.MILLISECONDS); } catch (InterruptedException e) { Thread.currentThread().interrupt(); } } long remainingTime = Math.max(DEFAULT_DESTORY_TIMEOUT - stopWatch.stop(), 100); awaitAsyncPutOpsCleared(remainingTime, 50); } } private boolean awaitAsyncPutOpsCleared(long waitTimeout, long checkUnitTime) { StopWatch stopWatch = new StopWatch(); stopWatch.start(); while (true) { Long currentPutOpsCount = asyncOperation.getCurrentOpsCount(); if (logger.isWarnEnabled()) { logger.warn("count {}", currentPutOpsCount); } if (currentPutOpsCount <= 0L) { return true; } if (stopWatch.stop() > waitTimeout) { return false; } try { Thread.sleep(checkUnitTime); } catch (InterruptedException e) { // ignore } } } private void assertAccessAvailable() { if (isClose.get()) { throw new HBaseAccessException("Already closed."); } } @Override public <T> T find(TableName tableName, String family, final ResultsExtractor<T> action) { Scan scan = new Scan(); scan.addFamily(family.getBytes(getCharset())); return find(tableName, scan, action); } @Override public <T> T find(TableName tableName, String family, String qualifier, final ResultsExtractor<T> action) { Scan scan = new Scan(); scan.addColumn(family.getBytes(getCharset()), qualifier.getBytes(getCharset())); return find(tableName, scan, action); } @Override public <T> T find(TableName tableName, final Scan scan, final ResultsExtractor<T> action) { assertAccessAvailable(); return execute(tableName, new TableCallback<T>() { @Override public T doInTable(Table table) throws Throwable { final ResultScanner scanner = table.getScanner(scan); try { return action.extractData(scanner); } finally { scanner.close(); } } }); } @Override public <T> List<T> find(TableName tableName, String family, final RowMapper<T> action) { Scan scan = new Scan(); scan.addFamily(family.getBytes(getCharset())); return find(tableName, scan, action); } @Override public <T> List<T> find(TableName tableName, String family, String qualifier, final RowMapper<T> action) { Scan scan = new Scan(); scan.addColumn(family.getBytes(getCharset()), qualifier.getBytes(getCharset())); return find(tableName, scan, action); } @Override public <T> List<T> find(TableName tableName, final Scan scan, final RowMapper<T> action) { return find(tableName, scan, new RowMapperResultsExtractor<>(action)); } @Override public <T> T get(TableName tableName, String rowName, final RowMapper<T> mapper) { return get(tableName, rowName, null, null, mapper); } @Override public <T> T get(TableName tableName, String rowName, String familyName, final RowMapper<T> mapper) { return get(tableName, rowName, familyName, null, mapper); } @Override public <T> T get(TableName tableName, final String rowName, final String familyName, final String qualifier, final RowMapper<T> mapper) { assertAccessAvailable(); return execute(tableName, new TableCallback<T>() { @Override public T doInTable(Table table) throws Throwable { Get get = new Get(rowName.getBytes(getCharset())); if (familyName != null) { byte[] family = familyName.getBytes(getCharset()); if (qualifier != null) { get.addColumn(family, qualifier.getBytes(getCharset())); } else { get.addFamily(family); } } Result result = table.get(get); return mapper.mapRow(result, 0); } }); } @Override public <T> T get(TableName tableName, byte[] rowName, RowMapper<T> mapper) { return get(tableName, rowName, null, null, mapper); } @Override public <T> T get(TableName tableName, byte[] rowName, byte[] familyName, RowMapper<T> mapper) { return get(tableName, rowName, familyName, null, mapper); } @Override public <T> T get(TableName tableName, final byte[] rowName, final byte[] familyName, final byte[] qualifier, final RowMapper<T> mapper) { assertAccessAvailable(); return execute(tableName, new TableCallback<T>() { @Override public T doInTable(Table table) throws Throwable { Get get = new Get(rowName); if (familyName != null) { if (qualifier != null) { get.addColumn(familyName, qualifier); } else { get.addFamily(familyName); } } Result result = table.get(get); return mapper.mapRow(result, 0); } }); } @Override public <T> T get(TableName tableName, final Get get, final RowMapper<T> mapper) { assertAccessAvailable(); return execute(tableName, new TableCallback<T>() { @Override public T doInTable(Table table) throws Throwable { Result result = table.get(get); return mapper.mapRow(result, 0); } }); } @Override public <T> List<T> get(TableName tableName, final List<Get> getList, final RowMapper<T> mapper) { assertAccessAvailable(); return execute(tableName, new TableCallback<List<T>>() { @Override public List<T> doInTable(Table table) throws Throwable { Result[] result = table.get(getList); List<T> list = new ArrayList<>(result.length); for (int i = 0; i < result.length; i++) { T t = mapper.mapRow(result[i], i); list.add(t); } return list; } }); } @Override public void put(TableName tableName, final byte[] rowName, final byte[] familyName, final byte[] qualifier, final byte[] value) { put(tableName, rowName, familyName, qualifier, null, value); } @Override public void put(TableName tableName, final byte[] rowName, final byte[] familyName, final byte[] qualifier, final Long timestamp, final byte[] value) { assertAccessAvailable(); execute(tableName, new TableCallback() { @Override public Object doInTable(Table table) throws Throwable { Put put = createPut(rowName, familyName, timestamp, qualifier, value); table.put(put); return null; } }); } @Override public <T> void put(TableName tableName, final byte[] rowName, final byte[] familyName, final byte[] qualifier, final T value, final ValueMapper<T> mapper) { put(tableName, rowName, familyName, qualifier, null, value, mapper); } @Override public <T> void put(TableName tableName, final byte[] rowName, final byte[] familyName, final byte[] qualifier, final Long timestamp, final T value, final ValueMapper<T> mapper) { assertAccessAvailable(); execute(tableName, new TableCallback<T>() { @Override public T doInTable(Table table) throws Throwable { byte[] bytes = mapper.mapValue(value); Put put = createPut(rowName, familyName, timestamp, qualifier, bytes); table.put(put); return null; } }); } @Override public void put(TableName tableName, final Put put) { assertAccessAvailable(); execute(tableName, new TableCallback() { @Override public Object doInTable(Table table) throws Throwable { table.put(put); return null; } }); } @Override public void put(TableName tableName, final List<Put> puts) { assertAccessAvailable(); execute(tableName, new TableCallback() { @Override public Object doInTable(Table table) throws Throwable { table.put(puts); return null; } }); } @Override public boolean asyncPut(TableName tableName, byte[] rowName, byte[] familyName, byte[] qualifier, byte[] value) { return asyncPut(tableName, rowName, familyName, qualifier, null, value); } @Override public boolean asyncPut(TableName tableName, byte[] rowName, byte[] familyName, byte[] qualifier, Long timestamp, byte[] value) { Put put = createPut(rowName, familyName, timestamp, qualifier, value); return asyncPut(tableName, put); } @Override public <T> boolean asyncPut(TableName tableName, byte[] rowName, byte[] familyName, byte[] qualifier, T value, ValueMapper<T> mapper) { return asyncPut(tableName, rowName, familyName, qualifier, null, value, mapper); } @Override public <T> boolean asyncPut(TableName tableName, byte[] rowName, byte[] familyName, byte[] qualifier, Long timestamp, T value, ValueMapper<T> mapper) { byte[] bytes = mapper.mapValue(value); Put put = createPut(rowName, familyName, timestamp, qualifier, bytes); return asyncPut(tableName, put); } @Override public boolean asyncPut(TableName tableName, Put put) { assertAccessAvailable(); if (asyncOperation.isAvailable()) { return asyncOperation.put(tableName, put); } else { put(tableName, put); return true; } } @Override public List<Put> asyncPut(TableName tableName, List<Put> puts) { assertAccessAvailable(); if (asyncOperation.isAvailable()) { return asyncOperation.put(tableName, puts); } else { put(tableName, puts); return Collections.emptyList(); } } private Put createPut(byte[] rowName, byte[] familyName, Long timestamp, byte[] qualifier, byte[] value) { Put put = new Put(rowName); if (familyName != null) { if (timestamp == null) { put.addColumn(familyName, qualifier, value); } else { put.addColumn(familyName, qualifier, timestamp, value); } } return put; } @Override public void delete(TableName tableName, final Delete delete) { assertAccessAvailable(); execute(tableName, new TableCallback() { @Override public Object doInTable(Table table) throws Throwable { table.delete(delete); return null; } }); } @Override public void delete(TableName tableName, final List<Delete> deletes) { assertAccessAvailable(); execute(tableName, new TableCallback() { @Override public Object doInTable(Table table) throws Throwable { table.delete(deletes); return null; } }); } @Override public <T> List<T> find(TableName tableName, final List<Scan> scanList, final ResultsExtractor<T> action) { assertAccessAvailable(); return execute(tableName, new TableCallback<List<T>>() { @Override public List<T> doInTable(Table table) throws Throwable { List<T> result = new ArrayList<>(scanList.size()); for (Scan scan : scanList) { final ResultScanner scanner = table.getScanner(scan); try { T t = action.extractData(scanner); result.add(t); } finally { scanner.close(); } } return result; } }); } @Override public <T> List<List<T>> find(TableName tableName, List<Scan> scanList, RowMapper<T> action) { return find(tableName, scanList, new RowMapperResultsExtractor<>(action)); } @Override public <T> List<T> findParallel(final TableName tableName, final List<Scan> scans, final ResultsExtractor<T> action) { assertAccessAvailable(); if (!this.enableParallelScan || scans.size() == 1) { return find(tableName, scans, action); } List<T> results = new ArrayList<>(scans.size()); List<Callable<T>> callables = new ArrayList<>(scans.size()); for (final Scan scan : scans) { callables.add(new Callable<T>() { @Override public T call() throws Exception { return execute(tableName, new TableCallback<T>() { @Override public T doInTable(Table table) throws Throwable { final ResultScanner scanner = table.getScanner(scan); try { return action.extractData(scanner); } finally { scanner.close(); } } }); } }); } List<List<Callable<T>>> callablePartitions = Lists.partition(callables, this.maxThreadsPerParallelScan); for (List<Callable<T>> callablePartition : callablePartitions) { try { List<Future<T>> futures = this.executor.invokeAll(callablePartition); for (Future<T> future : futures) { results.add(future.get()); } } catch (InterruptedException e) { Thread.currentThread().interrupt(); logger.warn("interrupted while findParallel [{}].", tableName); return Collections.emptyList(); } catch (ExecutionException e) { logger.warn("findParallel [{}], error : {}", tableName, e); return Collections.emptyList(); } } return results; } @Override public <T> List<List<T>> findParallel(TableName tableName, final List<Scan> scans, final RowMapper<T> action) { return findParallel(tableName, scans, new RowMapperResultsExtractor<>(action)); } @Override public <T> List<T> find(TableName tableName, final Scan scan, final AbstractRowKeyDistributor rowKeyDistributor, final RowMapper<T> action) { final ResultsExtractor<List<T>> resultsExtractor = new RowMapperResultsExtractor<>(action); return executeDistributedScan(tableName, scan, rowKeyDistributor, resultsExtractor); } @Override public <T> List<T> find(TableName tableName, final Scan scan, final AbstractRowKeyDistributor rowKeyDistributor, final int limit, final RowMapper<T> action) { final ResultsExtractor<List<T>> resultsExtractor = new LimitRowMapperResultsExtractor<>(action, limit); return executeDistributedScan(tableName, scan, rowKeyDistributor, resultsExtractor); } @Override public <T> List<T> find(TableName tableName, final Scan scan, final AbstractRowKeyDistributor rowKeyDistributor, int limit, final RowMapper<T> action, final LimitEventHandler limitEventHandler) { final LimitRowMapperResultsExtractor<T> resultsExtractor = new LimitRowMapperResultsExtractor<>(action, limit, limitEventHandler); return executeDistributedScan(tableName, scan, rowKeyDistributor, resultsExtractor); } @Override public <T> T find(TableName tableName, final Scan scan, final AbstractRowKeyDistributor rowKeyDistributor, final ResultsExtractor<T> action) { return executeDistributedScan(tableName, scan, rowKeyDistributor, action); } protected final <T> T executeDistributedScan(TableName tableName, final Scan scan, final AbstractRowKeyDistributor rowKeyDistributor, final ResultsExtractor<T> action) { assertAccessAvailable(); return execute(tableName, new TableCallback<T>() { @Override public T doInTable(Table table) throws Throwable { StopWatch watch = null; if (debugEnabled) { watch = new StopWatch(); watch.start(); } final ResultScanner[] splitScanners = splitScan(table, scan, rowKeyDistributor); final ResultScanner scanner = new DistributedScanner(rowKeyDistributor, splitScanners); if (debugEnabled) { logger.debug("DistributedScanner createTime: {}ms", watch.stop()); watch.start(); } try { return action.extractData(scanner); } finally { scanner.close(); if (debugEnabled) { logger.debug("DistributedScanner scanTime: {}ms", watch.stop()); } } } }); } private ResultScanner[] splitScan(Table table, Scan originalScan, AbstractRowKeyDistributor rowKeyDistributor) throws IOException { Scan[] scans = rowKeyDistributor.getDistributedScans(originalScan); final int length = scans.length; for (int i = 0; i < length; i++) { Scan scan = scans[i]; // other properties are already set upon construction scan.setId(scan.getId() + "-" + i); } ResultScanner[] scanners = new ResultScanner[length]; boolean success = false; try { for (int i = 0; i < length; i++) { scanners[i] = table.getScanner(scans[i]); } success = true; } finally { if (!success) { closeScanner(scanners); } } return scanners; } private void closeScanner(ResultScanner[] scannerList) { for (ResultScanner scanner : scannerList) { if (scanner != null) { try { scanner.close(); } catch (Exception e) { logger.warn("Scanner.close() error Caused:{}", e.getMessage(), e); } } } } @Override public <T> List<T> findParallel(TableName tableName, Scan scan, AbstractRowKeyDistributor rowKeyDistributor, RowMapper<T> action, int numParallelThreads) { if (!this.enableParallelScan || numParallelThreads <= 1) { // use DistributedScanner if parallel scan is disabled or if called to use a single thread return find(tableName, scan, rowKeyDistributor, action); } else { int numThreadsUsed = numParallelThreads < this.maxThreadsPerParallelScan ? numParallelThreads : this.maxThreadsPerParallelScan; final ResultsExtractor<List<T>> resultsExtractor = new RowMapperResultsExtractor<>(action); return executeParallelDistributedScan(tableName, scan, rowKeyDistributor, resultsExtractor, numThreadsUsed); } } @Override public <T> List<T> findParallel(TableName tableName, Scan scan, AbstractRowKeyDistributor rowKeyDistributor, int limit, RowMapper<T> action, int numParallelThreads) { if (!this.enableParallelScan || numParallelThreads <= 1) { // use DistributedScanner if parallel scan is disabled or if called to use a single thread return find(tableName, scan, rowKeyDistributor, limit, action); } else { int numThreadsUsed = numParallelThreads < this.maxThreadsPerParallelScan ? numParallelThreads : this.maxThreadsPerParallelScan; final ResultsExtractor<List<T>> resultsExtractor = new LimitRowMapperResultsExtractor<>(action, limit); return executeParallelDistributedScan(tableName, scan, rowKeyDistributor, resultsExtractor, numThreadsUsed); } } @Override public <T> List<T> findParallel(TableName tableName, Scan scan, AbstractRowKeyDistributor rowKeyDistributor, int limit, RowMapper<T> action, LimitEventHandler limitEventHandler, int numParallelThreads) { if (!this.enableParallelScan || numParallelThreads <= 1) { // use DistributedScanner if parallel scan is disabled or if called to use a single thread return find(tableName, scan, rowKeyDistributor, limit, action, limitEventHandler); } else { int numThreadsUsed = numParallelThreads < this.maxThreadsPerParallelScan ? numParallelThreads : this.maxThreadsPerParallelScan; final LimitRowMapperResultsExtractor<T> resultsExtractor = new LimitRowMapperResultsExtractor<>(action, limit, limitEventHandler); return executeParallelDistributedScan(tableName, scan, rowKeyDistributor, resultsExtractor, numThreadsUsed); } } @Override public <T> T findParallel(TableName tableName, Scan scan, AbstractRowKeyDistributor rowKeyDistributor, ResultsExtractor<T> action, int numParallelThreads) { if (!this.enableParallelScan || numParallelThreads <= 1) { // use DistributedScanner if parallel scan is disabled or if called to use a single thread return find(tableName, scan, rowKeyDistributor, action); } else { int numThreadsUsed = numParallelThreads < this.maxThreadsPerParallelScan ? numParallelThreads : this.maxThreadsPerParallelScan; return executeParallelDistributedScan(tableName, scan, rowKeyDistributor, action, numThreadsUsed); } } protected final <T> T executeParallelDistributedScan(TableName tableName, Scan scan, AbstractRowKeyDistributor rowKeyDistributor, ResultsExtractor<T> action, int numParallelThreads) { assertAccessAvailable(); try { StopWatch watch = null; if (debugEnabled) { watch = new StopWatch(); watch.start(); } ParallelResultScanner scanner = new ParallelResultScanner(tableName, this, this.executor, scan, rowKeyDistributor, numParallelThreads); if (debugEnabled) { logger.debug("ParallelDistributedScanner createTime: {}ms", watch.stop()); watch.start(); } try { return action.extractData(scanner); } finally { scanner.close(); if (debugEnabled) { logger.debug("ParallelDistributedScanner scanTime: {}ms", watch.stop()); } } } catch (Throwable th) { Throwable throwable = th; if (th instanceof ScanTaskException) { throwable = th.getCause(); } if (throwable instanceof Error) { throw ((Error) th); } if (throwable instanceof RuntimeException) { throw ((RuntimeException) th); } throw new HbaseSystemException((Exception) throwable); } } @Override public Result increment(TableName tableName, final Increment increment) { assertAccessAvailable(); return execute(tableName, new TableCallback<Result>() { @Override public Result doInTable(Table table) throws Throwable { return table.increment(increment); } }); } @Override public List<Result> increment(final TableName tableName, final List<Increment> incrementList) { assertAccessAvailable(); return execute(tableName, new TableCallback<List<Result>>() { @Override public List<Result> doInTable(Table table) throws Throwable { final List<Result> resultList = new ArrayList<>(incrementList.size()); Exception lastException = null; for (Increment increment : incrementList) { try { Result result = table.increment(increment); resultList.add(result); } catch (IOException e) { logger.warn("{} increment error Caused:{}", tableName, e.getMessage(), e); lastException = e; } } if (lastException != null) { throw lastException; } return resultList; } }); } @Override public long incrementColumnValue(TableName tableName, final byte[] rowName, final byte[] familyName, final byte[] qualifier, final long amount) { assertAccessAvailable(); return execute(tableName, new TableCallback<Long>() { @Override public Long doInTable(Table table) throws Throwable { return table.incrementColumnValue(rowName, familyName, qualifier, amount); } }); } @Override public long incrementColumnValue(TableName tableName, final byte[] rowName, final byte[] familyName, final byte[] qualifier, final long amount, final boolean writeToWAL) { assertAccessAvailable(); return execute(tableName, new TableCallback<Long>() { @Override public Long doInTable(Table table) throws Throwable { return table.incrementColumnValue(rowName, familyName, qualifier, amount, writeToWAL ? Durability.SKIP_WAL : Durability.USE_DEFAULT); } }); } @Override public <T> T execute(TableName tableName, TableCallback<T> action) { Assert.notNull(action, "Callback object must not be null"); Assert.notNull(tableName, "No table specified"); assertAccessAvailable(); Table table = getTable(tableName); try { T result = action.doInTable(table); return result; } catch (Throwable e) { if (e instanceof Error) { throw ((Error) e); } if (e instanceof RuntimeException) { throw ((RuntimeException) e); } throw new HbaseSystemException((Exception) e); } finally { releaseTable(table); } } private void releaseTable(Table table) { getTableFactory().releaseTable(table); } }