rsm

package

Go to main page

Versions in this module

v3

v3.3.8

Sep 25, 2023

v3.3.7

Jun 14, 2023

v3.3.6

Dec 6, 2022

v3.3.5

Jan 13, 2022

v3.3.4

May 7, 2021

v3.3.3

May 6, 2021

v3.3.2

Apr 11, 2021

v3.3.1

Jan 31, 2021

v3.3.0

Jan 20, 2021

Changes in this version

+ func GetEncoded(ct dio.CompressionType, cmd []byte, dst []byte) []byte

+ func GetPayload(e pb.Entry) []byte

+ func IsShrunkSnapshotFile(fp string, fs vfs.IFS) (shrunk bool, err error)

+ func ReplaceSnapshot(newFp string, fp string, fs vfs.IFS) error

+ func ToDioType(ct config.CompressionType) dio.CompressionType

type BlockWriter

+ func (bw *BlockWriter) Close() error

type ConcurrentStateMachine

+ func (s *ConcurrentStateMachine) Concurrent() bool

+ func (s *ConcurrentStateMachine) OnDisk() bool

+ func (s *ConcurrentStateMachine) Prepare() (interface{}, error)

+ func (s *ConcurrentStateMachine) Recover(r io.Reader, fs []sm.SnapshotFile, stopc <-chan struct{}) error

+ func (s *ConcurrentStateMachine) Save(ctx interface{}, w io.Writer, fc sm.ISnapshotFileCollection, ...) error

+ func (s *ConcurrentStateMachine) Type() pb.StateMachineType

+ type ILoadable interface

+ LoadSessions func(io.Reader, SSVersion) error

type IManagedStateMachine

+ Close func()

+ Concurrent func() bool

+ ConcurrentLookup func(interface{}) (interface{}, error)

+ DestroyedC func() <-chan struct{}

+ NAConcurrentLookup func([]byte) ([]byte, error)

+ OnDisk func() bool

+ Prepare func() (interface{}, error)

+ Recover func(io.Reader, []sm.SnapshotFile) error

+ Save func(SSMeta, io.Writer, []byte, sm.ISnapshotFileCollection) (bool, error)

+ Stream func(interface{}, io.Writer) error

+ Type func() pb.StateMachineType

type INode

+ StepReady func()

+ type IRecoverable interface

+ Recover func(io.Reader, []sm.SnapshotFile) error

type ISavable

+ Save func(SSMeta, io.Writer, []byte, sm.ISnapshotFileCollection) (bool, error)

type ISnapshotter

+ Shrunk func(ss pb.Snapshot) (bool, error)

type IStateMachine

+ Concurrent func() bool

+ OnDisk func() bool

+ Prepare func() (interface{}, error)

+ Recover func(io.Reader, []sm.SnapshotFile, <-chan struct{}) error

+ Save func(interface{}, io.Writer, sm.ISnapshotFileCollection, <-chan struct{}) error

+ Type func() pb.StateMachineType

type IStreamable

+ Stream func(interface{}, io.Writer) error

+ type InMemStateMachine struct

+ func NewInMemStateMachine(s sm.IStateMachine) *InMemStateMachine

+ func (i *InMemStateMachine) Close() error

+ func (i *InMemStateMachine) Concurrent() bool

+ func (i *InMemStateMachine) GetHash() (uint64, error)

+ func (i *InMemStateMachine) Lookup(query interface{}) (interface{}, error)

+ func (i *InMemStateMachine) NALookup(query []byte) ([]byte, error)

+ func (i *InMemStateMachine) OnDisk() bool

+ func (i *InMemStateMachine) Open(stopc <-chan struct{}) (uint64, error)

+ func (i *InMemStateMachine) Prepare() (interface{}, error)

+ func (i *InMemStateMachine) Recover(r io.Reader, fs []sm.SnapshotFile, stopc <-chan struct{}) error

+ func (i *InMemStateMachine) Save(ctx interface{}, w io.Writer, fc sm.ISnapshotFileCollection, ...) error

+ func (i *InMemStateMachine) Sync() error

+ func (i *InMemStateMachine) Type() pb.StateMachineType

+ func (i *InMemStateMachine) Update(entries []sm.Entry) ([]sm.Entry, error)

type NativeSM

+ func (ds *NativeSM) Close()

+ func (ds *NativeSM) Concurrent() bool

+ func (ds *NativeSM) ConcurrentLookup(query interface{}) (interface{}, error)

+ func (ds *NativeSM) DestroyedC() <-chan struct{}

+ func (ds *NativeSM) NAConcurrentLookup(query []byte) ([]byte, error)

+ func (ds *NativeSM) OnDisk() bool

+ func (ds *NativeSM) Prepare() (interface{}, error)

+ func (ds *NativeSM) Recover(r io.Reader, files []sm.SnapshotFile) error

+ func (ds *NativeSM) Save(meta SSMeta, w io.Writer, session []byte, c sm.ISnapshotFileCollection) (bool, error)

+ func (ds *NativeSM) Stream(ctx interface{}, w io.Writer) error

+ func (ds *NativeSM) Type() pb.StateMachineType

type OffloadedStatus

+ DestroyedC chan struct{}

type OnDiskStateMachine

+ func (s *OnDiskStateMachine) Concurrent() bool

+ func (s *OnDiskStateMachine) OnDisk() bool

+ func (s *OnDiskStateMachine) Prepare() (interface{}, error)

+ func (s *OnDiskStateMachine) Recover(r io.Reader, fs []sm.SnapshotFile, stopc <-chan struct{}) error

+ func (s *OnDiskStateMachine) Save(ctx interface{}, w io.Writer, fc sm.ISnapshotFileCollection, ...) error

+ func (s *OnDiskStateMachine) Type() pb.StateMachineType

+ type SSEnv = server.SSEnv

type SSReqType

+ const Exported

+ const Periodic

+ const Streaming

+ const UserRequested

type SSRequest

+ func (r *SSRequest) Exported() bool

+ func (r *SSRequest) Streaming() bool

type SSVersion

+ const DefaultVersion

+ const HeaderSize

+ const V1

+ const V2

type StateMachine

+ func (s *StateMachine) Close()

+ func (s *StateMachine) DestroyedC() <-chan struct{}

+ func (s *StateMachine) ReadyToStream() bool

+ func (s *StateMachine) Recover(t Task) (uint64, error)

+ func (s *StateMachine) Save(req SSRequest) (pb.Snapshot, SSEnv, error)

+ func (s *StateMachine) SetLastApplied(index uint64)

+ func (s *StateMachine) Stream(sink pb.IChunkSink) error

+ func (s *StateMachine) Type() pb.StateMachineType

type Task

+ Initial bool

+ Recover bool

+ Save bool

+ Stream bool

type TaskQueue

+ func (tq *TaskQueue) GetAll() []Task

v3.2.8

Sep 16, 2020

v3.2.7

Sep 7, 2020

v3.2.6

Aug 22, 2020

v3.2.5

Aug 14, 2020

v3.2.4

Aug 8, 2020

v3.2.3

May 21, 2020

v3.2.2

Apr 19, 2020

v3.2.1

Apr 19, 2020

v3.2.0

Mar 5, 2020

Changes in this version

+ const EEHasSession

+ const EEHeaderSize

+ const EENoCompression

+ const EENoSession

+ const EESnappy

+ const EEV0

+ const EEV0SizeOffset

+ const EEVersion

+ func GetEncodedPayload(ct dio.CompressionType, cmd []byte, dst []byte) []byte

+ func GetEntryPayload(e pb.Entry) []byte

+ func GetMaxBlockSize(ct config.CompressionType) uint64

+ func GetWitnessSnapshot(fs vfs.IFS) ([]byte, error)

+ func ToDioCompressionType(ct config.CompressionType) dio.CompressionType

type IManagedStateMachine

+ func NewNativeSM(config config.Config, ism IStateMachine, done <-chan struct{}) IManagedStateMachine

+ type INode interface

+ ApplyConfigChange func(pb.ConfigChange)

+ ApplyUpdate func(pb.Entry, sm.Result, bool, bool, bool)

+ ClusterID func() uint64

+ ConfigChangeProcessed func(uint64, bool)

+ NodeID func() uint64

+ NodeReady func()

+ RestoreRemotes func(pb.Snapshot)

+ ShouldStop func() <-chan struct{}

+ type ITestFS interface

+ SetTestFS func(fs config.IFS)

+ type NativeSM struct

+ func (ds *NativeSM) BatchedUpdate(ents []sm.Entry) ([]sm.Entry, error)

+ func (ds *NativeSM) ConcurrentSnapshot() bool

+ func (ds *NativeSM) GetHash() (uint64, error)

+ func (ds *NativeSM) Loaded(from From)

+ func (ds *NativeSM) Lookup(query interface{}) (interface{}, error)

+ func (ds *NativeSM) NALookup(query []byte) ([]byte, error)

+ func (ds *NativeSM) Offloaded(from From) bool

+ func (ds *NativeSM) OnDiskStateMachine() bool

+ func (ds *NativeSM) Open() (uint64, error)

+ func (ds *NativeSM) PrepareSnapshot() (interface{}, error)

+ func (ds *NativeSM) RecoverFromSnapshot(r io.Reader, files []sm.SnapshotFile) error

+ func (ds *NativeSM) SaveSnapshot(meta *SSMeta, w io.Writer, session []byte, ...) (bool, error)

+ func (ds *NativeSM) StateMachineType() pb.StateMachineType

+ func (ds *NativeSM) StreamSnapshot(ssctx interface{}, w io.Writer) error

+ func (ds *NativeSM) Sync() error

+ func (ds *NativeSM) Update(e sm.Entry) (sm.Result, error)

type OnDiskStateMachine

+ func (s *OnDiskStateMachine) SetTestFS(fs config.IFS)

+ type SSMeta struct

+ CompressionType config.CompressionType

+ Ctx interface{}

+ From uint64

+ Index uint64

+ Membership pb.Membership

+ OnDiskIndex uint64

+ Request SSRequest

+ Session *bytes.Buffer

+ Term uint64

+ Type pb.StateMachineType

+ type SSReqType uint64

+ const StreamSnapshot

+ type SSRequest struct

+ CompactionOverhead uint64

+ Key uint64

+ OverrideCompaction bool

+ Path string

+ Type SSReqType

+ func (r *SSRequest) IsExportedSnapshot() bool

+ func (r *SSRequest) IsStreamingSnapshot() bool

+ type SSVersion uint64

type StateMachine

+ func (s *StateMachine) Concurrent() bool

type Task

+ SSRequest SSRequest

v3.1.5

Dec 7, 2019

v3.1.4

Oct 24, 2019

v3.1.3

Sep 7, 2019

v3.1.2

Aug 5, 2019

v3.1.1

Aug 4, 2019

v3.1.0

Jul 4, 2019

Changes in this version

type SnapshotMeta

+ OnDiskIndex uint64

v3.0.2

Jun 26, 2019

v3.0.1

Jun 24, 2019

v3.0.0

Jun 21, 2019

Changes in this version

+ const ChunkSize

+ const EmptyClientSessionLength

+ var ErrClusterClosed = errors.New("raft cluster already closed")

+ var ErrRestoreSnapshot = errors.New("failed to restore from snapshot")

+ var ErrSaveSnapshot = errors.New("failed to save snapshot")

+ var ErrTestKnobReturn = errors.New("returned earlier due to test knob")

+ var LRUMaxSessionCount = settings.Hard.LRUMaxSessionCount

+ func GetDefaultChecksum() hash.Hash

+ func GetEmptyLRUSession() []byte

+ func GetV2PayloadChecksum(fp string) (crc []byte, err error)

+ func GetV2PayloadSize(sz uint64) uint64

+ func IsShrinkedSnapshotFile(fp string) (shrunk bool, err error)

+ func ReplaceSnapshotFile(newFp string, fp string) error

+ func ShrinkSnapshot(fp string, newFp string) (err error)

+ type BlockWriter struct

+ func NewBlockWriter(blockSize uint64, onNewBlock func(data []byte, crc []byte) error, ...) *BlockWriter

+ func (bw *BlockWriter) Flush() error

+ func (bw *BlockWriter) GetPayloadChecksum() []byte

+ func (bw *BlockWriter) Write(bs []byte) (int, error)

+ type ChunkWriter struct

+ func NewChunkWriter(sink pb.IChunkSink, meta *SnapshotMeta) *ChunkWriter

+ func (cw *ChunkWriter) Close() error

+ func (cw *ChunkWriter) Write(data []byte) (int, error)

+ type ConcurrentStateMachine struct

+ func NewConcurrentStateMachine(s sm.IConcurrentStateMachine) *ConcurrentStateMachine

+ func (s *ConcurrentStateMachine) Close() error

+ func (s *ConcurrentStateMachine) ConcurrentSnapshot() bool

+ func (s *ConcurrentStateMachine) GetHash() (uint64, error)

+ func (s *ConcurrentStateMachine) Lookup(query interface{}) (interface{}, error)

+ func (s *ConcurrentStateMachine) NALookup(query []byte) ([]byte, error)

+ func (s *ConcurrentStateMachine) OnDiskStateMachine() bool

+ func (s *ConcurrentStateMachine) Open(stopc <-chan struct{}) (uint64, error)

+ func (s *ConcurrentStateMachine) PrepareSnapshot() (interface{}, error)

+ func (s *ConcurrentStateMachine) RecoverFromSnapshot(index uint64, r io.Reader, fs []sm.SnapshotFile, stopc <-chan struct{}) error

+ func (s *ConcurrentStateMachine) SaveSnapshot(ctx interface{}, w io.Writer, fc sm.ISnapshotFileCollection, ...) error

+ func (s *ConcurrentStateMachine) StateMachineType() pb.StateMachineType

+ func (s *ConcurrentStateMachine) Sync() error

+ func (s *ConcurrentStateMachine) Update(entries []sm.Entry) ([]sm.Entry, error)

+ type Files struct

+ func NewFileCollection() *Files

+ func (fc *Files) AddFile(fileID uint64, path string, metadata []byte)

+ func (fc *Files) GetFileAt(idx uint64) *pb.SnapshotFile

+ func (fc *Files) PrepareFiles(tmpdir string, finaldir string) ([]*pb.SnapshotFile, error)

+ func (fc *Files) Size() uint64

+ type From uint64

+ const FromCommitWorker

+ const FromNodeHost

+ const FromSnapshotWorker

+ const FromStepWorker

+ func (f From) String() string

+ type IBlockWriter interface

+ Flush func() error

+ GetPayloadChecksum func() []byte

+ Write func(bs []byte) (int, error)

+ type ILoadableSM interface

+ RecoverFromSnapshot func(uint64, *SnapshotReader, []sm.SnapshotFile) error

+ type ILoadableSessions interface

+ LoadSessions func(io.Reader, SnapshotVersion) error

+ type IManagedStateMachine interface

+ BatchedUpdate func([]sm.Entry) ([]sm.Entry, error)

+ ConcurrentSnapshot func() bool

+ GetHash func() (uint64, error)

+ Loaded func(From)

+ Lookup func(interface{}) (interface{}, error)

+ NALookup func([]byte) ([]byte, error)

+ Offloaded func(From)

+ OnDiskStateMachine func() bool

+ Open func() (uint64, error)

+ PrepareSnapshot func() (interface{}, error)

+ RecoverFromSnapshot func(uint64, *SnapshotReader, []sm.SnapshotFile) error

+ SaveSnapshot func(*SnapshotMeta, *SnapshotWriter, []byte, sm.ISnapshotFileCollection) (bool, uint64, error)

+ StateMachineType func() pb.StateMachineType

+ StreamSnapshot func(interface{}, *ChunkWriter) error

+ Sync func() error

+ Update func(*Session, pb.Entry) (sm.Result, error)

+ func NewNativeStateMachine(clusterID uint64, nodeID uint64, ism IStateMachine, done <-chan struct{}) IManagedStateMachine

+ type INodeProxy interface

+ ApplyConfigChange func(pb.ConfigChange)

+ ApplyUpdate func(pb.Entry, sm.Result, bool, bool, bool)

+ ClusterID func() uint64

+ ConfigChangeProcessed func(uint64, bool)

+ NodeID func() uint64

+ NodeReady func()

+ RestoreRemotes func(pb.Snapshot)

+ ShouldStop func() <-chan struct{}

+ type ISavable interface

+ SaveSnapshot func(*SnapshotMeta, *SnapshotWriter, []byte, sm.ISnapshotFileCollection) (bool, uint64, error)

+ type ISnapshotter interface

+ GetFilePath func(uint64) string

+ GetMostRecentSnapshot func() (pb.Snapshot, error)

+ GetSnapshot func(uint64) (pb.Snapshot, error)

+ IsNoSnapshotError func(error) bool

+ Load func(uint64, ILoadableSessions, ILoadableSM, string, []sm.SnapshotFile) error

+ Save func(ISavable, *SnapshotMeta) (*pb.Snapshot, *server.SnapshotEnv, error)

+ Stream func(IStreamable, *SnapshotMeta, pb.IChunkSink) error

+ type IStateMachine interface

+ Close func() error

+ ConcurrentSnapshot func() bool

+ GetHash func() (uint64, error)

+ Lookup func(query interface{}) (interface{}, error)

+ NALookup func(query []byte) ([]byte, error)

+ OnDiskStateMachine func() bool

+ Open func(<-chan struct{}) (uint64, error)

+ PrepareSnapshot func() (interface{}, error)

+ RecoverFromSnapshot func(uint64, io.Reader, []sm.SnapshotFile, <-chan struct{}) error

+ SaveSnapshot func(interface{}, io.Writer, sm.ISnapshotFileCollection, <-chan struct{}) error

+ StateMachineType func() pb.StateMachineType

+ Sync func() error

+ Update func(entries []sm.Entry) ([]sm.Entry, error)

+ type IStreamable interface

+ StreamSnapshot func(interface{}, *ChunkWriter) error

+ type IVReader interface

+ Read func(data []byte) (int, error)

+ Sum func() []byte

+ type IVValidator interface

+ AddChunk func(data []byte, chunkID uint64) bool

+ Validate func() bool

+ type IVWriter interface

+ Flush func() error

+ GetPayloadSize func(uint64) uint64

+ GetPayloadSum func() []byte

+ GetVersion func() SnapshotVersion

+ Write func(data []byte) (int, error)

+ type ManagedStateMachineFactory func(clusterID uint64, nodeID uint64, stopc <-chan struct{}) IManagedStateMachine

+ type NativeStateMachine struct

+ func (ds *NativeStateMachine) BatchedUpdate(ents []sm.Entry) ([]sm.Entry, error)

+ func (ds *NativeStateMachine) ConcurrentSnapshot() bool

+ func (ds *NativeStateMachine) GetHash() (uint64, error)

+ func (ds *NativeStateMachine) Loaded(from From)

+ func (ds *NativeStateMachine) Lookup(query interface{}) (interface{}, error)

+ func (ds *NativeStateMachine) NALookup(query []byte) ([]byte, error)

+ func (ds *NativeStateMachine) Offloaded(from From)

+ func (ds *NativeStateMachine) OnDiskStateMachine() bool

+ func (ds *NativeStateMachine) Open() (uint64, error)

+ func (ds *NativeStateMachine) PrepareSnapshot() (interface{}, error)

+ func (ds *NativeStateMachine) RecoverFromSnapshot(index uint64, reader *SnapshotReader, files []sm.SnapshotFile) error

+ func (ds *NativeStateMachine) SaveSnapshot(meta *SnapshotMeta, writer *SnapshotWriter, session []byte, ...) (bool, uint64, error)

+ func (ds *NativeStateMachine) StateMachineType() pb.StateMachineType

+ func (ds *NativeStateMachine) StreamSnapshot(ssctx interface{}, writer *ChunkWriter) error

+ func (ds *NativeStateMachine) Sync() error

+ func (ds *NativeStateMachine) Update(session *Session, e pb.Entry) (sm.Result, error)

+ type OffloadedStatus struct

+ func (o *OffloadedStatus) Destroyed() bool

+ func (o *OffloadedStatus) ReadyToDestroy() bool

+ func (o *OffloadedStatus) SetDestroyed()

+ func (o *OffloadedStatus) SetLoaded(from From)

+ func (o *OffloadedStatus) SetOffloaded(from From)

+ type OnDiskStateMachine struct

+ func NewOnDiskStateMachine(s sm.IOnDiskStateMachine) *OnDiskStateMachine

+ func (s *OnDiskStateMachine) Close() error

+ func (s *OnDiskStateMachine) ConcurrentSnapshot() bool

+ func (s *OnDiskStateMachine) GetHash() (uint64, error)

+ func (s *OnDiskStateMachine) Lookup(query interface{}) (interface{}, error)

+ func (s *OnDiskStateMachine) NALookup(query []byte) ([]byte, error)

+ func (s *OnDiskStateMachine) OnDiskStateMachine() bool

+ func (s *OnDiskStateMachine) Open(stopc <-chan struct{}) (uint64, error)

+ func (s *OnDiskStateMachine) PrepareSnapshot() (interface{}, error)

+ func (s *OnDiskStateMachine) RecoverFromSnapshot(index uint64, r io.Reader, fs []sm.SnapshotFile, stopc <-chan struct{}) error

+ func (s *OnDiskStateMachine) SaveSnapshot(ctx interface{}, w io.Writer, fc sm.ISnapshotFileCollection, ...) error

+ func (s *OnDiskStateMachine) StateMachineType() pb.StateMachineType

+ func (s *OnDiskStateMachine) Sync() error

+ func (s *OnDiskStateMachine) Update(entries []sm.Entry) ([]sm.Entry, error)

+ type RaftClientID uint64

+ func (a *RaftClientID) Compare(b llrb.Comparable) int

+ type RaftSeriesID uint64

+ type RegularStateMachine struct

+ func NewRegularStateMachine(s sm.IStateMachine) *RegularStateMachine

+ func (s *RegularStateMachine) Close() error

+ func (s *RegularStateMachine) ConcurrentSnapshot() bool

+ func (s *RegularStateMachine) GetHash() (uint64, error)

+ func (s *RegularStateMachine) Lookup(query interface{}) (interface{}, error)

+ func (s *RegularStateMachine) NALookup(query []byte) ([]byte, error)

+ func (s *RegularStateMachine) OnDiskStateMachine() bool

+ func (s *RegularStateMachine) Open(stopc <-chan struct{}) (uint64, error)

+ func (s *RegularStateMachine) PrepareSnapshot() (interface{}, error)

+ func (s *RegularStateMachine) RecoverFromSnapshot(index uint64, r io.Reader, fs []sm.SnapshotFile, stopc <-chan struct{}) error

+ func (s *RegularStateMachine) SaveSnapshot(ctx interface{}, w io.Writer, fc sm.ISnapshotFileCollection, ...) error

+ func (s *RegularStateMachine) StateMachineType() pb.StateMachineType

+ func (s *RegularStateMachine) Sync() error

+ func (s *RegularStateMachine) Update(entries []sm.Entry) ([]sm.Entry, error)

+ type SMFactoryFunc func(clusterID uint64, nodeID uint64, done <-chan struct{}) IManagedStateMachine

+ type Session struct

+ ClientID RaftClientID

+ History map[RaftSeriesID]sm.Result

+ RespondedUpTo RaftSeriesID

+ func (s *Session) AddResponse(id RaftSeriesID, result sm.Result)

+ type SessionManager struct

+ func NewSessionManager() *SessionManager

+ func (ds *SessionManager) AddResponse(session *Session, seriesID uint64, result sm.Result)

+ func (ds *SessionManager) ClientRegistered(clientID uint64) (*Session, bool)

+ func (ds *SessionManager) GetSessionHash() uint64

+ func (ds *SessionManager) LoadSessions(reader io.Reader, v SnapshotVersion) error

+ func (ds *SessionManager) MustHaveClientSeries(session *Session, seriesID uint64)

+ func (ds *SessionManager) RegisterClientID(clientID uint64) sm.Result

+ func (ds *SessionManager) SaveSessions(writer io.Writer) (uint64, error)

+ func (ds *SessionManager) UnregisterClientID(clientID uint64) sm.Result

+ func (ds *SessionManager) UpdateRequired(session *Session, seriesID uint64) (sm.Result, bool, bool)

+ func (ds *SessionManager) UpdateRespondedTo(session *Session, respondedTo uint64)

+ type SnapshotMeta struct

+ Ctx interface{}

+ From uint64

+ Index uint64

+ Membership pb.Membership

+ Request SnapshotRequest

+ Session *bytes.Buffer

+ Term uint64

+ Type pb.StateMachineType

+ type SnapshotReader struct

+ func NewSnapshotReader(fp string) (*SnapshotReader, error)

+ func (sr *SnapshotReader) Close() error

+ func (sr *SnapshotReader) GetHeader() (pb.SnapshotHeader, error)

+ func (sr *SnapshotReader) Read(data []byte) (int, error)

+ func (sr *SnapshotReader) ValidateHeader(header pb.SnapshotHeader)

+ func (sr *SnapshotReader) ValidatePayload(header pb.SnapshotHeader)

+ type SnapshotRequest struct

+ Key uint64

+ Path string

+ Type SnapshotRequestType

+ func (sr *SnapshotRequest) IsExportedSnapshot() bool

+ type SnapshotRequestType uint64

+ const ExportedSnapshot

+ const PeriodicSnapshot

+ const UserRequestedSnapshot

+ type SnapshotValidator struct

+ func NewSnapshotValidator() *SnapshotValidator

+ func (v *SnapshotValidator) AddChunk(data []byte, chunkID uint64) bool

+ func (v *SnapshotValidator) Validate() bool

+ type SnapshotVersion uint64

+ const CurrentSnapshotVersion

+ const DefaultChecksumType

+ const SnapshotHeaderSize

+ const V1SnapshotVersion

+ const V2SnapshotVersion

+ type SnapshotWriter struct

+ func NewSnapshotWriter(fp string, version SnapshotVersion) (*SnapshotWriter, error)

+ func (sw *SnapshotWriter) Close() error

+ func (sw *SnapshotWriter) GetPayloadChecksum() []byte

+ func (sw *SnapshotWriter) GetPayloadSize(sz uint64) uint64

+ func (sw *SnapshotWriter) Write(data []byte) (int, error)

+ type StateMachine struct

+ func NewStateMachine(sm IManagedStateMachine, snapshotter ISnapshotter, ordered bool, ...) *StateMachine

+ func (s *StateMachine) ConcurrentSnapshot() bool

+ func (s *StateMachine) GetBatchedLastApplied() uint64

+ func (s *StateMachine) GetHash() (uint64, error)

+ func (s *StateMachine) GetLastApplied() uint64

+ func (s *StateMachine) GetMembership() (map[uint64]string, map[uint64]string, map[uint64]struct{}, uint64)

+ func (s *StateMachine) GetMembershipHash() uint64

+ func (s *StateMachine) GetSessionHash() uint64

+ func (s *StateMachine) GetSyncedIndex() uint64

+ func (s *StateMachine) Handle(batch []Task, apply []sm.Entry) (Task, error)

+ func (s *StateMachine) Loaded(from From)

+ func (s *StateMachine) Lookup(query interface{}) (interface{}, error)

+ func (s *StateMachine) NALookup(query []byte) ([]byte, error)

+ func (s *StateMachine) Offloaded(from From)

+ func (s *StateMachine) OnDiskStateMachine() bool

+ func (s *StateMachine) OpenOnDiskStateMachine() (uint64, error)

+ func (s *StateMachine) ReadyToStreamSnapshot() bool

+ func (s *StateMachine) RecoverFromSnapshot(t Task) (uint64, error)

+ func (s *StateMachine) SaveSnapshot(req SnapshotRequest) (*pb.Snapshot, *server.SnapshotEnv, error)

+ func (s *StateMachine) SetBatchedLastApplied(index uint64)

+ func (s *StateMachine) StreamSnapshot(sink pb.IChunkSink) error

+ func (s *StateMachine) Sync() error

+ func (s *StateMachine) TaskChanBusy() bool

+ func (s *StateMachine) TaskQ() *TaskQueue

+ type Task struct

+ ClusterID uint64

+ Entries []pb.Entry

+ Index uint64

+ InitialSnapshot bool

+ NewNode bool

+ NodeID uint64

+ PeriodicSync bool

+ SnapshotAvailable bool

+ SnapshotRequest SnapshotRequest

+ SnapshotRequested bool

+ StreamSnapshot bool

+ func (t *Task) IsSnapshotTask() bool

+ type TaskQueue struct

+ func NewTaskQueue() *TaskQueue

+ func (tq *TaskQueue) Add(task Task)

+ func (tq *TaskQueue) Get() (Task, bool)

+ func (tq *TaskQueue) MoreEntryToApply() bool

+ func (tq *TaskQueue) Size() uint64

Other modules containing this package

github.com/lni/dragonboat

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL