func SetupInterfaces()

in google_guest_agent/network/manager/manager.go [176:256]
60 lines of code
15 McCabe index (conditional complexity)

func SetupInterfaces(ctx context.Context, config *cfg.Sections, mds *metadata.Descriptor) error {
	if seenMetadata != nil {
		diff := reflect.DeepEqual(mds.Instance.NetworkInterfaces, seenMetadata.Instance.NetworkInterfaces) &&
			reflect.DeepEqual(mds.Instance.VlanNetworkInterfaces, seenMetadata.Instance.VlanNetworkInterfaces)

		if diff {
			logger.Debugf("MDS returned Ethernet NICs [%+v] and VLAN NICs [%+v] are already seen and applied, skipping", seenMetadata.Instance.NetworkInterfaces, seenMetadata.Instance.VlanNetworkInterfaces)
			return nil
		}
	}

	// User may have disabled network interface setup entirely.
	if !config.NetworkInterfaces.Setup {
		logger.Infof("Network interface setup disabled, skipping...")
		return nil
	}

	nics := &Interfaces{
		EthernetInterfaces: mds.Instance.NetworkInterfaces,
		VlanInterfaces:     map[string]VlanInterface{},
	}

	interfaces, err := interfaceNames(nics.EthernetInterfaces)
	if err != nil {
		return fmt.Errorf("error getting interface names: %v", err)
	}
	primaryInterface := interfaces[0]

	// Get the network manager.
	activeService, err := detectNetworkManager(ctx, primaryInterface)
	if err != nil {
		return fmt.Errorf("error detecting network manager service: %v", err)
	}

	if err := rollbackLeftoverConfigs(ctx, config, mds); err != nil {
		logger.Errorf("Failed to rollback left over configs: %v", err)
	}

	// Attempt to rollback any left over configuration of non active network managers.
	for _, svc := range knownNetworkManagers {
		if svc == activeService.manager {
			continue
		}

		logger.Infof("Rolling back %s", svc.Name())
		if err = svc.Rollback(ctx, nics); err != nil {
			logger.Warningf("Unable to roll back config for %s: %v", svc.Name(), err)
		}
	}

	// Attempt to configure all present/active network managers.

	activeService.manager.Configure(ctx, config)

	logger.Infof("Setting up %s", activeService.manager.Name())
	if err = activeService.manager.SetupEthernetInterface(ctx, config, nics); err != nil {
		return fmt.Errorf("manager(%s): error setting up ethernet interfaces: %v", activeService.manager.Name(), err)
	}

	if config.NetworkInterfaces.VlanSetupEnabled {
		logger.Infof("VLAN setup is enabled via config file, setting up interfaces")
		if err := reformatVlanNics(mds, nics, interfaces); err != nil {
			return fmt.Errorf("unable to read vlans, invalid format: %w", err)
		}
		if err = activeService.manager.SetupVlanInterface(ctx, config, nics); err != nil {
			return fmt.Errorf("manager(%s): error setting up vlan interfaces: %v", activeService.manager.Name(), err)
		}
	}

	logger.Infof("Finished setting up %s", activeService.manager.Name())

	go func() {
		// Setup might not have finished when we log and collect this information. Adding this
		// temporary sleep for debugging purposes to make sure we have up-to-date information.
		time.Sleep(2 * time.Second)
		logInterfaceState(ctx)
	}()

	seenMetadata = mds
	return nil
}