rsm

package
v2.1.5+incompatible Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Apr 5, 2019 License: Apache-2.0 Imports: 25 Imported by: 0

Documentation

Overview

Package rsm implements Replicated State Machines used in Dragonboat.

This package is internally used by Dragonboat, applications are not expected to import this package.

Index

Constants

View Source 
const (

	// SnapshotHeaderSize is the size of snapshot in number of bytes.
	SnapshotHeaderSize = settings.SnapshotHeaderSize
)

Variables

View Source 
var (
	// ErrSaveSnapshot indicates there is error when trying to save a snapshot
	ErrSaveSnapshot = errors.New("failed to save snapshot")
	// ErrRestoreSnapshot indicates there is error when trying to restore
	// from a snapshot
	ErrRestoreSnapshot = errors.New("failed to restore from snapshot")
)
View Source 
var (
	// ErrClusterClosed indicates that the cluster has been closed
	ErrClusterClosed = errors.New("raft cluster already closed")
)
View Source 
var (
	// LRUMaxSessionCount is the largest number of client sessions that can be
	// concurrently managed by a LRUSession instance.
	LRUMaxSessionCount = settings.Hard.LRUMaxSessionCount
)

Functions

This section is empty.

Types

type Commit 

type Commit struct {
	Index             uint64
	SnapshotAvailable bool
	InitialSnapshot   bool
	SnapshotRequested bool
	Entries           []pb.Entry
}

Commit is the processing units that can be handled by StateMachines.

type From 

type From uint64

From identifies a component in the system. 

const (
	// FromNodeHost indicates the data store has been loaded by or offloaded from
	// nodehost.
	FromNodeHost From = iota
	// FromStepWorker indicates that the data store has been loaded by or
	// offloaded from the step worker.
	FromStepWorker
	// FromCommitWorker indicates that the data store has been loaded by or
	// offloaded from the commit worker.
	FromCommitWorker
	// FromSnapshotWorker indicates that the data store has been loaded by or
	// offloaded from the snapshot worker.
	FromSnapshotWorker
)

type IManagedStateMachine 

type IManagedStateMachine interface {
	GetSessionHash() uint64
	UpdateRespondedTo(*Session, uint64)
	UnregisterClientID(clientID uint64) uint64
	RegisterClientID(clientID uint64) uint64
	ClientRegistered(clientID uint64) (*Session, bool)
	UpdateRequired(*Session, uint64) (uint64, bool, bool)
	Update(*Session, uint64, []byte) uint64
	Lookup([]byte) ([]byte, error)
	GetHash() uint64
	SaveSnapshot(string, statemachine.ISnapshotFileCollection) (uint64, error)
	RecoverFromSnapshot(string, []statemachine.SnapshotFile) error
	Offloaded(From)
	Loaded(From)
}

IManagedStateMachine is the interface used to manage data store.

func NewNativeStateMachine 

func NewNativeStateMachine(ds statemachine.IStateMachine,
	done <-chan struct{}) IManagedStateMachine

NewNativeStateMachine creates and returns a new NativeStateMachine object.

type INodeProxy 

type INodeProxy interface {
	RestoreRemotes(pb.Snapshot)
	ApplyUpdate(pb.Entry, uint64, bool, bool, bool)
	ApplyConfigChange(pb.ConfigChange)
	ConfigChangeProcessed(uint64, bool)
	NodeID() uint64
	ClusterID() uint64
}

INodeProxy is the interface used as proxy to a nodehost.

type ISnapshotter 

type ISnapshotter interface {
	GetSnapshot(uint64) (pb.Snapshot, error)
	GetMostRecentSnapshot() (pb.Snapshot, error)
	GetFilePath(uint64) string
	Save(uint64, uint64, IManagedStateMachine) (*pb.Snapshot, *server.SnapshotEnv, error)
	IsNoSnapshotError(error) bool
}

ISnapshotter is the interface for the snapshotter object.

type ManagedStateMachineFactory 

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

ManagedStateMachineFactory is the factory function type for creating an IManagedStateMachine instance.

type NativeStateMachine 

type NativeStateMachine struct {
	OffloadedStatus
	SessionManager
	// contains filtered or unexported fields
}

NativeStateMachine is the IManagedStateMachine object used to manage native data store in Golang.

func (*NativeStateMachine) GetHash 

func (ds *NativeStateMachine) GetHash() uint64

GetHash returns an integer value representing the state of the data store.

func (*NativeStateMachine) Loaded 

func (ds *NativeStateMachine) Loaded(from From)

Loaded marks the statemachine as loaded by the specified component.

func (*NativeStateMachine) Lookup 

func (ds *NativeStateMachine) Lookup(data []byte) ([]byte, error)

Lookup queries the data store.

func (*NativeStateMachine) Offloaded 

func (ds *NativeStateMachine) Offloaded(from From)

Offloaded offloads the data store from the specified part of the system.

func (*NativeStateMachine) RecoverFromSnapshot 

func (ds *NativeStateMachine) RecoverFromSnapshot(fp string,
	files []statemachine.SnapshotFile) (err error)

RecoverFromSnapshot recovers the state of the data store from the snapshot file specified by the fp input string.

func (*NativeStateMachine) SaveSnapshot 

func (ds *NativeStateMachine) SaveSnapshot(fp string,
	collection statemachine.ISnapshotFileCollection) (uint64, error)

SaveSnapshot saves the state of the data store to the snapshot file specified by the fp input string.

func (*NativeStateMachine) Update 

func (ds *NativeStateMachine) Update(session *Session,
	seriesID uint64, data []byte) uint64

Update updates the data store.

type OffloadedStatus 

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

OffloadedStatus is used for tracking whether the managed data store has been offloaded from various system components.

func (*OffloadedStatus) Destroyed 

func (o *OffloadedStatus) Destroyed() bool

Destroyed returns a boolean value indicating whether the belonging object has been destroyed.

func (*OffloadedStatus) ReadyToDestroy 

func (o *OffloadedStatus) ReadyToDestroy() bool

ReadyToDestroy returns a boolean value indicating whether the the managed data store is ready to be destroyed.

func (*OffloadedStatus) SetDestroyed 

func (o *OffloadedStatus) SetDestroyed()

SetDestroyed set the destroyed flag to be true

func (*OffloadedStatus) SetLoaded 

func (o *OffloadedStatus) SetLoaded(from From)

SetLoaded marks the managed data store as loaded from the specified component.

func (*OffloadedStatus) SetOffloaded 

func (o *OffloadedStatus) SetOffloaded(from From)

SetOffloaded marks the managed data store as offloaded from the specified component.

type RaftClientID 

type RaftClientID uint64

RaftClientID is the type used as client id in sessions.

func (*RaftClientID) Compare 

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

Compare implements the llrb.Comparable interface.

type RaftSeriesID 

type RaftSeriesID uint64

RaftSeriesID is the type used as series id in sessions.

type SMFactoryFunc 

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

SMFactoryFunc is the function type for creating an IStateMachine instance

type Session 

type Session struct {
	ClientID      RaftClientID
	RespondedUpTo RaftSeriesID
	History       map[RaftSeriesID]uint64
}

Session is the session object maintained on the raft side.

type SessionManager 

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

SessionManager is the wrapper struct that implements client session related functionalites used in the IManagedStateMachine interface.

func NewSessionManager 

func NewSessionManager() SessionManager

NewSessionManager returns a new SessionManager instance.

func (*SessionManager) AddResponse 

func (ds *SessionManager) AddResponse(session *Session,
	seriesID uint64, result uint64)

AddResponse adds the specified result to the session.

func (*SessionManager) ClientRegistered 

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

ClientRegistered returns whether the specified client exists in the system.

func (*SessionManager) GetSessionHash 

func (ds *SessionManager) GetSessionHash() uint64

GetSessionHash returns an uint64 integer representing the state of the session manager.

func (*SessionManager) LoadSessions 

func (ds *SessionManager) LoadSessions(reader io.Reader) error

LoadSessions loads and restores sessions from io.Reader.

func (*SessionManager) MustHaveClientSeries 

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

MustHaveClientSeries checks whether the session manager contains a client session identified as clientID and whether it has seriesID responded.

func (*SessionManager) RegisterClientID 

func (ds *SessionManager) RegisterClientID(clientID uint64) uint64

RegisterClientID registers a new client, it returns the input client id if it is previously unknown, or 0 when the client has already been registered.

func (*SessionManager) SaveSessions 

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

SaveSessions saves the sessions to the provided io.writer.

func (*SessionManager) UnregisterClientID 

func (ds *SessionManager) UnregisterClientID(clientID uint64) uint64

UnregisterClientID removes the specified client session from the system. It returns the client id if the client is successfully removed, or 0 if the client session does not exist.

func (*SessionManager) UpdateRequired 

func (ds *SessionManager) UpdateRequired(session *Session,
	seriesID uint64) (uint64, bool, bool)

UpdateRequired return a tuple of request result, responded before, update required.

func (*SessionManager) UpdateRespondedTo 

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

UpdateRespondedTo updates the responded to value of the specified client session.

type SnapshotReader 

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

SnapshotReader is an io.Reader for reading from snapshot files.

func NewSnapshotReader 

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

NewSnapshotReader creates a new snapshot reader instance.

func (*SnapshotReader) Close 

func (sr *SnapshotReader) Close() error

Close closes the snapshot reader instance.

func (*SnapshotReader) GetHeader 

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

GetHeader returns the snapshot header instance.

func (*SnapshotReader) Read 

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

Read reads up to len(data) bytes from the snapshot file.

func (*SnapshotReader) ValidateHeader 

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

ValidateHeader validates whether the header matches the header checksum recorded in the header.

func (*SnapshotReader) ValidatePayload 

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

ValidatePayload validates whether the snapshot content matches the checksum recorded in the header.

type SnapshotValidator 

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

SnapshotValidator is the validator used to check incoming snapshot chunks.

func NewSnapshotValidator 

func NewSnapshotValidator() *SnapshotValidator

NewSnapshotValidator creates and returns a new SnapshotValidator instance.

func (*SnapshotValidator) AddChunk 

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

AddChunk adds a new snapshot chunk to the validator.

func (*SnapshotValidator) Validate 

func (v *SnapshotValidator) Validate() bool

Validate validates the added chunks and return a boolean flag indicating whether the snapshot chunks are valid.

type SnapshotWriter 

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

SnapshotWriter is an io.Writer used to write snapshot file.

func NewSnapshotWriter 

func NewSnapshotWriter(fp string) (*SnapshotWriter, error)

NewSnapshotWriter creates a new snapshot writer instance.

func (*SnapshotWriter) Close 

func (sw *SnapshotWriter) Close() error

Close closes the snapshot writer instance.

func (*SnapshotWriter) SaveHeader 

func (sw *SnapshotWriter) SaveHeader(smsz uint64, sz uint64) error

SaveHeader saves the snapshot header to the snapshot.

func (*SnapshotWriter) Write 

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

Write writes the specified data to the snapshot.

type StateMachine 

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

StateMachine is a manager class that manages application state machine

func NewStateMachine 

func NewStateMachine(sm IManagedStateMachine,
	snapshotter ISnapshotter, ordered bool,
	proxy INodeProxy) *StateMachine

NewStateMachine creates a new application state machine object.

func (*StateMachine) CommitC 

func (s *StateMachine) CommitC() chan Commit

CommitC returns the commit channel.

func (*StateMachine) CommitChanBusy 

func (s *StateMachine) CommitChanBusy() bool

CommitChanBusy returns whether the CommitC chan is busy. Busy is defined as having more than half of its buffer occupied.

func (*StateMachine) GetBatchedLastApplied 

func (s *StateMachine) GetBatchedLastApplied() uint64

GetBatchedLastApplied returns the batched last applied value.

func (*StateMachine) GetHash 

func (s *StateMachine) GetHash() uint64

GetHash returns the state machine hash.

func (*StateMachine) GetLastApplied 

func (s *StateMachine) GetLastApplied() uint64

GetLastApplied returns the last applied value.

func (*StateMachine) GetMembership 

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

GetMembership returns the membership info maintained by the state machine.

func (*StateMachine) GetMembershipHash 

func (s *StateMachine) GetMembershipHash() uint64

GetMembershipHash returns the hash of the membership instance.

func (*StateMachine) GetSessionHash 

func (s *StateMachine) GetSessionHash() uint64

GetSessionHash returns the session hash.

func (*StateMachine) Handle 

func (s *StateMachine) Handle(batch []Commit) (Commit, bool)

Handle pulls the committed record and apply it if there is any available.

func (*StateMachine) Loaded 

func (s *StateMachine) Loaded(from From)

Loaded marks the state machine as loaded from the specified component.

func (*StateMachine) Lookup 

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

Lookup performances local lookup on the data store.

func (*StateMachine) Offloaded 

func (s *StateMachine) Offloaded(from From)

Offloaded marks the state machine as offloaded from the specified component.

func (*StateMachine) RecoverFromSnapshot 

func (s *StateMachine) RecoverFromSnapshot(rec Commit) (uint64, error)

RecoverFromSnapshot applies the snapshot.

func (*StateMachine) SaveSnapshot 

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

SaveSnapshot creates a snapshot.

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.