Rename functions and vars to make more sense

cmd/meshnamed/main.go

@@ -29,9 +29,9 @@ func parseNetworks(networksconf string) (map[string]*net.IPNet, error) {
 }
 
 func loadConfig(s *meshname.MeshnameServer, confPath string) error {
-	zoneConf, err := meshname.ParseConfigFile(confPath)
+	dnsRecords, err := meshname.ParseConfigFile(confPath)
 	if err == nil {
-		s.SetZoneConfig(zoneConf)
+		s.ConfigureDNSRecords(dnsRecords)
 	}
 	return err
 }
@@ -74,14 +74,14 @@ func main() {
 	s := meshname.New(logger, listenAddr)
 
 	if networks, err := parseNetworks(networksconf); err == nil {
-		s.SetNetworks(networks)
+		s.ConfigureNetworks(networks)
 	} else {
-		logger.Errorln(err)
+		logger.Fatalln(err)
 	}
 
 	if useconffile != "" {
 		if err := loadConfig(s, useconffile); err != nil {
-			logger.Errorln(err)
+			logger.Fatalln(err)
 		}
 	}
 

pkg/meshname/config.go

@@ -22,7 +22,7 @@ func GenConf(target, zone string) (string, error) {
 	return confString, nil
 }
 
-// Load zoneConfig from a JSON file
+// Load dnsRecords from a JSON file
 func ParseConfigFile(configPath string) (map[string][]dns.RR, error) {
 	conf, err := ioutil.ReadFile(configPath)
 	if err != nil {
@@ -30,22 +30,23 @@ func ParseConfigFile(configPath string) (map[string][]dns.RR, error) {
 	}
 	var dat map[string][]string
 	if err := json.Unmarshal(conf, &dat); err == nil {
-		return ParseZoneConfigMap(dat)
+		return ParseDNSRecordsMap(dat)
 	} else {
 		return nil, err
 	}
 }
 
-func ParseZoneConfigMap(zoneConfigMap map[string][]string) (map[string][]dns.RR, error) {
+// ParseDNSRecordsMap takes a string map and returns a resource record map
-	var zoneConfig = make(map[string][]dns.RR)
+func ParseDNSRecordsMap(dnsRecordsMap map[string][]string) (map[string][]dns.RR, error) {
-	for subDomain, records := range zoneConfigMap {
+	var dnsRecords = make(map[string][]dns.RR)
+	for subDomain, records := range dnsRecordsMap {
 		for _, r := range records {
 			if rr, err := dns.NewRR(r); err == nil {
-				zoneConfig[subDomain] = append(zoneConfig[subDomain], rr)
+				dnsRecords[subDomain] = append(dnsRecords[subDomain], rr)
 			} else {
 				return nil, err
 			}
 		}
 	}
-	return zoneConfig, nil
+	return dnsRecords, nil
 }

pkg/meshname/server.go

@@ -17,8 +17,8 @@ type MeshnameServer struct {
 	dnsServer  *dns.Server
 	networks   map[string]*net.IPNet
 
-	zoneConfigLock sync.RWMutex
+	dnsRecordsLock sync.RWMutex
-	zoneConfig     map[string][]dns.RR
+	dnsRecords     map[string][]dns.RR
 
 	startedLock sync.RWMutex
 	started     bool
@@ -32,7 +32,7 @@ func New(log *log.Logger, listenAddr string) *MeshnameServer {
 	return &MeshnameServer{
 		log:        log,
 		listenAddr: listenAddr,
-		zoneConfig: make(map[string][]dns.RR),
+		dnsRecords: make(map[string][]dns.RR),
 		networks:   make(map[string]*net.IPNet),
 		dnsClient:  dnsClient,
 	}
@@ -69,13 +69,13 @@ func (s *MeshnameServer) Start() error {
 	}
 }
 
-func (s *MeshnameServer) SetZoneConfig(zoneConfig map[string][]dns.RR) {
+func (s *MeshnameServer) ConfigureDNSRecords(dnsRecords map[string][]dns.RR) {
-	s.zoneConfigLock.Lock()
+	s.dnsRecordsLock.Lock()
-	s.zoneConfig = zoneConfig
+	s.dnsRecords = dnsRecords
-	s.zoneConfigLock.Unlock()
+	s.dnsRecordsLock.Unlock()
 }
 
-func (s *MeshnameServer) SetNetworks(networks map[string]*net.IPNet) {
+func (s *MeshnameServer) ConfigureNetworks(networks map[string]*net.IPNet) {
 	s.networks = networks
 }
 
@@ -84,7 +84,7 @@ func (s *MeshnameServer) handleRequest(w dns.ResponseWriter, r *dns.Msg) {
 	m := new(dns.Msg)
 	m.SetReply(r)
 
-	s.zoneConfigLock.RLock()
+	s.dnsRecordsLock.RLock()
 	for _, q := range r.Question {
 		labels := dns.SplitDomainName(q.Name)
 		if len(labels) < 2 {
@@ -93,7 +93,7 @@ func (s *MeshnameServer) handleRequest(w dns.ResponseWriter, r *dns.Msg) {
 		}
 		subDomain := labels[len(labels)-2]
 
-		if records, ok := s.zoneConfig[subDomain]; ok {
+		if records, ok := s.dnsRecords[subDomain]; ok {
 			for _, rec := range records {
 				if h := rec.Header(); h.Name == q.Name && h.Rrtype == q.Qtype && h.Class == q.Qclass {
 					m.Answer = append(m.Answer, rec)
@@ -116,7 +116,7 @@ func (s *MeshnameServer) handleRequest(w dns.ResponseWriter, r *dns.Msg) {
 			}
 		}
 	}
-	s.zoneConfigLock.RUnlock()
+	s.dnsRecordsLock.RUnlock()
 
 	for remoteServer, questions := range remoteLookups {
 		rm := new(dns.Msg)

pkg/meshname/server_test.go

@@ -17,16 +17,15 @@ func TestServerLocalDomain(t *testing.T) {
 	log := log.New(os.Stdout, "", log.Flags())
 
 	ts := meshname.New(log, bindAddr)
-	// ...
 	yggIPNet := &net.IPNet{IP: net.ParseIP("200::"), Mask: net.CIDRMask(7, 128)}
-	ts.SetNetworks(map[string]*net.IPNet{"ygg": yggIPNet, "meshname": yggIPNet})
+	ts.ConfigureNetworks(map[string]*net.IPNet{"ygg": yggIPNet, "meshname": yggIPNet})
 
 	exampleConfig := make(map[string][]string)
 	exampleConfig["aiarnf2wpqjxkp6rhivuxbondy"] = append(exampleConfig["aiarnf2wpqjxkp6rhivuxbondy"],
 		"test.aiarnf2wpqjxkp6rhivuxbondy.meshname. AAAA 201:1697:567c:1375:3fd1:3a2b:4b85:cd1e")
 
-	if zoneConfig, err := meshname.ParseZoneConfigMap(exampleConfig); err == nil {
+	if dnsRecords, err := meshname.ParseDNSRecordsMap(exampleConfig); err == nil {
-		ts.SetZoneConfig(zoneConfig)
+		ts.ConfigureDNSRecords(dnsRecords)
 	} else {
 		t.Fatalf("meshname: Failed to parse Meshname config: %s", err)
 	}