vikarti.anatra/safing-portmaster
1
0
Fork 0
mirror of https://github.com/safing/portmaster synced 2025-09-01 18:19:12 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

Merge pull request #84 from safing/feature/standalone-resolver-testing

Browse source 
Make resolver testing configurable
This commit is contained in:
Daniel 2020-06-27 15:04:19 +02:00 • committed by GitHub
commit cd19560956
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
3 changed files with 102 additions and 75 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
resolver/resolver-pooled.go
View file

@ -11,14 +11,12 @@ import (
"github.com/safing/portbase/utils"
)
const (
var (
defaultClientTTL = 5 * time.Minute
defaultRequestTimeout = 3 * time.Second // dns query
defaultConnectTimeout = 5 * time.Second // tcp/tls
connectionEOLGracePeriod = 7 * time.Second
)
var (
localAddrFactory func(network string) net.Addr
)

72
resolver/resolver-tcp_test.go
View file

@ -1,72 +0,0 @@
package resolver
import (
"context"
"fmt"
"io"
"os"
"runtime/pprof"
"sync"
"testing"
"time"
"github.com/miekg/dns"
)
func testTCPQuery(t *testing.T, wg *sync.WaitGroup, rc ResolverConn, q *Query) {
start := time.Now()
_, err := rc.Query(context.TODO(), q)
if err != nil {
t.Logf("client failed: %s", err) //nolint:staticcheck
wg.Done()
return
}
t.Logf("resolved %s in %s", q.FQDN, time.Since(start))
wg.Done()
}
func TestTCPResolver(t *testing.T) {
// skip if short - this test depends on the Internet and might fail randomly
if testing.Short() {
t.Skip()
}
go func() {
time.Sleep(15 * time.Second)
fmt.Fprintln(os.Stderr, "===== TAKING TOO LONG FOR SHUTDOWN =====")
printStackTo(os.Stderr)
os.Exit(1)
}()
// create separate resolver for this test
resolver, _, err := createResolver("dot://9.9.9.9:853?verify=dns.quad9.net&name=Quad9&blockedif=empty", "config")
// resolver, _, err := createResolver("dot://1.1.1.2:853?verify=cloudflare-dns.com&name=Cloudflare&blockedif=zeroip", "config")
if err != nil {
t.Fatal(err)
}
started := time.Now()
wg := &sync.WaitGroup{}
wg.Add(100)
for i := 0; i < 100; i++ {
go testTCPQuery(t, wg, resolver.Conn, &Query{ //nolint:staticcheck
FQDN: <-domainFeed,
QType: dns.Type(dns.TypeA),
})
}
wg.Wait()
t.Logf("time taken: %s", time.Since(started))
}
func printStackTo(writer io.Writer) {
fmt.Fprintln(writer, "=== PRINTING TRACES ===")
fmt.Fprintln(writer, "=== GOROUTINES ===")
_ = pprof.Lookup("goroutine").WriteTo(writer, 1)
fmt.Fprintln(writer, "=== BLOCKING ===")
_ = pprof.Lookup("block").WriteTo(writer, 1)
fmt.Fprintln(writer, "=== MUTEXES ===")
_ = pprof.Lookup("mutex").WriteTo(writer, 1)
fmt.Fprintln(writer, "=== END TRACES ===")
}

101
resolver/resolver_test.go Normal file
View file

@ -0,0 +1,101 @@
package resolver
import (
"context"
"flag"
"sync"
"testing"
"time"
"github.com/safing/portbase/log"
"github.com/miekg/dns"
)
var (
testResolver string
silencingTraceCtx, _ = log.AddTracer(context.Background())
)
func init() {
flag.StringVar(
&testResolver,
"resolver",
"dot://9.9.9.9:853?verify=dns.quad9.net&name=Quad9&blockedif=empty",
"set custom resolver for testing",
)
}
func startQuery(t *testing.T, wg *sync.WaitGroup, rc ResolverConn, q *Query) {
start := time.Now()
_, err := rc.Query(silencingTraceCtx, q)
if err != nil {
t.Logf("client failed: %s", err) //nolint:staticcheck
wg.Done()
return
}
t.Logf("resolved %s in %s", q.FQDN, time.Since(start))
wg.Done()
}
func TestSingleResolving(t *testing.T) {
// skip if short - this test depends on the Internet and might fail randomly
if testing.Short() {
t.Skip()
}
defaultRequestTimeout = 30 * time.Second
// create separate resolver for this test
resolver, _, err := createResolver(testResolver, "config")
if err != nil {
t.Fatal(err)
}
t.Logf("running bulk query test with resolver %s", resolver.Server)
started := time.Now()
wg := &sync.WaitGroup{}
wg.Add(100)
for i := 0; i < 100; i++ {
startQuery(t, wg, resolver.Conn, &Query{ //nolint:staticcheck
FQDN: <-domainFeed,
QType: dns.Type(dns.TypeA),
})
}
wg.Wait()
t.Logf("total time taken: %s", time.Since(started))
}
func TestBulkResolving(t *testing.T) {
// skip if short - this test depends on the Internet and might fail randomly
if testing.Short() {
t.Skip()
}
defaultRequestTimeout = 30 * time.Second
// create separate resolver for this test
resolver, _, err := createResolver(testResolver, "config")
if err != nil {
t.Fatal(err)
}
t.Logf("running bulk query test with resolver %s", resolver.Server)
started := time.Now()
wg := &sync.WaitGroup{}
wg.Add(100)
for i := 0; i < 100; i++ {
go startQuery(t, wg, resolver.Conn, &Query{ //nolint:staticcheck
FQDN: <-domainFeed,
QType: dns.Type(dns.TypeA),
})
}
wg.Wait()
t.Logf("total time taken: %s", time.Since(started))
}