engine

type CacheSizeFunction = func() int64

type Engine interface {
	IsDomainRuleMatched(consumer *net.IP, domain string) (rule.Match, *config.GudgeonList, string)
	Resolve(domainName string) (string, error)
	Reverse(address string) string

	// different direct handle methods
	Handle(address *net.IP, protocol string, request *dns.Msg) (*dns.Msg, *resolver.RequestContext, *resolver.ResolutionResult)
	HandleWithConsumerName(consumerName string, rCon *resolver.RequestContext, request *dns.Msg) (*dns.Msg, *resolver.RequestContext, *resolver.ResolutionResult)
	HandleWithConsumer(consumer *consumer, rCon *resolver.RequestContext, request *dns.Msg) (*dns.Msg, *resolver.RequestContext, *resolver.ResolutionResult)
	HandleWithGroups(groups []string, rCon *resolver.RequestContext, request *dns.Msg) (*dns.Msg, *resolver.RequestContext, *resolver.ResolutionResult)
	HandleWithResolvers(resolvers []string, rCon *resolver.RequestContext, request *dns.Msg) (*dns.Msg, *resolver.RequestContext, *resolver.ResolutionResult)

	// info, things by name
	Consumers() *[]string
	Groups() *[]string
	Resolvers() *[]string
	Lists() *[]*ListEntry

	// stats
	CacheSize() int64

	// inner providers
	QueryLog() QueryLog
	Metrics() Metrics

	// close engine and all resources
	Close()

	// shutdown engine and all threads
	Shutdown()
}

type InfoRecord struct {
	// client address
	Address string

	// hold the information but aren't serialized
	Request        *dns.Msg                   `json:"-"`
	Response       *dns.Msg                   `json:"-"`
	Result         *resolver.ResolutionResult `json:"-"`
	RequestContext *resolver.RequestContext   `json:"-"`

	// generated/calculated values
	Consumer       string
	ClientName     string
	ConnectionType string
	RequestDomain  string
	RequestType    string
	ResponseText   string
	Rcode          string

	// hard consumer blocked
	Blocked bool

	// matching
	Match          rule.Match
	MatchList      string
	MatchListShort string
	MatchRule      string

	// cached in resolver cache store
	Cached bool

	// when this log record was created
	Created  time.Time
	Finished time.Time

	// how long it took to service the request inside the engine
	ServiceMilliseconds int64
}

type ListEntry struct {
	Name  string `json:"name"`
	Short string `json:"short"`
}

type Metric struct {
	Count int64 `json:"count"`
}

type Metrics interface {
	GetAll() *map[string]*Metric
	Get(name string) *Metric

	// duration of metrics retention
	Duration() *time.Duration

	// duration between metrics collection
	Interval() *time.Duration

	// use cache function
	UseCacheSizeFunction(function CacheSizeFunction)

	// Query metrics from db
	Query(start time.Time, end time.Time) ([]*MetricsEntry, error)
	QueryFunc(accumulatorFunction MetricsAccumulator, options QueryOptions, unmarshall bool, start time.Time, end time.Time) error

	// top information
	TopClients(limit int) []*TopInfo
	TopDomains(limit int) []*TopInfo
	TopQueryTypes(limit int) []*TopInfo
	TopLists(limit int) []*TopInfo
	TopRules(limit int) []*TopInfo

	// stop the metrics collection
	Stop()
	// contains filtered or unexported methods
}

type MetricsAccumulator = func(entry *MetricsEntry)

type MetricsEntry struct {
	FromTime        time.Time
	AtTime          time.Time
	JsonBytes       []byte             `json:"-"`
	Values          map[string]*Metric `json:"Values,omitempty"`
	IntervalSeconds int
}

type QueryAccumulator = func(count uint64, info *InfoRecord)

type QueryLog interface {
	Query(query *QueryLogQuery) ([]*InfoRecord, uint64)
	QueryFunc(query *QueryLogQuery, accumulator QueryAccumulator)
	Stop()
	// contains filtered or unexported methods
}

type QueryLogQuery struct {
	// query on fields
	Address        string
	ClientName     string
	ConnectionType string
	RequestDomain  string
	RequestType    string
	ResponseText   string
	Blocked        *bool
	Cached         *bool
	// aspects of the match
	Match     *rule.Match
	MatchList string
	MatchRule string
	// query on created time
	After  *time.Time
	Before *time.Time
	// query limits for paging
	Skip  int
	Limit int
	// query sort
	SortBy    string
	Direction string
}

type QueryOptions struct {
	// a list of metrics names to "choose"
	// to return
	ChosenMetrics string
	// will be used as a modulus to skip rows
	// which reduces the resolution of a given
	// metrics stream and makes the graph
	// less cluttered
	StepSize int
}

type ReverseLookupFunction = func(address string) string

type TopInfo struct {
	Desc  string
	Count uint64
}