diff options
Diffstat (limited to 'ransim/ransimctrlr/RANSIM-CTRLR/src/main/java/org/onap/ransim/rest/api/controller')
4 files changed, 3300 insertions, 0 deletions
diff --git a/ransim/ransimctrlr/RANSIM-CTRLR/src/main/java/org/onap/ransim/rest/api/controller/RansimController.java b/ransim/ransimctrlr/RANSIM-CTRLR/src/main/java/org/onap/ransim/rest/api/controller/RansimController.java new file mode 100644 index 0000000..9ea789e --- /dev/null +++ b/ransim/ransimctrlr/RANSIM-CTRLR/src/main/java/org/onap/ransim/rest/api/controller/RansimController.java @@ -0,0 +1,1150 @@ +/*- + * ============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 com.google.gson.Gson; + +import java.io.BufferedReader; +import java.io.File; +import java.io.FileInputStream; +import java.io.FileReader; +import java.io.IOException; +import java.io.InputStream; +import java.util.ArrayList; +import java.util.Collections; +import java.util.HashMap; +import java.util.HashSet; +import java.util.Iterator; +import java.util.List; +import java.util.Map; +import java.util.Properties; +import java.util.Random; +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.persistence.Query; +import javax.persistence.TypedQuery; +import javax.websocket.Session; + +import org.apache.log4j.Logger; +import org.onap.ransim.websocket.model.*; +import org.onap.ransim.rest.api.models.CellData; +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.NbrDump; +import org.onap.ransim.rest.api.models.NeighborDetails; +import org.onap.ransim.rest.api.models.NeighborPmDetails; +import org.onap.ransim.rest.api.models.NeihborId; +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.rest.api.models.TopologyDump; +import org.onap.ransim.rest.client.RestClient; +import org.onap.ransim.websocket.model.FmMessage; +import org.onap.ransim.websocket.model.ModifyNeighbor; +import org.onap.ransim.websocket.model.ModifyPci; +import org.onap.ransim.websocket.model.Neighbor; +import org.onap.ransim.websocket.model.PmMessage; +import org.onap.ransim.websocket.model.SetConfigTopology; +import org.onap.ransim.websocket.model.Topology; +import org.onap.ransim.websocket.model.UpdateCell; +import org.onap.ransim.websocket.server.RansimWebSocketServer; +import org.springframework.http.HttpStatus; +import org.springframework.http.ResponseEntity; + +public class RansimController { + + static Logger log = Logger.getLogger(RansimController.class + .getName()); + + private static RansimController rsController = null; + Properties netconfConstants = new Properties(); + int gridSize = 10; + boolean collision = false; + String serverIdPrefix = ""; + static int numberOfCellsPerNcServer = 15; + int numberOfMachines = 1; + int numberOfProcessPerMc = 5; + boolean strictValidateRansimAgentsAvailability = false; + static public Map<String, Session> webSocketSessions = new ConcurrentHashMap<String, Session>(); + static Map<String, String> serverIdIpPortMapping = new ConcurrentHashMap<String, String>(); + + static Map<String, String> globalNcServerUuidMap = new ConcurrentHashMap<String, String>(); + static List<String> unassignedServerIds = Collections + .synchronizedList(new ArrayList<String>()); + static Map<String, List<String>> serverIdIpNodeMapping = new ConcurrentHashMap<String, List<String>>(); + int nextServerIdNumber = 1001; + String sdnrServerIp = ""; + int sdnrServerPort = 0; + static String sdnrServerUserid = ""; + static String sdnrServerPassword = ""; + static String dumpFileName = ""; + static long maxPciValueAllowed = 503; + + static RansimPciHandler rsPciHdlr = RansimPciHandler.getRansimPciHandler(); + + private RansimController() { + + } + + /** + * To accesss variable of this class from another class. + * + * @return returns rscontroller constructor + */ + public static synchronized RansimController getRansimController() { + if (rsController == null) { + rsController = new RansimController(); + new KeepWebsockAliveThread(rsController).start(); + } + return rsController; + } + + private String checkIpPortAlreadyExists(String ipPort, + Map<String, String> serverIdIpPortMapping) { + String serverId = null; + for (String key : serverIdIpPortMapping.keySet()) { + String value = serverIdIpPortMapping.get(key); + if (value.equals(ipPort)) { + serverId = key; + break; + } + } + return serverId; + } + + /** + * Add web socket sessions. + * + * @param ipPort + * ip address for the session + * @param wsSession + * session details + */ + public synchronized String addWebSocketSessions(String ipPort, + Session wsSession) { + loadProperties(); + if (webSocketSessions.containsKey(ipPort)) { + log.info("addWebSocketSessions: Client session " + + wsSession.getId() + " for " + ipPort + + " already exist. Removing old session."); + webSocketSessions.remove(ipPort); + } + + log.info("addWebSocketSessions: Adding Client session " + + wsSession.getId() + " for " + ipPort); + webSocketSessions.put(ipPort, wsSession); + String serverId = null; + if (!serverIdIpPortMapping.containsValue(ipPort)) { + if (unassignedServerIds.size() > 0) { + log.info("addWebSocketSessions: No serverIds pending to assign for " + + ipPort); + serverId = checkIpPortAlreadyExists(ipPort, + serverIdIpPortMapping); + if (serverId == null) { + serverId = unassignedServerIds.remove(0); + } else { + if (unassignedServerIds.contains(serverId)) { + unassignedServerIds.remove(serverId); + } + } + log.info("RansCtrller = Available unassigned ServerIds :" + + unassignedServerIds); + log.info("RansCtrller = addWebSocketSessions: Adding serverId " + + serverId + " for " + ipPort); + serverIdIpPortMapping.put(serverId, ipPort); + log.debug("RansCtrller = serverIdIpPortMapping >>>> :" + + serverIdIpPortMapping); + mapServerIdToNodes(serverId); + RansimControllerDatabase rsDb = new RansimControllerDatabase(); + try { + + NetconfServers server = rsDb.getNetconfServer(serverId); + if (server != null) { + server.setIp(ipPort.split(":")[0]); + server.setNetconfPort(ipPort.split(":")[1]); + rsDb.mergeNetconfServers(server); + } + + } catch (Exception e1) { + log.info("Exception mapServerIdToNodes :", e1); + } + } else { + log.info("addWebSocketSessions: No serverIds pending to assign for " + + ipPort); + } + } else { + for (String key : serverIdIpPortMapping.keySet()) { + if (serverIdIpPortMapping.get(key).equals(ipPort)) { + log.info("addWebSocketSessions: ServerId " + key + " for " + + ipPort + " is exist already"); + serverId = key; + break; + } + } + } + return serverId; + } + + /** + * Map server ID to the cells + * + * @param serverId + * Server ID + */ + private void mapServerIdToNodes(String serverId) { + dumpSessionDetails(); + if (serverIdIpNodeMapping.containsKey(serverId)) { + // already mapped.RansimController Do nothing. + } else { + List<String> nodeIds = new ArrayList<String>(); + RansimControllerDatabase rsDb = new RansimControllerDatabase(); + try { + List<CellDetails> nodes = rsDb.getCellsWithNoServerIds(); + for (CellDetails cell : nodes) { + cell.setServerId(serverId); + nodeIds.add(cell.getNodeId()); + rsDb.mergeCellDetails(cell); + } + serverIdIpNodeMapping.put(serverId, nodeIds); + } catch (Exception e1) { + log.info("Exception mapServerIdToNodes :", e1); + + } + } + } + + /** + * It removes the web socket sessions. + * + * @param ipPort + * ip address of the netconf server + */ + public synchronized void removeWebSocketSessions(String ipPort) { + RansimControllerDatabase rsDb = new RansimControllerDatabase(); + log.info("remove websocket session request received for: " + ipPort); + try { + if (webSocketSessions.containsKey(ipPort)) { + String removedServerId = null; + for (String serverId : serverIdIpPortMapping.keySet()) { + String ipPortVal = serverIdIpPortMapping.get(serverId); + if (ipPortVal.equals(ipPort)) { + if (!unassignedServerIds.contains(serverId)) { + unassignedServerIds.add(serverId); + log.info(serverId + "added in unassignedServerIds"); + } + NetconfServers ns = rsDb.getNetconfServer(serverId); + ns.setIp(null); + ns.setNetconfPort(null); + log.info(serverId + " ip and Port set as null "); + rsDb.mergeNetconfServers(ns); + removedServerId = serverId; + break; + } + } + serverIdIpPortMapping.remove(removedServerId); + + Session wsSession = webSocketSessions.remove(ipPort); + log.info("removeWebSocketSessions: Client session " + + wsSession.getId() + " for " + ipPort + + " is removed. Server Id : " + removedServerId); + } else { + log.info("addWebSocketSessions: Client session for " + ipPort + + " not exist"); + } + } catch (Exception e) { + log.info("Exception in removeWebSocketSessions. e: " + e); + } + + } + + /** + * Checks the number of ransim agents running. + * + * @param cellsToBeSimulated + * number of cells to be simulated + * @return returns true if there are enough ransim agents running + */ + public boolean hasEnoughRansimAgentsRunning(int cellsToBeSimulated) { + + log.info("hasEnoughRansimAgentsRunning: numberOfCellsPerNCServer " + + numberOfCellsPerNcServer + " , webSocketSessions.size:" + + webSocketSessions.size() + " , cellsToBeSimulated:" + + cellsToBeSimulated); + log.info(strictValidateRansimAgentsAvailability); + + if (strictValidateRansimAgentsAvailability) { + if (numberOfCellsPerNcServer * webSocketSessions.size() < cellsToBeSimulated) { + return false; + } + } + return true; + } + + /** + * It updates the constant values in the properties file. + */ + public void loadProperties() { + InputStream input = null; + try { + input = new FileInputStream( + "/tmp/ransim-install/config/ransim.properties"); + netconfConstants.load(input); + serverIdPrefix = netconfConstants.getProperty("serverIdPrefix"); + numberOfCellsPerNcServer = Integer.parseInt(netconfConstants + .getProperty("numberOfCellsPerNCServer")); + numberOfMachines = Integer.parseInt(netconfConstants + .getProperty("numberOfMachines")); + numberOfProcessPerMc = Integer.parseInt(netconfConstants + .getProperty("numberOfProcessPerMc")); + strictValidateRansimAgentsAvailability = Boolean + .parseBoolean(netconfConstants + .getProperty("strictValidateRansimAgentsAvailability")); + sdnrServerIp = netconfConstants.getProperty("sdnrServerIp"); + sdnrServerPort = Integer.parseInt(netconfConstants + .getProperty("sdnrServerPort")); + sdnrServerUserid = netconfConstants.getProperty("sdnrServerUserid"); + sdnrServerPassword = netconfConstants + .getProperty("sdnrServerPassword"); + dumpFileName = netconfConstants.getProperty("dumpFileName"); + maxPciValueAllowed = Long.parseLong(netconfConstants + .getProperty("maxPciValueAllowed")); + + } catch (Exception e) { + log.info("Properties file error", e); + } finally { + try { + if (input != null) { + input.close(); + } + } catch (Exception ex) { + log.info("Properties file error", ex); + } + } + } + + /** + * The function adds the cell(with nodeId passed as an argument) to its + * netconf server list if the netconf server already exists. Else it will + * create a new netconf server in the NetconfServers Table and the cell into + * its list. + * + * @param nodeId + * node Id of the cell + */ + static void setNetconfServers(String nodeId) { + + RansimControllerDatabase rsDb = new RansimControllerDatabase(); + CellDetails currentCell = rsDb.getCellDetail(nodeId); + + Set<CellDetails> newList = new HashSet<CellDetails>(); + try { + if (currentCell != null) { + NetconfServers server = rsDb.getNetconfServer(currentCell + .getServerId()); + + if (server == null) { + + server = new NetconfServers(); + server.setServerId(currentCell.getServerId()); + } else { + newList.addAll(server.getCells()); + } + + newList.add(currentCell); + server.setCells(newList); + log.info("setNetconfServers: nodeId: " + nodeId + ", X:" + + currentCell.getGridX() + ", Y:" + + currentCell.getGridY() + ", ip: " + server.getIp() + + ", portNum: " + server.getNetconfPort() + + ", serverId:" + currentCell.getServerId()); + + rsDb.mergeNetconfServers(server); + + } + + } catch (Exception eu) { + log.info("/setNetconfServers Function Error", eu); + + } + } + + private static double degToRadians(double angle) { + double radians = 57.2957795; + return (angle / radians); + } + + private static double metersDeglon(double angle) { + + double d2r = degToRadians(angle); + return ((111415.13 * Math.cos(d2r)) - (94.55 * Math.cos(3.0 * d2r)) + (0.12 * Math + .cos(5.0 * d2r))); + + } + + private static double metersDeglat(double angle) { + + double d2r = degToRadians(angle); + return (111132.09 - (566.05 * Math.cos(2.0 * d2r)) + + (1.20 * Math.cos(4.0 * d2r)) - (0.002 * Math.cos(6.0 * d2r))); + + } + + /** + * generateClusterFromFile() + * + * @throws IOException + */ + static void generateClusterFromFile() throws IOException { + + EntityManagerFactory emfactory = Persistence + .createEntityManagerFactory("ransimctrlrdb"); + EntityManager entitymanager = emfactory.createEntityManager(); + log.info("Inside generateClusterFromFile"); + File dumpFile = null; + String cellDetailsString = ""; + + dumpFile = new File(dumpFileName); + + 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(); + } + cellDetailsString = sb.toString(); + + TopologyDump dumpTopo = new Gson().fromJson(cellDetailsString, + TopologyDump.class); + CellDetails cellsDb = new CellDetails(); + + log.info("dumpTopo.getCellList().size():" + + dumpTopo.getCellList().size()); + for (int i = 0; i < dumpTopo.getCellList().size(); i++) { + Gson g = new Gson(); + String pnt = g.toJson(dumpTopo.getCellList().get(i)); + log.info("Creating Cell:" + pnt); + log.info("Creating Cell:" + + dumpTopo.getCellList().get(i).getCell().getNodeId()); + + cellsDb = new CellDetails(); + entitymanager.getTransaction().begin(); + cellsDb.setNodeId(dumpTopo.getCellList().get(i).getCell() + .getNodeId()); + cellsDb.setPhysicalCellId(dumpTopo.getCellList().get(i) + .getCell().getPhysicalCellId()); + cellsDb.setLongitude(dumpTopo.getCellList().get(i).getCell() + .getLongitude()); + cellsDb.setLatitude(dumpTopo.getCellList().get(i).getCell() + .getLatitude()); + cellsDb.setServerId(dumpTopo.getCellList().get(i).getCell() + .getPnfName()); + if (!unassignedServerIds.contains(cellsDb.getServerId())) { + unassignedServerIds.add(cellsDb.getServerId()); + } + cellsDb.setNetworkId(dumpTopo.getCellList().get(i).getCell() + .getNetworkId()); + + double lon = Float.valueOf(dumpTopo.getCellList().get(i) + .getCell().getLongitude()); + double lat = Float.valueOf(dumpTopo.getCellList().get(i) + .getCell().getLatitude()); + + double xx = (lon - 0) * metersDeglon(0); + double yy = (lat - 0) * metersDeglat(0); + + double rad = Math.sqrt(xx * xx + yy * yy); + + if (rad > 0) { + double ct = xx / rad; + double st = yy / rad; + xx = rad * ((ct * Math.cos(0)) + (st * Math.sin(0))); + yy = rad * ((st * Math.cos(0)) - (ct * Math.sin(0))); + } + + cellsDb.setScreenX((float) (xx)); + cellsDb.setScreenY((float) (yy)); + + List<String> attachedNoeds = serverIdIpNodeMapping.get(cellsDb + .getServerId()); + log.info("Attaching Cell:" + + dumpTopo.getCellList().get(i).getCell().getNodeId() + + " to " + cellsDb.getServerId()); + if (attachedNoeds == null) { + attachedNoeds = new ArrayList<String>(); + } + attachedNoeds.add(cellsDb.getNodeId()); + serverIdIpNodeMapping.put(cellsDb.getServerId(), attachedNoeds); + if (attachedNoeds.size() > numberOfCellsPerNcServer) { + log.warn("Attaching Cell:" + + dumpTopo.getCellList().get(i).getCell() + .getNodeId() + " to " + + cellsDb.getServerId() + + ", But it is exceeding numberOfCellsPerNcServer " + + numberOfCellsPerNcServer); + } + + entitymanager.merge(cellsDb); + entitymanager.flush(); + entitymanager.getTransaction().commit(); + + setNetconfServers(cellsDb.getNodeId()); + } + + dumpSessionDetails(); + + try { + + for (int i = 0; i < dumpTopo.getCellList().size(); i++) { + + String cellNodeId = dumpTopo.getCellList().get(i).getCell() + .getNodeId(); + entitymanager.getTransaction().begin(); + + // neighbor list with the corresponding node id + CellNeighbor neighborList = entitymanager.find( + CellNeighbor.class, cellNodeId); + // cell with the corresponding nodeId + CellDetails currentCell = entitymanager.find( + CellDetails.class, cellNodeId); + + Set<NeighborDetails> newCell = new HashSet<NeighborDetails>(); + + if (currentCell != null) { + if (neighborList == null) { + neighborList = new CellNeighbor(); + neighborList.setNodeId(cellNodeId); + } + List<NbrDump> neighboursFromFile = dumpTopo + .getCellList().get(i).getNeighbor(); + log.info("Creating Neighbor for Cell :" + cellNodeId); + for (NbrDump a : neighboursFromFile) { + String id = a.getNodeId().trim(); + boolean noHo = Boolean.parseBoolean(a + .getBlacklisted().trim()); + CellDetails neighborCell = entitymanager.find( + CellDetails.class, id); + NeighborDetails neighborDetails = new NeighborDetails( + new NeihborId(currentCell.getNodeId(), + neighborCell.getNodeId()), noHo); + + newCell.add(neighborDetails); + } + + neighborList.setNeighborList(newCell); + entitymanager.merge(neighborList); + entitymanager.flush(); + + entitymanager.getTransaction().commit(); + + rsPciHdlr.setCollisionConfusionFromFile(cellNodeId); + + } + + } + + } catch (Exception e1) { + log.info("Exception generateClusterFromFile :", e1); + if (entitymanager.getTransaction().isActive()) { + entitymanager.getTransaction().rollback(); + } + } + + try { + + long startTimeSectorNumber = System.currentTimeMillis(); + for (int i = 0; i < dumpTopo.getCellList().size(); i++) { + + CellData icellData = dumpTopo.getCellList().get(i); + CellDetails icell = entitymanager.find(CellDetails.class, + icellData.getCell().getNodeId()); + int icount = icell.getSectorNumber(); + if (icount == 0) { + entitymanager.getTransaction().begin(); + log.info("Setting sectorNumber for Cell(i) :" + + icell.getNodeId()); + int jcount = 0; + for (int j = (i + 1); j < dumpTopo.getCellList().size(); j++) { + + CellData jcellData = dumpTopo.getCellList().get(j); + if (icellData.getCell().getLatitude() + .equals(jcellData.getCell().getLatitude())) { + if (icellData + .getCell() + .getLongitude() + .equals(jcellData.getCell() + .getLongitude())) { + + if (icount == 0) { + icount++; + jcount = icount + 1; + } + + CellDetails jcell = entitymanager.find( + CellDetails.class, dumpTopo + .getCellList().get(j) + .getCell().getNodeId()); + + jcell.setSectorNumber(jcount); + log.info("Setting sectorNumber for Cell(j) :" + + jcell.getNodeId() + + " icell: " + + icell.getNodeId() + + " Sector number: " + jcount); + entitymanager.merge(jcell); + jcount++; + if (jcount > 3) { + break; + } + } + } + } + icell.setSectorNumber(icount); + entitymanager.merge(icell); + entitymanager.flush(); + entitymanager.getTransaction().commit(); + } + + } + + long endTimeSectorNumber = System.currentTimeMillis(); + log.info("Time taken for setting sector number: " + + (endTimeSectorNumber - startTimeSectorNumber)); + + } catch (Exception e3) { + log.info("Exception generateClusterFromFile :", e3); + if (entitymanager.getTransaction().isActive()) { + entitymanager.getTransaction().rollback(); + } + } + + } catch (Exception e) { + log.info("Exception generateClusterFromFile :", e); + if (entitymanager.getTransaction().isActive()) { + entitymanager.getTransaction().rollback(); + } + } finally { + br.close(); + entitymanager.close(); + emfactory.close(); + } + } + + /** + * The function deletes the cell from the database with the nodeId passed in + * the arguments. It removes the cell from its neighbor's neighbor list and + * the netconf server list. + * + * @param nodeId + * node Id of the cell to be deleted. + * @return returns success or failure message + */ + public static String deleteCellFunction(String nodeId) { + String result = "failure node dosent exist"; + log.info("deleteCellFunction called with nodeId :" + nodeId); + RansimControllerDatabase rsDb = new RansimControllerDatabase(); + + try { + CellDetails deleteCelldetail = rsDb.getCellDetail(nodeId); + + CellNeighbor deleteCellNeighbor = rsDb.getCellNeighbor(nodeId); + + if (deleteCelldetail != null) { + if (deleteCellNeighbor != null) { + List<CellNeighbor> cellNeighborList = rsDb + .getCellNeighborList(); + for (CellNeighbor cellNeighbors : cellNeighborList) { + Set<NeighborDetails> currentCellNeighbors = new HashSet<NeighborDetails>( + cellNeighbors.getNeighborList()); + + NeihborId deleteNeighborDetail = new NeihborId( + cellNeighbors.getNodeId(), + deleteCelldetail.getNodeId()); + + if (currentCellNeighbors.contains(deleteNeighborDetail)) { + log.info("Deleted Cell is Neighbor of NodeId : " + + cellNeighbors.getNodeId()); + currentCellNeighbors.remove(deleteNeighborDetail); + cellNeighbors.setNeighborList(currentCellNeighbors); + rsDb.mergeCellNeighbor(cellNeighbors); + } + } + + deleteCellNeighbor.getNeighborList().clear(); + rsDb.deleteCellNeighbor(deleteCellNeighbor); + } + + rsDb.deleteCellDetails(deleteCelldetail); + result = "cell has been deleted from the database"; + } else { + log.info("cell id does not exist"); + result = "failure nodeId dosent exist"; + return result; + } + } catch (Exception eu) { + log.info("Exception deleteCellFunction :", eu); + + result = "exception in function"; + } + return result; + } + + /** + * Send configuration details to all the netconf server. + */ + public void sendInitialConfigAll() { + RansimControllerDatabase rsDb = new RansimControllerDatabase(); + try { + dumpSessionDetails(); + List<NetconfServers> ncServers = rsDb.getNetconfServersList(); + for (NetconfServers netconfServers : ncServers) { + String ipPortKey = serverIdIpPortMapping.get(netconfServers + .getServerId()); + if (ipPortKey == null || ipPortKey.trim().equals("")) { + log.info("No client for " + netconfServers.getServerId()); + for (String ipPortKeyStr : webSocketSessions.keySet()) { + if (!serverIdIpPortMapping.containsValue(ipPortKeyStr)) { + serverIdIpPortMapping.put( + netconfServers.getServerId(), ipPortKeyStr); + ipPortKey = ipPortKeyStr; + break; + } + } + } + if (ipPortKey != null && !ipPortKey.trim().equals("")) { + Session clSess = webSocketSessions.get(ipPortKey); + if (clSess != null) { + sendInitialConfig(netconfServers.getServerId()); + try { + String[] agentDetails = ipPortKey.split(":"); + new RestClient().sendMountRequestToSdnr( + netconfServers.getServerId(), sdnrServerIp, + sdnrServerPort, agentDetails[0], + agentDetails[1], sdnrServerUserid, + sdnrServerPassword); + } catch (Exception ex1) { + log.info("Ignoring exception", ex1); + } + + } else { + log.info("No session for " + ipPortKey); + } + } + } + } catch (Exception eu) { + log.info("Exception:", eu); + } + } + + /** + * Sends initial configuration details of the cells for a new netconf server + * that has been started. + * + * @param ipPortKey + * ip address details of the netconf server + */ + public void sendInitialConfigForNewAgent(String ipPortKey, String serverId) { + try { + dumpSessionDetails(); + if (ipPortKey != null && !ipPortKey.trim().equals("")) { + if (serverId != null && !serverId.trim().equals("")) { + Session clSess = webSocketSessions.get(ipPortKey); + if (clSess != null) { + String[] agentDetails = ipPortKey.split(":"); + sendInitialConfig(serverId); + new RestClient().sendMountRequestToSdnr(serverId, + sdnrServerIp, sdnrServerPort, agentDetails[0], + agentDetails[1], sdnrServerUserid, + sdnrServerPassword); + } else { + log.info("No session for " + ipPortKey); + } + } else { + log.info("No serverid for " + ipPortKey); + } + } else { + log.info("Invalid ipPortKey " + ipPortKey); + } + } catch (Exception eu) { + log.info("Exception:", eu); + } + } + + /** + * To send the initial configration to the netconf server. + * + * @param serverId + * ip address details of the netconf server + */ + public void sendInitialConfig(String serverId) { + + RansimControllerDatabase rsDb = new RansimControllerDatabase(); + try { + NetconfServers server = rsDb.getNetconfServer(serverId); + log.info("sendInitialConfig: serverId:" + serverId + ", server:" + + server); + if (server == null) { + return; + } + + String ipPortKey = serverIdIpPortMapping.get(serverId); + + log.info("sendInitialConfig: ipPortKey:" + ipPortKey); + + List<CellDetails> cellList = new ArrayList<CellDetails>( + server.getCells()); + + List<Topology> config = new ArrayList<Topology>(); + + for (int i = 0; i < server.getCells().size(); i++) { + Topology cell = new Topology(); + CellDetails currentCell = rsDb.getCellDetail(cellList.get(i) + .getNodeId()); + CellNeighbor neighbor = rsDb.getCellNeighbor(cellList.get(i) + .getNodeId()); + + cell.setCellId("" + currentCell.getNodeId()); + cell.setPciId(currentCell.getPhysicalCellId()); + cell.setPnfName(serverId); + + List<Neighbor> nbrList = new ArrayList<Neighbor>(); + Set<NeighborDetails> nbrsDet = neighbor.getNeighborList(); + for (NeighborDetails cellDetails : nbrsDet) { + Neighbor nbr = new Neighbor(); + CellDetails nbrCell = rsDb.getCellDetail(cellDetails + .getNeigbor().getNeighborCell()); + nbr.setNodeId(nbrCell.getNodeId()); + nbr.setPhysicalCellId(nbrCell.getPhysicalCellId()); + nbr.setPnfName(nbrCell.getServerId()); + nbr.setServerId(nbrCell.getServerId()); + nbr.setPlmnId(nbrCell.getNetworkId()); + nbr.setBlacklisted(cellDetails.isBlacklisted()); + nbrList.add(nbr); + } + cell.setNeighborList(nbrList); + config.add(i, cell); + } + + SetConfigTopology topo = new SetConfigTopology(); + + topo.setServerId(server.getServerId()); + String uuid = globalNcServerUuidMap.get(server.getServerId()); + if (uuid == null) { + uuid = getUuid(); + globalNcServerUuidMap.put(server.getServerId(), uuid); + } + topo.setUuid(uuid); + + topo.setTopology(config); + + Gson gson = new Gson(); + String jsonStr = gson.toJson(topo); + log.info("ConfigTopologyMessage: " + jsonStr); + Session clSess = webSocketSessions.get(ipPortKey); + RansimWebSocketServer.sendSetConfigTopologyMessage(jsonStr, clSess); + + } catch (Exception eu) { + log.info("Exception:", eu); + } + + } + + private static String getUuid() { + return UUID.randomUUID().toString(); + } + + /** + * The function alters the database information based on the modifications + * made in the SDNR. + * + * @param message + * message received from the SDNR + * @param session + * sends the session details + * @param ipPort + * ip address of the netconf server + */ + public void handleModifyPciFromSdnr(String message, Session session, + String ipPort) { + log.info("handleModifyPciFromSDNR: message:" + message + " session:" + + session + " ipPort:" + ipPort); + RansimControllerDatabase rcDb = new RansimControllerDatabase(); + ModifyPci modifyPci = new Gson().fromJson(message, ModifyPci.class); + log.info("handleModifyPciFromSDNR: modifyPci:" + modifyPci.getCellId() + + "; pci: " + modifyPci.getPciId()); + String source = "Netconf"; + + CellDetails cd = rcDb.getCellDetail(modifyPci.getCellId()); + long pci = cd.getPhysicalCellId(); + cd.setPhysicalCellId(modifyPci.getPciId()); + rcDb.mergeCellDetails(cd); + rsPciHdlr.updatePciOperationsTable(modifyPci.getCellId(), source, pci, + modifyPci.getPciId()); + } + + /** + * The function alters the database information based on the modifications + * made in the SDNR. + * + * @param message + * message received from the SDNR + * @param session + * sends the session details + * @param ipPort + * ip address of the netconf server + */ + public void handleModifyNeighborFromSdnr(String message, Session session, + String ipPort) { + log.info("handleModifyAnrFromSDNR: message:" + message + " session:" + + session + " ipPort:" + ipPort); + RansimControllerDatabase rsDb = new RansimControllerDatabase(); + ModifyNeighbor modifyNeighbor = new Gson().fromJson(message, + ModifyNeighbor.class); + log.info("handleModifyAnrFromSDNR: modifyPci:" + + modifyNeighbor.getCellId()); + CellDetails currentCell = rsDb + .getCellDetail(modifyNeighbor.getCellId()); + List<NeighborDetails> neighborList = new ArrayList<NeighborDetails>(); + List<String> cellList = new ArrayList<String>(); + cellList.add(modifyNeighbor.getCellId()); + String nbrsAdd = ""; + String nbrsDel = ""; + String source = "Netconf"; + + for (int i = 0; i < modifyNeighbor.getNeighborList().size(); i++) { + if (modifyNeighbor.getNeighborList().get(i).isBlacklisted()) { + NeighborDetails nd = new NeighborDetails(new NeihborId( + modifyNeighbor.getCellId(), modifyNeighbor + .getNeighborList().get(i).getNodeId()), true); + rsDb.mergeNeighborDetails(nd); + cellList.add(modifyNeighbor.getNeighborList().get(i) + .getNodeId()); + if (nbrsAdd.equals("")) { + nbrsDel = modifyNeighbor.getNeighborList().get(i) + .getNodeId(); + } else { + nbrsDel += "," + + modifyNeighbor.getNeighborList().get(i) + .getNodeId(); + } + } else { + NeighborDetails nd = new NeighborDetails(new NeihborId( + modifyNeighbor.getCellId(), modifyNeighbor + .getNeighborList().get(i).getNodeId()), false); + rsDb.mergeNeighborDetails(nd); + cellList.add(modifyNeighbor.getNeighborList().get(i) + .getNodeId()); + if (nbrsDel.equals("")) { + nbrsAdd = modifyNeighbor.getNeighborList().get(i) + .getNodeId(); + } else { + nbrsAdd += "," + + modifyNeighbor.getNeighborList().get(i) + .getNodeId(); + } + } + + } + + for (String cl : cellList) { + RansimPciHandler.setCollisionConfusionFromFile(cl); + } + + log.info("neighbor list: " + neighborList); + + rsPciHdlr.updateNbrsOperationsTable(modifyNeighbor.getCellId(), source, + nbrsAdd, nbrsDel); + } + + /** + * The function sends the modification made in the GUI to the netconf + * server. + * + * @param cellId + * node Id of the cell which was modified + * @param pciId + * PCI number of the cell which was modified + */ + public void handleModifyPciFromGui(String cellId, long pciId) { + log.info("handleModifyPciFromGUI: cellId:" + cellId + " pciId:" + pciId); + RansimControllerDatabase rsDb = new RansimControllerDatabase(); + + try { + CellDetails currentCell = rsDb.getCellDetail(cellId); + CellNeighbor neighborList = rsDb.getCellNeighbor(cellId); + List<Neighbor> nbrList = new ArrayList<Neighbor>(); + Iterator<NeighborDetails> iter = neighborList.getNeighborList() + .iterator(); + while (iter.hasNext()) { + NeighborDetails nbCell = iter.next(); + Neighbor nbr = new Neighbor(); + CellDetails nbrCell = rsDb.getCellDetail(nbCell.getNeigbor() + .getNeighborCell()); + + nbr.setNodeId(nbrCell.getNodeId()); + nbr.setPhysicalCellId(nbrCell.getPhysicalCellId()); + nbr.setPnfName(nbrCell.getNodeName()); + nbr.setServerId(nbrCell.getServerId()); + nbr.setPlmnId(nbrCell.getNetworkId()); + nbrList.add(nbr); + } + + String pnfName = currentCell.getServerId(); + String ipPort = serverIdIpPortMapping.get(pnfName); + log.info("handleModifyPciFromGui:ipPort >>>>>>> " + ipPort); + + if (ipPort != null && !ipPort.trim().equals("")) { + + String[] ipPortArr = ipPort.split(":"); + Topology oneCell = new Topology(pnfName, pciId, cellId, nbrList); + UpdateCell updatedPci = new UpdateCell( + currentCell.getServerId(), ipPortArr[0], ipPortArr[1], + oneCell); + Gson gson = new Gson(); + String jsonStr = gson.toJson(updatedPci); + if (ipPort != null && !ipPort.trim().equals("")) { + Session clSess = webSocketSessions.get(ipPort); + if (clSess != null) { + RansimWebSocketServer.sendUpdateCellMessage(jsonStr, + clSess); + log.info("handleModifyPciFromGui, message: " + jsonStr); + } else { + log.info("No client session for " + ipPort); + } + } else { + log.info("No client for " + currentCell.getServerId()); + } + } + + } catch (Exception eu) { + + log.info("Exception:", eu); + } + } + + /** + * The function unmounts the connection with SDNR. + * + * @return returns null value + */ + public String stopAllCells() { + RansimControllerDatabase rcDb = new RansimControllerDatabase(); + try { + List<NetconfServers> ncServers = rcDb.getNetconfServersList(); + for (NetconfServers netconfServers : ncServers) { + try { + log.info("Unmount " + netconfServers.getServerId()); + new RestClient().sendUnmountRequestToSdnr( + netconfServers.getServerId(), sdnrServerIp, + sdnrServerPort, sdnrServerUserid, + sdnrServerPassword); + } catch (Exception e) { + log.info("Ignore Exception:", e); + } + serverIdIpNodeMapping.clear(); + } + return "Netconf servers unmounted."; + } catch (Exception eu) { + + log.info("Exception:", eu); + return "Error"; + } + + } + + /** + * Used to dump session details. + */ + synchronized public static void dumpSessionDetails() { + + try { + + log.info("serverIdIpPortMapping.size:" + + serverIdIpPortMapping.size() + "webSocketSessions.size" + + webSocketSessions.size()); + for (String key : serverIdIpPortMapping.keySet()) { + String val = serverIdIpPortMapping.get(key); + Session sess = webSocketSessions.get(val); + log.info("ServerId:" + key + " IpPort:" + val + " Session:" + + sess); + } + for (String serverId : unassignedServerIds) { + log.info("Unassigned ServerId:" + serverId); + } + for (String serverId : serverIdIpPortMapping.keySet()) { + List<String> attachedNoeds = serverIdIpNodeMapping + .get(serverId); + if (attachedNoeds != null) { + log.info("ServerId:" + serverId + " attachedNoeds.size:" + + attachedNoeds.size() + " nodes:" + + attachedNoeds.toArray()); + } else { + log.info("ServerId:" + serverId + " attachedNoeds:" + null); + } + } + } catch (Exception e) { + log.info("Exception:", e); + } + } + +} + +class KeepWebsockAliveThread extends Thread { + static Logger log = Logger + .getLogger(KeepWebsockAliveThread.class.getName()); + RansimController rsCtrlr = null; + + KeepWebsockAliveThread(RansimController ctrlr) { + rsCtrlr = ctrlr; + } + + @Override + public void run() { + log.info("Inside KeepWebsockAliveThread run method"); + while (true) { + for (String ipPort : rsCtrlr.webSocketSessions.keySet()) { + try { + Session sess = rsCtrlr.webSocketSessions.get(ipPort); + RansimWebSocketServer.sendPingMessage(sess); + log.debug("Sent ping message to Client ipPort:" + ipPort); + } catch (Exception ex1) { + } + } + try { + Thread.sleep(10000); + } catch (Exception ex) { + } + } + } +} diff --git a/ransim/ransimctrlr/RANSIM-CTRLR/src/main/java/org/onap/ransim/rest/api/controller/RansimControllerDatabase.java b/ransim/ransimctrlr/RANSIM-CTRLR/src/main/java/org/onap/ransim/rest/api/controller/RansimControllerDatabase.java new file mode 100644 index 0000000..0d7ea3a --- /dev/null +++ b/ransim/ransimctrlr/RANSIM-CTRLR/src/main/java/org/onap/ransim/rest/api/controller/RansimControllerDatabase.java @@ -0,0 +1,409 @@ +/*- + * ============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.util.ArrayList; +import java.util.List; + +import javax.persistence.EntityManager; +import javax.persistence.EntityManagerFactory; +import javax.persistence.Persistence; +import javax.persistence.Query; +import javax.persistence.TypedQuery; + +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.NeighborDetails; +import org.onap.ransim.rest.api.models.NetconfServers; +import org.onap.ransim.rest.api.models.OperationLog; + +public class RansimControllerDatabase { + + static Logger log = Logger.getLogger(RansimControllerDatabase.class + .getName()); + + /** + * Gets the CellDetail from the database. + * + * @param nodeId Node Id of the cell(primary key) + * @return Returns the cell with mentioned node ID. + */ + CellDetails getCellDetail(String nodeId){ + EntityManagerFactory emfactory = Persistence + .createEntityManagerFactory("ransimctrlrdb"); + EntityManager entitymanager = emfactory.createEntityManager(); + CellDetails currentCell = null; + + try{ + currentCell = entitymanager.find(CellDetails.class, nodeId); + }catch(Exception e){ + log.info("Exception in getCellDetail: " + e); + if (entitymanager.getTransaction().isActive()) { + entitymanager.getTransaction().rollback(); + } + } + finally { + entitymanager.close(); + emfactory.close(); + } + + return currentCell; + + } + + /** + * + * @param serverId + * @return + */ + static NetconfServers getNetconfServer(String serverId){ + EntityManagerFactory emfactory = Persistence + .createEntityManagerFactory("ransimctrlrdb"); + EntityManager entitymanager = emfactory.createEntityManager(); + NetconfServers ns = null; + + try{ + ns = entitymanager.find(NetconfServers.class, serverId); + }catch(Exception e){ + log.info("Exception in getCellDetail: " + e); + if (entitymanager.getTransaction().isActive()) { + entitymanager.getTransaction().rollback(); + } + } + finally { + entitymanager.close(); + emfactory.close(); + } + + return ns; + + } + CellNeighbor getCellNeighbor(String nodeId){ + EntityManagerFactory emfactory = Persistence + .createEntityManagerFactory("ransimctrlrdb"); + EntityManager entitymanager = emfactory.createEntityManager(); + CellNeighbor ns = null; + + try{ + ns = entitymanager.find(CellNeighbor.class, nodeId); + }catch(Exception e){ + log.info("Exception in getCellDetail: " + e); + if (entitymanager.getTransaction().isActive()) { + entitymanager.getTransaction().rollback(); + } + } + finally { + entitymanager.close(); + emfactory.close(); + } + + return ns; + + } + + void deleteCellDetails(CellDetails deleteCelldetail){ + EntityManagerFactory emfactory = Persistence + .createEntityManagerFactory("ransimctrlrdb"); + EntityManager entitymanager = emfactory.createEntityManager(); + + + + try{ + if (deleteCelldetail.getServerId() != null) { + entitymanager.getTransaction().begin(); + log.info("inside NetconfServers handling ...."); + NetconfServers ns = entitymanager.find(NetconfServers.class, deleteCelldetail.getServerId()); + ns.getCells().remove(deleteCelldetail); + entitymanager.merge(ns); + entitymanager.flush(); + entitymanager.getTransaction().commit(); + + } + entitymanager.getTransaction().begin(); + CellDetails cd = entitymanager.find(CellDetails.class, deleteCelldetail.getNodeId()); + entitymanager.remove(cd); + entitymanager.flush(); + entitymanager.getTransaction().commit(); + + }catch(Exception e){ + log.info("Exception in getCellDetail: " + e); + if (entitymanager.getTransaction().isActive()) { + entitymanager.getTransaction().rollback(); + } + } + finally { + entitymanager.close(); + emfactory.close(); + } + } + + void deleteCellNeighbor(CellNeighbor deleteCellNeighbor){ + EntityManagerFactory emfactory = Persistence + .createEntityManagerFactory("ransimctrlrdb"); + EntityManager entitymanager = emfactory.createEntityManager(); + + entitymanager.getTransaction().begin(); + + try{ + log.info("inside delete cel neighbor"); + CellNeighbor cn = entitymanager.find(CellNeighbor.class, deleteCellNeighbor.getNodeId()); + entitymanager.remove(cn); + entitymanager.flush(); + entitymanager.getTransaction().commit(); + log.info("removed cell neighbor from database"); + + }catch(Exception e){ + log.info("Exception in deleteCellNeighbor: " + e); + if (entitymanager.getTransaction().isActive()) { + entitymanager.getTransaction().rollback(); + } + } + finally { + entitymanager.close(); + emfactory.close(); + } + } + + static void mergeCellDetails(CellDetails cellDetail){ + EntityManagerFactory emfactory = Persistence.createEntityManagerFactory("ransimctrlrdb"); + EntityManager entitymanager = emfactory.createEntityManager(); + try{ + entitymanager.getTransaction().begin(); + entitymanager.merge(cellDetail); + log.info("updated in database...."); + entitymanager.flush(); + entitymanager.getTransaction().commit(); + }catch (Exception eu) { + if (entitymanager.getTransaction().isActive()) { + entitymanager.getTransaction().rollback(); + } + log.info("Exception:", eu); + } finally { + entitymanager.close(); + emfactory.close(); + } + } + + void mergeNeighborDetails(NeighborDetails neighborDetails){ + EntityManagerFactory emfactory = Persistence.createEntityManagerFactory("ransimctrlrdb"); + EntityManager entitymanager = emfactory.createEntityManager(); + try{ + entitymanager.getTransaction().begin(); + entitymanager.merge(neighborDetails); + log.info("updated in database...."); + entitymanager.flush(); + entitymanager.getTransaction().commit(); + } catch (Exception eu) { + if (entitymanager.getTransaction().isActive()) { + entitymanager.getTransaction().rollback(); + } + log.info("Exception:", eu); + } finally { + entitymanager.close(); + emfactory.close(); + } + } + + void mergeNetconfServers(NetconfServers netconfServers){ + EntityManagerFactory emfactory = Persistence.createEntityManagerFactory("ransimctrlrdb"); + EntityManager entitymanager = emfactory.createEntityManager(); + try{ + entitymanager.getTransaction().begin(); + entitymanager.merge(netconfServers); + log.info("updated in database...."); + entitymanager.flush(); + entitymanager.getTransaction().commit(); + } catch (Exception eu) { + if (entitymanager.getTransaction().isActive()) { + entitymanager.getTransaction().rollback(); + } + log.info("Exception:", eu); + } finally { + entitymanager.close(); + emfactory.close(); + } + } + + void mergeCellNeighbor(CellNeighbor cellNeighbor){ + EntityManagerFactory emfactory = Persistence.createEntityManagerFactory("ransimctrlrdb"); + EntityManager entitymanager = emfactory.createEntityManager(); + try{ + entitymanager.getTransaction().begin(); + log.info("updated in database...."); + entitymanager.merge(cellNeighbor); + entitymanager.flush(); + entitymanager.getTransaction().commit(); + } catch (Exception eu) { + if (entitymanager.getTransaction().isActive()) { + entitymanager.getTransaction().rollback(); + } + log.info("Exception:", eu); + } finally { + entitymanager.close(); + emfactory.close(); + } + } + + List<CellDetails> getCellDetailsList(){ + EntityManagerFactory emfactory = Persistence.createEntityManagerFactory("ransimctrlrdb"); + EntityManager entitymanager = emfactory.createEntityManager(); + List<CellDetails> cds = new ArrayList<CellDetails>(); + try{ + entitymanager.getTransaction().begin(); + log.info("updated in database...."); + Query query = entitymanager.createQuery("from CellDetails cd", CellDetails.class); + cds = query.getResultList(); + entitymanager.flush(); + entitymanager.getTransaction().commit(); + } catch (Exception eu) { + if (entitymanager.getTransaction().isActive()) { + entitymanager.getTransaction().rollback(); + } + log.info("Exception:", eu); + } finally { + entitymanager.close(); + emfactory.close(); + } + + return cds; + } + + List<CellDetails> getCellsWithNoServerIds(){ + EntityManagerFactory emfactory = Persistence.createEntityManagerFactory("ransimctrlrdb"); + EntityManager entitymanager = emfactory.createEntityManager(); + List<CellDetails> cds = new ArrayList<CellDetails>(); + try{ + entitymanager.getTransaction().begin(); + log.info("getCellswithNoServerIds: updated in database...."); + TypedQuery<CellDetails> query = entitymanager.createQuery( + "SELECT n FROM CellDetails WHERE n.serverId is null", CellDetails.class); + cds = query.getResultList(); + entitymanager.flush(); + entitymanager.getTransaction().commit(); + } catch (Exception eu) { + if (entitymanager.getTransaction().isActive()) { + entitymanager.getTransaction().rollback(); + } + log.info("Exception:", eu); + } finally { + entitymanager.close(); + emfactory.close(); + } + + return cds; + } + + List<CellDetails> getCellsWithCollisionOrConfusion(){ + EntityManagerFactory emfactory = Persistence.createEntityManagerFactory("ransimctrlrdb"); + EntityManager entitymanager = emfactory.createEntityManager(); + List<CellDetails> cds = new ArrayList<CellDetails>(); + try{ + entitymanager.getTransaction().begin(); + log.info("getCellsWithCollisionOrConfusion: updated in database...."); + Query query = entitymanager + .createQuery( + "from CellDetails cd where cd.pciCollisionDetected=true or cd.pciConfusionDetected=true", + CellDetails.class); + cds = query.getResultList(); + entitymanager.flush(); + entitymanager.getTransaction().commit(); + } catch (Exception eu) { + if (entitymanager.getTransaction().isActive()) { + entitymanager.getTransaction().rollback(); + } + log.info("Exception:", eu); + } finally { + entitymanager.close(); + emfactory.close(); + } + + return cds; + } + + List<OperationLog> getOperationLogList(){ + EntityManagerFactory emfactory = Persistence.createEntityManagerFactory("ransimctrlrdb"); + EntityManager entitymanager = emfactory.createEntityManager(); + List<OperationLog> ols = new ArrayList<OperationLog>(); + try{ + entitymanager.getTransaction().begin(); + log.info("updated in database...."); + Query query = entitymanager.createQuery("from OperationLog ol", OperationLog.class); + ols = query.getResultList(); + entitymanager.flush(); + entitymanager.getTransaction().commit(); + } catch (Exception eu) { + if (entitymanager.getTransaction().isActive()) { + entitymanager.getTransaction().rollback(); + } + log.info("Exception:", eu); + } finally { + entitymanager.close(); + emfactory.close(); + } + + return ols; + } + + List<NetconfServers> getNetconfServersList(){ + EntityManagerFactory emfactory = Persistence.createEntityManagerFactory("ransimctrlrdb"); + EntityManager entitymanager = emfactory.createEntityManager(); + List<NetconfServers> cnl = new ArrayList<NetconfServers>(); + try{ + log.info("updated in database...."); + Query query = entitymanager.createQuery("from NetconfServers ns", NetconfServers.class); + cnl = query.getResultList(); + } catch (Exception eu) { + if (entitymanager.getTransaction().isActive()) { + entitymanager.getTransaction().rollback(); + } + log.info("Exception:", eu); + } finally { + entitymanager.close(); + emfactory.close(); + } + + return cnl; + } + + List<CellNeighbor> getCellNeighborList() { + EntityManagerFactory emfactory = Persistence.createEntityManagerFactory("ransimctrlrdb"); + EntityManager entitymanager = emfactory.createEntityManager(); + List<CellNeighbor> cellNeighborList = new ArrayList<CellNeighbor>(); + try { + entitymanager.getTransaction().begin(); + TypedQuery<CellNeighbor> query = entitymanager.createQuery("from CellNeighbor cn", CellNeighbor.class); + cellNeighborList = query.getResultList(); + entitymanager.flush(); + entitymanager.getTransaction().commit(); + } catch (Exception eu) { + if (entitymanager.getTransaction().isActive()) { + entitymanager.getTransaction().rollback(); + } + log.info("Exception:", eu); + } finally { + entitymanager.close(); + emfactory.close(); + } + return cellNeighborList; + } + +} diff --git a/ransim/ransimctrlr/RANSIM-CTRLR/src/main/java/org/onap/ransim/rest/api/controller/RansimControllerServices.java b/ransim/ransimctrlr/RANSIM-CTRLR/src/main/java/org/onap/ransim/rest/api/controller/RansimControllerServices.java new file mode 100644 index 0000000..9fc130c --- /dev/null +++ b/ransim/ransimctrlr/RANSIM-CTRLR/src/main/java/org/onap/ransim/rest/api/controller/RansimControllerServices.java @@ -0,0 +1,730 @@ +/*- + * ============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.util.ArrayList; +import java.util.List; +import java.util.Map; +import java.util.concurrent.ConcurrentHashMap; +import java.util.concurrent.Executors; +import java.util.concurrent.ScheduledExecutorService; +import java.util.concurrent.TimeUnit; + +import javax.persistence.EntityManager; +import javax.persistence.EntityManagerFactory; +import javax.persistence.Persistence; +import javax.persistence.Query; + +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.DeleteACellReq; +import org.onap.ransim.rest.api.models.GetACellDetailReq; +import org.onap.ransim.rest.api.models.GetNeighborList; +import org.onap.ransim.rest.api.models.GetNeighborListReq; +import org.onap.ransim.rest.api.models.GetNetconfServerDetailsReq; +import org.onap.ransim.rest.api.models.GetPmDataReq; +import org.onap.ransim.rest.api.models.ModifyACellReq; +import org.onap.ransim.rest.api.models.NeighborDetails; +import org.onap.ransim.rest.api.models.NeihborId; +import org.onap.ransim.rest.api.models.NetconfServers; +import org.onap.ransim.rest.api.models.OperationLog; +import org.onap.ransim.rest.api.models.Topology; +import org.springframework.http.HttpStatus; +import org.springframework.http.ResponseEntity; +import org.springframework.web.bind.annotation.CrossOrigin; +import org.springframework.web.bind.annotation.RequestBody; +import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.bind.annotation.RequestMethod; +import org.springframework.web.bind.annotation.RestController; + +import com.google.gson.Gson; +import com.google.gson.GsonBuilder; + +import io.swagger.annotations.Api; +import io.swagger.annotations.ApiOperation; +import io.swagger.annotations.ApiResponse; +import io.swagger.annotations.ApiResponses; + +@RestController +@Api(value = "Ran Simulator Controller Services") +@RequestMapping("/") +@CrossOrigin(origins = "*") +public class RansimControllerServices { + + static Logger log = Logger.getLogger(RansimControllerServices.class + .getName()); + + private static boolean isSimulationStarted = false; + private static boolean isPmDataGenerating = false; + + private static RansimControllerServices rscServices = null; + + ScheduledExecutorService execService = Executors.newScheduledThreadPool(5); + + private RansimControllerServices() { + + } + + /** + * To accesss variable of this class from another class. + * + * @return returns rscServices constructor + */ + public static synchronized RansimControllerServices getRansimControllerServices() { + if (rscServices == null) { + rscServices = new RansimControllerServices(); + } + return rscServices; + } + + RansimController rsCtrlr = RansimController.getRansimController(); + RansimPciHandler rsPciHdlr = RansimPciHandler.getRansimPciHandler(); + + /** + * Start the RAN network simulation. + * + * @param req + * gets the necessary details as a request of class type + * StartSimulationReq + * @return returns Http status + * @throws Exception + * throws exceptions in the functions + */ + @ApiOperation("Starts the RAN network simulation") + @RequestMapping(value = "/StartSimulation", method = RequestMethod.POST) + @ApiResponses(value = { @ApiResponse(code = 200, message = "Successful"), + @ApiResponse(code = 500, message = "Cannot start the simulation") }) + public ResponseEntity<String> startSimulation() throws Exception { + + RansimControllerDatabase rsDb = new RansimControllerDatabase(); + + List<CellDetails> cellList = rsDb.getCellDetailsList(); + if (!cellList.isEmpty()) { + return new ResponseEntity<>("Already simulation is running.", + HttpStatus.INTERNAL_SERVER_ERROR); + } + + try { + rsCtrlr.loadProperties(); + long startTimeStartSimulation = System.currentTimeMillis(); + rsCtrlr.generateClusterFromFile(); + rsCtrlr.sendInitialConfigAll(); + long endTimeStartSimulation = System.currentTimeMillis(); + log.info("Time taken for start simulation : " + + (endTimeStartSimulation - startTimeStartSimulation)); + + return new ResponseEntity<String>(HttpStatus.OK); + + } catch (Exception eu) { + log.info("/StartSimulation ", eu); + return new ResponseEntity<String>(HttpStatus.INTERNAL_SERVER_ERROR); + } + + } + + /** + * The performance Management Data of each cell will be sent to its netconf + * agent at a regular interval. + * + * @param req + * Contains the details of node ids which will have bad and poor + * pm values + * @return return HTTP status. + * + */ + @ApiOperation("Generate PM data") + @RequestMapping(value = "/GeneratePmData", method = RequestMethod.POST) + @ApiResponses(value = { @ApiResponse(code = 200, message = "Successful"), + @ApiResponse(code = 500, message = "Cannot start the simulation") }) + public ResponseEntity<String> generatePmData(@RequestBody GetPmDataReq req) + throws Exception { + + log.info("Inside generatePmData..."); + log.info("nodeId_bad: " + req.getNodeIdBad()); + log.info("nodeId_poor: " + req.getNodeIdPoor()); + + try { + rsPciHdlr.readPmParameters(); + execService = Executors.newScheduledThreadPool(5); + execService.scheduleAtFixedRate( + () -> { + + List<String> resp = rsPciHdlr.generatePmData( + req.getNodeIdBad(), req.getNodeIdPoor()); + log.info("execService.isTerminated(): " + + execService.isTerminated()); + + }, 0, 300, TimeUnit.SECONDS); + + isPmDataGenerating = true; + + return new ResponseEntity<>("Request generated.", HttpStatus.OK); + + } catch (Exception eu) { + log.info("Exception: ", eu); + return new ResponseEntity<String>(HttpStatus.INTERNAL_SERVER_ERROR); + + } + + } + + /** + * Terminates the ScheduledExecutorService which sends the PM data at + * regular interval. + * + * @return returns HTTP status + * + */ + @ApiOperation("stop PM data") + @RequestMapping(value = "/stopPmData", method = RequestMethod.GET) + @ApiResponses(value = { @ApiResponse(code = 200, message = "Successful"), + @ApiResponse(code = 500, message = "Cannot start the simulation") }) + public ResponseEntity<String> stopPmData() throws Exception { + + long startTime = (System.currentTimeMillis() / 1000); + + try { + log.info("1. execService.isTerminated(): " + + execService.isTerminated()); + if (!execService.isTerminated()) { + execService.shutdown(); + log.info("2. execService.isTerminated(): " + + execService.isTerminated()); + + } + isPmDataGenerating = false; + return new ResponseEntity<>("PM data generated.", HttpStatus.OK); + + } catch (Exception eu) { + return new ResponseEntity<String>(HttpStatus.INTERNAL_SERVER_ERROR); + } + + } + + /** + * Get the status of ScheduledExecutorService, whether active or terminated. + * + * @return return the status + * + */ + @ApiOperation("get PM data status") + @RequestMapping(value = "/GetPmDataStatus", method = RequestMethod.GET) + @ApiResponses(value = { @ApiResponse(code = 200, message = "Successful"), + @ApiResponse(code = 500, message = "Cannot get information") }) + public boolean getPmDataStatus() throws Exception { + + try { + return isPmDataGenerating; + } catch (Exception eu) { + return false; + } + + } + + /** + * The function retrieves RAN simulation network topology. + * + * @return returns Http status + * @throws Exception + * throws exceptions in the functions + * + */ + @ApiOperation("Retrieves RAN simulation network topology") + @RequestMapping(value = "/GetTopology", method = RequestMethod.GET) + @ApiResponses(value = { + @ApiResponse(code = 200, message = "Successful"), + @ApiResponse(code = 500, message = "Cannot retrieve the RAN simulation network topology details") }) + public ResponseEntity<String> getTopology() throws Exception { + log.info("Inside getTopology..."); + RansimControllerDatabase rsDb = new RansimControllerDatabase(); + try { + rsPciHdlr.checkCollisionAfterModify(); + List<CellDetails> cds = rsDb.getCellDetailsList(); + + Topology top = new Topology(); + + if (cds != null && cds.size() > 0) { + top.setMinScreenX(cds.get(0).getScreenX()); + top.setMaxScreenX(cds.get(0).getScreenX()); + top.setMinScreenY(cds.get(0).getScreenY()); + top.setMaxScreenY(cds.get(0).getScreenY()); + + for (int i = 0; i < cds.size(); i++) { + if (cds.get(i).getScreenX() < top.getMinScreenX()) { + top.setMinScreenX(cds.get(i).getScreenX()); + } + if (cds.get(i).getScreenY() < top.getMinScreenY()) { + top.setMinScreenY(cds.get(i).getScreenY()); + } + + if (cds.get(i).getScreenX() > top.getMaxScreenX()) { + top.setMaxScreenX(cds.get(i).getScreenX()); + } + if (cds.get(i).getScreenY() > top.getMaxScreenY()) { + top.setMaxScreenY(cds.get(i).getScreenY()); + } + } + top.setCellTopology(cds); + } + top.setGridSize(rsCtrlr.gridSize); + + Gson gson = new Gson(); + String jsonStr = gson.toJson(top); + + return new ResponseEntity<>(jsonStr, HttpStatus.OK); + + } catch (Exception eu) { + log.info("/GetTopology", eu); + return new ResponseEntity<>("Failure", + HttpStatus.INTERNAL_SERVER_ERROR); + } + } + + /** + * The function retrieves the neighbor list details for the cell with the + * mentioned nodeId. + * + * @param req + * gets the necessary details as a request of class type + * GetNeighborListReq + * @return returns Http status + * @throws Exception + * throws exceptions in the functions + */ + @ApiOperation("Retrieves the neighbor list details for the cell with the mentioned nodeId") + @RequestMapping(value = "/GetNeighborList", method = RequestMethod.POST) + @ApiResponses(value = { + @ApiResponse(code = 200, message = "Successful"), + @ApiResponse(code = 500, message = "Cannot Insert the given parameters") }) + public ResponseEntity<String> getNeighborList( + @RequestBody GetNeighborListReq req) throws Exception { + log.info("Inside getNeighborList..."); + + try { + String jsonStr = ""; + + GetNeighborList message = rsPciHdlr.generateNeighborList(req + .getNodeId()); + + if (message != null) { + + log.info("message.getNodeId(): " + message.getNodeId()); + + Gson gson = new Gson(); + jsonStr = gson.toJson(message); + } + return new ResponseEntity<>(jsonStr, HttpStatus.OK); + + } catch (Exception eu) { + log.info("/getNeighborList", eu); + + return new ResponseEntity<>("Failure", + HttpStatus.INTERNAL_SERVER_ERROR); + } + } + + /** + * The function retrieves the neighbor list for the cell with the mentioned + * nodeId. + * + * @param req + * gets the necessary details as a request of class type + * GetNeighborListReq + * @return returns Http status + * @throws Exception + * throws exceptions in the functions + */ + @ApiOperation("Retrieves the neighbor list details for the cell with the mentioned nodeId") + @RequestMapping(value = "/GetNeighborBlacklistDetails", method = RequestMethod.POST) + @ApiResponses(value = { + @ApiResponse(code = 200, message = "Successful"), + @ApiResponse(code = 500, message = "Cannot Insert the given parameters") }) + public ResponseEntity<String> getNeighborBlacklistDetails( + @RequestBody GetNeighborListReq req) throws Exception { + log.info("Inside getNeighborList..."); + + try { + String jsonStr = ""; + + RansimControllerDatabase rsDb = new RansimControllerDatabase(); + CellNeighbor neighborList = rsDb.getCellNeighbor(req.getNodeId()); + + Map<String, String> result = new ConcurrentHashMap<String, String>(); + + for (NeighborDetails nd : neighborList.getNeighborList()) { + + result.put(nd.getNeigbor().getNeighborCell(), + "" + nd.isBlacklisted()); + } + + if (result != null) { + Gson gson = new Gson(); + jsonStr = gson.toJson(result); + } + return new ResponseEntity<>(jsonStr, HttpStatus.OK); + + } catch (Exception eu) { + log.info("/getNeighborList", eu); + + return new ResponseEntity<>("Failure", + HttpStatus.INTERNAL_SERVER_ERROR); + } + } + + /** + * Changes the pci number or nbr list for the given cell. + * + * @param req + * gets the necessary details as a request of class type + * ModifyACellReq + * @return returns Http status + * @throws Exception + * throws exceptions in the functions + */ + @ApiOperation("Changes the pci number or nbr list for the given cell") + @RequestMapping(value = "/ModifyACell", method = RequestMethod.POST) + @ApiResponses(value = { + @ApiResponse(code = 200, message = "Successful"), + @ApiResponse(code = 500, message = "Cannot update the PCI for the given cell") }) + public ResponseEntity<String> modifyACell(@RequestBody ModifyACellReq req) + throws Exception { + log.info("Inside ModifyCell..."); + + try { + long startTimemodifyCell = System.currentTimeMillis(); + + String nbrsStr = req.getNewNbrs(); + if (req.getNewNbrs() == null) { + nbrsStr = ""; + } + String source = "GUI"; + List<NeighborDetails> nbrsList = new ArrayList<NeighborDetails>(); + String[] newNbrsArr = nbrsStr.split(","); + + for (int i = 0; i < newNbrsArr.length; i++) { + NeighborDetails cell = new NeighborDetails(new NeihborId( + req.getNodeId(), newNbrsArr[i].trim()), false); + nbrsList.add(cell); + } + + int result = rsPciHdlr.modifyCellFunction(req.getNodeId(), + req.getNewPhysicalCellId(), nbrsList, source); + log.info("Inside modify cell : " + (startTimemodifyCell)); + log.info("Result:********************" + result); + rsCtrlr.handleModifyPciFromGui(req.getNodeId(), + req.getNewPhysicalCellId()); + long endTimemodifyCell = System.currentTimeMillis(); + log.info("Time taken to modify cell : " + + (endTimemodifyCell - startTimemodifyCell)); + + if (result == 200) { + return new ResponseEntity<String>(HttpStatus.OK); + } else if (result == 400) { + return new ResponseEntity<String>(HttpStatus.BAD_REQUEST); + } else { + return new ResponseEntity<String>( + HttpStatus.INTERNAL_SERVER_ERROR); + } + + } catch (Exception eu) { + log.info("Exception in modifyACell", eu); + + return new ResponseEntity<>( + "Cannot update the PCI for the given cell", + HttpStatus.INTERNAL_SERVER_ERROR); + } + + } + + /** + * The function changes the PCI number of the cell for the the mentioned + * nodeId. + * + * @param req + * gets the necessary details as a request of class type + * GetACellDetailReq + * @return returns Http status + * @throws Exception + * throws exceptions in the functions + */ + @ApiOperation("Changes the pci number of the cell for the the mentioned nodeId") + @RequestMapping(value = "/GetACellDetail", method = RequestMethod.POST) + @ApiResponses(value = { + @ApiResponse(code = 200, message = "Successful"), + @ApiResponse(code = 500, message = "Cannot retrive the cell details for the given cell") }) + public ResponseEntity<String> getACellDetail( + @RequestBody GetACellDetailReq req) throws Exception { + log.info("Inside GetACellDetailReq..."); + RansimControllerDatabase rsDb = new RansimControllerDatabase(); + try { + String jsonStr = null; + + CellDetails cd = rsDb.getCellDetail(req.getNodeId()); + + if (cd != null) { + Gson gson = new Gson(); + jsonStr = gson.toJson(cd); + } + return new ResponseEntity<>(jsonStr, HttpStatus.OK); + + } catch (Exception eu) { + log.info("Exception in modifyACell", eu); + return new ResponseEntity<>( + "Cannot update the PCI for the given cell", + HttpStatus.INTERNAL_SERVER_ERROR); + } + } + + /** + * The function deletes a cell with the mentioned nodeId. + * + * @param req + * gets the necessary details as a request of class type + * DeleteACellReq + * @return returns Http status + * @throws Exception + * throws exceptions in the functions + */ + @ApiOperation("Deletes a cell with the mentioned nodeId") + @RequestMapping(value = "/DeleteACell", method = RequestMethod.POST) + @ApiResponses(value = { @ApiResponse(code = 200, message = "Successful"), + @ApiResponse(code = 500, message = "Cannot delete the given cell") }) + public ResponseEntity<String> deleteACell(@RequestBody DeleteACellReq req) + throws Exception { + log.info("Inside delete cell..."); + + try { + long startTimeDeleteCell = System.currentTimeMillis(); + String result = rsCtrlr.deleteCellFunction(req.getNodeId()); + log.info("deleted in database...." + result); + long endTimeDeleteCell = System.currentTimeMillis(); + log.info("Time taken to delete cell : " + + (endTimeDeleteCell - startTimeDeleteCell)); + + return new ResponseEntity<String>(HttpStatus.OK); + + } catch (Exception eu) { + log.info("Exception in deleteACell", eu); + return new ResponseEntity<String>(HttpStatus.INTERNAL_SERVER_ERROR); + } + } + + /** + * The function stops RAN network simulation and deletes all the cell data + * from the database. + * + * @return returns Http status + * @throws Exception + * throws exceptions in the functions + */ + @ApiOperation("Stops RAN network simulation and deletes all the cell data from the database") + @RequestMapping(value = "/StopSimulation", method = RequestMethod.DELETE) + @ApiResponses(value = { @ApiResponse(code = 200, message = "Successful"), + @ApiResponse(code = 500, message = "Cannot stop simulation") }) + public ResponseEntity<String> stopSimulation() throws Exception { + log.info("Inside stopSimulation..."); + EntityManagerFactory emfactory = Persistence + .createEntityManagerFactory("ransimctrlrdb"); + EntityManager entitymanager = emfactory.createEntityManager(); + + Query query = entitymanager.createQuery("from CellDetails cd", + CellDetails.class); + if (query.getResultList() == null) { + return new ResponseEntity<>("No simulation is running.", + HttpStatus.INTERNAL_SERVER_ERROR); + } + + try { + entitymanager.getTransaction().begin(); + long startTimStopSimulation = System.currentTimeMillis(); + Query q3 = entitymanager + .createQuery("DELETE FROM NetconfServers ns"); + q3.executeUpdate(); + + Query q2 = entitymanager.createQuery("DELETE FROM CellNeighbor cn"); + q2.executeUpdate(); + + Query q4 = entitymanager + .createQuery("DELETE FROM NeighborDetails cn"); + q4.executeUpdate(); + + log.info("Stop simulation : " + (startTimStopSimulation)); + Query q1 = entitymanager.createQuery("DELETE FROM CellDetails cd"); + q1.executeUpdate(); + + String result = rsCtrlr.stopAllCells(); + log.info("All cell simulation are stopped...." + result); + + entitymanager.flush(); + entitymanager.getTransaction().commit(); + + long endTimStopSimulation = System.currentTimeMillis(); + log.info("Time taken for stopping simulation : " + + (endTimStopSimulation - startTimStopSimulation)); + + isSimulationStarted = false; + return new ResponseEntity<>("Success", HttpStatus.OK); + + } catch (Exception eu) { + log.info("Exception in stopSimulation", eu); + if (entitymanager.getTransaction().isActive()) { + entitymanager.getTransaction().rollback(); + } + return new ResponseEntity<>("Failure", + HttpStatus.INTERNAL_SERVER_ERROR); + } finally { + entitymanager.close(); + emfactory.close(); + } + + } + + /** + * The function returns the details of a Netconf server for the mentioned + * server id. + * + * @param req + * gets the necessary details as a request of class type + * GetNetconfServerDetailsReq + * @return returns Http status + * @throws Exception + * throws exceptions in the functions + */ + @ApiOperation("Returns the details of a Netconf server for the mentioned server id") + @RequestMapping(value = "/GetNetconfServerDetails", method = RequestMethod.POST) + @ApiResponses(value = { + @ApiResponse(code = 200, message = "Successful"), + @ApiResponse(code = 500, message = "Failure in GetNetconfServerDetails API") }) + public ResponseEntity<String> getNetconfServerDetails( + @RequestBody GetNetconfServerDetailsReq req) throws Exception { + + EntityManagerFactory emfactory = Persistence + .createEntityManagerFactory("ransimctrlrdb"); + EntityManager entitymanager = emfactory.createEntityManager(); + try { + log.info("Inside GetNetconfServerDetails API..."); + String result = ""; + entitymanager.getTransaction().begin(); + String input = req.getServerId(); + if (input.startsWith("Chn")) { + CellDetails cds = entitymanager.find(CellDetails.class, input); + if (cds != null) { + Gson gson = new Gson(); + String jsonStr = gson.toJson(cds); + result = "{\"serverId\":\"any\",\"cells\":[" + jsonStr + + "]}"; + } else { + result = ("Cell Id does not exist"); + } + } else { + NetconfServers ns = entitymanager.find(NetconfServers.class, + req.getServerId()); + if (ns != null) { + Gson gson = new Gson(); + String jsonStr = gson.toJson(ns); + result = jsonStr; + } else { + result = ("Server Id does not exist"); + } + } + return new ResponseEntity<>(result, HttpStatus.OK); + + } catch (Exception eu) { + log.info("/GetNetconfServers", eu); + if (entitymanager.getTransaction().isActive()) { + entitymanager.getTransaction().rollback(); + } + return new ResponseEntity<>( + "Failure in GetNetconfServerDetails API", + HttpStatus.INTERNAL_SERVER_ERROR); + } finally { + entitymanager.close(); + emfactory.close(); + } + } + + @ApiOperation("Returns the connection status of all netconf servers") + @RequestMapping(value = "/GetNetconfStatus", method = RequestMethod.GET) + @ApiResponses(value = { + @ApiResponse(code = 200, message = "Successful"), + @ApiResponse(code = 500, message = "Failure in GetNetconfServerDetails API") }) + public ResponseEntity<String> GetNetconfStatus() throws Exception { + + RansimControllerDatabase rsDb = new RansimControllerDatabase(); + try { + log.info("Inside GetNetconfServerDetails API..."); + String result = ""; + + List<NetconfServers> ns = rsDb.getNetconfServersList(); + if (ns != null) { + GsonBuilder gsonBuilder = new GsonBuilder(); + gsonBuilder.serializeNulls(); + Gson gson = gsonBuilder.create(); + String jsonStr = gson.toJson(ns); + result = jsonStr; + } else { + result = ("Server Id does not exist"); + } + + return new ResponseEntity<>(result, HttpStatus.OK); + + } catch (Exception eu) { + log.info("/GetNetconfServers", eu); + return new ResponseEntity<>( + "Failure in GetNetconfServerDetails API", + HttpStatus.INTERNAL_SERVER_ERROR); + } + } + + /** + * The function retrieves RAN simulation network topology. + * + * @return returns Http status + * @throws Exception + * throws exceptions in the functions + * + */ + @ApiOperation("Retrieves operations log - Modify/Delete operations performed") + @RequestMapping(value = "/GetOperationLog", method = RequestMethod.GET) + @ApiResponses(value = { + @ApiResponse(code = 200, message = "Successful"), + @ApiResponse(code = 500, message = "Cannot retrieve the Operation Logs") }) + public ResponseEntity<String> getOperationLog() throws Exception { + log.info("Inside getOperationLog..."); + RansimControllerDatabase rsDb = new RansimControllerDatabase(); + try { + List<OperationLog> ols = rsDb.getOperationLogList(); + if (ols != null && ols.size() > 0) { + Gson gson = new Gson(); + String jsonStr = gson.toJson(ols); + return new ResponseEntity<>(jsonStr, HttpStatus.OK); + } else { + return new ResponseEntity<>("", HttpStatus.OK); + } + } catch (Exception eu) { + log.info("/GetOperationLog", eu); + return new ResponseEntity<>("Failure", + HttpStatus.INTERNAL_SERVER_ERROR); + } + } + +} 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 "); + } + + } + +} |