func New()

in plugins/vpc-branch-eni/config/netconfig.go [89:218]
99 lines of code
29 McCabe index (conditional complexity)

func New(args *cniSkel.CmdArgs) (*NetConfig, error) {
	// Parse network configuration.
	var config netConfigJSON
	err := json.Unmarshal(args.StdinData, &config)
	if err != nil {
		return nil, fmt.Errorf("failed to parse network config: %v", err)
	}

	// Parse optional per-container arguments.
	if args.Args != "" {
		var pca pcArgs
		pca.IgnoreUnknown = ignoreUnknown

		if err := cniTypes.LoadArgs(args.Args, &pca); err != nil {
			return nil, fmt.Errorf("failed to parse per-container args: %v", err)
		}

		// Per-container arguments override the ones from network configuration.
		if pca.BranchVlanID != "" {
			config.BranchVlanID = string(pca.BranchVlanID)
		}
		if pca.BranchMACAddress != "" {
			config.BranchMACAddress = string(pca.BranchMACAddress)
		}
		if pca.IPAddresses != "" {
			config.IPAddresses = strings.Split(string(pca.IPAddresses), ",")
		}
		if pca.GatewayIPAddresses != "" {
			config.GatewayIPAddresses = strings.Split(string(pca.GatewayIPAddresses), ",")
		}
	}

	// Set defaults.
	if config.InterfaceType == "" {
		config.InterfaceType = IfTypeTAP
	}

	// Validate if all the required fields are present.
	if config.TrunkName == "" && config.TrunkMACAddress == "" {
		return nil, fmt.Errorf("missing required parameter trunkName or trunkMACAddress")
	}
	if config.BranchVlanID == "" {
		return nil, fmt.Errorf("missing required parameter branchVlanID")
	}
	if config.BranchMACAddress == "" {
		return nil, fmt.Errorf("missing required parameter branchMACAddress")
	}

	// Under TAP mode, UID and GID are required to set TAP ownership.
	if config.InterfaceType == IfTypeTAP {
		if config.Uid == "" {
			return nil, fmt.Errorf("missing required parameter uid")
		}
		if config.Gid == "" {
			return nil, fmt.Errorf("missing required parameter gid")
		}
	}

	// Populate NetConfig.
	netConfig := NetConfig{
		NetConf:       config.NetConf,
		TrunkName:     config.TrunkName,
		BlockIMDS:     config.BlockIMDS,
		InterfaceType: config.InterfaceType,
	}

	// Parse the trunk MAC address.
	if config.TrunkMACAddress != "" {
		netConfig.TrunkMACAddress, err = net.ParseMAC(config.TrunkMACAddress)
		if err != nil {
			return nil, fmt.Errorf("invalid trunkMACAddress %s", config.TrunkMACAddress)
		}
	}

	// Parse the branch VLAN ID.
	netConfig.BranchVlanID, err = strconv.Atoi(config.BranchVlanID)
	if err != nil {
		return nil, fmt.Errorf("invalid branchVlanID %s", config.BranchVlanID)
	}

	// Parse the branch MAC address.
	netConfig.BranchMACAddress, err = net.ParseMAC(config.BranchMACAddress)
	if err != nil {
		return nil, fmt.Errorf("invalid branchMACAddress %s", config.BranchMACAddress)
	}

	// Parse branch IP addresses. These can be IPv4 or IPv6 addresses and are optional for some
	// setups like TAP interfaces where the IP addresses are assigned through other means.
	for _, s := range config.IPAddresses {
		addr, err := vpc.GetIPAddressFromString(s)
		if err != nil {
			return nil, fmt.Errorf("invalid ipAddress %s", s)
		}
		netConfig.IPAddresses = append(netConfig.IPAddresses, *addr)
	}

	// Parse optional gateway IP addresses.
	for _, s := range config.GatewayIPAddresses {
		addr := net.ParseIP(s)
		if addr == nil {
			return nil, fmt.Errorf("invalid gatewayIPAddress %s", s)
		}
		netConfig.GatewayIPAddresses = append(netConfig.GatewayIPAddresses, addr)
	}

	// Parse the TAP interface owner UID and GID.
	if config.InterfaceType == IfTypeTAP {
		netConfig.Tap = &TAPConfig{
			Queues: defaultTapQueues,
		}

		if config.Uid != "" {
			netConfig.Tap.Uid, err = strconv.Atoi(config.Uid)
			if err != nil {
				return nil, fmt.Errorf("invalid uid %s", config.Uid)
			}
		}

		if config.Gid != "" {
			netConfig.Tap.Gid, err = strconv.Atoi(config.Gid)
			if err != nil {
				return nil, fmt.Errorf("invalid gid %s", config.Gid)
			}
		}
	}

	// Validation complete. Return the parsed NetConfig object.
	log.Debugf("Created NetConfig: %+v", netConfig)
	return &netConfig, nil
}