org.neo4j.causalclustering.core.consensus.log.segmented

Class SegmentedRaftLog

java.lang.Object

org.neo4j.kernel.lifecycle.LifecycleAdapter

org.neo4j.causalclustering.core.consensus.log.segmented.SegmentedRaftLog

All Implemented Interfaces:

RaftLog, ReadableRaftLog, org.neo4j.kernel.lifecycle.Lifecycle

public class SegmentedRaftLog
extends org.neo4j.kernel.lifecycle.LifecycleAdapter
implements RaftLog

The segmented RAFT log is an append only log supporting the operations required to support the RAFT consensus algorithm.

A RAFT log must be able to append new entries, but also truncate not yet committed entries, prune out old compacted entries and skip to a later starting point.

The RAFT log consists of a sequence of individual log files, called segments, with the following format:

[HEADER] [ENTRY]*

So a header with zero or more entries following it. Each segment file contains a consecutive sequence of appended entries. The operations of truncating and skipping in the log is implemented by switching to the next segment file, called the next version. A new segment file is also started when the threshold for a particular file has been reached.

Nested Class Summary

Nested classes/interfaces inherited from interface org.neo4j.kernel.lifecycle.Lifecycle

org.neo4j.kernel.lifecycle.Lifecycle.Delegate

Field Summary

Fields inherited from interface org.neo4j.causalclustering.core.consensus.log.RaftLog

PHYSICAL_LOG_DIRECTORY_NAME

Constructor Summary

Constructors

Constructor and Description
SegmentedRaftLog(org.neo4j.io.fs.FileSystemAbstraction fileSystem, File directory, long rotateAtSize, ChannelMarshal<ReplicatedContent> contentMarshal, org.neo4j.logging.LogProvider logProvider, int readerPoolSize, Clock clock, org.neo4j.kernel.impl.util.JobScheduler scheduler, CoreLogPruningStrategy pruningStrategy)

Method Summary

Modifier and Type	Method and Description
long	append(RaftLogEntry... entries) Appends entry to the end of the log.
long	appendIndex()
RaftLogCursor	getEntryCursor(long fromIndex) Returns a RaftLogCursor of RaftLogEntrys from the specified index until the end of the log
long	prevIndex()
long	prune(long safeIndex) Attempt to prune (delete) a prefix of the log, no further than the safeIndex.
long	readEntryTerm(long logIndex) Reads the term associated with the entry at the supplied index.
long	skip(long newIndex, long newTerm) Skip up to the supplied index if it is not already present.
void	start()
void	stop()
void	truncate(long fromIndex) Truncates the log starting from the supplied index.

Methods inherited from class org.neo4j.kernel.lifecycle.LifecycleAdapter

init, shutdown

Methods inherited from class java.lang.Object

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

Constructor Detail

SegmentedRaftLog

public SegmentedRaftLog(org.neo4j.io.fs.FileSystemAbstraction fileSystem,
                        File directory,
                        long rotateAtSize,
                        ChannelMarshal<ReplicatedContent> contentMarshal,
                        org.neo4j.logging.LogProvider logProvider,
                        int readerPoolSize,
                        Clock clock,
                        org.neo4j.kernel.impl.util.JobScheduler scheduler,
                        CoreLogPruningStrategy pruningStrategy)

Method Detail

start

public void start()
           throws IOException,
                  DamagedLogStorageException,
                  org.neo4j.causalclustering.core.consensus.log.segmented.DisposedException

Specified by:

start in interface org.neo4j.kernel.lifecycle.Lifecycle

Overrides:

start in class org.neo4j.kernel.lifecycle.LifecycleAdapter

Throws:

IOException

DamagedLogStorageException

org.neo4j.causalclustering.core.consensus.log.segmented.DisposedException

stop

public void stop()
          throws Throwable

Specified by:

stop in interface org.neo4j.kernel.lifecycle.Lifecycle

Overrides:

stop in class org.neo4j.kernel.lifecycle.LifecycleAdapter

Throws:

Throwable

append

public long append(RaftLogEntry... entries)
            throws IOException

Description copied from interface: RaftLog

Appends entry to the end of the log. The first log index is 0.

The entries must be uniquely identifiable and already appended entries must not be re-appended (unless they have been removed through truncation).

Specified by:

append in interface RaftLog

Parameters:

entries - The log entry.

Returns:

the index at which the entry was appended.

Throws:

IOException

truncate

public void truncate(long fromIndex)
              throws IOException

Description copied from interface: RaftLog

Truncates the log starting from the supplied index. Committed entries can never be truncated.

Specified by:

truncate in interface RaftLog

Parameters:

fromIndex - The start index (inclusive).

Throws:

IOException

appendIndex

public long appendIndex()

Specified by:

appendIndex in interface ReadableRaftLog

Returns:

The index of the last appended entry.

prevIndex

public long prevIndex()

Specified by:

prevIndex in interface ReadableRaftLog

Returns:

The index immediately preceding entries in the log.

getEntryCursor

public RaftLogCursor getEntryCursor(long fromIndex)
                             throws IOException

Description copied from interface: ReadableRaftLog

Returns a RaftLogCursor of RaftLogEntrys from the specified index until the end of the log

Specified by:

getEntryCursor in interface ReadableRaftLog

Parameters:

fromIndex - The log index at which the cursor should be positioned

Throws:

IOException

skip

public long skip(long newIndex,
                 long newTerm)
          throws IOException

Description copied from interface: RaftLog

Skip up to the supplied index if it is not already present.

If the entry was not present then it gets defined with the supplied term, but without content, and thus can be used only for log matching from a later index.

This is useful when a snapshot starting from a later index has been downloaded and thus earlier entries are irrelevant and possibly non-existent in the cluster.

Specified by:

skip in interface RaftLog

Parameters:

newIndex - the index we want to skip to

newTerm - the term of the index

Returns:

The appendIndex after this call, which will be at least index.

Throws:

IOException

readEntryTerm

public long readEntryTerm(long logIndex)
                   throws IOException

Description copied from interface: ReadableRaftLog

Reads the term associated with the entry at the supplied index.

Specified by:

readEntryTerm in interface ReadableRaftLog

Parameters:

logIndex - The index of the log entry.

Returns:

The term of the entry, or -1 if the entry does not exist

Throws:

IOException

prune

public long prune(long safeIndex)
           throws IOException

Description copied from interface: RaftLog

Attempt to prune (delete) a prefix of the log, no further than the safeIndex.

Implementations can choose to prune a shorter prefix if this is convenient for their storage mechanism. The return value tells the caller how much was actually pruned.

Specified by:

prune in interface RaftLog

Parameters:

safeIndex - Highest index that may be pruned.

Returns:

The new prevIndex for the log, which will be at most safeIndex.

Throws:

IOException