8467233545

Committed 28 Mar 2024 12:26PM UTC coverage: 38.344% (+0.7%) from 37.675%

Build # 8467233545

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #643 from ykulazhenkov/pr-turn-on-switchdev

[switchdev 9/9] Enable new switchdev implementation

Run Details

189 of 289 new or added lines in 9 files covered. (65.4%)

26 existing lines in 8 files now uncovered.

4798 of 12513 relevant lines covered (38.34%)

0.42 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

45.77

/api/v1/helper.go

package v1

import (
        "context"
        "encoding/json"
        "fmt"
        "os"
        "regexp"
        "sort"
        "strconv"
        "strings"

        corev1 "k8s.io/api/core/v1"
        metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
        uns "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
        intstrutil "k8s.io/apimachinery/pkg/util/intstr"
        "k8s.io/client-go/kubernetes"
        logf "sigs.k8s.io/controller-runtime/pkg/log"

        "github.com/k8snetworkplumbingwg/sriov-network-operator/pkg/consts"
        "github.com/k8snetworkplumbingwg/sriov-network-operator/pkg/render"
        "github.com/k8snetworkplumbingwg/sriov-network-operator/pkg/vars"
)

const (
        LASTNETWORKNAMESPACE    = "operator.sriovnetwork.openshift.io/last-network-namespace"
        NETATTDEFFINALIZERNAME  = "netattdef.finalizers.sriovnetwork.openshift.io"
        POOLCONFIGFINALIZERNAME = "poolconfig.finalizers.sriovnetwork.openshift.io"
        ESwithModeLegacy        = "legacy"
        ESwithModeSwitchDev     = "switchdev"

        SriovCniStateEnable  = "enable"
        SriovCniStateDisable = "disable"
        SriovCniStateAuto    = "auto"
        SriovCniStateOff     = "off"
        SriovCniStateOn      = "on"
        SriovCniIpam         = "\"ipam\""
        SriovCniIpamEmpty    = SriovCniIpam + ":{}"
)

const invalidVfIndex = -1

var ManifestsPath = "./bindata/manifests/cni-config"
var log = logf.Log.WithName("sriovnetwork")

// NicIDMap contains supported mapping of IDs with each in the format of:
// Vendor ID, Physical Function Device ID, Virtual Function Device ID
var NicIDMap = []string{}

var InitialState SriovNetworkNodeState

// NetFilterType Represents the NetFilter tags to be used
type NetFilterType int

const (
        // OpenstackNetworkID network UUID
        OpenstackNetworkID NetFilterType = iota

        SupportedNicIDConfigmap = "supported-nic-ids"
)

type ConfigurationModeType string

const (
        DaemonConfigurationMode  ConfigurationModeType = "daemon"
        SystemdConfigurationMode ConfigurationModeType = "systemd"
)

func (e NetFilterType) String() string {
        switch e {
        case OpenstackNetworkID:
                return "openstack/NetworkID"
        default:
                return fmt.Sprintf("%d", int(e))
        }
}

func InitNicIDMapFromConfigMap(client kubernetes.Interface, namespace string) error {
        cm, err := client.CoreV1().ConfigMaps(namespace).Get(
                context.Background(),
                SupportedNicIDConfigmap,
                metav1.GetOptions{},
        )
        // if the configmap does not exist, return false
        if err != nil {
                return err
        }
        for _, v := range cm.Data {
                NicIDMap = append(NicIDMap, v)
        }

        return nil
}

func InitNicIDMapFromList(idList []string) {
        NicIDMap = append(NicIDMap, idList...)
}

func IsSupportedVendor(vendorID string) bool {
        for _, n := range NicIDMap {
                ids := strings.Split(n, " ")
                if vendorID == ids[0] {
                        return true
                }
        }
        return false
}

func IsSupportedDevice(deviceID string) bool {
        for _, n := range NicIDMap {
                ids := strings.Split(n, " ")
                if deviceID == ids[1] {
                        return true
                }
        }
        return false
}

func IsSupportedModel(vendorID, deviceID string) bool {
        for _, n := range NicIDMap {
                ids := strings.Split(n, " ")
                if vendorID == ids[0] && deviceID == ids[1] {
                        return true
                }
        }
        log.Info("IsSupportedModel(): found unsupported model", "vendorId:", vendorID, "deviceId:", deviceID)
        return false
}

func IsVfSupportedModel(vendorID, deviceID string) bool {
        for _, n := range NicIDMap {
                ids := strings.Split(n, " ")
                if vendorID == ids[0] && deviceID == ids[2] {
                        return true
                }
        }
        log.Info("IsVfSupportedModel(): found unsupported VF model", "vendorId:", vendorID, "deviceId:", deviceID)
        return false
}

func IsEnabledUnsupportedVendor(vendorID string, unsupportedNicIDMap map[string]string) bool {
        for _, n := range unsupportedNicIDMap {
                if IsValidPciString(n) {
                        ids := strings.Split(n, " ")
                        if vendorID == ids[0] {
                                return true
                        }
                }
        }
        return false
}

func IsValidPciString(nicIDString string) bool {
        ids := strings.Split(nicIDString, " ")

        if len(ids) != 3 {
                log.Info("IsValidPciString(): ", nicIDString)
                return false
        }

        if len(ids[0]) != 4 {
                log.Info("IsValidPciString():", "Invalid vendor PciId ", ids[0])
                return false
        }
        if _, err := strconv.ParseInt(ids[0], 16, 32); err != nil {
                log.Info("IsValidPciString():", "Invalid vendor PciId ", ids[0])
        }

        if len(ids[1]) != 4 {
                log.Info("IsValidPciString():", "Invalid PciId of PF ", ids[1])
                return false
        }
        if _, err := strconv.ParseInt(ids[1], 16, 32); err != nil {
                log.Info("IsValidPciString():", "Invalid PciId of PF ", ids[1])
        }

        if len(ids[2]) != 4 {
                log.Info("IsValidPciString():", "Invalid PciId of VF ", ids[2])
                return false
        }
        if _, err := strconv.ParseInt(ids[2], 16, 32); err != nil {
                log.Info("IsValidPciString():", "Invalid PciId of VF ", ids[2])
        }

        return true
}

func GetSupportedVfIds() []string {
        var vfIds []string
        for _, n := range NicIDMap {
                ids := strings.Split(n, " ")
                vfID := "0x" + ids[2]
                if !StringInArray(vfID, vfIds) {
                        vfIds = append(vfIds, vfID)
                }
        }
        // return a sorted slice so that udev rule is stable
        sort.Slice(vfIds, func(i, j int) bool {
                ip, _ := strconv.ParseInt(vfIds[i], 0, 32)
                jp, _ := strconv.ParseInt(vfIds[j], 0, 32)
                return ip < jp
        })
        return vfIds
}

func GetVfDeviceID(deviceID string) string {
        for _, n := range NicIDMap {
                ids := strings.Split(n, " ")
                if deviceID == ids[1] {
                        return ids[2]
                }
        }
        return ""
}

func IsSwitchdevModeSpec(spec SriovNetworkNodeStateSpec) bool {
        return ContainsSwitchdevInterface(spec.Interfaces)
}

// ContainsSwitchdevInterface returns true if provided interface list contains interface
// with switchdev configuration
func ContainsSwitchdevInterface(interfaces []Interface) bool {
        for _, iface := range interfaces {
                if iface.EswitchMode == ESwithModeSwitchDev {
                        return true
                }
        }
        return false
}

func FindInterface(interfaces Interfaces, name string) (iface Interface, err error) {
        for _, i := range interfaces {
                if i.Name == name {
                        return i, nil
                }
        }
        return Interface{}, fmt.Errorf("unable to find interface: %v", name)
}

// GetEswitchModeFromSpec returns ESwitchMode from the interface spec, returns legacy if not set
func GetEswitchModeFromSpec(ifaceSpec *Interface) string {
        if ifaceSpec.EswitchMode == "" {
                return ESwithModeLegacy
        }
        return ifaceSpec.EswitchMode
}

// GetEswitchModeFromStatus returns ESwitchMode from the interface status, returns legacy if not set
func GetEswitchModeFromStatus(ifaceStatus *InterfaceExt) string {
        if ifaceStatus.EswitchMode == "" {
                return ESwithModeLegacy
        }
        return ifaceStatus.EswitchMode
}

func NeedToUpdateSriov(ifaceSpec *Interface, ifaceStatus *InterfaceExt) bool {
        if ifaceSpec.Mtu > 0 {
                mtu := ifaceSpec.Mtu
                if mtu != ifaceStatus.Mtu {
                        log.V(2).Info("NeedToUpdateSriov(): MTU needs update", "desired", mtu, "current", ifaceStatus.Mtu)
                        return true
                }
        }
        currentEswitchMode := GetEswitchModeFromStatus(ifaceStatus)
        desiredEswitchMode := GetEswitchModeFromSpec(ifaceSpec)
        if currentEswitchMode != desiredEswitchMode {
                log.V(2).Info("NeedToUpdateSriov(): EswitchMode needs update", "desired", desiredEswitchMode, "current", currentEswitchMode)
                return true
        }
        if ifaceSpec.NumVfs != ifaceStatus.NumVfs {
                log.V(2).Info("NeedToUpdateSriov(): NumVfs needs update", "desired", ifaceSpec.NumVfs, "current", ifaceStatus.NumVfs)
                return true
        }
        if ifaceSpec.NumVfs > 0 {
                for _, vfStatus := range ifaceStatus.VFs {
                        ingroup := false
                        for _, groupSpec := range ifaceSpec.VfGroups {
                                if IndexInRange(vfStatus.VfID, groupSpec.VfRange) {
                                        ingroup = true
                                        if vfStatus.Driver == "" {
                                                log.V(2).Info("NeedToUpdateSriov(): Driver needs update - has no driver",
                                                        "desired", groupSpec.DeviceType)
                                                return true
                                        }
                                        if groupSpec.DeviceType != "" && groupSpec.DeviceType != consts.DeviceTypeNetDevice {
                                                if groupSpec.DeviceType != vfStatus.Driver {
                                                        log.V(2).Info("NeedToUpdateSriov(): Driver needs update",
                                                                "desired", groupSpec.DeviceType, "current", vfStatus.Driver)
                                                        return true
                                                }
                                        } else {
                                                if StringInArray(vfStatus.Driver, vars.DpdkDrivers) {
                                                        log.V(2).Info("NeedToUpdateSriov(): Driver needs update",
                                                                "desired", groupSpec.DeviceType, "current", vfStatus.Driver)
                                                        return true
                                                }
                                                if vfStatus.Mtu != 0 && groupSpec.Mtu != 0 && vfStatus.Mtu != groupSpec.Mtu {
                                                        log.V(2).Info("NeedToUpdateSriov(): VF MTU needs update",
                                                                "vf", vfStatus.VfID, "desired", groupSpec.Mtu, "current", vfStatus.Mtu)
                                                        return true
                                                }

                                                // this is needed to be sure the admin mac address is configured as expected
                                                if ifaceSpec.ExternallyManaged {
                                                        log.V(2).Info("NeedToUpdateSriov(): need to update the device as it's externally manage",
                                                                "device", ifaceStatus.PciAddress)
                                                        return true
                                                }
                                        }
                                        if groupSpec.VdpaType != vfStatus.VdpaType {
                                                log.V(2).Info("NeedToUpdateSriov(): VF VdpaType mismatch",
                                                        "desired", groupSpec.VdpaType, "current", vfStatus.VdpaType)
                                                return true
                                        }
                                        break
                                }
                        }
                        if !ingroup && (StringInArray(vfStatus.Driver, vars.DpdkDrivers) || vfStatus.VdpaType != "") {
                                // need to reset VF if it is not a part of a group and:
                                // a. has DPDK driver loaded
                                // b. has VDPA device
                                return true
                        }
                }
        }
        return false
}

type ByPriority []SriovNetworkNodePolicy

func (a ByPriority) Len() int {
        return len(a)
}

func (a ByPriority) Less(i, j int) bool {
        if a[i].Spec.Priority != a[j].Spec.Priority {
                return a[i].Spec.Priority > a[j].Spec.Priority
        }
        return a[i].GetName() < a[j].GetName()
}

func (a ByPriority) Swap(i, j int) {
        a[i], a[j] = a[j], a[i]
}

// Match check if node is selected by NodeSelector
func (p *SriovNetworkNodePolicy) Selected(node *corev1.Node) bool {
        for k, v := range p.Spec.NodeSelector {
                if nv, ok := node.Labels[k]; ok && nv == v {
                        continue
                }
                return false
        }
        return true
}

func StringInArray(val string, array []string) bool {
        for i := range array {
                if array[i] == val {
                        return true
                }
        }
        return false
}

func RemoveString(s string, slice []string) (result []string, found bool) {
        if len(slice) != 0 {
                for _, item := range slice {
                        if item == s {
                                found = true
                                continue
                        }
                        result = append(result, item)
                }
        }
        return
}

func UniqueAppend(inSlice []string, strings ...string) []string {
        for _, s := range strings {
                if !StringInArray(s, inSlice) {
                        inSlice = append(inSlice, s)
                }
        }
        return inSlice
}

// Apply policy to SriovNetworkNodeState CR
func (p *SriovNetworkNodePolicy) Apply(state *SriovNetworkNodeState, equalPriority bool) error {
        s := p.Spec.NicSelector
        if s.Vendor == "" && s.DeviceID == "" && len(s.RootDevices) == 0 && len(s.PfNames) == 0 &&
                len(s.NetFilter) == 0 {
                // Empty NicSelector match none
                return nil
        }
        for _, iface := range state.Status.Interfaces {
                if s.Selected(&iface) {
                        log.Info("Update interface", "name:", iface.Name)
                        result := Interface{
                                PciAddress:        iface.PciAddress,
                                Mtu:               p.Spec.Mtu,
                                Name:              iface.Name,
                                LinkType:          p.Spec.LinkType,
                                EswitchMode:       p.Spec.EswitchMode,
                                NumVfs:            p.Spec.NumVfs,
                                ExternallyManaged: p.Spec.ExternallyManaged,
                        }
                        if p.Spec.NumVfs > 0 {
                                group, err := p.generateVfGroup(&iface)
                                if err != nil {
                                        return err
                                }
                                result.VfGroups = []VfGroup{*group}
                                found := false
                                for i := range state.Spec.Interfaces {
                                        if state.Spec.Interfaces[i].PciAddress == result.PciAddress {
                                                found = true
                                                state.Spec.Interfaces[i].mergeConfigs(&result, equalPriority)
                                                state.Spec.Interfaces[i] = result
                                                break
                                        }
                                }
                                if !found {
                                        state.Spec.Interfaces = append(state.Spec.Interfaces, result)
                                }
                        }
                }
        }
        return nil
}

// mergeConfigs merges configs from multiple polices where the last one has the
// highest priority. This merge is dependent on: 1. SR-IOV partition is
// configured with the #-notation in pfName, 2. The VF groups are
// non-overlapping or SR-IOV policies have the same priority.
func (iface Interface) mergeConfigs(input *Interface, equalPriority bool) {
        m := false
        // merge VF groups (input.VfGroups already contains the highest priority):
        // - skip group with same ResourceName,
        // - skip overlapping groups (use only highest priority)
        for _, gr := range iface.VfGroups {
                if gr.ResourceName == input.VfGroups[0].ResourceName || gr.isVFRangeOverlapping(input.VfGroups[0]) {
                        continue
                }
                m = true
                input.VfGroups = append(input.VfGroups, gr)
        }

        if !equalPriority && !m {
                return
        }

        // mtu configuration we take the highest value
        if input.Mtu < iface.Mtu {
                input.Mtu = iface.Mtu
        }
        if input.NumVfs < iface.NumVfs {
                input.NumVfs = iface.NumVfs
        }
}

func (gr VfGroup) isVFRangeOverlapping(group VfGroup) bool {
        rngSt, rngEnd, err := parseRange(gr.VfRange)
        if err != nil {
                return false
        }
        rngSt2, rngEnd2, err := parseRange(group.VfRange)
        if err != nil {
                return false
        }
        // compare minimal range has overlap
        if rngSt < rngSt2 {
                return IndexInRange(rngSt2, gr.VfRange) || IndexInRange(rngEnd2, gr.VfRange)
        }
        return IndexInRange(rngSt, group.VfRange) || IndexInRange(rngEnd, group.VfRange)
}

func (p *SriovNetworkNodePolicy) generateVfGroup(iface *InterfaceExt) (*VfGroup, error) {
        var err error
        pfName := ""
        var rngStart, rngEnd int
        found := false
        for _, selector := range p.Spec.NicSelector.PfNames {
                pfName, rngStart, rngEnd, err = ParsePFName(selector)
                if err != nil {
                        log.Error(err, "Unable to parse PF Name.")
                        return nil, err
                }
                if pfName == iface.Name {
                        found = true
                        if rngStart == invalidVfIndex && rngEnd == invalidVfIndex {
                                rngStart, rngEnd = 0, p.Spec.NumVfs-1
                        }
                        break
                }
        }
        if !found {
                // assign the default vf index range if the pfName is not specified by the nicSelector
                rngStart, rngEnd = 0, p.Spec.NumVfs-1
        }
        rng := strconv.Itoa(rngStart) + "-" + strconv.Itoa(rngEnd)
        return &VfGroup{
                ResourceName: p.Spec.ResourceName,
                DeviceType:   p.Spec.DeviceType,
                VfRange:      rng,
                PolicyName:   p.GetName(),
                Mtu:          p.Spec.Mtu,
                IsRdma:       p.Spec.IsRdma,
                VdpaType:     p.Spec.VdpaType,
        }, nil
}

func IndexInRange(i int, r string) bool {
        rngSt, rngEnd, err := parseRange(r)
        if err != nil {
                return false
        }
        if i <= rngEnd && i >= rngSt {
                return true
        }
        return false
}

func parseRange(r string) (rngSt, rngEnd int, err error) {
        rng := strings.Split(r, "-")
        rngSt, err = strconv.Atoi(rng[0])
        if err != nil {
                return
        }
        rngEnd, err = strconv.Atoi(rng[1])
        if err != nil {
                return
        }
        return
}

// Parse PF name with VF range
func ParsePFName(name string) (ifName string, rngSt, rngEnd int, err error) {
        rngSt, rngEnd = invalidVfIndex, invalidVfIndex
        if strings.Contains(name, "#") {
                fields := strings.Split(name, "#")
                ifName = fields[0]
                rngSt, rngEnd, err = parseRange(fields[1])
        } else {
                ifName = name
        }
        return
}

func (selector *SriovNetworkNicSelector) Selected(iface *InterfaceExt) bool {
        if selector.Vendor != "" && selector.Vendor != iface.Vendor {
                return false
        }
        if selector.DeviceID != "" && selector.DeviceID != iface.DeviceID {
                return false
        }
        if len(selector.RootDevices) > 0 && !StringInArray(iface.PciAddress, selector.RootDevices) {
                return false
        }
        if len(selector.PfNames) > 0 {
                var pfNames []string
                for _, p := range selector.PfNames {
                        if strings.Contains(p, "#") {
                                fields := strings.Split(p, "#")
                                pfNames = append(pfNames, fields[0])
                        } else {
                                pfNames = append(pfNames, p)
                        }
                }
                if !StringInArray(iface.Name, pfNames) {
                        return false
                }
        }
        if selector.NetFilter != "" && !NetFilterMatch(selector.NetFilter, iface.NetFilter) {
                return false
        }

        return true
}

func (s *SriovNetworkNodeState) GetInterfaceStateByPciAddress(addr string) *InterfaceExt {
        for _, iface := range s.Status.Interfaces {
                if addr == iface.PciAddress {
                        return &iface
                }
        }
        return nil
}

func (s *SriovNetworkNodeState) GetDriverByPciAddress(addr string) string {
        for _, iface := range s.Status.Interfaces {
                if addr == iface.PciAddress {
                        return iface.Driver
                }
        }
        return ""
}

// RenderNetAttDef renders a net-att-def for ib-sriov CNI
func (cr *SriovIBNetwork) RenderNetAttDef() (*uns.Unstructured, error) {
        logger := log.WithName("RenderNetAttDef")
        logger.Info("Start to render IB SRIOV CNI NetworkAttachmentDefinition")

        // render RawCNIConfig manifests
        data := render.MakeRenderData()
        data.Data["CniType"] = "ib-sriov"
        data.Data["SriovNetworkName"] = cr.Name
        if cr.Spec.NetworkNamespace == "" {
                data.Data["SriovNetworkNamespace"] = cr.Namespace
        } else {
                data.Data["SriovNetworkNamespace"] = cr.Spec.NetworkNamespace
        }
        data.Data["SriovCniResourceName"] = os.Getenv("RESOURCE_PREFIX") + "/" + cr.Spec.ResourceName

        data.Data["StateConfigured"] = true
        switch cr.Spec.LinkState {
        case SriovCniStateEnable:
                data.Data["SriovCniState"] = SriovCniStateEnable
        case SriovCniStateDisable:
                data.Data["SriovCniState"] = SriovCniStateDisable
        case SriovCniStateAuto:
                data.Data["SriovCniState"] = SriovCniStateAuto
        default:
                data.Data["StateConfigured"] = false
        }

        if cr.Spec.Capabilities == "" {
                data.Data["CapabilitiesConfigured"] = false
        } else {
                data.Data["CapabilitiesConfigured"] = true
                data.Data["SriovCniCapabilities"] = cr.Spec.Capabilities
        }

        if cr.Spec.IPAM != "" {
                data.Data["SriovCniIpam"] = SriovCniIpam + ":" + strings.Join(strings.Fields(cr.Spec.IPAM), "")
        } else {
                data.Data["SriovCniIpam"] = SriovCniIpamEmpty
        }

        // metaplugins for the infiniband cni
        data.Data["MetaPluginsConfigured"] = false
        if cr.Spec.MetaPluginsConfig != "" {
                data.Data["MetaPluginsConfigured"] = true
                data.Data["MetaPlugins"] = cr.Spec.MetaPluginsConfig
        }

        // logLevel and logFile are currently not supports by the ip-sriov-cni -> hardcode them to false.
        data.Data["LogLevelConfigured"] = false
        data.Data["LogFileConfigured"] = false

        objs, err := render.RenderDir(ManifestsPath, &data)
        if err != nil {
                return nil, err
        }
        for _, obj := range objs {
                raw, _ := json.Marshal(obj)
                logger.Info("render NetworkAttachmentDefinition output", "raw", string(raw))
        }
        return objs[0], nil
}

// NetworkNamespace returns target network namespace for the network
func (cr *SriovIBNetwork) NetworkNamespace() string {
        return cr.Spec.NetworkNamespace
}

// RenderNetAttDef renders a net-att-def for sriov CNI
func (cr *SriovNetwork) RenderNetAttDef() (*uns.Unstructured, error) {
        logger := log.WithName("RenderNetAttDef")
        logger.Info("Start to render SRIOV CNI NetworkAttachmentDefinition")

        // render RawCNIConfig manifests
        data := render.MakeRenderData()
        data.Data["CniType"] = "sriov"
        data.Data["SriovNetworkName"] = cr.Name
        if cr.Spec.NetworkNamespace == "" {
                data.Data["SriovNetworkNamespace"] = cr.Namespace
        } else {
                data.Data["SriovNetworkNamespace"] = cr.Spec.NetworkNamespace
        }
        data.Data["SriovCniResourceName"] = os.Getenv("RESOURCE_PREFIX") + "/" + cr.Spec.ResourceName
        data.Data["SriovCniVlan"] = cr.Spec.Vlan

        if cr.Spec.VlanQoS <= 7 && cr.Spec.VlanQoS >= 0 {
                data.Data["VlanQoSConfigured"] = true
                data.Data["SriovCniVlanQoS"] = cr.Spec.VlanQoS
        } else {
                data.Data["VlanQoSConfigured"] = false
        }

        data.Data["VlanProtoConfigured"] = false
        if cr.Spec.VlanProto != "" {
                data.Data["VlanProtoConfigured"] = true
                data.Data["SriovCniVlanProto"] = cr.Spec.VlanProto
        }

        if cr.Spec.Capabilities == "" {
                data.Data["CapabilitiesConfigured"] = false
        } else {
                data.Data["CapabilitiesConfigured"] = true
                data.Data["SriovCniCapabilities"] = cr.Spec.Capabilities
        }

        data.Data["SpoofChkConfigured"] = true
        switch cr.Spec.SpoofChk {
        case SriovCniStateOff:
                data.Data["SriovCniSpoofChk"] = SriovCniStateOff
        case SriovCniStateOn:
                data.Data["SriovCniSpoofChk"] = SriovCniStateOn
        default:
                data.Data["SpoofChkConfigured"] = false
        }

        data.Data["TrustConfigured"] = true
        switch cr.Spec.Trust {
        case SriovCniStateOn:
                data.Data["SriovCniTrust"] = SriovCniStateOn
        case SriovCniStateOff:
                data.Data["SriovCniTrust"] = SriovCniStateOff
        default:
                data.Data["TrustConfigured"] = false
        }

        data.Data["StateConfigured"] = true
        switch cr.Spec.LinkState {
        case SriovCniStateEnable:
                data.Data["SriovCniState"] = SriovCniStateEnable
        case SriovCniStateDisable:
                data.Data["SriovCniState"] = SriovCniStateDisable
        case SriovCniStateAuto:
                data.Data["SriovCniState"] = SriovCniStateAuto
        default:
                data.Data["StateConfigured"] = false
        }

        data.Data["MinTxRateConfigured"] = false
        if cr.Spec.MinTxRate != nil {
                if *cr.Spec.MinTxRate >= 0 {
                        data.Data["MinTxRateConfigured"] = true
                        data.Data["SriovCniMinTxRate"] = *cr.Spec.MinTxRate
                }
        }

        data.Data["MaxTxRateConfigured"] = false
        if cr.Spec.MaxTxRate != nil {
                if *cr.Spec.MaxTxRate >= 0 {
                        data.Data["MaxTxRateConfigured"] = true
                        data.Data["SriovCniMaxTxRate"] = *cr.Spec.MaxTxRate
                }
        }

        if cr.Spec.IPAM != "" {
                data.Data["SriovCniIpam"] = SriovCniIpam + ":" + strings.Join(strings.Fields(cr.Spec.IPAM), "")
        } else {
                data.Data["SriovCniIpam"] = SriovCniIpamEmpty
        }

        data.Data["MetaPluginsConfigured"] = false
        if cr.Spec.MetaPluginsConfig != "" {
                data.Data["MetaPluginsConfigured"] = true
                data.Data["MetaPlugins"] = cr.Spec.MetaPluginsConfig
        }

        data.Data["LogLevelConfigured"] = (cr.Spec.LogLevel != "")
        data.Data["LogLevel"] = cr.Spec.LogLevel
        data.Data["LogFileConfigured"] = (cr.Spec.LogFile != "")
        data.Data["LogFile"] = cr.Spec.LogFile

        objs, err := render.RenderDir(ManifestsPath, &data)
        if err != nil {
                return nil, err
        }
        for _, obj := range objs {
                raw, _ := json.Marshal(obj)
                logger.Info("render NetworkAttachmentDefinition output", "raw", string(raw))
        }
        return objs[0], nil
}

// NetworkNamespace returns target network namespace for the network
func (cr *SriovNetwork) NetworkNamespace() string {
        return cr.Spec.NetworkNamespace
}

// NetFilterMatch -- parse netFilter and check for a match
func NetFilterMatch(netFilter string, netValue string) (isMatch bool) {
        logger := log.WithName("NetFilterMatch")

        var re = regexp.MustCompile(`(?m)^\s*([^\s]+)\s*:\s*([^\s]+)`)

        netFilterResult := re.FindAllStringSubmatch(netFilter, -1)

        if netFilterResult == nil {
                logger.Info("Invalid NetFilter spec...", "netFilter", netFilter)
                return false
        }

        netValueResult := re.FindAllStringSubmatch(netValue, -1)

        if netValueResult == nil {
                logger.Info("Invalid netValue...", "netValue", netValue)
                return false
        }

        return netFilterResult[0][1] == netValueResult[0][1] && netFilterResult[0][2] == netValueResult[0][2]
}

// MaxUnavailable calculate the max number of unavailable nodes to represent the number of nodes
// we can drain in parallel
func (s *SriovNetworkPoolConfig) MaxUnavailable(numOfNodes int) (int, error) {
        // this means we want to drain all the nodes in parallel
        if s.Spec.MaxUnavailable == nil {
                return -1, nil
        }
        intOrPercent := *s.Spec.MaxUnavailable

        if intOrPercent.Type == intstrutil.String {
                if strings.HasSuffix(intOrPercent.StrVal, "%") {
                        i := strings.TrimSuffix(intOrPercent.StrVal, "%")
                        v, err := strconv.Atoi(i)
                        if err != nil {
                                return 0, fmt.Errorf("invalid value %q: %v", intOrPercent.StrVal, err)
                        }
                        if v > 100 || v < 1 {
                                return 0, fmt.Errorf("invalid value: percentage needs to be between 1 and 100")
                        }
                } else {
                        return 0, fmt.Errorf("invalid type: strings needs to be a percentage")
                }
        }

        maxunavail, err := intstrutil.GetScaledValueFromIntOrPercent(&intOrPercent, numOfNodes, false)
        if err != nil {
                return 0, err
        }

        if maxunavail < 0 {
                return 0, fmt.Errorf("negative number is not allowed")
        }

        return maxunavail, nil
}

k8snetworkplumbingwg / sriov-network-operator / 8467233545

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous