8758605927

Committed 19 Apr 2024 07:22PM UTC coverage: 52.363% (-0.006%) from 52.369%

Build # 8758605927

Build Type

Pull #4293

github

Committed by

cathy-zhou

Commit Message

make svc_template_support configurable, default is enabled

Signed-off-by: Yun Zhou <yunz@nvidia.com>

Pull Request Pull Request #4293: make svc_template_support configurable, default is enabled

Run Details

0 of 3 new or added lines in 1 file covered. (0.0%)

4 existing lines in 2 files now uncovered.

27507 of 52531 relevant lines covered (52.36%)

92.59 hits per line

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

0.0

/go-controller/pkg/network-controller-manager/network_controller_manager.go

package networkControllerManager

import (
        "context"
        "fmt"
        "sync"
        "time"

        "github.com/containernetworking/cni/pkg/types"
        libovsdbclient "github.com/ovn-org/libovsdb/client"
        ovncnitypes "github.com/ovn-org/ovn-kubernetes/go-controller/pkg/cni/types"
        "github.com/ovn-org/ovn-kubernetes/go-controller/pkg/config"
        "github.com/ovn-org/ovn-kubernetes/go-controller/pkg/factory"
        "github.com/ovn-org/ovn-kubernetes/go-controller/pkg/kube"
        libovsdbops "github.com/ovn-org/ovn-kubernetes/go-controller/pkg/libovsdb/ops"
        libovsdbutil "github.com/ovn-org/ovn-kubernetes/go-controller/pkg/libovsdb/util"
        "github.com/ovn-org/ovn-kubernetes/go-controller/pkg/metrics"
        "github.com/ovn-org/ovn-kubernetes/go-controller/pkg/nbdb"
        nad "github.com/ovn-org/ovn-kubernetes/go-controller/pkg/network-attach-def-controller"
        "github.com/ovn-org/ovn-kubernetes/go-controller/pkg/ovn"
        ovntypes "github.com/ovn-org/ovn-kubernetes/go-controller/pkg/types"
        "github.com/ovn-org/ovn-kubernetes/go-controller/pkg/util"

        "k8s.io/apimachinery/pkg/util/wait"
        clientset "k8s.io/client-go/kubernetes"
        "k8s.io/client-go/tools/record"
        "k8s.io/klog/v2"
)

// NetworkControllerManager structure is the object manages all controllers for all networks
type NetworkControllerManager struct {
        client       clientset.Interface
        kube         *kube.KubeOVN
        watchFactory *factory.WatchFactory
        podRecorder  *metrics.PodRecorder
        // event recorder used to post events to k8s
        recorder record.EventRecorder
        // libovsdb northbound client interface
        nbClient libovsdbclient.Client
        // libovsdb southbound client interface
        sbClient libovsdbclient.Client
        // has SCTP support
        SCTPSupport bool
        // Supports multicast?
        multicastSupport bool
        // Supports OVN Template Load Balancers?
        svcTemplateSupport bool

        stopChan chan struct{}
        wg       *sync.WaitGroup

        defaultNetworkController nad.BaseNetworkController

        // net-attach-def controller handle net-attach-def and create/delete network controllers
        nadController *nad.NetAttachDefinitionController
}

func (cm *NetworkControllerManager) NewNetworkController(nInfo util.NetInfo) (nad.NetworkController, error) {
        cnci, err := cm.newCommonNetworkControllerInfo()
        if err != nil {
                return nil, fmt.Errorf("failed to create network controller info %w", err)
        }
        topoType := nInfo.TopologyType()
        switch topoType {
        case ovntypes.Layer3Topology:
                return ovn.NewSecondaryLayer3NetworkController(cnci, nInfo), nil
        case ovntypes.Layer2Topology:
                return ovn.NewSecondaryLayer2NetworkController(cnci, nInfo), nil
        case ovntypes.LocalnetTopology:
                return ovn.NewSecondaryLocalnetNetworkController(cnci, nInfo), nil
        }
        return nil, fmt.Errorf("topology type %s not supported", topoType)
}

// newDummyNetworkController creates a dummy network controller used to clean up specific network
func (cm *NetworkControllerManager) newDummyNetworkController(topoType, netName string) (nad.NetworkController, error) {
        cnci, err := cm.newCommonNetworkControllerInfo()
        if err != nil {
                return nil, fmt.Errorf("failed to create network controller info %w", err)
        }
        netInfo, _ := util.NewNetInfo(&ovncnitypes.NetConf{NetConf: types.NetConf{Name: netName}, Topology: topoType})
        switch topoType {
        case ovntypes.Layer3Topology:
                return ovn.NewSecondaryLayer3NetworkController(cnci, netInfo), nil
        case ovntypes.Layer2Topology:
                return ovn.NewSecondaryLayer2NetworkController(cnci, netInfo), nil
        case ovntypes.LocalnetTopology:
                return ovn.NewSecondaryLocalnetNetworkController(cnci, netInfo), nil
        }
        return nil, fmt.Errorf("topology type %s not supported", topoType)
}

// Find all the OVN logical switches/routers for the secondary networks
func findAllSecondaryNetworkLogicalEntities(nbClient libovsdbclient.Client) ([]*nbdb.LogicalSwitch,
        []*nbdb.LogicalRouter, error) {
        p1 := func(item *nbdb.LogicalSwitch) bool {
                _, ok := item.ExternalIDs[ovntypes.NetworkExternalID]
                return ok
        }
        nodeSwitches, err := libovsdbops.FindLogicalSwitchesWithPredicate(nbClient, p1)
        if err != nil {
                klog.Errorf("Failed to get all logical switches of secondary network error: %v", err)
                return nil, nil, err
        }
        p2 := func(item *nbdb.LogicalRouter) bool {
                _, ok := item.ExternalIDs[ovntypes.NetworkExternalID]
                return ok
        }
        clusterRouters, err := libovsdbops.FindLogicalRoutersWithPredicate(nbClient, p2)
        if err != nil {
                klog.Errorf("Failed to get all distributed logical routers: %v", err)
                return nil, nil, err
        }
        return nodeSwitches, clusterRouters, nil
}

func (cm *NetworkControllerManager) CleanupDeletedNetworks(allControllers []nad.NetworkController) error {
        existingNetworksMap := map[string]struct{}{}
        for _, oc := range allControllers {
                existingNetworksMap[oc.GetNetworkName()] = struct{}{}
        }

        // Get all the existing secondary networks and its logical entities
        switches, routers, err := findAllSecondaryNetworkLogicalEntities(cm.nbClient)
        if err != nil {
                return err
        }

        staleNetworkControllers := map[string]nad.NetworkController{}
        for _, ls := range switches {
                netName := ls.ExternalIDs[ovntypes.NetworkExternalID]
                if _, ok := existingNetworksMap[netName]; ok {
                        // network still exists, no cleanup to do
                        continue
                }
                // TopologyExternalID always co-exists with NetworkExternalID
                topoType := ls.ExternalIDs[ovntypes.TopologyExternalID]
                // Create dummy network controllers to clean up logical entities
                klog.V(5).Infof("Found stale %s network %s", topoType, netName)
                if oc, err := cm.newDummyNetworkController(topoType, netName); err == nil {
                        staleNetworkControllers[netName] = oc
                        continue
                }
        }
        for _, lr := range routers {
                netName := lr.ExternalIDs[ovntypes.NetworkExternalID]
                if _, ok := existingNetworksMap[netName]; ok {
                        // network still exists, no cleanup to do
                        continue
                }
                // TopologyExternalID always co-exists with NetworkExternalID
                topoType := lr.ExternalIDs[ovntypes.TopologyExternalID]
                // Create dummy network controllers to clean up logical entities
                klog.V(5).Infof("Found stale %s network %s", topoType, netName)
                if oc, err := cm.newDummyNetworkController(topoType, netName); err == nil {
                        staleNetworkControllers[netName] = oc
                        continue
                }
        }

        for netName, oc := range staleNetworkControllers {
                klog.Infof("Cleanup entities for stale network %s", netName)
                err = oc.Cleanup(netName)
                if err != nil {
                        klog.Errorf("Failed to delete stale OVN logical entities for network %s: %v", netName, err)
                }
        }
        return nil
}

// NewNetworkControllerManager creates a new ovnkube controller manager to manage all the controller for all networks
func NewNetworkControllerManager(ovnClient *util.OVNClientset, wf *factory.WatchFactory,
        libovsdbOvnNBClient libovsdbclient.Client, libovsdbOvnSBClient libovsdbclient.Client,
        recorder record.EventRecorder, wg *sync.WaitGroup) (*NetworkControllerManager, error) {
        podRecorder := metrics.NewPodRecorder()

        cm := &NetworkControllerManager{
                client: ovnClient.KubeClient,
                kube: &kube.KubeOVN{
                        Kube:                 kube.Kube{KClient: ovnClient.KubeClient},
                        ANPClient:            ovnClient.ANPClient,
                        EIPClient:            ovnClient.EgressIPClient,
                        EgressFirewallClient: ovnClient.EgressFirewallClient,
                        CloudNetworkClient:   ovnClient.CloudNetworkClient,
                        EgressServiceClient:  ovnClient.EgressServiceClient,
                        APBRouteClient:       ovnClient.AdminPolicyRouteClient,
                        EgressQoSClient:      ovnClient.EgressQoSClient,
                },
                stopChan:     make(chan struct{}),
                watchFactory: wf,
                recorder:     recorder,
                nbClient:     libovsdbOvnNBClient,
                sbClient:     libovsdbOvnSBClient,
                podRecorder:  &podRecorder,

                wg:               wg,
                multicastSupport: config.EnableMulticast,
        }

        var err error
        if config.OVNKubernetesFeature.EnableMultiNetwork {
                cm.nadController, err = nad.NewNetAttachDefinitionController("network-controller-manager", cm, ovnClient.NetworkAttchDefClient, cm.recorder)
                if err != nil {
                        return nil, err
                }
        }
        return cm, nil
}

func (cm *NetworkControllerManager) configureSCTPSupport() error {
        hasSCTPSupport, err := util.DetectSCTPSupport()
        if err != nil {
                return err
        }

        if !hasSCTPSupport {
                klog.Warningf("SCTP unsupported by this version of OVN. Kubernetes service creation with SCTP will not work ")
        } else {
                klog.Info("SCTP support detected in OVN")
        }
        cm.SCTPSupport = hasSCTPSupport
        return nil
}

func (cm *NetworkControllerManager) configureSvcTemplateSupport() {
        if !config.OVNKubernetesFeature.EnableServiceTemplateSupport {
                cm.svcTemplateSupport = false
        } else if _, _, err := util.RunOVNNbctl("--columns=_uuid", "list", "Chassis_Template_Var"); err != nil {
                klog.Warningf("Version of OVN in use does not support Chassis_Template_Var. " +
                        "Disabling Templates Support")
                cm.svcTemplateSupport = false
        } else {
                cm.svcTemplateSupport = true
        }
}

func (cm *NetworkControllerManager) configureMetrics(stopChan <-chan struct{}) {
        metrics.RegisterOVNKubeControllerPerformance(cm.nbClient)
        metrics.RegisterOVNKubeControllerFunctional()
        metrics.RunTimestamp(stopChan, cm.sbClient, cm.nbClient)
        metrics.MonitorIPSec(cm.nbClient)
}

func (cm *NetworkControllerManager) createACLLoggingMeter() error {
        band := &nbdb.MeterBand{
                Action: ovntypes.MeterAction,
                Rate:   config.Logging.ACLLoggingRateLimit,
        }
        ops, err := libovsdbops.CreateMeterBandOps(cm.nbClient, nil, band)
        if err != nil {
                return fmt.Errorf("can't create meter band %v: %v", band, err)
        }

        meterFairness := true
        meter := &nbdb.Meter{
                Name: ovntypes.OvnACLLoggingMeter,
                Fair: &meterFairness,
                Unit: ovntypes.PacketsPerSecond,
        }
        ops, err = libovsdbops.CreateOrUpdateMeterOps(cm.nbClient, ops, meter, []*nbdb.MeterBand{band},
                &meter.Bands, &meter.Fair, &meter.Unit)
        if err != nil {
                return fmt.Errorf("can't create meter %v: %v", meter, err)
        }

        _, err = libovsdbops.TransactAndCheck(cm.nbClient, ops)
        if err != nil {
                return fmt.Errorf("can't transact ACL logging meter: %v", err)
        }

        return nil
}

// newCommonNetworkControllerInfo creates and returns the common networkController info
func (cm *NetworkControllerManager) newCommonNetworkControllerInfo() (*ovn.CommonNetworkControllerInfo, error) {
        return ovn.NewCommonNetworkControllerInfo(cm.client, cm.kube, cm.watchFactory, cm.recorder, cm.nbClient,
                cm.sbClient, cm.podRecorder, cm.SCTPSupport, cm.multicastSupport, cm.svcTemplateSupport)
}

// initDefaultNetworkController creates the controller for default network
func (cm *NetworkControllerManager) initDefaultNetworkController() error {
        cnci, err := cm.newCommonNetworkControllerInfo()
        if err != nil {
                return fmt.Errorf("failed to create common network controller info: %w", err)
        }
        defaultController, err := ovn.NewDefaultNetworkController(cnci)
        if err != nil {
                return err
        }
        // Make sure we only set defaultNetworkController in case of no error,
        // otherwise we would initialize the interface with a nil implementation
        // which is not the same as nil interface.
        cm.defaultNetworkController = defaultController
        return nil
}

// Start the ovnkube controller
func (cm *NetworkControllerManager) Start(ctx context.Context) error {
        klog.Info("Starting the ovnkube controller")

        // Make sure that the ovnkube-controller zone matches with the Northbound db zone.
        // Wait for 300s before giving up
        maxTimeout := 300 * time.Second
        klog.Infof("Waiting up to %s for NBDB zone to match: %s", maxTimeout, config.Default.Zone)
        start := time.Now()
        var zone string
        var err1 error
        err := wait.PollUntilContextTimeout(ctx, 250*time.Millisecond, maxTimeout, true, func(ctx context.Context) (bool, error) {
                zone, err1 = libovsdbutil.GetNBZone(cm.nbClient)
                if err1 != nil {
                        return false, nil
                }
                if config.Default.Zone != zone {
                        err1 = fmt.Errorf("config zone %s different from NBDB zone %s", config.Default.Zone, zone)
                        return false, nil
                }
                return true, nil
        })

        if err != nil {
                return fmt.Errorf("failed to start default ovnkube-controller - OVN NBDB zone %s does not match the configured zone %q: errors: %v, %v",
                        zone, config.Default.Zone, err, err1)
        }
        klog.Infof("NBDB zone sync took: %s", time.Since(start))

        err = cm.watchFactory.Start()
        if err != nil {
                return err
        }

        // Wait for one node to have the zone we want to manage, otherwise there is no point in configuring NBDB.
        // Really this covers a use case where a node is going from local -> remote, but has not yet annotated itself.
        // In this case ovnkube-controller on this remote node will treat the node as remote, and then once the annotation
        // appears will convert it to local, which may or may not clean up DB resources correctly.
        klog.Infof("Waiting up to %s for a node to have %q zone", maxTimeout, config.Default.Zone)
        start = time.Now()
        err = wait.PollUntilContextTimeout(ctx, 250*time.Millisecond, maxTimeout, true, func(ctx context.Context) (bool, error) {
                nodes, err := cm.watchFactory.GetNodes()
                if err != nil {
                        klog.Errorf("Unable to get nodes from informer while waiting for node zone sync")
                        return false, nil
                }
                if len(nodes) == 0 {
                        klog.Infof("No nodes in cluster: waiting for a node to have %q zone is not needed", config.Default.Zone)
                        return true, nil
                }
                for _, node := range nodes {
                        if util.GetNodeZone(node) == config.Default.Zone {
                                return true, nil
                        }
                }
                return false, nil
        })
        if err != nil {
                return fmt.Errorf("failed to start default network controller - while waiting for any node to have zone: %q, error: %v",
                        config.Default.Zone, err)
        }
        klog.Infof("Waiting for node in zone sync took: %s", time.Since(start))

        cm.configureMetrics(cm.stopChan)

        err = cm.configureSCTPSupport()
        if err != nil {
                return err
        }

        cm.configureSvcTemplateSupport()

        err = cm.createACLLoggingMeter()
        if err != nil {
                return nil
        }

        if config.Metrics.EnableConfigDuration {
                // with k=10,
                //  for a cluster with 10 nodes, measurement of 1 in every 100 requests
                //  for a cluster with 100 nodes, measurement of 1 in every 1000 requests
                metrics.GetConfigDurationRecorder().Run(cm.nbClient, cm.kube, 10, time.Second*5, cm.stopChan)
        }
        cm.podRecorder.Run(cm.sbClient, cm.stopChan)

        err = cm.initDefaultNetworkController()
        if err != nil {
                return fmt.Errorf("failed to init default network controller: %v", err)
        }
        err = cm.defaultNetworkController.Start(ctx)
        if err != nil {
                return fmt.Errorf("failed to start default network controller: %v", err)
        }

        // nadController is nil if multi-network is disabled
        if cm.nadController != nil {
                return cm.nadController.Start()
        }

        return nil
}

// Stop gracefully stops all managed controllers
func (cm *NetworkControllerManager) Stop() {
        // stop metric recorders
        close(cm.stopChan)

        // stop the default network controller
        if cm.defaultNetworkController != nil {
                cm.defaultNetworkController.Stop()
        }

        // stop the NAD controller
        if cm.nadController != nil {
                cm.nadController.Stop()
        }
}

1	package networkControllerManager
2
3	import (
4	"context"
5	"fmt"
6	"sync"
7	"time"
8
9	"github.com/containernetworking/cni/pkg/types"
10	libovsdbclient "github.com/ovn-org/libovsdb/client"
11	ovncnitypes "github.com/ovn-org/ovn-kubernetes/go-controller/pkg/cni/types"
12	"github.com/ovn-org/ovn-kubernetes/go-controller/pkg/config"
13	"github.com/ovn-org/ovn-kubernetes/go-controller/pkg/factory"
14	"github.com/ovn-org/ovn-kubernetes/go-controller/pkg/kube"
15	libovsdbops "github.com/ovn-org/ovn-kubernetes/go-controller/pkg/libovsdb/ops"
16	libovsdbutil "github.com/ovn-org/ovn-kubernetes/go-controller/pkg/libovsdb/util"
17	"github.com/ovn-org/ovn-kubernetes/go-controller/pkg/metrics"
18	"github.com/ovn-org/ovn-kubernetes/go-controller/pkg/nbdb"
19	nad "github.com/ovn-org/ovn-kubernetes/go-controller/pkg/network-attach-def-controller"
20	"github.com/ovn-org/ovn-kubernetes/go-controller/pkg/ovn"
21	ovntypes "github.com/ovn-org/ovn-kubernetes/go-controller/pkg/types"
22	"github.com/ovn-org/ovn-kubernetes/go-controller/pkg/util"
23
24	"k8s.io/apimachinery/pkg/util/wait"
25	clientset "k8s.io/client-go/kubernetes"
26	"k8s.io/client-go/tools/record"
27	"k8s.io/klog/v2"
28	)
29
30	// NetworkControllerManager structure is the object manages all controllers for all networks
31	type NetworkControllerManager struct {
32	client clientset.Interface
33	kube *kube.KubeOVN
34	watchFactory *factory.WatchFactory
35	podRecorder *metrics.PodRecorder
36	// event recorder used to post events to k8s
37	recorder record.EventRecorder
38	// libovsdb northbound client interface
39	nbClient libovsdbclient.Client
40	// libovsdb southbound client interface
41	sbClient libovsdbclient.Client
42	// has SCTP support
43	SCTPSupport bool
44	// Supports multicast?
45	multicastSupport bool
46	// Supports OVN Template Load Balancers?
47	svcTemplateSupport bool
48
49	stopChan chan struct{}
50	wg *sync.WaitGroup
51
52	defaultNetworkController nad.BaseNetworkController
53
54	// net-attach-def controller handle net-attach-def and create/delete network controllers
55	nadController *nad.NetAttachDefinitionController
56	}
57
58	func (cm *NetworkControllerManager) NewNetworkController(nInfo util.NetInfo) (nad.NetworkController, error) {	×
59	cnci, err := cm.newCommonNetworkControllerInfo()	×
60	if err != nil {	×
61	return nil, fmt.Errorf("failed to create network controller info %w", err)	×
62	}	×
63	topoType := nInfo.TopologyType()	×
64	switch topoType {	×
65	case ovntypes.Layer3Topology:	×
66	return ovn.NewSecondaryLayer3NetworkController(cnci, nInfo), nil	×
67	case ovntypes.Layer2Topology:	×
68	return ovn.NewSecondaryLayer2NetworkController(cnci, nInfo), nil	×
69	case ovntypes.LocalnetTopology:	×
70	return ovn.NewSecondaryLocalnetNetworkController(cnci, nInfo), nil	×
71	}
72	return nil, fmt.Errorf("topology type %s not supported", topoType)	×
73	}
74
75	// newDummyNetworkController creates a dummy network controller used to clean up specific network
76	func (cm *NetworkControllerManager) newDummyNetworkController(topoType, netName string) (nad.NetworkController, error) {	×
77	cnci, err := cm.newCommonNetworkControllerInfo()	×
78	if err != nil {	×
79	return nil, fmt.Errorf("failed to create network controller info %w", err)	×
80	}	×
81	netInfo, _ := util.NewNetInfo(&ovncnitypes.NetConf{NetConf: types.NetConf{Name: netName}, Topology: topoType})	×
82	switch topoType {	×
83	case ovntypes.Layer3Topology:	×
84	return ovn.NewSecondaryLayer3NetworkController(cnci, netInfo), nil	×
85	case ovntypes.Layer2Topology:	×
86	return ovn.NewSecondaryLayer2NetworkController(cnci, netInfo), nil	×
87	case ovntypes.LocalnetTopology:	×
88	return ovn.NewSecondaryLocalnetNetworkController(cnci, netInfo), nil	×
89	}
90	return nil, fmt.Errorf("topology type %s not supported", topoType)	×
91	}
92
93	// Find all the OVN logical switches/routers for the secondary networks
94	func findAllSecondaryNetworkLogicalEntities(nbClient libovsdbclient.Client) ([]*nbdb.LogicalSwitch,
95	[]*nbdb.LogicalRouter, error) {	×
96	p1 := func(item *nbdb.LogicalSwitch) bool {	×
97	_, ok := item.ExternalIDs[ovntypes.NetworkExternalID]	×
98	return ok	×
99	}	×
100	nodeSwitches, err := libovsdbops.FindLogicalSwitchesWithPredicate(nbClient, p1)	×
101	if err != nil {	×
102	klog.Errorf("Failed to get all logical switches of secondary network error: %v", err)	×
103	return nil, nil, err	×
104	}	×
105	p2 := func(item *nbdb.LogicalRouter) bool {	×
106	_, ok := item.ExternalIDs[ovntypes.NetworkExternalID]	×
107	return ok	×
108	}	×
109	clusterRouters, err := libovsdbops.FindLogicalRoutersWithPredicate(nbClient, p2)	×
110	if err != nil {	×
111	klog.Errorf("Failed to get all distributed logical routers: %v", err)	×
112	return nil, nil, err	×
113	}	×
114	return nodeSwitches, clusterRouters, nil	×
115	}
116
117	func (cm *NetworkControllerManager) CleanupDeletedNetworks(allControllers []nad.NetworkController) error {	×
118	existingNetworksMap := map[string]struct{}{}	×
119	for _, oc := range allControllers {	×
120	existingNetworksMap[oc.GetNetworkName()] = struct{}{}	×
121	}	×
122
123	// Get all the existing secondary networks and its logical entities
124	switches, routers, err := findAllSecondaryNetworkLogicalEntities(cm.nbClient)	×
125	if err != nil {	×
126	return err	×
127	}	×
128
129	staleNetworkControllers := map[string]nad.NetworkController{}	×
130	for _, ls := range switches {	×
131	netName := ls.ExternalIDs[ovntypes.NetworkExternalID]	×
132	if _, ok := existingNetworksMap[netName]; ok {	×
133	// network still exists, no cleanup to do	×
134	continue	×
135	}
136	// TopologyExternalID always co-exists with NetworkExternalID
137	topoType := ls.ExternalIDs[ovntypes.TopologyExternalID]	×
138	// Create dummy network controllers to clean up logical entities	×
139	klog.V(5).Infof("Found stale %s network %s", topoType, netName)	×
140	if oc, err := cm.newDummyNetworkController(topoType, netName); err == nil {	×
141	staleNetworkControllers[netName] = oc	×
142	continue	×
143	}
144	}
145	for _, lr := range routers {	×
146	netName := lr.ExternalIDs[ovntypes.NetworkExternalID]	×
147	if _, ok := existingNetworksMap[netName]; ok {	×
148	// network still exists, no cleanup to do	×
149	continue	×
150	}
151	// TopologyExternalID always co-exists with NetworkExternalID
152	topoType := lr.ExternalIDs[ovntypes.TopologyExternalID]	×
153	// Create dummy network controllers to clean up logical entities	×
154	klog.V(5).Infof("Found stale %s network %s", topoType, netName)	×
155	if oc, err := cm.newDummyNetworkController(topoType, netName); err == nil {	×
156	staleNetworkControllers[netName] = oc	×
157	continue	×
158	}
159	}
160
161	for netName, oc := range staleNetworkControllers {	×
162	klog.Infof("Cleanup entities for stale network %s", netName)	×
163	err = oc.Cleanup(netName)	×
164	if err != nil {	×
165	klog.Errorf("Failed to delete stale OVN logical entities for network %s: %v", netName, err)	×
166	}	×
167	}
168	return nil	×
169	}
170
171	// NewNetworkControllerManager creates a new ovnkube controller manager to manage all the controller for all networks
172	func NewNetworkControllerManager(ovnClient util.OVNClientset, wf factory.WatchFactory,
173	libovsdbOvnNBClient libovsdbclient.Client, libovsdbOvnSBClient libovsdbclient.Client,
174	recorder record.EventRecorder, wg sync.WaitGroup) (NetworkControllerManager, error) {	×
175	podRecorder := metrics.NewPodRecorder()	×
176		×
177	cm := &NetworkControllerManager{	×
178	client: ovnClient.KubeClient,	×
179	kube: &kube.KubeOVN{	×
180	Kube: kube.Kube{KClient: ovnClient.KubeClient},	×
181	ANPClient: ovnClient.ANPClient,	×
182	EIPClient: ovnClient.EgressIPClient,	×
183	EgressFirewallClient: ovnClient.EgressFirewallClient,	×
184	CloudNetworkClient: ovnClient.CloudNetworkClient,	×
185	EgressServiceClient: ovnClient.EgressServiceClient,	×
186	APBRouteClient: ovnClient.AdminPolicyRouteClient,	×
187	EgressQoSClient: ovnClient.EgressQoSClient,	×
188	},	×
189	stopChan: make(chan struct{}),	×
190	watchFactory: wf,	×
191	recorder: recorder,	×
192	nbClient: libovsdbOvnNBClient,	×
193	sbClient: libovsdbOvnSBClient,	×
194	podRecorder: &podRecorder,	×
195		×
196	wg: wg,	×
197	multicastSupport: config.EnableMulticast,	×
198	}	×
199		×
200	var err error	×
201	if config.OVNKubernetesFeature.EnableMultiNetwork {	×
202	cm.nadController, err = nad.NewNetAttachDefinitionController("network-controller-manager", cm, ovnClient.NetworkAttchDefClient, cm.recorder)	×
203	if err != nil {	×
204	return nil, err	×
205	}	×
206	}
207	return cm, nil	×
208	}
209
210	func (cm *NetworkControllerManager) configureSCTPSupport() error {	×
211	hasSCTPSupport, err := util.DetectSCTPSupport()	×
212	if err != nil {	×
213	return err	×
214	}	×
215
216	if !hasSCTPSupport {	×
217	klog.Warningf("SCTP unsupported by this version of OVN. Kubernetes service creation with SCTP will not work ")	×
218	} else {	×
219	klog.Info("SCTP support detected in OVN")	×
220	}	×
221	cm.SCTPSupport = hasSCTPSupport	×
222	return nil	×
223	}
224
225	func (cm *NetworkControllerManager) configureSvcTemplateSupport() {	×
NEW 226	if !config.OVNKubernetesFeature.EnableServiceTemplateSupport {	×
NEW 227	cm.svcTemplateSupport = false	×
NEW 228	} else if _, _, err := util.RunOVNNbctl("--columns=_uuid", "list", "Chassis_Template_Var"); err != nil {	×
229	klog.Warningf("Version of OVN in use does not support Chassis_Template_Var. " +	×
230	"Disabling Templates Support")	×
231	cm.svcTemplateSupport = false	×
232	} else {	×
233	cm.svcTemplateSupport = true	×
234	}	×
235	}
236
237	func (cm *NetworkControllerManager) configureMetrics(stopChan <-chan struct{}) {	×
238	metrics.RegisterOVNKubeControllerPerformance(cm.nbClient)	×
239	metrics.RegisterOVNKubeControllerFunctional()	×
240	metrics.RunTimestamp(stopChan, cm.sbClient, cm.nbClient)	×
241	metrics.MonitorIPSec(cm.nbClient)	×
242	}	×
243
244	func (cm *NetworkControllerManager) createACLLoggingMeter() error {	×
245	band := &nbdb.MeterBand{	×
246	Action: ovntypes.MeterAction,	×
247	Rate: config.Logging.ACLLoggingRateLimit,	×
248	}	×
249	ops, err := libovsdbops.CreateMeterBandOps(cm.nbClient, nil, band)	×
250	if err != nil {	×
251	return fmt.Errorf("can't create meter band %v: %v", band, err)	×
252	}	×
253
254	meterFairness := true	×
255	meter := &nbdb.Meter{	×
256	Name: ovntypes.OvnACLLoggingMeter,	×
257	Fair: &meterFairness,	×
258	Unit: ovntypes.PacketsPerSecond,	×
259	}	×
260	ops, err = libovsdbops.CreateOrUpdateMeterOps(cm.nbClient, ops, meter, []*nbdb.MeterBand{band},	×
261	&meter.Bands, &meter.Fair, &meter.Unit)	×
262	if err != nil {	×
263	return fmt.Errorf("can't create meter %v: %v", meter, err)	×
264	}	×
265
266	_, err = libovsdbops.TransactAndCheck(cm.nbClient, ops)	×
267	if err != nil {	×
268	return fmt.Errorf("can't transact ACL logging meter: %v", err)	×
269	}	×
270
271	return nil	×
272	}
273
274	// newCommonNetworkControllerInfo creates and returns the common networkController info
275	func (cm NetworkControllerManager) newCommonNetworkControllerInfo() (ovn.CommonNetworkControllerInfo, error) {	×
276	return ovn.NewCommonNetworkControllerInfo(cm.client, cm.kube, cm.watchFactory, cm.recorder, cm.nbClient,	×
277	cm.sbClient, cm.podRecorder, cm.SCTPSupport, cm.multicastSupport, cm.svcTemplateSupport)	×
278	}	×
279
280	// initDefaultNetworkController creates the controller for default network
281	func (cm *NetworkControllerManager) initDefaultNetworkController() error {	×
282	cnci, err := cm.newCommonNetworkControllerInfo()	×
283	if err != nil {	×
284	return fmt.Errorf("failed to create common network controller info: %w", err)	×
285	}	×
286	defaultController, err := ovn.NewDefaultNetworkController(cnci)	×
287	if err != nil {	×
288	return err	×
289	}	×
290	// Make sure we only set defaultNetworkController in case of no error,
291	// otherwise we would initialize the interface with a nil implementation
292	// which is not the same as nil interface.
293	cm.defaultNetworkController = defaultController	×
294	return nil	×
295	}
296
297	// Start the ovnkube controller
298	func (cm *NetworkControllerManager) Start(ctx context.Context) error {	×
299	klog.Info("Starting the ovnkube controller")	×
300		×
301	// Make sure that the ovnkube-controller zone matches with the Northbound db zone.	×
302	// Wait for 300s before giving up	×
303	maxTimeout := 300 * time.Second	×
304	klog.Infof("Waiting up to %s for NBDB zone to match: %s", maxTimeout, config.Default.Zone)	×
305	start := time.Now()	×
306	var zone string	×
307	var err1 error	×
308	err := wait.PollUntilContextTimeout(ctx, 250*time.Millisecond, maxTimeout, true, func(ctx context.Context) (bool, error) {	×
309	zone, err1 = libovsdbutil.GetNBZone(cm.nbClient)	×
310	if err1 != nil {	×
311	return false, nil	×
312	}	×
313	if config.Default.Zone != zone {	×
314	err1 = fmt.Errorf("config zone %s different from NBDB zone %s", config.Default.Zone, zone)	×
315	return false, nil	×
316	}	×
317	return true, nil	×
318	})
319
320	if err != nil {	×
321	return fmt.Errorf("failed to start default ovnkube-controller - OVN NBDB zone %s does not match the configured zone %q: errors: %v, %v",	×
322	zone, config.Default.Zone, err, err1)	×
323	}	×
324	klog.Infof("NBDB zone sync took: %s", time.Since(start))	×
325		×
326	err = cm.watchFactory.Start()	×
327	if err != nil {	×
328	return err	×
329	}	×
330
331	// Wait for one node to have the zone we want to manage, otherwise there is no point in configuring NBDB.
332	// Really this covers a use case where a node is going from local -> remote, but has not yet annotated itself.
333	// In this case ovnkube-controller on this remote node will treat the node as remote, and then once the annotation
334	// appears will convert it to local, which may or may not clean up DB resources correctly.
335	klog.Infof("Waiting up to %s for a node to have %q zone", maxTimeout, config.Default.Zone)	×
336	start = time.Now()	×
337	err = wait.PollUntilContextTimeout(ctx, 250*time.Millisecond, maxTimeout, true, func(ctx context.Context) (bool, error) {	×
338	nodes, err := cm.watchFactory.GetNodes()	×
339	if err != nil {	×
340	klog.Errorf("Unable to get nodes from informer while waiting for node zone sync")	×
341	return false, nil	×
342	}	×
343	if len(nodes) == 0 {	×
344	klog.Infof("No nodes in cluster: waiting for a node to have %q zone is not needed", config.Default.Zone)	×
345	return true, nil	×
346	}	×
347	for _, node := range nodes {	×
348	if util.GetNodeZone(node) == config.Default.Zone {	×
349	return true, nil	×
350	}	×
351	}
352	return false, nil	×
353	})
354	if err != nil {	×
355	return fmt.Errorf("failed to start default network controller - while waiting for any node to have zone: %q, error: %v",	×
356	config.Default.Zone, err)	×
357	}	×
358	klog.Infof("Waiting for node in zone sync took: %s", time.Since(start))	×
359		×
360	cm.configureMetrics(cm.stopChan)	×
361		×
362	err = cm.configureSCTPSupport()	×
363	if err != nil {	×
364	return err	×
365	}	×
366
367	cm.configureSvcTemplateSupport()	×
368		×
369	err = cm.createACLLoggingMeter()	×
370	if err != nil {	×
371	return nil	×
372	}	×
373
374	if config.Metrics.EnableConfigDuration {	×
375	// with k=10,	×
376	// for a cluster with 10 nodes, measurement of 1 in every 100 requests	×
377	// for a cluster with 100 nodes, measurement of 1 in every 1000 requests	×
378	metrics.GetConfigDurationRecorder().Run(cm.nbClient, cm.kube, 10, time.Second*5, cm.stopChan)	×
379	}	×
380	cm.podRecorder.Run(cm.sbClient, cm.stopChan)	×
381		×
382	err = cm.initDefaultNetworkController()	×
383	if err != nil {	×
384	return fmt.Errorf("failed to init default network controller: %v", err)	×
385	}	×
386	err = cm.defaultNetworkController.Start(ctx)	×
387	if err != nil {	×
388	return fmt.Errorf("failed to start default network controller: %v", err)	×
389	}	×
390
391	// nadController is nil if multi-network is disabled
392	if cm.nadController != nil {	×
393	return cm.nadController.Start()	×
394	}	×
395
396	return nil	×
397	}
398
399	// Stop gracefully stops all managed controllers
400	func (cm *NetworkControllerManager) Stop() {	×
401	// stop metric recorders	×
402	close(cm.stopChan)	×
403		×
404	// stop the default network controller	×
405	if cm.defaultNetworkController != nil {	×
406	cm.defaultNetworkController.Stop()	×
407	}	×
408
409	// stop the NAD controller
410	if cm.nadController != nil {	×
411	cm.nadController.Stop()	×
412	}	×
413	}

ovn-org / ovn-kubernetes / 8758605927

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