com.bigdata.journal

Class DelegateTransactionService

java.lang.Object

com.bigdata.journal.DelegateTransactionService

All Implemented Interfaces:

IDistributedTransactionService, ITimestampService, ITransactionService, IService, Remote

public class DelegateTransactionService
extends Object
implements IDistributedTransactionService

Delegation pattern for an ITransactionService.

Version:

$Id$

Author:

Bryan Thompson

Constructor Summary

Constructors

Constructor and Description
DelegateTransactionService(IDistributedTransactionService proxy)

Method Summary

Methods

Modifier and Type	Method and Description
void	abort(long tx) Request abort of the transaction write set.
long	commit(long tx) Request commit of the transaction write set.
boolean	committed(long tx, UUID dataService) Sent by a task participating in a distributed commit of a transaction when the task has successfully committed the write set of the transaction on the live journal of the local IDataService.
void	declareResources(long tx, UUID dataService, String[] resource) An IDataService MUST invoke this method before permitting an operation isolated by a read-write transaction to execute with access to the named resources (this applies only to distributed databases).
void	destroy() Destroy the service.
String	getHostname() The host on which this service is running.
long	getLastCommitTime() Return the last commitTime reported to the ITransactionService.
long	getReleaseTime() Return the timestamp whose historical data MAY be released.
Class	getServiceIface() Return the most interesting interface for the service.
String	getServiceName() Return name by which a user might recognize this service.
UUID	getServiceUUID() The unique identifier for this service.
long	newTx(long timestamp) Create a new transaction.
long	nextTimestamp() Return the next unique timestamp.
void	notifyCommit(long commitTime) Notify the ITransactionService that a commit has been performed with the given timestamp (which it assigned) and that it should update its lastCommitTime iff the given commitTime is GT its current lastCommitTime.
long	prepared(long tx, UUID dataService) Callback by an IDataService participating in a two phase commit for a distributed transaction.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

DelegateTransactionService

public DelegateTransactionService(IDistributedTransactionService proxy)

Method Detail

getServiceUUID

public UUID getServiceUUID()
                    throws IOException

Description copied from interface: IService

The unique identifier for this service.

Note: Some service discovery frameworks (Jini) will assign the service a UUID asynchronously after a new service starts, in which case this method will return null until the service UUID has been assigned.

Specified by:

getServiceUUID in interface IService

Returns:

The unique data service identifier.

Throws:

IOException - since you can use this method with RMI.

getServiceName

public String getServiceName()
                      throws IOException

Description copied from interface: IService

Return name by which a user might recognize this service.

Specified by:

getServiceName in interface IService

Throws:

IOException - since you can use this method with RMI.

getServiceIface

public Class getServiceIface()
                      throws IOException

Description copied from interface: IService

Return the most interesting interface for the service.

Specified by:

getServiceIface in interface IService

Throws:

IOException - since you can use this method with RMI.

getHostname

public String getHostname()
                   throws IOException

Description copied from interface: IService

The host on which this service is running.

Specified by:

getHostname in interface IService

Throws:

IOException - since you can use this method with RMI.

destroy

public void destroy()
             throws RemoteException

Description copied from interface: IService

Destroy the service. If the service is running, it is shutdown immediately and then destroyed. This method has the same signature as DestroyAdmin#destroy().

Specified by:

destroy in interface IService

Throws:

RemoteException

nextTimestamp

public long nextTimestamp()
                   throws IOException

Description copied from interface: ITimestampService

Return the next unique timestamp. Timestamps must be strictly increasing.

Note: This method MUST return strictly increasing values, even when it is invoked by concurrent threads. While other implementations are possible and may be more efficient, one way to insure thread safety is to synchronize on some object such that the implementaiton exhibits a FIFO behavior.

Specified by:

nextTimestamp in interface ITimestampService

Throws:

IOException - if there is an RMI problem.

See Also:

TimestampServiceUtil.nextTimestamp(ITimestampService)

prepared

public long prepared(long tx,
            UUID dataService)
              throws IOException,
                     InterruptedException,
                     BrokenBarrierException

Description copied from interface: IDistributedTransactionService

Callback by an IDataService participating in a two phase commit for a distributed transaction. The ITransactionService will wait until all IDataServices have prepared. It will then choose a commitTime for the transaction and return that value to each IDataService.

Note: If this method throws ANY exception then the task MUST cancel the commit, discard the local write set of the transaction, and note that the transaction is aborted in its local state.

Specified by:

prepared in interface IDistributedTransactionService

Parameters:

tx - The transaction identifier.

dataService - The UUID of the IDataService which sent the message.

Returns:

The assigned commit time.

Throws:

IOException - if there is an RMI problem.

InterruptedException

BrokenBarrierException

notifyCommit

public void notifyCommit(long commitTime)
                  throws IOException

Description copied from interface: ITransactionService

Notify the ITransactionService that a commit has been performed with the given timestamp (which it assigned) and that it should update its lastCommitTime iff the given commitTime is GT its current lastCommitTime.

Note: This is used to inform the ITransactionService of commits that DO NOT involve transaction commits. That is, local unisolated writes on individual IDataServices in an IBigdataFederation.

Specified by:

notifyCommit in interface ITransactionService

Parameters:

commitTime - The commit time.

Throws:

IOException

newTx

public long newTx(long timestamp)
           throws IOException

Description copied from interface: ITransactionService

Create a new transaction.

Specified by:

newTx in interface ITransactionService

Parameters:

timestamp - The timestamp may be:

• A timestamp (GT ZERO), which will result in a read-historical (read-only) transaction that reads from the most recent committed state whose commit timestamp is less than or equal to timestamp. (As a special case, a timestamp that is GT the lastCommitTime will produce a read-only transaction that is reading on the lastCommitTime with snapshot isolation (new writes will not become visible in the view). This is basically the same behavior as specifying ITx.READ_COMMITTED. While perhaps counter-intuitive, this behavior is preferred to throwing an exception when a user attempts to read from a commit time GT the most recent commit point.).
• The symbolic constant ITx.READ_COMMITTED to obtain a read-historical transaction reading from the most recently committed state of the database. The transaction will be assigned a start time corresponding to the most recent commit point of the database and will be a fully isolated read-only view of the state of the database as of that start time. (This is an atomic shorthand for newTx(getLastCommitTime())).
• ITx.UNISOLATED for a read-write transaction.

Returns:

The unique transaction identifier.

Throws:

IOException - RMI errors.

getReleaseTime

public long getReleaseTime()
                    throws IOException

Description copied from interface: ITransactionService

Return the timestamp whose historical data MAY be released. This time is derived from the minimum of the timestamp of the earliest running transaction and now-minReleaseAge and is updated whenever the earliest running transaction terminates. This value is monotonically increasing. It will always be LT the last non-zero last commit time. It will never be negative. It MAY be ZERO (0L) and will be ZERO (0L) on startup (unless explicitly set by the database to the last known commit time).

The returned values is used to identify the most recent commit point LTE the releaseTime. This is the earliest commit point on whose data MAY be released. (Consequently, the first commit point GT the releaseTime is the earliest visible commit point.)

Specified by:

getReleaseTime in interface ITransactionService

Throws:

IOException

getLastCommitTime

public long getLastCommitTime()
                       throws IOException

Description copied from interface: ITransactionService

Return the last commitTime reported to the ITransactionService.

Specified by:

getLastCommitTime in interface ITransactionService

Returns:

The last known commit time.

Throws:

IOException

declareResources

public void declareResources(long tx,
                    UUID dataService,
                    String[] resource)
                      throws IOException

Description copied from interface: IDistributedTransactionService

An IDataService MUST invoke this method before permitting an operation isolated by a read-write transaction to execute with access to the named resources (this applies only to distributed databases). The declared resources are used in the commit phase of the read-write tx to impose a partial order on commits. That partial order guarantees that commits do not deadlock in contention for the same resources.

Specified by:

declareResources in interface IDistributedTransactionService

Parameters:

tx - The transaction identifier.

dataService - The UUID an IDataService on which the transaction will write.

resource - An array of the named resources which the transaction will use on that IDataService (this may be different for each operation submitted by that transaction to the IDataService).

Throws:

IOException

committed

public boolean committed(long tx,
                UUID dataService)
                  throws IOException,
                         InterruptedException,
                         BrokenBarrierException

Description copied from interface: IDistributedTransactionService

Sent by a task participating in a distributed commit of a transaction when the task has successfully committed the write set of the transaction on the live journal of the local IDataService. If this method returns false then the distributed commit has failed and the task MUST rollback the live journal to the previous commit point. If the return is true then the distributed commit was successful and the task should halt permitting the IDataService to return from the ITxCommitProtocol.prepare(long, long) method.

Specified by:

committed in interface IDistributedTransactionService

Parameters:

tx - The transaction identifier.

dataService - The UUID of the IDataService which sent the message.

Returns:

true if the distributed commit was successfull and false if there was a problem.

Throws:

IOException

InterruptedException

BrokenBarrierException

commit

public long commit(long tx)
            throws ValidationError,
                   IOException

Description copied from interface: ITransactionService

Request commit of the transaction write set. Committing a read-only transaction is necessary in order to release read locks (this is very fast). If a transaction has a write set, then this method does not return until that write set has been made restart safe or the transaction has failed.

The commit of a transaction with a write set on a single IDataService does not require either ITx.UNISOLATED tasks or other transactions to wait. The latency for such commits is directly related to the size of the transaction write set.

However, the commit of a transaction with writes on more than one IDataService requires a distributed commit protocol. The distributed commit protocol forces ALL tasks writing on those IDataServices to wait until the transaction is complete. This is necessary in order to obtain a global commit point that corresponds to the atomic commit state of the transaction (without this we would not have the Atomic property for distributed transaction commits).

Specified by:

commit in interface ITransactionService

Parameters:

tx - The transaction identifier.

Returns:

The commit time for the transaction -or- ZERO (0L) if the transaction was read-only or had an empty write set. This commit time identifies a global commit point on the database from which you may read the coherent post-commit state of the transaction.

Throws:

ValidationError - if the transaction could not be validated.

IOException - RMI errors.

abort

public void abort(long tx)
           throws IOException

Description copied from interface: ITransactionService

Request abort of the transaction write set.

Specified by:

abort in interface ITransactionService

Parameters:

tx - The transaction identifier.

Throws:

IOException - RMI errors.