dynhost/main.go

package main

import (
	"encoding/json"
	"errors"
	"fmt"
	"io/ioutil"
	"log"
	"net/http"
	"os"

	"github.com/nrdcg/namesilo"
)

func updateDns(token, domain, host, address string) error {
	transport, err := namesilo.NewTokenTransport(token)
	if err != nil {
		return err
	}

	client := namesilo.NewClient(transport.Client())

	var record *namesilo.ResourceRecord
	{
		log.Println("querying DNS records...")

		params := &namesilo.DnsListRecordsParams{
			Domain: domain,
		}

		dnsListRecords, err := client.DnsListRecords(params)
		if err != nil {
			return err
		}

		for _, r := range dnsListRecords.Reply.ResourceRecord {
			if r.Host == fmt.Sprintf("%s.%s", host, domain) {
				record = &r
				break
			}
		}
	}

	if record == nil {
		log.Println("adding new DNS record...")

		params := &namesilo.DnsAddRecordParams{
			Distance: 0,
			Domain:   domain,
			Host:     host,
			TTL:      7200,
			Type:     "A",
			Value:    address,
		}

		if _, err := client.DnsAddRecord(params); err != nil {
			return err
		}
	} else if record.Value != address {
		log.Println("updating DNS record...")

		params := &namesilo.DnsUpdateRecordParams{
			Distance: 0,
			Domain:   domain,
			Host:     host,
			ID:       record.RecordID,
			TTL:      7200,
			Value:    address,
		}

		if _, err := client.DnsUpdateRecord(params); err != nil {
			return err
		}
	} else {
		log.Println("DNS record is current")
	}

	return nil
}

func queryAddress() (string, error) {
	log.Println("querying current address...")

	type response struct {
		Query string
	}

	req, err := http.Get("http://ip-api.com/json/")
	if err != nil {
		return "", err
	}
	defer req.Body.Close()

	body, err := ioutil.ReadAll(req.Body)
	if err != nil {
		return "", err
	}

	var ip response
	if err := json.Unmarshal(body, &ip); err != nil {
		return "", err
	}

	return ip.Query, nil
}

func exec() error {
	var (
		token  = os.Getenv("DYN_TOKEN")
		domain = os.Getenv("DYN_DOMAIN")
		host   = os.Getenv("DYN_HOST")
	)

	if len(token) == 0 || len(domain) == 0 || len(host) == 0 {
		return errors.New("undefined environment")
	}

	address, err := queryAddress()
	if err != nil {
		return err
	}

	if err := updateDns(token, domain, host, address); err != nil {
		return err
	}

	return nil
}

func main() {
	if err := exec(); err != nil {
		log.Fatal(err)
	}
}