proxard

README

proxard

official forward-like plugin but supports DoH & DNSCrypt

Documentation

Overview

Package proxard implements a forwarding proxy. It caches an upstream net.Conn for some time, so if the same client returns the upstream's Conn will be precached. Depending on how you benchmark this looks to be 50% faster than just opening a new connection for every client. It works with UDP and TCP and uses inband healthchecking.

Package forward implements a forwarding proxy. It caches an upstream net.Conn for some time, so if the same client returns the upstream's Conn will be precached. Depending on how you benchmark this looks to be 50% faster than just opening a new connection for every client. It works with UDP and TCP and uses inband healthchecking.

Index

• Variables
• type HealthChecker
  • func NewHealthChecker(trans string, recursionDesired bool) HealthChecker
• type Proxard
  • func New() *Proxard
  • func (f *Proxard) ForceTCP() bool
  • func (f *Proxard) Len() int
  • func (f *Proxard) List() []*Proxy
  • func (f *Proxard) Name() string
  • func (f *Proxard) OnShutdown() error
  • func (f *Proxard) OnStartup() (err error)
  • func (f *Proxard) PreferUDP() bool
  • func (f *Proxard) ServeDNS(ctx context.Context, w dns.ResponseWriter, r *dns.Msg) (int, error)
  • func (f *Proxard) SetProxy(p *Proxy)
• type Proxy
  • func NewProxy(addr, trans string) *Proxy
  • func (p *Proxy) Connect(ctx context.Context, state request.Request, opts options) (*dns.Msg, error)
  • func (p *Proxy) Down(maxfails uint32) bool
  • func (p *Proxy) Healthcheck()
  • func (p *Proxy) SetExpire(expire time.Duration)
  • func (p *Proxy) SetTLSConfig(cfg *tls.Config)
• type Transport
  • func (t *Transport) Dial(proto string) (*persistConn, bool, error)
  • func (t *Transport) SetExpire(expire time.Duration)
  • func (t *Transport) SetTLSConfig(cfg *tls.Config)
  • func (t *Transport) Start()
  • func (t *Transport) Stop()
  • func (t *Transport) Yield(pc *persistConn)

Variables

var (
	RequestCount = prometheus.NewCounterVec(prometheus.CounterOpts{
		Namespace: plugin.Namespace,
		Subsystem: "proxard",
		Name:      "request_count_total",
		Help:      "Counter of requests made per upstream.",
	}, []string{"to"})
	RcodeCount = prometheus.NewCounterVec(prometheus.CounterOpts{
		Namespace: plugin.Namespace,
		Subsystem: "proxard",
		Name:      "response_rcode_count_total",
		Help:      "Counter of requests made per upstream.",
	}, []string{"rcode", "to"})
	RequestDuration = prometheus.NewHistogramVec(prometheus.HistogramOpts{
		Namespace: plugin.Namespace,
		Subsystem: "proxard",
		Name:      "request_duration_seconds",
		Buckets:   plugin.TimeBuckets,
		Help:      "Histogram of the time each request took.",
	}, []string{"to"})
	HealthcheckFailureCount = prometheus.NewCounterVec(prometheus.CounterOpts{
		Namespace: plugin.Namespace,
		Subsystem: "proxard",
		Name:      "healthcheck_failure_count_total",
		Help:      "Counter of the number of failed healthchecks.",
	}, []string{"to"})
	HealthcheckBrokenCount = prometheus.NewCounter(prometheus.CounterOpts{
		Namespace: plugin.Namespace,
		Subsystem: "proxard",
		Name:      "healthcheck_broken_count_total",
		Help:      "Counter of the number of complete failures of the healthchecks.",
	})
	SocketGauge = prometheus.NewGaugeVec(prometheus.GaugeOpts{
		Namespace: plugin.Namespace,
		Subsystem: "proxard",
		Name:      "sockets_open",
		Help:      "Gauge of open sockets per upstream.",
	}, []string{"to"})
	MaxConcurrentRejectCount = prometheus.NewCounter(prometheus.CounterOpts{
		Namespace: plugin.Namespace,
		Subsystem: "proxard",
		Name:      "max_concurrent_reject_count_total",
		Help:      "Counter of the number of queries rejected because the concurrent queries were at maximum.",
	})
)

Variables declared for monitoring.

var (
	// ErrNoHealthy means no healthy proxies left.
	ErrNoHealthy = errors.New("no healthy proxies")
	// ErrNoForward means no forwarder defined.
	ErrNoForward = errors.New("no forwarder defined")
	// ErrCachedClosed means cached connection was closed by peer.
	ErrCachedClosed = errors.New("cached connection was closed by peer")
)

Types

type HealthChecker

type HealthChecker interface {
	Check(*Proxy) error
	SetTLSConfig(*tls.Config)
	SetRecursionDesired(bool)
	GetRecursionDesired() bool
}

HealthChecker checks the upstream health.

func NewHealthChecker

func NewHealthChecker(trans string, recursionDesired bool) HealthChecker

NewHealthChecker returns a new HealthChecker based on transport.

type Proxard

type Proxard struct {

	// ErrLimitExceeded indicates that a query was rejected because the number of concurrent queries has exceeded
	// the maximum allowed (maxConcurrent)
	ErrLimitExceeded error

	Next plugin.Handler
	// contains filtered or unexported fields
}

Proxard represents a plugin instance that can proxy requests to another (DNS) server. It has a list of proxies each representing one upstream proxy.

func New

func New() *Proxard

New returns a new Proxard.

func (*Proxard) ForceTCP

func (f *Proxard) ForceTCP() bool

ForceTCP returns if TCP is forced to be used even when the request comes in over UDP.

func (*Proxard) Len

func (f *Proxard) Len() int

Len returns the number of configured proxies.

func (*Proxard) List

func (f *Proxard) List() []*Proxy

List returns a set of proxies to be used for this client depending on the policy in f.

func (*Proxard) Name

func (f *Proxard) Name() string

Name implements plugin.Handler.

func (*Proxard) OnShutdown

func (f *Proxard) OnShutdown() error

OnShutdown stops all configured proxies.

func (*Proxard) OnStartup

func (f *Proxard) OnStartup() (err error)

OnStartup starts a goroutines for all proxies.

func (*Proxard) PreferUDP

func (f *Proxard) PreferUDP() bool

PreferUDP returns if UDP is preferred to be used even when the request comes in over TCP.

func (*Proxard) ServeDNS

func (f *Proxard) ServeDNS(ctx context.Context, w dns.ResponseWriter, r *dns.Msg) (int, error)

ServeDNS implements plugin.Handler.

func (*Proxard) SetProxy

func (f *Proxard) SetProxy(p *Proxy)

SetProxy appends p to the proxy list and starts healthchecking.

type Proxy

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

Proxy defines an upstream host.

func NewProxy

func NewProxy(addr, trans string) *Proxy

NewProxy returns a new proxy.

func (*Proxy) Connect

func (p *Proxy) Connect(ctx context.Context, state request.Request, opts options) (*dns.Msg, error)

Connect selects an upstream, sends the request and waits for a response.

func (*Proxy) Down

func (p *Proxy) Down(maxfails uint32) bool

Down returns true if this proxy is down, i.e. has *more* fails than maxfails.

func (*Proxy) Healthcheck

func (p *Proxy) Healthcheck()

Healthcheck kicks of a round of health checks for this proxy.

func (*Proxy) SetExpire

func (p *Proxy) SetExpire(expire time.Duration)

SetExpire sets the expire duration in the lower p.transport.

func (*Proxy) SetTLSConfig

func (p *Proxy) SetTLSConfig(cfg *tls.Config)

SetTLSConfig sets the TLS config in the lower p.transport and in the healthchecking client.

type Transport

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

Transport hold the persistent cache.

func (*Transport) Dial

func (t *Transport) Dial(proto string) (*persistConn, bool, error)

Dial dials the address configured in transport, potentially reusing a connection or creating a new one.

func (*Transport) SetExpire

func (t *Transport) SetExpire(expire time.Duration)

SetExpire sets the connection expire time in transport.

func (*Transport) SetTLSConfig

func (t *Transport) SetTLSConfig(cfg *tls.Config)

SetTLSConfig sets the TLS config in transport.

func (*Transport) Start

func (t *Transport) Start()

Start starts the transport's connection manager.

func (*Transport) Stop

func (t *Transport) Stop()

Stop stops the transport's connection manager.

func (*Transport) Yield

func (t *Transport) Yield(pc *persistConn)

Yield return the connection to transport for reuse.