Namecom v4 api (#298)

* new Name.com api version and go client library * vendor github.com/namedotcom/go/namecom
StackExchange · Jan 10, 2018 · 716cc08 · 716cc08
1 parent b7c2511
commit 716cc08
Show file tree

Hide file tree

Showing 15 changed files with 1,993 additions and 387 deletions.
diff --git a/providers/namedotcom/namedotcomProvider.go b/providers/namedotcom/namedotcomProvider.go
@@ -2,21 +2,20 @@
 package namedotcom
 
 import (
-	"bytes"
 	"encoding/json"
 	"fmt"
-	"io/ioutil"
-	"net/http"
 
 	"github.com/StackExchange/dnscontrol/providers"
+	"github.com/namedotcom/go/namecom"
 )
 
-const defaultAPIBase = "https://api.name.com/api"
+const defaultAPIBase = "api.name.com"
 
-type nameDotCom struct {
+type NameCom struct {
 	APIUrl  string `json:"apiurl"`
 	APIUser string `json:"apiuser"`
 	APIKey  string `json:"apikey"`
+	client  *namecom.NameCom
 }
 
 var features = providers.DocumentationNotes{
@@ -36,8 +35,11 @@ func newDsp(conf map[string]string, meta json.RawMessage) (providers.DNSServiceP
 	return newProvider(conf)
 }
 
-func newProvider(conf map[string]string) (*nameDotCom, error) {
-	api := &nameDotCom{}
+func newProvider(conf map[string]string) (*NameCom, error) {
+	api := &NameCom{
+		client: namecom.New(conf["apiuser"], conf["apikey"]),
+	}
+	api.client.Server = conf["apiurl"]
 	api.APIUser, api.APIKey, api.APIUrl = conf["apiuser"], conf["apikey"], conf["apiurl"]
 	if api.APIKey == "" || api.APIUser == "" {
 		return nil, fmt.Errorf("missing Name.com apikey or apiuser")
@@ -52,77 +54,3 @@ func init() {
 	providers.RegisterRegistrarType("NAMEDOTCOM", newReg)
 	providers.RegisterDomainServiceProviderType("NAMEDOTCOM", newDsp, features)
 }
-
-// various http helpers for interacting with api
-
-func (n *nameDotCom) addAuth(r *http.Request) {
-	r.Header.Add("Api-Username", n.APIUser)
-	r.Header.Add("Api-Token", n.APIKey)
-}
-
-type apiResult struct {
-	Result struct {
-		Code    int    `json:"code"`
-		Message string `json:"message"`
-	} `json:"result"`
-}
-
-func (r *apiResult) getErr() error {
-	if r == nil {
-		return nil
-	}
-	if r.Result.Code != 100 {
-		if r.Result.Message == "" {
-			return fmt.Errorf("Unknown error from name.com")
-		}
-		return fmt.Errorf(r.Result.Message)
-	}
-	return nil
-}
-
-// perform http GET and unmarshal response json into target struct
-func (n *nameDotCom) get(url string, target interface{}) error {
-	req, err := http.NewRequest("GET", url, nil)
-	if err != nil {
-		return err
-	}
-	n.addAuth(req)
-	resp, err := http.DefaultClient.Do(req)
-	if err != nil {
-		return err
-	}
-	defer resp.Body.Close()
-	data, err := ioutil.ReadAll(resp.Body)
-	if err != nil {
-		return err
-	}
-	return json.Unmarshal(data, target)
-}
-
-// perform http POST, json marshalling the given data into the body
-func (n *nameDotCom) post(url string, data interface{}) (*apiResult, error) {
-	buf := &bytes.Buffer{}
-	enc := json.NewEncoder(buf)
-	if err := enc.Encode(data); err != nil {
-		return nil, err
-	}
-	req, err := http.NewRequest("POST", url, buf)
-	if err != nil {
-		return nil, err
-	}
-	n.addAuth(req)
-	resp, err := http.DefaultClient.Do(req)
-	if err != nil {
-		return nil, err
-	}
-	defer resp.Body.Close()
-	text, err := ioutil.ReadAll(resp.Body)
-	if err != nil {
-		return nil, err
-	}
-	result := &apiResult{}
-	if err = json.Unmarshal(text, result); err != nil {
-		return nil, err
-	}
-	return result, nil
-}
diff --git a/providers/namedotcom/nameservers.go b/providers/namedotcom/nameservers.go
@@ -7,11 +7,12 @@ import (
 	"strings"
 
 	"github.com/StackExchange/dnscontrol/models"
+	"github.com/namedotcom/go/namecom"
 )
 
 var nsRegex = regexp.MustCompile(`ns([1-4])[a-z]{3}\.name\.com`)
 
-func (n *nameDotCom) GetNameservers(domain string) ([]*models.Nameserver, error) {
+func (n *NameCom) GetNameservers(domain string) ([]*models.Nameserver, error) {
 	// This is an interesting edge case. Name.com expects you to SET the nameservers to ns[1-4].name.com,
 	// but it will internally set it to ns1xyz.name.com, where xyz is a uniqueish 3 letters.
 	// In order to avoid endless loops, we will use the unique nameservers if present, or else the generic ones if not.
@@ -29,19 +30,21 @@ func (n *nameDotCom) GetNameservers(domain string) ([]*models.Nameserver, error)
 	return models.StringsToNameservers(toUse), nil
 }
 
-func (n *nameDotCom) getNameserversRaw(domain string) ([]string, error) {
-	result := &getDomainResult{}
-	if err := n.get(n.apiGetDomain(domain), result); err != nil {
-		return nil, err
+func (n *NameCom) getNameserversRaw(domain string) ([]string, error) {
+	request := &namecom.GetDomainRequest{
+		DomainName: domain,
 	}
-	if err := result.getErr(); err != nil {
+
+	response, err := n.client.GetDomain(request)
+	if err != nil {
 		return nil, err
 	}
-	sort.Strings(result.Nameservers)
-	return result.Nameservers, nil
+
+	sort.Strings(response.Nameservers)
+	return response.Nameservers, nil
 }
 
-func (n *nameDotCom) GetRegistrarCorrections(dc *models.DomainConfig) ([]*models.Correction, error) {
+func (n *NameCom) GetRegistrarCorrections(dc *models.DomainConfig) ([]*models.Correction, error) {
 	nss, err := n.getNameserversRaw(dc.Name)
 	if err != nil {
 		return nil, err
@@ -66,31 +69,14 @@ func (n *nameDotCom) GetRegistrarCorrections(dc *models.DomainConfig) ([]*models
 	return nil, nil
 }
 
-// even if you provide them "ns1.name.com", they will set it to "ns1qrt.name.com". This will match that pattern to see if defaults are in use.
-var defaultNsRegexp = regexp.MustCompile(`ns1[a-z]{0,3}\.name\.com,ns2[a-z]{0,3}\.name\.com,ns3[a-z]{0,3}\.name\.com,ns4[a-z]{0,3}\.name\.com`)
-
-func (n *nameDotCom) apiGetDomain(domain string) string {
-	return fmt.Sprintf("%s/domain/get/%s", n.APIUrl, domain)
-}
-func (n *nameDotCom) apiUpdateNS(domain string) string {
-	return fmt.Sprintf("%s/domain/update_nameservers/%s", n.APIUrl, domain)
-}
-
-type getDomainResult struct {
-	*apiResult
-	DomainName  string   `json:"domain_name"`
-	Nameservers []string `json:"nameservers"`
-}
-
-func (n *nameDotCom) updateNameservers(ns []string, domain string) func() error {
+func (n *NameCom) updateNameservers(ns []string, domain string) func() error {
 	return func() error {
-		dat := struct {
-			Nameservers []string `json:"nameservers"`
-		}{ns}
-		resp, err := n.post(n.apiUpdateNS(domain), dat)
-		if err != nil {
-			return err
+		request := &namecom.SetNameserversRequest{
+			DomainName:  domain,
+			Nameservers: ns,
 		}
-		return resp.getErr()
+
+		_, err := n.client.SetNameservers(request)
+		return err
 	}
 }
diff --git a/providers/namedotcom/nameservers_test.go b/providers/namedotcom/nameservers_test.go