[Multicast] Use group as flow actions for multicast traffic

Add local pod receivers into an OpenFlow "all" type group for each
multicast group, and use that group in the flow action. Remove the pod
from group buckets if the pod has left the multicast group or is
deleted.

Signed-off-by: wenyingd <wenyingd@vmware.com>

cmd/antrea-agent/agent.go

@@ -573,6 +573,7 @@ func run(o *Options) error {
 		}
 		mcastController := multicast.NewMulticastController(
 			ofClient,
+			v4GroupIDAllocator,
 			nodeConfig,
 			ifaceStore,
 			multicastSocket,

pkg/agent/cniserver/pod_configuration.go

@@ -303,6 +303,7 @@ func (pc *podConfigurator) removeInterfaces(containerID string) error {
 	if err := pc.routeClient.DeleteLocalAntreaFlexibleIPAMPodRule(containerConfig.IPs); err != nil {
 		return err
 	}
+
 	return nil
 }
 

pkg/agent/interfacestore/interface_cache.go

@@ -64,7 +64,8 @@ const (
 // Todo: add periodic task to sync local cache with container veth pair
 
 type interfaceCache struct {
-	cache cache.Indexer
+	cache                        cache.Indexer
+	podInterfaceDeletionHandlers []chan *InterfaceConfig
 }
 
 func (c *interfaceCache) Initialize(interfaces []*InterfaceConfig) {
@@ -107,6 +108,9 @@ func (c *interfaceCache) DeleteInterface(interfaceConfig *InterfaceConfig) {
 	c.cache.Delete(interfaceConfig)
 
 	if interfaceConfig.Type == ContainerInterface {
+		for _, h := range c.podInterfaceDeletionHandlers {
+			h <- interfaceConfig
+		}
 		metrics.PodCount.Dec()
 	}
 }
@@ -208,6 +212,10 @@ func (c *interfaceCache) GetInterfaceByOFPort(ofPort uint32) (*InterfaceConfig,
 	return interfaceConfigs[0].(*InterfaceConfig), true
 }
 
+func (c *interfaceCache) RegisterInterfaceDeletionHandler(handler chan *InterfaceConfig) {
+	c.podInterfaceDeletionHandlers = append(c.podInterfaceDeletionHandlers, handler)
+}
+
 func interfaceNameIndexFunc(obj interface{}) ([]string, error) {
 	interfaceConfig := obj.(*InterfaceConfig)
 	return []string{interfaceConfig.InterfaceName}, nil

pkg/agent/interfacestore/types.go

@@ -103,6 +103,7 @@ type InterfaceStore interface {
 	GetInterfacesByType(interfaceType InterfaceType) []*InterfaceConfig
 	Len() int
 	GetInterfaceKeysByType(interfaceType InterfaceType) []string
+	RegisterInterfaceDeletionHandler(handler chan *InterfaceConfig)
 }
 
 // NewContainerInterface creates InterfaceConfig for a Pod.

pkg/agent/multicast/mcast_controller.go

@@ -28,6 +28,7 @@ import (
 	"antrea.io/antrea/pkg/agent/config"
 	"antrea.io/antrea/pkg/agent/interfacestore"
 	"antrea.io/antrea/pkg/agent/openflow"
+	binding "antrea.io/antrea/pkg/ovs/openflow"
 	"antrea.io/antrea/pkg/ovs/ovsconfig"
 )
 
@@ -60,9 +61,10 @@ type mcastGroupEvent struct {
 type GroupMemberStatus struct {
 	group net.IP
 	// localMembers is a set for the local Pod's interface name which has joined in the multicast group.
-	localMembers   sets.String
+	localMembers   map[string]time.Time
 	lastIGMPReport time.Time
 	mutex          sync.RWMutex
+	ofGroupID      binding.GroupIDType
 }
 
 // eventHandler process the multicast Group membership report or leave messages.
@@ -82,7 +84,8 @@ func (c *Controller) addGroupMemberStatus(e *mcastGroupEvent) {
 	status := &GroupMemberStatus{
 		group:          e.group,
 		lastIGMPReport: e.time,
-		localMembers:   sets.NewString(e.iface.InterfaceName),
+		localMembers:   map[string]time.Time{e.iface.InterfaceName: e.time},
+		ofGroupID:      c.v4GroupAllocator.Allocate(),
 	}
 	c.groupCache.Add(status)
 	c.queue.Add(e.group.String())
@@ -101,25 +104,32 @@ func (c *Controller) updateGroupMemberStatus(obj interface{}, e *mcastGroupEvent
 	defer status.mutex.Unlock()
 	newStatus := &GroupMemberStatus{
 		group:          status.group,
-		localMembers:   status.localMembers.Union(nil),
+		localMembers:   status.localMembers,
 		lastIGMPReport: status.lastIGMPReport,
+		ofGroupID:      status.ofGroupID,
 	}
-	exist := status.localMembers.Has(e.iface.InterfaceName)
+	_, exist := status.localMembers[e.iface.InterfaceName]
 	switch e.eType {
 	case groupJoin:
 		newStatus.lastIGMPReport = e.time
 		if !exist {
-			newStatus.localMembers.Insert(e.iface.InterfaceName)
+			newStatus.localMembers[e.iface.InterfaceName] = e.time
+			c.groupCache.Update(newStatus)
 			klog.InfoS("Added member to multicast group", "group", e.group.String(), "member", e.iface.InterfaceName)
+			c.queue.Add(newStatus.group.String())
+		} else {
+			newStatus.localMembers[e.iface.InterfaceName] = e.time
+			c.groupCache.Update(newStatus)
 		}
-		c.groupCache.Update(newStatus)
-		c.queue.Add(newStatus.group.String())
 	case groupLeave:
 		if exist {
-			newStatus.localMembers.Delete(e.iface.InterfaceName)
+			delete(newStatus.localMembers, e.iface.InterfaceName)
 			c.groupCache.Update(newStatus)
 			klog.InfoS("Deleted member from multicast group", "group", e.group.String(), "member", e.iface.InterfaceName)
-			if len(newStatus.localMembers) == 0 {
+			_, found := c.ifaceStore.GetInterfaceByName(e.iface.InterfaceName)
+			if !found || len(newStatus.localMembers) > 0 {
+				c.queue.Add(newStatus.group.String())
+			} else {
 				klog.InfoS("Check last member in multicast group", "group", e.group.String(), "member", e.iface.InterfaceName)
 				c.checkLastMember(e.group)
 			}
@@ -139,52 +149,84 @@ func (c *Controller) checkLastMember(group net.IP) {
 	c.queue.AddAfter(group.String(), igmpMaxResponseTime)
 }
 
-// clearStaleGroups checks the stale groups which have not been updated for mcastGroupTimeout, and then notifies worker
+// clearStaleGroups checks the stale group members which have not been updated for mcastGroupTimeout, and then notifies worker
 // to remove them from groupCache.
 func (c *Controller) clearStaleGroups() {
 	now := time.Now()
 	for _, obj := range c.groupCache.List() {
 		status := obj.(*GroupMemberStatus)
 		status.mutex.RLock()
-		diff := now.Sub(status.lastIGMPReport)
+		for member, lastUpdate := range status.localMembers {
+			if now.Sub(lastUpdate) > mcastGroupTimeout {
+				ifConfig, _ := c.ifaceStore.GetInterfaceByName(member)
+				event := &mcastGroupEvent{
+					group: status.group,
+					eType: groupLeave,
+					time:  now,
+					iface: ifConfig,
+				}
+				c.groupEventCh <- event
+			}
+		}
 		status.mutex.RUnlock()
-		if diff > mcastGroupTimeout {
-			c.queue.Add(status.group.String())
+	}
+}
+
+// removeLocalInterface searches the GroupMemberStatus which the deleted interface has joined, and then trigger a member
+// leave event so that antrea can remove the corresponding interface from local multicast receivers on OVS. This function
+// should be called if the removed Pod receiver fails to send IGMP leave message before deletion.
+func (c *Controller) removeLocalInterface(ifConfig *interfacestore.InterfaceConfig) {
+	groupStatuses := c.getGroupMemberStatusesByPod(ifConfig.InterfaceName)
+	for _, g := range groupStatuses {
+		event := &mcastGroupEvent{
+			group: g.group,
+			eType: groupLeave,
+			time:  time.Now(),
+			iface: ifConfig,
 		}
+		c.groupEventCh <- event
 	}
 }
 
 type Controller struct {
-	ofClient     openflow.Client
-	nodeConfig   *config.NodeConfig
-	igmpSnooper  *IGMPSnooper
-	groupEventCh chan *mcastGroupEvent
-	groupCache   cache.Indexer
-	queue        workqueue.RateLimitingInterface
+	ofClient         openflow.Client
+	v4GroupAllocator openflow.GroupAllocator
+	ifaceStore       interfacestore.InterfaceStore
+	nodeConfig       *config.NodeConfig
+	igmpSnooper      *IGMPSnooper
+	groupEventCh     chan *mcastGroupEvent
+	groupCache       cache.Indexer
+	queue            workqueue.RateLimitingInterface
 	// installedGroups saves the groups which are configured on both OVS and the host.
 	installedGroups      sets.String
 	installedGroupsMutex sync.RWMutex
 	mRouteClient         *MRouteClient
 	ovsBridgeClient      ovsconfig.OVSBridgeClient
+	podDeletionCh        chan *interfacestore.InterfaceConfig
 }
 
-func NewMulticastController(ofClient openflow.Client, nodeConfig *config.NodeConfig, ifaceStore interfacestore.InterfaceStore, multicastSocket RouteInterface, multicastInterfaces sets.String, ovsBridgeClient ovsconfig.OVSBridgeClient) *Controller {
+func NewMulticastController(ofClient openflow.Client, v4GroupAllocator openflow.GroupAllocator, nodeConfig *config.NodeConfig, ifaceStore interfacestore.InterfaceStore, multicastSocket RouteInterface, multicastInterfaces sets.String, ovsBridgeClient ovsconfig.OVSBridgeClient) *Controller {
 	eventCh := make(chan *mcastGroupEvent, workerCount)
 	groupSnooper := newSnooper(ofClient, ifaceStore, eventCh)
 	groupCache := cache.NewIndexer(getGroupEventKey, cache.Indexers{
 		podInterfaceIndex: podInterfaceIndexFunc,
 	})
 	multicastRouteClient := newRouteClient(nodeConfig, groupCache, multicastSocket, multicastInterfaces)
+	podDeletionCh := make(chan *interfacestore.InterfaceConfig, 10)
+	ifaceStore.RegisterInterfaceDeletionHandler(podDeletionCh)
 	return &Controller{
-		ofClient:        ofClient,
-		nodeConfig:      nodeConfig,
-		igmpSnooper:     groupSnooper,
-		groupEventCh:    eventCh,
-		groupCache:      groupCache,
-		installedGroups: sets.NewString(),
-		queue:           workqueue.NewNamedRateLimitingQueue(workqueue.NewItemExponentialFailureRateLimiter(minRetryDelay, maxRetryDelay), "multicastgroup"),
-		mRouteClient:    multicastRouteClient,
-		ovsBridgeClient: ovsBridgeClient,
+		ofClient:         ofClient,
+		ifaceStore:       ifaceStore,
+		v4GroupAllocator: v4GroupAllocator,
+		nodeConfig:       nodeConfig,
+		igmpSnooper:      groupSnooper,
+		groupEventCh:     eventCh,
+		groupCache:       groupCache,
+		installedGroups:  sets.NewString(),
+		queue:            workqueue.NewNamedRateLimitingQueue(workqueue.NewItemExponentialFailureRateLimiter(minRetryDelay, maxRetryDelay), "multicastgroup"),
+		mRouteClient:     multicastRouteClient,
+		ovsBridgeClient:  ovsBridgeClient,
+		podDeletionCh:    podDeletionCh,
 	}
 }
 
@@ -222,6 +264,7 @@ func (c *Controller) Run(stopCh <-chan struct{}) {
 	// Periodically check the group member status, and remove the groups in which no members exist
 	go wait.NonSlidingUntil(c.clearStaleGroups, queryInterval, stopCh)
 
+	go c.podDeletionHandler(stopCh)
 	go c.eventHandler(stopCh)
 
 	for i := 0; i < int(workerCount); i++ {
@@ -298,15 +341,29 @@ func (c *Controller) syncGroup(groupKey string) error {
 		return nil
 	}
 	status := obj.(*GroupMemberStatus)
+	memberPorts := make([]uint32, 0)
+	status.mutex.Lock()
+	defer status.mutex.Unlock()
+	for memberInterfaceName, _ := range status.localMembers {
+		obj, found := c.ifaceStore.GetInterfaceByName(memberInterfaceName)
+		if !found {
+			klog.InfoS("Failed to find interface from cache", "interface", memberInterfaceName)
+			continue
+		}
+		memberPorts = append(memberPorts, uint32(obj.OFPort))
+	}
 	if c.groupHasInstalled(groupKey) {
-		status.mutex.Lock()
-		defer status.mutex.Unlock()
 		if c.groupIsStale(status) {
 			// Remove the multicast flow entry if no local Pod is in the group.
 			if err := c.ofClient.UninstallMulticastFlow(status.group); err != nil {
 				klog.ErrorS(err, "Failed to uninstall multicast flows", "group", groupKey)
 				return err
 			}
+			// Remove the multicast flow entry if no local Pod is in the group.
+			if err := c.ofClient.UninstallGroup(status.ofGroupID); err != nil {
+				klog.ErrorS(err, "Failed to uninstall multicast group", "group", groupKey)
+				return err
+			}
 			err := c.mRouteClient.deleteInboundMrouteEntryByGroup(status.group)
 			if err != nil {
 				klog.ErrorS(err, "Cannot delete multicast group", "group", groupKey)
@@ -320,10 +377,22 @@ func (c *Controller) syncGroup(groupKey string) error {
 			c.delInstalledGroup(groupKey)
 			c.groupCache.Delete(status)
 			klog.InfoS("Removed multicast group from cache after all members left", "group", groupKey)
+			return nil
+		}
+		// Reinstall OpenFlow group because the local pod receivers have changed.
+		if err := c.ofClient.InstallMulticastGroup(status.ofGroupID, memberPorts); err != nil {
+			return err
 		}
+		klog.V(2).InfoS("Updated OpenFlow group for local receivers for multicast group", "group", groupKey, "ofGroup", status.ofGroupID, "localReceivers", memberPorts)
 		return nil
 	}
-	if err := c.ofClient.InstallMulticastFlow(status.group); err != nil {
+	// Install OpenFlow group for a new multicast group in which local pod receivers have joined.
+	if err := c.ofClient.InstallMulticastGroup(status.ofGroupID, memberPorts); err != nil {
+		return err
+	}
+	klog.V(2).InfoS("Installed OpenFlow group for local receivers for multicast group", "group", groupKey, "ofGroup", status.ofGroupID, "localReceivers", memberPorts)
+	// Install OpenFlow flow to forward packets to local pod receivers which are included in the group.
+	if err := c.ofClient.InstallMulticastFlow(status.group, status.ofGroupID); err != nil {
 		klog.ErrorS(err, "Failed to install multicast flows", "group", status.group)
 		return err
 	}
@@ -377,6 +446,18 @@ func (c *Controller) addOrUpdateGroupEvent(e *mcastGroupEvent) {
 			c.updateGroupMemberStatus(obj, e)
 		}
 	}
+	return
+}
+
+func (c *Controller) podDeletionHandler(stopCh <-chan struct{}) {
+	for {
+		select {
+		case e := <-c.podDeletionCh:
+			c.removeLocalInterface(e)
+		case <-stopCh:
+			return
+		}
+	}
 }
 
 func podInterfaceIndexFunc(obj interface{}) ([]string, error) {