server

Documentation

Index

• type GetConnectionCntReq
• type GetConnectionCntRsp
• type GetConnectionStateReq
• type GetConnectionStateRsp
• type GetIdReq
• type GetIdRsp
• type GetNeighborAddrsReq
• type GetNeighborAddrsRsp
• type GetNodeTypeReq
• type GetNodeTypeRsp
• type GetPortReq
• type GetPortRsp
• type GetRelayStateReq
• type GetRelayStateRsp
• type GetTimeReq
• type GetTimeRsp
• type GetVersionReq
• type GetVersionRsp
• type P2PActor
  • func NewP2PActor(p2pServer *p2pserver.P2PServer) *P2PActor
  • func (this *P2PActor) Receive(ctx actor.Context)
  • func (this *P2PActor) Start() (*actor.PID, error)
• type StopServerReq
• type StopServerRsp
• type TransmitConsensusMsgReq

Types

type GetConnectionCntReq

type GetConnectionCntReq struct {
}

connection count requet

type GetConnectionCntRsp

type GetConnectionCntRsp struct {
	Cnt uint32
}

response of connection count requet

type GetConnectionStateReq

type GetConnectionStateReq struct {
}

get connection state requet

type GetConnectionStateRsp

type GetConnectionStateRsp struct {
	State uint32
}

response of connection state requet

type GetIdReq

type GetIdReq struct {
}

get net module id

type GetIdRsp

type GetIdRsp struct {
	Id uint64
}

response of net module id

type GetNeighborAddrsReq

type GetNeighborAddrsReq struct {
}

get all nbr`s address request

type GetNeighborAddrsRsp

type GetNeighborAddrsRsp struct {
	Addrs []types.PeerAddr
}

response of all nbr`s address

type GetNodeTypeReq

type GetNodeTypeReq struct {
}

type GetNodeTypeRsp

type GetNodeTypeRsp struct {
	NodeType uint64
}

type GetPortReq

type GetPortReq struct {
}

get connection port requet

type GetPortRsp

type GetPortRsp struct {
	SyncPort uint16
}

response of connection port requet

type GetRelayStateReq

type GetRelayStateReq struct {
}

whether net can relay

type GetRelayStateRsp

type GetRelayStateRsp struct {
	Relay bool
}

response of whether net can relay

type GetTimeReq

type GetTimeReq struct {
}

get net timestamp request

type GetTimeRsp

type GetTimeRsp struct {
	Time int64
}

response of net timestamp

type GetVersionReq

type GetVersionReq struct {
}

version request

type GetVersionRsp

type GetVersionRsp struct {
	Version uint32
}

response of version request

type P2PActor

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

func NewP2PActor

func NewP2PActor(p2pServer *p2pserver.P2PServer) *P2PActor

NewP2PActor creates an actor to handle the messages from txnpool and consensus

func (*P2PActor) Receive

func (this *P2PActor) Receive(ctx actor.Context)

message handler

func (*P2PActor) Start

func (this *P2PActor) Start() (*actor.PID, error)

start a actor called net_server

type StopServerReq

type StopServerReq struct {
}

stop net server

type StopServerRsp

type StopServerRsp struct {
}

response of stop request

type TransmitConsensusMsgReq

type TransmitConsensusMsgReq struct {
	Target uint64
	Msg    ptypes.Message
}