lego/vendor/github.com/akamai/AkamaiOPEN-edgegrid-golang/configdns-v1/zone.go

package dns

import (
	"errors"
	"fmt"
	"reflect"
	"strings"
	"sync"
	"time"

	"github.com/akamai/AkamaiOPEN-edgegrid-golang/client-v1"
)

type name struct {
	recordType string
	name       string
}

var (
	cnameNames    []name
	nonCnameNames []name
	zoneWriteLock sync.Mutex
)

// Zone represents a DNS zone
type Zone struct {
	Token string `json:"token"`
	Zone  struct {
		Name       string              `json:"name,omitempty"`
		A          []*ARecord          `json:"a,omitempty"`
		Aaaa       []*AaaaRecord       `json:"aaaa,omitempty"`
		Afsdb      []*AfsdbRecord      `json:"afsdb,omitempty"`
		Cname      []*CnameRecord      `json:"cname,omitempty"`
		Dnskey     []*DnskeyRecord     `json:"dnskey,omitempty"`
		Ds         []*DsRecord         `json:"ds,omitempty"`
		Hinfo      []*HinfoRecord      `json:"hinfo,omitempty"`
		Loc        []*LocRecord        `json:"loc,omitempty"`
		Mx         []*MxRecord         `json:"mx,omitempty"`
		Naptr      []*NaptrRecord      `json:"naptr,omitempty"`
		Ns         []*NsRecord         `json:"ns,omitempty"`
		Nsec3      []*Nsec3Record      `json:"nsec3,omitempty"`
		Nsec3param []*Nsec3paramRecord `json:"nsec3param,omitempty"`
		Ptr        []*PtrRecord        `json:"ptr,omitempty"`
		Rp         []*RpRecord         `json:"rp,omitempty"`
		Rrsig      []*RrsigRecord      `json:"rrsig,omitempty"`
		Soa        *SoaRecord          `json:"soa,omitempty"`
		Spf        []*SpfRecord        `json:"spf,omitempty"`
		Srv        []*SrvRecord        `json:"srv,omitempty"`
		Sshfp      []*SshfpRecord      `json:"sshfp,omitempty"`
		Txt        []*TxtRecord        `json:"txt,omitempty"`
	} `json:"zone"`
}

// NewZone creates a new Zone
func NewZone(hostname string) *Zone {
	zone := &Zone{Token: "new"}
	zone.Zone.Soa = NewSoaRecord()
	zone.Zone.Name = hostname
	return zone
}

// GetZone retrieves a DNS Zone for a given hostname
func GetZone(hostname string) (*Zone, error) {
	zone := NewZone(hostname)
	req, err := client.NewRequest(
		Config,
		"GET",
		"/config-dns/v1/zones/"+hostname,
		nil,
	)
	if err != nil {
		return nil, err
	}

	res, err := client.Do(Config, req)
	if err != nil {
		return nil, err
	}

	if client.IsError(res) && res.StatusCode != 404 {
		return nil, client.NewAPIError(res)
	} else if res.StatusCode == 404 {
		return nil, &ZoneError{zoneName: hostname}
	} else {
		err = client.BodyJSON(res, &zone)
		if err != nil {
			return nil, err
		}

		return zone, nil
	}
}

// Save updates the Zone
func (zone *Zone) Save() error {
	// This lock will restrict the concurrency of API calls
	// to 1 save request at a time. This is needed for the Soa.Serial value which
	// is required to be incremented for every subsequent update to a zone
	// so we have to save just one request at a time to ensure this is always
	// incremented properly
	zoneWriteLock.Lock()
	defer zoneWriteLock.Unlock()

	valid, f := zone.validateCnames()
	if valid == false {
		var msg string
		for _, v := range f {
			msg = msg + fmt.Sprintf("\n%s Record '%s' conflicts with CNAME", v.recordType, v.name)
		}
		return &ZoneError{
			zoneName:        zone.Zone.Name,
			apiErrorMessage: "All CNAMEs must be unique in the zone" + msg,
		}
	}

	req, err := client.NewJSONRequest(
		Config,
		"POST",
		"/config-dns/v1/zones/"+zone.Zone.Name,
		zone,
	)
	if err != nil {
		return err
	}

	res, err := client.Do(Config, req)

	// Network error
	if err != nil {
		return &ZoneError{
			zoneName:         zone.Zone.Name,
			httpErrorMessage: err.Error(),
			err:              err,
		}
	}

	// API error
	if client.IsError(res) {
		err := client.NewAPIError(res)
		return &ZoneError{zoneName: zone.Zone.Name, apiErrorMessage: err.Detail, err: err}
	}

	for {
		updatedZone, err := GetZone(zone.Zone.Name)
		if err != nil {
			return err
		}

		if updatedZone.Token != zone.Token {
			*zone = *updatedZone
			break
		}
		time.Sleep(time.Second)
	}

	return nil
}

func (zone *Zone) Delete() error {
	// remove all the records except for SOA
	// which is required and save the zone
	zone.Zone.A = nil
	zone.Zone.Aaaa = nil
	zone.Zone.Afsdb = nil
	zone.Zone.Cname = nil
	zone.Zone.Dnskey = nil
	zone.Zone.Ds = nil
	zone.Zone.Hinfo = nil
	zone.Zone.Loc = nil
	zone.Zone.Mx = nil
	zone.Zone.Naptr = nil
	zone.Zone.Ns = nil
	zone.Zone.Nsec3 = nil
	zone.Zone.Nsec3param = nil
	zone.Zone.Ptr = nil
	zone.Zone.Rp = nil
	zone.Zone.Rrsig = nil
	zone.Zone.Spf = nil
	zone.Zone.Srv = nil
	zone.Zone.Sshfp = nil
	zone.Zone.Txt = nil

	return zone.Save()
}

func (zone *Zone) AddRecord(recordPtr interface{}) error {
	switch recordPtr.(type) {
	case *ARecord:
		zone.addARecord(recordPtr.(*ARecord))
	case *AaaaRecord:
		zone.addAaaaRecord(recordPtr.(*AaaaRecord))
	case *AfsdbRecord:
		zone.addAfsdbRecord(recordPtr.(*AfsdbRecord))
	case *CnameRecord:
		zone.addCnameRecord(recordPtr.(*CnameRecord))
	case *DnskeyRecord:
		zone.addDnskeyRecord(recordPtr.(*DnskeyRecord))
	case *DsRecord:
		zone.addDsRecord(recordPtr.(*DsRecord))
	case *HinfoRecord:
		zone.addHinfoRecord(recordPtr.(*HinfoRecord))
	case *LocRecord:
		zone.addLocRecord(recordPtr.(*LocRecord))
	case *MxRecord:
		zone.addMxRecord(recordPtr.(*MxRecord))
	case *NaptrRecord:
		zone.addNaptrRecord(recordPtr.(*NaptrRecord))
	case *NsRecord:
		zone.addNsRecord(recordPtr.(*NsRecord))
	case *Nsec3Record:
		zone.addNsec3Record(recordPtr.(*Nsec3Record))
	case *Nsec3paramRecord:
		zone.addNsec3paramRecord(recordPtr.(*Nsec3paramRecord))
	case *PtrRecord:
		zone.addPtrRecord(recordPtr.(*PtrRecord))
	case *RpRecord:
		zone.addRpRecord(recordPtr.(*RpRecord))
	case *RrsigRecord:
		zone.addRrsigRecord(recordPtr.(*RrsigRecord))
	case *SoaRecord:
		zone.addSoaRecord(recordPtr.(*SoaRecord))
	case *SpfRecord:
		zone.addSpfRecord(recordPtr.(*SpfRecord))
	case *SrvRecord:
		zone.addSrvRecord(recordPtr.(*SrvRecord))
	case *SshfpRecord:
		zone.addSshfpRecord(recordPtr.(*SshfpRecord))
	case *TxtRecord:
		zone.addTxtRecord(recordPtr.(*TxtRecord))
	}

	return nil
}

func (zone *Zone) RemoveRecord(recordPtr interface{}) error {
	switch recordPtr.(type) {
	case *ARecord:
		return zone.removeARecord(recordPtr.(*ARecord))
	case *AaaaRecord:
		return zone.removeAaaaRecord(recordPtr.(*AaaaRecord))
	case *AfsdbRecord:
		return zone.removeAfsdbRecord(recordPtr.(*AfsdbRecord))
	case *CnameRecord:
		return zone.removeCnameRecord(recordPtr.(*CnameRecord))
	case *DnskeyRecord:
		return zone.removeDnskeyRecord(recordPtr.(*DnskeyRecord))
	case *DsRecord:
		return zone.removeDsRecord(recordPtr.(*DsRecord))
	case *HinfoRecord:
		return zone.removeHinfoRecord(recordPtr.(*HinfoRecord))
	case *LocRecord:
		return zone.removeLocRecord(recordPtr.(*LocRecord))
	case *MxRecord:
		return zone.removeMxRecord(recordPtr.(*MxRecord))
	case *NaptrRecord:
		return zone.removeNaptrRecord(recordPtr.(*NaptrRecord))
	case *NsRecord:
		return zone.removeNsRecord(recordPtr.(*NsRecord))
	case *Nsec3Record:
		return zone.removeNsec3Record(recordPtr.(*Nsec3Record))
	case *Nsec3paramRecord:
		return zone.removeNsec3paramRecord(recordPtr.(*Nsec3paramRecord))
	case *PtrRecord:
		return zone.removePtrRecord(recordPtr.(*PtrRecord))
	case *RpRecord:
		return zone.removeRpRecord(recordPtr.(*RpRecord))
	case *RrsigRecord:
		return zone.removeRrsigRecord(recordPtr.(*RrsigRecord))
	case *SoaRecord:
		return zone.removeSoaRecord(recordPtr.(*SoaRecord))
	case *SpfRecord:
		return zone.removeSpfRecord(recordPtr.(*SpfRecord))
	case *SrvRecord:
		return zone.removeSrvRecord(recordPtr.(*SrvRecord))
	case *SshfpRecord:
		return zone.removeSshfpRecord(recordPtr.(*SshfpRecord))
	case *TxtRecord:
		return zone.removeTxtRecord(recordPtr.(*TxtRecord))
	}

	return nil
}

func (zone *Zone) addARecord(record *ARecord) {
	zone.Zone.A = append(zone.Zone.A, record)
	nonCnameNames = append(nonCnameNames, name{recordType: "A", name: record.Name})
}

func (zone *Zone) addAaaaRecord(record *AaaaRecord) {
	zone.Zone.Aaaa = append(zone.Zone.Aaaa, record)
	nonCnameNames = append(nonCnameNames, name{recordType: "AAAA", name: record.Name})
}

func (zone *Zone) addAfsdbRecord(record *AfsdbRecord) {
	zone.Zone.Afsdb = append(zone.Zone.Afsdb, record)
	nonCnameNames = append(nonCnameNames, name{recordType: "AFSDB", name: record.Name})
}

func (zone *Zone) addCnameRecord(record *CnameRecord) {
	zone.Zone.Cname = append(zone.Zone.Cname, record)
	cnameNames = append(cnameNames, name{recordType: "CNAME", name: record.Name})
}

func (zone *Zone) addDnskeyRecord(record *DnskeyRecord) {
	zone.Zone.Dnskey = append(zone.Zone.Dnskey, record)
	nonCnameNames = append(nonCnameNames, name{recordType: "DNSKEY", name: record.Name})
}

func (zone *Zone) addDsRecord(record *DsRecord) {
	zone.Zone.Ds = append(zone.Zone.Ds, record)
	nonCnameNames = append(nonCnameNames, name{recordType: "DS", name: record.Name})
}

func (zone *Zone) addHinfoRecord(record *HinfoRecord) {
	zone.Zone.Hinfo = append(zone.Zone.Hinfo, record)
	nonCnameNames = append(nonCnameNames, name{recordType: "HINFO", name: record.Name})
}

func (zone *Zone) addLocRecord(record *LocRecord) {
	zone.Zone.Loc = append(zone.Zone.Loc, record)
	nonCnameNames = append(nonCnameNames, name{recordType: "LOC", name: record.Name})
}

func (zone *Zone) addMxRecord(record *MxRecord) {
	zone.Zone.Mx = append(zone.Zone.Mx, record)
	nonCnameNames = append(nonCnameNames, name{recordType: "MX", name: record.Name})
}

func (zone *Zone) addNaptrRecord(record *NaptrRecord) {
	zone.Zone.Naptr = append(zone.Zone.Naptr, record)
	nonCnameNames = append(nonCnameNames, name{recordType: "NAPTR", name: record.Name})
}

func (zone *Zone) addNsRecord(record *NsRecord) {
	zone.Zone.Ns = append(zone.Zone.Ns, record)
	nonCnameNames = append(nonCnameNames, name{recordType: "NS", name: record.Name})
}

func (zone *Zone) addNsec3Record(record *Nsec3Record) {
	zone.Zone.Nsec3 = append(zone.Zone.Nsec3, record)
	nonCnameNames = append(nonCnameNames, name{recordType: "NSEC3", name: record.Name})
}

func (zone *Zone) addNsec3paramRecord(record *Nsec3paramRecord) {
	zone.Zone.Nsec3param = append(zone.Zone.Nsec3param, record)
	nonCnameNames = append(nonCnameNames, name{recordType: "NSEC3PARAM", name: record.Name})
}

func (zone *Zone) addPtrRecord(record *PtrRecord) {
	zone.Zone.Ptr = append(zone.Zone.Ptr, record)
	nonCnameNames = append(nonCnameNames, name{recordType: "PTR", name: record.Name})
}

func (zone *Zone) addRpRecord(record *RpRecord) {
	zone.Zone.Rp = append(zone.Zone.Rp, record)
	nonCnameNames = append(nonCnameNames, name{recordType: "RP", name: record.Name})
}

func (zone *Zone) addRrsigRecord(record *RrsigRecord) {
	zone.Zone.Rrsig = append(zone.Zone.Rrsig, record)
	nonCnameNames = append(nonCnameNames, name{recordType: "RRSIG", name: record.Name})
}

func (zone *Zone) addSoaRecord(record *SoaRecord) {
	// Only one SOA records is allowed
	zone.Zone.Soa = record
}

func (zone *Zone) addSpfRecord(record *SpfRecord) {
	zone.Zone.Spf = append(zone.Zone.Spf, record)
	nonCnameNames = append(nonCnameNames, name{recordType: "SPF", name: record.Name})
}

func (zone *Zone) addSrvRecord(record *SrvRecord) {
	zone.Zone.Srv = append(zone.Zone.Srv, record)
	nonCnameNames = append(nonCnameNames, name{recordType: "SRV", name: record.Name})
}

func (zone *Zone) addSshfpRecord(record *SshfpRecord) {
	zone.Zone.Sshfp = append(zone.Zone.Sshfp, record)
	nonCnameNames = append(nonCnameNames, name{recordType: "SSHFP", name: record.Name})
}

func (zone *Zone) addTxtRecord(record *TxtRecord) {
	zone.Zone.Txt = append(zone.Zone.Txt, record)
	nonCnameNames = append(nonCnameNames, name{recordType: "TXT", name: record.Name})
}

func (zone *Zone) removeARecord(record *ARecord) error {
	for key, r := range zone.Zone.A {
		if reflect.DeepEqual(r, record) {
			records := zone.Zone.A[:key]
			if len(zone.Zone.A) > key {
				if len(zone.Zone.A) > key {
					zone.Zone.A = append(records, zone.Zone.A[key+1:]...)
				} else {
					zone.Zone.A = records
				}
			}
			zone.removeNonCnameName(record.Name)

			return nil
		}
	}

	return errors.New("A Record not found")
}

func (zone *Zone) removeAaaaRecord(record *AaaaRecord) error {
	for key, r := range zone.Zone.Aaaa {
		if reflect.DeepEqual(r, record) {
			records := zone.Zone.Aaaa[:key]
			if len(zone.Zone.Aaaa) > key {
				zone.Zone.Aaaa = append(records, zone.Zone.Aaaa[key+1:]...)
			} else {
				zone.Zone.Aaaa = records
			}
			zone.removeNonCnameName(record.Name)

			return nil
		}
	}

	return errors.New("AAAA Record not found")
}

func (zone *Zone) removeAfsdbRecord(record *AfsdbRecord) error {
	for key, r := range zone.Zone.Afsdb {
		if reflect.DeepEqual(r, record) {
			records := zone.Zone.Afsdb[:key]
			if len(zone.Zone.Afsdb) > key {
				zone.Zone.Afsdb = append(records, zone.Zone.Afsdb[key+1:]...)
			} else {
				zone.Zone.Afsdb = records
			}
			zone.removeNonCnameName(record.Name)

			return nil
		}
	}

	return errors.New("Afsdb Record not found")
}

func (zone *Zone) removeCnameRecord(record *CnameRecord) error {
	for key, r := range zone.Zone.Cname {
		if reflect.DeepEqual(r, record) {
			records := zone.Zone.Cname[:key]
			if len(zone.Zone.Cname) > key {
				zone.Zone.Cname = append(records, zone.Zone.Cname[key+1:]...)
			} else {
				zone.Zone.Cname = records
			}
			zone.removeNonCnameName(record.Name)

			return nil
		}
	}

	return errors.New("Cname Record not found")

	zone.removeCnameName(record.Name)

	return nil
}

func (zone *Zone) removeDnskeyRecord(record *DnskeyRecord) error {
	for key, r := range zone.Zone.Dnskey {
		if reflect.DeepEqual(r, record) {
			records := zone.Zone.Dnskey[:key]
			if len(zone.Zone.Dnskey) > key {
				zone.Zone.Dnskey = append(records, zone.Zone.Dnskey[key+1:]...)
			} else {
				zone.Zone.Dnskey = records
			}
			zone.removeNonCnameName(record.Name)

			return nil
		}
	}

	return errors.New("Dnskey Record not found")
}

func (zone *Zone) removeDsRecord(record *DsRecord) error {
	for key, r := range zone.Zone.Ds {
		if reflect.DeepEqual(r, record) {
			records := zone.Zone.Ds[:key]
			if len(zone.Zone.Ds) > key {
				zone.Zone.Ds = append(records, zone.Zone.Ds[key+1:]...)
			} else {
				zone.Zone.Ds = records
			}
			zone.removeNonCnameName(record.Name)

			return nil
		}
	}

	return errors.New("Ds Record not found")
}

func (zone *Zone) removeHinfoRecord(record *HinfoRecord) error {
	for key, r := range zone.Zone.Hinfo {
		if reflect.DeepEqual(r, record) {
			records := zone.Zone.Hinfo[:key]
			if len(zone.Zone.Hinfo) > key {
				zone.Zone.Hinfo = append(records, zone.Zone.Hinfo[key+1:]...)
			} else {
				zone.Zone.Hinfo = records
			}
			zone.removeNonCnameName(record.Name)

			return nil
		}
	}

	return errors.New("Hinfo Record not found")
}

func (zone *Zone) removeLocRecord(record *LocRecord) error {
	for key, r := range zone.Zone.Loc {
		if reflect.DeepEqual(r, record) {
			records := zone.Zone.Loc[:key]
			if len(zone.Zone.Loc) > key {
				zone.Zone.Loc = append(records, zone.Zone.Loc[key+1:]...)
			} else {
				zone.Zone.Loc = records
			}
			zone.removeNonCnameName(record.Name)

			return nil
		}
	}

	return errors.New("Loc Record not found")
}

func (zone *Zone) removeMxRecord(record *MxRecord) error {
	for key, r := range zone.Zone.Mx {
		if reflect.DeepEqual(r, record) {
			records := zone.Zone.Mx[:key]
			if len(zone.Zone.Mx) > key {
				zone.Zone.Mx = append(records, zone.Zone.Mx[key+1:]...)
			} else {
				zone.Zone.Mx = records
			}
			zone.removeNonCnameName(record.Name)

			return nil
		}
	}

	return errors.New("Mx Record not found")
}

func (zone *Zone) removeNaptrRecord(record *NaptrRecord) error {
	for key, r := range zone.Zone.Naptr {
		if reflect.DeepEqual(r, record) {
			records := zone.Zone.Naptr[:key]
			if len(zone.Zone.Naptr) > key {
				zone.Zone.Naptr = append(records, zone.Zone.Naptr[key+1:]...)
			} else {
				zone.Zone.Naptr = records
			}
			zone.removeNonCnameName(record.Name)

			return nil
		}
	}

	return errors.New("Naptr Record not found")
}

func (zone *Zone) removeNsRecord(record *NsRecord) error {
	for key, r := range zone.Zone.Ns {
		if reflect.DeepEqual(r, record) {
			records := zone.Zone.Ns[:key]
			if len(zone.Zone.Ns) > key {
				zone.Zone.Ns = append(records, zone.Zone.Ns[key+1:]...)
			} else {
				zone.Zone.Ns = records
			}
			zone.removeNonCnameName(record.Name)

			return nil
		}
	}

	return errors.New("Ns Record not found")
}

func (zone *Zone) removeNsec3Record(record *Nsec3Record) error {
	for key, r := range zone.Zone.Nsec3 {
		if reflect.DeepEqual(r, record) {
			records := zone.Zone.Nsec3[:key]
			if len(zone.Zone.Nsec3) > key {
				zone.Zone.Nsec3 = append(records, zone.Zone.Nsec3[key+1:]...)
			} else {
				zone.Zone.Nsec3 = records
			}
			zone.removeNonCnameName(record.Name)

			return nil
		}
	}

	return errors.New("Nsec3 Record not found")
}

func (zone *Zone) removeNsec3paramRecord(record *Nsec3paramRecord) error {
	for key, r := range zone.Zone.Nsec3param {
		if reflect.DeepEqual(r, record) {
			records := zone.Zone.Nsec3param[:key]
			if len(zone.Zone.Nsec3param) > key {
				zone.Zone.Nsec3param = append(records, zone.Zone.Nsec3param[key+1:]...)
			} else {
				zone.Zone.Nsec3param = records
			}
			zone.removeNonCnameName(record.Name)

			return nil
		}
	}

	return errors.New("Nsec3param Record not found")
}

func (zone *Zone) removePtrRecord(record *PtrRecord) error {
	for key, r := range zone.Zone.Ptr {
		if reflect.DeepEqual(r, record) {
			records := zone.Zone.Ptr[:key]
			if len(zone.Zone.Ptr) > key {
				zone.Zone.Ptr = append(records, zone.Zone.Ptr[key+1:]...)
			} else {
				zone.Zone.Ptr = records
			}
			zone.removeNonCnameName(record.Name)

			return nil
		}
	}

	return errors.New("Ptr Record not found")
}

func (zone *Zone) removeRpRecord(record *RpRecord) error {
	for key, r := range zone.Zone.Rp {
		if reflect.DeepEqual(r, record) {
			records := zone.Zone.Rp[:key]
			if len(zone.Zone.Rp) > key {
				zone.Zone.Rp = append(records, zone.Zone.Rp[key+1:]...)
			} else {
				zone.Zone.Rp = records
			}
			zone.removeNonCnameName(record.Name)

			return nil
		}
	}

	return errors.New("Rp Record not found")
}

func (zone *Zone) removeRrsigRecord(record *RrsigRecord) error {
	for key, r := range zone.Zone.Rrsig {
		if reflect.DeepEqual(r, record) {
			records := zone.Zone.Rrsig[:key]
			if len(zone.Zone.Rrsig) > key {
				zone.Zone.Rrsig = append(records, zone.Zone.Rrsig[key+1:]...)
			} else {
				zone.Zone.Rrsig = records
			}
			zone.removeNonCnameName(record.Name)

			return nil
		}
	}

	return errors.New("Rrsig Record not found")
}

func (zone *Zone) removeSoaRecord(record *SoaRecord) error {
	if reflect.DeepEqual(zone.Zone.Soa, record) {
		zone.Zone.Soa = nil

		return nil
	}

	return errors.New("SOA Record does not match")
}

func (zone *Zone) removeSpfRecord(record *SpfRecord) error {
	for key, r := range zone.Zone.Spf {
		if reflect.DeepEqual(r, record) {
			records := zone.Zone.Spf[:key]
			if len(zone.Zone.Spf) > key {
				zone.Zone.Spf = append(records, zone.Zone.Spf[key+1:]...)
			} else {
				zone.Zone.Spf = records
			}
			zone.removeNonCnameName(record.Name)

			return nil
		}
	}

	return errors.New("Spf Record not found")
}

func (zone *Zone) removeSrvRecord(record *SrvRecord) error {
	for key, r := range zone.Zone.Srv {
		if reflect.DeepEqual(r, record) {
			records := zone.Zone.Srv[:key]
			if len(zone.Zone.Srv) > key {
				zone.Zone.Srv = append(records, zone.Zone.Srv[key+1:]...)
			} else {
				zone.Zone.Srv = records
			}
			zone.removeNonCnameName(record.Name)

			return nil
		}
	}

	return errors.New("Srv Record not found")
}

func (zone *Zone) removeSshfpRecord(record *SshfpRecord) error {
	for key, r := range zone.Zone.Sshfp {
		if reflect.DeepEqual(r, record) {
			records := zone.Zone.Sshfp[:key]
			if len(zone.Zone.Sshfp) > key {
				zone.Zone.Sshfp = append(records, zone.Zone.Sshfp[key+1:]...)
			} else {
				zone.Zone.Sshfp = records
			}
			zone.removeNonCnameName(record.Name)

			return nil
		}
	}

	return errors.New("Sshfp Record not found")
}

func (zone *Zone) removeTxtRecord(record *TxtRecord) error {
	for key, r := range zone.Zone.Txt {
		if reflect.DeepEqual(r, record) {
			records := zone.Zone.Txt[:key]
			if len(zone.Zone.Txt) > key {
				zone.Zone.Txt = append(records, zone.Zone.Txt[key+1:]...)
			} else {
				zone.Zone.Txt = records
			}
			zone.removeNonCnameName(record.Name)

			return nil
		}
	}

	return errors.New("Txt Record not found")
}

func (zone *Zone) PreMarshalJSON() error {
	if zone.Zone.Soa.Serial > 0 {
		zone.Zone.Soa.Serial = zone.Zone.Soa.Serial + 1
	} else {
		zone.Zone.Soa.Serial = uint(time.Now().Unix())
	}
	return nil
}

func (zone *Zone) validateCnames() (bool, []name) {
	var valid bool = true
	var failedRecords []name
	for _, v := range cnameNames {
		for _, vv := range nonCnameNames {
			if v.name == vv.name {
				valid = false
				failedRecords = append(failedRecords, vv)
			}
		}
	}
	return valid, failedRecords
}

func (zone *Zone) removeCnameName(host string) {
	for i, v := range cnameNames {
		if v.name == host {
			r := cnameNames[:i]
			cnameNames = append(r, cnameNames[i+1:]...)
		}
	}
}

func (zone *Zone) removeNonCnameName(host string) {
	for i, v := range nonCnameNames {
		if v.name == host {
			r := nonCnameNames[:i]
			nonCnameNames = append(r, nonCnameNames[i+1:]...)
		}
	}
}

func (zone *Zone) FindRecords(recordType string, options map[string]interface{}) []DNSRecord {
	switch strings.ToUpper(recordType) {
	case "A":
		return zone.findARecord(options)
	case "AAAA":
		return zone.findAaaaRecord(options)
	case "AFSDB":
		return zone.findAfsdbRecord(options)
	case "CNAME":
		return zone.findCnameRecord(options)
	case "DNSKEY":
		return zone.findDnskeyRecord(options)
	case "DS":
		return zone.findDsRecord(options)
	case "HINFO":
		return zone.findHinfoRecord(options)
	case "LOC":
		return zone.findLocRecord(options)
	case "MX":
		return zone.findMxRecord(options)
	case "NAPTR":
		return zone.findNaptrRecord(options)
	case "NS":
		return zone.findNsRecord(options)
	case "NSEC3":
		return zone.findNsec3Record(options)
	case "NSEC3PARAM":
		return zone.findNsec3paramRecord(options)
	case "PTR":
		return zone.findPtrRecord(options)
	case "RP":
		return zone.findRpRecord(options)
	case "RRSIG":
		return zone.findRrsigRecord(options)
	case "SPF":
		return zone.findSpfRecord(options)
	case "SRV":
		return zone.findSrvRecord(options)
	case "SSHFP":
		return zone.findSshfpRecord(options)
	case "TXT":
		return zone.findTxtRecord(options)
	}

	return make([]DNSRecord, 0)
}

func (zone *Zone) findARecord(options map[string]interface{}) []DNSRecord {
	found := make([]DNSRecord, 0)
	matchesNeeded := len(options)
	for _, record := range zone.Zone.A {
		matchCounter := 0
		if name, ok := options["name"]; ok && record.Name == name.(string) {
			matchCounter++
		}

		if target, ok := options["target"]; ok && record.Target == target.(string) {
			matchCounter++
		}

		if active, ok := options["active"]; ok && record.Active == active.(bool) {
			matchCounter++
		}

		if ttl, ok := options["ttl"]; ok && record.TTL == ttl.(int) {
			matchCounter++
		}

		if matchCounter >= matchesNeeded {
			found = append(found, record)
		}
	}

	return found
}

func (zone *Zone) findAaaaRecord(options map[string]interface{}) []DNSRecord {
	found := make([]DNSRecord, 0)
	matchesNeeded := len(options)
	for _, record := range zone.Zone.Aaaa {
		matchCounter := 0
		if name, ok := options["name"]; ok && record.Name == name.(string) {
			matchCounter++
		}

		if target, ok := options["target"]; ok && record.Target == target.(string) {
			matchCounter++
		}

		if active, ok := options["active"]; ok && record.Active == active.(bool) {
			matchCounter++
		}

		if ttl, ok := options["ttl"]; ok && record.TTL == ttl.(int) {
			matchCounter++
		}

		if matchCounter >= matchesNeeded {
			found = append(found, record)
		}
	}

	return found
}

func (zone *Zone) findAfsdbRecord(options map[string]interface{}) []DNSRecord {
	found := make([]DNSRecord, 0)
	matchesNeeded := len(options)
	for _, record := range zone.Zone.Afsdb {
		matchCounter := 0
		if name, ok := options["name"]; ok && record.Name == name.(string) {
			matchCounter++
		}

		if target, ok := options["target"]; ok && record.Target == target.(string) {
			matchCounter++
		}

		if active, ok := options["active"]; ok && record.Active == active.(bool) {
			matchCounter++
		}

		if ttl, ok := options["ttl"]; ok && record.TTL == ttl.(int) {
			matchCounter++
		}

		if subtype, ok := options["subtype"]; ok && record.Subtype == subtype.(int) {
			matchCounter++
		}

		if matchCounter >= matchesNeeded {
			found = append(found, record)
		}
	}
	return found
}

func (zone *Zone) findCnameRecord(options map[string]interface{}) []DNSRecord {
	found := make([]DNSRecord, 0)
	matchesNeeded := len(options)
	for _, record := range zone.Zone.Cname {
		matchCounter := 0
		if name, ok := options["name"]; ok && record.Name == name.(string) {
			matchCounter++
		}

		if target, ok := options["target"]; ok && record.Target == target.(string) {
			matchCounter++
		}

		if active, ok := options["active"]; ok && record.Active == active.(bool) {
			matchCounter++
		}

		if ttl, ok := options["ttl"]; ok && record.TTL == ttl.(int) {
			matchCounter++
		}

		if matchCounter >= matchesNeeded {
			found = append(found, record)
		}
	}
	return found
}

func (zone *Zone) findDnskeyRecord(options map[string]interface{}) []DNSRecord {
	found := make([]DNSRecord, 0)
	matchesNeeded := len(options)
	for _, record := range zone.Zone.Dnskey {
		matchCounter := 0
		if name, ok := options["name"]; ok && record.Name == name.(string) {
			matchCounter++
		}

		if active, ok := options["active"]; ok && record.Active == active.(bool) {
			matchCounter++
		}

		if ttl, ok := options["ttl"]; ok && record.TTL == ttl.(int) {
			matchCounter++
		}

		if flags, ok := options["flags"]; ok && record.Flags == flags.(int) {
			matchCounter++
		}

		if protocol, ok := options["protocol"]; ok && record.Protocol == protocol.(int) {
			matchCounter++
		}

		if algorithm, ok := options["algorithm"]; ok && record.Algorithm == algorithm.(int) {
			matchCounter++
		}

		if key, ok := options["key"]; ok && record.Key == key.(string) {
			matchCounter++
		}

		if matchCounter >= matchesNeeded {
			found = append(found, record)
		}
	}
	return found
}

func (zone *Zone) findDsRecord(options map[string]interface{}) []DNSRecord {
	found := make([]DNSRecord, 0)
	matchesNeeded := len(options)
	for _, record := range zone.Zone.Ds {
		matchCounter := 0
		if name, ok := options["name"]; ok && record.Name == name.(string) {
			matchCounter++
		}

		if active, ok := options["active"]; ok && record.Active == active.(bool) {
			matchCounter++
		}

		if ttl, ok := options["ttl"]; ok && record.TTL == ttl.(int) {
			matchCounter++
		}

		if keytag, ok := options["keytag"]; ok && record.Keytag == keytag.(int) {
			matchCounter++
		}

		if algorithm, ok := options["algorithm"]; ok && record.Algorithm == algorithm.(int) {
			matchCounter++
		}

		if digesttype, ok := options["digesttype"]; ok && record.DigestType == digesttype.(int) {
			matchCounter++
		}

		if digest, ok := options["digest"]; ok && record.Digest == digest.(string) {
			matchCounter++
		}

		if matchCounter >= matchesNeeded {
			found = append(found, record)
		}
	}
	return found
}

func (zone *Zone) findHinfoRecord(options map[string]interface{}) []DNSRecord {
	found := make([]DNSRecord, 0)
	matchesNeeded := len(options)
	for _, record := range zone.Zone.Hinfo {
		matchCounter := 0
		if name, ok := options["name"]; ok && record.Name == name.(string) {
			matchCounter++
		}

		if active, ok := options["active"]; ok && record.Active == active.(bool) {
			matchCounter++
		}

		if ttl, ok := options["ttl"]; ok && record.TTL == ttl.(int) {
			matchCounter++
		}

		if hardware, ok := options["hardware"]; ok && record.Hardware == hardware.(string) {
			matchCounter++
		}

		if software, ok := options["software"]; ok && record.Software == software.(string) {
			matchCounter++
		}

		if matchCounter >= matchesNeeded {
			found = append(found, record)
		}
	}
	return found
}

func (zone *Zone) findLocRecord(options map[string]interface{}) []DNSRecord {
	found := make([]DNSRecord, 0)
	matchesNeeded := len(options)
	for _, record := range zone.Zone.Loc {
		matchCounter := 0
		if name, ok := options["name"]; ok && record.Name == name.(string) {
			matchCounter++
		}

		if active, ok := options["active"]; ok && record.Active == active.(bool) {
			matchCounter++
		}

		if ttl, ok := options["ttl"]; ok && record.TTL == ttl.(int) {
			matchCounter++
		}

		if target, ok := options["target"]; ok && record.Target == target.(string) {
			matchCounter++
		}

		if matchCounter >= matchesNeeded {
			found = append(found, record)
		}
	}
	return found
}

func (zone *Zone) findMxRecord(options map[string]interface{}) []DNSRecord {
	found := make([]DNSRecord, 0)
	matchesNeeded := len(options)
	for _, record := range zone.Zone.Mx {
		matchCounter := 0
		if name, ok := options["name"]; ok && record.Name == name.(string) {
			matchCounter++
		}

		if active, ok := options["active"]; ok && record.Active == active.(bool) {
			matchCounter++
		}

		if ttl, ok := options["ttl"]; ok && record.TTL == ttl.(int) {
			matchCounter++
		}

		if target, ok := options["target"]; ok && record.Target == target.(string) {
			matchCounter++
		}

		if priority, ok := options["priority"]; ok && record.Priority == priority.(int) {
			matchCounter++
		}

		if matchCounter >= matchesNeeded {
			found = append(found, record)
		}
	}
	return found
}

func (zone *Zone) findNaptrRecord(options map[string]interface{}) []DNSRecord {
	found := make([]DNSRecord, 0)
	matchesNeeded := len(options)
	for _, record := range zone.Zone.Naptr {
		matchCounter := 0
		if name, ok := options["name"]; ok && record.Name == name.(string) {
			matchCounter++
		}

		if active, ok := options["active"]; ok && record.Active == active.(bool) {
			matchCounter++
		}

		if ttl, ok := options["ttl"]; ok && record.TTL == ttl.(int) {
			matchCounter++
		}

		if order, ok := options["order"]; ok && record.Order == order.(uint16) {
			matchCounter++
		}

		if preference, ok := options["preference"]; ok && record.Preference == preference.(uint16) {
			matchCounter++
		}

		if flags, ok := options["flags"]; ok && record.Flags == flags.(string) {
			matchCounter++
		}

		if service, ok := options["service"]; ok && record.Service == service.(string) {
			matchCounter++
		}

		if regexp, ok := options["regexp"]; ok && record.Regexp == regexp.(string) {
			matchCounter++
		}

		if replacement, ok := options["replacement"]; ok && record.Replacement == replacement.(string) {
			matchCounter++
		}

		if matchCounter >= matchesNeeded {
			found = append(found, record)
		}
	}
	return found
}

func (zone *Zone) findNsRecord(options map[string]interface{}) []DNSRecord {
	found := make([]DNSRecord, 0)
	matchesNeeded := len(options)
	for _, record := range zone.Zone.Ns {
		matchCounter := 0
		if name, ok := options["name"]; ok && record.Name == name.(string) {
			matchCounter++
		}

		if active, ok := options["active"]; ok && record.Active == active.(bool) {
			matchCounter++
		}

		if ttl, ok := options["ttl"]; ok && record.TTL == ttl.(int) {
			matchCounter++
		}

		if target, ok := options["target"]; ok && record.Target == target.(string) {
			matchCounter++
		}

		if matchCounter >= matchesNeeded {
			found = append(found, record)
		}
	}
	return found
}

func (zone *Zone) findNsec3Record(options map[string]interface{}) []DNSRecord {
	found := make([]DNSRecord, 0)
	matchesNeeded := len(options)
	for _, record := range zone.Zone.Nsec3 {
		matchCounter := 0
		if name, ok := options["name"]; ok && record.Name == name.(string) {
			matchCounter++
		}

		if active, ok := options["active"]; ok && record.Active == active.(bool) {
			matchCounter++
		}

		if ttl, ok := options["ttl"]; ok && record.TTL == ttl.(int) {
			matchCounter++
		}

		if algorithm, ok := options["algorithm"]; ok && record.Algorithm == algorithm.(int) {
			matchCounter++
		}

		if flags, ok := options["flags"]; ok && record.Flags == flags.(int) {
			matchCounter++
		}

		if iterations, ok := options["iterations"]; ok && record.Iterations == iterations.(int) {
			matchCounter++
		}

		if salt, ok := options["salt"]; ok && record.Salt == salt.(string) {
			matchCounter++
		}

		if nextHashedOwnerName, ok := options["nextHashedOwnerName"]; ok && record.NextHashedOwnerName == nextHashedOwnerName.(string) {
			matchCounter++
		}

		if typeBitmaps, ok := options["typeBitmaps"]; ok && record.TypeBitmaps == typeBitmaps.(string) {
			matchCounter++
		}

		if matchCounter >= matchesNeeded {
			found = append(found, record)
		}
	}
	return found
}

func (zone *Zone) findNsec3paramRecord(options map[string]interface{}) []DNSRecord {
	found := make([]DNSRecord, 0)
	matchesNeeded := len(options)
	for _, record := range zone.Zone.Nsec3param {
		matchCounter := 0
		if name, ok := options["name"]; ok && record.Name == name.(string) {
			matchCounter++
		}

		if active, ok := options["active"]; ok && record.Active == active.(bool) {
			matchCounter++
		}

		if ttl, ok := options["ttl"]; ok && record.TTL == ttl.(int) {
			matchCounter++
		}

		if algorithm, ok := options["algorithm"]; ok && record.Algorithm == algorithm.(int) {
			matchCounter++
		}

		if flags, ok := options["flags"]; ok && record.Flags == flags.(int) {
			matchCounter++
		}

		if iterations, ok := options["iterations"]; ok && record.Iterations == iterations.(int) {
			matchCounter++
		}

		if salt, ok := options["salt"]; ok && record.Salt == salt.(string) {
			matchCounter++
		}

		if matchCounter >= matchesNeeded {
			found = append(found, record)
		}
	}
	return found
}

func (zone *Zone) findPtrRecord(options map[string]interface{}) []DNSRecord {
	found := make([]DNSRecord, 0)
	matchesNeeded := len(options)
	for _, record := range zone.Zone.Ptr {
		matchCounter := 0
		if name, ok := options["name"]; ok && record.Name == name.(string) {
			matchCounter++
		}

		if active, ok := options["active"]; ok && record.Active == active.(bool) {
			matchCounter++
		}

		if ttl, ok := options["ttl"]; ok && record.TTL == ttl.(int) {
			matchCounter++
		}

		if target, ok := options["target"]; ok && record.Target == target.(string) {
			matchCounter++
		}

		if matchCounter >= matchesNeeded {
			found = append(found, record)
		}
	}
	return found
}

func (zone *Zone) findRpRecord(options map[string]interface{}) []DNSRecord {
	found := make([]DNSRecord, 0)
	matchesNeeded := len(options)
	for _, record := range zone.Zone.Rp {
		matchCounter := 0
		if name, ok := options["name"]; ok && record.Name == name.(string) {
			matchCounter++
		}

		if active, ok := options["active"]; ok && record.Active == active.(bool) {
			matchCounter++
		}

		if ttl, ok := options["ttl"]; ok && record.TTL == ttl.(int) {
			matchCounter++
		}

		if mailbox, ok := options["mailbox"]; ok && record.Mailbox == mailbox.(string) {
			matchCounter++
		}

		if txt, ok := options["txt"]; ok && record.Txt == txt.(string) {
			matchCounter++
		}

		if matchCounter >= matchesNeeded {
			found = append(found, record)
		}
	}
	return found
}

func (zone *Zone) findRrsigRecord(options map[string]interface{}) []DNSRecord {
	found := make([]DNSRecord, 0)
	matchesNeeded := len(options)
	for _, record := range zone.Zone.Rrsig {
		matchCounter := 0
		if name, ok := options["name"]; ok && record.Name == name.(string) {
			matchCounter++
		}

		if active, ok := options["active"]; ok && record.Active == active.(bool) {
			matchCounter++
		}

		if ttl, ok := options["ttl"]; ok && record.TTL == ttl.(int) {
			matchCounter++
		}

		if typeCovered, ok := options["typeCovered"]; ok && record.TypeCovered == typeCovered.(string) {
			matchCounter++
		}

		if algorithm, ok := options["algorithm"]; ok && record.Algorithm == algorithm.(int) {
			matchCounter++
		}

		if originalTTL, ok := options["originalTTL"]; ok && record.OriginalTTL == originalTTL.(int) {
			matchCounter++
		}

		if expiration, ok := options["expiration"]; ok && record.Expiration == expiration.(string) {
			matchCounter++
		}

		if inception, ok := options["inception"]; ok && record.Inception == inception.(string) {
			matchCounter++
		}

		if keytag, ok := options["keytag"]; ok && record.Keytag == keytag.(int) {
			matchCounter++
		}

		if signer, ok := options["signer"]; ok && record.Signer == signer.(string) {
			matchCounter++
		}

		if signature, ok := options["signature"]; ok && record.Signature == signature.(string) {
			matchCounter++
		}

		if labels, ok := options["labels"]; ok && record.Labels == labels.(int) {
			matchCounter++
		}

		if matchCounter >= matchesNeeded {
			found = append(found, record)
		}
	}
	return found
}

func (zone *Zone) findSpfRecord(options map[string]interface{}) []DNSRecord {
	found := make([]DNSRecord, 0)
	matchesNeeded := len(options)
	for _, record := range zone.Zone.Spf {
		matchCounter := 0
		if name, ok := options["name"]; ok && record.Name == name.(string) {
			matchCounter++
		}

		if active, ok := options["active"]; ok && record.Active == active.(bool) {
			matchCounter++
		}

		if ttl, ok := options["ttl"]; ok && record.TTL == ttl.(int) {
			matchCounter++
		}

		if target, ok := options["target"]; ok && record.Target == target.(string) {
			matchCounter++
		}

		if matchCounter >= matchesNeeded {
			found = append(found, record)
		}
	}
	return found
}

func (zone *Zone) findSrvRecord(options map[string]interface{}) []DNSRecord {
	found := make([]DNSRecord, 0)
	matchesNeeded := len(options)
	for _, record := range zone.Zone.Srv {
		matchCounter := 0
		if name, ok := options["name"]; ok && record.Name == name.(string) {
			matchCounter++
		}

		if active, ok := options["active"]; ok && record.Active == active.(bool) {
			matchCounter++
		}

		if ttl, ok := options["ttl"]; ok && record.TTL == ttl.(int) {
			matchCounter++
		}

		if target, ok := options["target"]; ok && record.Target == target.(string) {
			matchCounter++
		}

		if priority, ok := options["priority"]; ok && record.Priority == priority.(int) {
			matchCounter++
		}

		if weight, ok := options["weight"]; ok && record.Weight == weight.(uint16) {
			matchCounter++
		}

		if port, ok := options["port"]; ok && record.Port == port.(uint16) {
			matchCounter++
		}

		if matchCounter >= matchesNeeded {
			found = append(found, record)
		}
	}
	return found
}

func (zone *Zone) findSshfpRecord(options map[string]interface{}) []DNSRecord {
	found := make([]DNSRecord, 0)
	matchesNeeded := len(options)
	for _, record := range zone.Zone.Sshfp {
		matchCounter := 0
		if name, ok := options["name"]; ok && record.Name == name.(string) {
			matchCounter++
		}

		if active, ok := options["active"]; ok && record.Active == active.(bool) {
			matchCounter++
		}

		if ttl, ok := options["ttl"]; ok && record.TTL == ttl.(int) {
			matchCounter++
		}

		if algorithm, ok := options["algorithm"]; ok && record.Algorithm == algorithm.(int) {
			matchCounter++
		}

		if fingerprintType, ok := options["fingerprintType"]; ok && record.FingerprintType == fingerprintType.(int) {
			matchCounter++
		}

		if fingerprint, ok := options["fingerprint"]; ok && record.Fingerprint == fingerprint.(string) {
			matchCounter++
		}

		if matchCounter >= matchesNeeded {
			found = append(found, record)
		}
	}
	return found
}

func (zone *Zone) findTxtRecord(options map[string]interface{}) []DNSRecord {
	found := make([]DNSRecord, 0)
	matchesNeeded := len(options)
	for _, record := range zone.Zone.Txt {
		matchCounter := 0
		if name, ok := options["name"]; ok && record.Name == name.(string) {
			matchCounter++
		}

		if active, ok := options["active"]; ok && record.Active == active.(bool) {
			matchCounter++
		}

		if ttl, ok := options["ttl"]; ok && record.TTL == ttl.(int) {
			matchCounter++
		}

		if target, ok := options["target"]; ok && record.Target == target.(string) {
			matchCounter++
		}

		if matchCounter >= matchesNeeded {
			found = append(found, record)
		}
	}
	return found
}