Method GetGuestAgentInterfaces

pkg/api/network_interfaces.go:37–156

GetGuestAgentInterfaces retrieves network interface information from the QEMU guest agent.

(vm *VM)

// GetGuestAgentInterfaces retrieves network interface information from the QEMU guest agent.
func (c *Client) GetGuestAgentInterfaces(vm *VM) ([]NetworkInterface, error) {
	if vm.Type != VMTypeQemu || vm.Status != VMStatusRunning {
		return nil, fmt.Errorf("guest agent not applicable for this VM type or status")
	}

	if !vm.AgentEnabled {
		return nil, fmt.Errorf("guest agent is not enabled for this VM")
	}

	var res map[string]interface{}

	endpoint := fmt.Sprintf("/nodes/%s/qemu/%d/agent/network-get-interfaces", vm.Node, vm.ID)

	// Use GetNoRetry to avoid repeated failed requests if agent is not running
	err := c.GetNoRetry(endpoint, &res)
	if err != nil {
		// Check if the error is due to guest agent not running
		if strings.Contains(err.Error(), "QEMU guest agent is not running") {
			return nil, fmt.Errorf("QEMU guest agent is not running")
		}

		return nil, fmt.Errorf("failed to get guest agent interfaces: %w", err)
	}

	data, ok := res["data"].(map[string]interface{})
	if !ok {
		return nil, fmt.Errorf("unexpected response format from guest agent")
	}

	resultArray, ok := data["result"].([]interface{})
	if !ok {
		return nil, fmt.Errorf("unexpected result format from guest agent")
	}

	var interfaces []NetworkInterface

	for _, iface := range resultArray {
		ifaceMap, ok := iface.(map[string]interface{})
		if !ok {
			continue
		}

		netInterface := NetworkInterface{}

		// Get interface name and MAC address
		if name, ok := ifaceMap["name"].(string); ok {
			netInterface.Name = name
			netInterface.IsLoopback = name == "lo" || strings.HasPrefix(name, "lo:")
		}

		if mac, ok := ifaceMap["hardware-address"].(string); ok {
			netInterface.MACAddress = mac
		}

		// Parse IP addresses
		if ipAddresses, ok := ifaceMap["ip-addresses"].([]interface{}); ok {
			for _, ipData := range ipAddresses {
				ipMap, ok := ipData.(map[string]interface{})