config

Documentation

Index

• Constants
• Variables
• func GetInterfaceIP(name string) (string, error)
• func GetInterfaceName(address string) (string, error)
• func InterfaceExists(name string) (bool, error)
• type APIInterface
• type APIInterfaceYaml
• type APIYaml
• type AuditLogging
• type AuditLoggingYaml
• type Config
  • func Validate(filePath string) (Config, error)
• type ConfigYAML
• type DB
• type DBYaml
• type Interfaces
• type InterfacesYaml
• type Logging
• type LoggingYaml
• type N2Interface
• type N2InterfaceYaml
• type N3Interface
• type N3InterfaceYaml
• type N6Interface
• type N6InterfaceYaml
• type SystemLogging
• type SystemLoggingYaml
• type TLS
• type TLSYaml
• type Telemetry
• type TelemetryYaml
• type UPFYaml
• type VlanConfig
• type XDP
• type XDPYaml

Constants

const (
	AttachModeNative  = "native"
	AttachModeGeneric = "generic"
)

const (
	LoggingSystemOutputStdout = "stdout"
	LoggingSystemOutputFile   = "file"
)

const (
	UpfNodeID = "0.0.0.0"
)

Variables

var CheckInterfaceExistsFunc = func(name string) (bool, error) {
	networkInterface, err := net.InterfaceByName(name)
	if err != nil {
		return false, err
	}
	if networkInterface == nil {
		return false, nil
	}
	return true, nil
}

var GetInterfaceIPFunc = func(name string) (string, error) {
	iface, err := net.InterfaceByName(name)
	if err != nil {
		return "", err
	}

	addresses, err := iface.Addrs()
	if err != nil {
		return "", err
	}

	for _, addr := range addresses {
		if ip, _, err := net.ParseCIDR(addr.String()); err == nil {
			if ip.To4() != nil {
				return ip.String(), nil
			}
		}
	}

	return "", errors.New("no valid IPv4 address found")
}

var GetInterfaceNameFunc = func(address string) (string, error) {
	if address == "" {
		return "", errors.New("address is empty")
	}
	interfaces, err := net.Interfaces()
	if err != nil {
		return "", fmt.Errorf("cannot list network interfaces: %w", err)
	}

	for _, iface := range interfaces {
		addresses, err := iface.Addrs()
		if err != nil {
			return "", err
		}

		for _, addr := range addresses {
			if ip, _, err := net.ParseCIDR(addr.String()); err == nil {
				if ip.String() == address {
					return iface.Name, nil
				}
			}
		}
	}

	return "", nil
}

var GetVLANConfigForInterfaceFunc = func(name string) (*VlanConfig, error) {
	link, err := netlink.LinkByName(name)
	if err != nil {
		return nil, err
	}
	if link.Type() == "vlan" {
		vlanLink := link.(*netlink.Vlan)
		parentLink, err := netlink.LinkByIndex(vlanLink.ParentIndex)
		if err != nil {
			return nil, err
		}
		config := VlanConfig{MasterInterface: parentLink.Attrs().Name, VlanId: vlanLink.VlanId}

		return &config, nil
	}
	return nil, nil
}

Functions

func GetInterfaceIP

func GetInterfaceIP(name string) (string, error)

func GetInterfaceName

func GetInterfaceName(address string) (string, error)

func InterfaceExists

func InterfaceExists(name string) (bool, error)

Types

type APIInterface

type APIInterface struct {
	Address string
	Port    int
	TLS     TLS
}

type APIInterfaceYaml

type APIInterfaceYaml struct {
	Name    string  `yaml:"name"`
	Address string  `yaml:"address"`
	Port    int     `yaml:"port"`
	TLS     TLSYaml `yaml:"tls"`
}

type APIYaml

type APIYaml struct {
	Port int     `yaml:"port"`
	TLS  TLSYaml `yaml:"tls"`
}

type AuditLogging

type AuditLogging struct {
	Output string
	Path   string
}

type AuditLoggingYaml

type AuditLoggingYaml struct {
	Output string `yaml:"output"`
	Path   string `yaml:"path"`
}

type Config

type Config struct {
	Logging    Logging
	DB         DB
	Interfaces Interfaces
	XDP        XDP
	Telemetry  Telemetry
}

func Validate

func Validate(filePath string) (Config, error)

type ConfigYAML

type ConfigYAML struct {
	Logging    LoggingYaml    `yaml:"logging"`
	DB         DBYaml         `yaml:"db"`
	Interfaces InterfacesYaml `yaml:"interfaces"`
	XDP        XDPYaml        `yaml:"xdp"`
	Telemetry  TelemetryYaml  `yaml:"telemetry"`
}

type DB

type DB struct {
	Path string
}

type DBYaml

type DBYaml struct {
	Path string `yaml:"path"`
}

type Interfaces

type Interfaces struct {
	N2  N2Interface
	N3  N3Interface
	N6  N6Interface
	API APIInterface
}

type InterfacesYaml

type InterfacesYaml struct {
	N2  N2InterfaceYaml  `yaml:"n2"`
	N3  N3InterfaceYaml  `yaml:"n3"`
	N6  N6InterfaceYaml  `yaml:"n6"`
	API APIInterfaceYaml `yaml:"api"`
}

type Logging

type Logging struct {
	SystemLogging SystemLogging
	AuditLogging  AuditLogging
}

type LoggingYaml

type LoggingYaml struct {
	SystemLogging SystemLoggingYaml `yaml:"system"`
	AuditLogging  AuditLoggingYaml  `yaml:"audit"`
}

type N2Interface

type N2Interface struct {
	Address string
	Port    int
}

type N2InterfaceYaml

type N2InterfaceYaml struct {
	Name    string `yaml:"name"`
	Address string `yaml:"address"`
	Port    int    `yaml:"port"`
}

type N3Interface

type N3Interface struct {
	Name       string
	Address    string
	VlanConfig *VlanConfig
}

type N3InterfaceYaml

type N3InterfaceYaml struct {
	Name    string `yaml:"name"`
	Address string `yaml:"address"`
}

type N6Interface

type N6Interface struct {
	Name       string
	VlanConfig *VlanConfig
}

type N6InterfaceYaml

type N6InterfaceYaml struct {
	Name string `yaml:"name"`
}

type SystemLogging

type SystemLogging struct {
	Level  string
	Output string
	Path   string
}

type SystemLoggingYaml

type SystemLoggingYaml struct {
	Level  string `yaml:"level"`
	Output string `yaml:"output"`
	Path   string `yaml:"path"`
}

type TLS

type TLS struct {
	Cert string
	Key  string
}

type TLSYaml

type TLSYaml struct {
	Cert string `yaml:"cert"`
	Key  string `yaml:"key"`
}

type Telemetry

type Telemetry struct {
	Enabled      bool
	OTLPEndpoint string // e.g., "otel-collector.default.svc:4317"
}

type TelemetryYaml

type TelemetryYaml struct {
	Enabled      bool   `yaml:"enabled"`
	OTLPEndpoint string `yaml:"otlp-endpoint"`
}

type UPFYaml

type UPFYaml struct {
	Interfaces []string `yaml:"interfaces"`
}

type VlanConfig

type VlanConfig struct {
	MasterInterface string
	VlanId          int
}

type XDP

type XDP struct {
	AttachMode string
}

type XDPYaml

type XDPYaml struct {
	AttachMode string `yaml:"attach-mode"`
}