internal

Index ¶

• Constants
• Variables
• func AwsErrToReply(err error) int32
• func CalcRequiredPageBufferSize(offset int64, dataLen int64) int64
• func CalculateBufferLengthForDownload(h MetaRWHandler, offset int64) int
• func CollectLRUChunks(dirtyMgr *DirtyMgr, raft *RaftInstance, reclaimDiskBytes int64) (keys []uint64, offsets []int64)
• func CollectLRUDirtyKeys(dirtyMgr *DirtyMgr, raft *RaftInstance, reclaimDiskBytes int64) (keys map[InodeKeyType]bool)
• func ErrnoToReply(err error) int32
• func GetAddrInet4FromString(headWorkerAddr string, headWorkerPort int) (common.NodeAddrInet4, error)
• func GetBufCheckSum(buf []byte) []byte
• func GetGroupForChunk(ring *hashring.HashRing, inodeKey InodeKeyType, offset int64, chunkSize int64) (groupId string, ok bool)
• func GetGroupForMeta(ring *hashring.HashRing, inodeKey InodeKeyType) (groupId string, ok bool)
• func GetRandF(r rand.Source) float64
• func GetServerConfig(args *common.ObjcacheCmdlineArgs, timeout time.Duration) (common.ObjcacheConfig, error)
• func HttpErrToReply(status int) int32
• func InitAccessLinkHead()
• func InitLog(args *common.ObjcacheCmdlineArgs) *common.LogHandle
• func InitMemoryPool()
• func MyHashFunc(in []byte) hashring.HashKey
• func MyHashFunc64(in []byte) hashring.HashKey
• func MyHashFunc64V2(in []byte) hashring.HashKey
• func MyHashFuncV2(in []byte) hashring.HashKey
• func NewAppendCommitUpdateChunkMsg(meta *WorkingMeta, chunks map[int64]*WorkingChunk, isDelete bool) *common.AppendCommitUpdateChunksMsg
• func NewNodeMsgFromAddr(addr common.NodeAddrInet4) *common.NodeMsg
• func NewSaFromApiNodeMsg(msg *api.ApiNodeMsg) (ret common.NodeAddrInet4)
• func NewSaFromNodeMsg(msg *common.NodeMsg) (ret common.NodeAddrInet4)
• func NewUpdateParentRetFromMsg(msg *common.UpdateParentRetMsg) (UpdateParentRet, RaftBasicReply)
• func PString(v string) *string
• func PTime(v time.Time) *time.Time
• func PrepareCommitUpdateChunkBody(inodeMgr *InodeMgr, offStags map[int64][]*common.StagingChunkMsg, ...) (chunks map[int64]*WorkingChunk, unlocks []func())
• func ProfilerThread(blockProfileRate int, mutexProfileRate int, listenIp string, profilePort int)
• func ReadDataToBuffer(fd int, msg *RpcMsg, r *ReadRpcMsgState, data []byte)
• func ReadDataToFd(fd int, msg *RpcMsg, r *ReadRpcMsgState, toFd int, pipeFds [2]int)
• func ReadDataToRaftLog(fd int, msg *RpcMsg, r *ReadRpcMsgState, extLogger *OnDiskLogger, ...)
• func ReadRpcMsg(fd int, msg *RpcMsg, r *ReadRpcMsgState)
• func ReplyToFuseErr(reply int32) error
• func ReturnPageBuffer(buf *PageBuffer)
• func SignV2(req *request.Request)
• type AbortParticipantOp
• • func NewAbortParticipantOp(rpcSeqNum TxId, abortTxIds []*common.TxIdMsg, groupId string, nodeLock bool) AbortParticipantOp
• • func (o AbortParticipantOp) GetCaller(n *NodeServer) RpcCaller
  • func (o AbortParticipantOp) GetLeader(n *NodeServer, l *RaftNodeList) (RaftNode, bool)
  • func (o AbortParticipantOp) GetTxId() TxId
  • func (o AbortParticipantOp) RetToMsg(_ interface{}, r RaftBasicReply) (proto.Message, []SlicedPageBuffer)
• type AbortTxCommand
• • func NewAbortTxCommand(txIds []TxId) AbortTxCommand
• • func (c AbortTxCommand) Commit(n *NodeServer)
  • func (c AbortTxCommand) GetExtCmdId() uint16
  • func (c AbortTxCommand) GetTxId() TxId
  • func (c AbortTxCommand) IsSingleShot() bool
  • func (c AbortTxCommand) NeedTwoPhaseCommit(*RaftGroupMgr) bool
• type AddInodeFileMapCommand
• • func NewAddInodeFileMapCommand(working *WorkingMeta, children map[string]InodeKeyType, key string) AddInodeFileMapCommand
• • func (c AddInodeFileMapCommand) Commit(n *NodeServer)
  • func (c AddInodeFileMapCommand) GetExtCmdId() uint16
  • func (c AddInodeFileMapCommand) GetTxId() TxId
  • func (c AddInodeFileMapCommand) IsSingleShot() bool
  • func (c AddInodeFileMapCommand) NeedTwoPhaseCommit(*RaftGroupMgr) bool
• type AddServerCommand
• • func NewAddServerCommand(serverId uint32, ip [4]byte, port uint16) AddServerCommand
• • func (c AddServerCommand) Apply(n *NodeServer, _ ExtLogCommandImpl)
  • func (c AddServerCommand) GetCmdId() uint16
  • func (c AddServerCommand) GetExtPayloadSize() uint8
  • func (c AddServerCommand) SetExtPayload(extPayload []byte)
• type AppendEntryCommand
• • func GetAppendEntryCommand(term uint32, rc RaftCommand) (cmd AppendEntryCommand)
• • func (l *AppendEntryCommand) AppendToRpcMsg(d *RpcMsg) (newOptHeaderLength uint16, newTotalExtLogSize uint32)
  • func (l *AppendEntryCommand) AsRaftCommand() (RaftCommand, bool)
  • func (l *AppendEntryCommand) GetChecksum() []byte
  • func (l *AppendEntryCommand) GetEntryLength() uint8
  • func (l *AppendEntryCommand) GetExtCmdId() uint16
  • func (l *AppendEntryCommand) GetExtPayload() []byte
  • func (l *AppendEntryCommand) GetTerm() uint32
• type BeginPersistCommand
• • func NewBeginPersistCommand(txId TxId, keys []string, uploadIds []string) BeginPersistCommand
• • func (c BeginPersistCommand) Commit(n *NodeServer)
  • func (c BeginPersistCommand) GetExtCmdId() uint16
  • func (c BeginPersistCommand) GetTxId() TxId
  • func (c BeginPersistCommand) IsSingleShot() bool
  • func (c BeginPersistCommand) NeedTwoPhaseCommit(*RaftGroupMgr) bool
  • func (c BeginPersistCommand) RemoteCommit(*RaftGroupMgr) []ParticipantOp
• type BlobItemOutput
• type BlobPrefixOutput
• type BucketCredential
• type BucketCredentials
• type BucketSpec
• type BufferedDiskPageReader
• • func NewBufferedDiskPageReaderFromStag(page *PageBuffer, logId LogIdType, logOffset int64, dataLen int64) *BufferedDiskPageReader
• • func (r *BufferedDiskPageReader) GetSlicedPageBufferAt(stagPart *StagingChunkPart, offset int64, dec func(interface{})) (SlicedPageBuffer, error)
• type Capabilities
• type Chunk
• • func CreateNewChunk(inodeKey InodeKeyType, offset int64, chunkIdx uint32) *Chunk
• • func (c *Chunk) AddWorkingChunk(inodeMgr *InodeMgr, working *WorkingChunk, prev *WorkingChunk)
  • func (c *Chunk) DeleteFromLRUListNoLock()
  • func (c *Chunk) Drop(inodeMgr *InodeMgr, raft *RaftInstance)
  • func (c *Chunk) GetLogId() LogIdType
  • func (c *Chunk) GetWorkingChunk(ver uint32, updateLRU bool) (*WorkingChunk, error)
  • func (c *Chunk) NewWorkingChunk(chunkVer uint32) *WorkingChunk
  • func (c *Chunk) UpdateLRUList()
• type ChunkReader
• • func (r *ChunkReader) Close() (err error)
  • func (r *ChunkReader) GetBufferZeroCopy(size int) (bufs []SlicedPageBuffer, count int, err error)
  • func (r *ChunkReader) GetLen() (int64, error)
  • func (r *ChunkReader) HasLen() (int, bool)
  • func (r *ChunkReader) IsSeeker() bool
  • func (r *ChunkReader) Read(p []byte) (int, error)
  • func (r *ChunkReader) Seek(offset int64, whence int) (int64, error)
  • func (r *ChunkReader) WriteTo(w io.Writer) (n int64, err error)
• type CommitAbortRpcCaller
• • func NewCommitAbortRpcCaller(fn ParticipantOp, remoteTimeout time.Duration, nodeLock bool) CommitAbortRpcCaller
• • func (c CommitAbortRpcCaller) ExecLocal(n *NodeServer, nodeListVer uint64) (ret RpcRet, r RaftBasicReply)
  • func (c CommitAbortRpcCaller) ExecLocalInRpc(n *NodeServer, nodeListVer uint64) (ret RpcRet, r RaftBasicReply)
  • func (c CommitAbortRpcCaller) ExecRemote(n *NodeServer, addr common.NodeAddrInet4, nodeListVer uint64) (ret RpcRet, r RaftBasicReply)
  • func (c CommitAbortRpcCaller) GetLeader(n *NodeServer, nodeList *RaftNodeList) (RaftNode, bool)
  • func (c CommitAbortRpcCaller) TryNext(n *NodeServer, i int) bool
• type CommitChunkCommand
• • func NewCommitChunkCommand(meta *WorkingMeta, chunks map[int64]*WorkingChunk, isDelete bool) CommitChunkCommand
• • func (c CommitChunkCommand) Commit(n *NodeServer)
  • func (c CommitChunkCommand) GetExtCmdId() uint16
  • func (c CommitChunkCommand) GetTxId() TxId
  • func (c CommitChunkCommand) IsSingleShot() bool
  • func (c CommitChunkCommand) NeedTwoPhaseCommit(*RaftGroupMgr) bool
• type CommitChunkRpcCaller
• • func NewCommitChunkRpcCaller(fn ParticipantOp, remoteTimeout time.Duration) CommitChunkRpcCaller
• • func (c CommitChunkRpcCaller) ExecLocal(n *NodeServer, nodeListVer uint64) (ret RpcRet, r RaftBasicReply)
  • func (c CommitChunkRpcCaller) ExecLocalInRpc(n *NodeServer, nodeListVer uint64) (ret RpcRet, r RaftBasicReply)
  • func (c CommitChunkRpcCaller) ExecRemote(n *NodeServer, addr common.NodeAddrInet4, nodeListVer uint64) (ret RpcRet, r RaftBasicReply)
  • func (c CommitChunkRpcCaller) GetLeader(n *NodeServer, nodeList *RaftNodeList) (RaftNode, bool)
  • func (c CommitChunkRpcCaller) TryNext(n *NodeServer, i int) bool
• type CommitCommand
• • func NewCommitCommand(txId TxId) CommitCommand
• • func (c CommitCommand) Apply(n *NodeServer, _ ExtLogCommandImpl)
  • func (c CommitCommand) GetCmdId() uint16
  • func (c CommitCommand) GetExtPayloadSize() uint8
  • func (c CommitCommand) SetExtPayload(extPayload []byte)
• type CommitDeleteChunkOp
• • func NewCommitDeleteChunkOp(txId TxId, newMeta *WorkingMeta, offset int64, deleteLen int64) CommitDeleteChunkOp
• • func (o CommitDeleteChunkOp) GetCaller(n *NodeServer) RpcCaller
  • func (o CommitDeleteChunkOp) GetLeader(n *NodeServer, l *RaftNodeList) (RaftNode, bool)
  • func (o CommitDeleteChunkOp) GetTxId() TxId
  • func (o CommitDeleteChunkOp) RetToMsg(_ interface{}, r RaftBasicReply) (proto.Message, []SlicedPageBuffer)
• type CommitExpandChunkOp
• • func NewCommitExpandChunkOp(txId TxId, newMeta *WorkingMeta, offset int64, expandLen int64) CommitExpandChunkOp
• • func (o CommitExpandChunkOp) GetCaller(n *NodeServer) RpcCaller
  • func (o CommitExpandChunkOp) GetLeader(n *NodeServer, l *RaftNodeList) (RaftNode, bool)
  • func (o CommitExpandChunkOp) GetTxId() TxId
  • func (o CommitExpandChunkOp) RetToMsg(_ interface{}, r RaftBasicReply) (proto.Message, []SlicedPageBuffer)
• type CommitParticipantOp
• • func NewCommitParticipantOp(rpcSeqNum TxId, commitTxId TxId, groupId string) CommitParticipantOp
  • func NewCommitParticipantOpForUpdateNode(rpcSeqNum TxId, commitTxId TxId, node RaftNode) CommitParticipantOp
• • func (o CommitParticipantOp) GetCaller(n *NodeServer) RpcCaller
  • func (o CommitParticipantOp) GetLeader(n *NodeServer, l *RaftNodeList) (RaftNode, bool)
  • func (o CommitParticipantOp) GetTxId() TxId
  • func (o CommitParticipantOp) RetToMsg(_ interface{}, r RaftBasicReply) (proto.Message, []SlicedPageBuffer)
• type CommitPersistChunkOp
• • func NewCommitPersistChunkOp(txId TxId, commitTxId TxId, groupId string, offsets []int64, cVers []uint32, ...) CommitPersistChunkOp
• • func (o CommitPersistChunkOp) GetCaller(n *NodeServer) RpcCaller
  • func (o CommitPersistChunkOp) GetLeader(n *NodeServer, l *RaftNodeList) (RaftNode, bool)
  • func (o CommitPersistChunkOp) GetTxId() TxId
  • func (o CommitPersistChunkOp) RetToMsg(ret interface{}, r RaftBasicReply) (proto.Message, []SlicedPageBuffer)
• type CommitUpdateChunkOp
• • func NewCommitUpdateChunkOp(txId TxId, record *common.UpdateChunkRecordMsg, newMeta *WorkingMeta) CommitUpdateChunkOp
• • func (o CommitUpdateChunkOp) GetCaller(n *NodeServer) RpcCaller
  • func (o CommitUpdateChunkOp) GetLeader(n *NodeServer, l *RaftNodeList) (RaftNode, bool)
  • func (o CommitUpdateChunkOp) GetTxId() TxId
  • func (o CommitUpdateChunkOp) RetToMsg(_ interface{}, r RaftBasicReply) (proto.Message, []SlicedPageBuffer)
• type CompactLogCoordinatorCommand
• • func NewCompactLogCoordinatorCommand(s *Snapshot) CompactLogCoordinatorCommand
• • func (c CompactLogCoordinatorCommand) Commit(n *NodeServer)
  • func (c CompactLogCoordinatorCommand) GetExtCmdId() uint16
  • func (c CompactLogCoordinatorCommand) GetTxId() TxId
  • func (c CompactLogCoordinatorCommand) IsSingleShot() bool
  • func (c CompactLogCoordinatorCommand) NeedTwoPhaseCommit(raftGroup *RaftGroupMgr) bool
  • func (c CompactLogCoordinatorCommand) RemoteCommit(_ *RaftGroupMgr) []ParticipantOp
• type CoordinatorCommand
• type CoordinatorCompactLogOp
• • func NewCoordinatorCompactLogOp(id CoordinatorId) CoordinatorCompactLogOp
• • func (o CoordinatorCompactLogOp) GetCaller(n *NodeServer) RpcCaller
  • func (o CoordinatorCompactLogOp) GetLeader(n *NodeServer, l *RaftNodeList) (RaftNode, bool)
  • func (o CoordinatorCompactLogOp) GetTxId() TxId
  • func (o CoordinatorCompactLogOp) RetToMsg(_ interface{}, r RaftBasicReply) proto.Message
• type CoordinatorCreateObjectOp
• • func NewCoordinatorCreateObjectOp(id CoordinatorId, parentFullPath string, parentInodeKey InodeKeyType, ...) CoordinatorCreateObjectOp
• • func (o CoordinatorCreateObjectOp) GetCaller(n *NodeServer) RpcCaller
  • func (o CoordinatorCreateObjectOp) GetLeader(n *NodeServer, l *RaftNodeList) (RaftNode, bool)
  • func (o CoordinatorCreateObjectOp) GetTxId() TxId
  • func (o CoordinatorCreateObjectOp) RetToMsg(ret interface{}, r RaftBasicReply) proto.Message
• type CoordinatorDeleteObjectOp
• • func NewCoordinatorDeleteObjectOp(id CoordinatorId, parentFullPath string, parentInodeKey InodeKeyType, ...) CoordinatorDeleteObjectOp
• • func (o CoordinatorDeleteObjectOp) GetCaller(n *NodeServer) RpcCaller
  • func (o CoordinatorDeleteObjectOp) GetLeader(n *NodeServer, l *RaftNodeList) (RaftNode, bool)
  • func (o CoordinatorDeleteObjectOp) GetTxId() TxId
  • func (o CoordinatorDeleteObjectOp) RetToMsg(ret interface{}, r RaftBasicReply) proto.Message
• type CoordinatorDeletePersistOp
• • func NewCoordinatorDeletePersistOp(id CoordinatorId, key string, inodeKey InodeKeyType, priority int) CoordinatorDeletePersistOp
• • func (o CoordinatorDeletePersistOp) GetCaller(n *NodeServer) RpcCaller
  • func (o CoordinatorDeletePersistOp) GetLeader(n *NodeServer, l *RaftNodeList) (RaftNode, bool)
  • func (o CoordinatorDeletePersistOp) GetTxId() TxId
  • func (o CoordinatorDeletePersistOp) RetToMsg(ret interface{}, r RaftBasicReply) proto.Message
• type CoordinatorFlushObjectOp
• • func NewCoordinatorFlushObjectOp(id CoordinatorId, inodeKey InodeKeyType, ...) CoordinatorFlushObjectOp
• • func (o CoordinatorFlushObjectOp) GetCaller(n *NodeServer) RpcCaller
  • func (o CoordinatorFlushObjectOp) GetLeader(n *NodeServer, l *RaftNodeList) (RaftNode, bool)
  • func (o CoordinatorFlushObjectOp) GetTxId() TxId
  • func (o CoordinatorFlushObjectOp) RetToMsg(ret interface{}, r RaftBasicReply) proto.Message
• type CoordinatorHardLinkOp
• • func NewCoordinatorHardLinkOp(id CoordinatorId, srcInodeKey InodeKeyType, srcParentInodeKey InodeKeyType, ...) CoordinatorHardLinkOp
• • func (o CoordinatorHardLinkOp) GetCaller(n *NodeServer) RpcCaller
  • func (o CoordinatorHardLinkOp) GetLeader(n *NodeServer, l *RaftNodeList) (RaftNode, bool)
  • func (o CoordinatorHardLinkOp) GetTxId() TxId
  • func (o CoordinatorHardLinkOp) RetToMsg(ret interface{}, r RaftBasicReply) proto.Message
• type CoordinatorId
• • func NewCoordinatorIdFromMsg(msg *common.CoordinatorIdMsg) CoordinatorId
• type CoordinatorOpBase
• • func NewCoordinatorCreateObjectOpFromMsg(msg RpcMsg) (CoordinatorOpBase, uint64, int32)
  • func NewCoordinatorDeleteObjectOpFromMsg(msg RpcMsg) (CoordinatorOpBase, uint64, int32)
  • func NewCoordinatorDeletePersistOpFromMsg(msg RpcMsg) (CoordinatorOpBase, uint64, int32)
  • func NewCoordinatorFlushObjectOpFromMsg(msg RpcMsg) (CoordinatorOpBase, uint64, int32)
  • func NewCoordinatorHardLinkOpFromMsg(msg RpcMsg) (CoordinatorOpBase, uint64, int32)
  • func NewCoordinatorPersistOpFromMsg(msg RpcMsg) (CoordinatorOpBase, uint64, int32)
  • func NewCoordinatorRenameObjectOpFromMsg(msg RpcMsg) (CoordinatorOpBase, uint64, int32)
  • func NewCoordinatorTruncateObjectOpFromMsg(msg RpcMsg) (CoordinatorOpBase, uint64, int32)
  • func NewCoordinatorUpdateNodeListOpFromMsg(msg RpcMsg) (CoordinatorOpBase, uint64, int32)
• type CoordinatorPersistOp
• • func NewCoordinatorPersistOp(id CoordinatorId, inodeKey InodeKeyType, priority int) CoordinatorPersistOp
• • func (o CoordinatorPersistOp) GetCaller(n *NodeServer) RpcCaller
  • func (o CoordinatorPersistOp) GetLeader(n *NodeServer, l *RaftNodeList) (RaftNode, bool)
  • func (o CoordinatorPersistOp) GetTxId() TxId
  • func (o CoordinatorPersistOp) RetToMsg(ret interface{}, r RaftBasicReply) proto.Message
• type CoordinatorRenameObjectOp
• • func NewCoordinatorRenameObjectOp(id CoordinatorId, srcParentKey string, srcParentInodeKey InodeKeyType, ...) CoordinatorRenameObjectOp
• • func (o CoordinatorRenameObjectOp) CheckError(unlink UpdateParentRet, link UpdateParentRet) int32
  • func (o CoordinatorRenameObjectOp) GetCaller(n *NodeServer) RpcCaller
  • func (o CoordinatorRenameObjectOp) GetLeader(n *NodeServer, l *RaftNodeList) (RaftNode, bool)
  • func (o CoordinatorRenameObjectOp) GetTxId() TxId
  • func (o CoordinatorRenameObjectOp) RetToMsg(ret interface{}, r RaftBasicReply) proto.Message
• type CoordinatorRet
• • func NewCoordinatorRetFromMsg(msg *common.CoordinatorRetMsg) *CoordinatorRet
• type CoordinatorRpcCaller
• • func NewCoordinatorRpcCaller(fn CoordinatorOpBase, nodeLock bool) CoordinatorRpcCaller
• • func (c CoordinatorRpcCaller) ExecLocal(n *NodeServer, nodeListVer uint64) (ret RpcRet, r RaftBasicReply)
  • func (c CoordinatorRpcCaller) ExecLocalInRpc(n *NodeServer, nodeListVer uint64) (ret RpcRet, r RaftBasicReply)
  • func (c CoordinatorRpcCaller) ExecRemote(n *NodeServer, addr common.NodeAddrInet4, nodeListVer uint64) (ret RpcRet, r RaftBasicReply)
  • func (c CoordinatorRpcCaller) GetLeader(n *NodeServer, nodeList *RaftNodeList) (RaftNode, bool)
  • func (c CoordinatorRpcCaller) TryNext(n *NodeServer, i int) bool
• type CoordinatorTruncateObjectOp
• • func NewCoordinatorTruncateObjectOp(id CoordinatorId, inodeKey InodeKeyType, newSize int64) CoordinatorTruncateObjectOp
• • func (o CoordinatorTruncateObjectOp) GetCaller(n *NodeServer) RpcCaller
  • func (o CoordinatorTruncateObjectOp) GetLeader(n *NodeServer, l *RaftNodeList) (RaftNode, bool)
  • func (o CoordinatorTruncateObjectOp) GetTxId() TxId
  • func (o CoordinatorTruncateObjectOp) RetToMsg(ret interface{}, r RaftBasicReply) proto.Message
• type CoordinatorUpdateNodeListOp
• • func NewCoordinatorUpdateNodeListOp(id CoordinatorId, trackerNode RaftNode, isAdd bool, target RaftNode, ...) CoordinatorUpdateNodeListOp
• • func (o CoordinatorUpdateNodeListOp) GetCaller(n *NodeServer) RpcCaller
  • func (o CoordinatorUpdateNodeListOp) GetLeader(_ *NodeServer, _ *RaftNodeList) (RaftNode, bool)
  • func (o CoordinatorUpdateNodeListOp) GetTxId() TxId
  • func (o CoordinatorUpdateNodeListOp) RetToMsg(_ interface{}, r RaftBasicReply) proto.Message
• type CopyBlobInput
• type CopyBlobOutput
• type CreateChildMetaOp
• • func NewCreateChildMetaOp(txId TxId, inodeKey InodeKeyType, key string, childName string, ...) CreateChildMetaOp
• • func (o CreateChildMetaOp) GetCaller(n *NodeServer) RpcCaller
  • func (o CreateChildMetaOp) GetLeader(n *NodeServer, l *RaftNodeList) (RaftNode, bool)
  • func (o CreateChildMetaOp) GetTxId() TxId
  • func (o CreateChildMetaOp) RetToMsg(ret interface{}, r RaftBasicReply) (proto.Message, []SlicedPageBuffer)
• type CreateChunkCommand
• • func NewCreateChunkCommand(inodeKey InodeKeyType, offset int64, version uint32, logOffset int64, ...) CreateChunkCommand
• • func (c CreateChunkCommand) Commit(n *NodeServer)
  • func (c CreateChunkCommand) GetExtCmdId() uint16
  • func (c CreateChunkCommand) GetTxId() TxId
  • func (c CreateChunkCommand) IsSingleShot() bool
  • func (c CreateChunkCommand) NeedTwoPhaseCommit(*RaftGroupMgr) bool
• type CreateCoordinatorCommand
• • func NewCreateCoordinatorCommand(txId TxId, newKey string, metaTx TxRet, parentTx TxRet, ...) CreateCoordinatorCommand
• • func (c CreateCoordinatorCommand) Commit(n *NodeServer)
  • func (c CreateCoordinatorCommand) GetExtCmdId() uint16
  • func (c CreateCoordinatorCommand) GetTxId() TxId
  • func (c CreateCoordinatorCommand) IsSingleShot() bool
  • func (c CreateCoordinatorCommand) NeedTwoPhaseCommit(*RaftGroupMgr) bool
  • func (c CreateCoordinatorCommand) RemoteCommit(_ *RaftGroupMgr) []ParticipantOp
• type CreateMetaCommand
• • func NewCreateMetaCommand(txId TxId, meta *WorkingMeta, newKey string, parent InodeKeyType) CreateMetaCommand
• • func (c CreateMetaCommand) Commit(n *NodeServer)
  • func (c CreateMetaCommand) GetExtCmdId() uint16
  • func (c CreateMetaCommand) GetTxId() TxId
  • func (c CreateMetaCommand) IsSingleShot() bool
  • func (c CreateMetaCommand) NeedTwoPhaseCommit(*RaftGroupMgr) bool
• type CreateMetaOp
• • func NewCreateMetaOp(txId TxId, inodeKey InodeKeyType, parentInodeKey InodeKeyType, newKey string, ...) CreateMetaOp
• • func (o CreateMetaOp) GetCaller(n *NodeServer) RpcCaller
  • func (o CreateMetaOp) GetLeader(n *NodeServer, l *RaftNodeList) (RaftNode, bool)
  • func (o CreateMetaOp) GetTxId() TxId
  • func (o CreateMetaOp) RetToMsg(ret interface{}, r RaftBasicReply) (proto.Message, []SlicedPageBuffer)
• type Delegator
• type DeleteBlobInput
• type DeleteBlobOutput
• type DeleteBlobsInput
• type DeleteBlobsOutput
• type DeleteCoordinatorCommand
• • func NewDeleteCoordinatorCommand(txId TxId, key string, prevSize int64, metaTx TxRet, parentTx TxRet, ...) DeleteCoordinatorCommand
• • func (c DeleteCoordinatorCommand) Commit(n *NodeServer)
  • func (c DeleteCoordinatorCommand) GetExtCmdId() uint16
  • func (c DeleteCoordinatorCommand) GetTxId() TxId
  • func (c DeleteCoordinatorCommand) IsSingleShot() bool
  • func (c DeleteCoordinatorCommand) NeedTwoPhaseCommit(*RaftGroupMgr) bool
  • func (c DeleteCoordinatorCommand) RemoteCommit(_ *RaftGroupMgr) []ParticipantOp
• type DeleteInodeFileMapCommand
• • func NewDeleteInodeFileMapCommand(inodeKeys []uint64, keys []string) DeleteInodeFileMapCommand
• • func (c DeleteInodeFileMapCommand) Commit(n *NodeServer)
  • func (c DeleteInodeFileMapCommand) GetExtCmdId() uint16
  • func (c DeleteInodeFileMapCommand) GetTxId() TxId
  • func (c DeleteInodeFileMapCommand) IsSingleShot() bool
  • func (c DeleteInodeFileMapCommand) NeedTwoPhaseCommit(*RaftGroupMgr) bool
• type DeleteMetaCommand
• • func NewDeleteMetaCommand(txId TxId, parentWorking *WorkingMeta, key string) DeleteMetaCommand
• • func (c DeleteMetaCommand) Commit(n *NodeServer)
  • func (c DeleteMetaCommand) GetExtCmdId() uint16
  • func (c DeleteMetaCommand) GetTxId() TxId
  • func (c DeleteMetaCommand) IsSingleShot() bool
  • func (c DeleteMetaCommand) NeedTwoPhaseCommit(*RaftGroupMgr) bool
• type DeleteMetaOp
• • func NewDeleteMetaOp(txId TxId, inodeKey InodeKeyType, removedKey string) DeleteMetaOp
• • func (o DeleteMetaOp) GetCaller(n *NodeServer) RpcCaller
  • func (o DeleteMetaOp) GetLeader(n *NodeServer, l *RaftNodeList) (RaftNode, bool)
  • func (o DeleteMetaOp) GetTxId() TxId
  • func (o DeleteMetaOp) RetToMsg(ret interface{}, r RaftBasicReply) (proto.Message, []SlicedPageBuffer)
• type DeletePersistCoordinatorCommand
• • func NewDeletePersistCoordinatorCommand(key string) DeletePersistCoordinatorCommand
• • func (c DeletePersistCoordinatorCommand) Commit(n *NodeServer)
  • func (c DeletePersistCoordinatorCommand) GetExtCmdId() uint16
  • func (c DeletePersistCoordinatorCommand) GetTxId() TxId
  • func (c DeletePersistCoordinatorCommand) IsSingleShot() bool
  • func (c DeletePersistCoordinatorCommand) NeedTwoPhaseCommit(*RaftGroupMgr) bool
  • func (c DeletePersistCoordinatorCommand) RemoteCommit(*RaftGroupMgr) []ParticipantOp
• type DeletedFileInfo
• • func NewDeleteFileInfoFromMeta(meta *WorkingMeta) DeletedFileInfo
  • func NewDeleteFileInfoFromMsg(msg *common.DeletedFileInfoMsg) DeletedFileInfo
• type DirtyChunkInfo
• • func NewDirtyChunkInfoFromMsg(msg *common.DirtyChunkInfoMsg) DirtyChunkInfo
• type DirtyMetaInfo
• • func NewDirtyMetaInfoFromMeta(meta *WorkingMeta) DirtyMetaInfo
  • func NewDirtyMetaInfoFromMsg(msg *common.DirtyMetaInfoMsg) DirtyMetaInfo
• type DirtyMgr
• • func NewDirtyMgr() *DirtyMgr
  • func NewDirtyMgrFromMsg(msg *common.DirtyMgrSnapshotMsg) *DirtyMgr
• • func (d *DirtyMgr) AddChildMetaNoLock(meta *WorkingMeta, name string)
  • func (d *DirtyMgr) AddChunkNoLock(inodeKey InodeKeyType, chunkSize int64, chunkVer uint32, offset int64, ...)
  • func (d *DirtyMgr) AddDeleteKeyNoLock(key string, meta *WorkingMeta)
  • func (d *DirtyMgr) AddMetaNoLock(meta *WorkingMeta)
  • func (d *DirtyMgr) AddMigratedAddChunk(migrationId MigrationId, chunk *common.AppendCommitUpdateChunksMsg)
  • func (d *DirtyMgr) AddMigratedAddMetas(s *Snapshot)
  • func (d *DirtyMgr) AddMigratedRemoveChunk(migrationId MigrationId, chunks []*common.ChunkRemoveDirtyMsg)
  • func (d *DirtyMgr) AddMigratedRemoveMetas(migrationId MigrationId, inodeKeys []uint64, dirKeys []uint64)
  • func (d *DirtyMgr) AppendForgetAllDirtyLog(raft *RaftInstance) int32
  • func (d *DirtyMgr) AppendRemoveNonDirtyChunksLog(raft *RaftInstance, fps []uint64) int32
  • func (d *DirtyMgr) ApplyAsRemoveNonDirtyChunks(pm proto.Message) int32
  • func (d *DirtyMgr) CheckReset() (ok bool)
  • func (d *DirtyMgr) CommitMigratedDataLocal(inodeMgr *InodeMgr, migrationId MigrationId)
  • func (d *DirtyMgr) CopyAllExpiredPrimaryDeletedDirtyMeta() map[string]InodeKeyType
  • func (d *DirtyMgr) CopyAllExpiredPrimaryDirtyMeta() []InodeKeyType
  • func (d *DirtyMgr) CopyAllPrimaryDeletedKeys() map[string]InodeKeyType
  • func (d *DirtyMgr) CopyAllPrimaryDirtyMeta() []InodeKeyType
  • func (d *DirtyMgr) DropMigratingData(migrationId MigrationId)
  • func (d *DirtyMgr) ForgetAllDirty()
  • func (d *DirtyMgr) GetAllDirtyMeta() []*common.DirtyMetaInfoMsg
  • func (d *DirtyMgr) GetDeleteKey(key string) (inodeKey InodeKeyType, ok bool)
  • func (d *DirtyMgr) GetDirInodesForNodeJoin(dirInodes []*common.InodeTreeMsg, migrationId MigrationId, ...) []*common.InodeTreeMsg
  • func (d *DirtyMgr) GetDirMetaForNodeLeave(keys []*common.InodeTreeMsg, nodeList *RaftNodeList) map[string][]*common.InodeTreeMsg
  • func (d *DirtyMgr) GetDirtyChunkAll() map[InodeKeyType]DirtyChunkInfo
  • func (d *DirtyMgr) GetDirtyChunkForNodeJoin(migrationId MigrationId, nodeList *RaftNodeList, newRing *hashring.HashRing, ...) map[InodeKeyType]DirtyChunkInfo
  • func (d *DirtyMgr) GetDirtyMetaForNodeLeave(nodeList *RaftNodeList) (map[InodeKeyType]bool, map[string]map[InodeKeyType]bool)
  • func (d *DirtyMgr) GetDirtyMetasForNodeJoin(migrationId MigrationId, nodeList *RaftNodeList, newRing *hashring.HashRing, ...) map[InodeKeyType]bool
  • func (d *DirtyMgr) GetLikelyDirtyChunkInodeIds() []InodeKeyType
  • func (d *DirtyMgr) IsDirtyChunk(chunk *Chunk) bool
  • func (d *DirtyMgr) IsDirtyMeta(inodeKey InodeKeyType) (ok bool)
  • func (d *DirtyMgr) RemoveChildMetaNoLock(meta *WorkingMeta, name string)
  • func (d *DirtyMgr) RemoveChunkNoLock(inodeKey InodeKeyType, offset int64, chunkVer uint32)
  • func (d *DirtyMgr) RemoveChunkNoLockAllOffsets(inodeId InodeKeyType)
  • func (d *DirtyMgr) RemoveDeleteKeyNoLock(key string) (InodeKeyType, bool)
  • func (d *DirtyMgr) RemoveMetaNoLock(inodeId InodeKeyType)
  • func (d *DirtyMgr) RemoveMetaNoLockIfLatest(inodeId InodeKeyType, version uint32) bool
  • func (d *DirtyMgr) RemoveNonDirtyChunks(fps []uint64)
• type DiskWriteVector
• • func (b *DiskWriteVector) Less(i btree.Item) bool
• type DropLRUChunksCommand
• • func NewDropLRUChunksCommand(inodeKeys []uint64, offsets []int64) DropLRUChunksCommand
• • func (c DropLRUChunksCommand) Commit(n *NodeServer)
  • func (c DropLRUChunksCommand) GetExtCmdId() uint16
  • func (c DropLRUChunksCommand) GetTxId() TxId
  • func (c DropLRUChunksCommand) IsSingleShot() bool
  • func (c DropLRUChunksCommand) NeedTwoPhaseCommit(*RaftGroupMgr) bool
• type EpollHandler
• • func NewEpollHandler() (*EpollHandler, error)
• • func (r *EpollHandler) AddFd(fd int, events uint32) (err error)
  • func (r *EpollHandler) Close() (err error)
  • func (r *EpollHandler) RemoveFd(fd int) (err error)
• type EpollReader
• • func NewEpollReader() (*EpollReader, error)
• • func (r *EpollReader) AddFd(fd int, sa common.NodeAddrInet4) (err error)
  • func (r *EpollReader) CheckReset() (ok bool)
  • func (r *EpollReader) Close() error
  • func (r *EpollReader) RaftRpcThread(maxEvents int, n *NodeServer, pipeFds [2]int, raft *RaftInstance)
  • func (r *EpollReader) RemoveFd(fd int) (err error)
• type ExpireDeleteInfo
• • func NewExpireDeleteInfoFromMeta(key string, meta *WorkingMeta, timestamp int64) ExpireDeleteInfo
  • func NewExpireDeleteInfoFromMsg(msg *common.DeletedFileInfoMsg) ExpireDeleteInfo
• • func (i ExpireDeleteInfo) Less(l btree.Item) bool
• type ExpireInfo
• • func NewExpireInfoFromMeta(meta *WorkingMeta, timestamp int64) ExpireInfo
  • func NewExpireInfoFromMsg(msg *common.DirtyMetaInfoMsg) ExpireInfo
• • func (i ExpireInfo) Less(l btree.Item) bool
• type ExtLogCommand
• • func NewExtLogCommand(extCmdId uint16, logId LogIdType, logOffset int64, dataLen uint32, ...) ExtLogCommand
  • func NewExtLogCommandFromExtBuf(extCmdId uint16, logId LogIdType, logOffset int64, extBuf []byte) ExtLogCommand
• • func (c ExtLogCommand) Apply(n *NodeServer, extLog ExtLogCommandImpl)
  • func (c ExtLogCommand) GetCmdId() uint16
  • func (c ExtLogCommand) GetExtPayloadSize() uint8
  • func (c ExtLogCommand) SetExtPayload(extPayload []byte)
• type ExtLogCommandImpl
• • func LoadExtBuf(extLogger *OnDiskLogger, l *AppendEntryCommand) (extCmd ExtLogCommandImpl, err error)
  • func NewAbortTxCommandFromExtbuf(extBuf []byte) (ExtLogCommandImpl, error)
  • func NewAddInodeFileMapCommandFromExtbuf(extBuf []byte) (ExtLogCommandImpl, error)
  • func NewBeginPersistCommandFromExtBuf(extBuf []byte) (ExtLogCommandImpl, error)
  • func NewCommitChunkCommandFromExtbuf(extBuf []byte) (ExtLogCommandImpl, error)
  • func NewCompactLogCoordinatorCommandFromExtBuf(extBuf []byte) (ExtLogCommandImpl, error)
  • func NewCreateChunkCommandFromExtbuf(extBuf []byte) (ExtLogCommandImpl, error)
  • func NewCreateCoordinatorCommandFromExtBuf(extBuf []byte) (ExtLogCommandImpl, error)
  • func NewCreateMetaCommandFromExtbuf(extBuf []byte) (ExtLogCommandImpl, error)
  • func NewDeleteCoordinatorCommandFromExtBuf(extBuf []byte) (ExtLogCommandImpl, error)
  • func NewDeleteInodeFileMapCommandFromExtbuf(extBuf []byte) (ExtLogCommandImpl, error)
  • func NewDeleteMetaCommandFromExtbuf(extBuf []byte) (ExtLogCommandImpl, error)
  • func NewDeletePersistCoordinatorCommandFromExtBuf(extBuf []byte) (ExtLogCommandImpl, error)
  • func NewDropLRUChunksCommandFromExtbuf(extBuf []byte) (ExtLogCommandImpl, error)
  • func NewFlushCoordinatorCommandFromExtBuf(extBuf []byte) (ExtLogCommandImpl, error)
  • func NewForgetAllDirtyLogCommandFromExtbuf(extBuf []byte) (ExtLogCommandImpl, error)
  • func NewHardLinkCoordinatorCommandFromExtBuf(extBuf []byte) (ExtLogCommandImpl, error)
  • func NewInitNodeListCommandFromExtBuf(extBuf []byte) (ExtLogCommandImpl, error)
  • func NewPersistChunkCommandFromExtbuf(extBuf []byte) (ExtLogCommandImpl, error)
  • func NewPersistCoordinatorCommandFromExtBuf(extBuf []byte) (ExtLogCommandImpl, error)
  • func NewRecordMigratedAddChunkCommandFromExtbuf(extBuf []byte) (ExtLogCommandImpl, error)
  • func NewRecordMigratedAddMetaCommandFromExtbuf(extBuf []byte) (ExtLogCommandImpl, error)
  • func NewRecordMigratedRemoveChunkCommandFromExtbuf(extBuf []byte) (ExtLogCommandImpl, error)
  • func NewRecordMigratedRemoveMetaCommandFromExtbuf(extBuf []byte) (ExtLogCommandImpl, error)
  • func NewRemoveNonDirtyChunksCommandFromExtbuf(extBuf []byte) (ExtLogCommandImpl, error)
  • func NewRenameCoordinatorCommandFromExtBuf(extBuf []byte) (ExtLogCommandImpl, error)
  • func NewTruncateCoordinatorCommandFromExtBuf(extBuf []byte) (ExtLogCommandImpl, error)
  • func NewUpdateChunkCommandFromExtbuf(extBuf []byte) (ExtLogCommandImpl, error)
  • func NewUpdateMetaAttrCommandFromExtbuf(extBuf []byte) (ExtLogCommandImpl, error)
  • func NewUpdateMetaCommandFromExtbuf(extBuf []byte) (ExtLogCommandImpl, error)
  • func NewUpdateMetaKeyCommandFromExtbuf(extBuf []byte) (ExtLogCommandImpl, error)
  • func NewUpdateNodeListCommandFromExtbuf(extBuf []byte) (ExtLogCommandImpl, error)
  • func NewUpdateNodeListCoordinatorCommandFromExtBuf(extBuf []byte) (ExtLogCommandImpl, error)
  • func NewUpdateParentMetaCommandFromExtbuf(extBuf []byte) (ExtLogCommandImpl, error)
• type FileHandle
• • func NewFileHandle(h MetaRWHandler, isReadOnly bool, disableLocalWriteBackCaching bool) *FileHandle
• • func (i *FileHandle) Flush(n *NodeServer) (meta *WorkingMeta, errno error)
  • func (i *FileHandle) GetLength() int64
  • func (i *FileHandle) Read(offset int64, size int64, n *NodeServer, op interface{}) (data [][]byte, count int, errno error)
  • func (i *FileHandle) ReadNoCache(offset int64, size int64, n *NodeServer, op interface{}) (data [][]byte, count int, errno error)
  • func (i *FileHandle) ReleaseFlyingBuffer(op interface{})
  • func (i *FileHandle) SetMeta(meta *WorkingMeta)
  • func (i *FileHandle) SetModeMTime(mode *os.FileMode, mTime *time.Time)
  • func (i *FileHandle) Write(offset int64, data []byte, n *NodeServer) (meta *WorkingMeta, errno error)
• type FillNodeListOp
• • func NewFillNodeListOp(txId TxId, nodeList *RaftNodeList, target RaftNode, migrationId MigrationId) FillNodeListOp
• • func (o FillNodeListOp) GetCaller(n *NodeServer) RpcCaller
  • func (o FillNodeListOp) GetLeader(n *NodeServer, l *RaftNodeList) (RaftNode, bool)
  • func (o FillNodeListOp) GetTxId() TxId
  • func (o FillNodeListOp) RetToMsg(ret interface{}, r RaftBasicReply) (proto.Message, []SlicedPageBuffer)
• type FillingInfo
• type FillingKey
• type FillingKey2
• type FlushCoordinatorCommand
• • func NewFlushCoordinatorCommand(txId TxId, chunks []*common.UpdateChunkRecordMsg, metaTx TxRet, ...) FlushCoordinatorCommand
• • func (c FlushCoordinatorCommand) Commit(n *NodeServer)
  • func (c FlushCoordinatorCommand) GetExtCmdId() uint16
  • func (c FlushCoordinatorCommand) GetTxId() TxId
  • func (c FlushCoordinatorCommand) IsSingleShot() bool
  • func (c FlushCoordinatorCommand) NeedTwoPhaseCommit(raftGroup *RaftGroupMgr) bool
  • func (c FlushCoordinatorCommand) RemoteCommit(raftGroup *RaftGroupMgr) []ParticipantOp
• type ForgetAllDirtyLogCommand
• • func NewForgetAllDirtyLogCommand() ForgetAllDirtyLogCommand
• • func (c ForgetAllDirtyLogCommand) Commit(n *NodeServer)
  • func (c ForgetAllDirtyLogCommand) GetExtCmdId() uint16
  • func (c ForgetAllDirtyLogCommand) GetTxId() TxId
  • func (c ForgetAllDirtyLogCommand) IsSingleShot() bool
  • func (c ForgetAllDirtyLogCommand) NeedTwoPhaseCommit(*RaftGroupMgr) bool
• type GCS3
• • func (s *GCS3) Delegate() interface{}
  • func (s *GCS3) DeleteBlobs(param *DeleteBlobsInput) (*DeleteBlobsOutput, error)
  • func (s *GCS3) MultipartBlobAdd(param *MultipartBlobAddInput) (*MultipartBlobAddOutput, error)
  • func (s *GCS3) MultipartBlobBegin(param *MultipartBlobBeginInput) (*MultipartBlobCommitInput, error)
  • func (s *GCS3) MultipartBlobCommit(param *MultipartBlobCommitInput) (*MultipartBlobCommitOutput, error)
• type GCSMultipartBlobCommitInput
• type GetApiIpAndPortOp
• • func NewGetApiIpAndPortOp(leader RaftNode) GetApiIpAndPortOp
• • func (o GetApiIpAndPortOp) GetCaller(*NodeServer) RpcCaller
  • func (o GetApiIpAndPortOp) GetLeader(n *NodeServer, l *RaftNodeList) (RaftNode, bool)
  • func (o GetApiIpAndPortOp) RetToMsg(ret interface{}, r RaftBasicReply) (proto.Message, []SlicedPageBuffer)
• type GetBlobInput
• type GetBlobOutput
• type GetMetaOp
• • func NewGetMetaOp(inodeKey InodeKeyType, key string, chunkSize int64, expireMs int32, ...) GetMetaOp
• • func (o GetMetaOp) GetCaller(*NodeServer) RpcCaller
  • func (o GetMetaOp) GetLeader(n *NodeServer, l *RaftNodeList) (RaftNode, bool)
  • func (o GetMetaOp) RetToMsg(ret interface{}, r RaftBasicReply) (proto.Message, []SlicedPageBuffer)
• type GetWorkingMetaRet
• • func NewGetWrokingMetaRetFromMsg(msg *common.GetWorkingMetaRetMsg) *GetWorkingMetaRet
• • func (u *GetWorkingMetaRet) GetChildrenMsg() []*common.CopiedMetaChildMsg
• type HardLinkCoordinatorCommand
• • func NewHardLinkCoordinatorCommand(txId TxId, groupId string, newKey string, metaTx TxRet, parentTx TxRet, ...) HardLinkCoordinatorCommand
• • func (c HardLinkCoordinatorCommand) Commit(n *NodeServer)
  • func (c HardLinkCoordinatorCommand) GetExtCmdId() uint16
  • func (c HardLinkCoordinatorCommand) GetTxId() TxId
  • func (c HardLinkCoordinatorCommand) IsSingleShot() bool
  • func (c HardLinkCoordinatorCommand) NeedTwoPhaseCommit(raftGroup *RaftGroupMgr) bool
  • func (c HardLinkCoordinatorCommand) RemoteCommit(_ *RaftGroupMgr) []ParticipantOp
• type HeadBlobInput
• type HeadBlobOutput
• type InitNodeListCommand
• • func NewInitNodeListCommand(node RaftNode) InitNodeListCommand
• • func (c InitNodeListCommand) Commit(n *NodeServer)
  • func (c InitNodeListCommand) GetExtCmdId() uint16
  • func (c InitNodeListCommand) GetTxId() TxId
  • func (c InitNodeListCommand) IsSingleShot() bool
  • func (c InitNodeListCommand) NeedTwoPhaseCommit(*RaftGroupMgr) bool
• type Inode
• • func NewInode() *Inode
• • func (i *Inode) CopyChildren() map[string]InodeKeyType
  • func (i *Inode) CopyFiles() []string
  • func (i *Inode) CopyMeta() *WorkingMeta
  • func (i *Inode) UpdateMeta(meta *WorkingMeta, children map[string]InodeKeyType)
• type InodeKeyType
• type InodeMgr
• • func NewInodeMgr(back *ObjCacheBackend, raft *RaftInstance, flags *common.ObjcacheConfig) *InodeMgr
• • func (n *InodeMgr) AppendStagingChunkBuffer(inodeKey InodeKeyType, offset int64, chunkSize int64, buf []byte) (logOffset int64, reply int32)
  • func (n *InodeMgr) AppendStagingChunkLog(inodeKey InodeKeyType, offset int64, logId LogIdType, logOffset int64, ...) (reply int32)
  • func (n *InodeMgr) CheckReset() (ok bool)
  • func (n *InodeMgr) Clean(dirtyMgr *DirtyMgr) int32
  • func (n *InodeMgr) CommitCreateChunk(inodeKey InodeKeyType, offset int64, version uint32, logOffset int64, ...)
  • func (n *InodeMgr) CommitCreateMeta(working *WorkingMeta, parent InodeKeyType, newKey string, dirtyMgr *DirtyMgr)
  • func (n *InodeMgr) CommitDeleteChunk(inodeKey InodeKeyType, offset int64, chunkSize int64, chunkVer uint32, ...)
  • func (n *InodeMgr) CommitDeleteInodeMap(inodeKeys []uint64, keys []string)
  • func (n *InodeMgr) CommitDeletePersistMeta(key string, dirtyMgr *DirtyMgr)
  • func (n *InodeMgr) CommitPersistChunk(inodeKey InodeKeyType, offsets []int64, cVers []uint32, dirtyMgr *DirtyMgr)
  • func (n *InodeMgr) CommitPersistMeta(inodeKey InodeKeyType, newFetchKey string, version uint32, ts int64, ...)
  • func (n *InodeMgr) CommitSetMetaAndInodeFile(working *WorkingMeta, children map[string]InodeKeyType, key string)
  • func (n *InodeMgr) CommitUpdateChunk(inodeKey InodeKeyType, offset int64, chunkSize int64, chunkVer uint32, ...)
  • func (n *InodeMgr) CommitUpdateInodeToFile(working *WorkingMeta, children map[string]InodeKeyType, removedKey string, ...) *WorkingMeta
  • func (n *InodeMgr) CommitUpdateMeta(working *WorkingMeta, dirtyMgr *DirtyMgr)
  • func (n *InodeMgr) CommitUpdateMetaAttr(inodeKey InodeKeyType, mode uint32, ts int64)
  • func (n *InodeMgr) CommitUpdateParentMeta(info *UpdateParentInfo, dirtyMgr *DirtyMgr)
  • func (n *InodeMgr) CreateInodeId() (InodeKeyType, error)
  • func (n *InodeMgr) DeleteInode(inodeKeys []uint64)
  • func (n *InodeMgr) DropLRUChunk(keys []uint64, offsets []int64)
  • func (n *InodeMgr) GetAllChunks(chunks map[InodeKeyType]DirtyChunkInfo) ([]*common.AppendCommitUpdateChunksMsg, error)
  • func (n *InodeMgr) GetAllDirInodes() []*common.InodeTreeMsg
  • func (n *InodeMgr) GetAllDirectoryMetaAsUint64() []uint64
  • func (n *InodeMgr) GetAllMeta() ([]*common.CopiedMetaMsg, []*common.InodeToFileMsg)
  • func (n *InodeMgr) GetAllMetaIn(inodeKeys []uint64) ([]*common.CopiedMetaMsg, []*common.InodeToFileMsg)
  • func (n *InodeMgr) GetChunk(inodeKey InodeKeyType, offset int64, chunkSize int64) *Chunk
  • func (n *InodeMgr) GetInode(inodeKey InodeKeyType) *Inode
  • func (n *InodeMgr) GetMetaForNodeJoin(migrationId MigrationId, selfGroup string, joinGroup string, ...) *Snapshot
  • func (n *InodeMgr) GetMetaForNodeLeave(migrationId MigrationId, nodeList *RaftNodeList, ...) map[string]*Snapshot
  • func (n *InodeMgr) GetOrFetchWorkingMeta(inodeKey InodeKeyType, key string, chunkSize int64, expireMs int32, ...) (*WorkingMeta, map[string]InodeKeyType, int32)
  • func (n *InodeMgr) MpuAbort(key string, uploadId string) (reply int32)
  • func (n *InodeMgr) MpuAdd(metaKey string, meta *WorkingMeta, offset int64, uploadId string, priority int, ...) (out MpuAddOut, unlock func(*NodeServer), reply int32)
  • func (n *InodeMgr) MpuBegin(key string) (uploadId string, reply int32)
  • func (n *InodeMgr) MpuCommit(key string, uploadId string, eTags []string) (ts int64, reply int32)
  • func (n *InodeMgr) NewWorkingMetaForRoot() (*WorkingMeta, map[string]InodeKeyType)
  • func (n *InodeMgr) PersistDeleteObject(key string, _ int) (reply int32)
  • func (n *InodeMgr) PrefetchChunkThread(h MetaRWHandler, offset int64)
  • func (n *InodeMgr) PrepareCreateMeta(inodeKey InodeKeyType, chunkSize int64, expireMs int32, mode uint32) (*WorkingMeta, func(*NodeServer), int32)
  • func (n *InodeMgr) PreparePersistChunk(meta *WorkingMeta, offset int64) (chunk *Chunk, working *WorkingChunk, reply int32)
  • func (n *InodeMgr) PreparePersistDeleteMeta(key string, dirtyMgr *DirtyMgr) int32
  • func (n *InodeMgr) PreparePersistMeta(inodeKey InodeKeyType, dirtyMgr *DirtyMgr) (*Inode, []string, *WorkingMeta, int32)
  • func (n *InodeMgr) PrepareUpdateChunk(newMeta *WorkingMeta, alignedOffset int64) (chunk *Chunk, working *WorkingChunk)
  • func (n *InodeMgr) PrepareUpdateMeta(inodeKey InodeKeyType, delete bool) (*WorkingMeta, func(*NodeServer), int32)
  • func (n *InodeMgr) PrepareUpdateMetaKey(inodeKey InodeKeyType, oldKey string, parent InodeKeyType, chunkSize int64, ...) (*WorkingMeta, map[string]InodeKeyType, func(*NodeServer), int32)
  • func (n *InodeMgr) PrepareUpdateParent(inodeKey InodeKeyType, delete bool) (*WorkingMeta, map[string]InodeKeyType, func(*NodeServer), int32)
  • func (n *InodeMgr) PutDirObject(inode *Inode, meta *WorkingMeta, _ int) (ts int64, reply int32)
  • func (n *InodeMgr) PutEmptyObject(metaKeys []string, meta *WorkingMeta, _ int) (ts int64, reply int32)
  • func (n *InodeMgr) PutObject(tm *TxIdMgr, metaKeys []string, meta *WorkingMeta, priority int, ...) (ts int64, chunks []*common.PersistedChunkInfoMsg, reply int32)
  • func (n *InodeMgr) QuickCommitDeleteChunk(localOffsets map[int64]int64, meta *WorkingMeta, dirtyMgr *DirtyMgr)
  • func (n *InodeMgr) QuickCommitExpandChunk(localOffsets map[int64]int64, meta *WorkingMeta, dirtyMgr *DirtyMgr)
  • func (n *InodeMgr) QuickCommitUpdateChunk(meta *WorkingMeta, selfGroup string, ucs []*common.UpdateChunkRecordMsg, ...)
  • func (n *InodeMgr) QuickPrepareChunk(newMeta *WorkingMeta, alignedOffset int64) (chunk *Chunk, working *WorkingChunk)
  • func (n *InodeMgr) RestoreInodeTree(inodes []*common.InodeTreeMsg)
  • func (n *InodeMgr) RestoreMetas(metas []*common.CopiedMetaMsg, files []*common.InodeToFileMsg)
  • func (n *InodeMgr) SetChunkNoLock(chunk *Chunk, h MetaRWHandler) (*WorkingChunk, int32)
  • func (n *InodeMgr) UnlockPersistInode(inode *Inode, inodeKey InodeKeyType)
  • func (n *InodeMgr) UpdateMetaAttr(inodeKey InodeKeyType, mode uint32, ts int64) (*WorkingMeta, int32)
  • func (n *InodeMgr) UpdateMetaXattr(inodeKey InodeKeyType, expireMs int32, dirtyMgr *DirtyMgr) int32
  • func (n *InodeMgr) VectorReadChunk(h MetaRWHandler, offset int64, size int, blocking bool) (bufs []SlicedPageBuffer, count int, reply int32)
• type JoinMigrationOp
• • func NewJoinMigrationOp(txId TxId, target RaftNode, leaderGroupId string, migrationId MigrationId) JoinMigrationOp
• • func (o JoinMigrationOp) GetCaller(n *NodeServer) RpcCaller
  • func (o JoinMigrationOp) GetLeader(n *NodeServer, l *RaftNodeList) (RaftNode, bool)
  • func (o JoinMigrationOp) GetTxId() TxId
  • func (o JoinMigrationOp) RetToMsg(ret interface{}, r RaftBasicReply) (proto.Message, []SlicedPageBuffer)
• type LeaveMigrationOp
• • func NewLeaveMigrationOp(txId TxId, target RaftNode, leaderGroupId string, migrationId MigrationId) LeaveMigrationOp
• • func (o LeaveMigrationOp) GetCaller(n *NodeServer) RpcCaller
  • func (o LeaveMigrationOp) GetLeader(n *NodeServer, l *RaftNodeList) (RaftNode, bool)
  • func (o LeaveMigrationOp) GetTxId() TxId
  • func (o LeaveMigrationOp) RetToMsg(ret interface{}, r RaftBasicReply) (proto.Message, []SlicedPageBuffer)
• type ListBlobsInput
• type ListBlobsOutput
• type LocalInode
• type LocalReadHistory
• • func NewLocalBufferCacheHistory() *LocalReadHistory
• • func (c *LocalReadHistory) Add(inodeKey InodeKeyType, offset int64, length int)
  • func (c *LocalReadHistory) CheckReset() (ok bool)
  • func (c *LocalReadHistory) Delete(inodeKey InodeKeyType)
  • func (c *LocalReadHistory) DropAll()
  • func (c *LocalReadHistory) Has(inodeKey InodeKeyType, offset int64) (int, bool)
• type LogIdType
• • func GetAppendEntryExtLogArgs(extEntryPayload []byte) (logId LogIdType, logLength int32, logOffset int64)
  • func NewLogIdTypeFromBuf(buf []byte) LogIdType
  • func NewLogIdTypeFromInodeKey(inodeKey InodeKeyType, offset int64, chunkSize int64) LogIdType
• • func (f LogIdType) IsValid() bool
  • func (f LogIdType) Put(buf []byte)
• type LogOffsetPair
• type MakeBucketInput
• type MakeBucketOutput
• type MemoryPool
• • func (m *MemoryPool) CheckReset() (ok bool)
  • func (m *MemoryPool) GetPages(nrPages int64) (buf *PageBuffer, err error)
  • func (m *MemoryPool) PutPages(buf *PageBuffer)
  • func (m *MemoryPool) Reset()
• type MetaRWHandler
• • func NewMetaRWHandlerFromMeta(meta *WorkingMeta) MetaRWHandler
  • func NewMetaRWHandlerFromMsg(msg *common.MetaRWHandlerMsg) MetaRWHandler
• type MigrationId
• • func NewMigrationIdFromMsg(migrationId *common.MigrationIdMsg) MigrationId
• type MpuAbortOp
• • func NewMpuAbortOp(txId TxId, keys []string, uploadIds []string) MpuAbortOp
• • func (o MpuAbortOp) GetCaller(n *NodeServer) RpcCaller
  • func (o MpuAbortOp) GetLeader(n *NodeServer, l *RaftNodeList) (RaftNode, bool)
  • func (o MpuAbortOp) GetTxId() TxId
  • func (o MpuAbortOp) RetToMsg(interface{}, RaftBasicReply) (proto.Message, []SlicedPageBuffer)
• type MpuAddOp
• • func NewMpuAddOp(leader RaftNode, nodeListVer uint64, txId TxId, metaKey string, ...) MpuAddOp
• • func (o MpuAddOp) GetCaller(n *NodeServer) RpcCaller
  • func (o MpuAddOp) GetLeader(n *NodeServer, l *RaftNodeList) (RaftNode, bool)
  • func (o MpuAddOp) GetTxId() TxId
  • func (o MpuAddOp) RetToMsg(ret interface{}, r RaftBasicReply) (proto.Message, []SlicedPageBuffer)
• type MpuAddOut
• type MpuContext
• • func (c *MpuContext) WaitRet(n *NodeServer) (ret []MpuAddOut, r RaftBasicReply)
• type MultipartBlobAbortOutput
• type MultipartBlobAddInput
• type MultipartBlobAddOutput
• type MultipartBlobBeginInput
• type MultipartBlobCommitInput
• type MultipartBlobCommitOutput
• type MultipartExpireInput
• type MultipartExpireOutput
• type MyHashKey
• • func (m MyHashKey) Less(l hashring.HashKey) bool
• type MyRandString
• • func (r *MyRandString) Get(digit int64) string
• type NoOpCommand
• • func NewNoOpCommand() NoOpCommand
• • func (c NoOpCommand) Apply(*NodeServer, ExtLogCommandImpl)
  • func (c NoOpCommand) GetCmdId() uint16
  • func (c NoOpCommand) GetExtPayloadSize() uint8
  • func (c NoOpCommand) SetExtPayload([]byte)
• type NodeServer
• • func NewNodeServer(back *ObjCacheBackend, args *common.ObjcacheCmdlineArgs, ...) *NodeServer
• • func (n *NodeServer) AbortWriteObject(recordMap map[string][]*common.StagingChunkMsg)
  • func (n *NodeServer) CheckReset() (ok bool)
  • func (n *NodeServer) CoreDump(_ context.Context, _ *api.Void) (*api.Void, error)
  • func (n *NodeServer) CreateObject(parentKey string, parentInodeKey InodeKeyType, name string, ...) (meta *WorkingMeta, err error)
  • func (n *NodeServer) DropCache(_ context.Context, _ *api.Void) (*api.ApiRet, error)
  • func (n *NodeServer) EndOp()
  • func (n *NodeServer) EvictionThread(cacheCapacityBytes int64)
  • func (n *NodeServer) ExecDataRpc(msg RpcMsg, sa common.NodeAddrInet4, fd int, pipeFds [2]int, ...) (noData bool)
  • func (n *NodeServer) ExecRpcThread(msg RpcMsg, sa common.NodeAddrInet4, fd int)
  • func (n *NodeServer) FlushObject(inodeKey InodeKeyType, records []*common.UpdateChunkRecordMsg, mTime int64, ...) (meta *WorkingMeta, err error)
  • func (n *NodeServer) FlusherThread()
  • func (n *NodeServer) ForceStop()
  • func (n *NodeServer) GetApiIpAndPort(RpcMsg) *common.GetApiIpAndPortRet
  • func (n *NodeServer) GetApiIpAndPortRemote(node RaftNode) (apiAddr string, apiPort int, reply int32)
  • func (n *NodeServer) GetApiPort(leader RaftNode) (apiPort int, reply int32)
  • func (n *NodeServer) GetConfig(context.Context, *api.Void) (*api.GetConfigRet, error)
  • func (n *NodeServer) GetMeta(inodeKey InodeKeyType, key string, parent InodeKeyType) (*WorkingMeta, map[string]InodeKeyType, error)
  • func (n *NodeServer) GetTrackerNode(context.Context, *api.Void) (*api.GetTrackerNodeRet, error)
  • func (n *NodeServer) HardLinkObject(srcInodeId fuseops.InodeID, srcParent InodeKeyType, dstParentKey string, ...) (meta *WorkingMeta, err error)
  • func (n *NodeServer) Init(back *ObjCacheBackend) error
  • func (n *NodeServer) IsReady(_ context.Context, _ *api.Void) (*api.ApiRet, error)
  • func (n *NodeServer) LockNode()
  • func (n *NodeServer) Panic(_ context.Context, _ *api.Void) (*api.Void, error)
  • func (n *NodeServer) PersistAllDirty()
  • func (n *NodeServer) PersistObject(inodeId fuseops.InodeID) (meta *WorkingMeta, err error)
  • func (n *NodeServer) PrefetchChunk(h MetaRWHandler, offset int64, length int64)
  • func (n *NodeServer) ReadAheadChunk(h MetaRWHandler, offset int64, size int64)
  • func (n *NodeServer) ReadChunk(h MetaRWHandler, offset int64, size int, blocking bool) (bufs []SlicedPageBuffer, count int, err error)
  • func (n *NodeServer) Rejuvenate(_ context.Context, _ *api.Void) (*api.ApiRet, error)
  • func (n *NodeServer) RemoveInodeMetadataKey(_ fuseops.InodeID, _ string) error
  • func (n *NodeServer) RenameObject(srcParentKey string, srcParent InodeKeyType, dstParentKey string, ...) (err error)
  • func (n *NodeServer) RequestJoin(_ context.Context, args *api.RequestJoinArgs) (*api.ApiRet, error)
  • func (n *NodeServer) RequestJoinLocal(headWorkerAddr string, headWorkerPort int) error
  • func (n *NodeServer) RequestLeave() int32
  • func (n *NodeServer) RequestRemoveNode(_ context.Context, args *api.RequestLeaveArgs) (*api.ApiRet, error)
  • func (n *NodeServer) SetFs(fs *ObjcacheFileSystem)
  • func (n *NodeServer) SetInodeMetadataKey(_ fuseops.InodeID, name string, value []byte, flags uint32) error
  • func (n *NodeServer) Shutdown(deleteStateFile bool) bool
  • func (n *NodeServer) StartGrpcServer() error
  • func (n *NodeServer) Terminate(_ context.Context, _ *api.Void) (*api.Void, error)
  • func (n *NodeServer) TerminateThread()
  • func (n *NodeServer) TruncateObject(inodeId fuseops.InodeID, size int64) (meta *WorkingMeta, err error)
  • func (n *NodeServer) TryBeginOp() bool
  • func (n *NodeServer) TryLockNode() bool
  • func (n *NodeServer) UnlinkObject(parentFullPath string, parentId fuseops.InodeID, name string, ...) (err error)
  • func (n *NodeServer) UnlockNode()
  • func (n *NodeServer) UpdateNodeListAsClient() error
  • func (n *NodeServer) UpdateObjectAttr(inodeKeyType InodeKeyType, mode uint32, ts int64) (meta *WorkingMeta, err error)
  • func (n *NodeServer) VectorReadFastPath(h MetaRWHandler, offset int64, size int, blocking bool) (bufs []SlicedPageBuffer, count int, err error)
  • func (n *NodeServer) WaitNodeUnlocked()
  • func (n *NodeServer) WaitShutdown()
  • func (n *NodeServer) WriteChunk(inodeKey InodeKeyType, chunkSize int64, offset int64, size int64, buf []byte) ([]*common.UpdateChunkRecordMsg, int32)
• type ObjCacheBackend
• • func NewObjCache(secretFile string, debugS3 bool, bufferSize int) (*ObjCacheBackend, error)
  • func NewObjCacheFromSecrets(buckets []BucketCredential, debugS3 bool, bufferSize int) (*ObjCacheBackend, error)
• • func (s *ObjCacheBackend) GetBucketKey(path string) (string, string)
  • func (s *ObjCacheBackend) Init(key string) error
• type ObjcacheFileSystem
• • func GetFSWithoutMount(args *common.ObjcacheCmdlineArgs, flags *common.ObjcacheConfig) (fs *ObjcacheFileSystem, err error)
  • func NewObjcacheFileSystem(args *common.ObjcacheCmdlineArgs, flags *common.ObjcacheConfig) (*ObjcacheFileSystem, error)
• • func (fs *ObjcacheFileSystem) BatchForget(_ context.Context, op *fuseops.BatchForgetOp) error
  • func (fs *ObjcacheFileSystem) CheckReset() (ok bool)
  • func (fs *ObjcacheFileSystem) CreateFile(_ context.Context, op *fuseops.CreateFileOp) (err error)
  • func (fs *ObjcacheFileSystem) CreateLink(_ context.Context, op *fuseops.CreateLinkOp) (err error)
  • func (fs *ObjcacheFileSystem) CreateSymlink(_ context.Context, op *fuseops.CreateSymlinkOp) (err error)
  • func (fs *ObjcacheFileSystem) Destroy()
  • func (fs *ObjcacheFileSystem) EndReset()
  • func (fs *ObjcacheFileSystem) Fallocate(_ context.Context, op *fuseops.FallocateOp) (err error)
  • func (fs *ObjcacheFileSystem) FlushFile(_ context.Context, op *fuseops.FlushFileOp) (err error)
  • func (fs *ObjcacheFileSystem) ForgetInode(_ context.Context, op *fuseops.ForgetInodeOp) error
  • func (fs *ObjcacheFileSystem) FuseMount(args *common.ObjcacheCmdlineArgs, flags *common.ObjcacheConfig) (err error)
  • func (fs *ObjcacheFileSystem) GetInodeAttributes(_ context.Context, op *fuseops.GetInodeAttributesOp) (err error)
  • func (fs *ObjcacheFileSystem) GetOpenInodes() map[InodeKeyType]bool
  • func (fs *ObjcacheFileSystem) GetXattr(_ context.Context, op *fuseops.GetXattrOp) (err error)
  • func (fs *ObjcacheFileSystem) InitNodeListAsClient() (err error)
  • func (fs *ObjcacheFileSystem) ListXattr(_ context.Context, op *fuseops.ListXattrOp) (err error)
  • func (fs *ObjcacheFileSystem) LookUpInode(_ context.Context, op *fuseops.LookUpInodeOp) (err error)
  • func (fs *ObjcacheFileSystem) MkDir(_ context.Context, op *fuseops.MkDirOp) (err error)
  • func (fs *ObjcacheFileSystem) MkNode(_ context.Context, op *fuseops.MkNodeOp) (err error)
  • func (fs *ObjcacheFileSystem) OpenDir(_ context.Context, op *fuseops.OpenDirOp) (err error)
  • func (fs *ObjcacheFileSystem) OpenFile(_ context.Context, op *fuseops.OpenFileOp) (err error)
  • func (fs *ObjcacheFileSystem) PostOp(_ context.Context, op interface{})
  • func (fs *ObjcacheFileSystem) ReadDir(_ context.Context, op *fuseops.ReadDirOp) (err error)
  • func (fs *ObjcacheFileSystem) ReadFile(_ context.Context, op *fuseops.ReadFileOp) (err error)
  • func (fs *ObjcacheFileSystem) ReadSymlink(_ context.Context, op *fuseops.ReadSymlinkOp) (err error)
  • func (fs *ObjcacheFileSystem) ReleaseDirHandle(_ context.Context, op *fuseops.ReleaseDirHandleOp) (err error)
  • func (fs *ObjcacheFileSystem) ReleaseFileHandle(_ context.Context, op *fuseops.ReleaseFileHandleOp) (err error)
  • func (fs *ObjcacheFileSystem) RemoveXattr(_ context.Context, op *fuseops.RemoveXattrOp) (err error)
  • func (fs *ObjcacheFileSystem) Rename(_ context.Context, op *fuseops.RenameOp) (err error)
  • func (fs *ObjcacheFileSystem) RequestJoinLocal(headWorkerAddr string, headWorkerPort int) (err error)
  • func (fs *ObjcacheFileSystem) Reset(shutdown bool) error
  • func (fs *ObjcacheFileSystem) RmDir(_ context.Context, op *fuseops.RmDirOp) (err error)
  • func (fs *ObjcacheFileSystem) SetInodeAttributes(_ context.Context, op *fuseops.SetInodeAttributesOp) (err error)
  • func (fs *ObjcacheFileSystem) SetRoot() error
  • func (fs *ObjcacheFileSystem) SetXattr(_ context.Context, op *fuseops.SetXattrOp) (err error)
  • func (fs *ObjcacheFileSystem) StatFS(_ context.Context, op *fuseops.StatFSOp) (err error)
  • func (fs *ObjcacheFileSystem) SyncFile(_ context.Context, op *fuseops.SyncFileOp) (err error)
  • func (fs *ObjcacheFileSystem) Unlink(_ context.Context, op *fuseops.UnlinkOp) (err error)
  • func (fs *ObjcacheFileSystem) WaitReset()
  • func (fs *ObjcacheFileSystem) WriteFile(_ context.Context, op *fuseops.WriteFileOp) (err error)
• type ObjcacheProc
• • func (p *ObjcacheProc) CheckReset() (ok bool)
• type OnDiskLog
• • func NewOnDiskLog(filePath string, maxNrCache int, maxWriters int) *OnDiskLog
• • func (d *OnDiskLog) AppendSingleBuffer(buf []byte) (vec *DiskWriteVector, sizeIncrease int64, err error)
  • func (d *OnDiskLog) BeginAppendSplice(srcFd int, size int64) (*DiskWriteVector, error)
  • func (d *OnDiskLog) BeginAppendWrite(buf []byte) (*DiskWriteVector, error)
  • func (d *OnDiskLog) BeginRandomSplice(srcFd int, size int64, logOffset int64) (*DiskWriteVector, error)
  • func (d *OnDiskLog) BeginRandomWrite(buf []byte, logOffset int64) (*DiskWriteVector, error)
  • func (d *OnDiskLog) CheckReset() (ok bool)
  • func (d *OnDiskLog) Clear() (size int64)
  • func (d *OnDiskLog) EndWrite(vec *DiskWriteVector) (sizeIncrease int64, err error)
  • func (d *OnDiskLog) GetSize() int64
  • func (d *OnDiskLog) InitSize(fileSize int64)
  • func (d *OnDiskLog) Read(logOffset int64, size int64) (bufs [][]byte, count int64, err error)
  • func (d *OnDiskLog) ReadNoCache(buf []byte, logOffset int64, dataLen int64, directIo bool) (count int64, err error)
  • func (d *OnDiskLog) ReserveAppendWrite(size int64) (logOffset int64)
  • func (d *OnDiskLog) SendZeroCopy(toFd int, logOffset int64, size int32, bufOff *int32) (err error)
  • func (d *OnDiskLog) Shrink(newSize int64) (oldSize int64, err error)
  • func (d *OnDiskLog) Splice(vec *DiskWriteVector, pipeFds [2]int, bufOff *int32) (err error)
  • func (d *OnDiskLog) WaitWrites() (size int64)
  • func (d *OnDiskLog) Write(vec *DiskWriteVector) error
  • func (d *OnDiskLog) WriteSingleBuffer(buf []byte, logOffset int64) (vec *DiskWriteVector, sizeIncrease int64, err error)
• type OnDiskLogger
• • func NewOnDiskLogger(filePrefix string) *OnDiskLogger
• • func (c *OnDiskLogger) AddDiskUsage(size int64) int64
  • func (c *OnDiskLogger) AppendSingleBuffer(logId LogIdType, buf []byte) (logOffset int64, err error)
  • func (c *OnDiskLogger) CheckReset() (ok bool)
  • func (c *OnDiskLogger) Clear()
  • func (c *OnDiskLogger) Freeze(logId LogIdType)
  • func (c *OnDiskLogger) GetDiskLog(logId LogIdType, maxNrCache int, maxWriters int) (disk *OnDiskLog)
  • func (c *OnDiskLogger) GetDiskUsage() int64
  • func (c *OnDiskLogger) GetSize(logId LogIdType) (size int64)
  • func (c *OnDiskLogger) IsFreezed(logId LogIdType) bool
  • func (c *OnDiskLogger) PutDiskLog(logId LogIdType, vec *DiskWriteVector, sizeIncrease int64)
  • func (c *OnDiskLogger) Read(logId LogIdType, logOffset int64, logBytes int64) (extBuf []byte, err error)
  • func (c *OnDiskLogger) ReadNoCache(logId LogIdType, buf []byte, logOffset int64, logBytes int64, directIo bool) (count int64, err error)
  • func (c *OnDiskLogger) Remove(logId LogIdType) (size int64, err error)
  • func (c *OnDiskLogger) ReserveRange(logId LogIdType, logBytes int64) (offset int64)
  • func (c *OnDiskLogger) Reset()
  • func (c *OnDiskLogger) SendZeroCopy(logId LogIdType, toFd int, logOffset int64, logBytes int32, bufOff *int32) (err error)
  • func (c *OnDiskLogger) WriteSingleBuffer(logId LogIdType, buf []byte, logOffset int64) error
  • func (c *OnDiskLogger) ZeroCopyRead(logId LogIdType, logOffset int64, logBytes int64) (bufs [][]byte, count int64, err error)
• type OnDiskState
• • func NewOnDiskState(rootDir string, selfId uint32, stateName string) (*OnDiskState, int32)
• • func (s *OnDiskState) CheckReset() (ok bool)
  • func (s *OnDiskState) Clean()
  • func (s *OnDiskState) Get() uint32
  • func (s *OnDiskState) Increment() int32
  • func (s *OnDiskState) Reset() int32
  • func (s *OnDiskState) Set(value uint32) int32
• type PageBuffer
• • func GetPageBuffer(size int64) (*PageBuffer, error)
• • func (p *PageBuffer) AsSlice() SlicedPageBuffer
  • func (p *PageBuffer) Down() (count int32)
  • func (p *PageBuffer) IsEvictable() bool
  • func (p *PageBuffer) Up()
• type PagePool
• • func NewPagePool(size int, maxNrElements int) *PagePool
• • func (p *PagePool) CheckReset() (ok bool)
  • func (p *PagePool) Get() (*PageBuffer, error)
  • func (p *PagePool) Put(buf *PageBuffer)
  • func (p *PagePool) Reset()
• type ParticipantOp
• • func NewAbortParticipantOpFromMsg(msg RpcMsg) (ParticipantOp, uint64, int32)
  • func NewCommitDeleteChunkOpFromMsg(msg RpcMsg) (ParticipantOp, uint64, int32)
  • func NewCommitExpandChunkOpFromMsg(msg RpcMsg) (ParticipantOp, uint64, int32)
  • func NewCommitParticipantOpFromMsg(msg RpcMsg) (ParticipantOp, uint64, int32)
  • func NewCommitPersistChunkOpFromMsg(msg RpcMsg) (ParticipantOp, uint64, int32)
  • func NewCommitUpdateChunkOpFromMsg(msg RpcMsg) (ParticipantOp, uint64, int32)
  • func NewCreateChildMetaOpFromMsg(msg RpcMsg) (ParticipantOp, uint64, int32)
  • func NewCreateMetaOpFromMsg(msg RpcMsg) (ParticipantOp, uint64, int32)
  • func NewDeleteMetaOpFromMsg(msg RpcMsg) (ParticipantOp, uint64, int32)
  • func NewFillNodeListOpFromMsg(msg RpcMsg) (ParticipantOp, uint64, int32)
  • func NewJoinMigrationOpFromMsg(msg RpcMsg) (ParticipantOp, uint64, int32)
  • func NewLeaveMigrationOpFromMsg(msg RpcMsg) (ParticipantOp, uint64, int32)
  • func NewMpuAddOpFromMsg(msg RpcMsg) (ParticipantOp, uint64, int32)
  • func NewRenameMetaOpFromMsg(msg RpcMsg) (ParticipantOp, uint64, int32)
  • func NewTruncateMetaOpFromMsg(msg RpcMsg) (ParticipantOp, uint64, int32)
  • func NewUnlinkMetaOpFromMsg(msg RpcMsg) (ParticipantOp, uint64, int32)
  • func NewUpdateChunkOpFromProtoMsg(m proto.Message, logId LogIdType, logOffset int64, dataLength uint32) (ParticipantOp, uint64)
  • func NewUpdateMetaKeyOpFromMsg(msg RpcMsg) (ParticipantOp, uint64, int32)
  • func NewUpdateMetaSizeOpFromMsg(msg RpcMsg) (ParticipantOp, uint64, int32)
  • func NewUpdateNodeListOpFromMsg(msg RpcMsg) (ParticipantOp, uint64, int32)
• type ParticipantTx
• • func NewParticipantTx(txRet TxRet) ParticipantTx
  • func NewParticipantTxFromMsg(msg *common.ParticipantTxMsg) ParticipantTx
• type PersistChunkCommand
• • func NewPersistChunkCommand(inodeKey InodeKeyType, offsets []int64, chunkVers []uint32) PersistChunkCommand
• • func (c PersistChunkCommand) Commit(n *NodeServer)
  • func (c PersistChunkCommand) GetExtCmdId() uint16
  • func (c PersistChunkCommand) GetTxId() TxId
  • func (c PersistChunkCommand) IsSingleShot() bool
  • func (c PersistChunkCommand) NeedTwoPhaseCommit(*RaftGroupMgr) bool
• type PersistCoordinatorCommand
• • func NewPersistCoordinatorCommand(txId TxId, inodeKey InodeKeyType, metaVer uint32, ts int64, keys []string, ...) PersistCoordinatorCommand
• • func (c PersistCoordinatorCommand) Commit(n *NodeServer)
  • func (c PersistCoordinatorCommand) GetExtCmdId() uint16
  • func (c PersistCoordinatorCommand) GetTxId() TxId
  • func (c PersistCoordinatorCommand) IsSingleShot() bool
  • func (c PersistCoordinatorCommand) NeedTwoPhaseCommit(raftGroup *RaftGroupMgr) bool
  • func (c PersistCoordinatorCommand) RemoteCommit(raftGroup *RaftGroupMgr) []ParticipantOp
• type PrefetchChunkOp
• • func NewPrefetchChunkOp(leader RaftNode, offset int64, length int64, h MetaRWHandler, ...) PrefetchChunkOp
• • func (o PrefetchChunkOp) GetCaller(*NodeServer) RpcCaller
  • func (o PrefetchChunkOp) GetLeader(*NodeServer, *RaftNodeList) (RaftNode, bool)
  • func (o PrefetchChunkOp) RetToMsg(ret interface{}, r RaftBasicReply) (proto.Message, []SlicedPageBuffer)
• type PrepareRpcCaller
• • func NewPrepareRpcCaller(fn ParticipantOp, remoteTimeout time.Duration, nodeLock bool) PrepareRpcCaller
• • func (c PrepareRpcCaller) ExecLocal(n *NodeServer, nodeListVer uint64) (ret RpcRet, r RaftBasicReply)
  • func (c PrepareRpcCaller) ExecLocalInRpc(n *NodeServer, nodeListVer uint64) (ret RpcRet, r RaftBasicReply)
  • func (c PrepareRpcCaller) ExecRemote(n *NodeServer, addr common.NodeAddrInet4, nodeListVer uint64) (ret RpcRet, r RaftBasicReply)
  • func (c PrepareRpcCaller) GetLeader(n *NodeServer, nodeList *RaftNodeList) (RaftNode, bool)
  • func (c PrepareRpcCaller) TryNext(n *NodeServer, i int) bool
• type PutBlobInput
• type PutBlobOutput
• type RaftBasicReply
• • func NewRaftBasicReply(Status int32, leader *common.LeaderNodeMsg) RaftBasicReply
• • func (r *RaftBasicReply) GetApiNodeMsg(groupId string) *api.ApiNodeMsg
  • func (r *RaftBasicReply) GetLeaderNodeMsg() *common.LeaderNodeMsg
  • func (r *RaftBasicReply) GetNodeMsg(groupId string) *common.NodeMsg
• type RaftCommand
• • func NewAddServerCommandFromBytes(l *AppendEntryCommand) RaftCommand
  • func NewCommitCommandFromBytes(l *AppendEntryCommand) RaftCommand
  • func NewExtLogCommandFromBytes(l *AppendEntryCommand) RaftCommand
  • func NewNoOpCommandFromBytes(_ *AppendEntryCommand) RaftCommand
  • func NewRemoveServerCommandFromBytes(l *AppendEntryCommand) RaftCommand
  • func NewResetExtCommandFromBytes(l *AppendEntryCommand) RaftCommand
• type RaftGroupMgr
• • func NewRaftGroupMgr(groupId string, nrVirt int) *RaftGroupMgr
• • func (m *RaftGroupMgr) Add(node RaftNode)
  • func (m *RaftGroupMgr) BeginRaftRead(raft *RaftInstance, nodeListVer uint64) (r RaftBasicReply)
  • func (m *RaftGroupMgr) CheckReset() (ok bool)
  • func (m *RaftGroupMgr) Clean()
  • func (m *RaftGroupMgr) CommitUpdate(nodes []RaftNode, isAdd bool, nodeListVer uint64)
  • func (m *RaftGroupMgr) GetChunkOwnerGroupId(inodeKey InodeKeyType, offset int64, chunkSize int64) (string, bool)
  • func (m *RaftGroupMgr) GetGroupLeader(groupId string, l *RaftNodeList) (RaftNode, bool)
  • func (m *RaftGroupMgr) GetGroupLeaderNoLock(groupId string, l *RaftNodeList) (RaftNode, bool)
  • func (m *RaftGroupMgr) GetNodeListLocal() *RaftNodeList
  • func (m *RaftGroupMgr) GetNumberOfGroups() int
  • func (m *RaftGroupMgr) GetRemovedNodeListLocal(removed RaftNode) *RaftNodeList
  • func (m *RaftGroupMgr) GetReplica(leader RaftNode) (replica RaftNode, found bool)
  • func (m *RaftGroupMgr) Remove(nodeId uint32, groupId string)
  • func (m *RaftGroupMgr) ResetWithRaftNodeListMsg(msg *common.RaftNodeListMsg)
  • func (m *RaftGroupMgr) SetNodeListDirect(nodes []*api.ApiNodeMsg, nodeListVer uint64)
  • func (m *RaftGroupMgr) UpdateLeader(newLeader RaftNode) bool
  • func (m *RaftGroupMgr) UpdateNodeListLocal(isAdd bool, nodes []RaftNode, nodeListVer uint64)
• type RaftInstance
• • func NewRaftInstance(server *NodeServer) (*RaftInstance, uint64)
• • func (n *RaftInstance) AddServerLocal(sa common.NodeAddrInet4, serverId uint32) int32
  • func (n *RaftInstance) AppendBootstrapLogs(groupId string) int32
  • func (n *RaftInstance) AppendEntriesLocal(rc RaftCommand, extLogCmd ExtLogCommandImpl) (ret interface{}, lastLogIndex uint64, reply int32)
  • func (n *RaftInstance) AppendEntriesRpcBottomHalf(msg RpcMsg, sa common.NodeAddrInet4, fd int) (hadEntry bool)
  • func (n *RaftInstance) AppendEntriesRpcTopHalf(msg RpcMsg, sa common.NodeAddrInet4, fd int) (success bool, abort bool)
  • func (n *RaftInstance) AppendExtendedLogEntry(extLogCmd ExtLogCommandImpl) int32
  • func (n *RaftInstance) AppendInitEntry(rc RaftCommand) int32
  • func (n *RaftInstance) ApplyAll(cmd *AppendEntryCommand, logIndex uint64, extLogCmd ExtLogCommandImpl)
  • func (n *RaftInstance) CatchUpLog(sa common.NodeAddrInet4, serverId uint32, timeout time.Duration) int32
  • func (n *RaftInstance) CheckReset() (ok bool)
  • func (n *RaftInstance) CleanExtLogger()
  • func (n *RaftInstance) GenerateCoordinatorId() CoordinatorId
  • func (n *RaftInstance) GetExtLogId() LogIdType
  • func (n *RaftInstance) GetExtLogIdForLogCompaction() LogIdType
  • func (n *RaftInstance) HandleAppendEntriesResponse(msg RpcMsg, sa common.NodeAddrInet4) int32
  • func (n *RaftInstance) HandleRequestVoteResponse(msg RpcMsg, sa common.NodeAddrInet4) int32
  • func (n *RaftInstance) HeartBeatRecvThread(interval time.Duration)
  • func (n *RaftInstance) HeartBeaterThread()
  • func (n *RaftInstance) Init(passive bool)
  • func (n *RaftInstance) IsLeader() (r RaftBasicReply)
  • func (n *RaftInstance) RemoveAllServerIds() int32
  • func (n *RaftInstance) RemoveServerLocal(serverId uint32) int32
  • func (n *RaftInstance) ReplayAll() int32
  • func (n *RaftInstance) ReplicateLog(lastLogIndex uint64, added *uint32, addedSa *common.NodeAddrInet4, ...) (reply int32)
  • func (n *RaftInstance) RequestVoteRpc(msg RpcMsg, sa common.NodeAddrInet4, fd int) bool
  • func (n *RaftInstance) SetExt(logId uint32, seqNum uint32)
  • func (n *RaftInstance) Shutdown()
  • func (n *RaftInstance) StartVoting()
  • func (n *RaftInstance) StepDown(lastLogIndex uint64)
  • func (n *RaftInstance) SwitchExtLog(logId uint32)
  • func (n *RaftInstance) SwitchFileAndAppendEntriesLocal(rc RaftCommand, extLogCmd ExtLogCommandImpl) (ret interface{}, lastLogIndex uint64, reply int32)
  • func (n *RaftInstance) SyncBeforeClientQuery() (r RaftBasicReply)
  • func (n *RaftInstance) WaitPreviousCommits()
• type RaftLogger
• • func NewRaftLogger(rootDir string, filePrefix string, maxNrCache int) (ret *RaftLogger, reply int32)
• • func (f *RaftLogger) AppendCommand(cmd AppendEntryCommand) (logIndex uint64, reply int32)
  • func (f *RaftLogger) CheckReset() (ok bool)
  • func (f *RaftLogger) Clear()
  • func (f *RaftLogger) CompactLog() (reply int32)
  • func (f *RaftLogger) GetCurrentLogLength() uint64
  • func (f *RaftLogger) LoadCommandAt(logIndex uint64) (cmd AppendEntryCommand, reply int32)
  • func (f *RaftLogger) Shrink(logIndex uint64) (reply int32)
  • func (f *RaftLogger) SwitchFileAndAppendCommand(cmd AppendEntryCommand) (logIndex uint64, reply int32)
• type RaftNode
• • func NewRaftNodeFromApiMsg(msg *api.ApiNodeMsg) RaftNode
  • func NewRaftNodeFromMsg(msg *common.NodeMsg) RaftNode
• type RaftNodeList
• • func NewRaftNodeList(ring *hashring.HashRing, version uint64) *RaftNodeList
  • func NewRaftNodeListFromMsg(nrVirt int, msg *common.RaftNodeListMsg) *RaftNodeList
• • func (r *RaftNodeList) CheckReset() (ok bool)
• type ReadChunkOp
• • func NewReadChunkOp(h MetaRWHandler, offset int64, size int, blocking bool, readAhead bool) ReadChunkOp
• • func (o ReadChunkOp) GetCaller(*NodeServer) RpcCaller
  • func (o ReadChunkOp) GetLeader(n *NodeServer, l *RaftNodeList) (RaftNode, bool)
  • func (o ReadChunkOp) RetToMsg(ret interface{}, r RaftBasicReply) (proto.Message, []SlicedPageBuffer)
• type ReadChunkOpRet
• type ReadRpcMsgState
• type ReadSeekerCloser
• • func (r *ReadSeekerCloser) Close() error
• type ReaderBufferCache
• • func NewReaderBufferCache(flags *common.ObjcacheConfig) *ReaderBufferCache
• • func (c *ReaderBufferCache) CheckReset() (ok bool)
  • func (c *ReaderBufferCache) Delete(logId LogIdType) (size int64)
  • func (c *ReaderBufferCache) DropAll()
  • func (c *ReaderBufferCache) EndFill(logId LogIdType, offset int64)
  • func (c *ReaderBufferCache) EndFillWithPut(reader *BufferedDiskPageReader)
  • func (c *ReaderBufferCache) GetCacheOrBeginFill(logId LogIdType, offset int64) (reader *BufferedDiskPageReader, beginFill bool)
  • func (c *ReaderBufferCache) GetCacheWithFillWait(logId LogIdType, stagPart *StagingChunkPart, offset int64) *BufferedDiskPageReader
  • func (c *ReaderBufferCache) GetNewBufferedDiskPageReader(logId LogIdType, stag *StagingChunk, blocking bool) (*BufferedDiskPageReader, error)
  • func (c *ReaderBufferCache) ReleaseInFlightBuffer(reader *BufferedDiskPageReader)
  • func (c *ReaderBufferCache) SetEvictable(reader *BufferedDiskPageReader)
  • func (c *ReaderBufferCache) TryBeginFill(logId LogIdType, offset int64) (beginFill bool)
• type RecordMigratedAddChunkCommand
• • func NewRecordMigratedAddChunkCommand(migrationId MigrationId, chunk *common.AppendCommitUpdateChunksMsg) RecordMigratedAddChunkCommand
• • func (c RecordMigratedAddChunkCommand) Commit(n *NodeServer)
  • func (c RecordMigratedAddChunkCommand) GetExtCmdId() uint16
  • func (c RecordMigratedAddChunkCommand) GetTxId() TxId
  • func (c RecordMigratedAddChunkCommand) IsSingleShot() bool
  • func (c RecordMigratedAddChunkCommand) NeedTwoPhaseCommit(*RaftGroupMgr) bool
• type RecordMigratedAddMetaCommand
• • func NewRecordMigratedAddMetaCommand(s *Snapshot) RecordMigratedAddMetaCommand
• • func (c RecordMigratedAddMetaCommand) Commit(n *NodeServer)
  • func (c RecordMigratedAddMetaCommand) GetExtCmdId() uint16
  • func (c RecordMigratedAddMetaCommand) GetTxId() TxId
  • func (c RecordMigratedAddMetaCommand) IsSingleShot() bool
  • func (c RecordMigratedAddMetaCommand) NeedTwoPhaseCommit(*RaftGroupMgr) bool
• type RecordMigratedRemoveChunkCommand
• • func NewRecordMigratedRemoveChunkCommand(migrationId MigrationId, chunks []*common.ChunkRemoveDirtyMsg) RecordMigratedRemoveChunkCommand
• • func (c RecordMigratedRemoveChunkCommand) Commit(n *NodeServer)
  • func (c RecordMigratedRemoveChunkCommand) GetExtCmdId() uint16
  • func (c RecordMigratedRemoveChunkCommand) GetTxId() TxId
  • func (c RecordMigratedRemoveChunkCommand) IsSingleShot() bool
  • func (c RecordMigratedRemoveChunkCommand) NeedTwoPhaseCommit(*RaftGroupMgr) bool
• type RecordMigratedRemoveMetaCommand
• • func NewRecordMigratedRemoveMetaCommand(migrationId MigrationId, inodeKeys map[InodeKeyType]bool, ...) RecordMigratedRemoveMetaCommand
• • func (c RecordMigratedRemoveMetaCommand) Commit(n *NodeServer)
  • func (c RecordMigratedRemoveMetaCommand) GetExtCmdId() uint16
  • func (c RecordMigratedRemoveMetaCommand) GetTxId() TxId
  • func (c RecordMigratedRemoveMetaCommand) IsSingleShot() bool
  • func (c RecordMigratedRemoveMetaCommand) NeedTwoPhaseCommit(*RaftGroupMgr) bool
• type RemoteBufferCache
• • func NewRemotePageBufferCache(maxSize int64) *RemoteBufferCache
• • func (c *RemoteBufferCache) CheckReset() (ok bool)
  • func (c *RemoteBufferCache) Delete(inode InodeKeyType)
  • func (c *RemoteBufferCache) DropAll()
  • func (c *RemoteBufferCache) EndFill(inodeKey InodeKeyType, offset int64)
  • func (c *RemoteBufferCache) EndFillWithPut(page *RemotePageBuffer)
  • func (c *RemoteBufferCache) GetCache(inodeKey InodeKeyType, offset int64) (SlicedPageBuffer, bool)
  • func (c *RemoteBufferCache) GetCacheOrBeginFill(inodeKey InodeKeyType, offset int64) (p *RemotePageBuffer, beginFill bool)
  • func (c *RemoteBufferCache) GetCacheWithFillWait(inodeKey InodeKeyType, offset int64, length int) (SlicedPageBuffer, bool)
  • func (c *RemoteBufferCache) GetRemotePageBuffer(inodeKey InodeKeyType, offset int64, length int64, blocking bool) (*RemotePageBuffer, error)
  • func (c *RemoteBufferCache) Has(inodekey InodeKeyType, offset int64) bool
  • func (c *RemoteBufferCache) ReleaseInFlightBuffer(p *RemotePageBuffer)
  • func (c *RemoteBufferCache) SetEvictable(page *RemotePageBuffer) (size int64)
• type RemotePageBuffer
• • func (r *RemotePageBuffer) AsSlice(dec func(interface{})) SlicedPageBuffer
• type RemoveBucketInput
• type RemoveBucketOutput
• type RemoveNonDirtyChunksCommand
• • func NewRemoveNonDirtyChunksCommand(inodeKeys []uint64) RemoveNonDirtyChunksCommand
• • func (c RemoveNonDirtyChunksCommand) Commit(n *NodeServer)
  • func (c RemoveNonDirtyChunksCommand) GetExtCmdId() uint16
  • func (c RemoveNonDirtyChunksCommand) GetTxId() TxId
  • func (c RemoveNonDirtyChunksCommand) IsSingleShot() bool
  • func (c RemoveNonDirtyChunksCommand) NeedTwoPhaseCommit(*RaftGroupMgr) bool
• type RemoveServerCommand
• • func NewRemoveServerCommand(serverId uint32) RemoveServerCommand
• • func (c RemoveServerCommand) Apply(n *NodeServer, _ ExtLogCommandImpl)
  • func (c RemoveServerCommand) GetCmdId() uint16
  • func (c RemoveServerCommand) GetExtPayloadSize() uint8
  • func (c RemoveServerCommand) SetExtPayload(extPayload []byte)
• type RenameBlobInput
• type RenameBlobOutput
• type RenameCoordinatorCommand
• • func NewRenameCoordinatorCommand(txId TxId) RenameCoordinatorCommand
• • func (r *RenameCoordinatorCommand) AddMeta(txRet TxRet, oldKey string, newKey string, selfGroup string)
  • func (r *RenameCoordinatorCommand) AddParent(txRet TxRet, selfGroup string)
  • func (c RenameCoordinatorCommand) Commit(n *NodeServer)
  • func (c RenameCoordinatorCommand) GetExtCmdId() uint16
  • func (c RenameCoordinatorCommand) GetTxId() TxId
  • func (c RenameCoordinatorCommand) IsSingleShot() bool
  • func (c RenameCoordinatorCommand) NeedTwoPhaseCommit(*RaftGroupMgr) bool
  • func (c RenameCoordinatorCommand) RemoteCommit(_ *RaftGroupMgr) []ParticipantOp
• type RenameMetaInfo
• • func NewRenameMetaInfo(meta *WorkingMeta, oldKey string, newKey string) RenameMetaInfo
  • func NewRenameMetaInfoFromMsg(msg *common.RenameMetaInfoMsg) RenameMetaInfo
• type RenameMetaOp
• • func NewRenameMetaOp(txId TxId, inodeKey InodeKeyType, key string, srcName string, dstName string, ...) RenameMetaOp
• • func (o RenameMetaOp) GetCaller(n *NodeServer) RpcCaller
  • func (o RenameMetaOp) GetLeader(n *NodeServer, l *RaftNodeList) (RaftNode, bool)
  • func (o RenameMetaOp) GetTxId() TxId
  • func (o RenameMetaOp) RetToMsg(ret interface{}, r RaftBasicReply) (proto.Message, []SlicedPageBuffer)
• type ResetExtCommand
• • func NewResetExtCommand(logId uint32, nextSeqNum uint32) ResetExtCommand
• • func (c ResetExtCommand) Apply(n *NodeServer, _ ExtLogCommandImpl)
  • func (c ResetExtCommand) GetCmdId() uint16
  • func (c ResetExtCommand) GetExtPayloadSize() uint8
  • func (c ResetExtCommand) SetExtPayload(extPayload []byte)
• type RestoreDirtyChunkOp
• • func NewRestoreDirtyChunkOp(migrationId MigrationId, target RaftNode, inodeKey InodeKeyType, ...) RestoreDirtyChunkOp
• • func (o RestoreDirtyChunkOp) GetCaller(*NodeServer) RpcCaller
  • func (o RestoreDirtyChunkOp) GetLeader(n *NodeServer, l *RaftNodeList) (RaftNode, bool)
  • func (o RestoreDirtyChunkOp) RetToMsg(ret interface{}, r RaftBasicReply) (proto.Message, []SlicedPageBuffer)
• type RestoreDirtyMetaOp
• • func NewRestoreDirtyMetaOp(s *Snapshot, target RaftNode) RestoreDirtyMetaOp
• • func (o RestoreDirtyMetaOp) GetCaller(*NodeServer) RpcCaller
  • func (o RestoreDirtyMetaOp) GetLeader(n *NodeServer, l *RaftNodeList) (RaftNode, bool)
  • func (o RestoreDirtyMetaOp) RetToMsg(ret interface{}, r RaftBasicReply) (proto.Message, []SlicedPageBuffer)
• type RpcCaller
• type RpcClient
• • func NewRpcClient(boundDev string) (*RpcClient, error)
• • func (w *RpcClient) AddFd(na common.NodeAddrInet4, fd int) error
  • func (w *RpcClient) BroadcastAndWaitRpcMsg(messages map[int]RpcMsg, raft *RaftInstance, timeout time.Duration, debug bool) (nrSuccess int)
  • func (w *RpcClient) CheckReset() (ok bool)
  • func (w *RpcClient) Close() (err error)
  • func (w *RpcClient) Connect(na common.NodeAddrInet4) (fd int, err error)
  • func (w *RpcClient) RemoveFd(fd int)
  • func (w *RpcClient) SendAndWait(msg RpcMsg, sa common.NodeAddrInet4, extLogger *OnDiskLogger, ...) (replyMsg RpcMsg, err error)
  • func (w *RpcClient) UnicastRpcMsg(msg RpcMsg, sa common.NodeAddrInet4, extLogger *OnDiskLogger, ...) (err error)
  • func (w *RpcClient) WaitAndCheckRaftReply(raft *RaftInstance, servers map[int]*WriteRpcState, timeout time.Duration, ...) (nrSuccess int)
  • func (w *RpcClient) WaitAndGetRpcReply(fd int, timeout time.Duration) (msg RpcMsg, reply int32)
• type RpcClientConnectionV2
• • func NewRpcClientConnectionV2(na common.NodeAddrInet4, connectErrLog bool, boundDev string) (ret *RpcClientConnectionV2, err error)
  • func NewRpcClientConnectionV2FromFd(fd int, na common.NodeAddrInet4) (ret *RpcClientConnectionV2, err error)
• • func (w *RpcClientConnectionV2) AsyncObjcacheRpc(extCmdId uint16, seqNum uint64, args proto.Message, sa common.NodeAddrInet4, ...) (reply int32)
  • func (w *RpcClientConnectionV2) CallObjcacheRpc(extCmdId uint16, seqNum uint64, args proto.Message, timeout time.Duration, ...) (reply int32)
  • func (w *RpcClientConnectionV2) CallObjcacheRpcNoTimeout(extCmdId uint16, seqNum uint64, args proto.Message, extLogger *OnDiskLogger, ...) (reply int32)
  • func (w *RpcClientConnectionV2) Close() bool
  • func (w *RpcClientConnectionV2) Down() int32
  • func (w *RpcClientConnectionV2) IsFree() bool
  • func (w *RpcClientConnectionV2) RemoveRpcArgs(seqNum uint64)
  • func (w *RpcClientConnectionV2) SendRpcMsg(msg RpcMsg, extLogger *OnDiskLogger, wakeUpInterval time.Duration, ...) (err error)
  • func (w *RpcClientConnectionV2) StoreRpcArgs(seqNum uint64, args *RpcSeqNumArgs)
  • func (w *RpcClientConnectionV2) Up()
  • func (w *RpcClientConnectionV2) WaitAndGetRpcReply(seqNum uint64, timeout time.Duration, enableLog bool) (msg RpcMsg, err error)
• type RpcClientV2
• • func NewRpcClientV2(boundDev string) (*RpcClientV2, error)
• • func (w *RpcClientV2) AsyncObjcacheRpc(extCmdId uint16, args proto.Message, sa common.NodeAddrInet4, ...) (con *RpcClientConnectionV2, seqNum uint64, reply int32)
  • func (w *RpcClientV2) CallObjcacheRpc(extCmdId uint16, args proto.Message, sa common.NodeAddrInet4, ...) (reply int32)
  • func (w *RpcClientV2) CheckReset() (ok bool)
  • func (w *RpcClientV2) Close()
  • func (w *RpcClientV2) WaitAsyncObjcacheRpc(con *RpcClientConnectionV2, seqNum uint64, ret proto.Message) (reply int32)
• type RpcMgr
• • func NewRpcManager(n *NodeServer) *RpcMgr
• • func (o *RpcMgr) AbortAll(tm *TxIdMgr, retryInterval time.Duration, nodeLock bool)
  • func (o *RpcMgr) CallRpc(c RpcCaller) (ret RpcRet, r RaftBasicReply)
  • func (o *RpcMgr) CallRpcOneShot(c RpcCaller, nodeList *RaftNodeList) (ret RpcRet, r RaftBasicReply)
  • func (o *RpcMgr) CheckReset() (ok bool)
  • func (o *RpcMgr) Commit(extLog CoordinatorCommand, retryInterval time.Duration) (reply int32)
  • func (o *RpcMgr) CommitCoordinator(extLog CoordinatorCommand, retryInterval time.Duration) (reply int32)
  • func (o *RpcMgr) DeleteAndGet(seq TxId) (call RpcState, ok bool)
  • func (o *RpcMgr) DeleteAndUnlockLocalAll(tm *TxIdMgr)
  • func (o *RpcMgr) Enter(seq TxId) (call RpcState, duplicated bool, passed bool)
  • func (o *RpcMgr) Get(seq TxId) (call RpcState, ok bool)
  • func (o *RpcMgr) Record(seq TxId, ret RpcRet)
  • func (o *RpcMgr) RestoreDirtyChunksBottomHalf(m proto.Message, logId LogIdType, logOffset int64, dataLength uint32, ...) (proto.Message, []SlicedPageBuffer)
  • func (o *RpcMgr) UpdateChunkBottomHalf(m proto.Message, logId LogIdType, logOffset int64, dataLength uint32, ...) proto.Message
• type RpcMsg
• • func (d *RpcMsg) CreateOptControlHeader(totalExtLogLength uint32, nrEntries uint32, entryPayloadLength uint16)
  • func (d *RpcMsg) FillAppendEntriesResponseArgs(term uint32, success bool, logLength uint64, reply int32)
  • func (d *RpcMsg) FillAppendEntryArgs(term uint32, prevTerm uint32, prevIndex uint64, leaderCommit uint64, ...)
  • func (d *RpcMsg) FillExecProtoBufArgs(execId uint16, seqNum uint64, m proto.Message, dataBufLen int, isResponse bool) int32
  • func (d *RpcMsg) FillRequestVoteArgs(term uint32, candidateId uint32, lastLogTerm uint32, lastLogIndex uint64)
  • func (d *RpcMsg) FillRequestVoteResponseArgs(term uint32, voteGranted bool, reply int32)
  • func (d *RpcMsg) GetAppendEntriesResponseArgs() (term uint32, success bool, logLength uint64, reply int32)
  • func (d *RpcMsg) GetAppendEntryArgs() (term uint32, prevTerm uint32, prevIndex uint64, leaderCommit uint64, ...)
  • func (d *RpcMsg) GetAppendEntryCommandDiskFormat(off uint16) (cmd AppendEntryCommand, nextOff uint16)
  • func (d *RpcMsg) GetAppendEntryExtHeader(off uint16) (extCmdId uint16, extEntryPayload []byte, nextOff uint16)
  • func (d *RpcMsg) GetAppendEntryNrEntries() (nrEntries uint32)
  • func (d *RpcMsg) GetArrivingMsgLengths(off uint16, optHeaderLength *uint16) (complete bool)
  • func (d *RpcMsg) GetCmdId() uint8
  • func (d *RpcMsg) GetCmdPayload() []byte
  • func (d *RpcMsg) GetExecProtoBufRpcId(payload []byte) (rpcId uint16)
  • func (d *RpcMsg) GetExecProtoBufRpcSeqNum(payload []byte) (seqNum uint64)
  • func (d *RpcMsg) GetOptControlHeader() (totalExtLogLength uint32, nrEntries uint32)
  • func (d *RpcMsg) GetOptHeaderLength() uint16
  • func (d *RpcMsg) GetOptHeaderPayload() []byte
  • func (d *RpcMsg) GetRequestVoteArgs() (term uint32, candidateId uint32, lastLogTerm uint32, lastLogIndex uint64)
  • func (d *RpcMsg) GetRequestVoteResponseArgs() (term uint32, voteGranted bool, reply int32)
  • func (d *RpcMsg) ParseExecProtoBufMessage(m proto.Message) (reply int32)
  • func (d *RpcMsg) SetCmdControlHeader(cmdId uint8, optHeaderLength uint16)
  • func (d *RpcMsg) SetNrEntries(nrEntries uint32)
  • func (d *RpcMsg) SetOptHeaderLength(optHeaderLength uint16)
  • func (d *RpcMsg) SetTotalExtLogLength(totalExtLogLength uint32)
• type RpcReplyClient
• • func NewRpcReplyClient() (*RpcReplyClient, error)
• • func (w *RpcReplyClient) CheckReset() (ok bool)
  • func (w *RpcReplyClient) Close()
  • func (w *RpcReplyClient) Register(fd int, sa common.NodeAddrInet4) (err error)
  • func (w *RpcReplyClient) ReplyRpcMsg(msg RpcMsg, fd int, sa common.NodeAddrInet4, extLogger *OnDiskLogger, ...) (reply int32)
• type RpcRet
• type RpcSeqNumArgs
• type RpcState
• type RpcStatePointer
• • func (o RpcStatePointer) Less(a btree.Item) bool
• type RpcThreads
• • func NewRpcThreads(sa common.NodeAddrInet4, boundDev string) (ret RpcThreads, err error)
• • func (f *RpcThreads) AcceptThread(epollFd int, acceptTimeout time.Duration, stopFlag *int32)
  • func (f *RpcThreads) CheckReset() (ok bool)
  • func (f *RpcThreads) Close()
  • func (f *RpcThreads) Start(maxEvents int, n *NodeServer, raft *RaftInstance) error
• type S3Backend
• • func NewGCS3(bucket string, debugS3 bool, config *S3Config, bufferSize int) (*S3Backend, error)
  • func NewS3(bucket string, debugS3 bool, config *S3Config, bufferSize int) (*S3Backend, error)
• • func (s *S3Backend) Bucket() string
  • func (s *S3Backend) Capabilities() *Capabilities
  • func (s *S3Backend) CopyBlob(param *CopyBlobInput) (*CopyBlobOutput, error)
  • func (s *S3Backend) Delegate() interface{}
  • func (s *S3Backend) DeleteBlob(param *DeleteBlobInput) (*DeleteBlobOutput, error)
  • func (s *S3Backend) DeleteBlobs(param *DeleteBlobsInput) (*DeleteBlobsOutput, error)
  • func (s *S3Backend) GetBlob(param *GetBlobInput) (*GetBlobOutput, error)
  • func (s *S3Backend) HeadBlob(param *HeadBlobInput) (*HeadBlobOutput, error)
  • func (s *S3Backend) Init(key string) error
  • func (s *S3Backend) ListBlobs(param *ListBlobsInput) (*ListBlobsOutput, error)
  • func (s *S3Backend) ListObjectsV2(params *s3.ListObjectsV2Input) (*s3.ListObjectsV2Output, string, error)
  • func (s *S3Backend) MakeBucket(param *MakeBucketInput) (*MakeBucketOutput, error)
  • func (s *S3Backend) MultipartBlobAbort(param *MultipartBlobCommitInput) (*MultipartBlobAbortOutput, error)
  • func (s *S3Backend) MultipartBlobAdd(param *MultipartBlobAddInput) (*MultipartBlobAddOutput, error)
  • func (s *S3Backend) MultipartBlobBegin(param *MultipartBlobBeginInput) (*MultipartBlobCommitInput, error)
  • func (s *S3Backend) MultipartBlobCommit(param *MultipartBlobCommitInput) (*MultipartBlobCommitOutput, error)
  • func (s *S3Backend) MultipartExpire(param *MultipartExpireInput) (*MultipartExpireOutput, error)
  • func (s *S3Backend) PutBlob(param *PutBlobInput) (*PutBlobOutput, error)
  • func (s *S3Backend) RemoveBucket(param *RemoveBucketInput) (*RemoveBucketOutput, error)
  • func (s *S3Backend) RenameBlob(param *RenameBlobInput) (*RenameBlobOutput, error)
• type S3Config
• • func (c *S3Config) Init() *S3Config
  • func (c *S3Config) ToAwsConfig(debugS3 bool, bufferSize int) (*aws.Config, error)
• type SingleShotOp
• • func NewGetApiIpAndPortOpFromMsg(msg RpcMsg) (fn SingleShotOp, nodeListVer uint64, reply int32)
  • func NewGetMetaOpFromMsg(msg RpcMsg) (fn SingleShotOp, nodeListVer uint64, reply int32)
  • func NewPrefetchChunkOpFromMsg(msg RpcMsg) (fn SingleShotOp, nodeListVer uint64, reply int32)
  • func NewReadChunkOpFromMsg(msg RpcMsg) (fn SingleShotOp, nodeListVer uint64, reply int32)
  • func NewRestoreDirtyChunkOpFromProtoMsg(m proto.Message, logId LogIdType, logOffset int64, dataLength uint32) (fn SingleShotOp, nodeListVer uint64)
  • func NewRestoreDirtyMetaOpFromMsg(msg RpcMsg) (fn SingleShotOp, nodeListVer uint64, reply int32)
  • func NewUpdateMetaAttrOpFromMsg(msg RpcMsg) (SingleShotOp, uint64, int32)
• type SingleShotRpcCaller
• • func NewSingleShotRpcCaller(fn SingleShotOp, remoteTimeout time.Duration, noTryBeginOp bool) SingleShotRpcCaller
• • func (c SingleShotRpcCaller) ExecLocal(n *NodeServer, nodeListVer uint64) (ret RpcRet, r RaftBasicReply)
  • func (c SingleShotRpcCaller) ExecLocalInRpc(n *NodeServer, nodeListVer uint64) (ret RpcRet, r RaftBasicReply)
  • func (c SingleShotRpcCaller) ExecRemote(n *NodeServer, addr common.NodeAddrInet4, nodeListVer uint64) (ret RpcRet, r RaftBasicReply)
  • func (c SingleShotRpcCaller) GetLeader(n *NodeServer, nodeList *RaftNodeList) (RaftNode, bool)
  • func (c SingleShotRpcCaller) TryNext(n *NodeServer, i int) bool
• type SlicedPageBuffer
• • func NewBlankSlicedPageBuffer(size int64) SlicedPageBuffer
• • func (p *SlicedPageBuffer) SetEvictable()
  • func (p *SlicedPageBuffer) Slice(begin int64, last int64)
• type Snapshot
• • func NewSnapshot(maxBytes int, migrationId MigrationId, newExtLogId uint32, ...) *Snapshot
  • func NewSnapshotFromMsg(msg *common.SnapshotMsg) *Snapshot
• • func (s *Snapshot) GetNext() *Snapshot
• type StagingChunk
• • func NewStagingChunk(slop int64, length int64, updateType byte, logOffset int64, key string, ...) *StagingChunk
  • func NewStagingChunkFromAddMsg(msg *common.StagingChunkAddMsg) *StagingChunk
• • func (s *StagingChunk) AppendToLog(inodeMgr *InodeMgr, reader *BufferedDiskPageReader, fetchKey string) (err error)
  • func (s *StagingChunk) GetObject(inodeMgr *InodeMgr, reader *BufferedDiskPageReader, fetchOffset int64) error
  • func (s *StagingChunk) ReadObject(inodeMgr *InodeMgr, reader *BufferedDiskPageReader) (err error)
• type StagingChunkPart
• • func (p *StagingChunkPart) LastOffset() int64
  • func (p *StagingChunkPart) Less(b btree.Item) bool
• type StaleInode
• type StorageBackend
• type StorageBackendInitError
• • func (s StorageBackendInitError) Bucket() string
  • func (e StorageBackendInitError) Capabilities() *Capabilities
  • func (e StorageBackendInitError) CopyBlob(param *CopyBlobInput) (*CopyBlobOutput, error)
  • func (e StorageBackendInitError) Delegate() interface{}
  • func (e StorageBackendInitError) DeleteBlob(param *DeleteBlobInput) (*DeleteBlobOutput, error)
  • func (e StorageBackendInitError) DeleteBlobs(param *DeleteBlobsInput) (*DeleteBlobsOutput, error)
  • func (e StorageBackendInitError) GetBlob(param *GetBlobInput) (*GetBlobOutput, error)
  • func (e StorageBackendInitError) HeadBlob(param *HeadBlobInput) (*HeadBlobOutput, error)
  • func (e StorageBackendInitError) Init(key string) error
  • func (e StorageBackendInitError) ListBlobs(param *ListBlobsInput) (*ListBlobsOutput, error)
  • func (e StorageBackendInitError) MakeBucket(param *MakeBucketInput) (*MakeBucketOutput, error)
  • func (e StorageBackendInitError) MultipartBlobAbort(param *MultipartBlobCommitInput) (*MultipartBlobAbortOutput, error)
  • func (e StorageBackendInitError) MultipartBlobAdd(param *MultipartBlobAddInput) (*MultipartBlobAddOutput, error)
  • func (e StorageBackendInitError) MultipartBlobBegin(param *MultipartBlobBeginInput) (*MultipartBlobCommitInput, error)
  • func (e StorageBackendInitError) MultipartBlobCommit(param *MultipartBlobCommitInput) (*MultipartBlobCommitOutput, error)
  • func (e StorageBackendInitError) MultipartExpire(param *MultipartExpireInput) (*MultipartExpireOutput, error)
  • func (e StorageBackendInitError) PutBlob(param *PutBlobInput) (*PutBlobOutput, error)
  • func (e StorageBackendInitError) RemoveBucket(param *RemoveBucketInput) (*RemoveBucketOutput, error)
  • func (e StorageBackendInitError) RenameBlob(param *RenameBlobInput) (*RenameBlobOutput, error)
• type StorageBackendInitWrapper
• • func (s *StorageBackendInitWrapper) Bucket() string
  • func (s *StorageBackendInitWrapper) Capabilities() *Capabilities
  • func (s *StorageBackendInitWrapper) CopyBlob(param *CopyBlobInput) (*CopyBlobOutput, error)
  • func (s *StorageBackendInitWrapper) DeleteBlob(param *DeleteBlobInput) (*DeleteBlobOutput, error)
  • func (s *StorageBackendInitWrapper) DeleteBlobs(param *DeleteBlobsInput) (*DeleteBlobsOutput, error)
  • func (s *StorageBackendInitWrapper) GetBlob(param *GetBlobInput) (*GetBlobOutput, error)
  • func (s *StorageBackendInitWrapper) HeadBlob(param *HeadBlobInput) (*HeadBlobOutput, error)
  • func (s *StorageBackendInitWrapper) Init(key string) error
  • func (s *StorageBackendInitWrapper) ListBlobs(param *ListBlobsInput) (*ListBlobsOutput, error)
  • func (s *StorageBackendInitWrapper) MakeBucket(param *MakeBucketInput) (*MakeBucketOutput, error)
  • func (s *StorageBackendInitWrapper) MultipartBlobAbort(param *MultipartBlobCommitInput) (*MultipartBlobAbortOutput, error)
  • func (s *StorageBackendInitWrapper) MultipartBlobAdd(param *MultipartBlobAddInput) (*MultipartBlobAddOutput, error)
  • func (s *StorageBackendInitWrapper) MultipartBlobBegin(param *MultipartBlobBeginInput) (*MultipartBlobCommitInput, error)
  • func (s *StorageBackendInitWrapper) MultipartBlobCommit(param *MultipartBlobCommitInput) (*MultipartBlobCommitOutput, error)
  • func (s *StorageBackendInitWrapper) MultipartExpire(param *MultipartExpireInput) (*MultipartExpireOutput, error)
  • func (s *StorageBackendInitWrapper) PutBlob(param *PutBlobInput) (*PutBlobOutput, error)
  • func (s *StorageBackendInitWrapper) RemoveBucket(param *RemoveBucketInput) (*RemoveBucketOutput, error)
  • func (s *StorageBackendInitWrapper) RenameBlob(param *RenameBlobInput) (*RenameBlobOutput, error)
• type TruncateCoordinatorCommand
• • func NewTruncateCoordinatorCommand(txId TxId, metaTx TxRet, raftGroup *RaftGroupMgr, commitTxId TxId) TruncateCoordinatorCommand
• • func (c TruncateCoordinatorCommand) Commit(n *NodeServer)
  • func (c TruncateCoordinatorCommand) GetExtCmdId() uint16
  • func (c TruncateCoordinatorCommand) GetTxId() TxId
  • func (c TruncateCoordinatorCommand) IsSingleShot() bool
  • func (c TruncateCoordinatorCommand) NeedTwoPhaseCommit(raftGroup *RaftGroupMgr) bool
  • func (c TruncateCoordinatorCommand) RemoteCommit(raftGroup *RaftGroupMgr) []ParticipantOp
• type TruncateMetaOp
• • func NewTruncateMetaOp(txId TxId, inodeKey InodeKeyType, newSize int64) TruncateMetaOp
• • func (o TruncateMetaOp) GetCaller(n *NodeServer) RpcCaller
  • func (o TruncateMetaOp) GetLeader(n *NodeServer, l *RaftNodeList) (RaftNode, bool)
  • func (o TruncateMetaOp) GetTxId() TxId
  • func (o TruncateMetaOp) RetToMsg(ret interface{}, r RaftBasicReply) (proto.Message, []SlicedPageBuffer)
• type Tx
• • func (p Tx) Less(b btree.Item) bool
• type TxId
• • func NewTxIdFromMsg(msg *common.TxIdMsg) TxId
• • func (t *TxId) GetNext() TxId
  • func (t *TxId) GetVariant(TxSeqNum uint64) TxId
• type TxIdMgr
• • func NewTxIdMgr(txId TxId) *TxIdMgr
• • func (t *TxIdMgr) AddTx(txId TxId, ret RpcRet) TxRet
  • func (t *TxIdMgr) GetCoordinatorTxId() TxId
  • func (t *TxIdMgr) GetLocalTxIds(selfGroup string) []TxId
  • func (t *TxIdMgr) GetMigrationId() MigrationId
  • func (t *TxIdMgr) GetNextId() TxId
  • func (t *TxIdMgr) GetTxGroupIds() map[TxId]string
• type TxMgr
• • func NewTxMgr() *TxMgr
• • func (m *TxMgr) ResumeTx(n *NodeServer) int32
• type TxRet
• type UnlinkMetaOp
• • func NewUnlinkMetaOp(txId TxId, inodeKey InodeKeyType, parentKey string, childName string, ...) UnlinkMetaOp
• • func (o UnlinkMetaOp) GetCaller(n *NodeServer) RpcCaller
  • func (o UnlinkMetaOp) GetLeader(n *NodeServer, l *RaftNodeList) (RaftNode, bool)
  • func (o UnlinkMetaOp) GetTxId() TxId
  • func (o UnlinkMetaOp) RetToMsg(ret interface{}, r RaftBasicReply) (proto.Message, []SlicedPageBuffer)
• type UpadteChunkRpcCaller
• • func NewUpadteChunkRpcCaller(fn ParticipantOp, remoteTimeout time.Duration) UpadteChunkRpcCaller
• • func (c UpadteChunkRpcCaller) ExecLocal(n *NodeServer, nodeListVer uint64) (ret RpcRet, r RaftBasicReply)
  • func (c UpadteChunkRpcCaller) ExecLocalInRpc(n *NodeServer, nodeListVer uint64) (ret RpcRet, r RaftBasicReply)
  • func (c UpadteChunkRpcCaller) ExecRemote(n *NodeServer, addr common.NodeAddrInet4, nodeListVer uint64) (ret RpcRet, r RaftBasicReply)
  • func (c UpadteChunkRpcCaller) GetLeader(n *NodeServer, nodeList *RaftNodeList) (RaftNode, bool)
  • func (c UpadteChunkRpcCaller) TryNext(n *NodeServer, i int) bool
• type UpdateChunkCommand
• • func NewUpdateChunkCommand() UpdateChunkCommand
• • func (c UpdateChunkCommand) Commit(n *NodeServer)
  • func (c UpdateChunkCommand) GetExtCmdId() uint16
  • func (c UpdateChunkCommand) GetTxId() TxId
  • func (c UpdateChunkCommand) IsSingleShot() bool
  • func (c UpdateChunkCommand) NeedTwoPhaseCommit(*RaftGroupMgr) bool
• type UpdateChunkOp
• • func NewUpdateChunkOp(txId TxId, inodeKey InodeKeyType, chunkSize int64, offset int64, buf []byte) UpdateChunkOp
• • func (o UpdateChunkOp) GetCaller(n *NodeServer) RpcCaller
  • func (o UpdateChunkOp) GetLeader(n *NodeServer, l *RaftNodeList) (RaftNode, bool)
  • func (o UpdateChunkOp) GetTxId() TxId
  • func (o UpdateChunkOp) RetToMsg(ret interface{}, r RaftBasicReply) (proto.Message, []SlicedPageBuffer)
• type UpdateMetaAttrCommand
• • func NewUpdateMetaAttrCommand(inodeKey InodeKeyType, mode uint32, ts int64) UpdateMetaAttrCommand
• • func (c UpdateMetaAttrCommand) Commit(n *NodeServer)
  • func (c UpdateMetaAttrCommand) GetExtCmdId() uint16
  • func (c UpdateMetaAttrCommand) GetTxId() TxId
  • func (c UpdateMetaAttrCommand) IsSingleShot() bool
  • func (c UpdateMetaAttrCommand) NeedTwoPhaseCommit(*RaftGroupMgr) bool
• type UpdateMetaAttrOp
• • func NewUpdateMetaAttrOp(txId TxId, inodeKey InodeKeyType, mode uint32, ts int64) UpdateMetaAttrOp
• • func (o UpdateMetaAttrOp) GetCaller(n *NodeServer) RpcCaller
  • func (o UpdateMetaAttrOp) GetLeader(n *NodeServer, l *RaftNodeList) (RaftNode, bool)
  • func (o UpdateMetaAttrOp) GetTxId() TxId
  • func (o UpdateMetaAttrOp) RetToMsg(ret interface{}, r RaftBasicReply) (proto.Message, []SlicedPageBuffer)
• type UpdateMetaCommand
• • func NewUpdateMetaCommand(txId TxId, working *WorkingMeta) UpdateMetaCommand
• • func (c UpdateMetaCommand) Commit(n *NodeServer)
  • func (c UpdateMetaCommand) GetExtCmdId() uint16
  • func (c UpdateMetaCommand) GetTxId() TxId
  • func (c UpdateMetaCommand) IsSingleShot() bool
  • func (c UpdateMetaCommand) NeedTwoPhaseCommit(*RaftGroupMgr) bool
• type UpdateMetaKeyCommand
• • func NewUpdateMetaKeyCommand(txId TxId, parentWorking *WorkingMeta, children map[string]InodeKeyType, ...) UpdateMetaKeyCommand
• • func (c UpdateMetaKeyCommand) Commit(n *NodeServer)
  • func (c UpdateMetaKeyCommand) GetExtCmdId() uint16
  • func (c UpdateMetaKeyCommand) GetTxId() TxId
  • func (c UpdateMetaKeyCommand) IsSingleShot() bool
  • func (c UpdateMetaKeyCommand) NeedTwoPhaseCommit(*RaftGroupMgr) bool
• type UpdateMetaKeyOp
• • func NewUpdateMetaKeyOp(txId TxId, inodeKey InodeKeyType, oldKey string, newKey string, ...) UpdateMetaKeyOp
• • func (o UpdateMetaKeyOp) GetCaller(n *NodeServer) RpcCaller
  • func (o UpdateMetaKeyOp) GetLeader(n *NodeServer, l *RaftNodeList) (RaftNode, bool)
  • func (o UpdateMetaKeyOp) GetTxId() TxId
  • func (o UpdateMetaKeyOp) RetToMsg(ret interface{}, r RaftBasicReply) (proto.Message, []SlicedPageBuffer)
• type UpdateMetaSizeOp
• • func NewUpdateMetaSizeOp(txId TxId, inodeKey InodeKeyType, newSize int64, mTime int64, mode uint32) UpdateMetaSizeOp
• • func (o UpdateMetaSizeOp) GetCaller(n *NodeServer) RpcCaller
  • func (o UpdateMetaSizeOp) GetLeader(n *NodeServer, l *RaftNodeList) (RaftNode, bool)
  • func (o UpdateMetaSizeOp) GetTxId() TxId
  • func (o UpdateMetaSizeOp) RetToMsg(ret interface{}, r RaftBasicReply) (proto.Message, []SlicedPageBuffer)
• type UpdateNodeListCommand
• • func NewUpdateNodeListCommand(txId TxId, migrationId MigrationId, isAdd bool, needRestore bool, ...) UpdateNodeListCommand
• • func (c UpdateNodeListCommand) Commit(n *NodeServer)
  • func (c UpdateNodeListCommand) GetExtCmdId() uint16
  • func (c UpdateNodeListCommand) GetTxId() TxId
  • func (c UpdateNodeListCommand) IsSingleShot() bool
  • func (c UpdateNodeListCommand) NeedTwoPhaseCommit(*RaftGroupMgr) bool
• type UpdateNodeListCoordinatorCommand
• • func NewUpdateNodeListCoordinatorCommand(txId TxId, migrationId MigrationId, target RaftNode, isAdd bool, ...) UpdateNodeListCoordinatorCommand
• • func (c *UpdateNodeListCoordinatorCommand) AddNode(txRet TxRet)
  • func (c UpdateNodeListCoordinatorCommand) Commit(n *NodeServer)
  • func (c UpdateNodeListCoordinatorCommand) GetExtCmdId() uint16
  • func (c UpdateNodeListCoordinatorCommand) GetTxId() TxId
  • func (c UpdateNodeListCoordinatorCommand) IsSingleShot() bool
  • func (c UpdateNodeListCoordinatorCommand) NeedTwoPhaseCommit(*RaftGroupMgr) bool
  • func (c UpdateNodeListCoordinatorCommand) RemoteCommit(_ *RaftGroupMgr) []ParticipantOp
• type UpdateNodeListOp
• • func NewUpdateNodeListOp(txId TxId, added RaftNode, leaderGroupId string, isAdd bool, ...) UpdateNodeListOp
• • func (o UpdateNodeListOp) GetCaller(n *NodeServer) RpcCaller
  • func (o UpdateNodeListOp) GetLeader(n *NodeServer, l *RaftNodeList) (RaftNode, bool)
  • func (o UpdateNodeListOp) GetTxId() TxId
  • func (o UpdateNodeListOp) RetToMsg(ret interface{}, r RaftBasicReply) (proto.Message, []SlicedPageBuffer)
• type UpdateParentInfo
• • func NewUpdateParentInfo(inodeKey InodeKeyType, key string, addInodeKey InodeKeyType, addChild string, ...) *UpdateParentInfo
  • func NewUpdateParentInfoFromMsg(msg *common.UpdateParentMetaInfoMsg) *UpdateParentInfo
• type UpdateParentMetaCommand
• • func NewUpdateParentMetaCommand(txId TxId, info *UpdateParentInfo) UpdateParentMetaCommand
• • func (c UpdateParentMetaCommand) Commit(n *NodeServer)
  • func (c UpdateParentMetaCommand) GetExtCmdId() uint16
  • func (c UpdateParentMetaCommand) GetTxId() TxId
  • func (c UpdateParentMetaCommand) IsSingleShot() bool
  • func (c UpdateParentMetaCommand) NeedTwoPhaseCommit(*RaftGroupMgr) bool
• type UpdateParentRet
• type WorkingChunk
• • func (c *WorkingChunk) AddNewStag(raft *RaftInstance, backingKey string, offset int64, updateType byte, ...) int32
  • func (c *WorkingChunk) AddNewStagFromMsg(l *common.StagingChunkAddMsg)
  • func (c *WorkingChunk) AddStag(stag *StagingChunk)
  • func (c *WorkingChunk) AddStagingChunkFromAddMsg(cLog *common.WorkingChunkAddMsg)
  • func (c *WorkingChunk) Copy(chunkVer uint32) *WorkingChunk
  • func (c *WorkingChunk) DeleteFromVersionListNoLock()
  • func (c *WorkingChunk) GetNext(inodeMgr *InodeMgr, offset int64, blocking bool) (buf SlicedPageBuffer, err error)
  • func (c *WorkingChunk) GetReader(chunkSize int64, objectSize int64, offset int64, inodeMgr *InodeMgr, ...) *ChunkReader
  • func (c *WorkingChunk) Head() *StagingChunkPart
  • func (c *WorkingChunk) LastNonDeletedPtr() *StagingChunkPart
  • func (c *WorkingChunk) NewStagingChunkPart(length int64, stag *StagingChunk, slop int64) *StagingChunkPart
  • func (c *WorkingChunk) Prefetch(inodeMgr *InodeMgr)
  • func (c *WorkingChunk) ReadNext(inodeMgr *InodeMgr, p []byte, offset int64, blocking bool) (int64, error)
  • func (c *WorkingChunk) Size() int64
  • func (c *WorkingChunk) Tail() *StagingChunkPart
  • func (c *WorkingChunk) WriteToNext(inodeMgr *InodeMgr, w io.Writer, offset int64, blocking bool) (int64, error)
• type WorkingMeta
• • func NewWorkingMeta(inodeKey InodeKeyType, chunkSize int64, expireMs int32, mode uint32, ...) *WorkingMeta
  • func NewWorkingMetaFromMsg(res *common.CopiedMetaMsg) *WorkingMeta
• • func (m *WorkingMeta) DropPrev()
  • func (m *WorkingMeta) GetAttr(uid uint32, gid uint32) fuseops.InodeAttributes
  • func (m *WorkingMeta) GetMetadata() map[string][]byte
  • func (m *WorkingMeta) IsDeleted() bool
  • func (m *WorkingMeta) IsDir() bool
• type WriteRpcState