core/api_handler.go - voltha-bbsim - Gitiles

 /*
  * Copyright 2018-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 core

 import (
 	"errors"
 	"net"
 	"strconv"
 	"time"

 	api "github.com/opencord/voltha-bbsim/api"
 	"github.com/opencord/voltha-bbsim/common/logger"
 	"github.com/opencord/voltha-bbsim/device"
 	"github.com/opencord/voltha-bbsim/flow"
 	openolt "github.com/opencord/voltha-protos/go/openolt"
 	"google.golang.org/grpc/codes"
 	"google.golang.org/grpc/status"
 )

 // Constants for reboot delays
 const (
 	OltRebootDelay     = 40
 	OnuSoftRebootDelay = 10
 	OnuHardRebootDelay = 30
 )

 // handleONUStatusRequest process ONU status request
 func (s *Server) handleONUStatusRequest(in *api.ONUInfo) (*api.ONUs, error) {
 	logger.Trace("handleONUStatusRequest() invoked")
 	onuInfo := &api.ONUs{}
 	if in.OnuSerial != "" { // Get status of single ONU by SerialNumber
 		// Get OpenOlt serial number from string
 		sn, err := getOpenoltSerialNumber(in.OnuSerial)
 		if err != nil {
 			logger.Error("Invalid serial number %s", in.OnuSerial)
 			return onuInfo, status.Errorf(codes.InvalidArgument, "serial: "+in.OnuSerial+" is invalid")
 		}
 		// Get ONU by serial number
 		onu, err := getOnuBySN(s.Onumap, sn)
 		if err != nil {
 			logger.Error("ONU with serial number %v not found", sn)
 			return onuInfo, status.Errorf(codes.NotFound, "serial: "+in.OnuSerial+" not found")
 		}
 		onuInfo.Onus = append(onuInfo.Onus, copyONUInfo(onu))
 	} else {
 		// Return error if specified PON port does not exist
 		if _, exist := s.Onumap[in.PonPortId]; !exist {
 			logger.Error("PON port %d not found", in.PonPortId)
 			return onuInfo, status.Errorf(codes.NotFound, "PON Port: "+strconv.Itoa(int(in.PonPortId))+" not found")
 		}

 		if in.OnuId != 0 { // Get status of single ONU by ONU-ID
 			for intfid := range s.Onumap {
 				for _, onu := range s.Onumap[intfid] {
 					if in.OnuId == onu.OnuID {
 						onuInfo.Onus = append(onuInfo.Onus, copyONUInfo(onu))
 					}
 				}
 			}
 		} else {
 			// Append ONU data
 			for _, onu := range s.Onumap[in.PonPortId] {
 				onuInfo.Onus = append(onuInfo.Onus, copyONUInfo(onu))
 			}
 		}
 	}

 	return onuInfo, nil
 }

 // handleONUActivate method handles ONU activate requests from user.
 func (s *Server) handleONUActivate(in []*api.ONUInfo) (*api.BBSimResponse, error) {
 	logger.Trace("handleONUActivate request received")
 	logger.Debug("Received values: %+v\n", in)

 	// Check if indication is enabled
 	if s.EnableServer == nil {
 		logger.Error(OLTNotEnabled)
 		return &api.BBSimResponse{}, status.Errorf(codes.FailedPrecondition, OLTNotEnabled)
 	}

 	onuaddmap := make(map[uint32][]*device.Onu)
 	var newSerialNums []string

 	//Iterate request for each PON port specified
 	for _, onu := range in {
 		intfid := onu.PonPortId

 		if !s.isPonIntfPresentInOlt(intfid) {
 			return &api.BBSimResponse{}, status.Errorf(codes.OutOfRange, "PON-"+strconv.Itoa(int(intfid))+
 				" not present in OLT-"+strconv.Itoa(int(s.Olt.ID)))
 		}

 		if s.Olt.PonIntfs[intfid].AlarmState == device.PonLosRaised {
 			return &api.BBSimResponse{}, status.Errorf(codes.FailedPrecondition, "pon-"+strconv.Itoa(int(intfid))+" is not active")
 		}

 		// Get the free ONU object for the intfid
 		Onu, err := s.GetNextFreeOnu(intfid)
 		if err != nil {
 			markONUsFree(onuaddmap)
 			logger.Error("Failed to get free ONU object for intfID %d :%v", intfid, err)
 			return &api.BBSimResponse{}, status.Errorf(codes.ResourceExhausted, err.Error())
 		}

 		// Check if Serial number is provided by user
 		if onu.OnuSerial != "" {
 			// Get OpenOlt serial number from string
 			sn, err := getOpenoltSerialNumber(onu.OnuSerial)
 			if err != nil {
 				logger.Error("Failed to get OpenOlt serial number %v", err)
 				Onu.InternalState = device.OnuFree
 				markONUsFree(onuaddmap)
 				return &api.BBSimResponse{}, status.Errorf(codes.InvalidArgument, "serial number: "+onu.OnuSerial+" is invalid")
 			}

 			// Check if serial number is not duplicate in requested ONUs
 			for _, sn := range newSerialNums {
 				if onu.OnuSerial == sn {
 					logger.Error("Duplicate serial number found %s", sn)
 					// Mark ONUs free
 					markONUsFree(onuaddmap)
 					Onu.InternalState = device.OnuFree
 					return &api.BBSimResponse{}, status.Errorf(codes.InvalidArgument, "duplicate serial number: "+onu.OnuSerial+" provided")
 				}
 			}
 			newSerialNums = append(newSerialNums, onu.OnuSerial)

 			// Check if serial number already exist
 			_, exist := s.getOnuFromSNmap(sn)
 			if exist {
 				logger.Error("Provided serial number %v already exist", sn)
 				// Mark ONUs free
 				markONUsFree(onuaddmap)
 				Onu.InternalState = device.OnuFree
 				return &api.BBSimResponse{}, status.Errorf(codes.AlreadyExists, "serial number: "+onu.OnuSerial+" already exist")
 			}

 			// Store user provided serial number in ONU object
 			Onu.SerialNumber = sn
 		}
 		// Store onu object in map for particular intfid
 		onuaddmap[intfid] = append(onuaddmap[intfid], Onu)
 	}

 	if len(onuaddmap) >= 1 {
 		//Pass onumap to activateONU to handle indication to VOLTHA
 		s.activateONUs(*s.EnableServer, onuaddmap)
 	}

 	return &api.BBSimResponse{StatusMsg: RequestAccepted}, nil
 }

 // handleONUDeactivate deactivates ONU described by a single ONUInfo object
 func (s *Server) handleONUDeactivate(in *api.ONUInfo) error {
 	logger.Trace("handleONUDeactivate() invoked")

 	if s.EnableServer == nil {
 		logger.Error(OLTNotEnabled)
 		return status.Errorf(codes.FailedPrecondition, OLTNotEnabled)
 	}

 	if in.OnuSerial != "" {
 		// Get OpenOlt serial number from string
 		serialNumber, err := getOpenoltSerialNumber(in.OnuSerial)
 		if err != nil {
 			logger.Error("Invalid serial number %s", in.OnuSerial)
 			return status.Errorf(codes.InvalidArgument, "serial: "+in.OnuSerial+" is invalid")
 		}
 		// Get ONU by serial number
 		onu, exist := s.getOnuFromSNmap(serialNumber)
 		if !exist {
 			logger.Error("ONU with serial number %s not found", in.OnuSerial)
 			return status.Errorf(codes.NotFound, "serial: "+in.OnuSerial+" not found")
 		}

 		if err := s.HandleOnuDeactivate(onu); err != nil {
 			return err
 		}
 	} else {
 		if in.OnuId != 0 { // if provided, delete ONU by ONU ID
 			onu, err := getOnuByID(s.Onumap, in.OnuId, in.PonPortId)
 			if err != nil {
 				return err
 			}
 			if err := s.HandleOnuDeactivate(onu); err != nil {
 				return err
 			}
 		} else { // delete all ONUs on provided port
 			if err := s.DeactivateAllOnuByIntfID(in.PonPortId); err != nil {
 				logger.Error("Failed in handleONUDeactivate: %v", err)
 				return err
 			}
 		}
 	}
 	return nil
 }

 func (s *Server) handleOLTReboot() {
 	logger.Trace("HandleOLTReboot() invoked")
 	logger.Debug("Sending stop to serverActionCh")
 	s.serverActionCh <- OpenOltStop

 	// Delete all flows
 	err := flow.DeleteAllFlows()
 	if err != nil {
 		logger.Warn("%v", err)
 	}

 	// clear flowMap
 	s.FlowMap = make(map[device.FlowKey]*openolt.Flow)

 	// clear flow IDs from ONU objects
 	for intfID := range s.Onumap {
 		for _, onu := range s.Onumap[intfID] {
 			onu.Flows = nil
 		}
 	}

 	time.Sleep(OltRebootDelay * time.Second)

 	logger.Debug("Sending start to serverActionCh")
 	s.serverActionCh <- OpenOltStart
 	for {
 		if s.Olt.GetIntState() == device.OltActive {
 			logger.Info("Info: OLT reactivated")
 			break
 		}
 		time.Sleep(2 * time.Second)
 	}
 	s.sendOnuIndicationsOnOltReboot()
 }

 func (s *Server) handleONUHardReboot(onu *device.Onu) {
 	logger.Trace("handleONUHardReboot() invoked")
 	_ = sendDyingGaspInd(*s.EnableServer, onu.IntfID, onu.OnuID)
 	device.UpdateOnusOpStatus(onu.IntfID, onu, "down")
 	// send operstat down to voltha
 	_ = sendOnuInd(*s.EnableServer, onu, "down", "up")
 	// Give OEH some time to perform cleanup
 	time.Sleep(OnuHardRebootDelay * time.Second)
 	s.activateOnu(onu)
 }

 func (s *Server) handleONUSoftReboot(IntfID uint32, OnuID uint32) {
 	logger.Trace("handleONUSoftReboot() invoked")
 	onu, err := s.GetOnuByID(OnuID, IntfID)
 	if err != nil {
 		logger.Error("No onu found with given OnuID on interface %v", IntfID)
 		return
 	}
 	OnuAlarmRequest := &api.ONUAlarmRequest{
 		OnuSerial: stringifySerialNumber(onu.SerialNumber),
 		AlarmType: OnuLossOfPloam,
 		Status:    "on",
 	}
 	// Raise alarm
 	_, err = s.handleOnuAlarm(OnuAlarmRequest)
 	if err != nil {
 		logger.Error(err.Error())
 	}
 	// Clear alarm
 	time.Sleep(OnuSoftRebootDelay * time.Second)
 	OnuAlarmRequest.Status = "off"
 	_, err = s.handleOnuAlarm(OnuAlarmRequest)
 	if err != nil {
 		logger.Error(err.Error())
 	}
 }

 // GetNextFreeOnu returns free onu object for specified interface ID
 func (s *Server) GetNextFreeOnu(intfid uint32) (*device.Onu, error) {
 	logger.Trace("GetNextFreeOnu() invoked")
 	onus, ok := s.Onumap[intfid]
 	if !ok {
 		return nil, errors.New("interface " + strconv.Itoa(int(intfid)) + " not present in ONU map")
 	}
 	for _, onu := range onus {
 		if onu.InternalState == device.OnuFree {
 			// If auto generated serial number is already used by some other ONU,
 			// continue to find for other free object
 			snkey := stringifySerialNumber(onu.SerialNumber)
 			if _, exist := s.SNmap.Load(snkey); exist {
 				continue
 			}
 			// Update Onu Internal State
 			onu.InternalState = device.OnuInactive
 			return onu, nil
 		}
 	}
 	return nil, errors.New("no free ONU found for pon port: " + strconv.Itoa(int(intfid)))
 }

 // DeactivateAllOnuByIntfID deletes all ONUs for given PON port ID
 func (s *Server) DeactivateAllOnuByIntfID(intfid uint32) error {
 	logger.Trace("DeactivateAllOnuByIntfID() invoked")
 	for _, onu := range s.Onumap[intfid] {
 		if onu.InternalState == device.OnuFree || onu.InternalState == device.OnuInactive {
 			continue
 		}
 		if err := s.HandleOnuDeactivate(onu); err != nil {
 			return err
 		}
 	}
 	return nil
 }

 // HandleOnuDeactivate method handles ONU state changes and sending Indication to voltha
 func (s *Server) HandleOnuDeactivate(onu *device.Onu) error {
 	logger.Trace("HandleOnuDeactivate() invoked")
 	logger.Info("Deactivating ONU %d for Intf: %d", onu.OnuID, onu.IntfID)

 	// Update ONU internal state to ONU_INACTIVE
 	s.updateDevIntState(onu, device.OnuInactive)

 	// Update ONU operstate to down
 	onu.OperState = "down"

 	// Send DyingGasp Alarm to VOLTHA
 	_ = sendDyingGaspInd(*s.EnableServer, onu.IntfID, onu.OnuID)
 	_ = sendOnuInd(*s.EnableServer, onu, onu.OperState, "down")
 	return nil
 }

 func markONUsFree(onumap map[uint32][]*device.Onu) {
 	logger.Trace("markONUsFree() invoked")
 	for intfid := range onumap {
 		for _, onu := range onumap[intfid] {
 			onu.UpdateIntState(device.OnuFree)
 		}
 	}
 }

 func copyONUInfo(onu *device.Onu) *api.ONUInfo {
 	onuData := &api.ONUInfo{
 		OnuId:     onu.OnuID,
 		PonPortId: onu.IntfID,
 		OnuSerial: stringifySerialNumber(onu.SerialNumber),
 		OnuState:  device.ONUState[onu.InternalState],
 		OperState: onu.OperState,
 	}

 	// update gemports
 	for _, gemPorts := range onu.GemPortMap {
 		onuData.Gemports = append(onuData.Gemports, gemPorts...)
 	}

 	// fill T-CONT data for ONU
 	if onu.Tconts != nil {
 		onuData.Tconts = &api.Tconts{
 			UniId:  onu.Tconts.UniId,
 			PortNo: onu.Tconts.PortNo,
 			Tconts: onu.Tconts.TrafficScheds,
 		}
 	}

 	return onuData
 }

 func (s *Server) fetchPortDetail(intfID uint32, portType string) (*api.PortInfo, error) {
 	logger.Trace("fetchPortDetail() invoked %s-%d", portType, intfID)

 	portInfo := &api.PortInfo{}
 	var maxOnu, activeOnu uint32
 	var alarmState device.AlarmState
 	var state string

 	// Get info for specified port
 	if portType == device.IntfNni && s.isNniIntfPresentInOlt(intfID) {
 		state = s.Olt.NniIntfs[intfID].OperState
 		alarmState = s.Olt.NniIntfs[intfID].AlarmState

 	} else if portType == device.IntfPon && s.isPonIntfPresentInOlt(intfID) {
 		maxOnu = uint32(len(s.Onumap[intfID]))
 		activeOnu = s.getNoOfActiveOnuByPortID(intfID)
 		state = s.Olt.PonIntfs[intfID].OperState
 		alarmState = s.Olt.PonIntfs[intfID].AlarmState

 	} else {
 		return &api.PortInfo{}, errors.New(portType + "-" + strconv.Itoa(int(intfID)) + " not present in OLT-" +
 			strconv.Itoa(int(s.Olt.ID)))
 	}

 	// fill proto structure
 	portInfo = &api.PortInfo{
 		PortType:          portType,
 		PortId:            intfID,
 		PonPortMaxOnus:    maxOnu,
 		PonPortActiveOnus: activeOnu,
 		PortState:         state,
 	}

 	// update alarm state only when alarm is raised
 	if alarmState == device.NniLosRaised || alarmState == device.PonLosRaised {
 		portInfo.AlarmState = device.OLTAlarmStateToString[alarmState]
 	}

 	return portInfo, nil
 }

 func (s *Server) validateDeviceActionRequest(request *api.DeviceAction) (*api.DeviceAction, error) {
 	logger.Trace("validateDeviceActionRequest() invoked")
 	switch request.DeviceType {
 	case DeviceTypeOnu:
 		if request.SerialNumber == "" {
 			return request, errors.New("onu serial number can not be blank")
 		}

 		if len(request.SerialNumber) != SerialNumberLength {
 			return request, errors.New("invalid serial number provided")
 		}

 		_, exist := s.SNmap.Load(request.SerialNumber)
 		if !exist {
 			return &api.DeviceAction{}, errors.New(request.SerialNumber + " not present in OLT-" +
 				strconv.Itoa(int(s.Olt.ID)))
 		}

 		if request.Action != SoftReboot && request.Action != HardReboot {
 			return request, errors.New("invalid device action provided")
 		}
 		return request, nil
 	case DeviceTypeOlt:
 		request.DeviceType = DeviceTypeOlt
 		request.Action = HardReboot
 		return request, nil
 	default:
 		return request, errors.New("invalid device type")
 	}
 }

 func (s *Server) getNoOfActiveOnuByPortID(portID uint32) uint32 {
 	var noOfActiveOnus uint32
 	for _, onu := range s.Onumap[portID] {
 		if onu.InternalState >= device.OnuActive {
 			noOfActiveOnus++
 		}
 	}
 	return noOfActiveOnus
 }

 func (s *Server) isPonIntfPresentInOlt(intfID uint32) bool {
 	for _, intf := range s.Olt.PonIntfs {
 		if intf.IntfID == intfID {
 			return true
 		}
 	}
 	return false
 }

 func (s *Server) isNniIntfPresentInOlt(intfID uint32) bool {
 	for _, intf := range s.Olt.NniIntfs {
 		if intf.IntfID == intfID {
 			return true
 		}
 	}
 	return false
 }

 func getOltIP() net.IP {
 	// TODO make this better
 	conn, err := net.Dial("udp", "8.8.8.8:80")
 	if err != nil {
 		logger.Error(err.Error())
 		return net.IP{}
 	}
 	defer func() {
 		err := conn.Close()
 		if err != nil {
 			logger.Error(err.Error())
 		}
 	}()

 	localAddr := conn.LocalAddr().(*net.UDPAddr)

 	return localAddr.IP
 }
	/*
	* Copyright 2018-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 core

	import (
	"errors"
	"net"
	"strconv"
	"time"

	api "github.com/opencord/voltha-bbsim/api"
	"github.com/opencord/voltha-bbsim/common/logger"
	"github.com/opencord/voltha-bbsim/device"
	"github.com/opencord/voltha-bbsim/flow"
	openolt "github.com/opencord/voltha-protos/go/openolt"
	"google.golang.org/grpc/codes"
	"google.golang.org/grpc/status"
	)

	// Constants for reboot delays
	const (
	OltRebootDelay = 40
	OnuSoftRebootDelay = 10
	OnuHardRebootDelay = 30
	)

	// handleONUStatusRequest process ONU status request
	func (s Server) handleONUStatusRequest(in api.ONUInfo) (*api.ONUs, error) {
	logger.Trace("handleONUStatusRequest() invoked")
	onuInfo := &api.ONUs{}
	if in.OnuSerial != "" { // Get status of single ONU by SerialNumber
	// Get OpenOlt serial number from string
	sn, err := getOpenoltSerialNumber(in.OnuSerial)
	if err != nil {
	logger.Error("Invalid serial number %s", in.OnuSerial)
	return onuInfo, status.Errorf(codes.InvalidArgument, "serial: "+in.OnuSerial+" is invalid")
	}
	// Get ONU by serial number
	onu, err := getOnuBySN(s.Onumap, sn)
	if err != nil {
	logger.Error("ONU with serial number %v not found", sn)
	return onuInfo, status.Errorf(codes.NotFound, "serial: "+in.OnuSerial+" not found")
	}
	onuInfo.Onus = append(onuInfo.Onus, copyONUInfo(onu))
	} else {
	// Return error if specified PON port does not exist
	if _, exist := s.Onumap[in.PonPortId]; !exist {
	logger.Error("PON port %d not found", in.PonPortId)
	return onuInfo, status.Errorf(codes.NotFound, "PON Port: "+strconv.Itoa(int(in.PonPortId))+" not found")
	}

	if in.OnuId != 0 { // Get status of single ONU by ONU-ID
	for intfid := range s.Onumap {
	for _, onu := range s.Onumap[intfid] {
	if in.OnuId == onu.OnuID {
	onuInfo.Onus = append(onuInfo.Onus, copyONUInfo(onu))
	}
	}
	}
	} else {
	// Append ONU data
	for _, onu := range s.Onumap[in.PonPortId] {
	onuInfo.Onus = append(onuInfo.Onus, copyONUInfo(onu))
	}
	}
	}

	return onuInfo, nil
	}

	// handleONUActivate method handles ONU activate requests from user.
	func (s Server) handleONUActivate(in []api.ONUInfo) (*api.BBSimResponse, error) {
	logger.Trace("handleONUActivate request received")
	logger.Debug("Received values: %+v\n", in)

	// Check if indication is enabled
	if s.EnableServer == nil {
	logger.Error(OLTNotEnabled)
	return &api.BBSimResponse{}, status.Errorf(codes.FailedPrecondition, OLTNotEnabled)
	}

	onuaddmap := make(map[uint32][]*device.Onu)
	var newSerialNums []string

	//Iterate request for each PON port specified
	for _, onu := range in {
	intfid := onu.PonPortId

	if !s.isPonIntfPresentInOlt(intfid) {
	return &api.BBSimResponse{}, status.Errorf(codes.OutOfRange, "PON-"+strconv.Itoa(int(intfid))+
	" not present in OLT-"+strconv.Itoa(int(s.Olt.ID)))
	}

	if s.Olt.PonIntfs[intfid].AlarmState == device.PonLosRaised {
	return &api.BBSimResponse{}, status.Errorf(codes.FailedPrecondition, "pon-"+strconv.Itoa(int(intfid))+" is not active")
	}

	// Get the free ONU object for the intfid
	Onu, err := s.GetNextFreeOnu(intfid)
	if err != nil {
	markONUsFree(onuaddmap)
	logger.Error("Failed to get free ONU object for intfID %d :%v", intfid, err)
	return &api.BBSimResponse{}, status.Errorf(codes.ResourceExhausted, err.Error())
	}

	// Check if Serial number is provided by user
	if onu.OnuSerial != "" {
	// Get OpenOlt serial number from string
	sn, err := getOpenoltSerialNumber(onu.OnuSerial)
	if err != nil {
	logger.Error("Failed to get OpenOlt serial number %v", err)
	Onu.InternalState = device.OnuFree
	markONUsFree(onuaddmap)
	return &api.BBSimResponse{}, status.Errorf(codes.InvalidArgument, "serial number: "+onu.OnuSerial+" is invalid")
	}

	// Check if serial number is not duplicate in requested ONUs
	for _, sn := range newSerialNums {
	if onu.OnuSerial == sn {
	logger.Error("Duplicate serial number found %s", sn)
	// Mark ONUs free
	markONUsFree(onuaddmap)
	Onu.InternalState = device.OnuFree
	return &api.BBSimResponse{}, status.Errorf(codes.InvalidArgument, "duplicate serial number: "+onu.OnuSerial+" provided")
	}
	}
	newSerialNums = append(newSerialNums, onu.OnuSerial)

	// Check if serial number already exist
	_, exist := s.getOnuFromSNmap(sn)
	if exist {
	logger.Error("Provided serial number %v already exist", sn)
	// Mark ONUs free
	markONUsFree(onuaddmap)
	Onu.InternalState = device.OnuFree
	return &api.BBSimResponse{}, status.Errorf(codes.AlreadyExists, "serial number: "+onu.OnuSerial+" already exist")
	}

	// Store user provided serial number in ONU object
	Onu.SerialNumber = sn
	}
	// Store onu object in map for particular intfid
	onuaddmap[intfid] = append(onuaddmap[intfid], Onu)
	}

	if len(onuaddmap) >= 1 {
	//Pass onumap to activateONU to handle indication to VOLTHA
	s.activateONUs(*s.EnableServer, onuaddmap)
	}

	return &api.BBSimResponse{StatusMsg: RequestAccepted}, nil
	}

	// handleONUDeactivate deactivates ONU described by a single ONUInfo object
	func (s Server) handleONUDeactivate(in api.ONUInfo) error {
	logger.Trace("handleONUDeactivate() invoked")

	if s.EnableServer == nil {
	logger.Error(OLTNotEnabled)
	return status.Errorf(codes.FailedPrecondition, OLTNotEnabled)
	}

	if in.OnuSerial != "" {
	// Get OpenOlt serial number from string
	serialNumber, err := getOpenoltSerialNumber(in.OnuSerial)
	if err != nil {
	logger.Error("Invalid serial number %s", in.OnuSerial)
	return status.Errorf(codes.InvalidArgument, "serial: "+in.OnuSerial+" is invalid")
	}
	// Get ONU by serial number
	onu, exist := s.getOnuFromSNmap(serialNumber)
	if !exist {
	logger.Error("ONU with serial number %s not found", in.OnuSerial)
	return status.Errorf(codes.NotFound, "serial: "+in.OnuSerial+" not found")
	}

	if err := s.HandleOnuDeactivate(onu); err != nil {
	return err
	}
	} else {
	if in.OnuId != 0 { // if provided, delete ONU by ONU ID
	onu, err := getOnuByID(s.Onumap, in.OnuId, in.PonPortId)
	if err != nil {
	return err
	}
	if err := s.HandleOnuDeactivate(onu); err != nil {
	return err
	}
	} else { // delete all ONUs on provided port
	if err := s.DeactivateAllOnuByIntfID(in.PonPortId); err != nil {
	logger.Error("Failed in handleONUDeactivate: %v", err)
	return err
	}
	}
	}
	return nil
	}

	func (s *Server) handleOLTReboot() {
	logger.Trace("HandleOLTReboot() invoked")
	logger.Debug("Sending stop to serverActionCh")
	s.serverActionCh <- OpenOltStop

	// Delete all flows
	err := flow.DeleteAllFlows()
	if err != nil {
	logger.Warn("%v", err)
	}

	// clear flowMap
	s.FlowMap = make(map[device.FlowKey]*openolt.Flow)

	// clear flow IDs from ONU objects
	for intfID := range s.Onumap {
	for _, onu := range s.Onumap[intfID] {
	onu.Flows = nil
	}
	}

	time.Sleep(OltRebootDelay * time.Second)

	logger.Debug("Sending start to serverActionCh")
	s.serverActionCh <- OpenOltStart
	for {
	if s.Olt.GetIntState() == device.OltActive {
	logger.Info("Info: OLT reactivated")
	break
	}
	time.Sleep(2 * time.Second)
	}
	s.sendOnuIndicationsOnOltReboot()
	}

	func (s Server) handleONUHardReboot(onu device.Onu) {
	logger.Trace("handleONUHardReboot() invoked")
	_ = sendDyingGaspInd(*s.EnableServer, onu.IntfID, onu.OnuID)
	device.UpdateOnusOpStatus(onu.IntfID, onu, "down")
	// send operstat down to voltha
	_ = sendOnuInd(*s.EnableServer, onu, "down", "up")
	// Give OEH some time to perform cleanup
	time.Sleep(OnuHardRebootDelay * time.Second)
	s.activateOnu(onu)
	}

	func (s *Server) handleONUSoftReboot(IntfID uint32, OnuID uint32) {
	logger.Trace("handleONUSoftReboot() invoked")
	onu, err := s.GetOnuByID(OnuID, IntfID)
	if err != nil {
	logger.Error("No onu found with given OnuID on interface %v", IntfID)
	return
	}
	OnuAlarmRequest := &api.ONUAlarmRequest{
	OnuSerial: stringifySerialNumber(onu.SerialNumber),
	AlarmType: OnuLossOfPloam,
	Status: "on",
	}
	// Raise alarm
	_, err = s.handleOnuAlarm(OnuAlarmRequest)
	if err != nil {
	logger.Error(err.Error())
	}
	// Clear alarm
	time.Sleep(OnuSoftRebootDelay * time.Second)
	OnuAlarmRequest.Status = "off"
	_, err = s.handleOnuAlarm(OnuAlarmRequest)
	if err != nil {
	logger.Error(err.Error())
	}
	}

	// GetNextFreeOnu returns free onu object for specified interface ID
	func (s Server) GetNextFreeOnu(intfid uint32) (device.Onu, error) {
	logger.Trace("GetNextFreeOnu() invoked")
	onus, ok := s.Onumap[intfid]
	if !ok {
	return nil, errors.New("interface " + strconv.Itoa(int(intfid)) + " not present in ONU map")
	}
	for _, onu := range onus {
	if onu.InternalState == device.OnuFree {
	// If auto generated serial number is already used by some other ONU,
	// continue to find for other free object
	snkey := stringifySerialNumber(onu.SerialNumber)
	if _, exist := s.SNmap.Load(snkey); exist {
	continue
	}
	// Update Onu Internal State
	onu.InternalState = device.OnuInactive
	return onu, nil
	}
	}
	return nil, errors.New("no free ONU found for pon port: " + strconv.Itoa(int(intfid)))
	}

	// DeactivateAllOnuByIntfID deletes all ONUs for given PON port ID
	func (s *Server) DeactivateAllOnuByIntfID(intfid uint32) error {
	logger.Trace("DeactivateAllOnuByIntfID() invoked")
	for _, onu := range s.Onumap[intfid] {
	if onu.InternalState == device.OnuFree \|\| onu.InternalState == device.OnuInactive {
	continue
	}
	if err := s.HandleOnuDeactivate(onu); err != nil {
	return err
	}
	}
	return nil
	}

	// HandleOnuDeactivate method handles ONU state changes and sending Indication to voltha
	func (s Server) HandleOnuDeactivate(onu device.Onu) error {
	logger.Trace("HandleOnuDeactivate() invoked")
	logger.Info("Deactivating ONU %d for Intf: %d", onu.OnuID, onu.IntfID)

	// Update ONU internal state to ONU_INACTIVE
	s.updateDevIntState(onu, device.OnuInactive)

	// Update ONU operstate to down
	onu.OperState = "down"

	// Send DyingGasp Alarm to VOLTHA
	_ = sendDyingGaspInd(*s.EnableServer, onu.IntfID, onu.OnuID)
	_ = sendOnuInd(*s.EnableServer, onu, onu.OperState, "down")
	return nil
	}

	func markONUsFree(onumap map[uint32][]*device.Onu) {
	logger.Trace("markONUsFree() invoked")
	for intfid := range onumap {
	for _, onu := range onumap[intfid] {
	onu.UpdateIntState(device.OnuFree)
	}
	}
	}

	func copyONUInfo(onu device.Onu) api.ONUInfo {
	onuData := &api.ONUInfo{
	OnuId: onu.OnuID,
	PonPortId: onu.IntfID,
	OnuSerial: stringifySerialNumber(onu.SerialNumber),
	OnuState: device.ONUState[onu.InternalState],
	OperState: onu.OperState,
	}

	// update gemports
	for _, gemPorts := range onu.GemPortMap {
	onuData.Gemports = append(onuData.Gemports, gemPorts...)
	}

	// fill T-CONT data for ONU
	if onu.Tconts != nil {
	onuData.Tconts = &api.Tconts{
	UniId: onu.Tconts.UniId,
	PortNo: onu.Tconts.PortNo,
	Tconts: onu.Tconts.TrafficScheds,
	}
	}

	return onuData
	}

	func (s Server) fetchPortDetail(intfID uint32, portType string) (api.PortInfo, error) {
	logger.Trace("fetchPortDetail() invoked %s-%d", portType, intfID)

	portInfo := &api.PortInfo{}
	var maxOnu, activeOnu uint32
	var alarmState device.AlarmState
	var state string

	// Get info for specified port
	if portType == device.IntfNni && s.isNniIntfPresentInOlt(intfID) {
	state = s.Olt.NniIntfs[intfID].OperState
	alarmState = s.Olt.NniIntfs[intfID].AlarmState

	} else if portType == device.IntfPon && s.isPonIntfPresentInOlt(intfID) {
	maxOnu = uint32(len(s.Onumap[intfID]))
	activeOnu = s.getNoOfActiveOnuByPortID(intfID)
	state = s.Olt.PonIntfs[intfID].OperState
	alarmState = s.Olt.PonIntfs[intfID].AlarmState

	} else {
	return &api.PortInfo{}, errors.New(portType + "-" + strconv.Itoa(int(intfID)) + " not present in OLT-" +
	strconv.Itoa(int(s.Olt.ID)))
	}

	// fill proto structure
	portInfo = &api.PortInfo{
	PortType: portType,
	PortId: intfID,
	PonPortMaxOnus: maxOnu,
	PonPortActiveOnus: activeOnu,
	PortState: state,
	}

	// update alarm state only when alarm is raised
	if alarmState == device.NniLosRaised \|\| alarmState == device.PonLosRaised {
	portInfo.AlarmState = device.OLTAlarmStateToString[alarmState]
	}

	return portInfo, nil
	}

	func (s Server) validateDeviceActionRequest(request api.DeviceAction) (*api.DeviceAction, error) {
	logger.Trace("validateDeviceActionRequest() invoked")
	switch request.DeviceType {
	case DeviceTypeOnu:
	if request.SerialNumber == "" {
	return request, errors.New("onu serial number can not be blank")
	}

	if len(request.SerialNumber) != SerialNumberLength {
	return request, errors.New("invalid serial number provided")
	}

	_, exist := s.SNmap.Load(request.SerialNumber)
	if !exist {
	return &api.DeviceAction{}, errors.New(request.SerialNumber + " not present in OLT-" +
	strconv.Itoa(int(s.Olt.ID)))
	}

	if request.Action != SoftReboot && request.Action != HardReboot {
	return request, errors.New("invalid device action provided")
	}
	return request, nil
	case DeviceTypeOlt:
	request.DeviceType = DeviceTypeOlt
	request.Action = HardReboot
	return request, nil
	default:
	return request, errors.New("invalid device type")
	}
	}

	func (s *Server) getNoOfActiveOnuByPortID(portID uint32) uint32 {
	var noOfActiveOnus uint32
	for _, onu := range s.Onumap[portID] {
	if onu.InternalState >= device.OnuActive {
	noOfActiveOnus++
	}
	}
	return noOfActiveOnus
	}

	func (s *Server) isPonIntfPresentInOlt(intfID uint32) bool {
	for _, intf := range s.Olt.PonIntfs {
	if intf.IntfID == intfID {
	return true
	}
	}
	return false
	}

	func (s *Server) isNniIntfPresentInOlt(intfID uint32) bool {
	for _, intf := range s.Olt.NniIntfs {
	if intf.IntfID == intfID {
	return true
	}
	}
	return false
	}

	func getOltIP() net.IP {
	// TODO make this better
	conn, err := net.Dial("udp", "8.8.8.8:80")
	if err != nil {
	logger.Error(err.Error())
	return net.IP{}
	}
	defer func() {
	err := conn.Close()
	if err != nil {
	logger.Error(err.Error())
	}
	}()

	localAddr := conn.LocalAddr().(*net.UDPAddr)

	return localAddr.IP
	}