dnsexit_manager.go

@@ -3,7 +3,7 @@ package dnsexit_manager
 import (
 	"bytes"
 	"encoding/json"
-	"errors"
+	"fmt"
 	"io"
 	"net/http"
 	"sync"
@@ -14,19 +14,19 @@ import (
 const API_BASE_URL = "https://api.dnsexit.com/dns/"
 
 type Config struct {
-	DomainName string
-	API_Key    string
-	API_URL    string
+	DOMAIN_NAME string
+	API_KEY     string
+	API_URL     string
 }
 
 type client struct {
 	Locker  sync.Mutex
-	API_Key string
+	API_KEY string
 	API_URL string
 	Domain  string
 }
 
-type dnsexitRequestDTO struct {
+type dnsexitDTO struct {
 	ApiKey string      `json:"apikey"`
 	Domain string      `json:"domain"`
 	Add    *dns.Record `json:"add,omitempty"`
@@ -34,31 +34,12 @@ type dnsexitRequestDTO struct {
 	Delete *dns.Record `json:"delete,omitempty"`
 }
 
-type dnsexitResponseDTO struct {
-	Code    int
-	Message string
-}
-
-func parseError(body *[]byte) error {
-	var response dnsexitResponseDTO
-
-	if err := json.Unmarshal(*body, &response); err != nil {
-		return err
-	}
-
-	if response.Code != 0 {
-		return errors.New(response.Message)
-	}
-
-	return nil
-}
-
 func (c *client) AddRecord(rec *dns.Record) (*dns.Response, error) {
 	c.Locker.Lock()
 	defer c.Locker.Unlock()
 
-	request_body, err := json.Marshal(&dnsexitRequestDTO{
-		ApiKey: c.API_Key,
+	request_body, err := json.Marshal(&dnsexitDTO{
+		ApiKey: c.API_KEY,
 		Domain: c.Domain,
 		Add:    rec,
 	})
@@ -67,7 +48,9 @@ func (c *client) AddRecord(rec *dns.Record) (*dns.Response, error) {
 		return nil, err
 	}
 
-	response, err := http.Post(
+	fmt.Println(string(request_body))
+
+	resp, err := http.Post(
 		c.API_URL,
 		"application/json",
 		bytes.NewBuffer(request_body),
@@ -77,16 +60,12 @@ func (c *client) AddRecord(rec *dns.Record) (*dns.Response, error) {
 		return nil, err
 	}
 
-	defer response.Body.Close()
-	body, err := io.ReadAll(response.Body)
+	defer resp.Body.Close()
+	body, err := io.ReadAll(resp.Body)
 	if err != nil {
 		return nil, err
 	}
 
-	if err = parseError(&body); err != nil {
-		return nil, err
-	}
-
 	return &dns.Response{Message: string(body)}, nil
 }
 
@@ -94,12 +73,11 @@ func (c *client) DeleteRecord(rec *dns.Record) (*dns.Response, error) {
 	c.Locker.Lock()
 	defer c.Locker.Unlock()
 
-	request_body, err := json.Marshal(&dnsexitRequestDTO{
-		ApiKey: c.API_Key,
+	request_body, err := json.Marshal(&dnsexitDTO{
+		ApiKey: c.API_KEY,
 		Domain: c.Domain,
 		Delete: rec,
 	})
-
 	if err != nil {
 		return nil, err
 	}
@@ -120,10 +98,6 @@ func (c *client) DeleteRecord(rec *dns.Record) (*dns.Response, error) {
 		return nil, err
 	}
 
-	if err = parseError(&body); err != nil {
-		return nil, err
-	}
-
 	return &dns.Response{Message: string(body)}, nil
 }
 
@@ -131,8 +105,8 @@ func (c *client) UpdateRecord(rec *dns.Record) (*dns.Response, error) {
 	c.Locker.Lock()
 	defer c.Locker.Unlock()
 
-	request_body, err := json.Marshal(&dnsexitRequestDTO{
-		ApiKey: c.API_Key,
+	request_body, err := json.Marshal(&dnsexitDTO{
+		ApiKey: c.API_KEY,
 		Domain: c.Domain,
 		Update: rec,
 	})
@@ -157,10 +131,6 @@ func (c *client) UpdateRecord(rec *dns.Record) (*dns.Response, error) {
 		return nil, err
 	}
 
-	if err = parseError(&body); err != nil {
-		return nil, err
-	}
-
 	return &dns.Response{Message: string(body)}, nil
 }
 
@@ -171,7 +141,7 @@ func (c *client) GetRecords() (*[]dns.Record, error) {
 	result_chan := make(chan []*dns.Record)
 	err_chan := make(chan error)
 
-	nameservers, err := c.getNSRecods()
+	err, nameservers := c.getNSRecods()
 	if err != nil {
 		return nil, err
 	}
@@ -181,7 +151,7 @@ func (c *client) GetRecords() (*[]dns.Record, error) {
 
 		go func(ns string) {
 			defer wg.Done()
-			records, err := find_dns_records(c.Domain, ns)
+			err, records := find_dns_records(c.Domain, ns)
 
 			if err != nil {
 				err_chan <- err
@@ -215,7 +185,7 @@ func (c *client) GetRecords() (*[]dns.Record, error) {
 }
 
 func (conf Config) New() (dns.Actions, error) {
-	var api_url = API_BASE_URL
+	var api_url string = API_BASE_URL
 
 	if len(conf.API_URL) > 5 {
 		api_url = conf.API_URL
@@ -223,8 +193,8 @@ func (conf Config) New() (dns.Actions, error) {
 
 	return &client{
 		Locker:  sync.Mutex{},
-		API_Key: conf.API_Key,
+		API_KEY: conf.API_KEY,
 		API_URL: api_url,
-		Domain:  conf.DomainName,
+		Domain:  conf.DOMAIN_NAME,
 	}, nil
 }

utilities.go

@@ -10,46 +10,46 @@ import (
 	dns_req "github.com/miekg/dns"
 )
 
-func (c *client) getNSRecods() (*[]string, error) {
+func (c *client) getNSRecods() (error, *[]string) {
 	var nameservers []string
 
 	ns, err := net.LookupNS(c.Domain)
 	if err != nil {
-		return nil, err
+		return err, nil
 	}
 
 	for _, v := range ns {
 		nameservers = append(nameservers, v.Host[:len(v.Host)-1]+":53")
 	}
 
-	return &nameservers, nil
+	return nil, &nameservers
 }
 
-func parse_record(record dns_req.RR) (*dns.Record, error) {
-	split := strings.SplitN(record.String(), "\t", -1)
+func parse_record(record dns_req.RR) (error, *dns.Record) {
+	splitted := strings.SplitN(record.String(), "\t", -1)
 
-	if len(split) == 5 {
+	if len(splitted) == 5 {
 		var parsed dns.Record
-		rec_type := dns.RecordType(split[3])
+		rec_type := dns.RecordType(splitted[3])
 
 		if !rec_type.Check() {
-			return nil, errors.New("provided DNS type is not exist in the main library")
+			return errors.New("provided DNS type is not exist in the main library"), nil
 		}
 
 		parsed.Type = rec_type
-		ttl, _ := strconv.ParseUint(split[1], 10, 64)
+		ttl, _ := strconv.ParseUint(splitted[1], 10, 64)
 
-		parsed.Name = split[0]
-		parsed.Content = split[4]
+		parsed.Name = splitted[0]
+		parsed.Content = splitted[4]
 		parsed.TTL = uint(ttl)
 
-		return &parsed, nil
+		return nil, &parsed
 	}
 
-	return nil, errors.New("no meaningful record provided")
+	return errors.New("no meaningful record provided"), nil
 }
 
-func find_dns_records(domain string, nameserver string) ([]*dns.Record, error) {
+func find_dns_records(domain string, nameserver string) (error, []*dns.Record) {
 	var subdomains []*dns.Record
 
 	tr := new(dns_req.Transfer)
@@ -58,21 +58,21 @@ func find_dns_records(domain string, nameserver string) ([]*dns.Record, error) {
 
 	client, err := tr.In(m, nameserver)
 	if err != nil {
-		return nil, errors.New("failed to zone transfer in " + err.Error())
+		return errors.New("failed to zone transfer in " + err.Error()), nil
 	}
 
 	for msg := range client {
 		if msg.Error != nil {
-			return nil, msg.Error
+			return msg.Error, nil
 		}
 
 		for _, r := range msg.RR {
-			record, err := parse_record(r)
+			err, record := parse_record(r)
 			if err == nil {
 				subdomains = append(subdomains, record)
 			}
 		}
 	}
 
-	return subdomains, nil
+	return nil, subdomains
 }