internal/pkg/application/dhcpserverhandler.go - voltha-go-controller - Gitiles

 /*
 * Copyright 2022-present Open Networking Foundation
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * 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

 import (
 	"sync"
 	"time"

 	"voltha-go-controller/log"
 )

 const (
 	dhcpTimeout uint8 = 60
 )

 // done channel required to gracefully stop dhcp server handler thread
 var done = make(chan bool)

 // dhcpServerInfo map having dhcp network as key and dhcp request response transaction as value
 var dhcpServerInfo map[dhcpServerTag]dhcpTransactionInfo

 // alarmsRaised is struct having array of dhcp network for which dhcp unreachable alarm raised
 var alarmsRaised alarmsRaisedInfo

 // mux is mutex variable used for lock unlock
 var mux sync.Mutex

 // StartDhcpServerHandler starts go routine periodically(every second) to verify DHCP server reachability.
 func StartDhcpServerHandler() {
 	// Intialize global dhcp map and ticker as one second
 	dhcpServerInfo = make(map[dhcpServerTag]dhcpTransactionInfo)
 	ticker := time.NewTicker(1 * time.Second)

 	// go routine runs checkDhcpTimeout every second and exit if done value is set.
 	go func() {
 		for {
 			select {
 			case <-done:
 				ticker.Stop()
 				return
 			case <-ticker.C:
 				mux.Lock()
 				checkDhcpTimeout()
 				mux.Unlock()

 			}
 		}
 	}()
 }

 // checkDhcpTimeout method called every second to verify dhcp timeout for each DHCP network
 func checkDhcpTimeout() {
 	// logger.Debugw(ctx, "[dhcptimeout] DHCP MAP Info", log.Fields{"Map": dhcpServerInfo})
 	for dsTag, dtInfo := range dhcpServerInfo {
 		dtInfo.decrementTimer()
 		if dtInfo.getTimer() == 0 {
 			logger.Debugw(ctx, "[dhcptimeout]Timer Expired", log.Fields{"ctag": dsTag.cTag, "stag": dsTag.sTag})
 			if dtInfo.getReceivedResponseCount() == 0 && !alarmsRaised.isexist(dsTag) {
 				alarmsRaised.add(dsTag)
 				logger.Infow(ctx, "Alarms Raised", log.Fields{"ctag": dsTag.cTag, "stag": dsTag.sTag})
 			}

 			// Reset helps in
 			// case 1: when 2 requests, 1 response received within timeout interval.
 			// case 2: 1 request and no response even after timeout. (Unreachable alarm raised)
 			// In both cases, reset method provides additional timeout to receive response before deleting
 			dtInfo.resetRequestResponseCount(dhcpTimeout)

 			// Delete dhcp entry in map and continue to process next entry if pending request set to 0
 			if dtInfo.getPendingRequestCount() == 0 {
 				delete(dhcpServerInfo, dsTag)
 				logger.Debugw(ctx, "[dhcptimeout]DhcpServerTag info removed", log.Fields{"ctag": dsTag.cTag, "stag": dsTag.sTag})
 				// logger.Debugw(ctx, "[dhcptimeout] DHCP MAP Info", log.Fields{"Map": dhcpServerInfo})
 				continue
 			}
 		}
 		// Update decremented timer value and continue loop
 		dhcpServerInfo[dsTag] = dtInfo
 	}
 }

 // dhcpRequestReceived called for every DHCP request received from client.
 func dhcpRequestReceived(cTag, sTag uint16, smac string) {
 	var dtInfo dhcpTransactionInfo
 	var valueExist bool
 	dsTag := newDhcpServerTag(cTag, sTag)

 	mux.Lock()
 	logger.Debugw(ctx, "dhcpRequestReceived", log.Fields{"ctag": cTag, "stag": sTag, "smac": smac})
 	if dtInfo, valueExist = dhcpServerInfo[dsTag]; !valueExist {
 		dtInfo = newDhcpTransactionInfo(dhcpTimeout, smac)
 		dtInfo.incrementPendingRequestCount()
 	}

 	// Source mac received in dhcp request is not same as dtInfo mac then
 	// Its new subscriber request, hence increment pending request count.
 	// If multiple dhcp request received with same mac are ignored.
 	if dtInfo.smac != smac {
 		dtInfo.incrementPendingRequestCount()
 	}

 	dhcpServerInfo[dsTag] = dtInfo
 	mux.Unlock()
 }

 // dhcpResponseReceived called for every DHCP response received from dhcp server.
 func dhcpResponseReceived(cTag, sTag uint16) {
 	var dtInfo dhcpTransactionInfo
 	var valueExist bool
 	dsTag := newDhcpServerTag(cTag, sTag)

 	mux.Lock()
 	logger.Debugw(ctx, "dhcpResponseReceived", log.Fields{"ctag": cTag, "stag": sTag})
 	if dtInfo, valueExist = dhcpServerInfo[dsTag]; !valueExist {
 		logger.Warnw(ctx, "Ignore unknown response", log.Fields{"DhcpResp": dsTag})
 		mux.Unlock()
 		return
 	}

 	// If already unreachable alarm raised, clear and remove from array
 	if alarmsRaised.isexist(dsTag) {
 		alarmsRaised.remove(dsTag)
 		logger.Infow(ctx, "Alarm Cleared", log.Fields{"ctag": dsTag.cTag, "stag": dsTag.sTag})
 	}

 	// Increments received count and decrement pending count
 	dtInfo.responseReceived()
 	logger.Debugw(ctx, "Updated dtInfo", log.Fields{"pendingReq": dtInfo.pendingRequestCount, "receivedReq": dtInfo.receivedResponseCount})

 	if dtInfo.getPendingRequestCount() == 0 {
 		delete(dhcpServerInfo, dsTag)
 	} else {
 		dhcpServerInfo[dsTag] = dtInfo
 	}
 	mux.Unlock()
 }

 // StopDhcpServerHandler stops dhcp server handler go routine
 func StopDhcpServerHandler() {
 	done <- true
 }

 // dhcpServerTag contains unique dhcp network information
 type dhcpServerTag struct {
 	sTag uint16
 	cTag uint16
 }

 func newDhcpServerTag(cTag, sTag uint16) dhcpServerTag {
 	var d dhcpServerTag
 	d.sTag = sTag
 	d.cTag = cTag
 	return d
 }

 // dhcpTransactionInfo contains DHCP request response transaction information.
 type dhcpTransactionInfo struct {
 	timer                 uint8
 	pendingRequestCount   uint32
 	receivedResponseCount uint32
 	previousRequestCount  uint32
 	smac                  string
 }

 func newDhcpTransactionInfo(timer uint8, smac string) dhcpTransactionInfo {
 	var dt dhcpTransactionInfo
 	dt.timer = timer
 	dt.smac = smac
 	return dt
 }

 func (dt *dhcpTransactionInfo) getTimer() uint8 {
 	return dt.timer
 }

 func (dt *dhcpTransactionInfo) decrementTimer() uint8 {
 	dt.timer--
 	return dt.timer
 }

 func (dt *dhcpTransactionInfo) getPendingRequestCount() uint32 {
 	return dt.pendingRequestCount
 }

 func (dt *dhcpTransactionInfo) incrementPendingRequestCount() {
 	dt.pendingRequestCount++
 }

 func (dt *dhcpTransactionInfo) getReceivedResponseCount() uint32 {
 	return dt.receivedResponseCount
 }

 func (dt *dhcpTransactionInfo) responseReceived() {
 	dt.receivedResponseCount++
 	dt.pendingRequestCount--
 }

 func (dt *dhcpTransactionInfo) resetRequestResponseCount(timer uint8) {
 	if dt.pendingRequestCount >= dt.previousRequestCount {
 		dt.pendingRequestCount = dt.pendingRequestCount - dt.previousRequestCount
 	}
 	dt.previousRequestCount = dt.pendingRequestCount
 	dt.receivedResponseCount = 0
 	dt.timer = timer
 }

 // alarmsRaisedInfo contains the all networks alarm raised information
 type alarmsRaisedInfo struct {
 	arrayInfo []dhcpServerTag
 }

 // add an entry into alarm raised array
 func (a *alarmsRaisedInfo) add(val dhcpServerTag) {
 	a.arrayInfo = append(a.arrayInfo, val)
 }

 // isexist check if entry exist in alarm raised array
 func (a *alarmsRaisedInfo) isexist(val dhcpServerTag) bool {
 	for _, srvTag := range a.arrayInfo {
 		if srvTag == val {
 			return true
 		}
 	}
 	return false
 }

 // remove deletes given entry from alarm raised array
 func (a *alarmsRaisedInfo) remove(val dhcpServerTag) {
 	for ind := range a.arrayInfo {
 		if a.arrayInfo[ind] == val {
 			a.arrayInfo = append(a.arrayInfo[:ind], a.arrayInfo[ind+1:]...)
 			break
 		}
 	}
 }
	/*
	* Copyright 2022-present Open Networking Foundation
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* 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

	import (
	"sync"
	"time"

	"voltha-go-controller/log"
	)

	const (
	dhcpTimeout uint8 = 60
	)

	// done channel required to gracefully stop dhcp server handler thread
	var done = make(chan bool)

	// dhcpServerInfo map having dhcp network as key and dhcp request response transaction as value
	var dhcpServerInfo map[dhcpServerTag]dhcpTransactionInfo

	// alarmsRaised is struct having array of dhcp network for which dhcp unreachable alarm raised
	var alarmsRaised alarmsRaisedInfo

	// mux is mutex variable used for lock unlock
	var mux sync.Mutex

	// StartDhcpServerHandler starts go routine periodically(every second) to verify DHCP server reachability.
	func StartDhcpServerHandler() {
	// Intialize global dhcp map and ticker as one second
	dhcpServerInfo = make(map[dhcpServerTag]dhcpTransactionInfo)
	ticker := time.NewTicker(1 * time.Second)

	// go routine runs checkDhcpTimeout every second and exit if done value is set.
	go func() {
	for {
	select {
	case <-done:
	ticker.Stop()
	return
	case <-ticker.C:
	mux.Lock()
	checkDhcpTimeout()
	mux.Unlock()

	}
	}
	}()
	}

	// checkDhcpTimeout method called every second to verify dhcp timeout for each DHCP network
	func checkDhcpTimeout() {
	// logger.Debugw(ctx, "[dhcptimeout] DHCP MAP Info", log.Fields{"Map": dhcpServerInfo})
	for dsTag, dtInfo := range dhcpServerInfo {
	dtInfo.decrementTimer()
	if dtInfo.getTimer() == 0 {
	logger.Debugw(ctx, "[dhcptimeout]Timer Expired", log.Fields{"ctag": dsTag.cTag, "stag": dsTag.sTag})
	if dtInfo.getReceivedResponseCount() == 0 && !alarmsRaised.isexist(dsTag) {
	alarmsRaised.add(dsTag)
	logger.Infow(ctx, "Alarms Raised", log.Fields{"ctag": dsTag.cTag, "stag": dsTag.sTag})
	}

	// Reset helps in
	// case 1: when 2 requests, 1 response received within timeout interval.
	// case 2: 1 request and no response even after timeout. (Unreachable alarm raised)
	// In both cases, reset method provides additional timeout to receive response before deleting
	dtInfo.resetRequestResponseCount(dhcpTimeout)

	// Delete dhcp entry in map and continue to process next entry if pending request set to 0
	if dtInfo.getPendingRequestCount() == 0 {
	delete(dhcpServerInfo, dsTag)
	logger.Debugw(ctx, "[dhcptimeout]DhcpServerTag info removed", log.Fields{"ctag": dsTag.cTag, "stag": dsTag.sTag})
	// logger.Debugw(ctx, "[dhcptimeout] DHCP MAP Info", log.Fields{"Map": dhcpServerInfo})
	continue
	}
	}
	// Update decremented timer value and continue loop
	dhcpServerInfo[dsTag] = dtInfo
	}
	}

	// dhcpRequestReceived called for every DHCP request received from client.
	func dhcpRequestReceived(cTag, sTag uint16, smac string) {
	var dtInfo dhcpTransactionInfo
	var valueExist bool
	dsTag := newDhcpServerTag(cTag, sTag)

	mux.Lock()
	logger.Debugw(ctx, "dhcpRequestReceived", log.Fields{"ctag": cTag, "stag": sTag, "smac": smac})
	if dtInfo, valueExist = dhcpServerInfo[dsTag]; !valueExist {
	dtInfo = newDhcpTransactionInfo(dhcpTimeout, smac)
	dtInfo.incrementPendingRequestCount()
	}

	// Source mac received in dhcp request is not same as dtInfo mac then
	// Its new subscriber request, hence increment pending request count.
	// If multiple dhcp request received with same mac are ignored.
	if dtInfo.smac != smac {
	dtInfo.incrementPendingRequestCount()
	}

	dhcpServerInfo[dsTag] = dtInfo
	mux.Unlock()
	}

	// dhcpResponseReceived called for every DHCP response received from dhcp server.
	func dhcpResponseReceived(cTag, sTag uint16) {
	var dtInfo dhcpTransactionInfo
	var valueExist bool
	dsTag := newDhcpServerTag(cTag, sTag)

	mux.Lock()
	logger.Debugw(ctx, "dhcpResponseReceived", log.Fields{"ctag": cTag, "stag": sTag})
	if dtInfo, valueExist = dhcpServerInfo[dsTag]; !valueExist {
	logger.Warnw(ctx, "Ignore unknown response", log.Fields{"DhcpResp": dsTag})
	mux.Unlock()
	return
	}

	// If already unreachable alarm raised, clear and remove from array
	if alarmsRaised.isexist(dsTag) {
	alarmsRaised.remove(dsTag)
	logger.Infow(ctx, "Alarm Cleared", log.Fields{"ctag": dsTag.cTag, "stag": dsTag.sTag})
	}

	// Increments received count and decrement pending count
	dtInfo.responseReceived()
	logger.Debugw(ctx, "Updated dtInfo", log.Fields{"pendingReq": dtInfo.pendingRequestCount, "receivedReq": dtInfo.receivedResponseCount})

	if dtInfo.getPendingRequestCount() == 0 {
	delete(dhcpServerInfo, dsTag)
	} else {
	dhcpServerInfo[dsTag] = dtInfo
	}
	mux.Unlock()
	}

	// StopDhcpServerHandler stops dhcp server handler go routine
	func StopDhcpServerHandler() {
	done <- true
	}

	// dhcpServerTag contains unique dhcp network information
	type dhcpServerTag struct {
	sTag uint16
	cTag uint16
	}

	func newDhcpServerTag(cTag, sTag uint16) dhcpServerTag {
	var d dhcpServerTag
	d.sTag = sTag
	d.cTag = cTag
	return d
	}

	// dhcpTransactionInfo contains DHCP request response transaction information.
	type dhcpTransactionInfo struct {
	timer uint8
	pendingRequestCount uint32
	receivedResponseCount uint32
	previousRequestCount uint32
	smac string
	}

	func newDhcpTransactionInfo(timer uint8, smac string) dhcpTransactionInfo {
	var dt dhcpTransactionInfo
	dt.timer = timer
	dt.smac = smac
	return dt
	}

	func (dt *dhcpTransactionInfo) getTimer() uint8 {
	return dt.timer
	}

	func (dt *dhcpTransactionInfo) decrementTimer() uint8 {
	dt.timer--
	return dt.timer
	}

	func (dt *dhcpTransactionInfo) getPendingRequestCount() uint32 {
	return dt.pendingRequestCount
	}

	func (dt *dhcpTransactionInfo) incrementPendingRequestCount() {
	dt.pendingRequestCount++
	}

	func (dt *dhcpTransactionInfo) getReceivedResponseCount() uint32 {
	return dt.receivedResponseCount
	}

	func (dt *dhcpTransactionInfo) responseReceived() {
	dt.receivedResponseCount++
	dt.pendingRequestCount--
	}

	func (dt *dhcpTransactionInfo) resetRequestResponseCount(timer uint8) {
	if dt.pendingRequestCount >= dt.previousRequestCount {
	dt.pendingRequestCount = dt.pendingRequestCount - dt.previousRequestCount
	}
	dt.previousRequestCount = dt.pendingRequestCount
	dt.receivedResponseCount = 0
	dt.timer = timer
	}

	// alarmsRaisedInfo contains the all networks alarm raised information
	type alarmsRaisedInfo struct {
	arrayInfo []dhcpServerTag
	}

	// add an entry into alarm raised array
	func (a *alarmsRaisedInfo) add(val dhcpServerTag) {
	a.arrayInfo = append(a.arrayInfo, val)
	}

	// isexist check if entry exist in alarm raised array
	func (a *alarmsRaisedInfo) isexist(val dhcpServerTag) bool {
	for _, srvTag := range a.arrayInfo {
	if srvTag == val {
	return true
	}
	}
	return false
	}

	// remove deletes given entry from alarm raised array
	func (a *alarmsRaisedInfo) remove(val dhcpServerTag) {
	for ind := range a.arrayInfo {
	if a.arrayInfo[ind] == val {
	a.arrayInfo = append(a.arrayInfo[:ind], a.arrayInfo[ind+1:]...)
	break
	}
	}
	}