aboutsummaryrefslogtreecommitdiffstats
path: root/ransim/ransimctrlr/RANSIM-CTRLR/src/main/java/org/onap/ransim/rest/api/controller/RansimPciHandler.java
diff options
context:
space:
mode:
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.java1011
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 ");
+ }
+
+ }
+
+}