// Removes 'subdomain' from etcd.
func (ks *kube2sky) removeDNS(subdomain string) error {
glog.V(2).Infof("Removing %s from DNS", subdomain)
resp, err := ks.etcdClient.RawGet(skymsg.Path(subdomain), false, true)
if err != nil {
return err
}
if resp.StatusCode == http.StatusNotFound {
glog.V(2).Infof("Subdomain %q does not exist in etcd", subdomain)
return nil
}
_, err = ks.etcdClient.Delete(skymsg.Path(subdomain), true)
return err
}
// ReverseRecord implements the SkyDNS Backend interface and returns standard records for
// a name.
func (b *ServiceResolver) ReverseRecord(name string) (*msg.Service, error) {
clusterIP, ok := extractIP(name)
if !ok {
return nil, fmt.Errorf("does not support reverse lookup with %s", name)
}
svc, err := b.accessor.ServiceByClusterIP(clusterIP)
if err != nil {
return nil, err
}
port := 0
if len(svc.Spec.Ports) > 0 {
port = int(svc.Spec.Ports[0].Port)
}
hostName := buildDNSName(b.base, "svc", svc.Namespace, svc.Name)
return &msg.Service{
Host: hostName,
Port: port,
Priority: 10,
Weight: 10,
Ttl: 30,
Key: msg.Path(name),
}, nil
}
// ReverseRecord implements the SkyDNS Backend interface and returns standard records for
// a name.
func (b *ServiceResolver) ReverseRecord(name string) (*msg.Service, error) {
portalIP, ok := extractIP(name)
if !ok {
return nil, fmt.Errorf("does not support reverse lookup with %s", name)
}
svc, err := b.accessor.ServiceByPortalIP(portalIP)
if err != nil {
return nil, err
}
port := 0
if len(svc.Spec.Ports) > 0 {
port = svc.Spec.Ports[0].Port
}
return &msg.Service{
Host: fmt.Sprintf("%s.%s.svc.%s", svc.Name, svc.Namespace, b.base),
Port: port,
Priority: 10,
Weight: 10,
Ttl: 30,
Text: "",
Key: msg.Path(name),
}, nil
}
func NewDomain(prefix string) (d *Domain) {
d = &Domain{}
msg.PathPrefix = "astralboot"
d.prefix = msg.Path(prefix)
d.entries = make(map[string]*msg.Service)
return d
}
func addDNS(record string, service *kapi.Service, etcdClient *etcd.Client) error {
// if PortalIP is not set, a DNS entry should not be created
if !kapi.IsServiceIPSet(service) {
log.Printf("Skipping dns record for headless service: %s\n", service.Name)
return nil
}
for i := range service.Spec.Ports {
svc := skymsg.Service{
Host: service.Spec.PortalIP,
Port: service.Spec.Ports[i].Port,
Priority: 10,
Weight: 10,
Ttl: 30,
}
b, err := json.Marshal(svc)
if err != nil {
return err
}
// Set with no TTL, and hope that kubernetes events are accurate.
log.Printf("Setting DNS record: %v -> %s:%d\n", record, service.Spec.PortalIP, service.Spec.Ports[i].Port)
_, err = etcdClient.Set(skymsg.Path(record), string(b), uint64(0))
if err != nil {
return err
}
}
return nil
}
func (g *Backendv3) Records(name string, exact bool) ([]msg.Service, error) {
path, star := msg.PathWithWildcard(name)
r, err := g.get(path, true)
if err != nil {
return nil, err
}
segments := strings.Split(msg.Path(name), "/")
return g.loopNodes(r.Kvs, segments, star, nil)
}
// NSRecords returns NS records from etcd.
func (s *server) NSRecords(q dns.Question, name string) (records []dns.RR, extra []dns.RR, err error) {
path, star := msg.PathWithWildcard(name)
r, err := get(s.client, path, true)
if err != nil {
return nil, nil, err
}
if !r.Node.Dir { // single element
serv := new(msg.Service)
if err := json.Unmarshal([]byte(r.Node.Value), serv); err != nil {
s.config.log.Infof("failed to parse json: %s", err.Error())
return nil, nil, err
}
ip := net.ParseIP(serv.Host)
ttl := s.calculateTtl(r.Node, serv)
serv.Key = r.Node.Key
serv.Ttl = ttl
switch {
case ip == nil:
return nil, nil, fmt.Errorf("NS record must be an IP address")
case ip.To4() != nil:
serv.Host = msg.Domain(serv.Key)
records = append(records, serv.NewNS(q.Name, serv.Host))
extra = append(extra, serv.NewA(serv.Host, ip.To4()))
case ip.To4() == nil:
serv.Host = msg.Domain(serv.Key)
records = append(records, serv.NewNS(q.Name, serv.Host))
extra = append(extra, serv.NewAAAA(serv.Host, ip.To16()))
}
return records, extra, nil
}
sx, err := s.loopNodes(&r.Node.Nodes, strings.Split(msg.Path(name), "/"), star, nil)
if err != nil || len(sx) == 0 {
return nil, nil, err
}
for _, serv := range sx {
ip := net.ParseIP(serv.Host)
switch {
case ip == nil:
return nil, nil, fmt.Errorf("NS record must be an IP address")
case ip.To4() != nil:
serv.Host = msg.Domain(serv.Key)
records = append(records, serv.NewNS(q.Name, serv.Host))
extra = append(extra, serv.NewA(serv.Host, ip.To4()))
case ip.To4() == nil:
serv.Host = msg.Domain(serv.Key)
records = append(records, serv.NewNS(q.Name, serv.Host))
extra = append(extra, serv.NewAAAA(serv.Host, ip.To16()))
}
}
return records, extra, nil
}
func (g *Backend) Records(name string, exact bool) ([]msg.Service, error) {
path, star := msg.PathWithWildcard(name)
r, err := g.get(path, true)
if err != nil {
return nil, err
}
segments := strings.Split(msg.Path(name), "/")
switch {
case exact && r.Node.Dir:
return nil, nil
case r.Node.Dir:
return g.loopNodes(r.Node.Nodes, segments, star, nil)
default:
return g.loopNodes([]*etcd.Node{r.Node}, segments, false, nil)
}
}
func (ksync *KubernetesSync) addDNS(service string, info *serviceInfo) error {
// ADD to SkyDNS registry
svc := msg.Service{
Host: info.portalIP.String(),
Port: info.portalPort,
Priority: 10,
Weight: 10,
Ttl: 30,
}
b, err := json.Marshal(svc)
//Set with no TTL, and hope that kubernetes events are accurate.
log.Printf("setting dns record: %v\n", service)
_, err = ksync.eclient.Set(msg.Path(service), string(b), uint64(0))
return err
}
func addDNS(record string, service *kapi.Service, etcdClient *etcd.Client) error {
svc := skymsg.Service{
Host: service.Spec.PortalIP,
Port: service.Spec.Port,
Priority: 10,
Weight: 10,
Ttl: 30,
}
b, err := json.Marshal(svc)
if err != nil {
return err
}
// Set with no TTL, and hope that kubernetes events are accurate.
log.Printf("Setting dns record: %v -> %s:%d\n", record, service.Spec.PortalIP, service.Spec.Port)
_, err = etcdClient.Set(skymsg.Path(record), string(b), uint64(0))
return err
}
// setEntry creates the entire path if it doesn't already exist in the cache,
// then sets the given service record under the given key. The path this entry
// would have occupied in an etcd datastore is computed from the given fqdn and
// stored as the "Key" of the skydns service; this is only required because
// skydns expects the service record to contain a key in a specific format
// (presumably for legacy compatibility). Note that the fqnd string typically
// contains both the key and all elements in the path.
func (cache *TreeCache) setEntry(key string, val *skymsg.Service, fqdn string, path ...string) {
// TODO: Consolidate setEntry and setSubCache into a single method with a
// type switch.
// TODO: Insted of passing the fqdn as an argument, we can reconstruct
// it from the path, provided callers always pass the full path to the
// object. This is currently *not* the case, since callers first create
// a new, empty node, populate it, then parent it under the right path.
// So we don't know the full key till the final parenting operation.
node := cache.ensureChildNode(path...)
// This key is used to construct the "target" for SRV record lookups.
// For normal service/endpoint lookups, this will result in a key like:
// /skydns/local/cluster/svc/svcNS/svcName/record-hash
// but for headless services that govern pods requesting a specific
// hostname (as used by petset), this will end up being:
// /skydns/local/cluster/svc/svcNS/svcName/pod-hostname
val.Key = skymsg.Path(fqdn)
node.Entries[key] = val
}
func (g *Backendv3) ReverseRecord(name string) (*msg.Service, error) {
path, star := msg.PathWithWildcard(name)
if star {
return nil, fmt.Errorf("reverse can not contain wildcards")
}
r, err := g.get(path, true)
if err != nil {
return nil, err
}
segments := strings.Split(msg.Path(name), "/")
records, err := g.loopNodes(r.Kvs, segments, false, nil)
if err != nil {
return nil, err
}
if len(records) != 1 {
return nil, fmt.Errorf("must be only one service record")
}
return &records[0], nil
}
func (g *Backend) ReverseRecord(name string, rmtIP net.IP) (*msg.Service, error) {
path, star := msg.PathWithWildcard(name)
if star {
return nil, fmt.Errorf("reverse can not contain wildcards")
}
r, err := g.get(path, true)
if err != nil {
return nil, err
}
if r.Node.Dir {
return nil, fmt.Errorf("reverse must not be a directory")
}
segments := strings.Split(msg.Path(name), "/")
records, err := g.loopNodes(&etcd.Nodes{r.Node}, segments, false, nil, rmtIP)
if err != nil {
return nil, err
}
if len(records) != 1 {
return nil, fmt.Errorf("must be only one service record")
}
return &records[0], nil
}
func (g *Backend) Records(name string, exact bool, rmtIP net.IP) ([]msg.Service, error) {
path, star := msg.PathWithWildcard(name)
r, err := g.get(path, true)
if err != nil {
return nil, err
}
segments := strings.Split(msg.Path(name), "/")
switch {
case exact && r.Node.Dir:
return nil, nil
case r.Node.Dir:
if _, err := g.get(fmt.Sprintf("%s/.wildcards", path), true); err != nil {
return nil, err
}
if r2, err := g.get(fmt.Sprintf("%s/.self", path), true); err != nil {
return g.loopNodes(&r.Node.Nodes, segments, star, nil, rmtIP)
} else {
return g.loopNodes(&etcd.Nodes{r2.Node}, segments, false, nil, rmtIP)
}
default:
return g.loopNodes(&etcd.Nodes{r.Node}, segments, false, nil, rmtIP)
}
}
func removeDNS(record string, etcdClient *etcd.Client) error {
log.Printf("Removing %s from DNS", record)
_, err := etcdClient.Delete(skymsg.Path(record), true)
return err
}
func main() {
flag.Parse()
machines := strings.Split(machine, ",")
client := newClient(machines, tlspem, tlskey, cacert)
if nameserver != "" {
for _, hostPort := range strings.Split(nameserver, ",") {
if err := validateHostPort(hostPort); err != nil {
log.Fatalf("skydns: nameserver is invalid: %s", err)
}
config.Nameservers = append(config.Nameservers, hostPort)
}
}
if err := validateHostPort(config.DnsAddr); err != nil {
log.Fatalf("skydns: addr is invalid: %s", err)
}
if err := loadConfig(client, config); err != nil {
log.Fatalf("skydns: %s", err)
}
if err := server.SetDefaults(config); err != nil {
log.Fatalf("skydns defaults could not be set from /etc/resolv.conf: %v", err)
}
if config.Local != "" {
config.Local = dns.Fqdn(config.Local)
}
backend := backendetcd.NewBackend(client, &backendetcd.Config{
Ttl: config.Ttl,
Priority: config.Priority,
})
s := server.New(backend, config)
if discover {
go func() {
recv := make(chan *etcd.Response)
go client.Watch("/_etcd/machines/", 0, true, recv, nil)
duration := 1 * time.Second
for {
select {
case n := <-recv:
if n != nil {
if client := updateClient(n, tlskey, tlspem, cacert); client != nil {
backend.UpdateClient(client)
}
duration = 1 * time.Second // reset
} else {
// we can see an n == nil, probably when we can't connect to etcd.
log.Printf("skydns: etcd machine cluster update failed, sleeping %s + ~3s", duration)
time.Sleep(duration + (time.Duration(rand.Float32() * 3e9))) // Add some random.
duration *= 2
if duration > 32*time.Second {
duration = 32 * time.Second
}
}
}
}
}()
}
if stub {
s.UpdateStubZones()
go func() {
recv := make(chan *etcd.Response)
go client.Watch(msg.Path(config.Domain)+"/dns/stub/", 0, true, recv, nil)
duration := 1 * time.Second
for {
select {
case n := <-recv:
if n != nil {
s.UpdateStubZones()
log.Printf("skydns: stubzone update")
duration = 1 * time.Second // reset
} else {
// we can see an n == nil, probably when we can't connect to etcd.
log.Printf("skydns: stubzone update failed, sleeping %s + ~3s", duration)
time.Sleep(duration + (time.Duration(rand.Float32() * 3e9))) // Add some random.
duration *= 2
if duration > 32*time.Second {
duration = 32 * time.Second
}
}
}
}
}()
}
stats.Collect() // Graphite
server.Metrics() // Prometheus
if err := s.Run(); err != nil {
log.Fatalf("skydns: %s", err)
}
}
// Records implements the SkyDNS Backend interface and returns standard records for
// a name.
//
// The standard pattern is <prefix>.<service_name>.<namespace>.(svc|endpoints|pod).<base>
//
// * prefix may be any series of prefix values
// * _endpoints is a special prefix that returns the same as <service_name>.<namespace>.svc.<base>
// * service_name and namespace must locate a real service
// * unless a fallback is defined, in which case the fallback name will be looked up
// * svc indicates standard service rules apply (clusterIP or endpoints as A records)
// * reverse lookup of IP is only possible for clusterIP
// * SRV records are returned for each host+port combination as:
// _<port_name>._<port_protocol>.<dns>
// _<port_name>.<endpoint_id>.<dns>
// * endpoints always returns each individual endpoint as A records
// * SRV records for endpoints are similar to SVC, but are prefixed with a single label
// that is a hash of the endpoint IP
// * pods is of the form <IP_with_dashes>.<namespace>.pod.<base> and resolves to <IP>
//
func (b *ServiceResolver) Records(dnsName string, exact bool) ([]msg.Service, error) {
if !strings.HasSuffix(dnsName, b.base) {
return nil, errNoSuchName
}
prefix := strings.Trim(strings.TrimSuffix(dnsName, b.base), ".")
segments := strings.Split(prefix, ".")
for i, j := 0, len(segments)-1; i < j; i, j = i+1, j-1 {
segments[i], segments[j] = segments[j], segments[i]
}
if len(segments) == 0 {
return nil, errNoSuchName
}
glog.V(4).Infof("Answering query %s:%t", dnsName, exact)
switch base := segments[0]; base {
case "pod":
if len(segments) != 3 {
return nil, errNoSuchName
}
namespace, encodedIP := segments[1], segments[2]
ip := convertDashIPToIP(encodedIP)
if net.ParseIP(ip) == nil {
return nil, errNoSuchName
}
return []msg.Service{
{
Host: ip,
Port: 0,
Priority: 10,
Weight: 10,
Ttl: 30,
Key: msg.Path(buildDNSName(b.base, "pod", namespace, getHash(ip))),
},
}, nil
case "svc", "endpoints":
if len(segments) < 3 {
return nil, errNoSuchName
}
namespace, name := segments[1], segments[2]
svc, err := b.accessor.Services(namespace).Get(name)
if err != nil {
if errors.IsNotFound(err) && b.fallback != nil {
if fallback, ok := b.fallback(prefix, exact); ok {
return b.Records(fallback+b.base, exact)
}
return nil, errNoSuchName
}
return nil, errNoSuchName
}
// no clusterIP and not headless, no DNS
if len(svc.Spec.ClusterIP) == 0 && svc.Spec.Type != kapi.ServiceTypeExternalName {
return nil, errNoSuchName
}
subdomain := buildDNSName(b.base, base, namespace, name)
endpointPrefix := base == "endpoints"
retrieveEndpoints := endpointPrefix || (len(segments) > 3 && segments[3] == "_endpoints")
includePorts := len(segments) > 3 && hasAllPrefixedSegments(segments[3:], "_") && segments[3] != "_endpoints"
// if has a portal IP and looking at svc
if svc.Spec.ClusterIP != kapi.ClusterIPNone && !retrieveEndpoints {
hostValue := svc.Spec.ClusterIP
if svc.Spec.Type == kapi.ServiceTypeExternalName {
hostValue = svc.Spec.ExternalName
}
defaultService := msg.Service{
Host: hostValue,
Port: 0,
Priority: 10,
Weight: 10,
Ttl: 30,
}
defaultHash := getHash(defaultService.Host)
defaultName := buildDNSName(subdomain, defaultHash)
defaultService.Key = msg.Path(defaultName)
if len(svc.Spec.Ports) == 0 || !includePorts {
glog.V(4).Infof("Answered %s:%t with %#v", dnsName, exact, defaultService)
return []msg.Service{defaultService}, nil
}
services := []msg.Service{}
protocolMatch, portMatch := segments[3], "*"
if len(segments) > 4 {
portMatch = segments[4]
}
for _, p := range svc.Spec.Ports {
portSegment, protocolSegment, ok := matchesPortAndProtocol(p.Name, string(p.Protocol), portMatch, protocolMatch)
if !ok {
continue
}
port := p.Port
if port == 0 {
port = int32(p.TargetPort.IntVal)
}
keyName := buildDNSName(defaultName, protocolSegment, portSegment)
services = append(services,
msg.Service{
Host: hostValue,
Port: int(port),
Priority: 10,
Weight: 10,
Ttl: 30,
TargetStrip: 2,
Key: msg.Path(keyName),
},
)
}
if len(services) == 0 {
services = append(services, defaultService)
}
glog.V(4).Infof("Answered %s:%t with %#v", dnsName, exact, services)
return services, nil
}
// return endpoints
endpoints, err := b.endpoints.Endpoints(namespace).Get(name)
if err != nil {
return nil, errNoSuchName
}
hostnameMappings := noHostnameMappings
if savedHostnames := endpoints.Annotations[kendpoints.PodHostnamesAnnotation]; len(savedHostnames) > 0 {
mapped := make(map[string]kendpoints.HostRecord)
if err = json.Unmarshal([]byte(savedHostnames), &mapped); err == nil {
hostnameMappings = mapped
}
}
matchHostname := len(segments) > 3 && !hasAllPrefixedSegments(segments[3:4], "_")
services := make([]msg.Service, 0, len(endpoints.Subsets)*4)
for _, s := range endpoints.Subsets {
for _, a := range s.Addresses {
defaultService := msg.Service{
Host: a.IP,
Port: 0,
Priority: 10,
Weight: 10,
Ttl: 30,
}
var endpointName string
if hostname, ok := getHostname(&a, hostnameMappings); ok {
endpointName = hostname
} else {
endpointName = getHash(defaultService.Host)
}
if matchHostname && endpointName != segments[3] {
continue
}
defaultName := buildDNSName(subdomain, endpointName)
defaultService.Key = msg.Path(defaultName)
if !includePorts {
services = append(services, defaultService)
continue
}
protocolMatch, portMatch := segments[3], "*"
if len(segments) > 4 {
portMatch = segments[4]
}
for _, p := range s.Ports {
portSegment, protocolSegment, ok := matchesPortAndProtocol(p.Name, string(p.Protocol), portMatch, protocolMatch)
if !ok || p.Port == 0 {
continue
}
keyName := buildDNSName(defaultName, protocolSegment, portSegment)
services = append(services, msg.Service{
Host: a.IP,
Port: int(p.Port),
Priority: 10,
Weight: 10,
Ttl: 30,
TargetStrip: 2,
Key: msg.Path(keyName),
})
}
}
}
glog.V(4).Infof("Answered %s:%t with %#v", dnsName, exact, services)
return services, nil
}
return nil, errNoSuchName
}
// Records implements the SkyDNS Backend interface and returns standard records for
// a name.
//
// The standard pattern is <prefix>.<service_name>.<namespace>.(svc|endpoints).<base>
//
// * prefix may be any series of prefix values
// * service_name and namespace must locate a real service
// * svc indicates standard service rules apply (portalIP or endpoints as A records)
// * reverse lookup of IP is only possible for portalIP
// * SRV records are returned for each host+port combination as:
// _<port_name>._<port_protocol>.<dns>
// _<port_name>.<endpoint_id>.<dns>
// * endpoint_id is "portal" when portalIP is set
// * endpoints always returns each individual endpoint as A records
//
func (b *ServiceResolver) Records(name string, exact bool) ([]msg.Service, error) {
if !strings.HasSuffix(name, b.base) {
return nil, nil
}
prefix := strings.Trim(strings.TrimSuffix(name, b.base), ".")
segments := strings.Split(prefix, ".")
for i, j := 0, len(segments)-1; i < j; i, j = i+1, j-1 {
segments[i], segments[j] = segments[j], segments[i]
}
if len(segments) == 0 {
return nil, nil
}
switch segments[0] {
case "svc", "endpoints":
if len(segments) < 3 {
return nil, nil
}
namespace, name := segments[1], segments[2]
svc, err := b.accessor.Services(namespace).Get(name)
if err != nil {
if errors.IsNotFound(err) && b.fallback != nil {
if fallback, ok := b.fallback(prefix, exact); ok {
return b.Records(fallback+b.base, exact)
}
}
return nil, err
}
// no portalIP and not headless, no DNS
if len(svc.Spec.ClusterIP) == 0 {
return nil, nil
}
retrieveEndpoints := segments[0] == "endpoints" || (len(segments) > 3 && segments[3] == "_endpoints")
// if has a portal IP and looking at svc
if svc.Spec.ClusterIP != kapi.ClusterIPNone && !retrieveEndpoints {
if len(svc.Spec.Ports) == 0 {
return nil, nil
}
services := []msg.Service{}
for _, p := range svc.Spec.Ports {
port := p.Port
if port == 0 {
port = p.TargetPort.IntVal
}
if port == 0 {
continue
}
if len(p.Protocol) == 0 {
p.Protocol = kapi.ProtocolTCP
}
portName := p.Name
if len(portName) == 0 {
portName = fmt.Sprintf("unknown-port-%d", port)
}
srvName := fmt.Sprintf("%s.portal.%s", portName, name)
keyName := fmt.Sprintf("_%s._%s.%s", portName, p.Protocol, name)
services = append(services,
msg.Service{
Host: svc.Spec.ClusterIP,
Port: port,
Priority: 10,
Weight: 10,
Ttl: 30,
Text: "",
Key: msg.Path(srvName),
},
msg.Service{
Host: srvName,
Port: port,
Priority: 10,
Weight: 10,
Ttl: 30,
Text: "",
Key: msg.Path(keyName),
},
)
}
return services, nil
}
// return endpoints
endpoints, err := b.endpoints.Endpoints(namespace).Get(name)
if err != nil {
return nil, err
}
targets := make(map[string]int)
services := make([]msg.Service, 0, len(endpoints.Subsets)*4)
count := 1
for _, s := range endpoints.Subsets {
for _, a := range s.Addresses {
shortName := ""
if a.TargetRef != nil {
name := fmt.Sprintf("%s-%s", a.TargetRef.Name, a.TargetRef.Namespace)
if c, ok := targets[name]; ok {
shortName = fmt.Sprintf("e%d", c)
} else {
shortName = fmt.Sprintf("e%d", count)
targets[name] = count
count++
}
} else {
shortName = fmt.Sprintf("e%d", count)
count++
}
hadPort := false
for _, p := range s.Ports {
port := p.Port
if port == 0 {
continue
}
hadPort = true
if len(p.Protocol) == 0 {
p.Protocol = kapi.ProtocolTCP
}
portName := p.Name
if len(portName) == 0 {
portName = fmt.Sprintf("unknown-port-%d", port)
}
srvName := fmt.Sprintf("%s.%s.%s", portName, shortName, name)
services = append(services, msg.Service{
Host: a.IP,
Port: port,
Priority: 10,
Weight: 10,
Ttl: 30,
Text: "",
Key: msg.Path(srvName),
})
keyName := fmt.Sprintf("_%s._%s.%s", portName, p.Protocol, name)
services = append(services, msg.Service{
Host: srvName,
Port: port,
Priority: 10,
Weight: 10,
Ttl: 30,
Text: "",
Key: msg.Path(keyName),
})
}
if !hadPort {
services = append(services, msg.Service{
Host: a.IP,
Priority: 10,
Weight: 10,
Ttl: 30,
Text: "",
Key: msg.Path(name),
})
}
}
}
return services, nil
}
return nil, nil
}
// SRVRecords returns SRV records from etcd.
// If the Target is not an name but an IP address, an name is created .
func (s *server) SRVRecords(q dns.Question, name string, bufsize uint16, dnssec bool) (records []dns.RR, extra []dns.RR, err error) {
path, star := msg.PathWithWildcard(name)
r, err := get(s.client, path, true)
if err != nil {
return nil, nil, err
}
if !r.Node.Dir { // single element
serv := new(msg.Service)
if err := json.Unmarshal([]byte(r.Node.Value), serv); err != nil {
s.config.log.Infof("failed to parse json: %s", err.Error())
return nil, nil, err
}
ip := net.ParseIP(serv.Host)
ttl := s.calculateTtl(r.Node, serv)
if serv.Priority == 0 {
serv.Priority = int(s.config.Priority)
}
serv.Key = r.Node.Key
serv.Ttl = ttl
switch {
case ip == nil:
srv := serv.NewSRV(q.Name, uint16(100))
records = append(records, srv)
if !dns.IsSubDomain(s.config.Domain, srv.Target) {
m1, e1 := s.Lookup(srv.Target, dns.TypeA, bufsize, dnssec)
if e1 == nil {
extra = append(extra, m1.Answer...)
}
m1, e1 = s.Lookup(srv.Target, dns.TypeAAAA, bufsize, dnssec)
if e1 == nil {
// If we have seen CNAME's we *assume* that they already added.
for _, a := range m1.Answer {
if _, ok := a.(*dns.CNAME); !ok {
extra = append(extra, a)
}
}
}
}
case ip.To4() != nil:
serv.Host = msg.Domain(serv.Key)
records = append(records, serv.NewSRV(q.Name, uint16(100)))
extra = append(extra, serv.NewA(serv.Host, ip.To4()))
case ip.To4() == nil:
serv.Host = msg.Domain(serv.Key)
records = append(records, serv.NewSRV(q.Name, uint16(100)))
extra = append(extra, serv.NewAAAA(serv.Host, ip.To16()))
}
return records, extra, nil
}
sx, err := s.loopNodes(&r.Node.Nodes, strings.Split(msg.Path(name), "/"), star, nil)
if err != nil || len(sx) == 0 {
return nil, nil, err
}
// Looping twice to get the right weight vs priority
w := make(map[int]int)
for _, serv := range sx {
weight := 100
if serv.Weight != 0 {
weight = serv.Weight
}
if _, ok := w[serv.Priority]; !ok {
w[serv.Priority] = weight
continue
}
w[serv.Priority] += weight
}
lookup := make(map[string]bool)
for _, serv := range sx {
w1 := 100.0 / float64(w[serv.Priority])
if serv.Weight == 0 {
w1 *= 100
} else {
w1 *= float64(serv.Weight)
}
weight := uint16(math.Floor(w1))
ip := net.ParseIP(serv.Host)
switch {
case ip == nil:
srv := serv.NewSRV(q.Name, weight)
records = append(records, srv)
if _, ok := lookup[srv.Target]; !ok {
if !dns.IsSubDomain(s.config.Domain, srv.Target) {
m1, e1 := s.Lookup(srv.Target, dns.TypeA, bufsize, dnssec)
if e1 == nil {
extra = append(extra, m1.Answer...)
}
m1, e1 = s.Lookup(srv.Target, dns.TypeAAAA, bufsize, dnssec)
if e1 == nil {
// If we have seen CNAME's we *assume* that they are already added.
for _, a := range m1.Answer {
if _, ok := a.(*dns.CNAME); !ok {
extra = append(extra, a)
}
}
}
}
}
lookup[srv.Target] = true
case ip.To4() != nil:
serv.Host = msg.Domain(serv.Key)
records = append(records, serv.NewSRV(q.Name, weight))
extra = append(extra, serv.NewA(serv.Host, ip.To4()))
case ip.To4() == nil:
serv.Host = msg.Domain(serv.Key)
records = append(records, serv.NewSRV(q.Name, weight))
extra = append(extra, serv.NewAAAA(serv.Host, ip.To16()))
}
}
return records, extra, nil
}
func main() {
flag.Parse()
machines := strings.Split(machine, ",")
client, err := newEtcdClient(machines, tlspem, tlskey, cacert)
if err != nil {
panic(err)
}
if nameserver != "" {
for _, hostPort := range strings.Split(nameserver, ",") {
if err := validateHostPort(hostPort); err != nil {
log.Fatalf("skydns: nameserver is invalid: %s", err)
}
config.Nameservers = append(config.Nameservers, hostPort)
}
}
if err := validateHostPort(config.DnsAddr); err != nil {
log.Fatalf("skydns: addr is invalid: %s", err)
}
if err := loadConfig(client, config); err != nil {
log.Fatalf("skydns: %s", err)
}
if err := server.SetDefaults(config); err != nil {
log.Fatalf("skydns: defaults could not be set from /etc/resolv.conf: %v", err)
}
if config.Local != "" {
config.Local = dns.Fqdn(config.Local)
}
backend := backendetcd.NewBackend(client, ctx, &backendetcd.Config{
Ttl: config.Ttl,
Priority: config.Priority,
})
s := server.New(backend, config)
if stub {
s.UpdateStubZones()
go func() {
duration := 1 * time.Second
var watcher etcd.Watcher
watcher = client.Watcher(msg.Path(config.Domain)+"/dns/stub/", &etcd.WatcherOptions{AfterIndex: 0, Recursive: true})
for {
_, err := watcher.Next(ctx)
if err != nil {
//
log.Printf("skydns: stubzone update failed, sleeping %s + ~3s", duration)
time.Sleep(duration + (time.Duration(rand.Float32() * 3e9))) // Add some random.
duration *= 2
if duration > 32*time.Second {
duration = 32 * time.Second
}
} else {
s.UpdateStubZones()
log.Printf("skydns: stubzone update")
duration = 1 * time.Second // reset
}
}
}()
}
if err := metrics.Metrics(); err != nil {
log.Fatalf("skydns: %s", err)
} else {
log.Printf("skydns: metrics enabled on :%s%s", metrics.Port, metrics.Path)
}
if err := s.Run(); err != nil {
log.Fatalf("skydns: %s", err)
}
}
func (s *server) AddressRecords(q dns.Question, name string, previousRecords []dns.RR) (records []dns.RR, err error) {
path, star := msg.PathWithWildcard(name)
r, err := get(s.client, path, true)
if err != nil {
return nil, err
}
if !r.Node.Dir { // single element
serv := new(msg.Service)
if err := json.Unmarshal([]byte(r.Node.Value), serv); err != nil {
s.config.log.Infof("failed to parse json: %s", err.Error())
return nil, err
}
ip := net.ParseIP(serv.Host)
ttl := s.calculateTtl(r.Node, serv)
serv.Ttl = ttl
serv.Key = r.Node.Key
switch {
case ip == nil:
// Try to resolve as CNAME if it's not an IP.
newRecord := serv.NewCNAME(q.Name, dns.Fqdn(serv.Host))
if len(previousRecords) > 7 {
s.config.log.Errorf("CNAME lookup limit of 8 exceeded for %s", newRecord)
return nil, fmt.Errorf("exceeded CNAME lookup limit")
}
if s.isDuplicateCNAME(newRecord, previousRecords) {
s.config.log.Errorf("CNAME loop detected for record %s", newRecord)
return nil, fmt.Errorf("detected CNAME loop")
}
records = append(records, newRecord)
nextRecords, err := s.AddressRecords(dns.Question{Name: dns.Fqdn(serv.Host), Qtype: q.Qtype, Qclass: q.Qclass}, strings.ToLower(dns.Fqdn(serv.Host)), append(previousRecords, newRecord))
if err != nil {
// This means we can not complete the CNAME, this is OK, but
// if we return an error this will trigger an NXDOMAIN.
// We also don't want to return the CNAME, because of the
// no other data rule. So return nothing and let NODATA
// kick in (via a hack).
return records, fmt.Errorf("incomplete CNAME chain")
}
records = append(records, nextRecords...)
case ip.To4() != nil && q.Qtype == dns.TypeA:
records = append(records, serv.NewA(q.Name, ip.To4()))
case ip.To4() == nil && q.Qtype == dns.TypeAAAA:
records = append(records, serv.NewAAAA(q.Name, ip.To16()))
}
return records, nil
}
nodes, err := s.loopNodes(&r.Node.Nodes, strings.Split(msg.Path(name), "/"), star, nil)
if err != nil {
s.config.log.Infof("failed to parse json: %s", err.Error())
return nil, err
}
for _, serv := range nodes {
ip := net.ParseIP(serv.Host)
switch {
case ip == nil:
// TODO: deduplicate with above code
// Try to resolve as CNAME if it's not an IP.
newRecord := serv.NewCNAME(q.Name, dns.Fqdn(serv.Host))
if len(previousRecords) > 7 {
s.config.log.Errorf("CNAME lookup limit of 8 exceeded for %s", newRecord)
return nil, fmt.Errorf("exceeded CNAME lookup limit")
}
if s.isDuplicateCNAME(newRecord, previousRecords) {
s.config.log.Errorf("CNAME loop detected for record %s", newRecord)
return nil, fmt.Errorf("detected CNAME loop")
}
records = append(records, newRecord)
nextRecords, err := s.AddressRecords(dns.Question{Name: dns.Fqdn(serv.Host), Qtype: q.Qtype, Qclass: q.Qclass}, strings.ToLower(dns.Fqdn(serv.Host)), append(previousRecords, newRecord))
if err != nil {
// This means we can not complete the CNAME, this is OK, but
// if we return an error this will trigger an NXDOMAIN.
// We also don't want to return the CNAME, because of the
// no other data rule. So return nothing and let NODATA
// kick in (via a hack).
return records, fmt.Errorf("incomplete CNAME chain")
}
records = append(records, nextRecords...)
case ip.To4() != nil && q.Qtype == dns.TypeA:
records = append(records, serv.NewA(q.Name, ip.To4()))
case ip.To4() == nil && q.Qtype == dns.TypeAAAA:
records = append(records, serv.NewAAAA(q.Name, ip.To16()))
}
}
if s.config.RoundRobin {
switch l := len(records); l {
case 2:
if dns.Id()%2 == 0 {
records[0], records[1] = records[1], records[0]
}
default:
// Do a minimum of l swap, maximum of 4l swaps
for j := 0; j < l*(int(dns.Id())%4+1); j++ {
q := int(dns.Id()) % l
p := int(dns.Id()) % l
if q == p {
p = (p + 1) % l
}
records[q], records[p] = records[p], records[q]
}
}
}
return records, nil
}
func main() {
flag.Parse()
if config.Version {
fmt.Printf("skydns server version: %s\n", server.Version)
os.Exit(0)
}
machines := strings.Split(machine, ",")
var clientptr *etcdv3.Client
var err error
var clientv3 etcdv3.Client
var clientv2 etcd.KeysAPI
if config.Etcd3 {
clientptr, err = newEtcdV3Client(machines, tlspem, tlskey, cacert)
clientv3 = *clientptr
} else {
clientv2, err = newEtcdV2Client(machines, tlspem, tlskey, cacert, username, password)
}
if err != nil {
panic(err)
}
if nameserver != "" {
for _, hostPort := range strings.Split(nameserver, ",") {
if err := validateHostPort(hostPort); err != nil {
log.Fatalf("skydns: nameserver is invalid: %s", err)
}
config.Nameservers = append(config.Nameservers, hostPort)
}
}
if err := validateHostPort(config.DnsAddr); err != nil {
log.Fatalf("skydns: addr is invalid: %s", err)
}
if config.Etcd3 {
if err := loadEtcdV3Config(clientv3, config); err != nil {
log.Fatalf("skydns: %s", err)
}
} else {
if err := loadEtcdV2Config(clientv2, config); err != nil {
log.Fatalf("skydns: %s", err)
}
}
if err := server.SetDefaults(config); err != nil {
log.Fatalf("skydns: defaults could not be set from /etc/resolv.conf: %v", err)
}
if config.Local != "" {
config.Local = dns.Fqdn(config.Local)
}
var backend server.Backend
if config.Etcd3 {
backend = backendetcdv3.NewBackendv3(clientv3, ctx, &backendetcdv3.Config{
Ttl: config.Ttl,
Priority: config.Priority,
})
} else {
backend = backendetcd.NewBackend(clientv2, ctx, &backendetcd.Config{
Ttl: config.Ttl,
Priority: config.Priority,
})
}
s := server.New(backend, config)
if stub {
s.UpdateStubZones()
go func() {
duration := 1 * time.Second
if config.Etcd3 {
var watcher etcdv3.WatchChan
watcher = clientv3.Watch(ctx, msg.Path(config.Domain)+"/dns/stub/", etcdv3.WithPrefix())
for wresp := range watcher {
if wresp.Err() != nil {
log.Printf("skydns: stubzone update failed, sleeping %s + ~3s", duration)
time.Sleep(duration + (time.Duration(rand.Float32() * 3e9)))
duration *= 2
if duration > 32*time.Second {
duration = 32 * time.Second
}
} else {
s.UpdateStubZones()
log.Printf("skydns: stubzone update")
duration = 1 * time.Second //reset
}
}
} else {
var watcher etcd.Watcher
watcher = clientv2.Watcher(msg.Path(config.Domain)+"/dns/stub/", &etcd.WatcherOptions{AfterIndex: 0, Recursive: true})
for {
_, err := watcher.Next(ctx)
if err != nil {
//
log.Printf("skydns: stubzone update failed, sleeping %s + ~3s", duration)
time.Sleep(duration + (time.Duration(rand.Float32() * 3e9))) // Add some random.
duration *= 2
if duration > 32*time.Second {
duration = 32 * time.Second
}
} else {
s.UpdateStubZones()
log.Printf("skydns: stubzone update")
duration = 1 * time.Second // reset
}
}
}
}()
}
if err := metrics.Metrics(); err != nil {
log.Fatalf("skydns: %s", err)
} else {
log.Printf("skydns: metrics enabled on :%s%s", metrics.Port, metrics.Path)
}
if err := s.Run(); err != nil {
log.Fatalf("skydns: %s", err)
}
}
// Records implements the SkyDNS Backend interface and returns standard records for
// a name.
//
// The standard pattern is <prefix>.<service_name>.<namespace>.(svc|endpoints|pod).<base>
//
// * prefix may be any series of prefix values
// * _endpoints is a special prefix that returns the same as <service_name>.<namespace>.svc.<base>
// * service_name and namespace must locate a real service
// * unless a fallback is defined, in which case the fallback name will be looked up
// * svc indicates standard service rules apply (portalIP or endpoints as A records)
// * reverse lookup of IP is only possible for portalIP
// * SRV records are returned for each host+port combination as:
// _<port_name>._<port_protocol>.<dns>
// _<port_name>.<endpoint_id>.<dns>
// * endpoints always returns each individual endpoint as A records
// * SRV records for endpoints are similar to SVC, but are prefixed with a single label
// that is a hash of the endpoint IP
// * pods is of the form <IP_with_dashes>.<namespace>.pod.<base> and resolves to <IP>
//
func (b *ServiceResolver) Records(dnsName string, exact bool) ([]msg.Service, error) {
if !strings.HasSuffix(dnsName, b.base) {
return nil, nil
}
prefix := strings.Trim(strings.TrimSuffix(dnsName, b.base), ".")
segments := strings.Split(prefix, ".")
for i, j := 0, len(segments)-1; i < j; i, j = i+1, j-1 {
segments[i], segments[j] = segments[j], segments[i]
}
if len(segments) == 0 {
return nil, nil
}
glog.V(4).Infof("Answering query %s:%t", dnsName, exact)
switch base := segments[0]; base {
case "pod":
if len(segments) != 3 {
return nil, nil
}
namespace, encodedIP := segments[1], segments[2]
ip := convertDashIPToIP(encodedIP)
if net.ParseIP(ip) == nil {
return nil, nil
}
return []msg.Service{
{
Host: ip,
Port: 0,
Priority: 10,
Weight: 10,
Ttl: 30,
Key: msg.Path(buildDNSName(b.base, "pod", namespace, getHash(ip))),
},
}, nil
case "svc", "endpoints":
if len(segments) < 3 {
return nil, nil
}
namespace, name := segments[1], segments[2]
svc, err := b.accessor.Services(namespace).Get(name)
if err != nil {
if errors.IsNotFound(err) && b.fallback != nil {
if fallback, ok := b.fallback(prefix, exact); ok {
return b.Records(fallback+b.base, exact)
}
}
return nil, err
}
// no portalIP and not headless, no DNS
if len(svc.Spec.ClusterIP) == 0 {
return nil, nil
}
subdomain := buildDNSName(b.base, base, namespace, name)
endpointPrefix := base == "endpoints"
retrieveEndpoints := endpointPrefix || (len(segments) > 3 && segments[3] == "_endpoints")
// if has a portal IP and looking at svc
if svc.Spec.ClusterIP != kapi.ClusterIPNone && !retrieveEndpoints {
defaultService := msg.Service{
Host: svc.Spec.ClusterIP,
Port: 0,
Priority: 10,
Weight: 10,
Ttl: 30,
}
defaultHash := getHash(defaultService.Host)
defaultName := buildDNSName(subdomain, defaultHash)
defaultService.Key = msg.Path(defaultName)
if len(svc.Spec.Ports) == 0 {
return []msg.Service{defaultService}, nil
}
services := []msg.Service{}
if len(segments) == 3 {
for _, p := range svc.Spec.Ports {
port := p.Port
if port == 0 {
port = p.TargetPort.IntVal
}
if port == 0 {
continue
}
if len(p.Protocol) == 0 {
p.Protocol = kapi.ProtocolTCP
}
portName := p.Name
if len(portName) == 0 {
portName = fmt.Sprintf("unknown-port-%d", port)
}
keyName := buildDNSName(subdomain, "_"+strings.ToLower(string(p.Protocol)), "_"+portName)
services = append(services,
msg.Service{
Host: svc.Spec.ClusterIP,
Port: port,
Priority: 10,
Weight: 10,
Ttl: 30,
Key: msg.Path(keyName),
},
)
}
}
if len(services) == 0 {
services = append(services, defaultService)
}
glog.V(4).Infof("Answered %s:%t with %#v", dnsName, exact, services)
return services, nil
}
// return endpoints
endpoints, err := b.endpoints.Endpoints(namespace).Get(name)
if err != nil {
return nil, err
}
services := make([]msg.Service, 0, len(endpoints.Subsets)*4)
for _, s := range endpoints.Subsets {
for _, a := range s.Addresses {
defaultService := msg.Service{
Host: a.IP,
Port: 0,
Priority: 10,
Weight: 10,
Ttl: 30,
}
defaultHash := getHash(defaultService.Host)
defaultName := buildDNSName(subdomain, defaultHash)
defaultService.Key = msg.Path(defaultName)
for _, p := range s.Ports {
port := p.Port
if port == 0 {
continue
}
if len(p.Protocol) == 0 {
p.Protocol = kapi.ProtocolTCP
}
portName := p.Name
if len(portName) == 0 {
portName = fmt.Sprintf("unknown-port-%d", port)
}
keyName := buildDNSName(subdomain, "_"+strings.ToLower(string(p.Protocol)), "_"+portName, defaultHash)
services = append(services, msg.Service{
Host: a.IP,
Port: port,
Priority: 10,
Weight: 10,
Ttl: 30,
Key: msg.Path(keyName),
})
}
if len(services) == 0 {
services = append(services, defaultService)
}
}
}
glog.V(4).Infof("Answered %s:%t with %#v", dnsName, exact, services)
return services, nil
}
return nil, nil
}
func (ksync *KubernetesSync) removeDNS(service string, info *serviceInfo) error {
// Remove from SkyDNS registration
log.Printf("removing %s from DNS", service)
_, err := ksync.eclient.Delete(msg.Path(service), true)
return err
}
func (ks *kube2sky) writeSkyRecord(subdomain string, data string) error {
// Set with no TTL, and hope that kubernetes events are accurate.
_, err := ks.etcdClient.Set(skymsg.Path(subdomain), data, uint64(0))
return err
}
func (ks *kube2sky) removeDNS(record string) error {
glog.V(2).Infof("Removing %s from DNS", record)
_, err := ks.etcdClient.Delete(skymsg.Path(record), true)
return err
}