github.com/openshift/installer@v1.4.17/pkg/asset/lbconfig/lbconfig.go

package lbconfig

import (
	"context"
	"fmt"
	"net"
	"os"
	"path/filepath"

	corev1 "k8s.io/api/core/v1"
	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
	"sigs.k8s.io/yaml"

	"github.com/openshift/installer/pkg/asset"
)

// LoadBalancerCategory describes the type of load balancer data.
type LoadBalancerCategory string

var (
	// ConfigName is the name of the load balancer config file.
	ConfigName = "openshift-lb-config.yaml"

	// ConfigPath is the path to the load balancer config file.
	ConfigPath = filepath.Join("openshift", ConfigName)

	// PublicLoadBalancer indicates that the data is related to public load balancers.
	PublicLoadBalancer LoadBalancerCategory = "external-api-lb-ips"

	// PrivateLoadBalancer indicates that the data is related to private load balancers.
	PrivateLoadBalancer LoadBalancerCategory = "internal-api-lb-ips"
)

// Config generates the lbConfigForDNS ConfigMap.
type Config struct {
	File *asset.File
}

var _ asset.WritableAsset = (*Config)(nil)

// Name returns a human friendly name for the asset.
func (*Config) Name() string {
	return "OpenShift Load Balancer Config"
}

// Dependencies returns all the dependencies directly needed to generate
// the asset.
func (*Config) Dependencies() []asset.Asset {
	return []asset.Asset{}
}

// Generate generates the openshift-install ConfigMap.
func (i *Config) Generate(_ context.Context, dependencies asset.Parents) error {
	cm, err := CreateLBConfigMap("openshift-lb-config", "", "")
	if err != nil {
		return err
	}

	i.File = &asset.File{
		Filename: ConfigPath,
		Data:     []byte(cm),
	}

	return nil
}

// GenerateLBConfigOverride generates an LBConfig an overrides the file data.
func GenerateLBConfigOverride(lbIntDNS, lbDNS string) (*Config, error) {
	config := &Config{}
	if err := config.Generate(context.TODO(), asset.Parents{}); err != nil {
		return nil, err
	}

	output, err := CreateLBConfigMap("openshift-lb-config", lbIntDNS, lbDNS)
	if err != nil {
		return nil, fmt.Errorf("failed to override the lb config: %w", err)
	}
	config.File.Data = []byte(output)
	return config, nil
}

// Files returns the files generated by the asset.
func (i *Config) Files() []*asset.File {
	if i.File != nil {
		return []*asset.File{i.File}
	}
	return []*asset.File{}
}

// Load loads the already-rendered files back from disk.
func (i *Config) Load(f asset.FileFetcher) (bool, error) {
	file, err := f.FetchByName(ConfigPath)
	if os.IsNotExist(err) {
		return false, nil
	} else if err != nil {
		return false, err
	}
	i.File = file
	return true, nil
}

// CreateLBConfigMap creates a ConfigMap containing API and APi-Int
// LB configuration. Returns an error if marshalling to YAML fails.
func CreateLBConfigMap(name, lbIntDNS, lbDNS string) (string, error) {
	if lbIntDNS == "" && lbDNS == "" {
		return "", nil
	}

	cm := &corev1.ConfigMap{
		TypeMeta: metav1.TypeMeta{
			APIVersion: corev1.SchemeGroupVersion.String(),
			Kind:       "ConfigMap",
		},
		ObjectMeta: metav1.ObjectMeta{
			Namespace: "openshift-infra",
			Name:      name,
		},
		Data: map[string]string{
			string(PrivateLoadBalancer): lbIntDNS,
			string(PublicLoadBalancer):  lbDNS,
		},
	}

	cmData, err := yaml.Marshal(cm)
	if err != nil {
		return "", fmt.Errorf("failed to create %q ConfigMap: %w", name, err)
	}

	return string(cmData), nil
}

// ParseDNSDataFromConfig parses the ip addresses and DNS names from the config map.
func (i *Config) ParseDNSDataFromConfig(loadBalancerType LoadBalancerCategory) ([]string, []net.IP, error) {
	ipAddresses := []net.IP{}
	dnsNames := []string{}

	// Load Data from LBConfig
	lbData := make(map[string]interface{})
	if err := yaml.Unmarshal(i.File.Data, &lbData); err != nil {
		return dnsNames, ipAddresses, err
	}

	if internalData, ok := lbData["data"]; ok {
		if lbStoredData, ok := internalData.(map[string]interface{})[string(loadBalancerType)]; ok {
			// TODO: make this parse a comma separated string
			parsedIP := net.ParseIP(lbStoredData.(string))
			if parsedIP != nil {
				ipAddresses = append(ipAddresses, parsedIP)
			} else {
				// assume the data is a dns entry
				dnsNames = append(dnsNames, lbStoredData.(string))
			}
		}
	}

	return dnsNames, ipAddresses, nil
}