local

type DataSyncer ¶

type DataSyncer func() error

DataSyncer is a callback that PeriodicSyncer.ProcessLocationsChanged() invokes into to request that the contents of objects are synchronized to disk.

Synchronizing these is a requirements to ensure that the ReferenceLocationMap does not reference objects that are only partially written.

type EpochIDResolver ¶

type EpochIDResolver interface {
	GetEpochStateForEpochID(epochID uint32) (EpochState, bool)
	GetCurrentEpochState() (EpochState, uint32)
}

EpochIDResolver is used by implementations of ReferenceLocationRecordArray to determine whether any entries it stores still point to valid data in the location-blob map.

type EpochList ¶

type EpochList interface {
	EpochIDResolver

	// Indicate that a write of an object to the location-blob map
	// ending at a given location has completed, and that a
	// reference-location map entry is about to be written.
	FinalizeWriteUpToLocation(location uint64) error

	// Indicate that an object ending at a given location was read
	// from the location-blob map, but that its contents were
	// invalid. This means that either data corruption has occurred,
	// or that the object got overwritten while being read.
	DiscardUpToLocation(location uint64)
}

EpochList is used by the local object store to manage the creation and lifetime of epochs. Epochs are assigned to reference-location map entries and act as a way of ensuring consistency between the reference-location map and location-blob map, even if unclean shutdowns are performed.

func NewVolatileEpochList(maximumLocationSpan uint64, randomNumberGenerator random.SingleThreadedGenerator) EpochList

type EpochState ¶

type EpochState struct {
	HashSeed        uint64
	MinimumLocation uint64
	MaximumLocation uint64
}

EpochState describes for a given state what the range of valid locations are. This allows implementations of ReferenceLocationRecordArray to suppress and overwrite entries that are no longer valid.

EpochState also contains a hash seed that may be used by ReferenceLocationRecordArray when computing hashes of entries. This is needed to ensure that entries belonging to previous unclean shutdowns are suppressed.

func (s *EpochState) IsValidLocation(location uint64, sizeBytes int) bool

type LocationBlobMap ¶

type LocationBlobMap interface {
	Get(location uint64, sizeBytes int) ([]byte, error)
	Put([]byte) (uint64, error)
	GetNextPutLocation() uint64
}

LocationBlobMap is a map of object location to its contents. Every time an object is stored, it is assigned a location. Locations are expected to increase monotonically. As storage space is only finite, implementations of LocationBlobMap are expected to behave like ring buffers. Once space is exhausted, objects with the lowest location values are expected to be overwritten.

func NewBlockDeviceBackedLocationBlobMap(blockDevice blockdevice.BlockDevice, sectorSizeBytes int, sectorCount int64, initialLocation uint64) LocationBlobMap

func NewInMemoryLocationBlobMap(sizeBytes int) LocationBlobMap

type PeriodicSyncer ¶

type PeriodicSyncer struct {
	// contains filtered or unexported fields
}

PeriodicSyncer can be used to monitor PersistentEpochList for allocations for storing objects. When such events occur, the state of the PersistentEpochList is extracted and written to disk. This allows its contents to be recovered after a restart.

func NewPeriodicSyncer(
	source PersistentStateSource,
	sourceLock *sync.RWMutex,
	store PersistentStateStore,
	clock clock.Clock,
	errorLogger util.ErrorLogger,
	errorRetryInterval,
	minimumEpochInterval time.Duration,
	referenceLocationMapHashInitialization uint64,
	dataSyncer DataSyncer,
) *PeriodicSyncer

func (ps *PeriodicSyncer) ProcessLocationsChanged(ctx context.Context) bool

type PersistentEpochList ¶

type PersistentEpochList struct {
	// contains filtered or unexported fields
}

PersistentEpochList is an implementation of EpochList whose internal state can be extracted and persisted. This allows data contained in the local object store to be accessed after restarts.

func NewPersistentEpochList(
	maximumLocationSpan uint64,
	randomNumberGenerator random.SingleThreadedGenerator,
	minimumEpochID uint32,
	minimumLocation uint64,
	epochs []*pb.EpochState,
) *PersistentEpochList

func (el *PersistentEpochList) DiscardUpToLocation(location uint64)

func (el *PersistentEpochList) FinalizeWriteUpToLocation(location uint64) error

func (el *PersistentEpochList) GetCurrentEpochState() (EpochState, uint32)

func (el *PersistentEpochList) GetEpochStateForEpochID(epochID uint32) (EpochState, bool)

func (el *PersistentEpochList) GetLocationsChangedWakeup() <-chan struct{}

func (el *PersistentEpochList) GetPersistentState() (uint32, uint64, []*pb.EpochState)

func (el *PersistentEpochList) NotifySyncCompleted()

func (el *PersistentEpochList) NotifySyncStarting(isFinalSync bool)

type PersistentStateSource ¶

type PersistentStateSource interface {
	// GetLocationsChangedWakeup returns a channel that triggers if
	// allocations for storing object contents have been made
	// against an EpochList, or if data is being discarded. This can
	// be used by PeriodicSyncer to synchronize data to storage.
	// PeriodicSyncer may apply a short delay before actually
	// synchronize data to perform some batching.
	//
	// This function must be called while holding a read lock on the
	// EpochList.
	GetLocationsChangedWakeup() <-chan struct{}

	// NotifySyncStarting instructs the EpochList that
	// PeriodicSyncer is about to synchronize data to storage.
	// Successive writes to the EpochList should use a new epoch ID,
	// as there is no guarantee their data is synchronized as part
	// of the current epoch.
	//
	// This function must be called while holding a write lock on
	// the EpochList.
	NotifySyncStarting(isFinalSync bool)

	// NotifySyncCompleted instructs the EpochList that the
	// synchronization performed after the last call to
	// NotifySyncStarting was successful.
	//
	// Future calls to GetPersistentState may now return information
	// about epochs that were created before the previous
	// NotifySyncStarting call.
	//
	// Calling this function may cause the next channel returned by
	// GetLocationsChangedWakeup to block once again.
	//
	// This function must be called while holding a write lock on
	// the EpochList.
	NotifySyncCompleted()

	// GetPersistentState returns information about all epochs that
	// are managed by the EpochList and have been synchronized to
	// storage successfully.
	//
	// This function must be called while holding a read lock on the
	// EpochList.
	GetPersistentState() (minimumEpochID uint32, minimumLocation uint64, epochs []*pb.EpochState)
}

PersistentStateSource is used by PeriodicSyncer to determine whether the persistent state file needs to update, and if so which contents it needs to hold.

type PersistentStateStore ¶

type PersistentStateStore interface {
	ReadPersistentState() (*pb.PersistentState, error)
	WritePersistentState(persistentState *pb.PersistentState) error
}

PersistentStateStore is used by PeriodicSyncer to write PersistentBlockList's state to disk. This state can be reloaded on startup to make it possible to access data that was written in the past.

func NewDirectoryBackedPersistentStateStore(directory filesystem.Directory) PersistentStateStore

type ReferenceLocationMap ¶

type ReferenceLocationMap = lossymap.Map[object.FlatReference, uint64, EpochIDResolver]

ReferenceLocationMap is used by the local object store to keep track of the location on disk where a given object is stored.

type ReferenceLocationRecord ¶

type ReferenceLocationRecord = lossymap.Record[object.FlatReference, uint64]

ReferenceLocationRecord represents a record that is stored in a ReferenceLocationRecordArray.

type ReferenceLocationRecordArray ¶

type ReferenceLocationRecordArray = lossymap.RecordArray[object.FlatReference, uint64, EpochIDResolver]

ReferenceLocationRecordArray is an array of ReferenceLocationRecord objects. Implementations of this type are used if a ReferenceLocationMap is backed by a hash table.

func NewBlockDeviceBackedReferenceLocationRecordArray(device blockdevice.BlockDevice) ReferenceLocationRecordArray

func NewInMemoryReferenceLocationRecordArray(size int) ReferenceLocationRecordArray

type ReferenceLocationRecordKey ¶

type ReferenceLocationRecordKey = lossymap.RecordKey[object.FlatReference]

ReferenceLocationRecordKey represents the key portion of a record that is stored in a ReferenceLocationRecordArray..