|
|
|
package main
|
|
|
|
|
|
|
|
import (
|
|
|
|
"encoding/json"
|
|
|
|
"fmt"
|
|
|
|
"net/http"
|
|
|
|
"os"
|
|
|
|
"strconv"
|
|
|
|
"strings"
|
|
|
|
"sync"
|
|
|
|
|
|
|
|
"github.com/dnsimple/dnsimple-go/dnsimple"
|
|
|
|
"github.com/pkg/errors"
|
|
|
|
"github.com/urfave/cli"
|
|
|
|
)
|
|
|
|
|
|
|
|
func main() {
|
|
|
|
app := cli.NewApp()
|
|
|
|
app.Name = "update-dns"
|
|
|
|
app.Usage = "update dnsimple with public ip address"
|
|
|
|
app.Action = action
|
|
|
|
|
|
|
|
app.Flags = []cli.Flag{
|
|
|
|
cli.StringFlag{
|
|
|
|
Name: "url",
|
|
|
|
Value: "https://whatismyipv6.buddy.wtf/json",
|
|
|
|
Usage: "url to use to get public ip address",
|
|
|
|
},
|
|
|
|
|
|
|
|
cli.StringFlag{
|
|
|
|
EnvVar: "DNSIMPLE_TOKEN",
|
|
|
|
Name: "dnsimple-token",
|
|
|
|
Usage: "dnsimple token",
|
|
|
|
},
|
|
|
|
}
|
|
|
|
|
|
|
|
app.Run(os.Args)
|
|
|
|
}
|
|
|
|
|
|
|
|
type runtimeError string
|
|
|
|
|
|
|
|
func (e runtimeError) Error() string {
|
|
|
|
return string(e)
|
|
|
|
}
|
|
|
|
|
|
|
|
func action(context *cli.Context) error {
|
|
|
|
var wg sync.WaitGroup
|
|
|
|
if context.NArg() < 1 {
|
|
|
|
return runtimeError("requires host argument")
|
|
|
|
}
|
|
|
|
|
|
|
|
host := context.Args().Get(0)
|
|
|
|
|
|
|
|
wg.Add(1)
|
|
|
|
var getIPError error
|
|
|
|
var ip string
|
|
|
|
go func() {
|
|
|
|
defer wg.Done()
|
|
|
|
result, err := getIP(context.String("url"))
|
|
|
|
if err != nil {
|
|
|
|
getIPError = errors.Wrap(err, "could not get IP address")
|
|
|
|
return
|
|
|
|
}
|
|
|
|
ip = result.IP
|
|
|
|
}()
|
|
|
|
|
|
|
|
var dnSimpleAccountID string
|
|
|
|
var getRecordError error
|
|
|
|
var record *dnsimple.ZoneRecord
|
|
|
|
credentials := dnsimple.NewOauthTokenCredentials(context.String("dnsimple-token"))
|
|
|
|
dnSimpleClient := dnsimple.NewClient(credentials)
|
|
|
|
wg.Add(1)
|
|
|
|
go func() {
|
|
|
|
defer wg.Done()
|
|
|
|
|
|
|
|
accountID, result, err := getRecord(dnSimpleClient, host, "AAAA")
|
|
|
|
dnSimpleAccountID = accountID
|
|
|
|
if err != nil {
|
|
|
|
getRecordError = errors.Wrap(err, "could not get ip for host")
|
|
|
|
return
|
|
|
|
}
|
|
|
|
record = result
|
|
|
|
}()
|
|
|
|
|
|
|
|
wg.Wait()
|
|
|
|
|
|
|
|
if getIPError != nil {
|
|
|
|
return errors.Wrap(getIPError, "could no get ip address")
|
|
|
|
}
|
|
|
|
if getRecordError != nil {
|
|
|
|
switch errors.Cause(getRecordError).(type) {
|
|
|
|
case notFoundError:
|
|
|
|
break
|
|
|
|
default:
|
|
|
|
return errors.Wrap(getRecordError, "could no get record")
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
subdomain, domain, _ := splitHost(host)
|
|
|
|
if record == nil {
|
|
|
|
_, err := dnSimpleClient.Zones.CreateRecord(dnSimpleAccountID, domain, dnsimple.ZoneRecord{
|
|
|
|
Name: subdomain,
|
|
|
|
Type: "AAAA",
|
|
|
|
Content: ip,
|
|
|
|
})
|
|
|
|
if err != nil {
|
|
|
|
return errors.Wrap(err, "could not create record")
|
|
|
|
}
|
|
|
|
fmt.Printf("%s record created for %s as %s\n", "AAAA", host, ip)
|
|
|
|
} else if ip != record.Content {
|
|
|
|
record.Content = ip
|
|
|
|
_, err := dnSimpleClient.Zones.UpdateRecord(dnSimpleAccountID, domain, record.ID, *record)
|
|
|
|
if err != nil {
|
|
|
|
return errors.Wrap(err, "could not update record")
|
|
|
|
}
|
|
|
|
fmt.Printf("%s record for %s updated to %s\n", "AAAA", host, ip)
|
|
|
|
} else {
|
|
|
|
fmt.Printf("%s record for %s already set as %s\n", "AAAA", host, ip)
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
type whatIsMyIPResult struct {
|
|
|
|
IP string `json:ip`
|
|
|
|
Version string `json:version`
|
|
|
|
}
|
|
|
|
|
|
|
|
type notFoundError error
|
|
|
|
|
|
|
|
func getRecord(client *dnsimple.Client, host string, kind string) (string, *dnsimple.ZoneRecord, error) {
|
|
|
|
subdomain, domain, err := splitHost(host)
|
|
|
|
if err != nil {
|
|
|
|
return "", nil, errors.Wrap(err, "unable to parse host")
|
|
|
|
}
|
|
|
|
accountID, err := getAccountID(client)
|
|
|
|
if err != nil {
|
|
|
|
return "", nil, errors.Wrap(err, "could not get account id")
|
|
|
|
}
|
|
|
|
|
|
|
|
records, err := client.Zones.ListRecords(accountID, domain, &dnsimple.ZoneRecordListOptions{})
|
|
|
|
if err != nil {
|
|
|
|
return "", nil, errors.Wrap(err, "could not get list of records")
|
|
|
|
}
|
|
|
|
|
|
|
|
for _, record := range records.Data {
|
|
|
|
if record.ZoneID == domain && record.Name == subdomain && record.Type == kind {
|
|
|
|
return accountID, &record, nil
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return accountID, nil, notFoundError(errors.New("could not find record"))
|
|
|
|
}
|
|
|
|
|
|
|
|
func getAccountID(client *dnsimple.Client) (string, error) {
|
|
|
|
whoamiResponse, err := client.Identity.Whoami()
|
|
|
|
if err != nil {
|
|
|
|
return "", errors.Wrap(err, "could not get account information from dnsimple")
|
|
|
|
}
|
|
|
|
if whoamiResponse.Data.Account == nil {
|
|
|
|
return "", errors.New("could not get account information")
|
|
|
|
}
|
|
|
|
return strconv.Itoa(whoamiResponse.Data.Account.ID), nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func splitHost(host string) (subdomain string, domain string, err error) {
|
|
|
|
subdomains := strings.Split(host, ".")
|
|
|
|
|
|
|
|
if len(subdomains) >= 3 {
|
|
|
|
domain = strings.Join(subdomains[len(subdomains)-2:], ".")
|
|
|
|
subdomain = strings.Join(subdomains[:len(subdomains)-2], ".")
|
|
|
|
} else if len(subdomains) == 2 {
|
|
|
|
domain = strings.Join(subdomains, ".")
|
|
|
|
} else {
|
|
|
|
err = errors.New("invalid domain")
|
|
|
|
}
|
|
|
|
return subdomain, domain, err
|
|
|
|
}
|
|
|
|
|
|
|
|
func getIP(url string) (*whatIsMyIPResult, error) {
|
|
|
|
result, err := http.Get(url)
|
|
|
|
if err != nil {
|
|
|
|
return nil, errors.Wrap(err, "could not get url "+url)
|
|
|
|
}
|
|
|
|
defer result.Body.Close()
|
|
|
|
ipResult := &whatIsMyIPResult{}
|
|
|
|
if err := json.NewDecoder(result.Body).Decode(ipResult); err != nil {
|
|
|
|
return nil, errors.Wrap(err, "could parse json from url "+url)
|
|
|
|
}
|
|
|
|
return ipResult, nil
|
|
|
|
}
|