AbstractJournal.BasicHA (Blazegraph Database Platform 2.1.5 API)

java.lang.Object
- com.bigdata.journal.AbstractJournal.BasicHA

All Implemented Interfaces:

HACommitGlue, HAGlue, HAGlueBase, HAPipelineGlue, HAReadGlue, HATXSGlue, IService, Remote

Enclosing class:

AbstractJournal
```
protected class AbstractJournal.BasicHA
extends Object
implements HAGlue
```
Implementation hooks into the various low-level operations required to support HA for the journal.

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

protected class AbstractJournal.BasicHA.VoteNoTask
Task votes NO (unconditional).

Nested Classes
Modifier and Type	Class and Description
`protected class`	`AbstractJournal.BasicHA.VoteNoTask` Task votes NO (unconditional).

Constructor Summary

Constructors
Modifier Constructor and Description

protected AbstractJournal.BasicHA(UUID serviceId, InetSocketAddress writePipelineAddr)

Constructors
Modifier	Constructor and Description
`protected`	`AbstractJournal.BasicHA(UUID serviceId, InetSocketAddress writePipelineAddr)`

Method Summary

Methods
Modifier and Type	Method and Description
`Future<Void>`	`abort2Phase(IHA2PhaseAbortMessage abortMessage)` Discard the current write set using `AbstractJournal.abort()`, reloading all state from the last root block, etc.
`long`	`awaitHAReady(long timeout, TimeUnit units)` Await the service being ready to partitipate in an HA quorum.
`IHANotifyReleaseTimeResponse`	`awaitServiceJoin(IHAAwaitServiceJoinRequest req)` A follower uses this message to request that the quorum leader await the visibility of the zookeeper event in which the service join becomes visible to the leader.
`Future<Void>`	`commit2Phase(IHA2PhaseCommitMessage commitMessage)` Commit using the root block from the corresponding prepare message.
`IHADigestResponse`	`computeDigest(IHADigestRequest req)` Compute the digest of the entire backing store - THIS METHOD IS ONLY FOR DIAGNOSTIC PURPOSES.
`IHALogDigestResponse`	`computeHALogDigest(IHALogDigestRequest req)` Compute the digest of the entire HALog file - THIS METHOD IS ONLY FOR DIAGNOSTIC PURPOSES.
`IHASnapshotDigestResponse`	`computeHASnapshotDigest(IHASnapshotDigestRequest req)` Compute the digest of the entire snapshot file - THIS METHOD IS ONLY FOR DIAGNOSTIC PURPOSES. This digest is computed for the compressed data so it may be compared directly with the digest of the backing store from which the snapshot was obtained.
`void`	`destroy()` Destroy the service.
`void`	`gatherMinimumVisibleCommitTime(IHAGatherReleaseTimeRequest req)` Message used to request information about the earliest commit point that is pinned on a follower.
`String`	`getExtendedRunState()` The extended run state of the service - this embeds more information but is not designed for progamatic interpretation.
`IHALogRootBlocksResponse`	`getHALogRootBlocksForWriteSet(IHALogRootBlocksRequest msg)` Request the root blocks for the HA Log for the specified commit point.
`HAStatusEnum`	`getHAStatus()` A simplified summary of the HA status of the service.
`IHAWriteSetStateResponse`	`getHAWriteSetState(IHAWriteSetStateRequest req)` Request metadata about the current write set from the quorum leader.
`String`	`getHostname()` The host on which this service is running.
`AbstractJournal`	`getIndexManager()` Return the backing `IIndexManager` (non-RMI method).
`int`	`getNSSPort()` The port that the NanoSparqlServer is running on.
`protected <E> Future<E>`	`getProxy(Future<E> future)` Return a proxy object for a `Future` suitable for use in an RMI environment (the default implementation returns its argument).
`protected <E> Future<E>`	`getProxy(Future<E> future, boolean asyncFuture)` Return a proxy object for a `Future` suitable for use in an RMI environment (the default implementation returns its argument).
`IHARootBlockResponse`	`getRootBlock(IHARootBlockRequest msg)` Return the then current root block for the persistence store.
`RunState`	`getRunState()` The `RunState` of the service - this does NOT tell you whether the service is ready to act as a leader or follower.
`UUID`	`getServiceId()` The `UUID` of this service.
`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.
`InetSocketAddress`	`getWritePipelineAddr()` Return the address at which this service will listen for write pipeline messages sent from the upstream service.
`Future<Void>`	`moveToEndOfPipeline()` Instruct the service to move to the end of the write pipeline.
`long`	`nextTimestamp()` This exposes the clock used to assign transaction identifiers and commit times.
`IHANotifyReleaseTimeResponse`	`notifyEarliestCommitTime(IHANotifyReleaseTimeRequest req)` Message used by the follower to notify the leader about the new release time that will be visible for new transaction starts.
`Future<Boolean>`	`prepare2Phase(IHA2PhasePrepareMessage prepareMessage)` Save a reference to the caller's root block, flush writes to the backing channel and acknowledge "yes" if ready to commit.
`Future<IHAReadResponse>`	`readFromDisk(IHAReadRequest msg)` Read a record an `IRawStore` managed by the service.
`Future<Void>`	`rebuildFromLeader(IHARemoteRebuildRequest req)` Disaster recovery (REBUILD) of the local database instance from the leader of a met quorum.
`Future<Void>`	`receiveAndReplicate(IHASyncRequest req, IHASendState snd, IHAWriteMessage msg)` Accept metadata describing an NIO buffer transfer along the write pipeline.
`Future<IHAPipelineResetResponse>`	`resetPipeline(IHAPipelineResetRequest req)` Reset the pipeline (blocking).
`Future<Void>`	`sendHALogForWriteSet(IHALogRequest msg)` The recipient will send the `WriteCache` blocks for the specified write set on the write pipeline.
`Future<IHASendStoreResponse>`	`sendHAStore(IHARebuildRequest msg)` Send the raw blocks for the requested backing store across the write pipeline.
`<T> Future<T>`	`submit(IIndexManagerCallable<T> callable, boolean asyncFuture)` Run the caller's task on the service.
`Future<IHASnapshotResponse>`	`takeSnapshot(IHASnapshotRequest req)` Request that the service take a snapshot.
`protected void`	`validateNewRootBlock(boolean isLeader, IRootBlockView oldRB, IRootBlockView newRB)` Validate the new root block against the current root block.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - AbstractJournal.BasicHA
```
protected AbstractJournal.BasicHA(UUID serviceId,
                       InetSocketAddress writePipelineAddr)
```
- Method Detail
  - getIndexManager
```
public AbstractJournal getIndexManager()
```
    Return the backing IIndexManager (non-RMI method).
  - getServiceId
```
public UUID getServiceId()
```
    Description copied from interface: HAGlueBase
    
    The UUID of this service.
    
    Specified by:
    
    getServiceId in interface HAGlueBase
  - getWritePipelineAddr
```
public InetSocketAddress getWritePipelineAddr()
```
    Description copied from interface: HAPipelineGlue
    
    Return the address at which this service will listen for write pipeline messages sent from the upstream service.
    
    Specified by:
    
    getWritePipelineAddr in interface HAPipelineGlue
  - getNSSPort
```
public int getNSSPort()
```
    Description copied from interface: HAGlue
    
    The port that the NanoSparqlServer is running on.
    
    Specified by:
    
    getNSSPort in interface HAGlue
  - getRunState
```
public RunState getRunState()
```
    Description copied from interface: HAGlue
    
    The RunState of the service - this does NOT tell you whether the service is ready to act as a leader or follower.
    
    Specified by:
    
    getRunState in interface HAGlue
  - getExtendedRunState
```
public String getExtendedRunState()
```
    Description copied from interface: HAGlue
    
    The extended run state of the service - this embeds more information but is not designed for progamatic interpretation.
    
    Specified by:
    
    getExtendedRunState in interface HAGlue
  - getHAStatus
```
public HAStatusEnum getHAStatus()
```
    Description copied from interface: HAGlue
    
    A simplified summary of the HA status of the service. This may be used to reliably decide whether the service is the HAStatusEnum.Leader, a HAStatusEnum.Follower, or HAStatusEnum.NotReady. This is exposed both here (an RMI interface) and by the REST API.
    
    Specified by:
    
    getHAStatus in interface HAGlue
  - awaitHAReady
```
public long awaitHAReady(long timeout,
                TimeUnit units)
                  throws AsynchronousQuorumCloseException,
                         InterruptedException,
                         TimeoutException
```
    Description copied from interface: HAGlue
    Await the service being ready to partitipate in an HA quorum. The preconditions include:
    1. receiving notice of the quorum token via #setQuorumToken(long)
    2. The service is joined with the met quorum for that token
    3. If the service is a follower and it's local root blocks were at commitCounter:=0, then the root blocks from the leader have been installed on the follower.
    Specified by:
    
    awaitHAReady in interface HAGlue
    
    Parameters:
    timeout - The timeout to await this condition.
    
    Returns:
    the quorum token for which the service became HA ready.
    
    Throws:
    
    AsynchronousQuorumCloseException
    
    InterruptedException
    
    TimeoutException
  - awaitServiceJoin
```
public IHANotifyReleaseTimeResponse awaitServiceJoin(IHAAwaitServiceJoinRequest req)
                                              throws AsynchronousQuorumCloseException,
                                                     InterruptedException,
                                                     TimeoutException
```
    A follower uses this message to request that the quorum leader await the visibility of the zookeeper event in which the service join becomes visible to the leader. This is invoked while holding a lock that blocks pipeline replication, so the leader can not flush the write replication pipeline and enter the commit. The callback to the leader ensures that the service join is visible to the leader before the leader makes an atomic decision about the set of services that are joined with the met quorum for a 2-phase commit. FIXME awaitServiceJoin() is failing to set the commitCounter on the message. Either create a new message type or return the right message. The joining service should be able to verify that the release time is applicable for its commit counter (in AbstractHATransactionService.runWithBarrierLock(Runnable).
    
    Specified by:
    
    awaitServiceJoin in interface HAGlue
    
    Parameters:
    req - The request.
    
    Returns:
    The most recent consensus release time for the quorum leader. This information is used to ensure that a service which joins after a gather and before a PREPARE will join with the correct release time for its local journal and thus will not permit transactions to start against commit points which have been recycled by the quorum leader.
    
    Throws:
    
    InterruptedException
    
    TimeoutException - if the timeout is exceeded before the service join becomes visible to this service.
    
    AsynchronousQuorumCloseException
    See Also:
    HAJournalServer deadlock: pipelineRemove() and getLeaderId()
  - computeDigest
```
public IHADigestResponse computeDigest(IHADigestRequest req)
                                throws IOException,
                                       NoSuchAlgorithmException,
                                       DigestException
```
    Description copied from interface: HAGlue
    
    Compute the digest of the entire backing store - THIS METHOD IS ONLY FOR DIAGNOSTIC PURPOSES.
    The digest is useless if there are concurrent writes since it can not be meaningfully compared with the digest of another store unless both stores are known to be stable.
    
    Specified by:
    
    computeDigest in interface HAGlue
    
    Throws:
    
    IOException
    
    NoSuchAlgorithmException
    
    DigestException
  - computeHALogDigest
```
public IHALogDigestResponse computeHALogDigest(IHALogDigestRequest req)
                                        throws IOException,
                                               NoSuchAlgorithmException,
                                               DigestException
```
    Description copied from interface: HAGlue
    
    Compute the digest of the entire HALog file - THIS METHOD IS ONLY FOR DIAGNOSTIC PURPOSES.
    The digest is useless if there are concurrent writes since it can not be meaningfully compared with the digest of another store unless both stores are known to be stable.
    
    Specified by:
    
    computeHALogDigest in interface HAGlue
    
    Throws:
    
    FileNotFoundException - if the HALog for the specified commit point does not exist.
    
    IOException
    
    NoSuchAlgorithmException
    
    DigestException
  - computeHASnapshotDigest
```
public IHASnapshotDigestResponse computeHASnapshotDigest(IHASnapshotDigestRequest req)
                                                  throws IOException,
                                                         NoSuchAlgorithmException,
                                                         DigestException
```
    Description copied from interface: HAGlue
    
    Compute the digest of the entire snapshot file - THIS METHOD IS ONLY FOR DIAGNOSTIC PURPOSES. This digest is computed for the compressed data so it may be compared directly with the digest of the backing store from which the snapshot was obtained.
    
    Specified by:
    
    computeHASnapshotDigest in interface HAGlue
    
    Throws:
    
    FileNotFoundException - if no snapshot exists for that commit point.
    
    IOException
    
    NoSuchAlgorithmException
    
    DigestException
  - takeSnapshot
```
public Future<IHASnapshotResponse> takeSnapshot(IHASnapshotRequest req)
                                         throws IOException
```
    Description copied from interface: HAGlue
    
    Request that the service take a snapshot. If there is already a snapshot in progress, then the Future for that request will be returned.
    
    Specified by:
    
    takeSnapshot in interface HAGlue
    
    Parameters:
    req - The request (optional). When null, the Future for any existing snapshot operation will be returned but the request WILL NOT schedule a snapshot if none is running.
    
    Returns:
    A Future for the snapshot -or- null if no snapshot is running and none will be taken for that request.
    
    Throws:
    
    IOException
  - rebuildFromLeader
```
public Future<Void> rebuildFromLeader(IHARemoteRebuildRequest req)
                               throws IOException
```
    Description copied from interface: HAGlue
    Disaster recovery (REBUILD) of the local database instance from the leader of a met quorum. There are several preconditions:
    - The quorum must be met and there must be an HAStatusEnum#Ready leader.
    - This service must be HAStatusEnum.NotReady.
    - This service MUST NOT be at the same commit point as the leader (if it is, then the service could meet in a data race with the met quorum and we do not permit RESTORE if the service is joined with the met quorum).
    - The HAJournalServer must not be running a RESTORE (we don't want it to accidentally interrupt a RESTORE that is in progress).
    Specified by:
    
    rebuildFromLeader in interface HAGlue
    
    Returns:
    The (asynchronous) Future of the REBUILD operation -or- null if any of the pre-conditions were violated.
    
    Throws:
    
    IOException
  - getProxy
```
protected final <E> Future<E> getProxy(Future<E> future)
```
    Return a proxy object for a Future suitable for use in an RMI environment (the default implementation returns its argument).
    
    Parameters:
    future - The future.
    
    Returns:
    The proxy for that future.
  - getProxy
```
protected <E> Future<E> getProxy(Future<E> future,
                     boolean asyncFuture)
```
    Return a proxy object for a Future suitable for use in an RMI environment (the default implementation returns its argument).
    
    Parameters:
    future - The future.
    asyncFuture - When true, the service should not wait for the Future to complete but should return a proxy object that may be used by the client to monitor or cancel the Future. When false, the method should wait for the Future to complete and then return a "thick" Future which wraps the completion state but does not permit asynchronous monitoring or cancellation of the operation wrapped by the Future.
    
    Returns:
    The proxy for that future.
  - prepare2Phase
```
public Future<Boolean> prepare2Phase(IHA2PhasePrepareMessage prepareMessage)
```
    Description copied from interface: HACommitGlue
    
    Save a reference to the caller's root block, flush writes to the backing channel and acknowledge "yes" if ready to commit. If the node can not prepare for any reason, then it must return "no".
    
    Specified by:
    
    prepare2Phase in interface HACommitGlue
    
    Parameters:
    prepareMessage - The message used to prepare for the commit.
    
    Returns:
    A Future which evaluates to a yes/no vote on whether the service is prepared to commit.
  - validateNewRootBlock
```
protected void validateNewRootBlock(boolean isLeader,
                        IRootBlockView oldRB,
                        IRootBlockView newRB)
```
    Validate the new root block against the current root block. This method checks a variety of invariants:
    - The UUID of the store must be the same.
    - The commitTime must be strictly increasing.
    - The commitCounter must increase by ONE (1).
    Note: This code path is only when [isJoined := true] (that is, the service was joined with the met quorum at the atomic decision point for the joined set for the 2-phase commit).
    Parameters:
    isLeader - iff this service is the leader for this commit.
    oldRB - the old (aka current) root block.
    newRB - the new (aka proposed) root block.
  - commit2Phase
```
public Future<Void> commit2Phase(IHA2PhaseCommitMessage commitMessage)
```
    Description copied from interface: HACommitGlue
    
    Commit using the root block from the corresponding prepare message. It is an error if a commit message is observed without the corresponding prepare message.
    
    Specified by:
    
    commit2Phase in interface HACommitGlue
    
    Parameters:
    commitMessage - The commit message.
  - abort2Phase
```
public Future<Void> abort2Phase(IHA2PhaseAbortMessage abortMessage)
```
    Description copied from interface: HACommitGlue
    
    Discard the current write set using AbstractJournal.abort(), reloading all state from the last root block, etc.
    Note: A service automatically does a local abort() if it leaves the pool of services joined with the quorum or if the leader fails over. Therefore a service should reject this message if the token has been invalidated since the service either has dine or will shortly do a low-level abort() on its own initiative.
    
    Specified by:
    
    abort2Phase in interface HACommitGlue
  - readFromDisk
```
public Future<IHAReadResponse> readFromDisk(IHAReadRequest msg)
```
    Read a record an IRawStore managed by the service. Services MUST NOT refer this message to another service. If the read can not be satisfied, for example because the IRawStore has been released or because there is a checksum error when reading on the IRawStore, then that exception should be thrown back to the caller.
    
    Specified by:
    
    readFromDisk in interface HAReadGlue
    
    Parameters:
    msg - The IHAReadRequest.
    
    Returns:
    The Future of an operation which evaluated to the desired record.
    See Also:
    QuorumRead.readFromQuorum(UUID, long)
  - receiveAndReplicate
```
public Future<Void> receiveAndReplicate(IHASyncRequest req,
                               IHASendState snd,
                               IHAWriteMessage msg)
                                 throws IOException
```
    Description copied from interface: HAPipelineGlue
    
    Accept metadata describing an NIO buffer transfer along the write pipeline. This method is never invoked on the master. It is only invoked on the failover nodes, including the last node in the failover chain.
    
    Specified by:
    
    receiveAndReplicate in interface HAPipelineGlue
    
    Parameters:
    req - A request for an HALog (optional). This is only non-null when historical WriteCache blocks are being replayed down the write pipeline in order to synchronize a service.
    snd - Metadata about the state of the sender and potentially the routing of the payload along the write replication pipeline.
    msg - The metadata.
    
    Returns:
    The Future which will become available once the buffer transfer is complete.
    
    Throws:
    
    IOException
  - getHALogRootBlocksForWriteSet
```
public IHALogRootBlocksResponse getHALogRootBlocksForWriteSet(IHALogRootBlocksRequest msg)
                                                       throws IOException
```
    Description copied from interface: HAPipelineGlue
    
    Request the root blocks for the HA Log for the specified commit point.
    
    Specified by:
    
    getHALogRootBlocksForWriteSet in interface HAPipelineGlue
    
    Parameters:
    msg - The request (specifies the desired HA Log by the commit counter of the closing root block).
    
    Returns:
    The requested root blocks.
    
    Throws:
    
    IOException
  - sendHALogForWriteSet
```
public Future<Void> sendHALogForWriteSet(IHALogRequest msg)
                                  throws IOException
```
    Description copied from interface: HAPipelineGlue
    
    The recipient will send the WriteCache blocks for the specified write set on the write pipeline. These WriteCache blocks will be visible to ALL services in the write pipeline. It is important that all services ignore WriteCache blocks that are not in sequence for the current write set unless they have explicitly requested an HALog using this method.
    Note: The WriteCache blocks are sent on the write pipeline. Therefore, a service MUST NOT request the write set from a service that is downstream from it in the write pipeline. It is always safe to request the data from the leader.
    Note: The HAWriteMessage includes a quorum token. When historical WriteCache blocks are being replicated in response to this method, the will be replicated using the quorum token that was in effect for that write set. Implementations MUST NOT perform asserts on the quorum token until after they have determined that the message is for the current write set.
    Note: DO NOT use a ThickFuture for the returned Future. That will defeat the ability of the requester to cancel the Future.
    
    Specified by:
    
    sendHALogForWriteSet in interface HAPipelineGlue
    
    Returns:
    A Future that may be used to cancel the remote process sending the data through the write pipeline.
    
    Throws:
    
    IOException
  - sendHAStore
```
public Future<IHASendStoreResponse> sendHAStore(IHARebuildRequest msg)
                                         throws IOException
```
    Description copied from interface: HAPipelineGlue
    
    Send the raw blocks for the requested backing store across the write pipeline.
    Note: This method supports disaster recovery of a service from a met quorum. This procedure can only be used when a met quorum exists.
    Note: DO NOT use a ThickFuture for the returned Future. That will defeat the ability of the requester to cancel the Future.
    
    Specified by:
    
    sendHAStore in interface HAPipelineGlue
    
    Returns:
    A Future that may be used to cancel the remote process sending the data through the write pipeline. The Future will report the current root block in effect as of the moment when the sendHAStore operation was completed.
    
    Throws:
    
    IOException
  - getHAWriteSetState
```
public IHAWriteSetStateResponse getHAWriteSetState(IHAWriteSetStateRequest req)
```
    Description copied from interface: HAPipelineGlue
    
    Request metadata about the current write set from the quorum leader.
    
    Specified by:
    
    getHAWriteSetState in interface HAPipelineGlue
    
    Parameters:
    req - The request.
    
    Returns:
    The response.
  - getRootBlock
```
public IHARootBlockResponse getRootBlock(IHARootBlockRequest msg)
```
    Description copied from interface: HAGlue
    
    Return the then current root block for the persistence store.
    Note: The initial root blocks are identical, so this may be used to create a new journal in a quorum by replicating the root blocks of the quorum leader.
    
    Specified by:
    
    getRootBlock in interface HAGlue
    
    Parameters:
    msg - The message requesting the then current root block.
    
    Returns:
    The then current root block.
  - moveToEndOfPipeline
```
public Future<Void> moveToEndOfPipeline()
```
    Instruct the service to move to the end of the write pipeline. The leader MUST be the first service in the write pipeline since it is the service to which the application directs all write requests. This message is used when a leader will be elected and it needs to force other services before it in the write pipeline to leave/add themselves from/to the write pipeline such that the leader becomes the first service in the write pipeline.
    This implementation does pipeline remove() followed by pipline add().
    
    Specified by:
    
    moveToEndOfPipeline in interface HAPipelineGlue
  - resetPipeline
```
public Future<IHAPipelineResetResponse> resetPipeline(IHAPipelineResetRequest req)
                                               throws IOException
```
    Description copied from interface: HAPipelineGlue
    
    Reset the pipeline (blocking). This message is used to handle an error in pipeline replication. If replication fails, the socket connections both upstream and downstream of the point of failure can be left in an indeterminate state with partially buffered data. In order to bring the pipeline back into a known state (without forcing a quorum break) we message each service in the pipeline to reset its HAReceiveService (including the inner HASendService). The next message and payload relayed from the leader will cause new socket connections to be established.
    
    Specified by:
    
    resetPipeline in interface HAPipelineGlue
    
    Returns:
    The Future for the operation on the remote service.
    
    Throws:
    
    IOException
  - gatherMinimumVisibleCommitTime
```
public void gatherMinimumVisibleCommitTime(IHAGatherReleaseTimeRequest req)
                                    throws IOException
```
    Message used to request information about the earliest commit point that is pinned on a follower. This is used by the leader to make a decision about the new release time for the replication cluster.
    Note: This message is used as part of a pattern where the leader instructs the followers to message the leader with their earliest commit point pinned by either a transaction or the minReleaseAge of their ITransactionService using #notifyEarliestCommitTime(IHANotifyReleaseTimeResponse).
    The message is a sync RMI call. The follower will clear an outcome and execute a task which runs asynchronously and messages back to the leader with its IHANotifyReleaseTimeResponse. The leader will report back the consensus release time. The outcome of these on the follower is not directly reported back to the leader, e.g., through a remote Future because this causes a DGC thread leak on the follower. See the ticket below. Instead, the follower notes the outcome of the gather operation and will vote "NO" in HACommitGlue.prepare2Phase(IHA2PhasePrepareMessage) unless it completes its side of the release time consensus protocol without error (that is, the otherwise unmonitored outcome of the asynchronous task for HATXSGlue.gatherMinimumVisibleCommitTime(IHAGatherReleaseTimeRequest)).
    
    Specified by:
    
    gatherMinimumVisibleCommitTime in interface HATXSGlue
    
    Parameters:
    req - The request from the leader.
    
    Throws:
    
    IOException
    See Also:
    Native thread leak in HAJournalServer process
  - notifyEarliestCommitTime
```
public IHANotifyReleaseTimeResponse notifyEarliestCommitTime(IHANotifyReleaseTimeRequest req)
                                                      throws IOException,
                                                             InterruptedException,
                                                             BrokenBarrierException
```
    Description copied from interface: HATXSGlue
    
    Message used by the follower to notify the leader about the new release time that will be visible for new transaction starts. The leader then chooses the mimimum across itself and the followers.
    
    Specified by:
    
    notifyEarliestCommitTime in interface HATXSGlue
    
    Returns:
    The earliest pinned commit point across the services joined with the met quorum.
    
    Throws:
    
    InterruptedException
    
    BrokenBarrierException
    
    IOException
  - nextTimestamp
```
public long nextTimestamp()
```
    This exposes the clock used to assign transaction identifiers and commit times. It is being exposed to support certain kinds of overrides for unit tests.
    Note: This method is NOT exposed to RMI. However, it can still be overridden by the unit tests.
    
    Returns:
    The next timestamp from that clock.
  - 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.
  - 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.
  - 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.
  - 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
  - submit
```
public <T> Future<T> submit(IIndexManagerCallable<T> callable,
                   boolean asyncFuture)
                 throws IOException
```
    Description copied from interface: HAGlue
    
    Run the caller's task on the service.
    Note: This interface provides direct access to the raw index manager. Caller's requiring concurrency control should submit an IApiTask in order to have their task queue for the necessary locks and run on the appropriate executor service.
    
    Specified by:
    
    submit in interface HAGlue
    
    Parameters:
    callable - The task to run on the service.
    asyncFuture - true if the task will execute asynchronously and return a Future for the computation that may be used to inspect and/or cancel the computation. false if the task will execute synchronously and return a thick Future.
    
    Throws:
    
    IOException

Class AbstractJournal.BasicHA

Nested Class Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

AbstractJournal.BasicHA

Method Detail

getIndexManager

getServiceId

getWritePipelineAddr

getNSSPort

getRunState

getExtendedRunState

getHAStatus

awaitHAReady

awaitServiceJoin

computeDigest

computeHALogDigest

computeHASnapshotDigest

takeSnapshot

rebuildFromLeader

getProxy

getProxy

prepare2Phase

validateNewRootBlock

commit2Phase

abort2Phase

readFromDisk

receiveAndReplicate

getHALogRootBlocksForWriteSet

sendHALogForWriteSet

sendHAStore

getHAWriteSetState

getRootBlock

moveToEndOfPipeline

resetPipeline

gatherMinimumVisibleCommitTime

notifyEarliestCommitTime

nextTimestamp

getServiceUUID

getServiceIface

getHostname

getServiceName

destroy

submit