func StaticMachineAssertions()

in pkg/providers/tinkerbell/hardware/validator.go [56:159]
83 lines of code
27 McCabe index (conditional complexity)

func StaticMachineAssertions() MachineAssertion {
	return func(m Machine) error {
		if m.IPAddress == "" {
			return newEmptyFieldError("IPAddress")
		}

		if err := networkutils.ValidateIP(m.IPAddress); err != nil {
			return fmt.Errorf("IPAddress: %v", err)
		}

		if m.Gateway == "" {
			return newEmptyFieldError("Gateway")
		}

		if err := networkutils.ValidateIP(m.Gateway); err != nil {
			return fmt.Errorf("Gateway: %v", err)
		}

		if len(m.Nameservers) == 0 {
			return newEmptyFieldError("Nameservers")
		}

		for _, nameserver := range m.Nameservers {
			if nameserver == "" {
				return newMachineError("Nameservers contains an empty entry")
			}
		}

		if m.Netmask == "" {
			return newEmptyFieldError("Netmask")
		}

		if m.MACAddress == "" {
			return newEmptyFieldError("MACAddress")
		}

		if _, err := net.ParseMAC(m.MACAddress); err != nil {
			return fmt.Errorf("MACAddress: %v", err)
		}

		if m.Hostname == "" {
			return newEmptyFieldError("Hostname")
		}

		if errs := apimachineryvalidation.IsDNS1123Subdomain(m.Hostname); len(errs) > 0 {
			return fmt.Errorf("invalid hostname: %v: %v", m.Hostname, errs)
		}

		if !linuxPathValidation.MatchString(m.Disk) {
			return fmt.Errorf(
				"disk must be a valid linux path (\"%v\")",
				linuxPathRegex,
			)
		}

		for key, value := range m.Labels {
			if err := validateLabelKey(key); err != nil {
				return err
			}

			if err := validateLabelValue(value); err != nil {
				return err
			}
		}

		if m.HasBMC() {
			if m.BMCIPAddress == "" {
				return newEmptyFieldError("BMCIPAddress")
			}

			if err := networkutils.ValidateIP(m.BMCIPAddress); err != nil {
				return fmt.Errorf("BMCIPAddress: %v", err)
			}

			if m.BMCOptions == nil || m.BMCOptions.RPC == nil {
				if m.BMCUsername == "" {
					return newEmptyFieldError("BMCUsername")
				}

				if m.BMCPassword == "" {
					return newEmptyFieldError("BMCPassword")
				}
			}
		}

		if m.VLANID != "" {
			i, err := strconv.Atoi(m.VLANID)
			if err != nil {
				return errors.New("VLANID: must be a string integer")
			}

			// valid VLAN IDs are between 1 and 4094 - https://en.m.wikipedia.org/wiki/VLAN#IEEE_802.1Q
			const (
				maxVLANID = 4094
				minVLANID = 1
			)
			if i < minVLANID || i > maxVLANID {
				return errors.New("VLANID: must be between 1 and 4094")
			}
		}

		return nil
	}
}