Update Lego

vendor/github.com/dnsimple/dnsimple-go/dnsimple/authentication.go

@@ -1,68 +1,52 @@
 package dnsimple
 
 import (
-	"encoding/base64"
+	"net/http"
 )
 
-const (
-	httpHeaderDomainToken   = "X-DNSimple-Domain-Token"
-	httpHeaderApiToken      = "X-DNSimple-Token"
-	httpHeaderAuthorization = "Authorization"
-)
+// BasicAuthTransport is an http.RoundTripper that authenticates all requests
+// using HTTP Basic Authentication with the provided username and password.
+type BasicAuthTransport struct {
+	Username string
+	Password string
 
-// Provides credentials that can be used for authenticating with DNSimple.
-//
-// See https://developer.dnsimple.com/v2/#authentication
-type Credentials interface {
-	// Returns the HTTP headers that should be set
-	// to authenticate the HTTP Request.
-	Headers() map[string]string
+	// Transport is the transport RoundTripper used to make HTTP requests.
+	// If nil, http.DefaultTransport is used.
+	Transport http.RoundTripper
 }
 
-// Domain token authentication
-type domainTokenCredentials struct {
-	domainToken string
+// RoundTrip implements the RoundTripper interface.  We just add the
+// basic auth and return the RoundTripper for this transport type.
+func (t *BasicAuthTransport) RoundTrip(req *http.Request) (*http.Response, error) {
+	req2 := cloneRequest(req) // per RoundTripper contract
+
+	req2.SetBasicAuth(t.Username, t.Password)
+	return t.transport().RoundTrip(req2)
 }
 
-// NewDomainTokenCredentials construct Credentials using the DNSimple Domain Token method.
-func NewDomainTokenCredentials(domainToken string) Credentials {
-	return &domainTokenCredentials{domainToken: domainToken}
+// Client returns an *http.Client that uses the BasicAuthTransport transport
+// to authenticate the request via HTTP Basic Auth.
+func (t *BasicAuthTransport) Client() *http.Client {
+	return &http.Client{Transport: t}
 }
 
-func (c *domainTokenCredentials) Headers() map[string]string {
-	return map[string]string{httpHeaderDomainToken: c.domainToken}
+func (t *BasicAuthTransport) transport() http.RoundTripper {
+	if t.Transport != nil {
+		return t.Transport
+	}
+	return http.DefaultTransport
 }
 
-// HTTP basic authentication
-type httpBasicCredentials struct {
-	email    string
-	password string
-}
-
-// NewHTTPBasicCredentials construct Credentials using HTTP Basic Auth.
-func NewHTTPBasicCredentials(email, password string) Credentials {
-	return &httpBasicCredentials{email, password}
-}
-
-func (c *httpBasicCredentials) Headers() map[string]string {
-	return map[string]string{httpHeaderAuthorization: "Basic " + c.basicAuth(c.email, c.password)}
-}
-
-func (c *httpBasicCredentials) basicAuth(username, password string) string {
-	auth := username + ":" + password
-	return base64.StdEncoding.EncodeToString([]byte(auth))
-}
-
-// OAuth token authentication
-type oauthTokenCredentials struct {
-	oauthToken string
-}
-
-// NewOauthTokenCredentials construct Credentials using the OAuth access token.
-func NewOauthTokenCredentials(oauthToken string) Credentials {
-	return &oauthTokenCredentials{oauthToken: oauthToken}
-}
-
-func (c *oauthTokenCredentials) Headers() map[string]string {
-	return map[string]string{httpHeaderAuthorization: "Bearer " + c.oauthToken}
+// cloneRequest returns a clone of the provided *http.Request.
+// The clone is a shallow copy of the struct and its Header map.
+func cloneRequest(r *http.Request) *http.Request {
+	// shallow copy of the struct
+	r2 := new(http.Request)
+	*r2 = *r
+	// deep copy of the Header
+	r2.Header = make(http.Header, len(r.Header))
+	for k, s := range r.Header {
+		r2.Header[k] = append([]string(nil), s...)
+	}
+	return r2
 }

vendor/github.com/dnsimple/dnsimple-go/dnsimple/dnsimple.go

@@ -23,7 +23,7 @@ const (
 	// This is a pro-forma convention given that Go dependencies
 	// tends to be fetched directly from the repo.
 	// It is also used in the user-agent identify the client.
-	Version = "0.16.0"
+	Version = "0.21.0"
 
 	// defaultBaseURL to the DNSimple production API.
 	defaultBaseURL = "https://api.dnsimple.com"
@@ -37,12 +37,9 @@ const (
 
 // Client represents a client to the DNSimple API.
 type Client struct {
-	// HttpClient is the underlying HTTP client
+	// httpClient is the underlying HTTP client
 	// used to communicate with the API.
-	HttpClient *http.Client
-
-	// Credentials used for accessing the DNSimple API
-	Credentials Credentials
+	httpClient *http.Client
 
 	// BaseURL for API requests.
 	// Defaults to the public DNSimple API, but can be set to a different endpoint (e.g. the sandbox).
@@ -85,9 +82,12 @@ type ListOptions struct {
 	Sort string `url:"sort,omitempty"`
 }
 
-// NewClient returns a new DNSimple API client using the given credentials.
-func NewClient(credentials Credentials) *Client {
-	c := &Client{Credentials: credentials, HttpClient: &http.Client{}, BaseURL: defaultBaseURL}
+// NewClient returns a new DNSimple API client.
+//
+// To authenticate you must provide an http.Client that will perform authentication
+// for you with one of the currently supported mechanisms: OAuth or HTTP Basic.
+func NewClient(httpClient *http.Client) *Client {
+	c := &Client{httpClient: httpClient, BaseURL: defaultBaseURL}
 	c.Identity = &IdentityService{client: c}
 	c.Accounts = &AccountsService{client: c}
 	c.Certificates = &CertificatesService{client: c}
@@ -126,9 +126,6 @@ func (c *Client) NewRequest(method, path string, payload interface{}) (*http.Req
 	req.Header.Set("Content-Type", "application/json")
 	req.Header.Add("Accept", "application/json")
 	req.Header.Add("User-Agent", formatUserAgent(c.UserAgent))
-	for key, value := range c.Credentials.Headers() {
-		req.Header.Add(key, value)
-	}
 
 	return req, nil
 }
@@ -212,7 +209,7 @@ func (c *Client) Do(req *http.Request, obj interface{}) (*http.Response, error)
 		log.Printf("Executing request (%v): %#v", req.URL, req)
 	}
 
-	resp, err := c.HttpClient.Do(req)
+	resp, err := c.httpClient.Do(req)
 	if err != nil {
 		return nil, err
 	}
@@ -231,7 +228,7 @@ func (c *Client) Do(req *http.Request, obj interface{}) (*http.Response, error)
 	// the response body is decoded into v.
 	if obj != nil {
 		if w, ok := obj.(io.Writer); ok {
-			io.Copy(w, resp.Body)
+			_, err = io.Copy(w, resp.Body)
 		} else {
 			err = json.NewDecoder(resp.Body).Decode(obj)
 		}

vendor/github.com/dnsimple/dnsimple-go/dnsimple/oauth.go

@@ -72,7 +72,7 @@ func (s *OauthService) ExchangeAuthorizationForToken(authorization *ExchangeAuth
 		return nil, err
 	}
 
-	resp, err := s.client.HttpClient.Do(req)
+	resp, err := s.client.httpClient.Do(req)
 	if err != nil {
 		return nil, err
 	}

vendor/github.com/dnsimple/dnsimple-go/dnsimple/webhooks.go

@@ -14,7 +14,7 @@ type WebhooksService struct {
 
 // Webhook represents a DNSimple webhook.
 type Webhook struct {
-	ID  int64    `json:"id,omitempty"`
+	ID  int64  `json:"id,omitempty"`
 	URL string `json:"url,omitempty"`
 }
 

vendor/github.com/dnsimple/dnsimple-go/dnsimple/zone_distributions.go

@@ -0,0 +1,46 @@
+package dnsimple
+
+import "fmt"
+
+// ZoneDistribution is the result of the zone distribution check.
+type ZoneDistribution struct {
+	Distributed bool `json:"distributed"`
+}
+
+// zoneDistributionResponse represents a response from an API method that returns a ZoneDistribution struct.
+type zoneDistributionResponse struct {
+	Response
+	Data *ZoneDistribution `json:"data"`
+}
+
+// CheckZoneDistribution checks if a zone is fully distributed across DNSimple nodes.
+//
+// See https://developer.dnsimple.com/v2/zones/#checkZoneDistribution
+func (s *ZonesService) CheckZoneDistribution(accountID string, zoneName string) (*zoneDistributionResponse, error) {
+	path := versioned(fmt.Sprintf("/%v/zones/%v/distribution", accountID, zoneName))
+	zoneDistributionResponse := &zoneDistributionResponse{}
+
+	resp, err := s.client.get(path, zoneDistributionResponse)
+	if err != nil {
+		return nil, err
+	}
+
+	zoneDistributionResponse.HttpResponse = resp
+	return zoneDistributionResponse, nil
+}
+
+// CheckZoneRecordDistribution checks if a zone is fully distributed across DNSimple nodes.
+//
+// See https://developer.dnsimple.com/v2/zones/#checkZoneRecordDistribution
+func (s *ZonesService) CheckZoneRecordDistribution(accountID string, zoneName string, recordID int64) (*zoneDistributionResponse, error) {
+	path := versioned(fmt.Sprintf("/%v/zones/%v/records/%v/distribution", accountID, zoneName, recordID))
+	zoneDistributionResponse := &zoneDistributionResponse{}
+
+	resp, err := s.client.get(path, zoneDistributionResponse)
+	if err != nil {
+		return nil, err
+	}
+
+	zoneDistributionResponse.HttpResponse = resp
+	return zoneDistributionResponse, nil
+}

vendor/github.com/dnsimple/dnsimple-go/dnsimple/zones.go

@@ -14,8 +14,8 @@ type ZonesService struct {
 
 // Zone represents a Zone in DNSimple.
 type Zone struct {
-	ID        int64    `json:"id,omitempty"`
-	AccountID int64    `json:"account_id,omitempty"`
+	ID        int64  `json:"id,omitempty"`
+	AccountID int64  `json:"account_id,omitempty"`
 	Name      string `json:"name,omitempty"`
 	Reverse   bool   `json:"reverse,omitempty"`
 	CreatedAt string `json:"created_at,omitempty"`

vendor/github.com/dnsimple/dnsimple-go/dnsimple/zones_records.go

@@ -6,9 +6,9 @@ import (
 
 // ZoneRecord represents a DNS record in DNSimple.
 type ZoneRecord struct {
-	ID           int64      `json:"id,omitempty"`
+	ID           int64    `json:"id,omitempty"`
 	ZoneID       string   `json:"zone_id,omitempty"`
-	ParentID     int64      `json:"parent_id,omitempty"`
+	ParentID     int64    `json:"parent_id,omitempty"`
 	Type         string   `json:"type,omitempty"`
 	Name         string   `json:"name"`
 	Content      string   `json:"content,omitempty"`