kafka.tier.state

Class FileTierPartitionState

java.lang.Object

kafka.tier.state.FileTierPartitionState

All Implemented Interfaces:

AutoCloseable, TierPartitionState

public class FileTierPartitionState
extends Object
implements TierPartitionState, AutoCloseable

Important: this code is performance sensitive. When making potentially performance sensitive code, please run the following under the jmh-benchmarks directory: ./jmh.sh -prof gc org.apache.kafka.jmh.tier.MergedLogTierBenchmark

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static interface	FileTierPartitionState.MaterializationListener

Nested classes/interfaces inherited from interface kafka.tier.state.TierPartitionState

TierPartitionState.AppendResult, TierPartitionState.RecoveryOperation, TierPartitionState.RestoreResult

Field Summary

Fields

Modifier and Type	Field and Description
static short	SUPER_BLOCK_LENGTH_ADLER
static short	SUPER_BLOCK_LENGTH_NO_CHECKSUM

Constructor Summary

Constructors

Constructor and Description
FileTierPartitionState(File dir, kafka.server.LogDirFailureChannel logDirFailureChannel, org.apache.kafka.common.TopicPartition topicPartition, boolean tieringEnabled, kafka.utils.Scheduler scheduler, boolean checksumEnabled)

Method Summary

Modifier and Type	Method and Description
TierPartitionState.AppendResult	append(AbstractTierMetadata metadata, OffsetAndEpoch offsetAndEpoch) Appends abstract metadata to the tier partition.
void	beginCatchup() Begin catchup phase for tier partition state.
void	close() Close TierPartition, flushing to disk.
void	closeHandlers()
long	committedEndOffset() Return the end offset spanned by the TierPartitionState that has been committed to disk.
void	delete() Delete this TierPartitionState from local storage.
File	dir() The directory where the TierPartition is stored on disk.
long	endOffset() Return the uncommitted end offset spanned by the TierPartitionState.
Collection<kafka.log.TierLogSegment>	fencedSegments()
boolean	flush() Flush data contained in this TierPartitionState to disk.
String	flushedPath()
kafka.common.FollowerRestorePoint	followerRestorePoint(long localLogStartOffset) Fetch and return the FollowerRestorePoint for the given localLogStartOffset.
TierPartitionState.RestoreResult	forceRestoreState(TierPartitionForceRestore metadata, ByteBuffer targetState, TierPartitionStatus targetStatus, OffsetAndEpoch offsetAndEpoch) Performs a TierPartitionState restore, swapping the current state file from buffer and replacing any internal state with the contents of the new TierPartitionState, setting the TierPartitionStatus of the state to status.
boolean	isErrorStatusReachedViaFenceEvent()
boolean	isTieringEnabled()
static Optional<FileTierPartitionIterator>	iterator(org.apache.kafka.common.TopicPartition topicPartition, CheckedFileIO channel)
OffsetAndEpoch	lastLocalMaterializedSrcOffsetAndEpoch() Return the last materialized source offset and epoch
long	materializationLag() Return the current tier materialization lag.
CompletableFuture<Optional<kafka.log.TierLogSegment>>	materializeUptoLeaderEpoch(int targetEpoch) Listen for the flushed materialization state to reach or surpass the provided LeaderEpoch.
CompletableFuture<kafka.log.TierLogSegment>	materializeUptoObjectIdAndRestoreEpoch(long upperBoundEndOffset, UUID targetObjectId, int targetRestoreEpoch) Listen for the flushed materialization state to materialize a fully uploaded segment matching the provided targetObjectId.
CompletableFuture<kafka.log.TierLogSegment>	materializeUptoOffset(long targetOffset) Listen for the flushed materialization state to reach or surpass the provided targetOffset.
boolean	maybeOpenChannelOnOffsetTieredException() Called when a replica receives OFFSET_TIERED exception while replicating from leader.
boolean	mayContainTieredData() Indicates if a partition may have some tiered data, essentially whether tiered storage is currently enabled or was enabled earlier for this partition.
Optional<kafka.log.TierLogSegment>	metadata(long targetOffset) Lookup the TierObjectMetadata which will contain data for a target offset.
int	numSegments() Scan the ObjectMetadata (segment) entries in this tier partition, and return the count.
int	numSegments(long from, long to) Count of the number of segments lying within a range
void	onCatchUpComplete() Mark catchup completed for tier partition state.
Optional<SegmentState>	previousMetadataBeforeOffset(long targetStartOffset) Get the in-memory metadata for the immediate previous segment (even beyond retention) to target startOffset
TierPartitionState.RestoreResult	processRestoreEvents(AbstractTierMetadata event, Optional<ByteBuffer> targetStateOpt, TierPartitionStatus targetStatus, OffsetAndEpoch offsetAndEpoch) Processes one of the recovery events TierPartitionForceRestore or TierPartitionUnfreezeLogStartOffset.
TierPartitionState.RestoreResult	processUnfreezeLogStartOffset(TierPartitionUnfreezeLogStartOffset metadata, TierPartitionStatus restoreStatus, OffsetAndEpoch sourceOffsetAndEpoch) Unfreeze log start offset at the MergedLog.
static Optional<Header>	readHeader(CheckedFileIO channel)
List<SegmentState>	segmentInMemoryMetadataRange(long from, long to) List of all the segment (minimal) metadata whose startOffset is in the range (even if they are beyond retention).
Iterator<kafka.log.TierLogSegment>	segments() Get an iterator for all readable tiered segments.
Iterator<kafka.log.TierLogSegment>	segments(long from, long to) Get an iterator for all readable tiered segments in a given range.
void	setTieredPartitionRecoveryWorkflowCb(Consumer<TierPartitionState.RecoveryOperation> cb) Sets the callback function used by tier partition state to communicate to the MergedLog layer during recovery of a tiered partition.
void	setTieringDisabled() Reset the tier(ing) enabled flag at TierPartitionState.
boolean	setTieringEnabled() Called when tiering is enabled for this tier topic partition.
boolean	setTopicId(UUID topicId) Sets the TopicIdPartition for this TierPartitionState.
Optional<Long>	startOffset() Determine start offset spanned by the TierPartitionState.
TierPartitionStatus	status() Return the current status of the TierPartitionState.
int	tierEpoch() Return the current tierEpoch.
Optional<TopicIdPartition>	topicIdPartition() Optional TopicIdPartition corresponding to this TierPartition If one has not been set, returns empty
org.apache.kafka.common.TopicPartition	topicPartition() The topic-partition corresponding to this TierPartition.
String	toString()
long	totalSize() Sum the size of all segment spanned by this TierPartitionState.
CompletableFuture<Boolean>	trackMetadataInitialization(int targetLeaderEpoch) Listen for the flushed materialization state to materialize up to or past the provided leader epoch.
void	updateDir(File dir) Update the directory reference for the log and indices in this segment.
boolean	validateChecksum() Validates the integrity by computing the checksum and validating the checksum.
static void	writeHeader(CheckedFileIO channel, Header header)

Methods inherited from class java.lang.Object

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

Field Detail

SUPER_BLOCK_LENGTH_ADLER

public static final short SUPER_BLOCK_LENGTH_ADLER

See Also:

Constant Field Values

SUPER_BLOCK_LENGTH_NO_CHECKSUM

public static final short SUPER_BLOCK_LENGTH_NO_CHECKSUM

See Also:

Constant Field Values

Constructor Detail

FileTierPartitionState

public FileTierPartitionState(File dir,
                              kafka.server.LogDirFailureChannel logDirFailureChannel,
                              org.apache.kafka.common.TopicPartition topicPartition,
                              boolean tieringEnabled,
                              kafka.utils.Scheduler scheduler,
                              boolean checksumEnabled)
                       throws IOException

Throws:

IOException

Method Detail

topicPartition

public org.apache.kafka.common.TopicPartition topicPartition()

Description copied from interface: TierPartitionState

The topic-partition corresponding to this TierPartition.

Specified by:

topicPartition in interface TierPartitionState

Returns:

topic-partition

topicIdPartition

public Optional<TopicIdPartition> topicIdPartition()

Description copied from interface: TierPartitionState

Optional TopicIdPartition corresponding to this TierPartition If one has not been set, returns empty

Specified by:

topicIdPartition in interface TierPartitionState

Returns:

TopicIdPartition

setTopicId

public boolean setTopicId(UUID topicId)
                   throws IOException

Description copied from interface: TierPartitionState

Sets the TopicIdPartition for this TierPartitionState. Will open the TierPartitionState if tiering is enabled, and a TopicIdPartition was not previously set or able to be read from the FileTierPartitionState header.

Specified by:

setTopicId in interface TierPartitionState

Parameters:

topicId - The topic id to assign

Returns:

true if a TopicIdPartition was not set and one has now been set, false otherwise

Throws:

IOException

isTieringEnabled

public boolean isTieringEnabled()

Specified by:

isTieringEnabled in interface TierPartitionState

setTieringEnabled

public boolean setTieringEnabled()
                          throws IOException

Description copied from interface: TierPartitionState

Called when tiering is enabled for this tier topic partition.

Specified by:

setTieringEnabled in interface TierPartitionState

Returns:

true if the TierPartitionState channel is opened by this method; false if the channel was already open. Caller will use this flag to register TierPartitionState with TierTopicConsumer for materialization.

Throws:

IOException

setTieringDisabled

public void setTieringDisabled()

Description copied from interface: TierPartitionState

Reset the tier(ing) enabled flag at TierPartitionState. This function is called when tiered storage is disabled for the partition.

Specified by:

setTieringDisabled in interface TierPartitionState

startOffset

public Optional<Long> startOffset()

Description copied from interface: TierPartitionState

Determine start offset spanned by the TierPartitionState.

Specified by:

startOffset in interface TierPartitionState

Returns:

start offset

endOffset

public long endOffset()

Description copied from interface: TierPartitionState

Return the uncommitted end offset spanned by the TierPartitionState.

Specified by:

endOffset in interface TierPartitionState

Returns:

end offset or -1 if not set

committedEndOffset

public long committedEndOffset()

Description copied from interface: TierPartitionState

Return the end offset spanned by the TierPartitionState that has been committed to disk.

Specified by:

committedEndOffset in interface TierPartitionState

Returns:

end offset or -1 if not set

totalSize

public long totalSize()

Description copied from interface: TierPartitionState

Sum the size of all segment spanned by this TierPartitionState.

Specified by:

totalSize in interface TierPartitionState

Returns:

total size

flush

public boolean flush()
              throws IOException

Description copied from interface: TierPartitionState

Flush data contained in this TierPartitionState to disk.

Specified by:

flush in interface TierPartitionState

Returns:

true if the flush operation succeeded false otherwise if the flush was not attempted

Throws:

IOException - if the flush operation failed

validateChecksum

public boolean validateChecksum()
                         throws IOException,
                                InstantiationException,
                                IllegalAccessException

Description copied from interface: TierPartitionState

Validates the integrity by computing the checksum and validating the checksum. This feature is supported only if checksum is enabled else it is no-op and return true. This call is done under write lock so that no other write is in progress.

Specified by:

validateChecksum in interface TierPartitionState

Returns:

true if the checksum based validation is true. It also returns true by default for checksum disabled mode. Other wise it returns false.

Throws:

IOException

InstantiationException

IllegalAccessException

tierEpoch

public int tierEpoch()

Description copied from interface: TierPartitionState

Return the current tierEpoch. Metadata will only be added to TierPartitionState if the metadata's tierEpoch is equal to the TierPartitionState's tierEpoch.

Specified by:

tierEpoch in interface TierPartitionState

Returns:

tierEpoch

dir

public File dir()

Description copied from interface: TierPartitionState

The directory where the TierPartition is stored on disk.

Specified by:

dir in interface TierPartitionState

Returns:

file handle for the directory

delete

public void delete()
            throws IOException

Description copied from interface: TierPartitionState

Delete this TierPartitionState from local storage.

Specified by:

delete in interface TierPartitionState

Throws:

IOException

updateDir

public void updateDir(File dir)

Description copied from interface: TierPartitionState

Update the directory reference for the log and indices in this segment. This would typically be called after a directory is renamed.

Specified by:

updateDir in interface TierPartitionState

Parameters:

dir - The new directory

forceRestoreState

public TierPartitionState.RestoreResult forceRestoreState(TierPartitionForceRestore metadata,
                                                          ByteBuffer targetState,
                                                          TierPartitionStatus targetStatus,
                                                          OffsetAndEpoch offsetAndEpoch)

Performs a TierPartitionState restore, swapping the current state file from buffer and replacing any internal state with the contents of the new TierPartitionState, setting the TierPartitionStatus of the state to status.

Parameters:

metadata - the TierPartitionForceRestore metadata including the coordinates and metadata about the state to be restored.

targetState - ByteBuffer containing the contents of the TierPartitionState to restore

targetStatus - the status that the TierPartitionState will be transitioned to upon successful restoration

offsetAndEpoch - Offset and epoch corresponding to this metadata entry

Returns:

Returns a RestoreResult: - When SUCCEEDED, it means the restore was successful, and the `TierPartitionState` status has been set to the `targetStatus`. - When FAILED, it means the restore failed, and the `TierPartitionState` status has not been changed. It is expected that the underlying state has not undergone any significant modifications during this failure.

processRestoreEvents

public TierPartitionState.RestoreResult processRestoreEvents(AbstractTierMetadata event,
                                                             Optional<ByteBuffer> targetStateOpt,
                                                             TierPartitionStatus targetStatus,
                                                             OffsetAndEpoch offsetAndEpoch)

Description copied from interface: TierPartitionState

Processes one of the recovery events TierPartitionForceRestore or TierPartitionUnfreezeLogStartOffset.

Specified by:

processRestoreEvents in interface TierPartitionState

Parameters:

event - the metadata event to be processed

targetStateOpt - ByteBuffer containing the contents of the TierPartitionState to restore

targetStatus - the status that the TierPartitionState will be transitioned to upon successful restoration

offsetAndEpoch - Offset and epoch corresponding to this metadata entry

Returns:

Returns a RestoreResult: - When SUCCEEDED, it means the restore event was successfully processed, and the `TierPartitionState` status has been set to the `targetStatus`. - When FAILED, it means the restore failed. It is expected that the underlying state has not undergone any significant modifications during this failure.

processUnfreezeLogStartOffset

public TierPartitionState.RestoreResult processUnfreezeLogStartOffset(TierPartitionUnfreezeLogStartOffset metadata,
                                                                      TierPartitionStatus restoreStatus,
                                                                      OffsetAndEpoch sourceOffsetAndEpoch)
                                                               throws org.apache.kafka.common.errors.KafkaStorageException

Unfreeze log start offset at the MergedLog. This method is invoked as part of data or metadata recovery for a tiered topic partition. Such recovery flow freezes the log start offset at the beginning and it needs to be un-frozen at the end.

Parameters:

metadata - metadata event to unfreeze log start offset

restoreStatus - TierPartitionStatus to restore the topic partition to, once log start offset is unfrozen. Valid values are TierPartitionStatus.ONLINE and TierPartitionStatus.CATCHUP

sourceOffsetAndEpoch - offset and epoch for the metadata event

Returns:

RestoreResult indicating if the metadata event was processed successfully or not

Throws:

org.apache.kafka.common.errors.KafkaStorageException

closeHandlers

public void closeHandlers()
                   throws IOException

Specified by:

closeHandlers in interface TierPartitionState

Throws:

IOException

status

public TierPartitionStatus status()

Description copied from interface: TierPartitionState

Return the current status of the TierPartitionState.

Specified by:

status in interface TierPartitionState

Returns:

TierPartitionStatus

materializationLag

public long materializationLag()

Description copied from interface: TierPartitionState

Return the current tier materialization lag.

Specified by:

materializationLag in interface TierPartitionState

Returns:

long

beginCatchup

public void beginCatchup()

Description copied from interface: TierPartitionState

Begin catchup phase for tier partition state.

Specified by:

beginCatchup in interface TierPartitionState

onCatchUpComplete

public void onCatchUpComplete()

Description copied from interface: TierPartitionState

Mark catchup completed for tier partition state.

Specified by:

onCatchUpComplete in interface TierPartitionState

numSegments

public int numSegments(long from,
                       long to)

Description copied from interface: TierPartitionState

Count of the number of segments lying within a range

Specified by:

numSegments in interface TierPartitionState

Parameters:

from - Start of the range, include segment which contains "from" (inclusive)

to - End of the range, upper bound exclusive offset to include or the end of the log if "to" is past the end

Returns:

number of tiered segments

numSegments

public int numSegments()

Description copied from interface: TierPartitionState

Scan the ObjectMetadata (segment) entries in this tier partition, and return the count.

Specified by:

numSegments in interface TierPartitionState

Returns:

number of tiered segments

materializeUptoOffset

public CompletableFuture<kafka.log.TierLogSegment> materializeUptoOffset(long targetOffset)
                                                                  throws IOException

Listen for the flushed materialization state to reach or surpass the provided targetOffset.

Specified by:

materializeUptoOffset in interface TierPartitionState

Parameters:

targetOffset - The minimum materialized offset required to complete this listener.

Returns:

A future resolving to a flushed TierObjectMetadata entry with an end offset greater than the targetOffset. The returned future can complete exceptionally, in which case the listener may need to be re-registered.

Throws:

IOException - Propagated from the listener.

materializeUptoObjectIdAndRestoreEpoch

public CompletableFuture<kafka.log.TierLogSegment> materializeUptoObjectIdAndRestoreEpoch(long upperBoundEndOffset,
                                                                                          UUID targetObjectId,
                                                                                          int targetRestoreEpoch)
                                                                                   throws IOException

Listen for the flushed materialization state to materialize a fully uploaded segment matching the provided targetObjectId. Completion will only occur if the targetObjectId is found at an TierPartitionState restore epoch equal to or greater than the provided targetRestoreEpoch.

Specified by:

materializeUptoObjectIdAndRestoreEpoch in interface TierPartitionState

Parameters:

upperBoundEndOffset - The upper bound end offset of the targetObjectId. This is used to set an upper bound for which the targetObjectId (at the targetRestoreEpoch) will not be found above. The upperBoundEndOffset is also used to provide approximate materialization progress for the materialization lag metric.

targetObjectId - The objectId of the target TierObjectMetadata. The listener will only complete if this objectId is found.

targetRestoreEpoch - The target TierPartitionState restore epoch. The listener will only complete if materialization has made it up to or surpassed this restore epoch.

Returns:

A future resolving to the TierObjectMetadata associated with the targetObjectId, materialized at or above the targetRestoreEpoch. The returned future can complete exceptionally, in which case the listener may need to be re-registered.

Throws:

IOException - Propagated from the listener.

materializeUptoLeaderEpoch

public CompletableFuture<Optional<kafka.log.TierLogSegment>> materializeUptoLeaderEpoch(int targetEpoch)
                                                                                 throws IOException

Listen for the flushed materialization state to reach or surpass the provided LeaderEpoch.

Specified by:

materializeUptoLeaderEpoch in interface TierPartitionState

Parameters:

targetEpoch - The minimum LeaderEpoch required to complete this listener.

Returns:

A future resolving to a the flushed TierObjectMetadata at the highest valid offset at completion time, or none if there are no valid tiered segments. The returned future can complete exceptionally, in which case the listener may need to be re-registered.

Throws:

IOException - Propagated from the listener.

trackMetadataInitialization

public CompletableFuture<Boolean> trackMetadataInitialization(int targetLeaderEpoch)
                                                       throws IOException

Listen for the flushed materialization state to materialize up to or past the provided leader epoch.

Specified by:

trackMetadataInitialization in interface TierPartitionState

Parameters:

targetLeaderEpoch - The minimum leader epoch required to complete this listener.

Returns:

A future resolving to true if the provided targetLeaderEpoch was materialized. The returned future can complete exceptionally, in which case the listener should be re-registered.

Throws:

IllegalStateException - Thrown if there was an existing metadata initialization listener registered.

IOException - Propagated from the listener.

close

public void close()
           throws IOException

Description copied from interface: TierPartitionState

Close TierPartition, flushing to disk.

Specified by:

close in interface AutoCloseable

Specified by:

close in interface TierPartitionState

Throws:

IOException

append

public TierPartitionState.AppendResult append(AbstractTierMetadata metadata,
                                              OffsetAndEpoch offsetAndEpoch)

Description copied from interface: TierPartitionState

Appends abstract metadata to the tier partition. Dispatches to more specific append method. When appending a TierTopicInitLeader entry, it may advance the tierEpoch. When appending a TierObjectMetadata entry, it may append the tier metadata to the tier partition log file.

Specified by:

append in interface TierPartitionState

Parameters:

metadata - AbstractTierMetadata entry to be appended to the tier partition log.

offsetAndEpoch - Offset and epoch corresponding to this metadata entry

Returns:

Returns an AppendResult denoting the result of the append action.

segments

public Iterator<kafka.log.TierLogSegment> segments()

Description copied from interface: TierPartitionState

Get an iterator for all readable tiered segments. The returned list is in order of base offset.

Specified by:

segments in interface TierPartitionState

Returns:

an iterator of tiered segments.

segments

public Iterator<kafka.log.TierLogSegment> segments(long from,
                                                   long to)

Description copied from interface: TierPartitionState

Get an iterator for all readable tiered segments in a given range. The iterator is sorted by base offset.

Specified by:

segments in interface TierPartitionState

Parameters:

from - Start of the range, include segment which contains "from" (inclusive)

to - End of the range, upper bound exclusive offset to include or the end of the log if "to" is past the end

Returns:

an iterator of tiered segments.

segmentInMemoryMetadataRange

public List<SegmentState> segmentInMemoryMetadataRange(long from,
                                                       long to)

Description copied from interface: TierPartitionState

List of all the segment (minimal) metadata whose startOffset is in the range (even if they are beyond retention). The list is sorted by startOffset.

Specified by:

segmentInMemoryMetadataRange in interface TierPartitionState

Parameters:

from - Inclusive startOffset position

to - Inclusive endOffset position

Returns:

List of the minimal metadata objects.

previousMetadataBeforeOffset

public Optional<SegmentState> previousMetadataBeforeOffset(long targetStartOffset)

Description copied from interface: TierPartitionState

Get the in-memory metadata for the immediate previous segment (even beyond retention) to target startOffset

Specified by:

previousMetadataBeforeOffset in interface TierPartitionState

Parameters:

targetStartOffset - target startOffset

Returns:

optional immediate previous segment metadata

followerRestorePoint

public kafka.common.FollowerRestorePoint followerRestorePoint(long localLogStartOffset)

Fetch and return the FollowerRestorePoint for the given localLogStartOffset. Followers require an objectId for the tiered segment directly preceding the local log start offset, as well as the latest (if any) restore epoch to ensure they have materialized enough of the tiered log to perform a restore.

Specified by:

followerRestorePoint in interface TierPartitionState

Parameters:

localLogStartOffset - target startOffset

Returns:

TierObjectMetadata if present

metadata

public Optional<kafka.log.TierLogSegment> metadata(long targetOffset)
                                            throws IOException

Description copied from interface: TierPartitionState

Lookup the TierObjectMetadata which will contain data for a target offset.

Specified by:

metadata in interface TierPartitionState

Parameters:

targetOffset - the target offset to lookup the overlapping or next metadata for.

Returns:

The TierObjectMetadata, if any.

Throws:

IOException - if disk error encountered

lastLocalMaterializedSrcOffsetAndEpoch

public OffsetAndEpoch lastLocalMaterializedSrcOffsetAndEpoch()

Description copied from interface: TierPartitionState

Return the last materialized source offset and epoch

Specified by:

lastLocalMaterializedSrcOffsetAndEpoch in interface TierPartitionState

flushedPath

public String flushedPath()

fencedSegments

public Collection<kafka.log.TierLogSegment> fencedSegments()

Specified by:

fencedSegments in interface TierPartitionState

toString

public String toString()

Overrides:

toString in class Object

readHeader

public static Optional<Header> readHeader(CheckedFileIO channel)
                                   throws IOException

Throws:

IOException

iterator

public static Optional<FileTierPartitionIterator> iterator(org.apache.kafka.common.TopicPartition topicPartition,
                                                           CheckedFileIO channel)
                                                    throws IOException

Throws:

IOException

mayContainTieredData

public boolean mayContainTieredData()

Description copied from interface: TierPartitionState

Indicates if a partition may have some tiered data, essentially whether tiered storage is currently enabled or was enabled earlier for this partition. This method is called by work flows that require access to existing tiered segments, no matter the current status of tierEnable configuration. For example, when tierEnable is switched to false for a given topic partition, we still need to access tiered segments to serve fetch requests and open the TierPartitionState channel for keeping track of current leader epoch and tiered segments as they get deleted.

Specified by:

mayContainTieredData in interface TierPartitionState

Returns:

true when tiering is enabled currently, or at any time in the past; false otherwise

maybeOpenChannelOnOffsetTieredException

public boolean maybeOpenChannelOnOffsetTieredException()
                                                throws IOException

Description copied from interface: TierPartitionState

Called when a replica receives OFFSET_TIERED exception while replicating from leader. In case when tier storage has been disabled for the partition, a new replica added to the assignment will neither see tier.enable config set, nor will it have the flushed(persistent) TierPartitionState file from when tier.enable was true. These are the conditions to open up a TierPartitionState file for materializing the tier state for a tiered partition. This method opens the TierPartitionState file for such replicas. Caller will use the returned value to register FileTierPartitionState with TierTopicConsumer for materialization.

Specified by:

maybeOpenChannelOnOffsetTieredException in interface TierPartitionState

Returns:

true, if TierPartitionState file was opened by this method; false otherwise.

Throws:

IOException

writeHeader

public static void writeHeader(CheckedFileIO channel,
                               Header header)
                        throws IOException

Throws:

IOException

setTieredPartitionRecoveryWorkflowCb

public void setTieredPartitionRecoveryWorkflowCb(Consumer<TierPartitionState.RecoveryOperation> cb)

Description copied from interface: TierPartitionState

Sets the callback function used by tier partition state to communicate to the MergedLog layer during recovery of a tiered partition.

Specified by:

setTieredPartitionRecoveryWorkflowCb in interface TierPartitionState

Parameters:

cb - callback function that takes a TierPartitionState.RecoveryOperation as a parameter

isErrorStatusReachedViaFenceEvent

public boolean isErrorStatusReachedViaFenceEvent()