core/api_handler.go

/*
 * 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"

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

// handleONUActivate process ONU status request
func (s *Server) handleONUStatusRequest(in *pb.ONUInfo) (*pb.ONUs, error) {
	onuInfo := &pb.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 []*pb.ONUInfo) (*pb.BBSimResponse, error) {
	logger.Info("handleONUActivate request received")
	logger.Debug("Received values: %+v\n", in)

	// Check if indication is enabled
	if s.EnableServer == nil {
		logger.Error(OLTNotEnabled)
		return &pb.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

		// 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 &pb.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.ONU_FREE
				markONUsFree(onuaddmap)
				return &pb.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.ONU_FREE
					return &pb.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.ONU_FREE
				return &pb.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 &pb.BBSimResponse{StatusMsg: RequestAccepted}, nil
}

// handleONUDeactivate deactivates ONU described by a single ONUInfo object
func (s *Server) handleONUDeactivate(in *pb.ONUInfo) error {

	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.Debug("HandleOLTReboot() invoked")
	logger.Debug("Sending stop to serverActionCh")
	s.serverActionCh <- OpenOltStop
	time.Sleep(40 * time.Second)

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

func (s *Server) handleONUHardReboot(onu *device.Onu) {
	logger.Debug("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(30 * time.Second)
	s.activateOnu(onu)
}

func (s *Server) handleONUSoftReboot(IntfID uint32, OnuID uint32) {
	logger.Debug("handleONUSoftReboot() invoked")
	onu, err := s.GetOnuByID(OnuID, IntfID)
	if err != nil {
		logger.Error("No onu found with given OnuID on interface %v", IntfID)
	}
	OnuAlarmRequest := &pb.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(10 * 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) {
	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.ONU_FREE {
			// 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.ONU_INACTIVE
			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 {
	for _, onu := range s.Onumap[intfid] {
		if onu.InternalState == device.ONU_FREE || onu.InternalState == device.ONU_INACTIVE {
			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.Debug("Deactivating ONU %d for Intf: %d", onu.OnuID, onu.IntfID)

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

	// 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) {
	for intfid := range onumap {
		for _, onu := range onumap[intfid] {
			onu.UpdateIntState(device.ONU_FREE)
		}
	}
}

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

func (s *Server) fetchPortDetail(intfID uint32, portType string) (*pb.PortInfo, error) {
	logger.Debug("fetchPortDetail() invoked")
	portInfo := &pb.PortInfo{}
	switch portType {
	case device.IntfNni:
		if !s.isNniIntfPresentInOlt(intfID) {
			return &pb.PortInfo{}, errors.New("NNI " + strconv.Itoa(int(intfID)) + " not present in " +
				strconv.Itoa(int(s.Olt.ID)))
		}
		portInfo = &pb.PortInfo{
			PortType:          portType,
			PortId:            intfID,
			PonPortMaxOnus:    0,
			PonPortActiveOnus: 0,
			PortState:         s.Olt.NniIntfs[intfID].OperState,
			AlarmState:        device.OLTAlarmStateToString[s.Olt.NniIntfs[intfID].AlarmState],
		}
		return portInfo, nil

	case device.IntfPon:
		if !s.isPonIntfPresentInOlt(intfID) {
			return &pb.PortInfo{}, errors.New("PON " + strconv.Itoa(int(intfID)) + " not present in OLT-" +
				strconv.Itoa(int(s.Olt.ID)))
		}
		portInfo = &pb.PortInfo{
			PortType:          portType,
			PortId:            intfID,
			PonPortMaxOnus:    int32(len(s.Onumap[uint32(intfID)])),
			PonPortActiveOnus: s.getNoOfActiveOnuByPortID(intfID),
			PortState:         s.Olt.PonIntfs[intfID].OperState,
			AlarmState:        device.OLTAlarmStateToString[s.Olt.PonIntfs[intfID].AlarmState],
		}
		return portInfo, nil
	default:
		return &pb.PortInfo{}, errors.New(portType + " is not a valid port type")
	}
}

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

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

		if request.DeviceAction != SoftReboot && request.DeviceAction != HardReboot {
			return request, errors.New("invalid device action provided")
		}
		return request, nil
	case DeviceTypeOlt:
		request.DeviceType = DeviceTypeOlt
		request.DeviceAction = 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.ONU_ACTIVE || onu.InternalState == device.ONU_OMCIACTIVE {
			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
}