Method GetLxcInterfaces

pkg/api/network_interfaces.go:159–228

GetLxcInterfaces retrieves network interface information for an LXC container.

(vm *VM)

// GetLxcInterfaces retrieves network interface information for an LXC container.
func (c *Client) GetLxcInterfaces(vm *VM) ([]NetworkInterface, error) {
	if vm.Type != VMTypeLXC || vm.Status != VMStatusRunning {
		return nil, fmt.Errorf("network interface endpoint not applicable for this guest type or status")
	}

	var apiResponse map[string]interface{}

	endpoint := fmt.Sprintf("/nodes/%s/lxc/%d/interfaces", vm.Node, vm.ID)

	if err := c.GetWithCache(endpoint, &apiResponse, VMDataTTL); err != nil {
		// Based on previous handling, API might return 500 if feature not available or container stopped.
		// Treat this as "no interfaces found" rather than a hard error for GetVmStatus.
		c.logger.Debug("Failed to get LXC interfaces for VM %d on node %s (may be expected): %v", vm.ID, vm.Node, err)

		return nil, nil
	}

	responseData, ok := apiResponse["data"].([]interface{})
	if !ok {
		// It's possible this specific endpoint returns the array directly without a "data" wrapper.
		// Let's try to type assert apiResponse itself to []interface{}. This is unusual for Proxmox API.
		// config.DebugLog("LXC interfaces: 'data' key not found or not an array. Full response: %+v", apiResponse)
		// This part is tricky. If the user-provided example `[{"hwaddr":...}]` is accurate for the *entire* response body,
		// then `c.Get` which expects `*map[string]interface{}` will fail to unmarshal it directly.
		// The user's confidence in `c.Get` working suggests the API *does* conform, or their example was just the *value* of the "data" field.
		// For now, assuming the standard `{"data": [...]}` structure based on other working code.
		// If it still fails, this is where the GetRaw approach or direct HTTP call would be needed if the endpoint is truly different.
		return nil, fmt.Errorf("unexpected response format for LXC interfaces: 'data' field missing or not an array. VM: %d, Node: %s", vm.ID, vm.Node)
	}

	var interfaces []NetworkInterface

	for _, ifaceDataItem := range responseData {
		ifaceMap, ok := ifaceDataItem.(map[string]interface{})
		if !ok {
			c.logger.Debug("LXC interface item is not a map[string]interface{}: %+v", ifaceDataItem)

			continue
		}

		netInterface := NetworkInterface{}
		if name, ok := ifaceMap["name"].(string); ok {
			netInterface.Name = name
			netInterface.IsLoopback = (name == "lo")
		}

		if hwaddr, ok := ifaceMap["hwaddr"].(string); ok {
			netInterface.MACAddress = hwaddr
		}

		var ipAddresses []IPAddress

		if inet, ok := ifaceMap["inet"].(string); ok {
			if ip, valid := parseIPCIDR(inet, IPTypeIPv4); valid {
				ipAddresses = append(ipAddresses, ip)
			}
		}