NetworkTool/server/internal/network/netplan/netplan.go

package netplan

import (
	"bytes"
	"fmt"
	"os"
	"path/filepath"
	"strings"

	"networktool/internal/model"

	"gopkg.in/yaml.v3"
)

type Service struct{}

type fileConfig struct {
	Network map[string]any `yaml:"network"`
}

func New() *Service { return &Service{} }

func (s *Service) FindSingleFile() (string, error) {
	files, err := filepath.Glob("/etc/netplan/*.yaml")
	if err != nil {
		return "", err
	}
	if len(files) == 0 {
		return "", fmt.Errorf("未找到 netplan 配置文件")
	}
	if len(files) > 1 {
		return "", fmt.Errorf("检测到多个 netplan 配置文件，首版暂不支持自动处理")
	}
	return files[0], nil
}

func (s *Service) Backup(path string) (string, error) {
	backupPath := path + ".networktool.bak"
	data, err := os.ReadFile(path)
	if err != nil {
		return "", err
	}
	if err := os.WriteFile(backupPath, data, 0600); err != nil {
		return "", err
	}
	return backupPath, nil
}

func (s *Service) Restore(path string, backupPath string) error {
	data, err := os.ReadFile(backupPath)
	if err != nil {
		return err
	}
	if err := os.WriteFile(path, data, 0600); err != nil {
		return err
	}
	_ = os.Remove(backupPath)
	return nil
}

func (s *Service) Write(path string, targetInterface string, input model.InterfaceConfig, managementInterface string, maintenanceCIDR string) error {
	data, err := os.ReadFile(path)
	if err != nil {
		return err
	}

	var cfg fileConfig
	if err := yaml.Unmarshal(data, &cfg); err != nil {
		return err
	}
	if cfg.Network == nil {
		cfg.Network = make(map[string]any)
	}
	if _, ok := cfg.Network["version"]; !ok {
		cfg.Network["version"] = 2
	}

	ethernets := ensureMap(cfg.Network, "ethernets")
	target := ensureMap(ethernets, targetInterface)
	if input.Dhcp4 {
		target["dhcp4"] = true
		delete(target, "addresses")
		delete(target, "gateway4")
		delete(target, "routes")
		if len(input.DNS) > 0 {
			nameservers := ensureMap(target, "nameservers")
			nameservers["addresses"] = input.DNS
		} else {
			delete(target, "nameservers")
		}
		output, err := marshalYAML(&cfg)
		if err != nil {
			return err
		}
		return os.WriteFile(path, output, 0600)
	}

	addresses := normalizedAddresses(input)
	routes := normalizedRoutes(input)
	target["dhcp4"] = false
	addressItems := make([]string, 0, len(addresses))
	for _, address := range addresses {
		addressItems = append(addressItems, fmt.Sprintf("%s/%d", strings.TrimSpace(address.IP), address.Prefix))
	}
	target["addresses"] = addressItems
	delete(target, "gateway4")
	if len(routes) > 0 {
		routeItems := make([]map[string]string, 0, len(routes))
		for _, route := range routes {
			routeItems = append(routeItems, map[string]string{"to": strings.TrimSpace(route.To), "via": strings.TrimSpace(route.Via)})
		}
		target["routes"] = routeItems
	} else {
		delete(target, "routes")
	}
	if len(input.DNS) > 0 {
		nameservers := ensureMap(target, "nameservers")
		nameservers["addresses"] = input.DNS
	} else {
		delete(target, "nameservers")
	}

	output, err := marshalYAML(&cfg)
	if err != nil {
		return err
	}
	return os.WriteFile(path, output, 0600)
}

func normalizedAddresses(input model.InterfaceConfig) []model.InterfaceAddressConfig {
	if len(input.Addresses) > 0 {
		return input.Addresses
	}
	if strings.TrimSpace(input.IP) == "" {
		return nil
	}
	return []model.InterfaceAddressConfig{{IP: strings.TrimSpace(input.IP), Prefix: input.Prefix}}
}

func normalizedRoutes(input model.InterfaceConfig) []model.InterfaceRouteConfig {
	if len(input.Routes) > 0 {
		return input.Routes
	}
	if strings.TrimSpace(input.Gateway) == "" {
		return nil
	}
	return []model.InterfaceRouteConfig{{To: "default", Via: strings.TrimSpace(input.Gateway)}}
}

func marshalYAML(value any) ([]byte, error) {
	var output bytes.Buffer
	encoder := yaml.NewEncoder(&output)
	encoder.SetIndent(2)
	if err := encoder.Encode(value); err != nil {
		_ = encoder.Close()
		return nil, err
	}
	if err := encoder.Close(); err != nil {
		return nil, err
	}
	return output.Bytes(), nil
}

func ensureMap(parent map[string]any, key string) map[string]any {
	if existing, ok := parent[key].(map[string]any); ok {
		return existing
	}
	child := make(map[string]any)
	parent[key] = child
	return child
}

func anyToStringSlice(value any) []string {
	switch typed := value.(type) {
	case []string:
		return append([]string(nil), typed...)
	case []any:
		result := make([]string, 0, len(typed))
		for _, item := range typed {
			text, ok := item.(string)
			if ok {
				result = append(result, text)
			}
		}
		return result
	default:
		return nil
	}
}

func contains(items []string, target string) bool {
	for _, item := range items {
		if item == target {
			return true
		}
	}
	return false
}

func uniqueNonEmpty(items []string) []string {
	seen := make(map[string]struct{})
	result := make([]string, 0, len(items))
	for _, item := range items {
		if item == "" {
			continue
		}
		if _, ok := seen[item]; ok {
			continue
		}
		seen[item] = struct{}{}
		result = append(result, item)
	}
	return result
}