akamai.go

// Copyright 2021 Akamai Technologies, Inc.
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package akamai

import (
	"github.com/akamai/edgedns-registrar-coordinator/registrar"
	log "github.com/apex/log"

	"context"
	"fmt"
	dns "github.com/akamai/AkamaiOPEN-edgegrid-golang/configdns-v2"
	edgegrid "github.com/akamai/AkamaiOPEN-edgegrid-golang/edgegrid"
	"gopkg.in/yaml.v2"
	"io/ioutil"
	"net"
	"os"
	"strconv"
	"strings"
)

const ()

var ()

// edgeDNSClient is a proxy interface of the Akamai edgegrid configdns-v2 package that can be stubbed for testing.
type AkamaiDNSService interface {
	GetDomains(ctx context.Context) ([]string, error)
	GetDomain(ctx context.Context, domain string) (*registrar.Domain, error)
	GetTsigKey(ctx context.Context, domain string) (*dns.TSIGKey, error)
	GetServeAlgorithm(ctx context.Context, domain string) (string, error)
	GetMasterIPs(ctx context.Context) ([]string, error)
}

type OpenEdgegridDNSService interface {
	ListZones(queryArgs dns.ZoneListQueryArgs) (*dns.ZoneListResponse, error)
	GetZone(domain string) (*dns.ZoneResponse, error)
	GetZoneKey(domain string) (*dns.TSIGKeyResponse, error)
	GetNameServerRecordList(contractId string) ([]string, error)
}

type OpenDNSConfig struct {
	config *edgegrid.Config
}

// AkamaiProvider implements the DNS provider for Akamai.
type AkamaiRegistrar struct {
	registrar.BaseRegistrarProvider
	akamaiConfig *AkamaiConfig
	// Defines client. Allows for mocking.
	client    AkamaiDNSService
	dnsclient OpenEdgegridDNSService
}

type AkamaiConfig struct {
	AkamaiConfigPath    string
	AkamaiContracts     string `yaml:"akamai_contracts"`
	AkamaiNameFilter    string `yaml:"akamai_name_filter"`
	AkamaiEdgercPath    string `yaml:"akamai_edgerc_path"`
	AkamaiEdgercSection string `yaml:"akamai_edgerc_section"`
	AkamaiHost          string `yaml:"akamai_host"`
	AkamaiAccessToken   string `yaml:"akamai_access_token"`
	AkamaiClientToken   string `yaml:"akamai_client_token"`
	AkamaiClientSecret  string `yaml:"akamai_client_secret"`
	MaxBody             int    `yaml:"akamai_max_body"`
	AccountKey          string `yaml:"akamai_account_key"`
}

// NewAkamaiProvider initializes a new Akamai DNS based Provider.
func NewAkamaiRegistrar(ctx context.Context, akaConfig AkamaiConfig, akaService AkamaiDNSService) (*AkamaiRegistrar, error) {

	var err error

	log := ctx.Value("appLog").(*log.Entry)
	akamaiConfig := &akaConfig
	// if mock, skip
	if akaService == nil {
		// Get file config and parse
		if akaConfig.AkamaiConfigPath == "" {
			return nil, fmt.Errorf("Akamai Registrar requires a configuration file")
		}
		akamaiConfig, err = loadConfig(log, akaConfig.AkamaiConfigPath)
		if err != nil {
			return nil, fmt.Errorf("Akamai Registrar. Invalid configuration file")
		}
	}
	// Process creds. Could be on cmd line, config file
	var edgeGridConfig edgegrid.Config

	log.Debugf("Host: %s", akamaiConfig.AkamaiHost)
	log.Debugf("ClientToken: %s", akamaiConfig.AkamaiClientToken)
	log.Debugf("ClientSecret: %s", akamaiConfig.AkamaiClientSecret)
	log.Debugf("AccessToken: %s", akamaiConfig.AkamaiAccessToken)
	log.Debugf("EdgePath: %s", akamaiConfig.AkamaiEdgercPath)
	log.Debugf("EdgeSection: %s", akamaiConfig.AkamaiEdgercSection)
	log.Debugf("AkamaiContracts: %v", akamaiConfig.AkamaiContracts)
	// environment overrides edgerc file but config needs to be complete
	if akamaiConfig.AkamaiHost == "" || akamaiConfig.AkamaiClientToken == "" || akamaiConfig.AkamaiClientSecret == "" || akamaiConfig.AkamaiAccessToken == "" {
		// Look for Akamai environment or .edgerd creds
		var err error
		edgeGridConfig, err = edgegrid.Init(akamaiConfig.AkamaiEdgercPath, akamaiConfig.AkamaiEdgercSection) // use default .edgerc location and section
		if err != nil {
			log.Errorf("Edgegrid Init Failed")
			return nil, err // return empty provider for backward compatibility
		}
	} else {
		// Use external-dns config
		edgeGridConfig = edgegrid.Config{
			Host:         akamaiConfig.AkamaiHost,
			ClientToken:  akamaiConfig.AkamaiClientToken,
			ClientSecret: akamaiConfig.AkamaiClientSecret,
			AccessToken:  akamaiConfig.AkamaiAccessToken,
			MaxBody:      131072, // same default val as used by Edgegrid
			Debug:        false,
		}
		if akamaiConfig.MaxBody != 0 {
			edgeGridConfig.MaxBody = akamaiConfig.MaxBody
		}
		if akamaiConfig.AccountKey != "" {
			edgeGridConfig.AccountKey = akamaiConfig.AccountKey
		}
		// Check for edgegrid environment overrides
		if envval, ok := os.LookupEnv("AKAMAI_MAX_BODY"); ok {
			if i, err := strconv.Atoi(envval); err == nil {
				edgeGridConfig.MaxBody = i
				log.Debugf("Edgegrid maxbody set to %s", envval)
			}
		}
		if envval, ok := os.LookupEnv("AKAMAI_ACCOUNT_KEY"); ok {
			edgeGridConfig.AccountKey = envval
			log.Debugf("Edgegrid applying account key %s", envval)
		}
		if envval, ok := os.LookupEnv("AKAMAI_DEBUG"); ok {
			if dbgval, err := strconv.ParseBool(envval); err == nil {
				edgeGridConfig.Debug = dbgval
				log.Debugf("Edgegrid debug set to %s", envval)
			}
		}
	}

	provider := &AkamaiRegistrar{
		dnsclient:    &OpenDNSConfig{config: &edgeGridConfig},
		akamaiConfig: akamaiConfig,
	}
	if akaService != nil {
		log.Debugf("Using STUB")
		provider.client = akaService
	} else {
		provider.client = provider
	}

	// Init library for direct endpoint calls
	dns.Init(edgeGridConfig)

	return provider, nil
}

func resetDNSConfig(orig edgegrid.Config) {

	dns.Config = orig

}

func (a *AkamaiRegistrar) GetDomains(ctx context.Context) ([]string, error) {

	log := ctx.Value("appLog").(*log.Entry)
	log.Debug("Entering Akamai registrar GetDomains")

	queryArgs := dns.ZoneListQueryArgs{
		Types:       "PRIMARY",
		SortBy:      "zone",
		ContractIds: a.akamaiConfig.AkamaiContracts,
		Search:      a.akamaiConfig.AkamaiNameFilter,
	}
	log.Debugf("ListZones Query Args: %v", queryArgs)
	zlResp, err := a.dnsclient.ListZones(queryArgs)
	if err != nil {
		log.Debugf("Registrar GetDomains failed. Error: %s", err.Error())
		return []string{}, err
	}
	filter := "LOCKED"
	domains := make([]string, 0, len(zlResp.Zones))
	for _, zone := range zlResp.Zones {
		if filter == zone.ActivationState {
			continue
		}
		domains = append(domains, zone.Zone)
	}

	log.Debugf("Registrar GetDomains result: %v", domains)
	return domains, nil
}

func (a *AkamaiRegistrar) GetDomain(ctx context.Context, domain string) (*registrar.Domain, error) {

	log := ctx.Value("appLog").(*log.Entry)
	log.Debug("Entering Akamai registrar GetDomain")

	zone, err := a.dnsclient.GetZone(domain)
	if err != nil {
		return nil, err
	}
	log.Debugf("Registrar GetDomain result: %v", zone)
	return &registrar.Domain{
		Name:                  zone.Zone,
		Type:                  zone.Type,
		SignAndServe:          zone.SignAndServe,
		SignAndServeAlgorithm: zone.SignAndServeAlgorithm,
		Masters:               zone.Masters,
		TsigKey:               zone.TsigKey,
	}, nil
}

func (a *AkamaiRegistrar) GetTsigKey(ctx context.Context, domain string) (tsigKey *dns.TSIGKey, err error) {

	log := ctx.Value("appLog").(*log.Entry)
	log.Debug("Entering Akamai registrar GetTsigKey")

	resp, err := a.dnsclient.GetZoneKey(domain)

	if err != nil {
		return nil, err
	}

	log.Debugf("Returning Registrar GetTsigKey result")
	return &resp.TSIGKey, nil
}

func (a *AkamaiRegistrar) GetServeAlgorithm(ctx context.Context, domain string) (algo string, err error) {

	log := ctx.Value("appLog").(*log.Entry)
	log.Debug("Entering Akamai registrar GetServeAlgorithm")

	zone, err := a.dnsclient.GetZone(domain)
	if err != nil {
		return "", err
	}
	log.Debugf("Returning Registrar GetServeAlgorithm result")
	return zone.SignAndServeAlgorithm, nil
}

func (a *AkamaiRegistrar) GetMasterIPs(ctx context.Context) ([]string, error) {

	log := ctx.Value("appLog").(*log.Entry)
	log.Debug("Entering Akamai registrar GetMasterIPs")

	if len(a.akamaiConfig.AkamaiContracts) < 1 {
		log.Debug("Registrar GetMasterIPs failed. No contracts")
		return []string{}, fmt.Errorf("No contracts provided")
	}
	contractId := strings.Split(a.akamaiConfig.AkamaiContracts, ",")[0]
	ns, err := a.dnsclient.GetNameServerRecordList(contractId)
	if err != nil {
		log.Debugf("Registrar GetMasterIPs failed. Error: %s", err.Error())
		return []string{}, err
	}
	log.Debugf("Retrieved IPs: %v", ns)
	masters := []string{}
	// Lookup IP4 address for each name server
	for _, entry := range ns {
		ips, err := net.LookupHost(entry)
		if err != nil {
			log.Warnf("Master Hostname %s lookup failed. %s", entry, err.Error())
			continue
		}
		for _, ip := range ips {
			if strings.Contains(ip, ".") {
				masters = append(masters, ip)
				break
			}
		}
	}
	log.Debugf("Registrar GetMasterIPs result: %v", masters)
	return masters, nil
}

//
// Config file processing
//
func loadConfig(log *log.Entry, configFile string) (*AkamaiConfig, error) {

	log.Debug("Entering Akamai registrar loadConfig")
	if fileExists(configFile) {
		// Load config from file
		configData, err := ioutil.ReadFile(configFile)
		if err != nil {
			return nil, err
		}

		return loadConfigContent(log, configData)
	}

	log.Infof("Config file %v does not exist, using default values", configFile)
	return nil, nil

}

func loadConfigContent(log *log.Entry, configData []byte) (*AkamaiConfig, error) {
	config := AkamaiConfig{}
	err := yaml.Unmarshal(configData, &config)
	if err != nil {
		return nil, err
	}

	log.Info("akamai registrar config loaded")
	return &config, nil
}

func fileExists(filename string) bool {
	info, err := os.Stat(filename)
	if os.IsNotExist(err) {
		return false
	}
	return !info.IsDir()
}

//
// Open DNS stubbable functions
//
func (o OpenDNSConfig) ListZones(queryArgs dns.ZoneListQueryArgs) (*dns.ZoneListResponse, error) {

	// both edgedns and this registrar using dns. need to temp swap config...
	existConfig := dns.Config
	defer resetDNSConfig(existConfig)
	dns.Config = *o.config

	return dns.ListZones(queryArgs)
}

func (o OpenDNSConfig) GetZone(domain string) (*dns.ZoneResponse, error) {

	// both edgedns and this registrar using dns. need to temp swap config...
	existConfig := dns.Config
	defer resetDNSConfig(existConfig)
	dns.Config = *o.config

	return dns.GetZone(domain)
}

func (o OpenDNSConfig) GetZoneKey(domain string) (*dns.TSIGKeyResponse, error) {

	// both edgedns and this registrar using dns. need to temp swap config...
	existConfig := dns.Config
	defer resetDNSConfig(existConfig)
	dns.Config = *o.config

	return dns.GetZoneKey(domain)
}

func (o OpenDNSConfig) GetNameServerRecordList(contractId string) ([]string, error) {

	// both edgedns and this registrar using dns. need to temp swap config...
	existConfig := dns.Config
	defer resetDNSConfig(existConfig)
	dns.Config = *o.config

	return dns.GetNameServerRecordList(contractId)
}