dnsping

type AbstractEngine interface {
	// RunAsync behaves like Engine.RunAsync
	RunAsync(plans []*SinglePingPlan) <-chan *Result

	// NextID returns the next ID.
	NextID() int64
}

type ArchivalResult struct {
	Pings []*ArchivalSinglePingResult `json:"pings"`
}

type ArchivalSinglePingReply struct {
	Addresses     []string                  `json:"addresses"`
	ALPNs         []string                  `json:"alpns"`
	Failure       *string                   `json:"failure"`
	ID            int64                     `json:"id"`
	Rcode         string                    `json:"rcode"`
	Reply         *model.ArchivalBinaryData `json:"reply"`
	SourceAddress string                    `json:"source_address"`
	T             float64                   `json:"t"`
}

type ArchivalSinglePingResult struct {
	Delay           float64                    `json:"delay"`
	Hostname        string                     `json:"hostname"`
	ID              int64                      `json:"id"`
	Query           *model.ArchivalBinaryData  `json:"query"`
	QueryID         int64                      `json:"query_id"`
	QueryType       string                     `json:"query_type"`
	ResolverAddress string                     `json:"resolver_address"`
	T               float64                    `json:"t"`
	Replies         []*ArchivalSinglePingReply `json:"replies"`
}

type Cache struct {
	// DisableNetwork allows to disable network operations.
	DisableNetwork bool

	// DNSPing is a reference to the underlying cache.
	DNSPing *caching.FSCache
}

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

type Engine struct {
	// Decoder is the MANDATORY specific DNSDecoder to use.
	Decoder model.DNSDecoder

	// Encoder is the specific MANDATORY DNSEncoder to use.
	Encoder model.DNSEncoder

	// IDGenerator is the MANDATORY IDGenerator to use.
	IDGenerator IDGenerator

	// Listener is the specific MANDATORY UDPListener to use.
	Listener model.UDPListener

	// QueryTimeout is the MANDATORY query timeout to use.
	QueryTimeout time.Duration
}

type IDGenerator interface {
	NextID() int64
}

type Result struct {
	// Pings contains a list of ping results. If this list is empty,
	// it means the input plan was empty or wrong.
	Pings []*SinglePingResult `json:",omitempty"`
}

type SinglePingPlan struct {
	// ResolverAddress is the resolver's address (e.g., 8.8.8.8:53).
	ResolverAddress string

	// Delay is the delay since the beginning of the ping
	// session after which we should send this ping.
	//
	// The maximum timeout of the ping session is equal to the
	// maximum delay plus the engine's DNSTimeout.
	Delay time.Duration

	// Domain is the domain to query. If the domain is not a
	// FQDN, we'll convert it to FQDN form. For example, this
	// means that we'll convert `x.org` to `x.org.`.
	Domain string

	// QueryType is the type of query to send. We accept the
	// following query types: `dns.Type{A,AAAA,HTTPS}`.
	QueryType uint16
	// contains filtered or unexported fields
}

type SinglePingReply struct {
	// ID is the unique ID of this reply.
	ID int64

	// SourceAddress is the address from which we received the reply.
	SourceAddress string

	// Reply contains the bytes of the DNS reply.
	Reply []byte

	// Error is the (netxlite-wrapped) error that occurred. We can
	// see two kinds of errors here:
	//
	// 1. errors that depend on the Rcode (e.g., dns_nxdomain_error);
	//
	// 2. errors that depend on the response not containing any
	// valid IP address (e.g., dns_no_answers).
	Error archival.FlatFailure

	// Finished is when we received this ping reply.
	Finished time.Time

	// Rcode contains the response rcode.
	Rcode string

	// Addresses contains the resolved addresses.
	Addresses []string

	// ALPNs contains the resolved ALPNs.
	ALPNs []string
}

type SinglePingResult struct {
	// ID is the unique ID of this result.
	ID int64

	// ResolverAddress is the resolver's address (e.g., 8.8.8.8:53).
	ResolverAddress string

	// Delay is the original delay.
	Delay time.Duration

	// Domain is the domain we queried. If the domain is not
	// a FQDN, we'll convert it to FQDN form. For example, this
	// means that we'll convert `x.org` to `x.org.`.
	Domain string

	// QueryType is the type of query we sent. We accept the
	// following query types: `dns.Type{A,AAAA,HTTPS}`.
	QueryType uint16

	// QueryID is the query ID.
	QueryID uint16

	// Query contains the bytes of the query we have sent.
	Query []byte

	// Started is when we sent the query.
	Started time.Time

	// Replies contains the replies for this query. This field will
	// be empty if we've got no replies. In the common case, it
	// will contain just one entry. It may contain more than one
	// entry in case of censorship or packet duplication.
	Replies []*SinglePingReply
}