segfetcher

type DefaultRequester struct {
	API         RequestAPI
	DstProvider DstProvider
}

type DefaultResolver struct {
	DB         pathdb.Read
	RevCache   revcache.RevCache
	IgnoreRevs bool
}

type DstProvider interface {
	Dst(context.Context, Request) (net.Addr, error)
}

type Fetcher struct {
	Validator             Validator
	Splitter              Splitter
	Resolver              Resolver
	Requester             Requester
	ReplyHandler          ReplyHandler
	PathDB                pathdb.PathDB
	QueryInterval         time.Duration
	NextQueryCleaner      NextQueryCleaner
	CryptoLookupAtLocalCS bool
	// contains filtered or unexported fields
}

type FetcherConfig struct {
	// QueryInterval specifies after how much time segments should be
	// refetched at the remote server.
	QueryInterval time.Duration
	// LocalIA is the IA this process is in.
	LocalIA addr.IA
	// VerificationFactory is the verification factory to use.
	VerificationFactory infra.VerificationFactory
	// ASInspector is the as inspector to use.
	ASInspector infra.ASInspector
	// PathDB is the path db to use.
	PathDB pathdb.PathDB
	// RevCache is the revocation cache to use.
	RevCache revcache.RevCache
	// RequestAPI is the request api to use.
	RequestAPI RequestAPI
	// DstProvider provides destinations to fetch segments from
	DstProvider DstProvider
	// Validator is used to validate requests.
	Validator Validator
	// Splitter is used to split requests.
	Splitter Splitter
	// SciondMode enables sciond mode, this means it uses the local CS to fetch
	// crypto material and considers revocations in the path lookup.
	SciondMode bool
	// The namespace used for metrics.
	MetricsNamespace string
}

type NextQueryCleaner struct {
	PathDB pathdb.PathDB
}

type ReplyHandler interface {
	Handle(ctx context.Context, recs seghandler.Segments, server net.Addr,
		earlyTrigger <-chan struct{}) *seghandler.ProcessedResult
}

type ReplyOrErr struct {
	Req   Request
	Reply *path_mgmt.SegReply
	Peer  net.Addr
	Err   error
}

type Request struct {
	Src   addr.IA
	Dst   addr.IA
	State RequestState
}

type RequestAPI interface {
	GetSegs(ctx context.Context, msg *path_mgmt.SegReq, a net.Addr,
		id uint64) (*path_mgmt.SegReply, error)
}

type RequestSet struct {
	Up    Request
	Cores Requests
	Down  Request
}

type RequestState int

type Requester interface {
	Request(ctx context.Context, req RequestSet) <-chan ReplyOrErr
}

type Requests []Request

type Resolver interface {
	// Resolve resolves a request set. It returns the segments that are locally
	// stored and the set of requests that have to be requested at a remote server.
	Resolve(ctx context.Context, segs Segments, req RequestSet) (Segments, RequestSet, error)
}

type Segments struct {
	Up   seg.Segments
	Core seg.Segments
	Down seg.Segments
}

type Splitter interface {
	// Split splits the request into a request set. Assumes that the request
	// has been validated for the local IA.
	Split(ctx context.Context, r Request) (RequestSet, error)
}

type Validator interface {
	// Validate should return an error if the given request is not valid.
	Validate(ctx context.Context, r Request) error
}