segfetcher

Documentation

Overview

Package segfetcher contains all the logic that is needed to fetch segments, verify and store segments in an efficient manner. It is designed to be pluggable into the daemon and control service.

Index

• Variables
• func ErrToMetricsLabel(err error) string
• func NewFetcherMetrics(ns string) metrics.Fetcher
• type DefaultRequester
  • func (r *DefaultRequester) Request(ctx context.Context, reqs Requests) <-chan ReplyOrErr
• type DefaultResolver
  • func NewResolver(DB pathdb.ReadWrite, revCache revcache.RevCache, localInfo LocalInfo) *DefaultResolver
  • func (r *DefaultResolver) Resolve(ctx context.Context, reqs Requests, refresh bool) (Segments, Requests, error)
• type DstProvider
• type Fetcher
  • func (f *Fetcher) Fetch(ctx context.Context, reqs Requests, refresh bool) (Segments, error)
  • func (f *Fetcher) Request(ctx context.Context, reqs Requests) (Segments, error)
• type LocalInfo
• type MultiSegmentSplitter
  • func (s *MultiSegmentSplitter) Split(ctx context.Context, dst addr.IA) (Requests, error)
• type Pather
  • func (p *Pather) GetPaths(ctx context.Context, dst addr.IA, refresh bool) ([]snet.Path, error)
• type RPC
• type ReplyHandler
• type ReplyOrErr
• type Request
  • func (r Request) Equal(other Request) bool
  • func (r Request) IsZero() bool
• type Requester
• type Requests
  • func (r Requests) DstIAs() []addr.IA
  • func (r Requests) IsEmpty() bool
  • func (r Requests) SrcIAs() []addr.IA
• type Resolver
• type Segments
  • func (s Segments) Segs() []*seg.PathSegment
• type SegmentsReply
• type Splitter

Variables

var (
	ErrBadDst = errors.New("bad destination AS")
)

Pather errors.

var ErrInvalidRequest = serrors.New("invalid request")

ErrInvalidRequest indicates an invalid request.

var ErrNotReachable = serrors.New("remote not reachable")

ErrNotReachable indicates that the destination is not reachable from this process.

Functions

func ErrToMetricsLabel

func ErrToMetricsLabel(err error) string

ErrToMetricsLabel classifies the error from the segfetcher into metrics labels.

func NewFetcherMetrics

func NewFetcherMetrics(ns string) metrics.Fetcher

NewFetcherMetrics exposes the metrics constructor.

XXX(roosd): This should be translated to the new metrics approach.

Types

type DefaultRequester

type DefaultRequester struct {
	RPC         RPC
	DstProvider DstProvider
	MaxRetries  int
}

DefaultRequester requests all segments that can be requested from a request set.

func (*DefaultRequester) Request

func (r *DefaultRequester) Request(ctx context.Context, reqs Requests) <-chan ReplyOrErr

Request all requests in the request set

type DefaultResolver

type DefaultResolver struct {
	DB        pathdb.ReadWrite
	RevCache  revcache.RevCache
	LocalInfo LocalInfo
}

DefaultResolver is the default resolver implementation.

func NewResolver

func NewResolver(DB pathdb.ReadWrite, revCache revcache.RevCache,
	localInfo LocalInfo) *DefaultResolver

NewResolver creates a new resolver with the given DB.

func (*DefaultResolver) Resolve

func (r *DefaultResolver) Resolve(ctx context.Context,
	reqs Requests, refresh bool) (Segments, Requests, error)

Resolve resolves requests. It loads the segments that are locally available from the DB and returns the set of requests that have to be requested at a remote server.

type DstProvider

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

DstProvider provides the destination for a segment lookup including the path.

type Fetcher

type Fetcher struct {
	Resolver     Resolver
	Requester    Requester
	ReplyHandler ReplyHandler
	PathDB       pathdb.DB
	// QueryInterval specifies after how much time segments should be
	// refetched at the remote server.
	QueryInterval time.Duration
	Metrics       metrics.Fetcher
}

Fetcher fetches, verifies and stores segments for a path segment request.

func (*Fetcher) Fetch

func (f *Fetcher) Fetch(ctx context.Context, reqs Requests, refresh bool) (Segments, error)

Fetch loads the requested segments from the path DB or requests them from a remote path server.

func (*Fetcher) Request

func (f *Fetcher) Request(ctx context.Context, reqs Requests) (Segments, error)

type LocalInfo

type LocalInfo interface {
	// IsSegLocal returns whether the requested segment is always locally stored.
	IsSegLocal(req Request) bool
}

LocalInfo provides information about which segments are always locally stored.

type MultiSegmentSplitter

type MultiSegmentSplitter struct {
	LocalIA   addr.IA
	Core      bool
	Inspector trust.Inspector
}

MultiSegmentSplitter splits requests consisting of one or multiple segments. The AS inspector is used to check whether an IA is core or not.

func (*MultiSegmentSplitter) Split

func (s *MultiSegmentSplitter) Split(ctx context.Context, dst addr.IA) (Requests, error)

Split splits a path request from the local AS to dst into a set of segment requests.

type Pather

type Pather struct {
	IA         addr.IA
	MTU        uint16
	NextHopper interface {
		UnderlayNextHop(uint16) *net.UDPAddr
	}
	RevCache revcache.RevCache
	Fetcher  *Fetcher
	Splitter Splitter
}

Pather is used to construct paths from the path database. If necessary, paths are fetched over the network.

func (*Pather) GetPaths

func (p *Pather) GetPaths(ctx context.Context, dst addr.IA,
	refresh bool) ([]snet.Path, error)

GetPaths returns all non-revoked and non-expired paths to the destination. The paths are sorted from best to worst according to the weighting in path combinator. In case the destination AS is the same as the local AS, a slice containing an empty path is returned.

type RPC

type RPC interface {
	Segments(ctx context.Context, req Request, dst net.Addr) (SegmentsReply, error)
}

RPC is used to fetch segments from a remote.

type ReplyHandler

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

ReplyHandler handles replies.

type ReplyOrErr

type ReplyOrErr struct {
	Req      Request
	Segments []*seg.Meta
	Peer     net.Addr
	Err      error
}

ReplyOrErr is a seg reply or an error for the given request.

type Request

type Request struct {
	Src     addr.IA
	Dst     addr.IA
	SegType seg.Type
}

Request represents a path or segment request.

func (Request) Equal

func (r Request) Equal(other Request) bool

Equal returns whether the two request refer to the same src/dst/type.

func (Request) IsZero

func (r Request) IsZero() bool

IsZero returns whether the request is empty.

type Requester

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

Requester requests segments.

type Requests

type Requests []Request

Requests is a list of requests and provides some convenience methods on top of it.

func (Requests) DstIAs

func (r Requests) DstIAs() []addr.IA

DstIAs returns all unique destinations in the request list.

func (Requests) IsEmpty

func (r Requests) IsEmpty() bool

IsEmpty returns whether the list of requests is empty.

func (Requests) SrcIAs

func (r Requests) SrcIAs() []addr.IA

SrcIAs returns all unique sources in the request list.

type Resolver

type Resolver interface {
	// Resolve resolves requests. It loads the segments that are locally available
	// from the DB and returns the set of requests that have to be requested at a
	// remote server.
	Resolve(ctx context.Context, reqs Requests, refresh bool) (Segments, Requests, error)
}

Resolver resolves segments that are locally cached.

type Segments

type Segments []*seg.Meta

func (Segments) Segs

func (s Segments) Segs() []*seg.PathSegment

type SegmentsReply

type SegmentsReply struct {
	Segments []*seg.Meta
	Peer     net.Addr
}

SegmentsReply represents the segments received from an RPC. It also includes meta data like the Peer address that is to be used for verification.

type Splitter

type Splitter interface {
	// Split splits a path request from the local AS to dst into a set of segment requests.
	Split(ctx context.Context, dst addr.IA) (Requests, error)
}

Splitter splits a path request into set of segment requests.