mirror of https://github.com/status-im/consul.git
103 lines
3.1 KiB
Go
103 lines
3.1 KiB
Go
// Copyright (c) HashiCorp, Inc.
|
|
// SPDX-License-Identifier: BUSL-1.1
|
|
|
|
//go:build !consulent
|
|
|
|
package agent
|
|
|
|
import (
|
|
"fmt"
|
|
|
|
"github.com/hashicorp/consul/acl"
|
|
"github.com/hashicorp/consul/agent/config"
|
|
agentdns "github.com/hashicorp/consul/agent/dns"
|
|
"github.com/hashicorp/consul/agent/structs"
|
|
)
|
|
|
|
// NOTE: these functions have also been copied to agent/dns package for dns v2.
|
|
// If you change these functions, please also change the ones in agent/dns as well.
|
|
// These v1 versions will soon be deprecated.
|
|
|
|
type enterpriseDNSConfig struct{}
|
|
|
|
func getEnterpriseDNSConfig(conf *config.RuntimeConfig) enterpriseDNSConfig {
|
|
return enterpriseDNSConfig{}
|
|
}
|
|
|
|
// parseLocality can parse peer name or datacenter from a DNS query's labels.
|
|
// Peer name is parsed from the same query part that datacenter is, so given this ambiguity
|
|
// we parse a "peerOrDatacenter". The caller or RPC handler are responsible for disambiguating.
|
|
func (d *DNSServer) parseLocality(labels []string, cfg *dnsRequestConfig) (queryLocality, bool) {
|
|
locality := queryLocality{
|
|
EnterpriseMeta: cfg.defaultEnterpriseMeta,
|
|
}
|
|
|
|
switch len(labels) {
|
|
case 2, 4:
|
|
// Support the following formats:
|
|
// - [.<datacenter>.dc]
|
|
// - [.<peer>.peer]
|
|
for i := 0; i < len(labels); i += 2 {
|
|
switch labels[i+1] {
|
|
case "dc":
|
|
locality.datacenter = labels[i]
|
|
case "peer":
|
|
locality.peer = labels[i]
|
|
default:
|
|
return queryLocality{}, false
|
|
}
|
|
}
|
|
// Return error when both datacenter and peer are specified.
|
|
if locality.datacenter != "" && locality.peer != "" {
|
|
return queryLocality{}, false
|
|
}
|
|
return locality, true
|
|
case 1:
|
|
return queryLocality{
|
|
peerOrDatacenter: labels[0],
|
|
EnterpriseMeta: cfg.defaultEnterpriseMeta,
|
|
}, true
|
|
|
|
case 0:
|
|
return queryLocality{}, true
|
|
}
|
|
|
|
return queryLocality{}, false
|
|
}
|
|
|
|
type querySameness struct{}
|
|
|
|
// parseSamenessGroupLocality wraps parseLocality in CE
|
|
func (d *DNSServer) parseSamenessGroupLocality(cfg *dnsRequestConfig, labels []string, errfnc func() error) (queryLocality, error) {
|
|
locality, ok := d.parseLocality(labels, cfg)
|
|
if !ok {
|
|
return queryLocality{
|
|
EnterpriseMeta: cfg.defaultEnterpriseMeta,
|
|
}, errfnc()
|
|
}
|
|
return locality, nil
|
|
}
|
|
|
|
func serviceCanonicalDNSName(name, kind, datacenter, domain string, _ *acl.EnterpriseMeta) string {
|
|
return fmt.Sprintf("%s.%s.%s.%s", name, kind, datacenter, domain)
|
|
}
|
|
|
|
func nodeCanonicalDNSName(node *structs.Node, respDomain string) string {
|
|
if node.PeerName != "" {
|
|
// We must return a more-specific DNS name for peering so
|
|
// that there is no ambiguity with lookups.
|
|
return fmt.Sprintf("%s.node.%s.peer.%s",
|
|
node.Node,
|
|
node.PeerName,
|
|
respDomain)
|
|
}
|
|
// Return a simpler format for non-peering nodes.
|
|
return fmt.Sprintf("%s.node.%s.%s", node.Node, node.Datacenter, respDomain)
|
|
}
|
|
|
|
// setEnterpriseMetaFromRequestContext sets the DefaultNamespace and DefaultPartition on the requestDnsConfig
|
|
// based on the requestContext's DefaultNamespace and DefaultPartition.
|
|
func (d *DNSServer) setEnterpriseMetaFromRequestContext(requestContext agentdns.Context, requestDnsConfig *dnsRequestConfig) {
|
|
// do nothing
|
|
}
|