TrueCloudLab/coredns
16
0
Fork 2
Code Issues Pull requests 1 Projects Releases Packages Wiki Activity Actions

Better naming (#2104)

Browse source 
* Move functions from pkg/transport to pkg/parse

Although "parse" is a fairly generic name I believe this is somewhat
better named. pkg/transport keeps a few constants that are uses
throughout for the rest is is renaming a bunch (and the fallout from
there to make things compile again).

Signed-off-by: Miek Gieben <miek@miek.nl>

* Fix tests

Signed-off-by: Miek Gieben <miek@miek.nl>
This commit is contained in:
Miek Gieben 2018-09-19 08:16:04 +01:00 • committed by GitHub
parent c349446a23
commit cb932ca231
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
14 changed files with 95 additions and 82 deletions
Download patch file Download diff file Expand all files Collapse all files

98
plugin/pkg/dnsutil/host.go
View file

@ -1,98 +0,0 @@
package dnsutil
import (
"fmt"
"net"
"os"
"github.com/coredns/coredns/plugin/pkg/transport"
"github.com/miekg/dns"
)
// ParseHostPortOrFile parses the strings in s, each string can either be a
// address, [scheme://]address:port or a filename. The address part is checked
// and in case of filename a resolv.conf like file is (assumed) and parsed and
// the nameservers found are returned.
func ParseHostPortOrFile(s ...string) ([]string, error) {
var servers []string
for _, h := range s {
trans, host := transport.Parse(h)
addr, _, err := net.SplitHostPort(host)
if err != nil {
// Parse didn't work, it is not a addr:port combo
if net.ParseIP(host) == nil {
// Not an IP address.
ss, err := tryFile(host)
if err == nil {
servers = append(servers, ss...)
continue
}
return servers, fmt.Errorf("not an IP address or file: %q", host)
}
var ss string
switch trans {
case transport.DNS:
ss = net.JoinHostPort(host, "53")
case transport.TLS:
ss = transport.TLS + "://" + net.JoinHostPort(host, transport.TLSPort)
case transport.GRPC:
ss = transport.GRPC + "://" + net.JoinHostPort(host, transport.GRPCPort)
case transport.HTTPS:
ss = transport.HTTPS + "://" + net.JoinHostPort(host, transport.HTTPSPort)
}
servers = append(servers, ss)
continue
}
if net.ParseIP(addr) == nil {
// Not an IP address.
ss, err := tryFile(host)
if err == nil {
servers = append(servers, ss...)
continue
}
return servers, fmt.Errorf("not an IP address or file: %q", host)
}
servers = append(servers, h)
}
return servers, nil
}
// Try to open this is a file first.
func tryFile(s string) ([]string, error) {
c, err := dns.ClientConfigFromFile(s)
if err == os.ErrNotExist {
return nil, fmt.Errorf("failed to open file %q: %q", s, err)
} else if err != nil {
return nil, err
}
servers := []string{}
for _, s := range c.Servers {
servers = append(servers, net.JoinHostPort(s, c.Port))
}
return servers, nil
}
// ParseHostPort will check if the host part is a valid IP address, if the
// IP address is valid, but no port is found, defaultPort is added.
func ParseHostPort(s, defaultPort string) (string, error) {
addr, port, err := net.SplitHostPort(s)
if port == "" {
port = defaultPort
}
if err != nil {
if net.ParseIP(s) == nil {
return "", fmt.Errorf("must specify an IP address: `%s'", s)
}
return net.JoinHostPort(s, port), nil
}
if net.ParseIP(addr) == nil {
return "", fmt.Errorf("must specify an IP address: `%s'", addr)
}
return net.JoinHostPort(addr, port), nil
}

85
plugin/pkg/dnsutil/host_test.go
View file

@ -1,85 +0,0 @@
package dnsutil
import (
"io/ioutil"
"os"
"testing"
)
func TestParseHostPortOrFile(t *testing.T) {
tests := []struct {
in string
expected string
shouldErr bool
}{
{
"8.8.8.8",
"8.8.8.8:53",
false,
},
{
"8.8.8.8:153",
"8.8.8.8:153",
false,
},
{
"/etc/resolv.conf:53",
"",
true,
},
{
"resolv.conf",
"127.0.0.1:53",
false,
},
}
err := ioutil.WriteFile("resolv.conf", []byte("nameserver 127.0.0.1\n"), 0600)
if err != nil {
t.Fatalf("Failed to write test resolv.conf")
}
defer os.Remove("resolv.conf")
for i, tc := range tests {
got, err := ParseHostPortOrFile(tc.in)
if err == nil && tc.shouldErr {
t.Errorf("Test %d, expected error, got nil", i)
continue
}
if err != nil && tc.shouldErr {
continue
}
if got[0] != tc.expected {
t.Errorf("Test %d, expected %q, got %q", i, tc.expected, got[0])
}
}
}
func TestParseHostPort(t *testing.T) {
tests := []struct {
in string
expected string
shouldErr bool
}{
{"8.8.8.8:53", "8.8.8.8:53", false},
{"a.a.a.a:153", "", true},
{"8.8.8.8", "8.8.8.8:53", false},
{"8.8.8.8:", "8.8.8.8:53", false},
{"8.8.8.8::53", "", true},
{"resolv.conf", "", true},
}
for i, tc := range tests {
got, err := ParseHostPort(tc.in, "53")
if err == nil && tc.shouldErr {
t.Errorf("Test %d, expected error, got nil", i)
continue
}
if err != nil && !tc.shouldErr {
t.Errorf("Test %d, expected no error, got %q", i, err)
}
if got != tc.expected {
t.Errorf("Test %d, expected %q, got %q", i, tc.expected, got)
}
}
}