diff options
author | Priyadharshini <priyadharshini.b96@wipro.com> | 2020-03-16 05:55:43 +0000 |
---|---|---|
committer | Priyadharshini <priyadharshini.b96@wipro.com> | 2020-03-23 09:11:55 +0530 |
commit | cfb63b2c5c381434a6fdea794ad0c2e89a2be328 (patch) | |
tree | 586b997a0634198bf0b0ded5dbbde51ff7311b27 /ransim/ransimctrlr/RANSIM-CTRLR/src/main/java/org/onap/ransim/rest/api/controller/RansimPciHandler.java | |
parent | 44d8e15bda321936078b99f8222175a8ab016bc6 (diff) |
Initial code check-in RANSim Controller and RANSim GUI
Issue-ID: INT-1485
Signed-off-by: Priyadharshini <priyadharshini.b96@wipro.com>
Change-Id: I99fe693065072ff5c9b188f2177488a4cd93237d
Diffstat (limited to 'ransim/ransimctrlr/RANSIM-CTRLR/src/main/java/org/onap/ransim/rest/api/controller/RansimPciHandler.java')
-rw-r--r-- | ransim/ransimctrlr/RANSIM-CTRLR/src/main/java/org/onap/ransim/rest/api/controller/RansimPciHandler.java | 1011 |
1 files changed, 1011 insertions, 0 deletions
diff --git a/ransim/ransimctrlr/RANSIM-CTRLR/src/main/java/org/onap/ransim/rest/api/controller/RansimPciHandler.java b/ransim/ransimctrlr/RANSIM-CTRLR/src/main/java/org/onap/ransim/rest/api/controller/RansimPciHandler.java new file mode 100644 index 0000000..e4796e8 --- /dev/null +++ b/ransim/ransimctrlr/RANSIM-CTRLR/src/main/java/org/onap/ransim/rest/api/controller/RansimPciHandler.java @@ -0,0 +1,1011 @@ +/*- + * ============LICENSE_START======================================================= + * Ran Simulator Controller + * ================================================================================ + * Copyright (C) 2020 Wipro Limited. + * ================================================================================ + * 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. + * ============LICENSE_END========================================================= + */ + +package org.onap.ransim.rest.api.controller; + +import java.io.BufferedReader; +import java.io.File; +import java.io.FileReader; +import java.util.ArrayList; +import java.util.Collections; +import java.util.HashMap; +import java.util.HashSet; +import java.util.List; +import java.util.Map; +import java.util.Set; +import java.util.UUID; +import java.util.concurrent.ConcurrentHashMap; + +import javax.persistence.EntityManager; +import javax.persistence.EntityManagerFactory; +import javax.persistence.Persistence; +import javax.websocket.Session; + +import org.apache.log4j.Logger; +import org.onap.ransim.rest.api.models.CellDetails; +import org.onap.ransim.rest.api.models.CellNeighbor; +import org.onap.ransim.rest.api.models.FmAlarmInfo; +import org.onap.ransim.rest.api.models.GetNeighborList; +import org.onap.ransim.rest.api.models.NeighborDetails; +import org.onap.ransim.rest.api.models.NetconfServers; +import org.onap.ransim.rest.api.models.OperationLog; +import org.onap.ransim.rest.api.models.PmDataDump; +import org.onap.ransim.rest.api.models.PmParameters; +import org.onap.ransim.websocket.model.AdditionalMeasurements; +import org.onap.ransim.websocket.model.CommonEventHeaderFm; +import org.onap.ransim.websocket.model.CommonEventHeaderPm; +import org.onap.ransim.websocket.model.EventFm; +import org.onap.ransim.websocket.model.EventPm; +import org.onap.ransim.websocket.model.FaultFields; +import org.onap.ransim.websocket.model.FmMessage; +import org.onap.ransim.websocket.model.Measurement; +import org.onap.ransim.websocket.model.PmMessage; +import org.onap.ransim.websocket.server.RansimWebSocketServer; + +import com.google.gson.Gson; + +public class RansimPciHandler { + + private static RansimPciHandler rsPciHandler = null; + + private RansimPciHandler() { + + } + + /** + * To accesss variable of this class from another class. + * + * @return returns rscontroller constructor + */ + public static synchronized RansimPciHandler getRansimPciHandler() { + if (rsPciHandler == null) { + rsPciHandler = new RansimPciHandler(); + } + return rsPciHandler; + } + + static Logger log = Logger.getLogger(RansimPciHandler.class + .getName()); + + RansimController rsCtrlr = RansimController.getRansimController(); + + static Map<String, String> globalFmCellIdUuidMap = new ConcurrentHashMap<String, String>(); + static Map<String, String> globalPmCellIdUuidMap = new ConcurrentHashMap<String, String>(); + + Set<String> cellsWithIssues = new HashSet<>(); + + List<PmParameters> pmParameters = new ArrayList<PmParameters>(); + int next = 0; + + static FmAlarmInfo setCollisionConfusionFromFile(String cellNodeId) { + + FmAlarmInfo result = new FmAlarmInfo(); + RansimControllerDatabase rsDb = new RansimControllerDatabase(); + + try { + + boolean collisionDetected = false; + boolean confusionDetected = false; + List<Long> nbrPcis = new ArrayList<Long>(); + List<Long> ConfusionPcis = new ArrayList<Long>(); + int collisionCount = 0; + int confusionCount = 0; + CellDetails currentCell = rsDb.getCellDetail(cellNodeId); + + log.info("Setting confusion/collision for Cell :" + cellNodeId); + + GetNeighborList cellNbrDetails = generateNeighborList(cellNodeId); + + for (CellDetails firstLevelNbr : cellNbrDetails.getCellsWithHo()) { + if (nbrPcis + .contains(new Long(firstLevelNbr.getPhysicalCellId()))) { + confusionDetected = true; + if (ConfusionPcis.contains(firstLevelNbr + .getPhysicalCellId())) { + confusionCount++; + } else { + ConfusionPcis.add(firstLevelNbr.getPhysicalCellId()); + confusionCount = confusionCount + 2; + } + + } else { + nbrPcis.add(new Long(firstLevelNbr.getPhysicalCellId())); + } + + if (currentCell.getPhysicalCellId() == firstLevelNbr + .getPhysicalCellId()) { + collisionDetected = true; + collisionCount++; + } + } + + currentCell.setPciCollisionDetected(collisionDetected); + currentCell.setPciConfusionDetected(confusionDetected); + + if (!currentCell.isPciCollisionDetected() + && !currentCell.isPciConfusionDetected()) { + currentCell.setColor("#BFBFBF"); // GREY - No Issues + result.setProblem("No Issues"); + } else if (currentCell.isPciCollisionDetected() + && currentCell.isPciConfusionDetected()) { + currentCell.setColor("#C30000"); // BROWN - Cell has both + // collision & confusion + result.setProblem("CollisionAndConfusion"); + + } else if (currentCell.isPciCollisionDetected()) { + currentCell.setColor("#FF0000"); // RED - Cell has collision + result.setProblem("Collision"); + + } else if (currentCell.isPciConfusionDetected()) { + currentCell.setColor("#E88B00"); // ORANGE - Cell has confusion + result.setProblem("Confusion"); + + } else { + currentCell.setColor("#BFBFBF"); // GREY - No Issues + result.setProblem("No Issues"); + } + + result.setCollisionCount("" + collisionCount); + result.setConfusionCount("" + confusionCount); + + rsDb.mergeCellDetails(currentCell); + + return result; + + } catch (Exception e2) { + log.info("setCollisionConfusionFromFile :", e2); + + return null; + } + + } + + /** + * Generates separate list of neighbors with and without hand-off for a + * cell. + * + * @param nodeId + * Node Id of cell for which the neighbor list is generated + * @return Returns GetNeighborList object + */ + static GetNeighborList generateNeighborList(String nodeId) { + + EntityManagerFactory emfactory = Persistence + .createEntityManagerFactory("ransimctrlrdb"); + EntityManager entitymanager = emfactory.createEntityManager(); + try { + log.info("inside generateNeighborList for: " + nodeId); + RansimControllerDatabase rsDb = new RansimControllerDatabase(); + CellNeighbor neighborList = entitymanager.find(CellNeighbor.class, + nodeId); + GetNeighborList result = new GetNeighborList(); + + List<CellDetails> cellsWithNoHO = new ArrayList<CellDetails>(); + List<CellDetails> cellsWithHO = new ArrayList<CellDetails>(); + + List<NeighborDetails> nbrList = new ArrayList<NeighborDetails>( + neighborList.getNeighborList()); + long readCellDetail = 0; + long checkBlacklisted = 0; + + for (int i = 0; i < nbrList.size(); i++) { + + CellDetails nbr = entitymanager.find(CellDetails.class, nbrList + .get(i).getNeigbor().getNeighborCell()); + + if (nbrList.get(i).isBlacklisted()) { + cellsWithNoHO.add(nbr); + } else { + cellsWithHO.add(nbr); + } + + } + + result.setNodeId(nodeId); + result.setCellsWithHo(cellsWithHO); + result.setCellsWithNoHo(cellsWithNoHO); + + return result; + + } catch (Exception eu) { + log.info("/getNeighborList", eu); + if (entitymanager.getTransaction().isActive()) { + entitymanager.getTransaction().rollback(); + } + return null; + } finally { + entitymanager.close(); + emfactory.close(); + } + } + + static void checkCollisionAfterModify() { + RansimControllerDatabase rsDb = new RansimControllerDatabase(); + try { + List<CellDetails> checkCollisionConfusion = rsDb + .getCellsWithCollisionOrConfusion(); + + for (int i = 0; i < checkCollisionConfusion.size(); i++) { + log.info(checkCollisionConfusion.get(i).getNodeId()); + setCollisionConfusionFromFile(checkCollisionConfusion.get(i) + .getNodeId()); + } + } catch (Exception eu) { + log.info("checkCollisionAfterModify", eu); + } + } + + /** + * It updates the cell with its new neighbor list and PCI and updates the + * change in a database. + * + * @param nodeId + * node Id of the cell + * @param physicalCellId + * PCI number of the cell + * @param newNbrs + * List of new neighbors for the cell + * @param source + * The source from which cell modification has been triggered + * @return returns success or failure message + */ + public int modifyCellFunction(String nodeId, long physicalCellId, + List<NeighborDetails> newNbrs, String source) { + + int result = 111; + + RansimControllerDatabase rsDb = new RansimControllerDatabase(); + log.info("modifyCellFunction nodeId:" + nodeId + ", physicalCellId:" + + physicalCellId); + CellDetails modifyCell = rsDb.getCellDetail(nodeId); + + if (modifyCell != null) { + if (physicalCellId < 0 + || physicalCellId > rsCtrlr.maxPciValueAllowed) { + log.info("NewPhysicalCellId is empty or invalid"); + result = 400; + } else { + long oldPciId = modifyCell.getPhysicalCellId(); + if (physicalCellId != oldPciId) { + updatePciOperationsTable(nodeId, source, physicalCellId, + oldPciId); + + modifyCell.setPhysicalCellId(physicalCellId); + rsDb.mergeCellDetails(modifyCell); + } + + CellNeighbor neighbors = rsDb.getCellNeighbor(nodeId); + List<NeighborDetails> oldNbrList = new ArrayList<NeighborDetails>( + neighbors.getNeighborList()); + List<NeighborDetails> oldNbrListWithHo = new ArrayList<NeighborDetails>(); + + for (NeighborDetails cell : oldNbrList) { + if (!cell.isBlacklisted()) { + oldNbrListWithHo.add(cell); + } + } + + boolean flag = false; + + List<NeighborDetails> addedNbrs = new ArrayList<NeighborDetails>(); + List<NeighborDetails> deletedNbrs = new ArrayList<NeighborDetails>(); + + String nbrsDel = ""; + + List<String> oldNbrsArr = new ArrayList<String>(); + for (NeighborDetails cell : oldNbrListWithHo) { + oldNbrsArr.add(cell.getNeigbor().getNeighborCell()); + } + + List<String> newNbrsArr = new ArrayList<String>(); + for (NeighborDetails cell : newNbrs) { + newNbrsArr.add(cell.getNeigbor().getNeighborCell()); + } + + for (NeighborDetails cell : oldNbrListWithHo) { + + if (!newNbrsArr.contains(cell.getNeigbor() + .getNeighborCell())) { + if (!flag) { + flag = true; + } + deletedNbrs.add(cell); + if (nbrsDel == "") { + nbrsDel = cell.getNeigbor().getNeighborCell(); + } else { + nbrsDel += "," + + cell.getNeigbor().getNeighborCell(); + } + log.info("deleted cell: " + + cell.getNeigbor().getNeighborCell() + + cell.isBlacklisted()); + + } + } + + String nbrsAdd = ""; + + for (NeighborDetails cell : newNbrs) { + if (cell.isBlacklisted()) { + addedNbrs.add(cell); + } else { + if (!oldNbrsArr.contains(cell.getNeigbor() + .getNeighborCell())) { + addedNbrs.add(cell); + if (nbrsAdd == "") { + nbrsAdd = cell.getNeigbor().getNeighborCell(); + } else { + nbrsAdd += "," + + cell.getNeigbor().getNeighborCell(); + } + log.info("added cell: " + + cell.getNeigbor().getNeighborCell() + + cell.isBlacklisted()); + } + } + + } + List<NeighborDetails> newNeighborList = new ArrayList<NeighborDetails>( + oldNbrList); + for (NeighborDetails cell : deletedNbrs) { + NeighborDetails removeHo = new NeighborDetails( + cell.getNeigbor(), true); + rsDb.mergeNeighborDetails(removeHo); + newNeighborList.add(removeHo); + } + + for (NeighborDetails cell : addedNbrs) { + rsDb.mergeNeighborDetails(cell); + newNeighborList.add(cell); + } + + if (!flag) { + if (newNbrs.size() != oldNbrList.size()) { + flag = true; + } + } + + if (flag) { + updateNbrsOperationsTable(nodeId, source, nbrsAdd, nbrsDel); + } + + if (newNbrs != null) { + neighbors.getNeighborList().clear(); + Set<NeighborDetails> updatedNbrList = new HashSet<NeighborDetails>( + newNeighborList); + neighbors.setNeighborList(updatedNbrList); + rsDb.mergeCellNeighbor(neighbors); + } + + generateFmData(source, modifyCell, newNeighborList); + + result = 200; + } + + + } else { + result = 400; + } + + return result; + } + + public void checkCellsWithIssue() { + + EntityManagerFactory emfactory = Persistence + .createEntityManagerFactory("ransimctrlrdb"); + EntityManager entitymanager = emfactory.createEntityManager(); + try { + + for (String id : cellsWithIssues) { + CellDetails currentCell = entitymanager.find(CellDetails.class, + id); + FmMessage fmDataMessage = new FmMessage(); + List<EventFm> data = new ArrayList<EventFm>(); + + if (!currentCell.isPciCollisionDetected()) { + if (!currentCell.isPciConfusionDetected()) { + + cellsWithIssues.remove(id); + CommonEventHeaderFm commonEventHeader = new CommonEventHeaderFm(); + FaultFields faultFields = new FaultFields(); + + commonEventHeader.setStartEpochMicrosec(System + .currentTimeMillis() * 1000); + commonEventHeader + .setSourceName(currentCell.getNodeId()); + commonEventHeader.setReportingEntityName(currentCell + .getServerId()); + String uuid = globalFmCellIdUuidMap.get(currentCell + .getNodeId()); + commonEventHeader.setSourceUuid(uuid); + + faultFields + .setAlarmCondition("RanPciCollisionConfusionOccurred"); + faultFields.setEventSeverity("NORMAL"); + faultFields.setEventSourceType("other"); + faultFields.setSpecificProblem("Problem Solved"); + + commonEventHeader.setLastEpochMicrosec(System + .currentTimeMillis() * 1000); + + EventFm event = new EventFm(); + event.setCommonEventHeader(commonEventHeader); + event.setFaultFields(faultFields); + + data.add(event); + } + } + + fmDataMessage.setFmEventList(data); + + if (!data.isEmpty()) { + sendFmData(currentCell.getServerId(), fmDataMessage); + } + + } + + } catch (Exception eu) { + if (entitymanager.getTransaction().isActive()) { + entitymanager.getTransaction().rollback(); + } + log.info("Exception:", eu); + } finally { + entitymanager.close(); + emfactory.close(); + } + + } + + void updatePciOperationsTable(String nodeId, String source, long physicalCellId, long oldPciId) { + EntityManagerFactory emfactory = Persistence.createEntityManagerFactory("ransimctrlrdb"); + EntityManager entitymanager = emfactory.createEntityManager(); + OperationLog operationLog = new OperationLog(); + + entitymanager.getTransaction().begin(); + operationLog.setNodeId(nodeId); + operationLog.setFieldName("PCID"); + operationLog.setOperation("Modify"); + operationLog.setSource(source); + operationLog.setTime(System.currentTimeMillis()); + operationLog.setMessage("PCID value changed from " + oldPciId + " to " + physicalCellId); + entitymanager.merge(operationLog); + entitymanager.flush(); + entitymanager.getTransaction().commit(); + } + + void updateNbrsOperationsTable(String nodeId, String source, String addedNbrs, String deletedNbrs) { + + EntityManagerFactory emfactory = Persistence.createEntityManagerFactory("ransimctrlrdb"); + EntityManager entitymanager = emfactory.createEntityManager(); + entitymanager.getTransaction().begin(); + OperationLog operationLogNbrChng = new OperationLog(); + operationLogNbrChng.setNodeId(nodeId); + operationLogNbrChng.setFieldName("Neighbors"); + operationLogNbrChng.setOperation("Modify"); + operationLogNbrChng.setSource(source); + + log.info(" Neighbors added " + addedNbrs + "."); + log.info(" Neighbors removed " + deletedNbrs + "."); + String message = ""; + if(!addedNbrs.equals("")){ + message += " Neighbors added " + addedNbrs + "." ; + } + + if(!deletedNbrs.equals("")){ + message += " Neighbors removed " + deletedNbrs + "." ; + } + + operationLogNbrChng.setMessage(message); + operationLogNbrChng.setTime(System.currentTimeMillis()); + entitymanager.merge(operationLogNbrChng); + entitymanager.flush(); + entitymanager.getTransaction().commit(); + + } + + /** + * Sends PM message to the netconf agent through the websocket server. + * + * @param serverId + * Netconf agent - Server ID to which the message is sent. + * @param pmMessage + * PM message to be sent. + */ + void sendPmdata(String serverId, String pmMessage) { + + log.info("Sending PM message to netconf agent"); + + String ipPort = rsCtrlr.serverIdIpPortMapping.get(serverId); + + if (ipPort != null && !ipPort.trim().equals("")) { + + String[] ipPortArr = ipPort.split(":"); + if (ipPort != null && !ipPort.trim().equals("")) { + + Session clSess = rsCtrlr.webSocketSessions.get(ipPort); + log.info("PM message. Netconf agent IP:" + ipPort); + if (clSess != null) { + RansimWebSocketServer.sendPmMessage(pmMessage, clSess); + log.info("Pm Data jsonStr: " + pmMessage); + log.info("PM message sent to netconf agent"); + } else { + log.info("No client session for " + ipPort); + } + } else { + log.info("Pm message not sent, ipPort is null"); + } + } else { + + log.info("Pm message not sent, ipPort is null. Server Id: " + + serverId); + } + + } + + /** + * + * Reads the values PM parameter values from a dump file. + * + */ + public void readPmParameters() { + + File dumpFile = null; + String kpiName = ""; + PmDataDump pmDump = null; + String jsonString = ""; + int next = 0; + dumpFile = new File("PM_Kpi_Data.json"); + + BufferedReader br = null; + + try { + log.info("Reading dump file"); + br = new BufferedReader(new FileReader(dumpFile)); + + StringBuilder sb = new StringBuilder(); + String line = br.readLine(); + + while (line != null) { + sb.append(line); + sb.append("\n"); + line = br.readLine(); + } + jsonString = sb.toString(); + + pmDump = new Gson().fromJson(jsonString, PmDataDump.class); + log.info("Dump value: " + + pmDump.getKpiDump().get(0).getParameter1()); + pmParameters = new ArrayList<PmParameters>(pmDump.getKpiDump()); + + } catch (Exception eu) { + log.info("Exception: ", eu); + } + } + + private static String getUuid() { + return UUID.randomUUID().toString(); + } + + /** + * Sets values for all the parameters in the PM message + * + * @param nodeIdBad + * List of node Ids with bad performance values + * @param nodeIdPoor + * List of node Ids with poor performance values + * @return It returns the pm message + */ + public List<String> generatePmData(String nodeIdBad, String nodeIdPoor) { + + List<String> result = new ArrayList<>(); + RansimControllerDatabase rcDb = new RansimControllerDatabase(); + + String parameter1 = ""; + String successValue1 = ""; + String badValue1 = ""; + String poorValue1 = ""; + String parameter2 = ""; + String successValue2 = ""; + String badValue2 = ""; + String poorValue2 = ""; + + try { + + if (next >= pmParameters.size()) { + next = 0; + log.info("next : " + next); + } + try { + log.info("next : " + next); + parameter1 = pmParameters.get(next).getParameter1(); + successValue1 = pmParameters.get(next).getSuccessValue1(); + badValue1 = pmParameters.get(next).getBadValue1(); + poorValue1 = pmParameters.get(next).getPoorValue1(); + parameter2 = pmParameters.get(next).getParameter2(); + successValue2 = pmParameters.get(next).getSuccessValue2(); + badValue2 = pmParameters.get(next).getBadValue2(); + poorValue2 = pmParameters.get(next).getPoorValue2(); + next++; + } catch (Exception e) { + log.info("Exception: ", e); + } + + List<NetconfServers> cnl = rcDb.getNetconfServersList(); + log.info("obtained data from db"); + String[] cellIdsBad = null; + String[] cellIdsPoor = null; + Set<String> nodeIdsBad = new HashSet<String>(); + Set<String> nodeIdsPoor = new HashSet<String>(); + + if (nodeIdBad != null) { + cellIdsBad = nodeIdBad.split(","); + for (int a = 0; a < cellIdsBad.length; a++) { + nodeIdsBad.add(cellIdsBad[a].trim()); + } + } + if (nodeIdPoor != null) { + cellIdsPoor = nodeIdPoor.split(","); + for (int a = 0; a < cellIdsPoor.length; a++) { + nodeIdsPoor.add(cellIdsPoor[a].trim()); + } + } + + for (int i = 0; i < cnl.size(); i++) { + + long startTime = System.currentTimeMillis(); + List<CellDetails> cellList = new ArrayList<CellDetails>(cnl + .get(i).getCells()); + List<EventPm> data = new ArrayList<EventPm>(); + + for (int j = 0; j < cellList.size(); j++) { + + long startTimeCell = System.currentTimeMillis(); + String nodeId = cellList.get(j).getNodeId(); + EventPm event = new EventPm(); + CommonEventHeaderPm commonEventHeader = new CommonEventHeaderPm(); + commonEventHeader.setSourceName(nodeId); + commonEventHeader.setStartEpochMicrosec(System + .currentTimeMillis() * 1000); + String uuid = globalPmCellIdUuidMap.get(nodeId); + if (uuid == null) { + uuid = getUuid(); + globalPmCellIdUuidMap.put(nodeId, uuid); + } + commonEventHeader.setSourceUuid(uuid); + + Measurement measurement = new Measurement(); + measurement.setMeasurementInterval(180); + + GetNeighborList cellNbrList = generateNeighborList(nodeId); + + long startTimeCheckBadPoor = System.currentTimeMillis(); + + boolean checkBad = false; + boolean checkPoor = false; + int countBad = 0; + int countPoor = 0; + + if (nodeIdsBad.contains(nodeId)) { + checkBad = true; + countBad = (int) (cellNbrList.getCellsWithHo().size() * 0.2); + } + if (nodeIdsPoor.contains(nodeId)) { + checkPoor = true; + countPoor = (int) (cellNbrList.getCellsWithHo().size() * 0.2); + } + + long endTimeCheckBadPoor = System.currentTimeMillis(); + + List<AdditionalMeasurements> additionalMeasurements = new ArrayList<AdditionalMeasurements>(); + if (checkPoor || checkBad) { + + Collections.sort(cellNbrList.getCellsWithHo()); + + for (int k = 0; k < cellNbrList.getCellsWithHo().size(); k++) { + AdditionalMeasurements addMsmnt = new AdditionalMeasurements(); + addMsmnt.setName(cellNbrList.getCellsWithHo() + .get(k).getNodeId()); + Map<String, String> hashMap = new HashMap<String, String>(); + hashMap.put("networkId", cellNbrList + .getCellsWithHo().get(k).getNetworkId()); + + hashMap.put(parameter1, successValue1); + + if (checkBad == true) { + + if (countBad > 0) { + log.info("countBad: " + countBad); + hashMap.put(parameter2, badValue2); + countBad--; + } else { + hashMap.put(parameter2, successValue2); + } + + } else if (checkPoor == true) { + if (countPoor > 0) { + log.info("countBad: " + countPoor); + hashMap.put(parameter2, poorValue2); + countPoor--; + } else { + hashMap.put(parameter2, successValue2); + } + + } + + addMsmnt.setHashMap(hashMap); + + additionalMeasurements.add(addMsmnt); + + } + } else { + for (int k = 0; k < cellNbrList.getCellsWithHo().size(); k++) { + AdditionalMeasurements addMsmnt = new AdditionalMeasurements(); + addMsmnt.setName(cellNbrList.getCellsWithHo() + .get(k).getNodeId()); + Map<String, String> hashMap = new HashMap<String, String>(); + + hashMap.put("networkId", cellNbrList + .getCellsWithHo().get(k).getNetworkId()); + + hashMap.put(parameter1, successValue1); + + hashMap.put(parameter2, successValue2); + + addMsmnt.setHashMap(hashMap); + additionalMeasurements.add(addMsmnt); + } + } + + commonEventHeader.setLastEpochMicrosec(System + .currentTimeMillis() * 1000); + measurement + .setAdditionalMeasurements(additionalMeasurements); + + event.setCommonEventHeader(commonEventHeader); + event.setMeasurement(measurement); + + data.add(event); + long endTimeCell = System.currentTimeMillis(); + } + + long endTime = System.currentTimeMillis(); + log.info("Time taken for generating PM data for " + + cnl.get(i).getServerId() + " : " + + (endTime - startTime)); + PmMessage msg = new PmMessage(); + + if (data.size() > 0) { + msg.setEventPmList(data); + Gson gson = new Gson(); + String jsonStr = gson.toJson(msg); + sendPmdata(cnl.get(i).getServerId(), jsonStr); + + result.add(jsonStr); + } + + } + } catch (Exception e) { + log.info("Exception in string builder", e); + } + + return result; + } + + /** + * Sets the value for all fields in the FM data for individual cell. + * + * @param networkId + * Network Id of the cell + * @param ncServer + * Server Id of the cell + * @param cellId + * Node Id of the cell + * @param issue + * Contains the collision/confusion details of the cess + * @return returns EventFm object, with all the necessary parameters. + */ + public static EventFm setEventFm(String networkId, String ncServer, + String cellId, FmAlarmInfo issue) { + + log.info("Inside generate FmData"); + EventFm event = new EventFm(); + + try { + + CommonEventHeaderFm commonEventHeader = new CommonEventHeaderFm(); + FaultFields faultFields = new FaultFields(); + + commonEventHeader + .setStartEpochMicrosec(System.currentTimeMillis() * 1000); + commonEventHeader.setSourceName(cellId); + commonEventHeader.setReportingEntityName(ncServer); + + String uuid = globalFmCellIdUuidMap.get(cellId); + if (uuid == null) { + uuid = getUuid(); + globalFmCellIdUuidMap.put(cellId, uuid); + } + commonEventHeader.setSourceUuid(uuid); + + if (issue.getProblem().equals("Collision") + || issue.getProblem().equals("Confusion") + || issue.getProblem().equals("CollisionAndConfusion")) { + faultFields + .setAlarmCondition("RanPciCollisionConfusionOccurred"); + faultFields.setEventSeverity("CRITICAL"); + faultFields.setEventSourceType("other"); + faultFields.setSpecificProblem(issue.getProblem()); + + Map<String, String> alarmAdditionalInformation = new HashMap<String, String>(); + alarmAdditionalInformation.put("networkId", networkId); + alarmAdditionalInformation.put("collisions", + issue.getCollisionCount()); + alarmAdditionalInformation.put("confusions", + issue.getConfusionCount()); + + faultFields + .setAlarmAdditionalInformation(alarmAdditionalInformation); + + } + commonEventHeader + .setLastEpochMicrosec(System.currentTimeMillis() * 1000); + + event.setCommonEventHeader(commonEventHeader); + event.setFaultFields(faultFields); + + } catch (Exception e) { + log.info("Exception: ", e); + } + + return event; + + } + + /** + * It checks if the cell or any of its neighbors have collision/confusion + * issue. If there are any issues it generates the FM data for the entire + * cluster + * + * @param source + * The source from which the cell modification has been + * triggered. + * @param cell + * Details of the given cell. + * @param newNeighborList + * Neighbor list of the given cell. + */ + public void generateFmData(String source, CellDetails cell, + List<NeighborDetails> newNeighborList) { + + List<EventFm> listCellIssue = new ArrayList<EventFm>(); + Set<String> ncs = new HashSet<>(); + log.info("Generating Fm data"); + + RansimControllerDatabase rsDb = new RansimControllerDatabase(); + + FmAlarmInfo op1 = setCollisionConfusionFromFile(cell.getNodeId()); + + if (source.equals("GUI")) { + if (op1.getProblem().equals("CollisionAndConfusion") + || op1.getProblem().equals("Collision") + || op1.getProblem().equals("Confusion")) { + log.info("op1: " + op1); + EventFm lci = setEventFm(cell.getNetworkId(), + cell.getServerId(), cell.getNodeId(), op1); + listCellIssue.add(lci); + ncs.add(cell.getServerId()); + log.info("Generating Fm data for: " + cell.getNodeId()); + } + } + + for (NeighborDetails cd : newNeighborList) { + FmAlarmInfo op2 = setCollisionConfusionFromFile(cd.getNeigbor() + .getNeighborCell()); + CellDetails nbrCell = rsDb.getCellDetail(cd.getNeigbor() + .getNeighborCell()); + + if (source.equals("GUI")) { + if (op2.getProblem().equals("CollisionAndConfusion") + || op2.getProblem().equals("Collision") + || op2.getProblem().equals("Confusion")) { + EventFm lci = setEventFm(nbrCell.getNetworkId(), + nbrCell.getServerId(), nbrCell.getNodeId(), op2); + log.info("FmData added:" + nbrCell.getNodeId()); + listCellIssue.add(lci); + ncs.add(nbrCell.getServerId()); + log.info("Generating Fm data for: " + nbrCell.getNodeId()); + } + } + + } + + if (source.equals("GUI")) { + for (String nc : ncs) { + + FmMessage fmDataMessage = new FmMessage(); + List<EventFm> data = new ArrayList<EventFm>(); + log.info("listCellIssue.size(): " + listCellIssue.size()); + for (EventFm cellIssue : listCellIssue) { + if (cellIssue.getCommonEventHeader() + .getReportingEntityName().equals(nc)) { + data.add(cellIssue); + if (!cellsWithIssues.contains(cellIssue + .getCommonEventHeader().getSourceName())) { + cellsWithIssues.add(cellIssue + .getCommonEventHeader().getSourceName()); + } + + } + } + log.info("data.size(): " + data.size()); + + if (data.size() > 0) { + fmDataMessage.setFmEventList(data); + log.info("Sending FM message: "); + sendFmData(nc, fmDataMessage); + } + + } + } + + } + + /** + * Sends the FM data message to the netconf agent through the ransim + * websocket server. + * + * @param serverId + * server id of the netconf agent + * @param fmDataMessage + * FM message to be sent + */ + public void sendFmData(String serverId, FmMessage fmDataMessage) { + + log.info("inside sendFmData"); + Gson gson = new Gson(); + String jsonStr = gson.toJson(fmDataMessage); + + log.info("Fm Data jsonStr: " + jsonStr); + + String ipPort = rsCtrlr.serverIdIpPortMapping.get(serverId); + + if (ipPort != null && !ipPort.trim().equals("")) { + + String[] ipPortArr = ipPort.split(":"); + log.info("Connection estabilished with ip: " + ipPort); + if (ipPort != null && !ipPort.trim().equals("")) { + Session clSess = rsCtrlr.webSocketSessions.get(ipPort); + if (clSess != null) { + log.info("FM message sent."); + RansimWebSocketServer.sendFmMessage(jsonStr, clSess); + } else { + log.info("No client session for " + ipPort); + } + } else { + log.info("No client for " + serverId); + } + } else { + log.info("No client for "); + } + + } + +} |