transport

type ConnectionManager interface {
	core.Diagnosable

	// Connect attempts to make an outbound connection to the given peer, after the delay has expired.
	// If the delay is 0 it will immediately start connecting. It will take the existing backoff into account when it is nil.
	Connect(peerAddress string, peerDID did.DID, delay *time.Duration)

	// Peers returns a slice containing the peers that are currently connected.
	Peers() []Peer

	// Contacts returns a slice containing the contacts that are currently known (to which we try to connect).
	Contacts() []Contact

	// RegisterObserver allows to register a callback function for stream state changes
	RegisterObserver(callback StreamStateObserverFunc)

	// Start instructs the ConnectionManager to start accepting connections and prepare to make outbound connections.
	Start() error

	// Stop shuts down the connections made by the ConnectionManager.
	Stop()
}

type Contact struct {
	// Address holds the target address the connector is connecting to.
	Address string
	// DID holds the target DID for the given Address. Is empty for bootstrap nodes
	DID did.DID
	// Attempts holds the number of times the node tried to connect to the peer.
	Attempts uint32
	// LastAttempt holds the time of the last connection attempt.
	LastAttempt *time.Time
	// NextAttempt holds the time of the next connection attempt.
	NextAttempt *time.Time
	// Error holds the errors that occurred during the connection attempts.
	Error *string
}

type Diagnostics struct {
	// Uptime the uptime (time since the node started) in seconds.
	Uptime time.Duration `json:"uptime"`
	// Peers contains the peer IDs of the node's peers.
	Peers []PeerID `json:"peers"`
	// NumberOfTransactions contains the total number of transactions on the node's DAG.
	NumberOfTransactions uint32 `json:"transactionNum"`
	// SoftwareVersion contains an indication of the software version of the node. It's recommended to use a (Git) commit ID that uniquely resolves to a code revision, alternatively a semantic version could be used (e.g. 1.2.5).
	SoftwareVersion string `json:"softwareVersion"`
	// SoftwareID contains an indication of the vendor of the software of the node. For open source implementations it's recommended to specify URL to the public, open source repository.
	// Proprietary implementations could specify the product's or vendor's name.
	SoftwareID string `json:"softwareID"`
	// Certificate contains the certificate presented by the peer during the TLS handshake.
	Certificate string `json:"certificate"`
	// NodeDID of the connection.
	NodeDID string `json:"nodeDID"`
	// Address is NutsComm on outbound, or IP for inbound connections.
	Address string `json:"address"`
}

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

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

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

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

type NutsCommURL struct {
	url.URL
}

type Peer struct {
	// ID holds the unique identifier of the peer
	ID PeerID `json:"id"`
	// Address holds the remote address of the node we're actually connected to
	Address string `json:"address"`
	// NodeDID holds the DID that the peer uses to identify its node on the network.
	// If Authenticated is true the NodeDID is verified.
	NodeDID did.DID `json:"nodedid"`
	// Authenticated is true when NodeDID is set and authentication is successful.
	Authenticated bool `json:"authenticated"`
	// Certificate presented by peer during TLS handshake.
	Certificate *x509.Certificate `json:"-" yaml:"-"`
}

type PeerID string

type Protocol interface {
	// Configure configures the Protocol implementation, must be called before Start().
	Configure(peerID PeerID) error
	// Start starts the Protocol implementation.
	Start() error
	// Stop stops the Protocol implementation.
	Stop()
	// Diagnostics collects and returns diagnostical information on the protocol.
	Diagnostics() []core.DiagnosticResult
	// PeerDiagnostics collects and returns diagnostical information on the peers the protocol is communicating with.
	PeerDiagnostics() map[PeerID]Diagnostics
	// Version returns the version of the protocol
	Version() int
}

type StreamState string

type StreamStateObserverFunc func(peer Peer, state StreamState, protocol Protocol)