network

type Aborter interface {
	// Abort forces to stop all node components
	Abort(ctx context.Context, reason string)
}

type AborterMock struct {
	AbortMock mAborterMockAbort
	// contains filtered or unexported fields
}

type AborterMockAbortExpectation struct {
	Counter uint64
	// contains filtered or unexported fields
}

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

type Auther interface {
	// GetCert returns certificate object by node reference, using discovery nodes for signing
	GetCert(context.Context, reference.Global) (nodeinfo.Certificate, error)
	// ValidateCert checks certificate signature
	// TODO make this cert.validate()
	ValidateCert(context.Context, nodeinfo.AuthorizationCertificate) (bool, error)
}

type BootstrapResult struct {
	Host *legacyhost.Host
	// FirstPulseTime    time.Time
	ReconnectRequired bool
	NetworkSize       int
}

type Bootstrapper interface {
	HandleNodeAuthorizeRequest(context.Context, Packet) (Packet, error)
	HandleNodeBootstrapRequest(context.Context, Packet) (Packet, error)
	HandleUpdateSchedule(context.Context, Packet) (Packet, error)
	HandleReconnect(context.Context, Packet) (Packet, error)
}

type CapturingReader struct {
	io.Reader
	// contains filtered or unexported fields
}

type Future interface {
	Request() Packet
	Response() <-chan ReceivedPacket
	WaitResponse(duration time.Duration) (ReceivedPacket, error)
	Cancel()
}

type Gateway interface {
	NewGateway(context.Context, State) Gateway

	Run(context.Context, pulse.Data)

	GetState() State

	OnPulseFromConsensus(context.Context, NetworkedPulse)
	OnConsensusFinished(context.Context, Report)

	UpdateState(context.Context, beat.Beat)

	RequestNodeState(chorus.NodeStateFunc)
	CancelNodeState()

	Auther() Auther
	Bootstrapper() Bootstrapper

	EphemeralMode(census.OnlinePopulation) bool

	FailState(ctx context.Context, reason string)
}

type Gatewayer interface {
	Gateway() Gateway
	SwitchState(context.Context, State, pulse.Data)
}

type HostNetwork interface {
	component.Starter
	component.Stopper

	// PublicAddress returns public address that can be published for all nodes.
	PublicAddress() string

	// SendRequest send request to a remote node addressed by reference.
	SendRequest(ctx context.Context, t types.PacketType, requestData interface{}, receiver reference.Global) (Future, error)
	// SendRequestToHost send request packet to a remote host.
	SendRequestToHost(ctx context.Context, t types.PacketType, requestData interface{}, receiver *legacyhost.Host) (Future, error)
	// RegisterRequestHandler register a handler function to process incoming requests of a specific type.
	// All RegisterRequestHandler calls should be executed before Start.
	RegisterRequestHandler(t types.PacketType, handler RequestHandler)
	// BuildResponse create response to an incoming request with Data set to responseData.
	BuildResponse(ctx context.Context, request Packet, responseData interface{}) Packet
}

type NetworkedPulse = beat.Beat

type OnConsensusFinished func(ctx context.Context, report Report)

type Options struct {
	// The maximum time to wait for a response to any packet.
	PacketTimeout time.Duration

	// The maximum time to wait for a response to ack packet.
	AckPacketTimeout time.Duration

	// Bootstrap ETA for join the Insolar network
	BootstrapTimeout time.Duration

	// Min bootstrap retry timeout
	MinTimeout time.Duration

	// Max bootstrap retry timeout
	MaxTimeout time.Duration

	// Multiplier for boostrap retry time
	TimeoutMult time.Duration

	// The maximum time to wait for a new pulse
	PulseWatchdogTimeout time.Duration
}

type Packet interface {
	GetSender() reference.Global
	GetSenderHost() *legacyhost.Host
	GetType() types.PacketType
	GetRequest() *rms.Request
	GetResponse() *rms.Response
	GetRequestID() types.RequestID
	String() string
}

type ReceivedPacket interface {
	Packet
	Bytes() []byte
}

type Report struct {
	PulseData       pulse.Data
	PulseNumber     pulse.Number
	MemberPower     member.Power
	MemberMode      member.OpMode
	IsJoiner        bool
	PopulationValid bool
}

type RequestHandler func(ctx context.Context, request ReceivedPacket) (response Packet, err error)

type RoutingTable interface {
	// Resolve NodeID -> ShortID, Address. Can initiate network requests.
	Resolve(reference.Global) (*legacyhost.Host, error)
}

type State int

type Status interface {
	GetNetworkStatus() StatusReply
}

type StatusReply struct {
	NetworkState    State
	LocalRef        reference.Holder
	LocalRole       member.PrimaryRole
	LocalNode       nodeinfo.NetworkNode
	ActiveListSize  int
	WorkingListSize int
	// Nodes from active list
	Nodes     []nodeinfo.NetworkNode
	Version   string
	Timestamp time.Time
	// node start timestamp for uptime duration
	StartTime time.Time

	PulseNumber pulse.Number
}

type TerminationHandler interface {
	// Leave locks until network accept leaving claim
	Leave(context.Context, pulse.Number)
	OnLeaveApproved(context.Context)
	// Terminating is an accessor
	Terminating() bool
}

type TerminationHandlerMock struct {
	LeaveMock mTerminationHandlerMockLeave

	OnLeaveApprovedMock mTerminationHandlerMockOnLeaveApproved

	TerminatingMock mTerminationHandlerMockTerminating
	// contains filtered or unexported fields
}

type TerminationHandlerMockLeaveExpectation struct {
	Counter uint64
	// contains filtered or unexported fields
}

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

type TerminationHandlerMockOnLeaveApprovedExpectation struct {
	Counter uint64
	// contains filtered or unexported fields
}

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

type TerminationHandlerMockTerminatingExpectation struct {
	Counter uint64
	// contains filtered or unexported fields
}

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