onet

package module

Go to main page

Versions in this module

v3

v3.2.10

Aug 25, 2021

Changes in this version

type Client

+ HandshakeTimeout time.Duration

+ ReadTimeout time.Duration

v3.2.9

Apr 27, 2021

Changes in this version

type StreamingConn

+ func (c *StreamingConn) Ping(data []byte, deadline time.Time) error

+ func (c *StreamingConn) ReadMessageWithOpts(ret interface{}, opts StreamingReadOpts) error

+ type StreamingReadOpts struct

+ Deadline time.Time

v3.2.8

Apr 15, 2021

v3.2.7

Mar 24, 2021

v3.2.6

Nov 9, 2020

v3.2.5

Aug 18, 2020

v3.2.4

Jun 24, 2020

Changes in this version

+ const AggregateMessages

+ const DefaultChannelLength

+ const Local

+ const SimulationFileName

+ const TCP

+ var ConfigMsgID = network.RegisterMessage(ConfigMsg{})

+ var ErrProtocolRegistered = xerrors.New("a ProtocolInstance already has been registered using this TreeNodeInstance")

+ var ErrWrongTreeNodeInstance = xerrors.New("This TreeNodeInstance doesn't exist")

+ var NilServiceID = ServiceID(uuid.Nil)

+ var ProtocolMsgID = network.RegisterMessage(ProtocolMsg{})

+ var RequestRosterMsgID = network.RegisterMessage(RequestRoster{})

+ var RequestTreeMsgID = network.RegisterMessage(RequestTree{})

+ var ResponseTreeMsgID = network.RegisterMessage(ResponseTree{})

+ var RosterTypeID = network.RegisterMessage(Roster{})

+ var SendRosterMsgID = RosterTypeID

+ var SendTreeMsgID = TreeMarshalTypeID

+ var ServiceFactory = serviceFactory

+ var TreeMarshalTypeID = network.RegisterMessage(TreeMarshal{})

+ func InformAllServersStopped()

+ func InformServerStarted()

+ func NewPrivIdentity(suite network.Suite, port int) (kyber.Scalar, *network.ServerIdentity)

+ func ReadTomlConfig(conf interface{}, filename string, dirOpt ...string) error

+ func RegisterMessageProxy(n NewMessageProxy)

+ func SimulationRegister(name string, sim simulationCreate)

+ func UnregisterService(name string) error

+ func WriteTomlConfig(conf interface{}, filename string, dirOpt ...string)

+ type BidirectionalStreamer interface

+ IsStreaming func(path string) (bool, error)

+ ProcessClientStreamRequest func(req *http.Request, path string, clientInputs chan []byte) (chan []byte, error)

+ type CertificateReloader struct

+ func NewCertificateReloader(certPath, keyPath string) (*CertificateReloader, error)

+ func (cr *CertificateReloader) GetCertificateFunc() func(*tls.ClientHelloInfo) (*tls.Certificate, error)

+ type Client struct

+ TLSClientConfig *tls.Config

+ func NewClient(suite network.Suite, s string) *Client

+ func NewClientKeep(suite network.Suite, s string) *Client

+ func (c *Client) Close() error

+ func (c *Client) Rx() uint64

+ func (c *Client) Send(dst *network.ServerIdentity, path string, buf []byte) ([]byte, error)

+ func (c *Client) SendProtobuf(dst *network.ServerIdentity, msg interface{}, ret interface{}) error

+ func (c *Client) SendProtobufParallel(nodes []*network.ServerIdentity, msg interface{}, ret interface{}, ...) (*network.ServerIdentity, error)

+ func (c *Client) SendProtobufParallelWithDecoder(nodes []*network.ServerIdentity, msg interface{}, ret interface{}, ...) (*network.ServerIdentity, error)

+ func (c *Client) SendToAll(dst *Roster, path string, buf []byte) ([][]byte, error)

+ func (c *Client) Stream(dst *network.ServerIdentity, msg interface{}) (StreamingConn, error)

+ func (c *Client) Suite() network.Suite

+ func (c *Client) Tx() uint64

+ type ConfigMsg struct

+ Config GenericConfig

+ Dest TokenID

+ type Context struct

+ func (c *Context) CreateProtocol(name string, t *Tree) (ProtocolInstance, error)

+ func (c *Context) GetAdditionalBucket(name []byte) (*bbolt.DB, []byte)

+ func (c *Context) GetValidPeers(peerID network.PeerSetID) []...

+ func (c *Context) Load(key []byte) (interface{}, error)

+ func (c *Context) LoadRaw(key []byte) ([]byte, error)

+ func (c *Context) LoadVersion() (int, error)

+ func (c *Context) NewPeerSetID(data []byte) network.PeerSetID

+ func (c *Context) NewTreeNodeInstance(t *Tree, tn *TreeNode, protoName string) *TreeNodeInstance

+ func (c *Context) ProtocolRegister(name string, protocol NewProtocol) (ProtocolID, error)

+ func (c *Context) RegisterMessageProxy(m MessageProxy)

+ func (c *Context) RegisterProcessor(p network.Processor, msgType network.MessageTypeID)

+ func (c *Context) RegisterProcessorFunc(msgType network.MessageTypeID, fn func(*network.Envelope) error)

+ func (c *Context) RegisterProtocolInstance(pi ProtocolInstance) error

+ func (c *Context) RegisterStatusReporter(name string, s StatusReporter)

+ func (c *Context) ReportStatus() map[string]*Status

+ func (c *Context) Save(key []byte, data interface{}) error

+ func (c *Context) SaveVersion(version int) error

+ func (c *Context) SendRaw(si *network.ServerIdentity, msg interface{}) error

+ func (c *Context) ServerIdentity() *network.ServerIdentity

+ func (c *Context) Service(name string) Service

+ func (c *Context) ServiceID() ServiceID

+ func (c *Context) SetValidPeers(peerID network.PeerSetID, peers []*network.ServerIdentity)

+ func (c *Context) String() string

+ func (c *Context) Suite() network.Suite

+ type ContextDB interface

+ Load func(key []byte) (interface{}, error)

+ LoadRaw func(key []byte) ([]byte, error)

+ LoadVersion func() (int, error)

+ SaveVersion func(version int) error

+ type Decoder func(data []byte, ret interface{}) error

+ type GenericConfig struct

+ Data []byte

+ type LeakyTestCheck int

+ const CheckAll

+ const CheckGoroutines

+ const CheckNone

+ type LocalTest struct

+ Check LeakyTestCheck

+ Nodes []*TreeNodeInstance

+ Overlays map[network.ServerIdentityID]*Overlay

+ Servers map[network.ServerIdentityID]*Server

+ Services map[network.ServerIdentityID]map[ServiceID]Service

+ Suite network.Suite

+ T *testing.T

+ Trees map[TreeID]*Tree

+ func NewLocalTest(s network.Suite) *LocalTest

+ func NewLocalTestT(s network.Suite, t *testing.T) *LocalTest

+ func NewTCPTest(s network.Suite) *LocalTest

+ func NewTCPTestWithTLS(s network.Suite, wsTLSCertificate []byte, wsTLSCertificateKey []byte) *LocalTest

+ func (l *LocalTest) CloseAll()

+ func (l *LocalTest) CreateProtocol(name string, t *Tree) (ProtocolInstance, error)

+ func (l *LocalTest) GenBigTree(nbrTreeNodes, nbrServers, bf int, register bool) ([]*Server, *Roster, *Tree)

+ func (l *LocalTest) GenRosterFromHost(servers ...*Server) *Roster

+ func (l *LocalTest) GenServers(n int) []*Server

+ func (l *LocalTest) GenTree(n int, register bool) ([]*Server, *Roster, *Tree)

+ func (l *LocalTest) GetPrivate(c *Server) kyber.Scalar

+ func (l *LocalTest) GetServices(servers []*Server, sid ServiceID) []Service

+ func (l *LocalTest) GetTreeNodeInstances(id network.ServerIdentityID) []*TreeNodeInstance

+ func (l *LocalTest) MakeSRS(s network.Suite, nbr int, sid ServiceID) ([]*Server, *Roster, Service)

+ func (l *LocalTest) NewClient(serviceName string) *Client

+ func (l *LocalTest) NewClientKeep(serviceName string) *Client

+ func (l *LocalTest) NewLocalServer(s network.Suite, port int) *Server

+ func (l *LocalTest) NewServer(s network.Suite, port int) *Server

+ func (l *LocalTest) NewTreeNodeInstance(tn *TreeNode, protName string) (*TreeNodeInstance, error)

+ func (l *LocalTest) StartProtocol(name string, t *Tree) (ProtocolInstance, error)

+ func (l *LocalTest) WaitDone(t time.Duration) error

+ type MessageProxy interface

+ Name func() string

+ PacketType func() network.MessageTypeID

+ Unwrap func(msg interface{}) (interface{}, *OverlayMsg, error)

+ Wrap func(msg interface{}, info *OverlayMsg) (interface{}, error)

+ type MsgHandler func([]*interface{})

+ type NewMessageProxy func() MessageProxy

+ type NewProtocol func(*TreeNodeInstance) (ProtocolInstance, error)

+ type NewServiceFunc func(c *Context) (Service, error)

+ type Overlay struct

+ func NewOverlay(c *Server) *Overlay

+ func (o *Overlay) Close()

+ func (o *Overlay) CreateProtocol(name string, t *Tree, sid ServiceID) (ProtocolInstance, error)

+ func (o *Overlay) NewTreeNodeInstanceFromProtoName(t *Tree, name string) *TreeNodeInstance

+ func (o *Overlay) NewTreeNodeInstanceFromProtocol(t *Tree, tn *TreeNode, protoID ProtocolID, io MessageProxy) *TreeNodeInstance

+ func (o *Overlay) NewTreeNodeInstanceFromService(t *Tree, tn *TreeNode, protoID ProtocolID, servID ServiceID, io MessageProxy) *TreeNodeInstance

+ func (o *Overlay) Process(env *network.Envelope)

+ func (o *Overlay) RegisterMessageProxy(m MessageProxy)

+ func (o *Overlay) RegisterProtocolInstance(pi ProtocolInstance) error

+ func (o *Overlay) RegisterTree(t *Tree)

+ func (o *Overlay) Rx() uint64

+ func (o *Overlay) SendToTreeNode(from *Token, to *TreeNode, msg network.Message, io MessageProxy, ...) (uint64, error)

+ func (o *Overlay) ServerIdentity() *network.ServerIdentity

+ func (o *Overlay) StartProtocol(name string, t *Tree, sid ServiceID) (ProtocolInstance, error)

+ func (o *Overlay) TransmitMsg(onetMsg *ProtocolMsg, io MessageProxy) error

+ func (o *Overlay) TreeNodeFromToken(t *Token) (*TreeNode, error)

+ func (o *Overlay) TreeNodeFromTree(tree *Tree, id TreeNodeID) (*TreeNode, error)

+ func (o *Overlay) Tx() uint64

+ type OverlayMsg struct

+ Config *GenericConfig

+ RequestRoster *RequestRoster

+ RequestTree *RequestTree

+ ResponseTree *ResponseTree

+ Roster *Roster

+ TreeMarshal *TreeMarshal

+ TreeNodeInfo *TreeNodeInfo

+ type ParallelOptions struct

+ AskNodes int

+ DontShuffle bool

+ IgnoreNodes []*network.ServerIdentity

+ Parallel int

+ QuitError bool

+ StartNode int

+ func (po *ParallelOptions) GetList(nodes []*network.ServerIdentity) (parallel int, nodesChan chan *network.ServerIdentity)

+ func (po *ParallelOptions) Quit() bool

+ type ProtocolID uuid.UUID

+ func GlobalProtocolRegister(name string, protocol NewProtocol) (ProtocolID, error)

+ func ProtocolNameToID(name string) ProtocolID

+ func (pid ProtocolID) Equal(pid2 ProtocolID) bool

+ func (pid ProtocolID) IsNil() bool

+ func (pid ProtocolID) String() string

+ type ProtocolInstance interface

+ Dispatch func() error

+ ProcessProtocolMsg func(*ProtocolMsg)

+ Shutdown func() error

+ Start func() error

+ Token func() *Token

+ type ProtocolMsg struct

+ Config *GenericConfig

+ From *Token

+ Msg network.Message

+ MsgSlice []byte

+ MsgType network.MessageTypeID

+ ServerIdentity *network.ServerIdentity

+ Size network.Size

+ To *Token

+ type RequestRoster struct

+ RosterID RosterID

+ type RequestTree struct

+ TreeID TreeID

+ Version uint32

+ type ResponseTree struct

+ Roster *Roster

+ TreeMarshal *TreeMarshal

+ type Roster struct

+ Aggregate kyber.Point

+ ID RosterID

+ List []*network.ServerIdentity

+ func NewRoster(ids []*network.ServerIdentity) *Roster

+ func (ro *Roster) Concat(sis ...*network.ServerIdentity) *Roster

+ func (ro *Roster) Contains(pubs []kyber.Point) bool

+ func (ro *Roster) Equal(other *Roster) (bool, error)

+ func (ro *Roster) GenerateBigNaryTree(N, nodes int) *Tree

+ func (ro *Roster) GenerateBinaryTree() *Tree

+ func (ro *Roster) GenerateNaryTree(N int) *Tree

+ func (ro *Roster) GenerateNaryTreeWithRoot(N int, root *network.ServerIdentity) *Tree

+ func (ro *Roster) GenerateStar() *Tree

+ func (ro *Roster) Get(idx int) *network.ServerIdentity

+ func (ro *Roster) GetID() (RosterID, error)

+ func (ro *Roster) NewRosterWithRoot(root *network.ServerIdentity) *Roster

+ func (ro *Roster) Publics() []kyber.Point

+ func (ro *Roster) RandomServerIdentity() *network.ServerIdentity

+ func (ro *Roster) RandomSubset(root *network.ServerIdentity, n int) *Roster

+ func (ro *Roster) Search(eID network.ServerIdentityID) (int, *network.ServerIdentity)

+ func (ro *Roster) ServicePublics(name string) []kyber.Point

+ func (ro *Roster) Toml(suite network.Suite) *RosterToml

+ func (ro Roster) IsRotation(target *Roster) bool

+ func (ro Roster) ServiceAggregate(name string) (kyber.Point, error)

+ type RosterID uuid.UUID

+ func (roID RosterID) Equal(roID2 RosterID) bool

+ func (roID RosterID) IsNil() bool

+ func (roID RosterID) String() string

+ type RosterToml struct

+ ID RosterID

+ List []*network.ServerIdentityToml

+ func (rot *RosterToml) Roster(suite network.Suite) *Roster

+ type RosterUnknown struct

+ type RoundID uuid.UUID

+ func (rId RoundID) Equal(rID2 RoundID) bool

+ func (rId RoundID) IsNil() bool

+ func (rId RoundID) String() string

+ type Server struct

+ IsStarted bool

+ WebSocket *WebSocket

+ func NewLocalServer(s network.Suite, port int) *Server

+ func NewServerTCP(e *network.ServerIdentity, suite network.Suite) *Server

+ func NewServerTCPWithListenAddr(e *network.ServerIdentity, suite network.Suite, listenAddr string) *Server

+ func (c *Server) Address() network.Address

+ func (c *Server) Close() error

+ func (c *Server) GetService(name string) Service

+ func (c *Server) GetStatus() *Status

+ func (c *Server) ProtocolRegister(name string, protocol NewProtocol) (ProtocolID, error)

+ func (c *Server) Service(name string) Service

+ func (c *Server) Start()

+ func (c *Server) StartInBackground()

+ func (c *Server) Suite() network.Suite

+ func (c *Server) WaitStartup()

+ type Service interface

+ NewProtocol func(*TreeNodeInstance, *GenericConfig) (ProtocolInstance, error)

+ ProcessClientRequest func(req *http.Request, handler string, msg []byte) (reply []byte, tunnel *StreamingTunnel, err error)

+ type ServiceID uuid.UUID

+ func RegisterNewService(name string, fn NewServiceFunc) (ServiceID, error)

+ func RegisterNewServiceWithSuite(name string, suite suites.Suite, fn NewServiceFunc) (ServiceID, error)

+ func (s ServiceID) Equal(s2 ServiceID) bool

+ func (s ServiceID) IsNil() bool

+ func (s ServiceID) String() string

+ type ServiceProcessor struct

+ func NewServiceProcessor(c *Context) *ServiceProcessor

+ func (p *ServiceProcessor) IsStreaming(path string) (bool, error)

+ func (p *ServiceProcessor) NewProtocol(tn *TreeNodeInstance, conf *GenericConfig) (ProtocolInstance, error)

+ func (p *ServiceProcessor) Process(env *network.Envelope)

+ func (p *ServiceProcessor) ProcessClientRequest(req *http.Request, path string, buf []byte) ([]byte, *StreamingTunnel, error)

+ func (p *ServiceProcessor) ProcessClientStreamRequest(req *http.Request, path string, clientInputs chan []byte) (chan []byte, error)

+ func (p *ServiceProcessor) RegisterHandler(f interface{}) error

+ func (p *ServiceProcessor) RegisterHandlers(procs ...interface{}) error

+ func (p *ServiceProcessor) RegisterRESTHandler(f interface{}, namespace, method string, minVersion, maxVersion int) error

+ func (p *ServiceProcessor) RegisterStreamingHandler(f interface{}) error

+ func (p *ServiceProcessor) RegisterStreamingHandlers(procs ...interface{}) error

+ type Simulation interface

+ Node func(config *SimulationConfig) error

+ Run func(config *SimulationConfig) error

+ Setup func(dir string, hosts []string) (*SimulationConfig, error)

+ func NewSimulation(name string, conf string) (Simulation, error)

+ type SimulationBFTree struct

+ BF int

+ Depth int

+ Hosts int

+ PreScript string

+ Rounds int

+ SingleHost bool

+ Suite string

+ TLS bool

+ func (s *SimulationBFTree) CreateRoster(sc *SimulationConfig, addresses []string, port int)

+ func (s *SimulationBFTree) CreateTree(sc *SimulationConfig) error

+ func (s *SimulationBFTree) Node(sc *SimulationConfig) error

+ type SimulationConfig struct

+ Config string

+ Overlay *Overlay

+ PrivateKeys map[network.Address]*SimulationPrivateKey

+ Roster *Roster

+ Server *Server

+ TLS bool

+ Tree *Tree

+ func LoadSimulationConfig(s, dir, ca string) ([]*SimulationConfig, error)

+ func (sc *SimulationConfig) GetService(name string) Service

+ func (sc *SimulationConfig) Save(dir string) error

+ func (sc SimulationConfig) GetSingleHost() bool

+ type SimulationConfigFile struct

+ Config string

+ PrivateKeys map[network.Address]*SimulationPrivateKey

+ Roster *Roster

+ TLS bool

+ TreeMarshal *TreeMarshal

+ type SimulationPrivateKey struct

+ Private kyber.Scalar

+ Services []kyber.Scalar

+ type Status struct

+ Field map[string]string

+ type StatusReporter interface

+ GetStatus func() *Status

+ type StreamingConn struct

+ func (c *StreamingConn) ReadMessage(ret interface{}) error

+ type StreamingTunnel struct

+ type TestClose interface

+ TestClose func()

+ type Token struct

+ ProtoID ProtocolID

+ RosterID RosterID

+ RoundID RoundID

+ ServiceID ServiceID

+ TreeID TreeID

+ TreeNodeID TreeNodeID

+ func (t *Token) ChangeTreeNodeID(newid TreeNodeID) *Token

+ func (t *Token) Clone() *Token

+ func (t *Token) ID() TokenID

+ type TokenID uuid.UUID

+ func (t TokenID) Equal(t2 TokenID) bool

+ func (t TokenID) IsNil() bool

+ func (t TokenID) String() string

+ type Tree struct

+ ID TreeID

+ Root *TreeNode

+ Roster *Roster

+ func NewTree(roster *Roster, root *TreeNode) *Tree

+ func NewTreeFromMarshal(s network.Suite, buf []byte, el *Roster) (*Tree, error)

+ func (t *Tree) BinaryMarshaler() ([]byte, error)

+ func (t *Tree) BinaryUnmarshaler(s network.Suite, b []byte) error

+ func (t *Tree) Dump() string

+ func (t *Tree) Equal(t2 *Tree) bool

+ func (t *Tree) IsBinary(root *TreeNode) bool

+ func (t *Tree) IsNary(root *TreeNode, N int) bool

+ func (t *Tree) List() (ret []*TreeNode)

+ func (t *Tree) MakeTreeMarshal() *TreeMarshal

+ func (t *Tree) Marshal() ([]byte, error)

+ func (t *Tree) Search(tn TreeNodeID) (ret *TreeNode)

+ func (t *Tree) Size() int

+ func (t *Tree) String() string

+ func (t *Tree) UsesList() bool

+ type TreeID uuid.UUID

+ func (tId TreeID) Equal(tID2 TreeID) bool

+ func (tId TreeID) Equals(tID2 TreeID) bool

+ func (tId TreeID) IsNil() bool

+ func (tId TreeID) String() string

+ type TreeMarshal struct

+ Children []*TreeMarshal

+ RosterID RosterID

+ ServerIdentityID network.ServerIdentityID

+ TreeID TreeID

+ TreeNodeID TreeNodeID

+ func TreeMarshalCopyTree(tr *TreeNode) *TreeMarshal

+ func (tm *TreeMarshal) MakeTreeFromList(parent *TreeNode, ro *Roster) (*TreeNode, error)

+ func (tm *TreeMarshal) String() string

+ func (tm TreeMarshal) MakeTree(ro *Roster) (*Tree, error)

+ type TreeNode struct

+ Children []*TreeNode

+ ID TreeNodeID

+ Parent *TreeNode

+ PublicAggregateSubTree kyber.Point

+ RosterIndex int

+ ServerIdentity *network.ServerIdentity

+ func NewTreeNode(entityIdx int, ni *network.ServerIdentity) *TreeNode

+ func (t *TreeNode) AddChild(c *TreeNode)

+ func (t *TreeNode) AggregatePublic(s network.Suite) kyber.Point

+ func (t *TreeNode) Equal(t2 *TreeNode) bool

+ func (t *TreeNode) IsConnectedTo(si *network.ServerIdentity) bool

+ func (t *TreeNode) IsInTree(tree *Tree) bool

+ func (t *TreeNode) IsLeaf() bool

+ func (t *TreeNode) IsRoot() bool

+ func (t *TreeNode) Name() string

+ func (t *TreeNode) String() string

+ func (t *TreeNode) SubtreeCount() int

+ func (t *TreeNode) Visit(firstDepth int, fn func(depth int, n *TreeNode))

+ type TreeNodeID uuid.UUID

+ func (tId TreeNodeID) Equal(tID2 TreeNodeID) bool

+ func (tId TreeNodeID) IsNil() bool

+ func (tId TreeNodeID) String() string

+ type TreeNodeInfo struct

+ From *Token

+ To *Token

+ type TreeNodeInstance struct

+ func (n *TreeNodeInstance) Aggregate() kyber.Point

+ func (n *TreeNodeInstance) Broadcast(msg interface{}) []error

+ func (n *TreeNodeInstance) Children() []*TreeNode

+ func (n *TreeNodeInstance) CloseHost() error

+ func (n *TreeNodeInstance) CreateProtocol(name string, t *Tree) (ProtocolInstance, error)

+ func (n *TreeNodeInstance) Dispatch() error

+ func (n *TreeNodeInstance) Done()

+ func (n *TreeNodeInstance) Host() *Server

+ func (n *TreeNodeInstance) Index() int

+ func (n *TreeNodeInstance) Info() string

+ func (n *TreeNodeInstance) IsLeaf() bool

+ func (n *TreeNodeInstance) IsRoot() bool

+ func (n *TreeNodeInstance) List() []*TreeNode

+ func (n *TreeNodeInstance) Multicast(msg interface{}, nodes ...*TreeNode) []error

+ func (n *TreeNodeInstance) Name() string

+ func (n *TreeNodeInstance) NodePublic(si *network.ServerIdentity) kyber.Point

+ func (n *TreeNodeInstance) OnDoneCallback(fn func() bool)

+ func (n *TreeNodeInstance) Parent() *TreeNode

+ func (n *TreeNodeInstance) Private() kyber.Scalar

+ func (n *TreeNodeInstance) ProcessProtocolMsg(msg *ProtocolMsg)

+ func (n *TreeNodeInstance) ProtocolInstance() ProtocolInstance

+ func (n *TreeNodeInstance) ProtocolName() string

+ func (n *TreeNodeInstance) Public() kyber.Point

+ func (n *TreeNodeInstance) Publics() []kyber.Point

+ func (n *TreeNodeInstance) RegisterChannel(c interface{}) error

+ func (n *TreeNodeInstance) RegisterChannelLength(c interface{}, length int) error

+ func (n *TreeNodeInstance) RegisterChannels(channels ...interface{}) error

+ func (n *TreeNodeInstance) RegisterChannelsLength(length int, channels ...interface{}) error

+ func (n *TreeNodeInstance) RegisterHandler(c interface{}) error

+ func (n *TreeNodeInstance) RegisterHandlers(handlers ...interface{}) error

+ func (n *TreeNodeInstance) Root() *TreeNode

+ func (n *TreeNodeInstance) Roster() *Roster

+ func (n *TreeNodeInstance) Rx() uint64

+ func (n *TreeNodeInstance) SendTo(to *TreeNode, msg interface{}) error

+ func (n *TreeNodeInstance) SendToChildren(msg interface{}) error

+ func (n *TreeNodeInstance) SendToChildrenInParallel(msg interface{}) []error

+ func (n *TreeNodeInstance) SendToParent(msg interface{}) error

+ func (n *TreeNodeInstance) ServerIdentity() *network.ServerIdentity

+ func (n *TreeNodeInstance) SetConfig(c *GenericConfig) error

+ func (n *TreeNodeInstance) Shutdown() error

+ func (n *TreeNodeInstance) Suite() network.Suite

+ func (n *TreeNodeInstance) Token() *Token

+ func (n *TreeNodeInstance) TokenID() TokenID

+ func (n *TreeNodeInstance) Tree() *Tree

+ func (n *TreeNodeInstance) TreeNode() *TreeNode

+ func (n *TreeNodeInstance) TreeNodeInstance() *TreeNodeInstance

+ func (n *TreeNodeInstance) Tx() uint64

+ type WebSocket struct

+ TLSConfig *tls.Config

+ func NewWebSocket(si *network.ServerIdentity) *WebSocket

+ func (w *WebSocket) Listening() bool

v3.2.3

Jun 8, 2020

v3.2.2

May 25, 2020

v3.2.0

Mar 18, 2020

v3.0.26

Oct 9, 2019

v3.0.19

Jul 11, 2019

v3.0.14

May 23, 2019

v3.0.1

Mar 15, 2019

Other modules containing this package

go.dedis.ch/onet/v4

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