Fixing golang linters for VGC
Change-Id: I386d232c74ab47e24d92c18800dc144120b920da
diff --git a/internal/pkg/application/igmpprofiles.go b/internal/pkg/application/igmpprofiles.go
index b855eb8..a1d999c 100644
--- a/internal/pkg/application/igmpprofiles.go
+++ b/internal/pkg/application/igmpprofiles.go
@@ -11,7 +11,7 @@
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
-*/
+ */
package application
@@ -24,10 +24,10 @@
"strings"
"sync"
- cntlr "voltha-go-controller/internal/pkg/controller"
- "voltha-go-controller/internal/pkg/types"
"voltha-go-controller/database"
+ cntlr "voltha-go-controller/internal/pkg/controller"
"voltha-go-controller/internal/pkg/of"
+ common "voltha-go-controller/internal/pkg/types"
"voltha-go-controller/internal/pkg/util"
"voltha-go-controller/log"
)
@@ -45,30 +45,30 @@
// MCGroupProxy identifies source specific multicast(SSM) config.
type MCGroupProxy struct {
- // Mode represents source list include/exclude
- Mode common.MulticastSrcListMode
- // SourceList represents list of multicast server IP addresses.
- SourceList []net.IP
+ // Mode represents source list include/exclude
+ Mode common.MulticastSrcListMode
+ // SourceList represents list of multicast server IP addresses.
+ SourceList []net.IP
}
// MvlanGroup identifies MC group info
type MvlanGroup struct {
- Name string
- Wildcard bool
- McIPs []string
- IsStatic bool
+ Name string
+ McIPs []string
+ Wildcard bool
+ IsStatic bool
}
// OperInProgress type
type OperInProgress uint8
const (
- // UpdateInProgress constant
- UpdateInProgress OperInProgress = 2
- // NoOp constant
- NoOp OperInProgress = 1
- // Nil constant
- Nil OperInProgress = 0
+ // UpdateInProgress constant
+ UpdateInProgress OperInProgress = 2
+ // NoOp constant
+ NoOp OperInProgress = 1
+ // Nil constant
+ Nil OperInProgress = 0
)
// MvlanProfile : A set of groups of MC IPs for a MVLAN profile. It is assumed that
@@ -76,1155 +76,1134 @@
// MVLAN profiles. The first match is used up on search to lcoate the
// MVLAN profile for an MC IP
type MvlanProfile struct {
- Name string
- Mvlan of.VlanType
- PonVlan of.VlanType
- Groups map[string]*MvlanGroup
- Proxy map[string]*MCGroupProxy
- Version string
- IsPonVlanPresent bool
- IsChannelBasedGroup bool
- DevicesList map[string]OperInProgress //device serial number //here
- oldGroups map[string]*MvlanGroup
- oldProxy map[string]*MCGroupProxy
- MaxActiveChannels uint32
- PendingDeleteFlow map[string]map[string]bool
- DeleteInProgress bool
- IgmpServVersion map[string]*uint8
- mvpLock sync.RWMutex
- mvpFlowLock sync.RWMutex
+ Groups map[string]*MvlanGroup
+ Proxy map[string]*MCGroupProxy
+ oldGroups map[string]*MvlanGroup
+ oldProxy map[string]*MCGroupProxy
+ IgmpServVersion map[string]*uint8
+ PendingDeleteFlow map[string]map[string]bool
+ DevicesList map[string]OperInProgress //device serial number //here
+ Version string
+ Name string
+ mvpLock sync.RWMutex
+ mvpFlowLock sync.RWMutex
+ MaxActiveChannels uint32
+ Mvlan of.VlanType
+ PonVlan of.VlanType
+ IsPonVlanPresent bool
+ IsChannelBasedGroup bool
+ DeleteInProgress bool
}
// NewMvlanProfile is constructor for MVLAN profile.
func NewMvlanProfile(name string, mvlan of.VlanType, ponVlan of.VlanType, isChannelBasedGroup bool, OLTSerialNums []string, actChannelPerPon uint32) *MvlanProfile {
- var mvp MvlanProfile
- mvp.Name = name
- mvp.Mvlan = mvlan
- mvp.PonVlan = ponVlan
- mvp.mvpLock = sync.RWMutex{}
- mvp.Groups = make(map[string]*MvlanGroup)
- mvp.Proxy = make(map[string]*MCGroupProxy)
- mvp.DevicesList = make(map[string]OperInProgress)
- mvp.PendingDeleteFlow = make(map[string]map[string]bool)
- mvp.IsChannelBasedGroup = isChannelBasedGroup
- mvp.MaxActiveChannels = actChannelPerPon
- mvp.DeleteInProgress = false
- mvp.IgmpServVersion = make(map[string]*uint8)
+ var mvp MvlanProfile
+ mvp.Name = name
+ mvp.Mvlan = mvlan
+ mvp.PonVlan = ponVlan
+ mvp.mvpLock = sync.RWMutex{}
+ mvp.Groups = make(map[string]*MvlanGroup)
+ mvp.Proxy = make(map[string]*MCGroupProxy)
+ mvp.DevicesList = make(map[string]OperInProgress)
+ mvp.PendingDeleteFlow = make(map[string]map[string]bool)
+ mvp.IsChannelBasedGroup = isChannelBasedGroup
+ mvp.MaxActiveChannels = actChannelPerPon
+ mvp.DeleteInProgress = false
+ mvp.IgmpServVersion = make(map[string]*uint8)
- if (ponVlan != of.VlanNone) && (ponVlan != 0) {
- mvp.IsPonVlanPresent = true
- }
- return &mvp
+ if (ponVlan != of.VlanNone) && (ponVlan != 0) {
+ mvp.IsPonVlanPresent = true
+ }
+ return &mvp
}
// AddMvlanProxy for addition of groups to an MVLAN profile
func (mvp *MvlanProfile) AddMvlanProxy(name string, proxyInfo common.MulticastGroupProxy) {
- proxy := &MCGroupProxy{}
- proxy.Mode = proxyInfo.Mode
- proxy.SourceList = util.GetExpIPList(proxyInfo.SourceList)
+ proxy := &MCGroupProxy{}
+ proxy.Mode = proxyInfo.Mode
+ proxy.SourceList = util.GetExpIPList(proxyInfo.SourceList)
- if _, ok := mvp.Proxy[name]; !ok {
- logger.Debugw(ctx, "Added MVLAN Proxy", log.Fields{"Name": name, "Proxy": proxy})
- } else {
- logger.Debugw(ctx, "Updated MVLAN Proxy", log.Fields{"Name": name, "Proxy": proxy})
- }
- if proxyInfo.IsStatic == common.IsStaticYes {
- mvp.Groups[name].IsStatic = true
- }
- mvp.Proxy[name] = proxy
+ if _, ok := mvp.Proxy[name]; !ok {
+ logger.Debugw(ctx, "Added MVLAN Proxy", log.Fields{"Name": name, "Proxy": proxy})
+ } else {
+ logger.Debugw(ctx, "Updated MVLAN Proxy", log.Fields{"Name": name, "Proxy": proxy})
+ }
+ if proxyInfo.IsStatic == common.IsStaticYes {
+ mvp.Groups[name].IsStatic = true
+ }
+ mvp.Proxy[name] = proxy
}
// AddMvlanGroup for addition of groups to an MVLAN profile
func (mvp *MvlanProfile) AddMvlanGroup(name string, ips []string) {
- mvg := &MvlanGroup{}
- mvg.Name = name
- mvg.Wildcard = len(ips) == 0
- mvg.McIPs = ips
- mvg.IsStatic = false
- if _, ok := mvp.Groups[name]; !ok {
- logger.Debugw(ctx, "Added MVLAN Group", log.Fields{"VLAN": mvp.Mvlan, "Name": name, "mvg": mvg, "IPs": mvg.McIPs})
- } else {
- logger.Debugw(ctx, "Updated MVLAN Group", log.Fields{"VLAN": mvp.Mvlan, "Name": name})
- }
- mvp.Groups[name] = mvg
+ mvg := &MvlanGroup{}
+ mvg.Name = name
+ mvg.Wildcard = len(ips) == 0
+ mvg.McIPs = ips
+ mvg.IsStatic = false
+ if _, ok := mvp.Groups[name]; !ok {
+ logger.Debugw(ctx, "Added MVLAN Group", log.Fields{"VLAN": mvp.Mvlan, "Name": name, "mvg": mvg, "IPs": mvg.McIPs})
+ } else {
+ logger.Debugw(ctx, "Updated MVLAN Group", log.Fields{"VLAN": mvp.Mvlan, "Name": name})
+ }
+ mvp.Groups[name] = mvg
}
// GetUsMatchVlan provides mvlan for US Match parameter
func (mvp *MvlanProfile) GetUsMatchVlan() of.VlanType {
- if mvp.IsPonVlanPresent {
- return mvp.PonVlan
- }
- return mvp.Mvlan
+ if mvp.IsPonVlanPresent {
+ return mvp.PonVlan
+ }
+ return mvp.Mvlan
}
// WriteToDb is utility to write Mvlan Profile Info to database
func (mvp *MvlanProfile) WriteToDb(cntx context.Context) error {
+ if mvp.DeleteInProgress {
+ logger.Warnw(ctx, "Skipping Redis Update for MvlanProfile, MvlanProfile delete in progress", log.Fields{"Mvlan": mvp.Mvlan})
+ return nil
+ }
- if mvp.DeleteInProgress {
- logger.Warnw(ctx, "Skipping Redis Update for MvlanProfile, MvlanProfile delete in progress", log.Fields{"Mvlan": mvp.Mvlan})
- return nil
- }
-
- mvp.Version = database.PresentVersionMap[database.MvlanPath]
- b, err := json.Marshal(mvp)
- if err != nil {
- return err
- }
- if err1 := db.PutMvlan(cntx, uint16(mvp.Mvlan), string(b)); err1 != nil {
- return err1
- }
- return nil
+ mvp.Version = database.PresentVersionMap[database.MvlanPath]
+ b, err := json.Marshal(mvp)
+ if err != nil {
+ return err
+ }
+ if err1 := db.PutMvlan(cntx, uint16(mvp.Mvlan), string(b)); err1 != nil {
+ return err1
+ }
+ return nil
}
-//isChannelStatic - Returns true if the given channel is part of static group in the Mvlan Profile
+// isChannelStatic - Returns true if the given channel is part of static group in the Mvlan Profile
func (mvp *MvlanProfile) isChannelStatic(channel net.IP) bool {
- for _, mvg := range mvp.Groups {
- if mvg.IsStatic {
- if isChannelStatic := doesIPMatch(channel, mvg.McIPs); isChannelStatic {
- return true
- }
- }
- }
- return false
+ for _, mvg := range mvp.Groups {
+ if mvg.IsStatic {
+ if isChannelStatic := doesIPMatch(channel, mvg.McIPs); isChannelStatic {
+ return true
+ }
+ }
+ }
+ return false
}
-//containsStaticChannels - Returns if any static channels is part of the Mvlan Profile
+// containsStaticChannels - Returns if any static channels is part of the Mvlan Profile
func (mvp *MvlanProfile) containsStaticChannels() bool {
- for _, mvg := range mvp.Groups {
- if mvg.IsStatic && len(mvg.McIPs) != 0 {
- return true
- }
- }
- return false
+ for _, mvg := range mvp.Groups {
+ if mvg.IsStatic && len(mvg.McIPs) != 0 {
+ return true
+ }
+ }
+ return false
}
-//getAllStaticChannels - Returns all static channels in the Mvlan Profile
+// getAllStaticChannels - Returns all static channels in the Mvlan Profile
func (mvp *MvlanProfile) getAllStaticChannels() ([]net.IP, bool) {
- channelList := []net.IP{}
- containsStatic := false
- for _, mvg := range mvp.Groups {
- if mvg.IsStatic {
- staticChannels, _ := mvg.getAllChannels()
- channelList = append(channelList, staticChannels...)
- }
- }
- if len(channelList) > 0 {
- containsStatic = true
- }
- return channelList, containsStatic
+ channelList := []net.IP{}
+ containsStatic := false
+ for _, mvg := range mvp.Groups {
+ if mvg.IsStatic {
+ staticChannels, _ := mvg.getAllChannels()
+ channelList = append(channelList, staticChannels...)
+ }
+ }
+ if len(channelList) > 0 {
+ containsStatic = true
+ }
+ return channelList, containsStatic
}
-//getAllOldGroupStaticChannels - Returns all static channels in the Mvlan Profile
+// getAllOldGroupStaticChannels - Returns all static channels in the Mvlan Profile
func (mvp *MvlanProfile) getAllOldGroupStaticChannels() ([]net.IP, bool) {
- channelList := []net.IP{}
- containsStatic := false
- for _, mvg := range mvp.oldGroups {
- if mvg.IsStatic {
- staticChannels, _ := mvg.getAllChannels()
- channelList = append(channelList, staticChannels...)
- }
- }
- if len(channelList) > 0 {
- containsStatic = true
- }
- return channelList, containsStatic
+ channelList := []net.IP{}
+ containsStatic := false
+ for _, mvg := range mvp.oldGroups {
+ if mvg.IsStatic {
+ staticChannels, _ := mvg.getAllChannels()
+ channelList = append(channelList, staticChannels...)
+ }
+ }
+ if len(channelList) > 0 {
+ containsStatic = true
+ }
+ return channelList, containsStatic
}
-//getAllChannels - Returns all channels in the Mvlan Profile
+// getAllChannels - Returns all channels in the Mvlan Profile
func (mvg *MvlanGroup) getAllChannels() ([]net.IP, bool) {
- channelList := []net.IP{}
+ channelList := []net.IP{}
- if mvg == nil || len(mvg.McIPs) == 0 {
- return []net.IP{}, false
- }
+ if mvg == nil || len(mvg.McIPs) == 0 {
+ return []net.IP{}, false
+ }
- grpChannelOrRange := mvg.McIPs
- for _, channelOrRange := range grpChannelOrRange {
- if strings.Contains(channelOrRange, "-") {
- var splits = strings.Split(channelOrRange, "-")
- ipStart := util.IP2LongConv(net.ParseIP(splits[0]))
- ipEnd := util.IP2LongConv(net.ParseIP(splits[1]))
+ grpChannelOrRange := mvg.McIPs
+ for _, channelOrRange := range grpChannelOrRange {
+ if strings.Contains(channelOrRange, "-") {
+ var splits = strings.Split(channelOrRange, "-")
+ ipStart := util.IP2LongConv(net.ParseIP(splits[0]))
+ ipEnd := util.IP2LongConv(net.ParseIP(splits[1]))
- for i := ipStart; i <= ipEnd; i++ {
- channelList = append(channelList, util.Long2ipConv(i))
- }
- } else {
- channelList = append(channelList, net.ParseIP(channelOrRange))
- }
- }
- return channelList, true
+ for i := ipStart; i <= ipEnd; i++ {
+ channelList = append(channelList, util.Long2ipConv(i))
+ }
+ } else {
+ channelList = append(channelList, net.ParseIP(channelOrRange))
+ }
+ }
+ return channelList, true
}
-//SetUpdateStatus - Sets profile update status for devices
+// SetUpdateStatus - Sets profile update status for devices
func (mvp *MvlanProfile) SetUpdateStatus(serialNum string, status OperInProgress) {
- if serialNum != "" {
- mvp.DevicesList[serialNum] = status
- return
- }
+ if serialNum != "" {
+ mvp.DevicesList[serialNum] = status
+ return
+ }
- for srNo := range mvp.DevicesList {
- mvp.DevicesList[srNo] = status
- }
+ for srNo := range mvp.DevicesList {
+ mvp.DevicesList[srNo] = status
+ }
}
-//isUpdateInProgress - checking is update is in progress for the mvlan profile
+// isUpdateInProgress - checking is update is in progress for the mvlan profile
func (mvp *MvlanProfile) isUpdateInProgress() bool {
-
- for srNo := range mvp.DevicesList {
- if mvp.DevicesList[srNo] == UpdateInProgress {
- return true
- }
- }
- return false
+ for srNo := range mvp.DevicesList {
+ if mvp.DevicesList[srNo] == UpdateInProgress {
+ return true
+ }
+ }
+ return false
}
-//IsUpdateInProgressForDevice - Checks is Mvlan Profile update is is progress for the given device
+// IsUpdateInProgressForDevice - Checks is Mvlan Profile update is is progress for the given device
func (mvp *MvlanProfile) IsUpdateInProgressForDevice(device string) bool {
- if vd := GetApplication().GetDevice(device); vd != nil {
- if mvp.DevicesList[vd.SerialNum] == UpdateInProgress {
- return true
- }
- }
- return false
+ if vd := GetApplication().GetDevice(device); vd != nil {
+ if mvp.DevicesList[vd.SerialNum] == UpdateInProgress {
+ return true
+ }
+ }
+ return false
}
// DelFromDb to delere mvlan from database
func (mvp *MvlanProfile) DelFromDb(cntx context.Context) {
- _ = db.DelMvlan(cntx, uint16(mvp.Mvlan))
+ _ = db.DelMvlan(cntx, uint16(mvp.Mvlan))
}
-//DelFlows - Triggers flow deletion after registering for flow indication event
+// DelFlows - Triggers flow deletion after registering for flow indication event
func (mvp *MvlanProfile) DelFlows(cntx context.Context, device *VoltDevice, flow *of.VoltFlow) error {
- mvp.mvpFlowLock.Lock()
- defer mvp.mvpFlowLock.Unlock()
+ mvp.mvpFlowLock.Lock()
+ defer mvp.mvpFlowLock.Unlock()
- var flowMap map[string]bool
- var ok bool
+ var flowMap map[string]bool
+ var ok bool
- for cookie := range flow.SubFlows {
- cookie := strconv.FormatUint(cookie, 10)
- fe := &FlowEvent{
- eType: EventTypeMcastFlowRemoved,
- device: device.Name,
- cookie: cookie,
- eventData: mvp,
- }
- device.RegisterFlowDelEvent(cookie, fe)
+ for cookie := range flow.SubFlows {
+ cookie := strconv.FormatUint(cookie, 10)
+ fe := &FlowEvent{
+ eType: EventTypeMcastFlowRemoved,
+ device: device.Name,
+ cookie: cookie,
+ eventData: mvp,
+ }
+ device.RegisterFlowDelEvent(cookie, fe)
- if flowMap, ok = mvp.PendingDeleteFlow[device.Name]; !ok {
- flowMap = make(map[string]bool)
- }
- flowMap[cookie] = true
- mvp.PendingDeleteFlow[device.Name] = flowMap
- }
- if err := mvp.WriteToDb(cntx); err != nil {
- logger.Errorw(ctx, "Mvlan profile write to DB failed", log.Fields{"ProfileName": mvp.Name})
- }
- return cntlr.GetController().DelFlows(cntx, device.NniPort, device.Name, flow)
+ if flowMap, ok = mvp.PendingDeleteFlow[device.Name]; !ok {
+ flowMap = make(map[string]bool)
+ }
+ flowMap[cookie] = true
+ mvp.PendingDeleteFlow[device.Name] = flowMap
+ }
+ if err := mvp.WriteToDb(cntx); err != nil {
+ logger.Errorw(ctx, "Mvlan profile write to DB failed", log.Fields{"ProfileName": mvp.Name})
+ }
+ return cntlr.GetController().DelFlows(cntx, device.NniPort, device.Name, flow)
}
-//FlowRemoveSuccess - Process flow success indication
+// FlowRemoveSuccess - Process flow success indication
func (mvp *MvlanProfile) FlowRemoveSuccess(cntx context.Context, cookie string, device string) {
- mvp.mvpFlowLock.Lock()
- defer mvp.mvpFlowLock.Unlock()
+ mvp.mvpFlowLock.Lock()
+ defer mvp.mvpFlowLock.Unlock()
- logger.Infow(ctx, "Mvlan Flow Remove Success Notification", log.Fields{"MvlanProfile": mvp.Name, "Cookie": cookie, "Device": device})
+ logger.Infow(ctx, "Mvlan Flow Remove Success Notification", log.Fields{"MvlanProfile": mvp.Name, "Cookie": cookie, "Device": device})
- if _, ok := mvp.PendingDeleteFlow[device]; ok {
- delete(mvp.PendingDeleteFlow[device], cookie)
- }
+ if _, ok := mvp.PendingDeleteFlow[device]; ok {
+ delete(mvp.PendingDeleteFlow[device], cookie)
+ }
- if err := mvp.WriteToDb(cntx); err != nil {
- logger.Errorw(ctx, "Mvlan profile write to DB failed", log.Fields{"ProfileName": mvp.Name})
- }
+ if err := mvp.WriteToDb(cntx); err != nil {
+ logger.Errorw(ctx, "Mvlan profile write to DB failed", log.Fields{"ProfileName": mvp.Name})
+ }
}
-//FlowRemoveFailure - Process flow failure indication
+// FlowRemoveFailure - Process flow failure indication
func (mvp *MvlanProfile) FlowRemoveFailure(cookie string, device string, errorCode uint32, errReason string) {
+ mvp.mvpFlowLock.Lock()
+ defer mvp.mvpFlowLock.Unlock()
- mvp.mvpFlowLock.Lock()
- defer mvp.mvpFlowLock.Unlock()
-
- if flowMap, ok := mvp.PendingDeleteFlow[device]; ok {
- if _, ok := flowMap[cookie]; ok {
- logger.Errorw(ctx, "Mvlan Flow Remove Failure Notification", log.Fields{"MvlanProfile": mvp.Name, "Cookie": cookie, "ErrorCode": errorCode, "ErrorReason": errReason, "Device": device})
- return
- }
- }
- logger.Errorw(ctx, "Mvlan Flow Del Failure Notification for Unknown cookie", log.Fields{"MvlanProfile": mvp.Name, "Cookie": cookie, "ErrorCode": errorCode, "ErrorReason": errReason})
-
+ if flowMap, ok := mvp.PendingDeleteFlow[device]; ok {
+ if _, ok := flowMap[cookie]; ok {
+ logger.Errorw(ctx, "Mvlan Flow Remove Failure Notification", log.Fields{"MvlanProfile": mvp.Name, "Cookie": cookie, "ErrorCode": errorCode, "ErrorReason": errReason, "Device": device})
+ return
+ }
+ }
+ logger.Errorw(ctx, "Mvlan Flow Del Failure Notification for Unknown cookie", log.Fields{"MvlanProfile": mvp.Name, "Cookie": cookie, "ErrorCode": errorCode, "ErrorReason": errReason})
}
// IsStaticGroup to check if group is static
func (mvp *MvlanProfile) IsStaticGroup(groupName string) bool {
- return mvp.Groups[groupName].IsStatic
+ return mvp.Groups[groupName].IsStatic
}
// generateGroupKey to generate group key
func (mvp *MvlanProfile) generateGroupKey(name string, ipAddr string) string {
- if mvp.IsChannelBasedGroup {
- return mvp.Mvlan.String() + "_" + ipAddr
- }
- return mvp.Mvlan.String() + "_" + name
+ if mvp.IsChannelBasedGroup {
+ return mvp.Mvlan.String() + "_" + ipAddr
+ }
+ return mvp.Mvlan.String() + "_" + name
}
// GetStaticGroupName to get static igmp group
func (mvp *MvlanProfile) GetStaticGroupName(gip net.IP) string {
- for _, mvg := range mvp.Groups {
- if mvg.IsStatic {
- if doesIPMatch(gip, mvg.McIPs) {
- return mvg.Name
- }
- }
- }
- return ""
+ for _, mvg := range mvp.Groups {
+ if mvg.IsStatic {
+ if doesIPMatch(gip, mvg.McIPs) {
+ return mvg.Name
+ }
+ }
+ }
+ return ""
}
// GetStaticIgmpGroup to get static igmp group
func (mvp *MvlanProfile) GetStaticIgmpGroup(gip net.IP) *IgmpGroup {
-
- staticGroupName := mvp.GetStaticGroupName(gip)
- grpKey := mvp.generateGroupKey(staticGroupName, gip.String())
- logger.Debugw(ctx, "Get Static IGMP Group", log.Fields{"Group": grpKey})
- ig, ok := GetApplication().IgmpGroups.Load(grpKey)
- if ok {
- logger.Debugw(ctx, "Get Static IGMP Group Success", log.Fields{"Group": grpKey})
- return ig.(*IgmpGroup)
- }
- return nil
+ staticGroupName := mvp.GetStaticGroupName(gip)
+ grpKey := mvp.generateGroupKey(staticGroupName, gip.String())
+ logger.Debugw(ctx, "Get Static IGMP Group", log.Fields{"Group": grpKey})
+ ig, ok := GetApplication().IgmpGroups.Load(grpKey)
+ if ok {
+ logger.Debugw(ctx, "Get Static IGMP Group Success", log.Fields{"Group": grpKey})
+ return ig.(*IgmpGroup)
+ }
+ return nil
}
-//pushIgmpMcastFlows - Adds all IGMP related flows (generic DS flow & static group flows)
+// pushIgmpMcastFlows - Adds all IGMP related flows (generic DS flow & static group flows)
func (mvp *MvlanProfile) pushIgmpMcastFlows(cntx context.Context, OLTSerialNum string) {
+ mvp.mvpLock.RLock()
+ defer mvp.mvpLock.RUnlock()
- mvp.mvpLock.RLock()
- defer mvp.mvpLock.RUnlock()
+ if mvp.DevicesList[OLTSerialNum] == Nil {
+ logger.Infow(ctx, "Mvlan Profile not configure for device", log.Fields{"Device": OLTSerialNum, "Mvlan": mvp.Mvlan})
+ return
+ }
- if mvp.DevicesList[OLTSerialNum] == Nil {
- logger.Infow(ctx, "Mvlan Profile not configure for device", log.Fields{"Device": OLTSerialNum, "Mvlan": mvp.Mvlan})
- return
- }
+ d, _ := GetApplication().GetDeviceBySerialNo(OLTSerialNum)
+ if d == nil {
+ logger.Warnw(ctx, "Skipping Igmp & Mcast Flow processing: Device Not Found", log.Fields{"Device_SrNo": OLTSerialNum, "Mvlan": mvp.Mvlan})
+ return
+ }
- d, _ := GetApplication().GetDeviceBySerialNo(OLTSerialNum)
- if d == nil {
- logger.Warnw(ctx, "Skipping Igmp & Mcast Flow processing: Device Not Found", log.Fields{"Device_SrNo": OLTSerialNum, "Mvlan": mvp.Mvlan})
- return
- }
+ p := d.GetPort(d.NniPort)
- p := d.GetPort(d.NniPort)
+ if p != nil && p.State == PortStateUp {
+ logger.Infow(ctx, "NNI Port Status is: UP & Vlan Enabled", log.Fields{"Device": d, "port": p})
- if p != nil && p.State == PortStateUp {
- logger.Infow(ctx, "NNI Port Status is: UP & Vlan Enabled", log.Fields{"Device": d, "port": p})
+ //Push Igmp DS Control Flows
+ err := mvp.ApplyIgmpDSFlowForMvp(cntx, d.Name)
+ if err != nil {
+ logger.Errorw(ctx, "DS IGMP Flow Add Failed for device",
+ log.Fields{"Reason": err.Error(), "device": d.Name})
+ }
- //Push Igmp DS Control Flows
- err := mvp.ApplyIgmpDSFlowForMvp(cntx, d.Name)
- if err != nil {
- logger.Errorw(ctx, "DS IGMP Flow Add Failed for device",
- log.Fields{"Reason": err.Error(), "device": d.Name})
- }
-
- //Trigger Join for static channels
- if channelList, containsStatic := mvp.getAllStaticChannels(); containsStatic {
- mvp.ProcessStaticGroup(cntx, d.Name, channelList, true)
- } else {
- logger.Infow(ctx, "No Static Channels Present", log.Fields{"mvp": mvp.Name, "Mvlan": mvp.Mvlan})
- }
- }
+ //Trigger Join for static channels
+ if channelList, containsStatic := mvp.getAllStaticChannels(); containsStatic {
+ mvp.ProcessStaticGroup(cntx, d.Name, channelList, true)
+ } else {
+ logger.Infow(ctx, "No Static Channels Present", log.Fields{"mvp": mvp.Name, "Mvlan": mvp.Mvlan})
+ }
+ }
}
-//removeIgmpMcastFlows - Removes all IGMP related flows (generic DS flow & static group flows)
+
+// removeIgmpMcastFlows - Removes all IGMP related flows (generic DS flow & static group flows)
func (mvp *MvlanProfile) removeIgmpMcastFlows(cntx context.Context, oltSerialNum string) {
+ mvp.mvpLock.RLock()
+ defer mvp.mvpLock.RUnlock()
- mvp.mvpLock.RLock()
- defer mvp.mvpLock.RUnlock()
+ if d, _ := GetApplication().GetDeviceBySerialNo(oltSerialNum); d != nil {
+ p := d.GetPort(d.NniPort)
+ if p != nil {
+ logger.Infow(ctx, "NNI Port Status is: UP", log.Fields{"Device": d, "port": p})
- if d, _ := GetApplication().GetDeviceBySerialNo(oltSerialNum); d != nil {
- p := d.GetPort(d.NniPort)
- if p != nil {
- logger.Infow(ctx, "NNI Port Status is: UP", log.Fields{"Device": d, "port": p})
+ // ***Do not change the order***
+ // When Vlan is disabled, the process end is determined by the DS Igmp flag in device
- // ***Do not change the order***
- // When Vlan is disabled, the process end is determined by the DS Igmp flag in device
+ //Trigger Leave for static channels
+ if channelList, containsStatic := mvp.getAllStaticChannels(); containsStatic {
+ mvp.ProcessStaticGroup(cntx, d.Name, channelList, false)
+ } else {
+ logger.Infow(ctx, "No Static Channels Present", log.Fields{"mvp": mvp.Name, "Mvlan": mvp.Mvlan})
+ }
- //Trigger Leave for static channels
- if channelList, containsStatic := mvp.getAllStaticChannels(); containsStatic {
- mvp.ProcessStaticGroup(cntx, d.Name, channelList, false)
- } else {
- logger.Infow(ctx, "No Static Channels Present", log.Fields{"mvp": mvp.Name, "Mvlan": mvp.Mvlan})
- }
+ //Remove all dynamic members for the Mvlan Profile
+ GetApplication().IgmpGroups.Range(func(key, value interface{}) bool {
+ ig := value.(*IgmpGroup)
+ if ig.Mvlan == mvp.Mvlan {
+ igd := ig.Devices[d.Name]
+ ig.DelIgmpGroupDevice(cntx, igd)
+ if ig.NumDevicesActive() == 0 {
+ GetApplication().DelIgmpGroup(cntx, ig)
+ }
+ }
+ return true
+ })
- //Remove all dynamic members for the Mvlan Profile
- GetApplication().IgmpGroups.Range(func(key, value interface{}) bool {
- ig := value.(*IgmpGroup)
- if ig.Mvlan == mvp.Mvlan {
- igd := ig.Devices[d.Name]
- ig.DelIgmpGroupDevice(cntx, igd)
- if ig.NumDevicesActive() == 0 {
- GetApplication().DelIgmpGroup(cntx, ig)
- }
- }
- return true
- })
-
- //Remove DS Igmp trap flow
- err := mvp.RemoveIgmpDSFlowForMvp(cntx, d.Name)
- if err != nil {
- logger.Errorw(ctx, "DS IGMP Flow Del Failed", log.Fields{"Reason": err.Error(), "device": d.Name})
- }
- }
- }
+ //Remove DS Igmp trap flow
+ err := mvp.RemoveIgmpDSFlowForMvp(cntx, d.Name)
+ if err != nil {
+ logger.Errorw(ctx, "DS IGMP Flow Del Failed", log.Fields{"Reason": err.Error(), "device": d.Name})
+ }
+ }
+ }
}
// ApplyIgmpDSFlowForMvp to apply Igmp DS flow for mvlan.
func (mvp *MvlanProfile) ApplyIgmpDSFlowForMvp(cntx context.Context, device string) error {
- va := GetApplication()
- dIntf, ok := va.DevicesDisc.Load(device)
- if !ok {
- return errors.New("Device Doesn't Exist")
- }
- d := dIntf.(*VoltDevice)
- mvlan := mvp.Mvlan
+ va := GetApplication()
+ dIntf, ok := va.DevicesDisc.Load(device)
+ if !ok {
+ return errors.New("Device Doesn't Exist")
+ }
+ d := dIntf.(*VoltDevice)
+ mvlan := mvp.Mvlan
- flowAlreadyApplied, ok := d.IgmpDsFlowAppliedForMvlan[uint16(mvlan)]
- if !ok || !flowAlreadyApplied {
- flows, err := mvp.BuildIgmpDSFlows(device)
- if err == nil {
- err = cntlr.GetController().AddFlows(cntx, d.NniPort, device, flows)
- if err != nil {
- logger.Warnw(ctx, "Configuring IGMP Flow for device failed ", log.Fields{"Device": device, "err": err})
- return err
- }
- d.IgmpDsFlowAppliedForMvlan[uint16(mvlan)] = true
- logger.Infow(ctx, "Updating voltDevice that IGMP DS flow as \"added\" for ",
- log.Fields{"device": d.SerialNum, "mvlan": mvlan})
- } else {
- logger.Errorw(ctx, "DS IGMP Flow Add Failed", log.Fields{"Reason": err.Error(), "Mvlan": mvlan})
- }
- }
+ flowAlreadyApplied, ok := d.IgmpDsFlowAppliedForMvlan[uint16(mvlan)]
+ if !ok || !flowAlreadyApplied {
+ flows, err := mvp.BuildIgmpDSFlows(device)
+ if err == nil {
+ err = cntlr.GetController().AddFlows(cntx, d.NniPort, device, flows)
+ if err != nil {
+ logger.Warnw(ctx, "Configuring IGMP Flow for device failed ", log.Fields{"Device": device, "err": err})
+ return err
+ }
+ d.IgmpDsFlowAppliedForMvlan[uint16(mvlan)] = true
+ logger.Infow(ctx, "Updating voltDevice that IGMP DS flow as \"added\" for ",
+ log.Fields{"device": d.SerialNum, "mvlan": mvlan})
+ } else {
+ logger.Errorw(ctx, "DS IGMP Flow Add Failed", log.Fields{"Reason": err.Error(), "Mvlan": mvlan})
+ }
+ }
- return nil
+ return nil
}
// RemoveIgmpDSFlowForMvp to remove Igmp DS flow for mvlan.
func (mvp *MvlanProfile) RemoveIgmpDSFlowForMvp(cntx context.Context, device string) error {
+ va := GetApplication()
+ mvlan := mvp.Mvlan
- va := GetApplication()
- mvlan := mvp.Mvlan
+ dIntf, ok := va.DevicesDisc.Load(device)
+ if !ok {
+ return errors.New("Device Doesn't Exist")
+ }
+ d := dIntf.(*VoltDevice)
+ /* No need of strict check during DS IGMP deletion
+ flowAlreadyApplied, ok := d.IgmpDsFlowAppliedForMvlan[uint16(mvlan)]
+ if ok && flowAlreadyApplied
+ */
+ flows, err := mvp.BuildIgmpDSFlows(device)
+ if err == nil {
+ flows.ForceAction = true
- dIntf, ok := va.DevicesDisc.Load(device)
- if !ok {
- return errors.New("Device Doesn't Exist")
- }
- d := dIntf.(*VoltDevice)
- /* No need of strict check during DS IGMP deletion
- flowAlreadyApplied, ok := d.IgmpDsFlowAppliedForMvlan[uint16(mvlan)]
- if ok && flowAlreadyApplied
- */
- flows, err := mvp.BuildIgmpDSFlows(device)
- if err == nil {
- flows.ForceAction = true
+ err = mvp.DelFlows(cntx, d, flows)
+ if err != nil {
+ logger.Warnw(ctx, "De-Configuring IGMP Flow for device failed ", log.Fields{"Device": device, "err": err})
+ return err
+ }
+ d.IgmpDsFlowAppliedForMvlan[uint16(mvlan)] = false
+ logger.Infow(ctx, "Updating voltDevice that IGMP DS flow as \"removed\" for ",
+ log.Fields{"device": d.SerialNum, "mvlan": mvlan})
+ } else {
+ logger.Errorw(ctx, "DS IGMP Flow Del Failed", log.Fields{"Reason": err.Error()})
+ }
- err = mvp.DelFlows(cntx, d, flows)
- if err != nil {
- logger.Warnw(ctx, "De-Configuring IGMP Flow for device failed ", log.Fields{"Device": device, "err": err})
- return err
- }
- d.IgmpDsFlowAppliedForMvlan[uint16(mvlan)] = false
- logger.Infow(ctx, "Updating voltDevice that IGMP DS flow as \"removed\" for ",
- log.Fields{"device": d.SerialNum, "mvlan": mvlan})
- } else {
- logger.Errorw(ctx, "DS IGMP Flow Del Failed", log.Fields{"Reason": err.Error()})
- }
-
- return nil
+ return nil
}
// BuildIgmpDSFlows to build Igmp DS flows for NNI port
func (mvp *MvlanProfile) BuildIgmpDSFlows(device string) (*of.VoltFlow, error) {
- dIntf, ok := GetApplication().DevicesDisc.Load(device)
- if !ok {
- return nil, errors.New("Device Doesn't Exist")
- }
- d := dIntf.(*VoltDevice)
+ dIntf, ok := GetApplication().DevicesDisc.Load(device)
+ if !ok {
+ return nil, errors.New("Device Doesn't Exist")
+ }
+ d := dIntf.(*VoltDevice)
- logger.Infow(ctx, "Building DS IGMP Flow for NNI port", log.Fields{"vs": d.NniPort, "Mvlan": mvp.Mvlan})
- flow := &of.VoltFlow{}
- flow.SubFlows = make(map[uint64]*of.VoltSubFlow)
- subFlow := of.NewVoltSubFlow()
- subFlow.SetTableID(0)
- subFlow.SetMatchVlan(mvp.Mvlan)
+ logger.Infow(ctx, "Building DS IGMP Flow for NNI port", log.Fields{"vs": d.NniPort, "Mvlan": mvp.Mvlan})
+ flow := &of.VoltFlow{}
+ flow.SubFlows = make(map[uint64]*of.VoltSubFlow)
+ subFlow := of.NewVoltSubFlow()
+ subFlow.SetTableID(0)
+ subFlow.SetMatchVlan(mvp.Mvlan)
- nniPort, err := GetApplication().GetNniPort(device)
- if err != nil {
- return nil, err
- }
- nniPortID, err1 := GetApplication().GetPortID(nniPort)
- if err1 != nil {
- return nil, errors.New("Unknown NNI outport")
- }
- subFlow.SetInPort(nniPortID)
- subFlow.SetIgmpMatch()
- subFlow.SetReportToController()
- subFlow.Cookie = uint64(nniPortID)<<32 | uint64(mvp.Mvlan)
- subFlow.Priority = of.IgmpFlowPriority
+ nniPort, err := GetApplication().GetNniPort(device)
+ if err != nil {
+ return nil, err
+ }
+ nniPortID, err1 := GetApplication().GetPortID(nniPort)
+ if err1 != nil {
+ return nil, errors.New("Unknown NNI outport")
+ }
+ subFlow.SetInPort(nniPortID)
+ subFlow.SetIgmpMatch()
+ subFlow.SetReportToController()
+ subFlow.Cookie = uint64(nniPortID)<<32 | uint64(mvp.Mvlan)
+ subFlow.Priority = of.IgmpFlowPriority
- flow.SubFlows[subFlow.Cookie] = subFlow
- logger.Infow(ctx, "Built DS IGMP flow", log.Fields{"cookie": subFlow.Cookie, "subflow": subFlow})
- return flow, nil
+ flow.SubFlows[subFlow.Cookie] = subFlow
+ logger.Infow(ctx, "Built DS IGMP flow", log.Fields{"cookie": subFlow.Cookie, "subflow": subFlow})
+ return flow, nil
}
-//updateStaticGroups - Generates static joins & leaves for newly added and removed static channels respectively
+// updateStaticGroups - Generates static joins & leaves for newly added and removed static channels respectively
func (mvp *MvlanProfile) updateStaticGroups(cntx context.Context, deviceID string, added []net.IP, removed []net.IP) {
+ // Update static group configs for all associated devices
+ updateGroups := func(key interface{}, value interface{}) bool {
+ d := value.(*VoltDevice)
- //Update static group configs for all associated devices
- updateGroups := func(key interface{}, value interface{}) bool {
- d := value.(*VoltDevice)
+ if mvp.DevicesList[d.SerialNum] == Nil {
+ logger.Infow(ctx, "Mvlan Profile not configure for device", log.Fields{"Device": d, "Profile Device List": mvp.DevicesList})
+ return true
+ }
+ // TODO if mvp.IsChannelBasedGroup {
+ mvp.ProcessStaticGroup(cntx, d.Name, added, true)
+ mvp.ProcessStaticGroup(cntx, d.Name, removed, false)
+ //}
+ return true
+ }
- if mvp.DevicesList[d.SerialNum] == Nil {
- logger.Infow(ctx, "Mvlan Profile not configure for device", log.Fields{"Device": d, "Profile Device List": mvp.DevicesList})
- return true
- }
- //TODO if mvp.IsChannelBasedGroup {
- mvp.ProcessStaticGroup(cntx, d.Name, added, true)
- mvp.ProcessStaticGroup(cntx, d.Name, removed, false)
- //}
- return true
- }
-
- if deviceID != "" {
- vd := GetApplication().GetDevice(deviceID)
- updateGroups(deviceID, vd)
- } else {
- GetApplication().DevicesDisc.Range(updateGroups)
- }
+ if deviceID != "" {
+ vd := GetApplication().GetDevice(deviceID)
+ updateGroups(deviceID, vd)
+ } else {
+ GetApplication().DevicesDisc.Range(updateGroups)
+ }
}
-//updateDynamicGroups - Generates joins with updated sources for existing channels
+// updateDynamicGroups - Generates joins with updated sources for existing channels
func (mvp *MvlanProfile) updateDynamicGroups(cntx context.Context, deviceID string, added []net.IP, removed []net.IP) {
+ //mvlan := mvp.Mvlan
+ va := GetApplication()
- //mvlan := mvp.Mvlan
- va := GetApplication()
+ updateGroups := func(key interface{}, value interface{}) bool {
+ d := value.(*VoltDevice)
- updateGroups := func(key interface{}, value interface{}) bool {
- d := value.(*VoltDevice)
+ if mvp.DevicesList[d.SerialNum] == Nil {
+ logger.Infow(ctx, "Mvlan Profile not configure for device", log.Fields{"Device": d, "Profile Device List": mvp.DevicesList})
+ return true
+ }
+ for _, groupAddr := range added {
+ _, gName := va.GetMvlanProfileForMcIP(mvp.Name, groupAddr)
+ grpKey := mvp.generateGroupKey(gName, groupAddr.String())
+ logger.Debugw(ctx, "IGMP Group", log.Fields{"Group": grpKey, "groupAddr": groupAddr})
+ if igIntf, ok := va.IgmpGroups.Load(grpKey); ok {
+ ig := igIntf.(*IgmpGroup)
+ if igd, ok := ig.getIgmpGroupDevice(cntx, d.Name); ok {
+ if igcIntf, ok := igd.GroupChannels.Load(groupAddr.String()); ok {
+ igc := igcIntf.(*IgmpGroupChannel)
+ incl := false
+ var ip []net.IP
+ var groupModified = false
+ if _, ok := mvp.Proxy[igc.GroupName]; ok {
+ if mvp.Proxy[igc.GroupName].Mode == common.Include {
+ incl = true
+ }
+ ip = mvp.Proxy[igc.GroupName].SourceList
+ }
+ for port, igp := range igc.NewReceivers {
+ // Process the include/exclude list which may end up modifying the group
+ if change, _ := igc.ProcessSources(cntx, port, ip, incl); change {
+ groupModified = true
+ }
+ igc.ProcessMode(port, incl)
- if mvp.DevicesList[d.SerialNum] == Nil {
- logger.Infow(ctx, "Mvlan Profile not configure for device", log.Fields{"Device": d, "Profile Device List": mvp.DevicesList})
- return true
- }
- for _, groupAddr := range added {
+ if err := igp.WriteToDb(cntx, igc.Mvlan, igc.GroupAddr, igc.Device); err != nil {
+ logger.Errorw(ctx, "Igmp group port Write to DB failed", log.Fields{"mvlan": igc.Mvlan, "GroupAddr": igc.GroupAddr})
+ }
+ }
+ // If the group is modified as this is the first receiver or due to include/exclude list modification
+ // send a report to the upstream multicast servers
+ if groupModified {
+ logger.Debug(ctx, "Group Modified and IGMP report sent to the upstream server")
+ igc.SendReport(false)
+ }
+ if err := igc.WriteToDb(cntx); err != nil {
+ logger.Errorw(ctx, "Igmp group channel Write to DB failed", log.Fields{"mvlan": igc.Mvlan, "GroupAddr": igc.GroupAddr})
+ }
+ }
+ }
+ }
+ }
- _, gName := va.GetMvlanProfileForMcIP(mvp.Name, groupAddr)
- grpKey := mvp.generateGroupKey(gName, groupAddr.String())
- logger.Debugw(ctx, "IGMP Group", log.Fields{"Group": grpKey, "groupAddr": groupAddr})
- if igIntf, ok := va.IgmpGroups.Load(grpKey); ok {
- ig := igIntf.(*IgmpGroup)
- if igd, ok := ig.getIgmpGroupDevice(cntx, d.Name); ok {
- if igcIntf, ok := igd.GroupChannels.Load(groupAddr.String()); ok {
- igc := igcIntf.(*IgmpGroupChannel)
- incl := false
- var ip []net.IP
- var groupModified = false
- if _, ok := mvp.Proxy[igc.GroupName]; ok {
- if mvp.Proxy[igc.GroupName].Mode == common.Include {
- incl = true
- }
- ip = mvp.Proxy[igc.GroupName].SourceList
- }
- for port, igp := range igc.NewReceivers {
- // Process the include/exclude list which may end up modifying the group
- if change, _ := igc.ProcessSources(cntx, port, ip, incl); change {
- groupModified = true
- }
- igc.ProcessMode(port, incl)
+ return true
+ }
- if err := igp.WriteToDb(cntx, igc.Mvlan, igc.GroupAddr, igc.Device); err != nil {
- logger.Errorw(ctx, "Igmp group port Write to DB failed", log.Fields{"mvlan": igc.Mvlan, "GroupAddr": igc.GroupAddr})
- }
- }
- // If the group is modified as this is the first receiver or due to include/exclude list modification
- // send a report to the upstream multicast servers
- if groupModified {
- logger.Debug(ctx, "Group Modified and IGMP report sent to the upstream server")
- igc.SendReport(false)
- }
- if err := igc.WriteToDb(cntx); err != nil {
- logger.Errorw(ctx, "Igmp group channel Write to DB failed", log.Fields{"mvlan": igc.Mvlan, "GroupAddr": igc.GroupAddr})
- }
- }
- }
- }
- }
-
- return true
- }
-
- if deviceID != "" {
- vd := GetApplication().GetDevice(deviceID)
- updateGroups(deviceID, vd)
- } else {
- GetApplication().DevicesDisc.Range(updateGroups)
- }
+ if deviceID != "" {
+ vd := GetApplication().GetDevice(deviceID)
+ updateGroups(deviceID, vd)
+ } else {
+ GetApplication().DevicesDisc.Range(updateGroups)
+ }
}
-//GroupsUpdated - Handles removing of Igmp Groups, flows & group table entries for
-//channels removed as part of update
+// GroupsUpdated - Handles removing of Igmp Groups, flows & group table entries for
+// channels removed as part of update
func (mvp *MvlanProfile) GroupsUpdated(cntx context.Context, deviceID string) {
+ deleteChannelIfRemoved := func(key interface{}, value interface{}) bool {
+ ig := value.(*IgmpGroup)
- deleteChannelIfRemoved := func(key interface{}, value interface{}) bool {
- ig := value.(*IgmpGroup)
+ if ig.Mvlan != mvp.Mvlan {
+ return true
+ }
+ grpName := ig.GroupName
+ logger.Infow(ctx, "###Update Cycle", log.Fields{"IG": ig.GroupName, "Addr": ig.GroupAddr})
+ // Check if group exists and remove the entire group object otherwise
+ if currentChannels := mvp.Groups[grpName]; currentChannels != nil {
+ if mvp.IsChannelBasedGroup {
+ channelPresent := doesIPMatch(ig.GroupAddr, currentChannels.McIPs)
+ if channelPresent || mvp.isChannelStatic(ig.GroupAddr) {
+ return true
+ }
+ } else {
+ allExistingChannels := ig.GetAllIgmpChannelForDevice(deviceID)
+ for channel := range allExistingChannels {
+ channelIP := net.ParseIP(channel)
+ channelPresent := mvp.IsChannelPresent(channelIP, currentChannels.McIPs, mvp.IsStaticGroup(ig.GroupName))
+ if channelPresent {
+ staticChannel := mvp.isChannelStatic(channelIP)
+ logger.Infow(ctx, "###Channel Comparison", log.Fields{"staticChannel": staticChannel, "Group": mvp.IsStaticGroup(ig.GroupName), "Channel": channel})
+ // Logic:
+ // If channel is Static & existing Group is also static - No migration required
+ // If channel is not Static & existing Group is also not static - No migration required
- if ig.Mvlan != mvp.Mvlan {
- return true
- }
- grpName := ig.GroupName
- logger.Infow(ctx, "###Update Cycle", log.Fields{"IG": ig.GroupName, "Addr": ig.GroupAddr})
- //Check if group exists and remove the entire group object otherwise
- if currentChannels := mvp.Groups[grpName]; currentChannels != nil {
+ // If channel is Static and existing Group is not static - Migrate (from dynamic to static)
+ // (Channel already part of dynamic, added to static)
- if mvp.IsChannelBasedGroup {
- channelPresent := doesIPMatch(ig.GroupAddr, currentChannels.McIPs)
- if channelPresent || mvp.isChannelStatic(ig.GroupAddr) {
- return true
- }
- } else {
- allExistingChannels := ig.GetAllIgmpChannelForDevice(deviceID)
- for channel := range allExistingChannels {
- channelIP := net.ParseIP(channel)
- channelPresent := mvp.IsChannelPresent(channelIP, currentChannels.McIPs, mvp.IsStaticGroup(ig.GroupName))
- if channelPresent {
- staticChannel := mvp.isChannelStatic(channelIP)
- logger.Infow(ctx, "###Channel Comparision", log.Fields{"staticChannel": staticChannel, "Group": mvp.IsStaticGroup(ig.GroupName), "Channel": channel})
- // Logic:
- // If channel is Static & existing Group is also static - No migration required
- // If channel is not Static & existing Group is also not static - No migration required
-
- // If channel is Static and existing Group is not static - Migrate (from dynamic to static)
- // (Channel already part of dynamic, added to static)
-
- // If channel is not Static but existing Group is static - Migrate (from static to dynamic)
- // (Channel removed from satic but part of dynamic)
- if (staticChannel != mvp.IsStaticGroup(ig.GroupName)) || (ig.IsGroupStatic != mvp.IsStaticGroup(ig.GroupName)) { // Equivalent of XOR
- ig.HandleGroupMigration(cntx, deviceID, channelIP)
- } else {
- if (ig.IsGroupStatic) && mvp.IsStaticGroup(ig.GroupName) {
- if ig.GroupName != mvp.GetStaticGroupName(channelIP) {
- ig.HandleGroupMigration(cntx, deviceID, channelIP)
- }
- }
- continue
- }
- } else {
- logger.Debugw(ctx, "Channel Removed", log.Fields{"Channel": channel, "Group": grpName})
- ig.DelIgmpChannel(cntx, deviceID, net.ParseIP(channel))
- if ig.NumDevicesActive() == 0 {
- GetApplication().DelIgmpGroup(cntx, ig)
- }
- }
- }
- ig.IsGroupStatic = mvp.IsStaticGroup(ig.GroupName)
- if err := ig.WriteToDb(cntx); err != nil {
- logger.Errorw(ctx, "Igmp group Write to DB failed", log.Fields{"groupName": ig.GroupName})
- }
- return true
- }
- }
- logger.Debugw(ctx, "Group Removed", log.Fields{"Channel": ig.GroupAddr, "Group": grpName, "ChannelBasedGroup": ig.IsChannelBasedGroup})
- ig.DelIgmpGroup(cntx)
- logger.Debugw(ctx, "Removed Igmp Group", log.Fields{"Channel": ig.GroupAddr, "Group": grpName})
- return true
- }
- GetApplication().IgmpGroups.Range(deleteChannelIfRemoved)
+ // If channel is not Static but existing Group is static - Migrate (from static to dynamic)
+ // (Channel removed from satic but part of dynamic)
+ if (staticChannel != mvp.IsStaticGroup(ig.GroupName)) || (ig.IsGroupStatic != mvp.IsStaticGroup(ig.GroupName)) { // Equivalent of XOR
+ ig.HandleGroupMigration(cntx, deviceID, channelIP)
+ } else {
+ if (ig.IsGroupStatic) && mvp.IsStaticGroup(ig.GroupName) {
+ if ig.GroupName != mvp.GetStaticGroupName(channelIP) {
+ ig.HandleGroupMigration(cntx, deviceID, channelIP)
+ }
+ }
+ continue
+ }
+ } else {
+ logger.Debugw(ctx, "Channel Removed", log.Fields{"Channel": channel, "Group": grpName})
+ ig.DelIgmpChannel(cntx, deviceID, net.ParseIP(channel))
+ if ig.NumDevicesActive() == 0 {
+ GetApplication().DelIgmpGroup(cntx, ig)
+ }
+ }
+ }
+ ig.IsGroupStatic = mvp.IsStaticGroup(ig.GroupName)
+ if err := ig.WriteToDb(cntx); err != nil {
+ logger.Errorw(ctx, "Igmp group Write to DB failed", log.Fields{"groupName": ig.GroupName})
+ }
+ return true
+ }
+ }
+ logger.Debugw(ctx, "Group Removed", log.Fields{"Channel": ig.GroupAddr, "Group": grpName, "ChannelBasedGroup": ig.IsChannelBasedGroup})
+ ig.DelIgmpGroup(cntx)
+ logger.Debugw(ctx, "Removed Igmp Group", log.Fields{"Channel": ig.GroupAddr, "Group": grpName})
+ return true
+ }
+ GetApplication().IgmpGroups.Range(deleteChannelIfRemoved)
}
// IsChannelPresent to check if channel is present
func (mvp *MvlanProfile) IsChannelPresent(channelIP net.IP, groupChannelList []string, IsStaticGroup bool) bool {
- // Only in case of static group, migration need to be supported.
- // Dynamic to dynamic group migration not supported currently
- if doesIPMatch(channelIP, groupChannelList) || mvp.isChannelStatic(channelIP) {
- return true
- } else if IsStaticGroup {
- return (mvp.GetMvlanGroup(channelIP) != "")
- }
+ // Only in case of static group, migration need to be supported.
+ // Dynamic to dynamic group migration not supported currently
+ if doesIPMatch(channelIP, groupChannelList) || mvp.isChannelStatic(channelIP) {
+ return true
+ } else if IsStaticGroup {
+ return (mvp.GetMvlanGroup(channelIP) != "")
+ }
- return false
+ return false
}
-
// GetMvlanGroup to get mvlan group
func (mvp *MvlanProfile) GetMvlanGroup(ip net.IP) string {
- //Check for Static Group First
- if mvp.containsStaticChannels() {
- grpName := mvp.GetStaticGroupName(ip)
- if grpName != "" {
- return grpName
- }
- }
+ // Check for Static Group First
+ if mvp.containsStaticChannels() {
+ grpName := mvp.GetStaticGroupName(ip)
+ if grpName != "" {
+ return grpName
+ }
+ }
- for _, mvg := range mvp.Groups {
- if mvg.Wildcard {
- return mvg.Name
- }
- if doesIPMatch(ip, mvg.McIPs) {
- return mvg.Name
- }
- }
- return ""
+ for _, mvg := range mvp.Groups {
+ if mvg.Wildcard {
+ return mvg.Name
+ }
+ if doesIPMatch(ip, mvg.McIPs) {
+ return mvg.Name
+ }
+ }
+ return ""
}
// ProcessStaticGroup - Process Static Join/Leave Req for static channels
func (mvp *MvlanProfile) ProcessStaticGroup(cntx context.Context, device string, groupAddresses []net.IP, isJoin bool) {
+ logger.Debugw(ctx, "Received Static Group Request", log.Fields{"Device": device, "Join": isJoin, "Group Address List": groupAddresses})
- logger.Debugw(ctx, "Received Static Group Request", log.Fields{"Device": device, "Join": isJoin, "Group Address List": groupAddresses})
+ mvlan := mvp.Mvlan
+ va := GetApplication()
- mvlan := mvp.Mvlan
- va := GetApplication()
+ // TODO - Handle bulk add of groupAddr
+ for _, groupAddr := range groupAddresses {
+ ig := mvp.GetStaticIgmpGroup(groupAddr)
+ if isJoin {
+ vd := va.GetDevice(device)
+ igmpProf, _, _ := getIgmpProxyCfgAndIP(mvlan, vd.SerialNum)
+ ver := igmpProf.IgmpVerToServer
- //TODO - Handle bulk add of groupAddr
- for _, groupAddr := range groupAddresses {
+ if ig == nil {
+ // First time group Creation: Create the IGMP group and then add the receiver to the group
+ logger.Infow(ctx, "Static IGMP Add received for new group", log.Fields{"Addr": groupAddr, "Port": StaticPort})
+ if ig = GetApplication().AddIgmpGroup(cntx, mvp.Name, groupAddr, device); ig != nil {
+ ig.IgmpGroupLock.Lock()
+ ig.AddReceiver(cntx, device, StaticPort, groupAddr, nil, getVersion(ver),
+ 0, 0, 0xFF)
+ ig.IgmpGroupLock.Unlock()
+ } else {
+ logger.Warnw(ctx, "Static IGMP Group Creation Failed", log.Fields{"Addr": groupAddr})
+ }
+ } else {
+ // Converting existing dynamic group to static group
+ if !mvp.IsStaticGroup(ig.GroupName) {
+ ig.updateGroupName(cntx, ig.GroupName)
+ }
+ // Update case: If the IGMP group is already created. just add the receiver
+ logger.Infow(ctx, "Static IGMP Add received for existing group", log.Fields{"Addr": groupAddr, "Port": StaticPort})
+ ig.IgmpGroupLock.Lock()
+ ig.AddReceiver(cntx, device, StaticPort, groupAddr, nil, getVersion(ver),
+ 0, 0, 0xFF)
+ ig.IgmpGroupLock.Unlock()
+ }
+ } else if ig != nil {
+ logger.Infow(ctx, "Static IGMP Del received for existing group", log.Fields{"Addr": groupAddr, "Port": StaticPort})
- ig := mvp.GetStaticIgmpGroup(groupAddr)
- if isJoin {
- vd := va.GetDevice(device)
- igmpProf, _, _ := getIgmpProxyCfgAndIP(mvlan, vd.SerialNum)
- ver := igmpProf.IgmpVerToServer
-
- if ig == nil {
- // First time group Creation: Create the IGMP group and then add the receiver to the group
- logger.Infow(ctx, "Static IGMP Add received for new group", log.Fields{"Addr": groupAddr, "Port": StaticPort})
- if ig := GetApplication().AddIgmpGroup(cntx, mvp.Name, groupAddr, device); ig != nil {
- ig.IgmpGroupLock.Lock()
- ig.AddReceiver(cntx, device, StaticPort, groupAddr, nil, getVersion(ver),
- 0, 0, 0xFF)
- ig.IgmpGroupLock.Unlock()
- } else {
- logger.Warnw(ctx, "Static IGMP Group Creation Failed", log.Fields{"Addr": groupAddr})
- }
- } else {
- //Converting existing dynamic group to static group
- if !mvp.IsStaticGroup(ig.GroupName) {
- ig.updateGroupName(cntx, ig.GroupName)
- }
- // Update case: If the IGMP group is already created. just add the receiver
- logger.Infow(ctx, "Static IGMP Add received for existing group", log.Fields{"Addr": groupAddr, "Port": StaticPort})
- ig.IgmpGroupLock.Lock()
- ig.AddReceiver(cntx, device, StaticPort, groupAddr, nil, getVersion(ver),
- 0, 0, 0xFF)
- ig.IgmpGroupLock.Unlock()
- }
- } else if ig != nil {
- logger.Infow(ctx, "Static IGMP Del received for existing group", log.Fields{"Addr": groupAddr, "Port": StaticPort})
-
- if ig.IsChannelBasedGroup {
- grpName := mvp.GetMvlanGroup(ig.GroupAddr)
- if grpName != "" {
- ig.IgmpGroupLock.Lock()
- ig.DelReceiver(cntx, device, StaticPort, groupAddr, nil, 0xFF)
- ig.IgmpGroupLock.Unlock()
- ig.updateGroupName(cntx, grpName)
- } else {
- ig.DelIgmpGroup(cntx)
- }
- } else {
- ig.IgmpGroupLock.Lock()
- ig.DelReceiver(cntx, device, StaticPort, groupAddr, nil, 0xFF)
- ig.IgmpGroupLock.Unlock()
- }
- if ig.NumDevicesActive() == 0 {
- GetApplication().DelIgmpGroup(cntx, ig)
- }
- } else {
- logger.Warnw(ctx, "Static IGMP Del received for unknown group", log.Fields{"Addr": groupAddr})
- }
- }
+ if ig.IsChannelBasedGroup {
+ grpName := mvp.GetMvlanGroup(ig.GroupAddr)
+ if grpName != "" {
+ ig.IgmpGroupLock.Lock()
+ ig.DelReceiver(cntx, device, StaticPort, groupAddr, nil, 0xFF)
+ ig.IgmpGroupLock.Unlock()
+ ig.updateGroupName(cntx, grpName)
+ } else {
+ ig.DelIgmpGroup(cntx)
+ }
+ } else {
+ ig.IgmpGroupLock.Lock()
+ ig.DelReceiver(cntx, device, StaticPort, groupAddr, nil, 0xFF)
+ ig.IgmpGroupLock.Unlock()
+ }
+ if ig.NumDevicesActive() == 0 {
+ GetApplication().DelIgmpGroup(cntx, ig)
+ }
+ } else {
+ logger.Warnw(ctx, "Static IGMP Del received for unknown group", log.Fields{"Addr": groupAddr})
+ }
+ }
}
-//getStaticChannelDiff - return the static channel newly added and removed from existing static group
+// getStaticChannelDiff - return the static channel newly added and removed from existing static group
func (mvp *MvlanProfile) getStaticChannelDiff() (newlyAdded []net.IP, removed []net.IP, common []net.IP) {
-
- var commonChannels []net.IP
- newChannelList, _ := mvp.getAllStaticChannels()
- existingChannelList, _ := mvp.getAllOldGroupStaticChannels()
- if len(existingChannelList) == 0 {
- return newChannelList, []net.IP{}, []net.IP{}
- }
- for _, newChannel := range append([]net.IP{}, newChannelList...) {
- for _, existChannel := range append([]net.IP{}, existingChannelList...) {
-
- //Remove common channels between existing and new list
- // The remaining in the below slices give the results
- // Remaining in newChannelList: Newly added
- // Remaining in existingChannelList: Removed channels
- if existChannel.Equal(newChannel) {
- existingChannelList = removeIPFromList(existingChannelList, existChannel)
- newChannelList = removeIPFromList(newChannelList, newChannel)
- commonChannels = append(commonChannels, newChannel)
- logger.Infow(ctx, "#############Channel: "+existChannel.String()+" New: "+newChannel.String(), log.Fields{"Added": newChannelList, "Removed": existingChannelList})
- break
- }
- }
- }
- return newChannelList, existingChannelList, commonChannels
+ var commonChannels []net.IP
+ newChannelList, _ := mvp.getAllStaticChannels()
+ existingChannelList, _ := mvp.getAllOldGroupStaticChannels()
+ if len(existingChannelList) == 0 {
+ return newChannelList, []net.IP{}, []net.IP{}
+ }
+ for _, newChannel := range append([]net.IP{}, newChannelList...) {
+ for _, existChannel := range append([]net.IP{}, existingChannelList...) {
+ // Remove common channels between existing and new list
+ // The remaining in the below slices give the results
+ // Remaining in newChannelList: Newly added
+ // Remaining in existingChannelList: Removed channels
+ if existChannel.Equal(newChannel) {
+ existingChannelList = removeIPFromList(existingChannelList, existChannel)
+ newChannelList = removeIPFromList(newChannelList, newChannel)
+ commonChannels = append(commonChannels, newChannel)
+ logger.Infow(ctx, "#############Channel: "+existChannel.String()+" New: "+newChannel.String(), log.Fields{"Added": newChannelList, "Removed": existingChannelList})
+ break
+ }
+ }
+ }
+ return newChannelList, existingChannelList, commonChannels
}
-//getGroupChannelDiff - return the channel newly added and removed from existing group
+// getGroupChannelDiff - return the channel newly added and removed from existing group
func (mvp *MvlanProfile) getGroupChannelDiff(newGroup *MvlanGroup, oldGroup *MvlanGroup) (newlyAdded []net.IP, removed []net.IP, common []net.IP) {
-
- var commonChannels []net.IP
- newChannelList, _ := newGroup.getAllChannels()
- existingChannelList, _ := oldGroup.getAllChannels()
- if len(existingChannelList) == 0 {
- return newChannelList, []net.IP{}, []net.IP{}
- }
- for _, newChannel := range append([]net.IP{}, newChannelList...) {
- for _, existChannel := range append([]net.IP{}, existingChannelList...) {
-
- //Remove common channels between existing and new list
- // The remaining in the below slices give the results
- // Remaining in newChannelList: Newly added
- // Remaining in existingChannelList: Removed channels
- if existChannel.Equal(newChannel) {
- existingChannelList = removeIPFromList(existingChannelList, existChannel)
- newChannelList = removeIPFromList(newChannelList, newChannel)
- commonChannels = append(commonChannels, newChannel)
- logger.Infow(ctx, "#############Channel: "+existChannel.String()+" New: "+newChannel.String(), log.Fields{"Added": newChannelList, "Removed": existingChannelList})
- break
- }
- }
- }
- return newChannelList, existingChannelList, commonChannels
+ var commonChannels []net.IP
+ newChannelList, _ := newGroup.getAllChannels()
+ existingChannelList, _ := oldGroup.getAllChannels()
+ if len(existingChannelList) == 0 {
+ return newChannelList, []net.IP{}, []net.IP{}
+ }
+ for _, newChannel := range append([]net.IP{}, newChannelList...) {
+ for _, existChannel := range append([]net.IP{}, existingChannelList...) {
+ // Remove common channels between existing and new list
+ // The remaining in the below slices give the results
+ // Remaining in newChannelList: Newly added
+ // Remaining in existingChannelList: Removed channels
+ if existChannel.Equal(newChannel) {
+ existingChannelList = removeIPFromList(existingChannelList, existChannel)
+ newChannelList = removeIPFromList(newChannelList, newChannel)
+ commonChannels = append(commonChannels, newChannel)
+ logger.Infow(ctx, "#############Channel: "+existChannel.String()+" New: "+newChannel.String(), log.Fields{"Added": newChannelList, "Removed": existingChannelList})
+ break
+ }
+ }
+ }
+ return newChannelList, existingChannelList, commonChannels
}
// UpdateProfile - Updates the group & member info w.r.t the mvlan profile for the given device
func (mvp *MvlanProfile) UpdateProfile(cntx context.Context, deviceID string) {
- logger.Infow(ctx, "Update Mvlan Profile task triggered", log.Fields{"Mvlan": mvp.Mvlan})
- var removedStaticChannels []net.IP
- addedStaticChannels := []net.IP{}
- /* Taking mvpLock to protect the mvp groups and proxy */
- mvp.mvpLock.RLock()
- defer mvp.mvpLock.RUnlock()
+ logger.Infow(ctx, "Update Mvlan Profile task triggered", log.Fields{"Mvlan": mvp.Mvlan})
+ var removedStaticChannels []net.IP
+ addedStaticChannels := []net.IP{}
+ /* Taking mvpLock to protect the mvp groups and proxy */
+ mvp.mvpLock.RLock()
+ defer mvp.mvpLock.RUnlock()
- serialNo := ""
- if deviceID != "" {
- if vd := GetApplication().GetDevice(deviceID); vd != nil {
- serialNo = vd.SerialNum
- if mvp.DevicesList[serialNo] != UpdateInProgress {
- logger.Warnw(ctx, "Exiting Update Task since device not present in MvlanProfile", log.Fields{"Device": deviceID, "SerialNum": vd.SerialNum, "MvlanProfile": mvp})
- return
- }
- } else {
- logger.Errorw(ctx, "Volt Device not found. Stopping Update Mvlan Profile processing for device", log.Fields{"SerialNo": deviceID, "MvlanProfile": mvp})
- return
- }
- }
+ serialNo := ""
+ if deviceID != "" {
+ if vd := GetApplication().GetDevice(deviceID); vd != nil {
+ serialNo = vd.SerialNum
+ if mvp.DevicesList[serialNo] != UpdateInProgress {
+ logger.Warnw(ctx, "Exiting Update Task since device not present in MvlanProfile", log.Fields{"Device": deviceID, "SerialNum": vd.SerialNum, "MvlanProfile": mvp})
+ return
+ }
+ } else {
+ logger.Errorw(ctx, "Volt Device not found. Stopping Update Mvlan Profile processing for device", log.Fields{"SerialNo": deviceID, "MvlanProfile": mvp})
+ return
+ }
+ }
- //Update the groups based on static channels added & removed
- if mvp.containsStaticChannels() {
- addedStaticChannels, removedStaticChannels, _ = mvp.getStaticChannelDiff()
- logger.Debugw(ctx, "Update Task - Static Group Changes", log.Fields{"Added": addedStaticChannels, "Removed": removedStaticChannels})
+ // Update the groups based on static channels added & removed
+ if mvp.containsStaticChannels() {
+ addedStaticChannels, removedStaticChannels, _ = mvp.getStaticChannelDiff()
+ logger.Debugw(ctx, "Update Task - Static Group Changes", log.Fields{"Added": addedStaticChannels, "Removed": removedStaticChannels})
- if len(addedStaticChannels) > 0 || len(removedStaticChannels) > 0 {
- mvp.updateStaticGroups(cntx, deviceID, []net.IP{}, removedStaticChannels)
- }
- }
- mvp.GroupsUpdated(cntx, deviceID)
- if len(addedStaticChannels) > 0 {
- mvp.updateStaticGroups(cntx, deviceID, addedStaticChannels, []net.IP{})
- }
+ if len(addedStaticChannels) > 0 || len(removedStaticChannels) > 0 {
+ mvp.updateStaticGroups(cntx, deviceID, []net.IP{}, removedStaticChannels)
+ }
+ }
+ mvp.GroupsUpdated(cntx, deviceID)
+ if len(addedStaticChannels) > 0 {
+ mvp.updateStaticGroups(cntx, deviceID, addedStaticChannels, []net.IP{})
+ }
- /* Need to handle if SSM params are modified for groups */
- for key := range mvp.Groups {
- _, _, commonChannels := mvp.getGroupChannelDiff(mvp.Groups[key], mvp.oldGroups[key])
- if mvp.checkStaticGrpSSMProxyDiff(mvp.oldProxy[key], mvp.Proxy[key]) {
- if mvp.Groups[key].IsStatic {
- /* Static group proxy modified, need to trigger membership report with new mode/src-list for existing channels */
- mvp.updateStaticGroups(cntx, deviceID, commonChannels, []net.IP{})
- } else {
- /* Dynamic group proxy modified, need to trigger membership report with new mode/src-list for existing channels */
- mvp.updateDynamicGroups(cntx, deviceID, commonChannels, []net.IP{})
- }
- }
- }
+ /* Need to handle if SSM params are modified for groups */
+ for key := range mvp.Groups {
+ _, _, commonChannels := mvp.getGroupChannelDiff(mvp.Groups[key], mvp.oldGroups[key])
+ if mvp.checkStaticGrpSSMProxyDiff(mvp.oldProxy[key], mvp.Proxy[key]) {
+ if mvp.Groups[key].IsStatic {
+ /* Static group proxy modified, need to trigger membership report with new mode/src-list for existing channels */
+ mvp.updateStaticGroups(cntx, deviceID, commonChannels, []net.IP{})
+ } else {
+ /* Dynamic group proxy modified, need to trigger membership report with new mode/src-list for existing channels */
+ mvp.updateDynamicGroups(cntx, deviceID, commonChannels, []net.IP{})
+ }
+ }
+ }
- mvp.SetUpdateStatus(serialNo, NoOp)
+ mvp.SetUpdateStatus(serialNo, NoOp)
- if deviceID == "" || !mvp.isUpdateInProgress() {
- mvp.oldGroups = nil
- }
- if err := mvp.WriteToDb(cntx); err != nil {
- logger.Errorw(ctx, "Mvlan profile write to DB failed", log.Fields{"ProfileName": mvp.Name})
- }
- logger.Debugw(ctx, "Updated MVLAN Profile", log.Fields{"VLAN": mvp.Mvlan, "Name": mvp.Name, "Grp IPs": mvp.Groups})
+ if deviceID == "" || !mvp.isUpdateInProgress() {
+ mvp.oldGroups = nil
+ }
+ if err := mvp.WriteToDb(cntx); err != nil {
+ logger.Errorw(ctx, "Mvlan profile write to DB failed", log.Fields{"ProfileName": mvp.Name})
+ }
+ logger.Debugw(ctx, "Updated MVLAN Profile", log.Fields{"VLAN": mvp.Mvlan, "Name": mvp.Name, "Grp IPs": mvp.Groups})
}
-//checkStaticGrpSSMProxyDiff- return true if the proxy of oldGroup is modified in newGroup
+// checkStaticGrpSSMProxyDiff- return true if the proxy of oldGroup is modified in newGroup
func (mvp *MvlanProfile) checkStaticGrpSSMProxyDiff(oldProxy *MCGroupProxy, newProxy *MCGroupProxy) bool {
+ if oldProxy == nil && newProxy == nil {
+ return false
+ }
+ if (oldProxy == nil && newProxy != nil) ||
+ (oldProxy != nil && newProxy == nil) {
+ return true
+ }
- if oldProxy == nil && newProxy == nil {
- return false
- }
- if (oldProxy == nil && newProxy != nil) ||
- (oldProxy != nil && newProxy == nil) {
- return true
- }
+ if oldProxy.Mode != newProxy.Mode {
+ return true
+ }
- if oldProxy.Mode != newProxy.Mode {
- return true
- }
+ oldSrcLst := oldProxy.SourceList
+ newSrcLst := newProxy.SourceList
+ oLen := len(oldSrcLst)
+ nLen := len(newSrcLst)
+ if oLen != nLen {
+ return true
+ }
- oldSrcLst := oldProxy.SourceList
- newSrcLst := newProxy.SourceList
- oLen := len(oldSrcLst)
- nLen := len(newSrcLst)
- if oLen != nLen {
- return true
- }
+ visited := make([]bool, nLen)
- visited := make([]bool, nLen)
+ /* check if any new IPs added in the src list, return true if present */
+ for i := 0; i < nLen; i++ {
+ found := false
+ element := newSrcLst[i]
+ for j := 0; j < oLen; j++ {
+ if visited[j] {
+ continue
+ }
+ if element.Equal(oldSrcLst[j]) {
+ visited[j] = true
+ found = true
+ break
+ }
+ }
+ if !found {
+ return true
+ }
+ }
- /* check if any new IPs added in the src list, return true if present */
- for i := 0; i < nLen; i++ {
- found := false
- element := newSrcLst[i]
- for j := 0; j < oLen; j++ {
- if visited[j] {
- continue
- }
- if element.Equal(oldSrcLst[j]) {
- visited[j] = true
- found = true
- break
- }
- }
- if !found {
- return true
- }
- }
-
- visited = make([]bool, nLen)
- /* check if any IPs removed from existing src list, return true if removed */
- for i := 0; i < oLen; i++ {
- found := false
- element := oldSrcLst[i]
- for j := 0; j < nLen; j++ {
- if visited[j] {
- continue
- }
- if element.Equal(newSrcLst[j]) {
- visited[j] = true
- found = true
- break
- }
- }
- if !found {
- return true
- }
- }
- return false
+ visited = make([]bool, nLen)
+ /* check if any IPs removed from existing src list, return true if removed */
+ for i := 0; i < oLen; i++ {
+ found := false
+ element := oldSrcLst[i]
+ for j := 0; j < nLen; j++ {
+ if visited[j] {
+ continue
+ }
+ if element.Equal(newSrcLst[j]) {
+ visited[j] = true
+ found = true
+ break
+ }
+ }
+ if !found {
+ return true
+ }
+ }
+ return false
}
-
-//UpdateActiveChannelSubscriberAlarm - Updates the Active Channel Subscriber Alarm
+// UpdateActiveChannelSubscriberAlarm - Updates the Active Channel Subscriber Alarm
func (mvp *MvlanProfile) UpdateActiveChannelSubscriberAlarm() {
- va := GetApplication()
- logger.Debugw(ctx, "Update of Active Channel Subscriber Alarm", log.Fields{"Mvlan": mvp.Mvlan})
- for srNo := range mvp.DevicesList {
- d, _ := va.GetDeviceBySerialNo(srNo)
- if d == nil {
- logger.Warnw(ctx, "Device info not found", log.Fields{"Device_SrNo": srNo, "Mvlan": mvp.Mvlan})
- return
- }
- d.Ports.Range(func(key, value interface{}) bool {
- //port := key.(string)
- vp := value.(*VoltPort)
- if vp.Type != VoltPortTypeAccess {
- return true
- }
- if mvp.MaxActiveChannels > vp.ActiveChannels && vp.ChannelPerSubAlarmRaised {
- serviceName := GetMcastServiceForSubAlarm(vp, mvp)
- logger.Debugw(ctx, "Clearing-SendActiveChannelPerSubscriberAlarm-due-to-update", log.Fields{"ActiveChannels": vp.ActiveChannels, "ServiceName": serviceName})
- vp.ChannelPerSubAlarmRaised = false
- } else if mvp.MaxActiveChannels < vp.ActiveChannels && !vp.ChannelPerSubAlarmRaised {
- /* When the max active channel count is reduced via update, we raise an alarm.
- But the previous excess channels still exist until a leave or expiry */
- serviceName := GetMcastServiceForSubAlarm(vp, mvp)
- logger.Debugw(ctx, "Raising-SendActiveChannelPerSubscriberAlarm-due-to-update", log.Fields{"ActiveChannels": vp.ActiveChannels, "ServiceName": serviceName})
- vp.ChannelPerSubAlarmRaised = true
- }
- return true
- })
- }
+ va := GetApplication()
+ logger.Debugw(ctx, "Update of Active Channel Subscriber Alarm", log.Fields{"Mvlan": mvp.Mvlan})
+ for srNo := range mvp.DevicesList {
+ d, _ := va.GetDeviceBySerialNo(srNo)
+ if d == nil {
+ logger.Warnw(ctx, "Device info not found", log.Fields{"Device_SrNo": srNo, "Mvlan": mvp.Mvlan})
+ return
+ }
+ d.Ports.Range(func(key, value interface{}) bool {
+ //port := key.(string)
+ vp := value.(*VoltPort)
+ if vp.Type != VoltPortTypeAccess {
+ return true
+ }
+ if mvp.MaxActiveChannels > vp.ActiveChannels && vp.ChannelPerSubAlarmRaised {
+ serviceName := GetMcastServiceForSubAlarm(vp, mvp)
+ logger.Debugw(ctx, "Clearing-SendActiveChannelPerSubscriberAlarm-due-to-update", log.Fields{"ActiveChannels": vp.ActiveChannels, "ServiceName": serviceName})
+ vp.ChannelPerSubAlarmRaised = false
+ } else if mvp.MaxActiveChannels < vp.ActiveChannels && !vp.ChannelPerSubAlarmRaised {
+ /* When the max active channel count is reduced via update, we raise an alarm.
+ But the previous excess channels still exist until a leave or expiry */
+ serviceName := GetMcastServiceForSubAlarm(vp, mvp)
+ logger.Debugw(ctx, "Raising-SendActiveChannelPerSubscriberAlarm-due-to-update", log.Fields{"ActiveChannels": vp.ActiveChannels, "ServiceName": serviceName})
+ vp.ChannelPerSubAlarmRaised = true
+ }
+ return true
+ })
+ }
}
-//TriggerAssociatedFlowDelete - Re-trigger delete for pending delete flows
+// TriggerAssociatedFlowDelete - Re-trigger delete for pending delete flows
func (mvp *MvlanProfile) TriggerAssociatedFlowDelete(cntx context.Context, device string) bool {
- mvp.mvpFlowLock.Lock()
+ mvp.mvpFlowLock.Lock()
- cookieList := []uint64{}
- flowMap := mvp.PendingDeleteFlow[device]
+ cookieList := []uint64{}
+ flowMap := mvp.PendingDeleteFlow[device]
- for cookie := range flowMap {
- cookieList = append(cookieList, convertToUInt64(cookie))
- }
- mvp.mvpFlowLock.Unlock()
+ for cookie := range flowMap {
+ cookieList = append(cookieList, convertToUInt64(cookie))
+ }
+ mvp.mvpFlowLock.Unlock()
- if len(cookieList) == 0 {
- return false
- }
+ if len(cookieList) == 0 {
+ return false
+ }
- for _, cookie := range cookieList {
- if vd := GetApplication().GetDevice(device); vd != nil {
- flow := &of.VoltFlow{}
- flow.SubFlows = make(map[uint64]*of.VoltSubFlow)
- subFlow := of.NewVoltSubFlow()
- subFlow.Cookie = cookie
- flow.SubFlows[cookie] = subFlow
- logger.Infow(ctx, "Retriggering Vnet Delete Flow", log.Fields{"Device": device, "Mvlan": mvp.Mvlan.String(), "Cookie": cookie})
- err := mvp.DelFlows(cntx, vd, flow)
- if err != nil {
- logger.Warnw(ctx, "De-Configuring IGMP Flow for device failed ", log.Fields{"Device": device, "err": err})
- }
- }
- }
- return true
+ for _, cookie := range cookieList {
+ if vd := GetApplication().GetDevice(device); vd != nil {
+ flow := &of.VoltFlow{}
+ flow.SubFlows = make(map[uint64]*of.VoltSubFlow)
+ subFlow := of.NewVoltSubFlow()
+ subFlow.Cookie = cookie
+ flow.SubFlows[cookie] = subFlow
+ logger.Infow(ctx, "Retriggering Vnet Delete Flow", log.Fields{"Device": device, "Mvlan": mvp.Mvlan.String(), "Cookie": cookie})
+ err := mvp.DelFlows(cntx, vd, flow)
+ if err != nil {
+ logger.Warnw(ctx, "De-Configuring IGMP Flow for device failed ", log.Fields{"Device": device, "err": err})
+ }
+ }
+ }
+ return true
}
-// JsonMarshal wrapper function for json Marshal MvlanProfile
-func (mvp *MvlanProfile) JsonMarshal() ([]byte, error) {
- return json.Marshal(MvlanProfile{
- Name: mvp.Name,
- Mvlan: mvp.Mvlan,
- PonVlan: mvp.PonVlan,
- Groups: mvp.Groups,
- Proxy: mvp.Proxy,
- Version: mvp.Version,
- IsPonVlanPresent: mvp.IsPonVlanPresent,
- IsChannelBasedGroup: mvp.IsChannelBasedGroup,
- DevicesList: mvp.DevicesList,
- MaxActiveChannels: mvp.MaxActiveChannels,
- PendingDeleteFlow: mvp.PendingDeleteFlow,
- DeleteInProgress: mvp.DeleteInProgress,
- IgmpServVersion: mvp.IgmpServVersion,
- })
+// JSONMarshal wrapper function for json Marshal MvlanProfile
+func (mvp *MvlanProfile) JSONMarshal() ([]byte, error) {
+ return json.Marshal(MvlanProfile{
+ Name: mvp.Name,
+ Mvlan: mvp.Mvlan,
+ PonVlan: mvp.PonVlan,
+ Groups: mvp.Groups,
+ Proxy: mvp.Proxy,
+ Version: mvp.Version,
+ IsPonVlanPresent: mvp.IsPonVlanPresent,
+ IsChannelBasedGroup: mvp.IsChannelBasedGroup,
+ DevicesList: mvp.DevicesList,
+ MaxActiveChannels: mvp.MaxActiveChannels,
+ PendingDeleteFlow: mvp.PendingDeleteFlow,
+ DeleteInProgress: mvp.DeleteInProgress,
+ IgmpServVersion: mvp.IgmpServVersion,
+ })
}
// removeIPFromList to remove ip from the list
func removeIPFromList(s []net.IP, value net.IP) []net.IP {
- i := 0
- for i = 0; i < len(s); i++ {
- if s[i].Equal(value) {
- break
- }
- }
- if i != len(s) {
- //It means value is found in the slice
- return append(s[0:i], s[i+1:]...)
- }
- return s
+ i := 0
+ for i = 0; i < len(s); i++ {
+ if s[i].Equal(value) {
+ break
+ }
+ }
+ if i != len(s) {
+ //It means value is found in the slice
+ return append(s[0:i], s[i+1:]...)
+ }
+ return s
}
// doesIPMatch to check if ip match with any ip from the list
func doesIPMatch(ip net.IP, ipsOrRange []string) bool {
- for _, ipOrRange := range ipsOrRange {
- if strings.Contains(ipOrRange, "-") {
- var splits = strings.Split(ipOrRange, "-")
- ipStart := util.IP2LongConv(net.ParseIP(splits[0]))
- ipEnd := util.IP2LongConv(net.ParseIP(splits[1]))
- if ipEnd < ipStart {
- return false
- }
- ipInt := util.IP2LongConv(ip)
- if ipInt >= ipStart && ipInt <= ipEnd {
- return true
- }
- } else if ip.Equal(net.ParseIP(ipOrRange)) {
- return true
- }
- }
- return false
+ for _, ipOrRange := range ipsOrRange {
+ if strings.Contains(ipOrRange, "-") {
+ var splits = strings.Split(ipOrRange, "-")
+ ipStart := util.IP2LongConv(net.ParseIP(splits[0]))
+ ipEnd := util.IP2LongConv(net.ParseIP(splits[1]))
+ if ipEnd < ipStart {
+ return false
+ }
+ ipInt := util.IP2LongConv(ip)
+ if ipInt >= ipStart && ipInt <= ipEnd {
+ return true
+ }
+ } else if ip.Equal(net.ParseIP(ipOrRange)) {
+ return true
+ }
+ }
+ return false
}
// IgmpProfile structure
type IgmpProfile struct {
- ProfileID string
- UnsolicitedTimeOut uint32 //In seconds
- MaxResp uint32
- KeepAliveInterval uint32
- KeepAliveCount uint32
- LastQueryInterval uint32
- LastQueryCount uint32
- FastLeave bool
- PeriodicQuery bool
- IgmpCos uint8
- WithRAUpLink bool
- WithRADownLink bool
- IgmpVerToServer string
- IgmpSourceIP net.IP
- Version string
+ ProfileID string
+ IgmpVerToServer string
+ Version string
+ IgmpSourceIP net.IP
+ UnsolicitedTimeOut uint32 //In seconds
+ MaxResp uint32
+ KeepAliveInterval uint32
+ KeepAliveCount uint32
+ LastQueryInterval uint32
+ LastQueryCount uint32
+ IgmpCos uint8
+ FastLeave bool
+ PeriodicQuery bool
+ WithRAUpLink bool
+ WithRADownLink bool
}
func newIgmpProfile(igmpProfileConfig *common.IGMPConfig) *IgmpProfile {
- var igmpProfile IgmpProfile
- igmpProfile.ProfileID = igmpProfileConfig.ProfileID
- igmpProfile.UnsolicitedTimeOut = uint32(igmpProfileConfig.UnsolicitedTimeOut)
- igmpProfile.MaxResp = uint32(igmpProfileConfig.MaxResp)
+ var igmpProfile IgmpProfile
+ igmpProfile.ProfileID = igmpProfileConfig.ProfileID
+ igmpProfile.UnsolicitedTimeOut = uint32(igmpProfileConfig.UnsolicitedTimeOut)
+ igmpProfile.MaxResp = uint32(igmpProfileConfig.MaxResp)
- keepAliveInterval := uint32(igmpProfileConfig.KeepAliveInterval)
+ keepAliveInterval := uint32(igmpProfileConfig.KeepAliveInterval)
- //KeepAliveInterval should have a min of 10 seconds
- if keepAliveInterval < MinKeepAliveInterval {
- keepAliveInterval = MinKeepAliveInterval
- logger.Infow(ctx, "Auto adjust keepAliveInterval - Value < 10", log.Fields{"Received": igmpProfileConfig.KeepAliveInterval, "Configured": keepAliveInterval})
- }
- igmpProfile.KeepAliveInterval = keepAliveInterval
+ //KeepAliveInterval should have a min of 10 seconds
+ if keepAliveInterval < MinKeepAliveInterval {
+ keepAliveInterval = MinKeepAliveInterval
+ logger.Infow(ctx, "Auto adjust keepAliveInterval - Value < 10", log.Fields{"Received": igmpProfileConfig.KeepAliveInterval, "Configured": keepAliveInterval})
+ }
+ igmpProfile.KeepAliveInterval = keepAliveInterval
- igmpProfile.KeepAliveCount = uint32(igmpProfileConfig.KeepAliveCount)
- igmpProfile.LastQueryInterval = uint32(igmpProfileConfig.LastQueryInterval)
- igmpProfile.LastQueryCount = uint32(igmpProfileConfig.LastQueryCount)
- igmpProfile.FastLeave = *igmpProfileConfig.FastLeave
- igmpProfile.PeriodicQuery = *igmpProfileConfig.PeriodicQuery
- igmpProfile.IgmpCos = uint8(igmpProfileConfig.IgmpCos)
- igmpProfile.WithRAUpLink = *igmpProfileConfig.WithRAUpLink
- igmpProfile.WithRADownLink = *igmpProfileConfig.WithRADownLink
+ igmpProfile.KeepAliveCount = uint32(igmpProfileConfig.KeepAliveCount)
+ igmpProfile.LastQueryInterval = uint32(igmpProfileConfig.LastQueryInterval)
+ igmpProfile.LastQueryCount = uint32(igmpProfileConfig.LastQueryCount)
+ igmpProfile.FastLeave = *igmpProfileConfig.FastLeave
+ igmpProfile.PeriodicQuery = *igmpProfileConfig.PeriodicQuery
+ igmpProfile.IgmpCos = uint8(igmpProfileConfig.IgmpCos)
+ igmpProfile.WithRAUpLink = *igmpProfileConfig.WithRAUpLink
+ igmpProfile.WithRADownLink = *igmpProfileConfig.WithRADownLink
- if igmpProfileConfig.IgmpVerToServer == "2" || igmpProfileConfig.IgmpVerToServer == "v2" {
- igmpProfile.IgmpVerToServer = "2"
- } else {
- igmpProfile.IgmpVerToServer = "3"
- }
- igmpProfile.IgmpSourceIP = net.ParseIP(igmpProfileConfig.IgmpSourceIP)
+ if igmpProfileConfig.IgmpVerToServer == "2" || igmpProfileConfig.IgmpVerToServer == "v2" {
+ igmpProfile.IgmpVerToServer = "2"
+ } else {
+ igmpProfile.IgmpVerToServer = "3"
+ }
+ igmpProfile.IgmpSourceIP = net.ParseIP(igmpProfileConfig.IgmpSourceIP)
- return &igmpProfile
+ return &igmpProfile
}
// newDefaultIgmpProfile Igmp profiles with default values
func newDefaultIgmpProfile() *IgmpProfile {
- return &IgmpProfile{
- ProfileID: DefaultIgmpProfID,
- UnsolicitedTimeOut: 60,
- MaxResp: 10, // seconds
- KeepAliveInterval: 60, // seconds
- KeepAliveCount: 3, // TODO - May not be needed
- LastQueryInterval: 0, // TODO - May not be needed
- LastQueryCount: 0, // TODO - May not be needed
- FastLeave: true,
- PeriodicQuery: false, // TODO - May not be needed
- IgmpCos: 7, //p-bit value included in the IGMP packet
- WithRAUpLink: false, // TODO - May not be needed
- WithRADownLink: false, // TODO - May not be needed
- IgmpVerToServer: "3",
- IgmpSourceIP: net.ParseIP("172.27.0.1"), // This will be replaced by configuration
- }
+ return &IgmpProfile{
+ ProfileID: DefaultIgmpProfID,
+ UnsolicitedTimeOut: 60,
+ MaxResp: 10, // seconds
+ KeepAliveInterval: 60, // seconds
+ KeepAliveCount: 3, // TODO - May not be needed
+ LastQueryInterval: 0, // TODO - May not be needed
+ LastQueryCount: 0, // TODO - May not be needed
+ FastLeave: true,
+ PeriodicQuery: false, // TODO - May not be needed
+ IgmpCos: 7, //p-bit value included in the IGMP packet
+ WithRAUpLink: false, // TODO - May not be needed
+ WithRADownLink: false, // TODO - May not be needed
+ IgmpVerToServer: "3",
+ IgmpSourceIP: net.ParseIP("172.27.0.1"), // This will be replaced by configuration
+ }
}
// WriteToDb is utility to write Igmp Config Info to database
func (igmpProfile *IgmpProfile) WriteToDb(cntx context.Context) error {
- igmpProfile.Version = database.PresentVersionMap[database.IgmpProfPath]
- b, err := json.Marshal(igmpProfile)
- if err != nil {
- return err
- }
- if err1 := db.PutIgmpProfile(cntx, igmpProfile.ProfileID, string(b)); err1 != nil {
- return err1
- }
- return nil
+ igmpProfile.Version = database.PresentVersionMap[database.IgmpProfPath]
+ b, err := json.Marshal(igmpProfile)
+ if err != nil {
+ return err
+ }
+ if err1 := db.PutIgmpProfile(cntx, igmpProfile.ProfileID, string(b)); err1 != nil {
+ return err1
+ }
+ return nil
}