account

package
v0.0.0-...-516970c Latest Latest
Warning

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

 Go to latest Published: Sep 26, 2019 License: LGPL-3.0 Imports: 24 Imported by: 0

Documentation

Index

Constants

View Source 
const (

	// user-oplog
	AddUserOplogMsg pkgservice.OpType //42
	AddUserOplogsMsg

	AddPendingUserOplogMsg
	AddPendingUserOplogsMsg

	SyncUserOplogMsg
	SyncUserOplogAckMsg
	SyncUserOplogNewOplogsMsg
	SyncUserOplogNewOplogsAckMsg

	InvalidSyncUserOplogMsg

	ForceSyncUserOplogMsg
	ForceSyncUserOplogAckMsg
	ForceSyncUserOplogByMerkleMsg
	ForceSyncUserOplogByMerkleAckMsg
	ForceSyncUserOplogByOplogAckMsg

	SyncPendingUserOplogMsg // 50
	SyncPendingUserOplogAckMsg

	// user-node
	SyncAddUserNodeMsg
	SyncAddUserNodeAckMsg

	ForceSyncUserNodeMsg
	ForceSyncUserNodeAckMsg

	// user-name
	SyncCreateUserNameMsg
	SyncCreateUserNameAckMsg

	SyncUpdateUserNameMsg // 56
	SyncUpdateUserNameAckMsg

	ForceSyncUserNameMsg
	ForceSyncUserNameAckMsg

	// user-img
	SyncCreateUserImgMsg
	SyncCreateUserImgAckMsg

	SyncUpdateUserImgMsg // 60
	SyncUpdateUserImgAckMsg

	ForceSyncUserImgMsg
	ForceSyncUserImgAckMsg

	// name-card
	SyncCreateNameCardMsg
	SyncCreateNameCardAckMsg

	SyncUpdateNameCardMsg // 56
	SyncUpdateNameCardAckMsg

	ForceSyncNameCardMsg
	ForceSyncNameCardAckMsg
)

protocol

View Source 
const (
	MaxProfileImgWidth  = 128
	MinProfileImgWidth  = 64
	MaxProfileImgHeight = 128
	MinProfileImgHeight = 64
	MaxProfileImgSize   = 65535

	MaxNameLength         = 25
	ProfileImageMaskRatio = 0.8
)

user-profile

View Source 
const (
	MaxSyncRandomSeconds = 30
	MinSyncRandomSeconds = 15
)

sync

View Source 
const (
	UserOpTypeInvalid pkgservice.OpType = iota
	UserOpTypeCreateProfile
	UserOpTypeDeleteProfile
	UserOpTypeTransferProfile

	UserOpTypeAddUserNode
	UserOpTypeRemoveUserNode

	UserOpTypeCreateUserName
	UserOpTypeUpdateUserName

	UserOpTypeCreateUserImg
	UserOpTypeUpdateUserImg

	UserOpTypeCreateNameCard
	UserOpTypeUpdateNameCard

	NUserOpType
)
View Source 
const (
	MaxMasters = 1
)

max-masters

Variables

View Source 
var (
	ErrInvalidImg  = errors.New("invalid img")
	ErrInvalidName = errors.New("invalid name")
)
View Source 
var (
	DBProfilePrefix = []byte(".pfdb")

	DBUserNamePrefix    = []byte(".umdb")
	DBUserNameIdxPrefix = []byte(".umix")
	DBUserImgPrefix     = []byte(".uidb")
	DBUserImgIdxPrefix  = []byte(".uiix")
	DBNameCardPrefix    = []byte(".ncdb")
	DBNameCardIdxPrefix = []byte(".ncix")

	DBUserNodePrefix     = []byte(".undb")
	DBUserNodeIdxPrefix  = []byte(".unix")
	DBUserNodeInfoPrefix = []byte(".uidb")
)

db

View Source 
var (
	RenewOpKeySeconds  int64 = 86400
	ExpireOpKeySeconds int64 = 259200
)

op-key

View Source 
var (
	DBUserOplogPrefix       = []byte(".urlg")
	DBUserIdxOplogPrefix    = []byte(".urig")
	DBUserMerkleOplogPrefix = []byte(".urmk")
)

oplog

View Source 
var (
	DefaultConfig = Config{
		DataDir: filepath.Join(node.DefaultDataDir(), "account"),
	}
)

config

Functions

func InitAccount 

func InitAccount(dataDir string) error

func NameCardsToObjs 

func NameCardsToObjs(typedObjs []*NameCard) []pkgservice.Object

func TeardownAccount 

func TeardownAccount()

func UserImgsToObjs 

func UserImgsToObjs(typedObjs []*UserImg) []pkgservice.Object

func UserNamesToObjs 

func UserNamesToObjs(typedObjs []*UserName) []pkgservice.Object

func UserNodesToObjs 

func UserNodesToObjs(typedObjs []*UserNode) []pkgservice.Object

func UserOplogsToOplogs 

func UserOplogsToOplogs(typedLogs []*UserOplog) []*pkgservice.BaseOplog

Types

type ApproveJoinEntity 

type ApproveJoinEntity struct {
	*pkgservice.ApproveJoinEntity `json:"b"`
	UserName                      *UserName `json:"n"`
	UserImg                       *UserImg  `json:"i"`
	NameCard                      *NameCard `json:"c"`
}

func NewEmptyApproveJoinProfile 

func NewEmptyApproveJoinProfile() *ApproveJoinEntity

type Backend 

type Backend struct {
	*pkgservice.BaseService
}

func NewBackend 

func NewBackend(ctx *pkgservice.ServiceContext, config *Config, ptt pkgservice.Ptt) (*Backend, error)

func (*Backend) APIs 

func (b *Backend) APIs() []rpc.API

func (*Backend) ForceSyncUserMerkle 

func (b *Backend) ForceSyncUserMerkle(entityIDBytes []byte) (bool, error)

func (*Backend) GetNameCard 

func (b *Backend) GetNameCard(idBytes []byte) (*BackendNameCard, error)

func (*Backend) GetNameCardByIDs 

func (b *Backend) GetNameCardByIDs(idByteList [][]byte) (map[string]*BackendNameCard, error)

func (*Backend) GetPendingUserOplogInternalList 

func (b *Backend) GetPendingUserOplogInternalList(entityIDBytes []byte, logIDBytes []byte, limit int, listOrder pttdb.ListOrder) ([]*UserOplog, error)

func (*Backend) GetPendingUserOplogMasterList 

func (b *Backend) GetPendingUserOplogMasterList(entityIDBytes []byte, logIDBytes []byte, limit int, listOrder pttdb.ListOrder) ([]*UserOplog, error)

func (*Backend) GetRawNameCard 

func (b *Backend) GetRawNameCard(idBytes []byte) (*NameCard, error)

func (*Backend) GetRawNameCardByID 

func (b *Backend) GetRawNameCardByID(id *types.PttID) (*NameCard, error)

func (*Backend) GetRawProfile 

func (b *Backend) GetRawProfile(entityIDBytes []byte) (*Profile, error)

func (*Backend) GetRawUserImg 

func (b *Backend) GetRawUserImg(idBytes []byte) (*UserImg, error)

func (*Backend) GetRawUserImgByID 

func (b *Backend) GetRawUserImgByID(id *types.PttID) (*UserImg, error)

func (*Backend) GetRawUserName 

func (b *Backend) GetRawUserName(idBytes []byte) (*UserName, error)

func (*Backend) GetRawUserNameByID 

func (b *Backend) GetRawUserNameByID(id *types.PttID) (*UserName, error)

func (*Backend) GetUserImg 

func (b *Backend) GetUserImg(idBytes []byte) (*BackendUserImg, error)

func (*Backend) GetUserImgByIDs 

func (b *Backend) GetUserImgByIDs(idByteList [][]byte) (map[string]*BackendUserImg, error)

func (*Backend) GetUserName 

func (b *Backend) GetUserName(idBytes []byte) (*BackendUserName, error)

func (*Backend) GetUserNameByIDs 

func (b *Backend) GetUserNameByIDs(idByteList [][]byte) (map[string]*BackendUserName, error)

func (*Backend) GetUserNodeInfo 

func (b *Backend) GetUserNodeInfo(entityIDBytes []byte) (*UserNodeInfo, error)

func (*Backend) GetUserNodeList 

func (b *Backend) GetUserNodeList(entityIDBytes []byte, startIDBytes []byte, limit int, listOrder pttdb.ListOrder) ([]*UserNode, error)

func (*Backend) GetUserOplogList 

func (b *Backend) GetUserOplogList(entityIDBytes []byte, logIDBytes []byte, limit int, listOrder pttdb.ListOrder) ([]*UserOplog, error)

func (*Backend) GetUserOplogMerkleNodeList 

func (b *Backend) GetUserOplogMerkleNodeList(entityIDBytes []byte, level pkgservice.MerkleTreeLevel, startKey []byte, limit int, listOrder pttdb.ListOrder) ([]*pkgservice.BackendMerkleNode, error)

func (*Backend) Name 

func (b *Backend) Name() string

func (*Backend) RemoveUserNode 

func (b *Backend) RemoveUserNode(entityIDBytes []byte, nodeIDBytes []byte) (types.Bool, error)

func (*Backend) Start 

func (b *Backend) Start() error

func (*Backend) Stop 

func (b *Backend) Stop() error

type BackendNameCard 

type BackendNameCard struct {
	ID   *types.PttID
	Card []byte `json:"C"`
}

type BackendUserImg 

type BackendUserImg struct {
	ID     *types.PttID
	Type   ImgType `json:"T"`
	Img    string  `json:"I"`
	Width  uint16  `json:"W"`
	Height uint16  `json:"H"`
}

type BackendUserName 

type BackendUserName struct {
	ID   *types.PttID
	Name []byte `json:"N"`
}

type Config 

type Config struct {
	DataDir string
}

func NewConfig 

func NewConfig() (*Config, error)

type ImgType 

type ImgType uint8

image-type 

const (
	ImgTypeJPEG ImgType = iota
	ImgTypeGIF
	ImgTypePNG
)

func NormalizeImage 

func NormalizeImage(theBytes []byte, maxWidth int, maxHeight int) (ImgType, uint16, uint16, []byte, error)

type NameCard 

type NameCard struct {
	*pkgservice.BaseObject `json:"b"`
	UpdateTS               types.Timestamp   `json:"UT"`
	SyncInfo               *SyncNameCardInfo `json:"s,omitempty"`

	Card []byte `json:"C,omitempty"`
}

func AliveNameCards 

func AliveNameCards(typedObjs []*NameCard) []*NameCard

func NewEmptyNameCard 

func NewEmptyNameCard() *NameCard

func NewNameCard 

func NewNameCard(
	createTS types.Timestamp,
	creatorID *types.PttID,
	entityID *types.PttID,

	logID *types.PttID,

	status types.Status,

	card []byte,

) (*NameCard, error)

func ObjsToNameCards 

func ObjsToNameCards(objs []pkgservice.Object) []*NameCard

func (*NameCard) Get 

func (u *NameCard) Get(isLocked bool) error

func (*NameCard) GetByID 

func (u *NameCard) GetByID(isLocked bool) error

func (*NameCard) GetNewObjByID 

func (u *NameCard) GetNewObjByID(id *types.PttID, isLocked bool) (pkgservice.Object, error)

func (*NameCard) GetSyncInfo 

func (u *NameCard) GetSyncInfo() pkgservice.SyncInfo

func (*NameCard) GetUpdateTS 

func (u *NameCard) GetUpdateTS() types.Timestamp

func (*NameCard) Marshal 

func (u *NameCard) Marshal() ([]byte, error)

func (*NameCard) MarshalKey 

func (u *NameCard) MarshalKey() ([]byte, error)

func (*NameCard) NewEmptyObj 

func (u *NameCard) NewEmptyObj() pkgservice.Object

func (*NameCard) Save 

func (u *NameCard) Save(isLocked bool) error

func (*NameCard) SetSyncInfo 

func (u *NameCard) SetSyncInfo(theSyncInfo pkgservice.SyncInfo) error

func (*NameCard) SetUpdateTS 

func (u *NameCard) SetUpdateTS(ts types.Timestamp)

func (*NameCard) Unmarshal 

func (u *NameCard) Unmarshal(theBytes []byte) error

type PrivateAPI 

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

func NewPrivateAPI 

func NewPrivateAPI(b *Backend) *PrivateAPI

func (*PrivateAPI) CountPeers 

func (api *PrivateAPI) CountPeers(profileID string) (int, error)

func (*PrivateAPI) ForceSync 

func (api *PrivateAPI) ForceSync(entityID string) (bool, error)

func (*PrivateAPI) ForceSyncMasterMerkle 

func (api *PrivateAPI) ForceSyncMasterMerkle(entityID string) (bool, error)

func (*PrivateAPI) ForceSyncMemberMerkle 

func (api *PrivateAPI) ForceSyncMemberMerkle(entityID string) (bool, error)

func (*PrivateAPI) ForceSyncUserMerkle 

func (api *PrivateAPI) ForceSyncUserMerkle(entityID string) (bool, error)

func (*PrivateAPI) GetMasterList 

func (api *PrivateAPI) GetMasterList(entityID string, startID string, limit int, listOrder pttdb.ListOrder) ([]*pkgservice.Master, error)

func (*PrivateAPI) GetMasterListFromCache 

func (api *PrivateAPI) GetMasterListFromCache(entityID string) ([]*pkgservice.Master, error)

func (*PrivateAPI) GetMasterOplogList 

func (api *PrivateAPI) GetMasterOplogList(profileID string, logID string, limit int, listOrder pttdb.ListOrder) ([]*pkgservice.MasterOplog, error)

func (*PrivateAPI) GetMasterOplogMerkleNodeList 

func (api *PrivateAPI) GetMasterOplogMerkleNodeList(profileID string, level uint8, startKey []byte, limit int, listOrder pttdb.ListOrder) ([]*pkgservice.BackendMerkleNode, error)

func (*PrivateAPI) GetMemberList 

func (api *PrivateAPI) GetMemberList(entityID string, startID string, limit int, listOrder pttdb.ListOrder) ([]*pkgservice.Member, error)

func (*PrivateAPI) GetMemberOplogList 

func (api *PrivateAPI) GetMemberOplogList(profileID string, logID string, limit int, listOrder pttdb.ListOrder) ([]*pkgservice.MemberOplog, error)

func (*PrivateAPI) GetMemberOplogMerkleNodeList 

func (api *PrivateAPI) GetMemberOplogMerkleNodeList(profileID string, level uint8, startKey []byte, limit int, listOrder pttdb.ListOrder) ([]*pkgservice.BackendMerkleNode, error)

func (*PrivateAPI) GetMyMemberLog 

func (api *PrivateAPI) GetMyMemberLog(entityID string) (*pkgservice.BaseOplog, error)

func (*PrivateAPI) GetOpKeyInfos 

func (api *PrivateAPI) GetOpKeyInfos(entityID string) ([]*pkgservice.KeyInfo, error)

func (*PrivateAPI) GetOpKeyInfosFromDB 

func (api *PrivateAPI) GetOpKeyInfosFromDB(entityID string) ([]*pkgservice.KeyInfo, error)

func (*PrivateAPI) GetOpKeyOplogList 

func (api *PrivateAPI) GetOpKeyOplogList(entityID string, logID string, limit int, listOrder pttdb.ListOrder) ([]*pkgservice.OpKeyOplog, error)

func (*PrivateAPI) GetPeers 

func (api *PrivateAPI) GetPeers(profileID string) ([]*pkgservice.BackendPeer, error)

func (*PrivateAPI) GetPendingMasterOplogInternalList 

func (api *PrivateAPI) GetPendingMasterOplogInternalList(profileID string, logID string, limit int, listOrder pttdb.ListOrder) ([]*pkgservice.MasterOplog, error)

func (*PrivateAPI) GetPendingMasterOplogMasterList 

func (api *PrivateAPI) GetPendingMasterOplogMasterList(profileID string, logID string, limit int, listOrder pttdb.ListOrder) ([]*pkgservice.MasterOplog, error)

func (*PrivateAPI) GetPendingMemberOplogInternalList 

func (api *PrivateAPI) GetPendingMemberOplogInternalList(profileID string, logID string, limit int, listOrder pttdb.ListOrder) ([]*pkgservice.MemberOplog, error)

func (*PrivateAPI) GetPendingMemberOplogMasterList 

func (api *PrivateAPI) GetPendingMemberOplogMasterList(profileID string, logID string, limit int, listOrder pttdb.ListOrder) ([]*pkgservice.MemberOplog, error)

func (*PrivateAPI) GetPendingOpKeyOplogInternalList 

func (api *PrivateAPI) GetPendingOpKeyOplogInternalList(entityID string, logID string, limit int, listOrder pttdb.ListOrder) ([]*pkgservice.OpKeyOplog, error)

func (*PrivateAPI) GetPendingOpKeyOplogMasterList 

func (api *PrivateAPI) GetPendingOpKeyOplogMasterList(entityID string, logID string, limit int, listOrder pttdb.ListOrder) ([]*pkgservice.OpKeyOplog, error)

func (*PrivateAPI) GetPendingUserOplogInternalList 

func (api *PrivateAPI) GetPendingUserOplogInternalList(profileID string, logID string, limit int, listOrder pttdb.ListOrder) ([]*UserOplog, error)

func (*PrivateAPI) GetPendingUserOplogMasterList 

func (api *PrivateAPI) GetPendingUserOplogMasterList(profileID string, logID string, limit int, listOrder pttdb.ListOrder) ([]*UserOplog, error)

func (*PrivateAPI) GetRawNameCard 

func (api *PrivateAPI) GetRawNameCard(idStr string) (*NameCard, error)

func (*PrivateAPI) GetRawProfile 

func (api *PrivateAPI) GetRawProfile(idStr string) (*Profile, error)

func (*PrivateAPI) GetRawUserImg 

func (api *PrivateAPI) GetRawUserImg(idStr string) (*UserImg, error)

func (*PrivateAPI) GetRawUserName 

func (api *PrivateAPI) GetRawUserName(idStr string) (*UserName, error)

func (*PrivateAPI) GetUserNodeInfo 

func (api *PrivateAPI) GetUserNodeInfo(entityID string) (*UserNodeInfo, error)

func (*PrivateAPI) GetUserNodeList 

func (api *PrivateAPI) GetUserNodeList(entityID string, startID string, limit int, listOrder pttdb.ListOrder) ([]*UserNode, error)

func (*PrivateAPI) GetUserOplogList 

func (api *PrivateAPI) GetUserOplogList(profileID string, logID string, limit int, listOrder pttdb.ListOrder) ([]*UserOplog, error)

func (*PrivateAPI) GetUserOplogMerkleNodeList 

func (api *PrivateAPI) GetUserOplogMerkleNodeList(profileID string, level uint8, startKey []byte, limit int, listOrder pttdb.ListOrder) ([]*pkgservice.BackendMerkleNode, error)

func (*PrivateAPI) RemoveUserNode 

func (api *PrivateAPI) RemoveUserNode(entityID string, nodeIDStr string) (types.Bool, error)

func (*PrivateAPI) RevokeOpKey 

func (api *PrivateAPI) RevokeOpKey(entityID string, keyID string, myKey string) (bool, error)

func (*PrivateAPI) ShowValidateKey 

func (api *PrivateAPI) ShowValidateKey() (*types.PttID, error)

func (*PrivateAPI) ValidateValidateKey 

func (api *PrivateAPI) ValidateValidateKey(key string) (bool, error)

type ProcessUserInfo 

type ProcessUserInfo struct {
	CreateUserNameInfo map[types.PttID]*pkgservice.BaseOplog
	UserNameInfo       map[types.PttID]*pkgservice.BaseOplog
	CreateUserImgInfo  map[types.PttID]*pkgservice.BaseOplog
	UserImgInfo        map[types.PttID]*pkgservice.BaseOplog
	CreateUserNodeInfo map[types.PttID]*pkgservice.BaseOplog
	UserNodeInfo       map[types.PttID]*pkgservice.BaseOplog
	CreateNameCardInfo map[types.PttID]*pkgservice.BaseOplog
	NameCardInfo       map[types.PttID]*pkgservice.BaseOplog
}

func NewProcessUserInfo 

func NewProcessUserInfo() *ProcessUserInfo

type Profile 

type Profile struct {
	*pkgservice.BaseEntity `json:"e"`
	UpdateTS               types.Timestamp `json:"UT"`

	MyID *types.PttID `json:"m"`
}

func NewEmptyProfile 

func NewEmptyProfile() *Profile

func NewProfile 

func NewProfile(myID *types.PttID, ts types.Timestamp, ptt pkgservice.Ptt, service pkgservice.Service, spm pkgservice.ServiceProtocolManager, dbLock *types.LockMap) (*Profile, error)

func (*Profile) GetUpdateTS 

func (p *Profile) GetUpdateTS() types.Timestamp

func (*Profile) Init 

func (p *Profile) Init(ptt pkgservice.Ptt, service pkgservice.Service, spm pkgservice.ServiceProtocolManager) error

func (*Profile) InitPM 

func (p *Profile) InitPM(ptt pkgservice.Ptt, service pkgservice.Service) error

func (*Profile) Marshal 

func (p *Profile) Marshal() ([]byte, error)

func (*Profile) MarshalKey 

func (p *Profile) MarshalKey() ([]byte, error)

func (*Profile) Save 

func (p *Profile) Save(isLocked bool) error

func (*Profile) SetUpdateTS 

func (p *Profile) SetUpdateTS(ts types.Timestamp)

func (*Profile) Unmarshal 

func (p *Profile) Unmarshal(theBytes []byte) error

type ProtocolManager 

type ProtocolManager struct {
	*pkgservice.BaseProtocolManager
	// contains filtered or unexported fields
}

func NewProtocolManager 

func NewProtocolManager(profile *Profile, ptt pkgservice.Ptt, svc pkgservice.Service) (*ProtocolManager, error)

func (*ProtocolManager) AddUserNode 

func (pm *ProtocolManager) AddUserNode(nodeID *discover.NodeID) error

func (*ProtocolManager) ApproveJoin 

func (pm *ProtocolManager) ApproveJoin(
	joinEntity *pkgservice.JoinEntity,
	keyInfo *pkgservice.KeyInfo,
	peer *pkgservice.PttPeer,
) (*pkgservice.KeyInfo, interface{}, error)

func (*ProtocolManager) BroadcastUserOplog 

func (pm *ProtocolManager) BroadcastUserOplog(oplog *UserOplog) error

func (*ProtocolManager) BroadcastUserOplogs 

func (pm *ProtocolManager) BroadcastUserOplogs(opKeyLogs []*UserOplog) error

func (*ProtocolManager) CleanObject 

func (pm *ProtocolManager) CleanObject() error

func (*ProtocolManager) CleanUserNode 

func (pm *ProtocolManager) CleanUserNode() error

func (*ProtocolManager) CreateNameCard 

func (pm *ProtocolManager) CreateNameCard(nameCard []byte) error

func (*ProtocolManager) CreateUserImg 

func (pm *ProtocolManager) CreateUserImg() error

func (*ProtocolManager) CreateUserName 

func (pm *ProtocolManager) CreateUserName(name []byte) error

func (*ProtocolManager) CreateUserOplog 

func (pm *ProtocolManager) CreateUserOplog(objID *types.PttID, ts types.Timestamp, op pkgservice.OpType, data interface{}) (*UserOplog, error)

func (*ProtocolManager) DeleteProfile 

func (pm *ProtocolManager) DeleteProfile() error

func (*ProtocolManager) ForceSyncNameCard 

func (pm *ProtocolManager) ForceSyncNameCard(syncIDs []*pkgservice.ForceSyncID, peer *pkgservice.PttPeer) error

func (*ProtocolManager) ForceSyncUserImg 

func (pm *ProtocolManager) ForceSyncUserImg(syncIDs []*pkgservice.ForceSyncID, peer *pkgservice.PttPeer) error

func (*ProtocolManager) ForceSyncUserMerkle 

func (pm *ProtocolManager) ForceSyncUserMerkle() (bool, error)

func (*ProtocolManager) ForceSyncUserName 

func (pm *ProtocolManager) ForceSyncUserName(syncIDs []*pkgservice.ForceSyncID, peer *pkgservice.PttPeer) error

func (*ProtocolManager) ForceSyncUserNode 

func (pm *ProtocolManager) ForceSyncUserNode(syncIDs []*pkgservice.ForceSyncID, peer *pkgservice.PttPeer) error

func (*ProtocolManager) GetPeerType 

func (pm *ProtocolManager) GetPeerType(peer *pkgservice.PttPeer) pkgservice.PeerType

func (*ProtocolManager) GetUserNodeInfo 

func (pm *ProtocolManager) GetUserNodeInfo() *UserNodeInfo

func (*ProtocolManager) GetUserNodeList 

func (pm *ProtocolManager) GetUserNodeList(startID *types.PttID, limit int, listOrder pttdb.ListOrder, isLocked bool) ([]*UserNode, error)

func (*ProtocolManager) GetUserOplogList 

func (pm *ProtocolManager) GetUserOplogList(logID *types.PttID, limit int, listOrder pttdb.ListOrder, status types.Status) ([]*UserOplog, error)

GetUserOplogList gets the UserOplogs.

func (*ProtocolManager) GetUserOplogMerkleNodeList 

func (pm *ProtocolManager) GetUserOplogMerkleNodeList(level pkgservice.MerkleTreeLevel, startKey []byte, limit int, listOrder pttdb.ListOrder) ([]*pkgservice.MerkleNode, error)

func (*ProtocolManager) HandleAddPendingUserOplog 

func (pm *ProtocolManager) HandleAddPendingUserOplog(dataBytes []byte, peer *pkgservice.PttPeer) error

func (*ProtocolManager) HandleAddPendingUserOplogs 

func (pm *ProtocolManager) HandleAddPendingUserOplogs(dataBytes []byte, peer *pkgservice.PttPeer) error

func (*ProtocolManager) HandleAddUserOplog 

func (pm *ProtocolManager) HandleAddUserOplog(dataBytes []byte, peer *pkgservice.PttPeer) error

func (*ProtocolManager) HandleAddUserOplogs 

func (pm *ProtocolManager) HandleAddUserOplogs(dataBytes []byte, peer *pkgservice.PttPeer) error

func (*ProtocolManager) HandleFailedUserOplog 

func (pm *ProtocolManager) HandleFailedUserOplog(oplog *pkgservice.BaseOplog) (err error)

func (*ProtocolManager) HandleFailedValidUserOplog 

func (pm *ProtocolManager) HandleFailedValidUserOplog(oplog *pkgservice.BaseOplog, processInfo pkgservice.ProcessInfo) (err error)

func (*ProtocolManager) HandleForceSyncNameCard 

func (pm *ProtocolManager) HandleForceSyncNameCard(dataBytes []byte, peer *pkgservice.PttPeer) error

func (*ProtocolManager) HandleForceSyncNameCardAck 

func (pm *ProtocolManager) HandleForceSyncNameCardAck(dataBytes []byte, peer *pkgservice.PttPeer) error

func (*ProtocolManager) HandleForceSyncUserImg 

func (pm *ProtocolManager) HandleForceSyncUserImg(dataBytes []byte, peer *pkgservice.PttPeer) error

func (*ProtocolManager) HandleForceSyncUserImgAck 

func (pm *ProtocolManager) HandleForceSyncUserImgAck(dataBytes []byte, peer *pkgservice.PttPeer) error

func (*ProtocolManager) HandleForceSyncUserName 

func (pm *ProtocolManager) HandleForceSyncUserName(dataBytes []byte, peer *pkgservice.PttPeer) error

func (*ProtocolManager) HandleForceSyncUserNameAck 

func (pm *ProtocolManager) HandleForceSyncUserNameAck(dataBytes []byte, peer *pkgservice.PttPeer) error

func (*ProtocolManager) HandleForceSyncUserNode 

func (pm *ProtocolManager) HandleForceSyncUserNode(dataBytes []byte, peer *pkgservice.PttPeer) error

func (*ProtocolManager) HandleForceSyncUserNodeAck 

func (pm *ProtocolManager) HandleForceSyncUserNodeAck(dataBytes []byte, peer *pkgservice.PttPeer) error

func (*ProtocolManager) HandleForceSyncUserOplog 

func (pm *ProtocolManager) HandleForceSyncUserOplog(dataBytes []byte, peer *pkgservice.PttPeer) error

func (*ProtocolManager) HandleForceSyncUserOplogAck 

func (pm *ProtocolManager) HandleForceSyncUserOplogAck(dataBytes []byte, peer *pkgservice.PttPeer) error

func (*ProtocolManager) HandleForceSyncUserOplogByMerkle 

func (pm *ProtocolManager) HandleForceSyncUserOplogByMerkle(dataBytes []byte, peer *pkgservice.PttPeer) error

func (*ProtocolManager) HandleForceSyncUserOplogByMerkleAck 

func (pm *ProtocolManager) HandleForceSyncUserOplogByMerkleAck(dataBytes []byte, peer *pkgservice.PttPeer) error

func (*ProtocolManager) HandleForceSyncUserOplogByOplogAck 

func (pm *ProtocolManager) HandleForceSyncUserOplogByOplogAck(dataBytes []byte, peer *pkgservice.PttPeer) error

func (*ProtocolManager) HandleMessage 

func (pm *ProtocolManager) HandleMessage(op pkgservice.OpType, dataBytes []byte, peer *pkgservice.PttPeer) (err error)

func (*ProtocolManager) HandlePendingUserOplogs 

func (pm *ProtocolManager) HandlePendingUserOplogs(oplogs []*pkgservice.BaseOplog, peer *pkgservice.PttPeer) error

func (*ProtocolManager) HandleSyncAddUserNodeAck 

func (pm *ProtocolManager) HandleSyncAddUserNodeAck(objs []*UserNode, peer *pkgservice.PttPeer) error

func (*ProtocolManager) HandleSyncCreateNameCard 

func (pm *ProtocolManager) HandleSyncCreateNameCard(dataBytes []byte, peer *pkgservice.PttPeer, syncAckMsg pkgservice.OpType) error

func (*ProtocolManager) HandleSyncCreateNameCardAck 

func (pm *ProtocolManager) HandleSyncCreateNameCardAck(dataBytes []byte, peer *pkgservice.PttPeer) error

func (*ProtocolManager) HandleSyncCreateUserImg 

func (pm *ProtocolManager) HandleSyncCreateUserImg(dataBytes []byte, peer *pkgservice.PttPeer, syncAckMsg pkgservice.OpType) error

func (*ProtocolManager) HandleSyncCreateUserImgAck 

func (pm *ProtocolManager) HandleSyncCreateUserImgAck(dataBytes []byte, peer *pkgservice.PttPeer) error

func (*ProtocolManager) HandleSyncCreateUserName 

func (pm *ProtocolManager) HandleSyncCreateUserName(dataBytes []byte, peer *pkgservice.PttPeer, syncAckMsg pkgservice.OpType) error

func (*ProtocolManager) HandleSyncCreateUserNameAck 

func (pm *ProtocolManager) HandleSyncCreateUserNameAck(dataBytes []byte, peer *pkgservice.PttPeer) error

func (*ProtocolManager) HandleSyncNewUserOplog 

func (pm *ProtocolManager) HandleSyncNewUserOplog(dataBytes []byte, peer *pkgservice.PttPeer) error

func (*ProtocolManager) HandleSyncNewUserOplogAck 

func (pm *ProtocolManager) HandleSyncNewUserOplogAck(dataBytes []byte, peer *pkgservice.PttPeer) error

func (*ProtocolManager) HandleSyncPendingUserOplog 

func (pm *ProtocolManager) HandleSyncPendingUserOplog(dataBytes []byte, peer *pkgservice.PttPeer) error

func (*ProtocolManager) HandleSyncPendingUserOplogAck 

func (pm *ProtocolManager) HandleSyncPendingUserOplogAck(dataBytes []byte, peer *pkgservice.PttPeer) error

func (*ProtocolManager) HandleSyncUpdateNameCard 

func (pm *ProtocolManager) HandleSyncUpdateNameCard(dataBytes []byte, peer *pkgservice.PttPeer, syncAckMsg pkgservice.OpType) error

func (*ProtocolManager) HandleSyncUpdateNameCardAck 

func (pm *ProtocolManager) HandleSyncUpdateNameCardAck(dataBytes []byte, peer *pkgservice.PttPeer) error

func (*ProtocolManager) HandleSyncUpdateUserImg 

func (pm *ProtocolManager) HandleSyncUpdateUserImg(dataBytes []byte, peer *pkgservice.PttPeer, syncAckMsg pkgservice.OpType) error

func (*ProtocolManager) HandleSyncUpdateUserImgAck 

func (pm *ProtocolManager) HandleSyncUpdateUserImgAck(dataBytes []byte, peer *pkgservice.PttPeer) error

func (*ProtocolManager) HandleSyncUpdateUserName 

func (pm *ProtocolManager) HandleSyncUpdateUserName(dataBytes []byte, peer *pkgservice.PttPeer, syncAckMsg pkgservice.OpType) error

func (*ProtocolManager) HandleSyncUpdateUserNameAck 

func (pm *ProtocolManager) HandleSyncUpdateUserNameAck(dataBytes []byte, peer *pkgservice.PttPeer) error

func (*ProtocolManager) HandleSyncUserOplog 

func (pm *ProtocolManager) HandleSyncUserOplog(dataBytes []byte, peer *pkgservice.PttPeer) error

func (*ProtocolManager) HandleSyncUserOplogAck 

func (pm *ProtocolManager) HandleSyncUserOplogAck(dataBytes []byte, peer *pkgservice.PttPeer) error

func (*ProtocolManager) HandleSyncUserOplogInvalid 

func (pm *ProtocolManager) HandleSyncUserOplogInvalid(dataBytes []byte, peer *pkgservice.PttPeer) error

func (*ProtocolManager) HandleUserOplogs 

func (pm *ProtocolManager) HandleUserOplogs(oplogs []*pkgservice.BaseOplog, peer *pkgservice.PttPeer, isUpdateSyncTime bool) error

func (*ProtocolManager) InitUserNode 

func (pm *ProtocolManager) InitUserNode(entityID *types.PttID)

func (*ProtocolManager) IsFitPeer 

func (pm *ProtocolManager) IsFitPeer(peer *pkgservice.PttPeer) pkgservice.PeerType

func (*ProtocolManager) IsImportantPeer 

func (pm *ProtocolManager) IsImportantPeer(peer *pkgservice.PttPeer) bool

func (*ProtocolManager) IsMemberPeer 

func (pm *ProtocolManager) IsMemberPeer(peer *pkgservice.PttPeer) bool

func (*ProtocolManager) IsMyDevice 

func (pm *ProtocolManager) IsMyDevice(peer *pkgservice.PttPeer) bool

func (*ProtocolManager) NewNameCard 

func (pm *ProtocolManager) NewNameCard(theData pkgservice.CreateData) (pkgservice.Object, pkgservice.OpData, error)

func (*ProtocolManager) NewUserImg 

func (pm *ProtocolManager) NewUserImg(theData pkgservice.CreateData) (pkgservice.Object, pkgservice.OpData, error)

func (*ProtocolManager) NewUserName 

func (pm *ProtocolManager) NewUserName(theData pkgservice.CreateData) (pkgservice.Object, pkgservice.OpData, error)

func (*ProtocolManager) NewUserNode 

func (pm *ProtocolManager) NewUserNode(theData pkgservice.CreateData) (pkgservice.Object, pkgservice.OpData, error)

func (*ProtocolManager) NewUserOplog 

func (pm *ProtocolManager) NewUserOplog(objID *types.PttID, op pkgservice.OpType, opData pkgservice.OpData) (pkgservice.Oplog, error)

func (*ProtocolManager) NewUserOplogWithTS 

func (pm *ProtocolManager) NewUserOplogWithTS(objID *types.PttID, ts types.Timestamp, op pkgservice.OpType, opData pkgservice.OpData) (pkgservice.Oplog, error)

func (*ProtocolManager) RemoveUserNode 

func (pm *ProtocolManager) RemoveUserNode(nodeID *discover.NodeID) error

func (*ProtocolManager) SetNameCardDB 

func (pm *ProtocolManager) SetNameCardDB(u *NameCard)

func (*ProtocolManager) SetNewestUserOplog 

func (pm *ProtocolManager) SetNewestUserOplog(oplog *pkgservice.BaseOplog) (err error)

func (*ProtocolManager) SetUserDB 

func (pm *ProtocolManager) SetUserDB(oplog *pkgservice.BaseOplog)

func (*ProtocolManager) SetUserImgDB 

func (pm *ProtocolManager) SetUserImgDB(u *UserImg)

func (*ProtocolManager) SetUserNameDB 

func (pm *ProtocolManager) SetUserNameDB(u *UserName)

func (*ProtocolManager) SetUserNodeDB 

func (pm *ProtocolManager) SetUserNodeDB(u *UserNode)

func (*ProtocolManager) SetUserOplogIsSync 

func (pm *ProtocolManager) SetUserOplogIsSync(oplog *UserOplog, isBroadcast bool) (bool, error)

func (*ProtocolManager) Start 

func (pm *ProtocolManager) Start() error

func (*ProtocolManager) Stop 

func (pm *ProtocolManager) Stop() error

func (*ProtocolManager) Sync 

func (pm *ProtocolManager) Sync(peer *pkgservice.PttPeer) error

func (*ProtocolManager) SyncAddUserNode 

func (pm *ProtocolManager) SyncAddUserNode(oplogs []*pkgservice.BaseOplog, peer *pkgservice.PttPeer) error

func (*ProtocolManager) SyncNameCard 

func (pm *ProtocolManager) SyncNameCard(op pkgservice.OpType, syncIDs []*pkgservice.SyncID, peer *pkgservice.PttPeer) error

func (*ProtocolManager) SyncPendingUserOplog 

func (pm *ProtocolManager) SyncPendingUserOplog(peer *pkgservice.PttPeer) error

func (*ProtocolManager) SyncUserImg 

func (pm *ProtocolManager) SyncUserImg(op pkgservice.OpType, syncIDs []*pkgservice.SyncID, peer *pkgservice.PttPeer) error

func (*ProtocolManager) SyncUserName 

func (pm *ProtocolManager) SyncUserName(op pkgservice.OpType, syncIDs []*pkgservice.SyncID, peer *pkgservice.PttPeer) error

func (*ProtocolManager) SyncUserOplog 

func (pm *ProtocolManager) SyncUserOplog(peer *pkgservice.PttPeer) error

func (*ProtocolManager) UpdateNameCard 

func (pm *ProtocolManager) UpdateNameCard(card []byte) (*NameCard, error)

func (*ProtocolManager) UpdateUserImg 

func (pm *ProtocolManager) UpdateUserImg(imgStr string) (*UserImg, error)

func (*ProtocolManager) UpdateUserName 

func (pm *ProtocolManager) UpdateUserName(name []byte) (*UserName, error)

type PublicAPI 

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

func NewPublicAPI 

func NewPublicAPI(b *Backend) *PublicAPI

func (*PublicAPI) GetNameCard 

func (api *PublicAPI) GetNameCard(idStr string) (*BackendNameCard, error)

func (*PublicAPI) GetNameCardByIDs 

func (api *PublicAPI) GetNameCardByIDs(idStrs []string) (map[string]*BackendNameCard, error)

func (*PublicAPI) GetUserImg 

func (api *PublicAPI) GetUserImg(idStr string) (*BackendUserImg, error)

func (*PublicAPI) GetUserImgByIDs 

func (api *PublicAPI) GetUserImgByIDs(idStrs []string) (map[string]*BackendUserImg, error)

func (*PublicAPI) GetUserName 

func (api *PublicAPI) GetUserName(idStr string) (*BackendUserName, error)

func (*PublicAPI) GetUserNameByIDs 

func (api *PublicAPI) GetUserNameByIDs(idStrs []string) (map[string]*BackendUserName, error)

type ServiceProtocolManager 

type ServiceProtocolManager struct {
	*pkgservice.BaseServiceProtocolManager
}

func NewServiceProtocolManager 

func NewServiceProtocolManager(ptt pkgservice.Ptt, service pkgservice.Service) (*ServiceProtocolManager, error)

func (*ServiceProtocolManager) CreateJoinEntity 

func (spm *ServiceProtocolManager) CreateJoinEntity(
	approveJoin *ApproveJoinEntity,
	peer *pkgservice.PttPeer,

	meLog *pkgservice.BaseOplog,

	isStart bool,
	isNew bool,
	isForceNotBroadcast bool,

	isLocked bool,
	isResetOwnerID bool,
) (pkgservice.Entity, error)

func (*ServiceProtocolManager) CreateProfile 

func (spm *ServiceProtocolManager) CreateProfile() (*Profile, error)

func (*ServiceProtocolManager) GetNameCardByID 

func (spm *ServiceProtocolManager) GetNameCardByID(id *types.PttID) (*NameCard, error)

func (*ServiceProtocolManager) GetProfileList 

func (spm *ServiceProtocolManager) GetProfileList(startingID *types.PttID, limit int) ([]*Profile, error)

func (*ServiceProtocolManager) GetUserImgByID 

func (spm *ServiceProtocolManager) GetUserImgByID(id *types.PttID) (*UserImg, error)

func (*ServiceProtocolManager) GetUserNameByID 

func (spm *ServiceProtocolManager) GetUserNameByID(id *types.PttID) (*UserName, error)

func (*ServiceProtocolManager) NewEmptyEntity 

func (spm *ServiceProtocolManager) NewEmptyEntity() pkgservice.Entity

func (*ServiceProtocolManager) NewProfile 

func (spm *ServiceProtocolManager) NewProfile(data pkgservice.CreateData, ptt pkgservice.Ptt, service pkgservice.Service) (pkgservice.Entity, pkgservice.OpData, error)

func (*ServiceProtocolManager) NewUserOplogWithTS 

func (spm *ServiceProtocolManager) NewUserOplogWithTS(entityID *types.PttID, ts types.Timestamp, op pkgservice.OpType, opData pkgservice.OpData) (pkgservice.Oplog, error)

func (*ServiceProtocolManager) SetNameCardDB 

func (spm *ServiceProtocolManager) SetNameCardDB(u *NameCard)

func (*ServiceProtocolManager) SetUserImgDB 

func (spm *ServiceProtocolManager) SetUserImgDB(u *UserImg)

func (*ServiceProtocolManager) SetUserNameDB 

func (spm *ServiceProtocolManager) SetUserNameDB(u *UserName)

type SyncNameCardAck 

type SyncNameCardAck struct {
	Objs []*NameCard `json:"o"`
}

type SyncNameCardInfo 

type SyncNameCardInfo struct {
	*pkgservice.BaseSyncInfo `json:"b"`

	Card []byte `json:"C,omitempty"`
}

func NewEmptySyncNameCardInfo 

func NewEmptySyncNameCardInfo() *SyncNameCardInfo

func (*SyncNameCardInfo) ToObject 

func (s *SyncNameCardInfo) ToObject(theObj pkgservice.Object) error

type SyncUpdateNameCardAck 

type SyncUpdateNameCardAck struct {
	Objs []*NameCard `json:"o"`
}

type SyncUpdateUserImgAck 

type SyncUpdateUserImgAck struct {
	Objs []*UserImg `json:"o"`
}

type SyncUpdateUserNameAck 

type SyncUpdateUserNameAck struct {
	Objs []*UserName `json:"o"`
}

type SyncUserImgAck 

type SyncUserImgAck struct {
	Objs []*UserImg `json:"o"`
}

type SyncUserImgInfo 

type SyncUserImgInfo struct {
	*pkgservice.BaseSyncInfo `json:"b"`

	ImgType ImgType `json:"T"`
	Width   uint16  `json:"W"`
	Height  uint16  `json:"H"`
	Str     string  `json:"I"`
}

func NewEmptySyncUserImgInfo 

func NewEmptySyncUserImgInfo() *SyncUserImgInfo

func (*SyncUserImgInfo) ToObject 

func (s *SyncUserImgInfo) ToObject(theObj pkgservice.Object) error

type SyncUserNameAck 

type SyncUserNameAck struct {
	Objs []*UserName `json:"o"`
}

type SyncUserNameInfo 

type SyncUserNameInfo struct {
	*pkgservice.BaseSyncInfo `json:"b"`

	Name []byte `json:"N,omitempty"`
}

func NewEmptySyncUserNameInfo 

func NewEmptySyncUserNameInfo() *SyncUserNameInfo

func (*SyncUserNameInfo) ToObject 

func (s *SyncUserNameInfo) ToObject(theObj pkgservice.Object) error

type SyncUserNodeAck 

type SyncUserNodeAck struct {
	Objs []*UserNode `json:"o"`
}

type UpdateNameCard 

type UpdateNameCard struct {
	Card []byte `json:"n"`
}

type UpdateUserImg 

type UpdateUserImg struct {
	ImgType ImgType `json:"T"`
	Width   uint16  `json:"W"`
	Height  uint16  `json:"H"`
	Str     string  `json:"I"`
}

type UpdateUserName 

type UpdateUserName struct {
	Name []byte `json:"n"`
}

type UserImg 

type UserImg struct {
	*pkgservice.BaseObject `json:"b"`
	UpdateTS               types.Timestamp `json:"UT"`

	SyncInfo *SyncUserImgInfo `json:"si,omitempty"`

	ImgType ImgType `json:"T"`
	Width   uint16  `json:"W"`
	Height  uint16  `json:"H"`
	Str     string  `json:"I"`
}

func AliveUserImgs 

func AliveUserImgs(typedObjs []*UserImg) []*UserImg

func NewEmptyUserImg 

func NewEmptyUserImg() *UserImg

func NewUserImg 

func NewUserImg(
	createTS types.Timestamp,
	creatorID *types.PttID,
	entityID *types.PttID,

	logID *types.PttID,

	status types.Status,
) (*UserImg, error)

func ObjsToUserImgs 

func ObjsToUserImgs(objs []pkgservice.Object) []*UserImg

func (*UserImg) Get 

func (u *UserImg) Get(isLocked bool) error

func (*UserImg) GetByID 

func (u *UserImg) GetByID(isLocked bool) error

func (*UserImg) GetNewObjByID 

func (u *UserImg) GetNewObjByID(id *types.PttID, isLocked bool) (pkgservice.Object, error)

func (*UserImg) GetSyncInfo 

func (u *UserImg) GetSyncInfo() pkgservice.SyncInfo

func (*UserImg) GetUpdateTS 

func (u *UserImg) GetUpdateTS() types.Timestamp

func (*UserImg) Marshal 

func (u *UserImg) Marshal() ([]byte, error)

func (*UserImg) MarshalKey 

func (u *UserImg) MarshalKey() ([]byte, error)

func (*UserImg) NewEmptyObj 

func (u *UserImg) NewEmptyObj() pkgservice.Object

func (*UserImg) Save 

func (u *UserImg) Save(isLocked bool) error

func (*UserImg) SetSyncInfo 

func (u *UserImg) SetSyncInfo(theSyncInfo pkgservice.SyncInfo) error

func (*UserImg) SetUpdateTS 

func (u *UserImg) SetUpdateTS(ts types.Timestamp)

func (*UserImg) Unmarshal 

func (u *UserImg) Unmarshal(theBytes []byte) error

type UserName 

type UserName struct {
	*pkgservice.BaseObject `json:"b"`
	UpdateTS               types.Timestamp   `json:"UT"`
	SyncInfo               *SyncUserNameInfo `json:"s,omitempty"`

	Name []byte `json:"N,omitempty"`
}

func AliveUserNames 

func AliveUserNames(typedObjs []*UserName) []*UserName

func NewEmptyUserName 

func NewEmptyUserName() *UserName

func NewUserName 

func NewUserName(
	createTS types.Timestamp,
	creatorID *types.PttID,
	entityID *types.PttID,

	logID *types.PttID,

	status types.Status,

	name []byte,

) (*UserName, error)

func ObjsToUserNames 

func ObjsToUserNames(objs []pkgservice.Object) []*UserName

func (*UserName) Get 

func (u *UserName) Get(isLocked bool) error

func (*UserName) GetByID 

func (u *UserName) GetByID(isLocked bool) error

func (*UserName) GetNewObjByID 

func (u *UserName) GetNewObjByID(id *types.PttID, isLocked bool) (pkgservice.Object, error)

func (*UserName) GetSyncInfo 

func (u *UserName) GetSyncInfo() pkgservice.SyncInfo

func (*UserName) GetUpdateTS 

func (u *UserName) GetUpdateTS() types.Timestamp

func (*UserName) Marshal 

func (u *UserName) Marshal() ([]byte, error)

func (*UserName) MarshalKey 

func (u *UserName) MarshalKey() ([]byte, error)

func (*UserName) NewEmptyObj 

func (u *UserName) NewEmptyObj() pkgservice.Object

func (*UserName) Save 

func (u *UserName) Save(isLocked bool) error

func (*UserName) SetSyncInfo 

func (u *UserName) SetSyncInfo(theSyncInfo pkgservice.SyncInfo) error

func (*UserName) SetUpdateTS 

func (u *UserName) SetUpdateTS(ts types.Timestamp)

func (*UserName) Unmarshal 

func (u *UserName) Unmarshal(theBytes []byte) error

type UserNode 

type UserNode struct {
	*pkgservice.BaseObject `json:"b"`
	UpdateTS               types.Timestamp `json:"UT"`

	UserID *types.PttID     `json:"UID"`
	NodeID *discover.NodeID `json:"NID"`

	SyncInfo *pkgservice.BaseSyncInfo `json:"s"`
	// contains filtered or unexported fields
}

func AliveUserNodes 

func AliveUserNodes(typedObjs []*UserNode) []*UserNode

func NewEmptyUserNode 

func NewEmptyUserNode() *UserNode

func NewUserNode 

func NewUserNode(
	createTS types.Timestamp,
	creatorID *types.PttID,
	entityID *types.PttID,

	logID *types.PttID,

	status types.Status,

	userID *types.PttID,
	nodeID *discover.NodeID,

) (*UserNode, error)

func ObjsToUserNodes 

func ObjsToUserNodes(objs []pkgservice.Object) []*UserNode

func (*UserNode) GetByID 

func (u *UserNode) GetByID(isLocked bool) error

func (*UserNode) GetIDByNodeID 

func (u *UserNode) GetIDByNodeID(nodeID *discover.NodeID) (*types.PttID, error)

func (*UserNode) GetNewObjByID 

func (u *UserNode) GetNewObjByID(id *types.PttID, isLocked bool) (pkgservice.Object, error)

func (*UserNode) GetSyncInfo 

func (u *UserNode) GetSyncInfo() pkgservice.SyncInfo

func (*UserNode) GetUpdateTS 

func (u *UserNode) GetUpdateTS() types.Timestamp

func (*UserNode) Idx2Key 

func (u *UserNode) Idx2Key() ([]byte, error)

func (*UserNode) Marshal 

func (u *UserNode) Marshal() ([]byte, error)

func (*UserNode) MarshalKey 

func (u *UserNode) MarshalKey() ([]byte, error)

func (*UserNode) NewEmptyObj 

func (u *UserNode) NewEmptyObj() pkgservice.Object

func (*UserNode) Save 

func (u *UserNode) Save(isLocked bool) error

func (*UserNode) SetSyncInfo 

func (u *UserNode) SetSyncInfo(theSyncInfo pkgservice.SyncInfo) error

func (*UserNode) SetUpdateTS 

func (u *UserNode) SetUpdateTS(ts types.Timestamp)

func (*UserNode) Unmarshal 

func (u *UserNode) Unmarshal(theBytes []byte) error

type UserNodeInfo 

type UserNodeInfo struct {
	ID         *types.PttID
	UserNodeID *types.PttID `json:"nid"`
	NUserNode  int          `json:"n"`
}

func NewUserNodeInfo 

func NewUserNodeInfo(
	id *types.PttID,
	userNodeID *types.PttID,
	nUserNode int,
) (*UserNodeInfo, error)

func (*UserNodeInfo) Delete 

func (u *UserNodeInfo) Delete() error

func (*UserNodeInfo) Get 

func (u *UserNodeInfo) Get(id *types.PttID) error

func (*UserNodeInfo) Marshal 

func (u *UserNodeInfo) Marshal() ([]byte, error)

func (*UserNodeInfo) MarshalKey 

func (u *UserNodeInfo) MarshalKey() ([]byte, error)

func (*UserNodeInfo) Save 

func (u *UserNodeInfo) Save() error

func (*UserNodeInfo) Unmarshal 

func (u *UserNodeInfo) Unmarshal(theBytes []byte) error

type UserOpAddUserNode 

type UserOpAddUserNode struct {
	NodeID *discover.NodeID `json:"n"`
}

type UserOpCreateNameCard 

type UserOpCreateNameCard struct {
}

type UserOpCreateProfile 

type UserOpCreateProfile struct {
}

type UserOpCreateUserImg 

type UserOpCreateUserImg struct {
}

type UserOpCreateUserName 

type UserOpCreateUserName struct {
}

type UserOpDeleteProfile 

type UserOpDeleteProfile struct {
}

type UserOpRemoveUserNode 

type UserOpRemoveUserNode struct {
	NodeID *discover.NodeID `json:"n"`
}

type UserOpTransferProfile 

type UserOpTransferProfile struct {
	ToID *types.PttID `json:"t"`
}

type UserOpUpdateNameCard 

type UserOpUpdateNameCard struct {
	Hash []byte `json:"H"`
}

type UserOpUpdateUserImg 

type UserOpUpdateUserImg struct {
	Hash []byte `json:"H"`
}

type UserOpUpdateUserName 

type UserOpUpdateUserName struct {
	Hash []byte `json:"H"`
}

type UserOplog 

type UserOplog struct {
	*pkgservice.BaseOplog `json:"O"`
}

func NewUserOplog 

func NewUserOplog(objID *types.PttID, ts types.Timestamp, doerID *types.PttID, op pkgservice.OpType, opData pkgservice.OpData, userID *types.PttID, dbLock *types.LockMap) (*UserOplog, error)

func OplogToUserOplog 

func OplogToUserOplog(oplog *pkgservice.BaseOplog) *UserOplog

func OplogsToUserOplogs 

func OplogsToUserOplogs(logs []*pkgservice.BaseOplog) []*UserOplog

func (*UserOplog) GetBaseOplog 

func (o *UserOplog) GetBaseOplog() *pkgservice.BaseOplog

Source Files

View all Source files

Jump to

Keyboard shortcuts

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