/*
* Copyright © 2012-2014 Cask Data, Inc.
*
* 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 co.cask.tephra.distributed;
import co.cask.tephra.InvalidTruncateTimeException;
import co.cask.tephra.Transaction;
import co.cask.tephra.TransactionCouldNotTakeSnapshotException;
import co.cask.tephra.TransactionNotInProgressException;
import co.cask.tephra.TransactionSystemClient;
import co.cask.tephra.TxConstants;
import co.cask.tephra.distributed.thrift.TInvalidTruncateTimeException;
import co.cask.tephra.distributed.thrift.TTransactionCouldNotTakeSnapshotException;
import co.cask.tephra.distributed.thrift.TTransactionNotInProgressException;
import co.cask.tephra.runtime.ConfigModule;
import co.cask.tephra.runtime.DiscoveryModules;
import co.cask.tephra.runtime.TransactionClientModule;
import co.cask.tephra.runtime.TransactionModules;
import co.cask.tephra.runtime.ZKModule;
import co.cask.tephra.util.ConfigurationFactory;
import com.google.common.annotations.VisibleForTesting;
import com.google.common.base.Throwables;
import com.google.inject.Guice;
import com.google.inject.Inject;
import com.google.inject.Injector;
import org.apache.hadoop.conf.Configuration;
import org.apache.thrift.TException;
import org.apache.twill.zookeeper.ZKClientService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.io.InputStream;
import java.util.Collection;
import java.util.Collections;
import java.util.Set;
/**
* A tx service client
*/
public class TransactionServiceClient implements TransactionSystemClient {
private static final Logger LOG =
LoggerFactory.getLogger(TransactionServiceClient.class);
// we will use this to provide every call with an tx client
private ThriftClientProvider clientProvider;
// the retry strategy we will use
private final RetryStrategyProvider retryStrategyProvider;
/**
* Utility to be used for basic verification of transaction system availability and functioning
* @param args arguments list, accepts single option "-v" that makes it to print out more details about started tx
* @throws Exception
*/
public static void main(String[] args) throws Exception {
if (args.length > 1 || (args.length == 1 && !"-v".equals(args[0]))) {
System.out.println("USAGE: TransactionServiceClient [-v]");
}
boolean verbose = false;
if (args.length == 1 && "-v".equals(args[0])) {
verbose = true;
}
doMain(verbose, new ConfigurationFactory().get());
}
@VisibleForTesting
public static void doMain(boolean verbose, Configuration conf) throws Exception {
LOG.info("Starting tx server client test.");
Injector injector = Guice.createInjector(
new ConfigModule(conf),
new ZKModule(),
new DiscoveryModules().getDistributedModules(),
new TransactionModules().getDistributedModules(),
new TransactionClientModule()
);
ZKClientService zkClient = injector.getInstance(ZKClientService.class);
zkClient.startAndWait();
try {
TransactionServiceClient client = injector.getInstance(TransactionServiceClient.class);
LOG.info("Starting tx...");
Transaction tx = client.startShort();
if (verbose) {
LOG.info("Started tx details: " + tx.toString());
} else {
LOG.info("Started tx: " + tx.getTransactionId() +
", readPointer: " + tx.getReadPointer() +
", invalids: " + tx.getInvalids().length +
", inProgress: " + tx.getInProgress().length);
}
LOG.info("Checking if canCommit tx...");
boolean canCommit = client.canCommit(tx, Collections.<byte[]>emptyList());
LOG.info("canCommit: " + canCommit);
if (canCommit) {
LOG.info("Committing tx...");
boolean committed = client.commit(tx);
LOG.info("Committed tx: " + committed);
if (!committed) {
LOG.info("Aborting tx...");
client.abort(tx);
LOG.info("Aborted tx...");
}
} else {
LOG.info("Aborting tx...");
client.abort(tx);
LOG.info("Aborted tx...");
}
} finally {
zkClient.stopAndWait();
}
}
/**
* Create from a configuration. This will first attempt to find a zookeeper
* for service discovery. Otherwise it will look for the port in the
* config and use localhost.
* @param config a configuration containing the zookeeper properties
*/
@Inject
public TransactionServiceClient(Configuration config,
ThriftClientProvider clientProvider) {
// initialize the retry logic
String retryStrat = config.get(
TxConstants.Service.CFG_DATA_TX_CLIENT_RETRY_STRATEGY,
TxConstants.Service.DEFAULT_DATA_TX_CLIENT_RETRY_STRATEGY);
if ("backoff".equals(retryStrat)) {
this.retryStrategyProvider = new RetryWithBackoff.Provider();
} else if ("n-times".equals(retryStrat)) {
this.retryStrategyProvider = new RetryNTimes.Provider();
} else {
String message = "Unknown Retry Strategy '" + retryStrat + "'.";
LOG.error(message);
throw new IllegalArgumentException(message);
}
this.retryStrategyProvider.configure(config);
LOG.debug("Retry strategy is " + this.retryStrategyProvider);
this.clientProvider = clientProvider;
}
/**
* This is an abstract class that encapsulates an operation. It provides a
* method to attempt the actual operation, and it can throw an operation
* exception.
* @param <T> The return type of the operation
*/
abstract static class Operation<T> {
/** the name of the operation. */
String name;
/** constructor with name of operation. */
Operation(String name) {
this.name = name;
}
/** return the name of the operation. */
String getName() {
return name;
}
/** execute the operation, given an tx client. */
abstract T execute(TransactionServiceThriftClient client)
throws Exception;
}
/** see execute(operation, client). */
private <T> T execute(Operation<T> operation) throws Exception {
return execute(operation, null);
}
/**
* This is a generic method implementing the somewhat complex execution
* and retry logic for operations, to avoid repetitive code.
*
* Attempts to execute one operation, by obtaining an tx client from
* the client provider and passing the operation to the client. If the
* call fails with a Thrift exception, apply the retry strategy. If no
* more retries are to be made according to the strategy, call the
* operation's error method to obtain a value to return. Note that error()
* may also throw an exception. Note also that the retry logic is only
* applied for thrift exceptions.
*
* @param operation The operation to be executed
* @param provider An tx client provider. If null, then a client will be
* obtained using the client provider
* @param <T> The return type of the operation
* @return the result of the operation, or a value returned by error()
*/
private <T> T execute(Operation<T> operation, ThriftClientProvider provider) throws Exception {
RetryStrategy retryStrategy = retryStrategyProvider.newRetryStrategy();
while (true) {
// did we get a custom client provider or do we use the default?
if (provider == null) {
provider = this.clientProvider;
}
// this will throw a TException if it cannot get a client
try (CloseableThriftClient closeable = provider.getCloseableClient()) {
// note that this can throw exceptions other than TException
return operation.execute(closeable.getThriftClient());
} catch (TException te) {
// determine whether we should retry
boolean retry = retryStrategy.failOnce();
if (!retry) {
// retry strategy is exceeded, throw an operation exception
String message =
"Thrift error for " + operation + ": " + te.getMessage();
LOG.error(message);
LOG.debug(message, te);
throw new Exception(message, te);
} else {
// call retry strategy before retrying
retryStrategy.beforeRetry();
String msg = "Retrying " + operation.getName() + " after Thrift error: " + te.getMessage();
LOG.info(msg);
LOG.debug(msg, te);
}
}
}
}
@Override
public Transaction startLong() {
try {
return execute(
new Operation<Transaction>("startLong") {
@Override
public Transaction execute(TransactionServiceThriftClient client)
throws TException {
return client.startLong();
}
});
} catch (Exception e) {
throw Throwables.propagate(e);
}
}
@Override
public Transaction startShort() {
try {
return execute(
new Operation<Transaction>("startShort") {
@Override
public Transaction execute(TransactionServiceThriftClient client)
throws TException {
return client.startShort();
}
});
} catch (Exception e) {
throw Throwables.propagate(e);
}
}
@Override
public Transaction startShort(final int timeout) {
try {
return execute(
new Operation<Transaction>("startShort") {
@Override
public Transaction execute(TransactionServiceThriftClient client)
throws TException {
return client.startShort(timeout);
}
});
} catch (Exception e) {
throw Throwables.propagate(e);
}
}
@Override
public boolean canCommit(final Transaction tx, final Collection<byte[]> changeIds)
throws TransactionNotInProgressException {
try {
return execute(
new Operation<Boolean>("canCommit") {
@Override
public Boolean execute(TransactionServiceThriftClient client)
throws Exception {
return client.canCommit(tx, changeIds);
}
});
} catch (TransactionNotInProgressException e) {
throw e;
} catch (Exception e) {
throw Throwables.propagate(e);
}
}
@Override
public boolean commit(final Transaction tx) throws TransactionNotInProgressException {
try {
return this.execute(
new Operation<Boolean>("commit") {
@Override
public Boolean execute(TransactionServiceThriftClient client)
throws Exception {
return client.commit(tx);
}
});
} catch (TransactionNotInProgressException e) {
throw e;
} catch (Exception e) {
throw Throwables.propagate(e);
}
}
@Override
public void abort(final Transaction tx) {
try {
this.execute(
new Operation<Boolean>("abort") {
@Override
public Boolean execute(TransactionServiceThriftClient client)
throws TException {
client.abort(tx);
return true;
}
});
} catch (Exception e) {
throw Throwables.propagate(e);
}
}
@Override
public boolean invalidate(final long tx) {
try {
return this.execute(
new Operation<Boolean>("invalidate") {
@Override
public Boolean execute(TransactionServiceThriftClient client)
throws TException {
return client.invalidate(tx);
}
});
} catch (Exception e) {
throw Throwables.propagate(e);
}
}
@Override
public Transaction checkpoint(final Transaction tx) throws TransactionNotInProgressException {
try {
return this.execute(
new Operation<Transaction>("checkpoint") {
@Override
Transaction execute(TransactionServiceThriftClient client) throws Exception {
return client.checkpoint(tx);
}
}
);
} catch (TransactionNotInProgressException e) {
throw e;
} catch (Exception e) {
throw Throwables.propagate(e);
}
}
@Override
public InputStream getSnapshotInputStream() throws TransactionCouldNotTakeSnapshotException {
try {
return this.execute(
new Operation<InputStream>("takeSnapshot") {
@Override
public InputStream execute(TransactionServiceThriftClient client)
throws Exception {
return client.getSnapshotStream();
}
});
} catch (TransactionCouldNotTakeSnapshotException e) {
throw e;
} catch (Exception e) {
throw Throwables.propagate(e);
}
}
@Override
public String status() {
try {
return this.execute(
new Operation<String>("status") {
@Override
public String execute(TransactionServiceThriftClient client) throws Exception {
return client.status();
}
});
} catch (Exception e) {
throw Throwables.propagate(e);
}
}
@Override
public void resetState() {
try {
this.execute(
new Operation<Boolean>("resetState") {
@Override
public Boolean execute(TransactionServiceThriftClient client)
throws TException {
client.resetState();
return true;
}
});
} catch (Exception e) {
throw Throwables.propagate(e);
}
}
@Override
public boolean truncateInvalidTx(final Set<Long> invalidTxIds) {
try {
return this.execute(
new Operation<Boolean>("truncateInvalidTx") {
@Override
public Boolean execute(TransactionServiceThriftClient client) throws TException {
return client.truncateInvalidTx(invalidTxIds);
}
});
} catch (Exception e) {
throw Throwables.propagate(e);
}
}
@Override
public boolean truncateInvalidTxBefore(final long time) throws InvalidTruncateTimeException {
try {
return this.execute(
new Operation<Boolean>("truncateInvalidTxBefore") {
@Override
public Boolean execute(TransactionServiceThriftClient client) throws Exception {
return client.truncateInvalidTxBefore(time);
}
});
} catch (InvalidTruncateTimeException e) {
throw e;
} catch (Exception e) {
throw Throwables.propagate(e);
}
}
@Override
public int getInvalidSize() {
try {
return this.execute(
new Operation<Integer>("getInvalidSize") {
@Override
public Integer execute(TransactionServiceThriftClient client) throws TException {
return client.getInvalidSize();
}
});
} catch (Exception e) {
throw Throwables.propagate(e);
}
}
}