Change dns.RR_* to dns.* as per dns library changes

config.go

@@ -247,13 +247,13 @@ func setupZoneData(data map[string]interface{}, Zone *Zone) {
 					switch dnsType {
 					case dns.TypeA:
 						if x := net.ParseIP(ip); x != nil {
-							record.RR = &dns.RR_A{Hdr: h, A: x}
+							record.RR = &dns.A{Hdr: h, A: x}
 							break
 						}
 						panic("Bad A record")
 					case dns.TypeAAAA:
 						if x := net.ParseIP(ip); x != nil {
-							record.RR = &dns.RR_AAAA{Hdr: h, AAAA: x}
+							record.RR = &dns.AAAA{Hdr: h, AAAA: x}
 							break
 						}
 						panic("Bad AAAA record")
@@ -272,7 +272,7 @@ func setupZoneData(data map[string]interface{}, Zone *Zone) {
 					if rec["preference"] != nil {
 						pref = uint16(valueToInt(rec["preference"]))
 					}
-					record.RR = &dns.RR_MX{
+					record.RR = &dns.MX{
 						Hdr:        h,
 						Mx:         mx,
 						Preference: pref}
@@ -283,12 +283,12 @@ func setupZoneData(data map[string]interface{}, Zone *Zone) {
 					if !dns.IsFqdn(target) {
 						target = target + "." + Zone.Origin
 					}
-					record.RR = &dns.RR_CNAME{Hdr: h, Target: dns.Fqdn(target)}
+					record.RR = &dns.CNAME{Hdr: h, Target: dns.Fqdn(target)}
 
 				case dns.TypeMF:
 					rec := records[rType][i]
 					// MF records (how we store aliases) are not FQDNs
-					record.RR = &dns.RR_MF{Hdr: h, Mf: rec.(string)}
+					record.RR = &dns.MF{Hdr: h, Mf: rec.(string)}
 
 				case dns.TypeNS:
 					rec := records[rType][i]
@@ -312,7 +312,7 @@ func setupZoneData(data map[string]interface{}, Zone *Zone) {
 						panic("Unrecognized NS format/syntax")
 					}
 
-					rr := &dns.RR_NS{Hdr: h, Ns: dns.Fqdn(ns)}
+					rr := &dns.NS{Hdr: h, Ns: dns.Fqdn(ns)}
 
 					record.RR = rr
 
@@ -345,7 +345,7 @@ func setupSOA(Zone *Zone) {
 	primaryNs := "ns"
 
 	if record, ok := label.Records[dns.TypeNS]; ok {
-		primaryNs = record[0].RR.(*dns.RR_NS).Ns
+		primaryNs = record[0].RR.(*dns.NS).Ns
 	}
 
 	s := Zone.Origin + ". 3600 IN SOA " +

config_test.go

@@ -33,15 +33,15 @@ func (s *ConfigSuite) TestReadConfigs(c *C) {
 
 	/* test different cname targets */
 	c.Check(tz.Labels["www"].
-		firstRR(dns.TypeCNAME).(*dns.RR_CNAME).
+		firstRR(dns.TypeCNAME).(*dns.CNAME).
 		Target, Equals, "geo.bitnames.com.")
 
 	c.Check(tz.Labels["www-cname"].
-		firstRR(dns.TypeCNAME).(*dns.RR_CNAME).
+		firstRR(dns.TypeCNAME).(*dns.CNAME).
 		Target, Equals, "bar.test.example.com.")
 
 	c.Check(tz.Labels["www-alias"].
-		firstRR(dns.TypeCNAME).(*dns.RR_CNAME).
+		firstRR(dns.TypeCNAME).(*dns.CNAME).
 		Target, Equals, "bar-alias.test.example.com.")
 
 }

serve.go

@@ -52,7 +52,7 @@ func serve(w dns.ResponseWriter, req *dns.Msg, z *Zone) {
 	if alias := z.findLabels(label, "", dns.TypeMF); alias != nil &&
 		alias.Records[dns.TypeMF] != nil {
 		// We found an alias record, so pretend the question was for that name instead
-		label = alias.firstRR(dns.TypeMF).(*dns.RR_MF).Mf
+		label = alias.firstRR(dns.TypeMF).(*dns.MF).Mf
 	}
 
 	labels := z.findLabels(label, country, qtype)
@@ -69,7 +69,7 @@ func serve(w dns.ResponseWriter, req *dns.Msg, z *Zone) {
 			h := dns.RR_Header{Ttl: 1, Class: dns.ClassINET, Rrtype: dns.TypeTXT}
 			h.Name = "_country." + z.Origin + "."
 
-			m.Answer = []dns.RR{&dns.RR_TXT{Hdr: h,
+			m.Answer = []dns.RR{&dns.TXT{Hdr: h,
 				Txt: []string{
 					w.RemoteAddr().String(),
 					string(country),
@@ -141,7 +141,7 @@ func statusRR(z *Zone) []dns.RR {
 
 	js, err := json.Marshal(status)
 
-	return []dns.RR{&dns.RR_TXT{Hdr: h, Txt: []string{string(js)}}}
+	return []dns.RR{&dns.TXT{Hdr: h, Txt: []string{string(js)}}}
 }
 
 func setupServerFunc(Zone *Zone) func(dns.ResponseWriter, *dns.Msg) {

serve_test.go

@@ -17,39 +17,39 @@ func (s *ConfigSuite) TestServing(c *C) {
 	time.Sleep(100 * time.Millisecond)
 
 	r := exchange(c, "_status.pgeodns.", dns.TypeTXT)
-	txt := r.Answer[0].(*dns.RR_TXT).Txt[0]
+	txt := r.Answer[0].(*dns.TXT).Txt[0]
 	if !strings.HasPrefix(txt, "{") {
 		c.Log("Unexpected result for _status.pgeodns", txt)
 		c.Fail()
 	}
 
 	r = exchange(c, "bar.test.example.com.", dns.TypeA)
-	ip := r.Answer[0].(*dns.RR_A).A
+	ip := r.Answer[0].(*dns.A).A
 	c.Check(ip.String(), Equals, "192.168.1.2")
 
 	r = exchange(c, "test.example.com.", dns.TypeSOA)
-	soa := r.Answer[0].(*dns.RR_SOA)
+	soa := r.Answer[0].(*dns.SOA)
 	serial := soa.Serial
 	c.Check(int(serial), Equals, 3)
 
 	// no AAAA records for 'bar', so check we get a soa record back
 	r = exchange(c, "test.example.com.", dns.TypeAAAA)
-	soa2 := r.Ns[0].(*dns.RR_SOA)
+	soa2 := r.Ns[0].(*dns.SOA)
 	c.Check(soa, DeepEquals, soa2)
 
 	/* CNAMEs */
 	r = exchange(c, "www.test.example.com.", dns.TypeA)
-	c.Check(r.Answer[0].(*dns.RR_CNAME).Target, Equals, "geo.bitnames.com.")
+	c.Check(r.Answer[0].(*dns.CNAME).Target, Equals, "geo.bitnames.com.")
 
 	// TODO: make the alias and cname respond with the data for the target, too?
 	r = exchange(c, "www-alias.test.example.com.", dns.TypeA)
-	c.Check(r.Answer[0].(*dns.RR_CNAME).Target, Equals, "bar-alias.test.example.com.")
+	c.Check(r.Answer[0].(*dns.CNAME).Target, Equals, "bar-alias.test.example.com.")
 
 	/* MX */
 	r = exchange(c, "test.example.com.", dns.TypeMX)
-	c.Check(r.Answer[0].(*dns.RR_MX).Mx, Equals, "mx.example.net.")
-	c.Check(r.Answer[1].(*dns.RR_MX).Mx, Equals, "mx2.example.net.")
-	c.Check(r.Answer[1].(*dns.RR_MX).Preference, Equals, uint16(20))
+	c.Check(r.Answer[0].(*dns.MX).Mx, Equals, "mx.example.net.")
+	c.Check(r.Answer[1].(*dns.MX).Mx, Equals, "mx2.example.net.")
+	c.Check(r.Answer[1].(*dns.MX).Preference, Equals, uint16(20))
 
 }
 

types.go

@@ -81,7 +81,7 @@ func (z *Zone) findLabels(s, cc string, qtype uint16) *Label {
 
 			// look for aliases
 			if label.Records[dns.TypeMF] != nil {
-				name = label.firstRR(dns.TypeMF).(*dns.RR_MF).Mf
+				name = label.firstRR(dns.TypeMF).(*dns.MF).Mf
 				// BUG(ask) - restructure this so it supports chains of aliases
 				label, ok = z.Labels[name]
 				if label == nil {

zone_test.go

@@ -12,16 +12,16 @@ func (s *ConfigSuite) TestZone(c *C) {
 	// Make sure that the empty "no.bar" zone gets skipped and "bar" is used
 	label := ex.findLabels("bar", "no", dns.TypeA)
 	c.Check(label.Records[dns.TypeA], HasLen, 1)
-	c.Check(label.Records[dns.TypeA][0].RR.(*dns.RR_A).A.String(), Equals, "192.168.1.2")
+	c.Check(label.Records[dns.TypeA][0].RR.(*dns.A).A.String(), Equals, "192.168.1.2")
 
 	label = ex.findLabels("", "", dns.TypeMX)
 	Mxs := label.Records[dns.TypeMX]
 	c.Check(Mxs, HasLen, 2)
-	c.Check(Mxs[0].RR.(*dns.RR_MX).Mx, Equals, "mx.example.net.")
-	c.Check(Mxs[1].RR.(*dns.RR_MX).Mx, Equals, "mx2.example.net.")
+	c.Check(Mxs[0].RR.(*dns.MX).Mx, Equals, "mx.example.net.")
+	c.Check(Mxs[1].RR.(*dns.MX).Mx, Equals, "mx2.example.net.")
 
 	Mxs = ex.findLabels("", "dk", dns.TypeMX).Records[dns.TypeMX]
 	c.Check(Mxs, HasLen, 1)
-	c.Check(Mxs[0].RR.(*dns.RR_MX).Mx, Equals, "mx-eu.example.net.")
+	c.Check(Mxs[0].RR.(*dns.MX).Mx, Equals, "mx-eu.example.net.")
 
 }