renderer/src/main/java/org/opendaylight/transportpce/renderer/ModelMappingUtils.java

   1 /*
   2  * Copyright © 2017 AT&T and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8 package org.opendaylight.transportpce.renderer;
   9
  10 import com.google.common.util.concurrent.ListenableFuture;
  11 import java.util.ArrayList;
  12 import java.util.Iterator;
  13 import java.util.List;
  14 import java.util.Map;
  15 import java.util.TreeMap;
  16 import org.opendaylight.transportpce.common.NodeIdPair;
  17 import org.opendaylight.transportpce.common.StringConstants;
  18 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.device.renderer.rev200128.OtnServicePathInput;
  19 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.device.renderer.rev200128.OtnServicePathInputBuilder;
  20 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.device.renderer.rev200128.ServicePathInput;
  21 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.device.renderer.rev200128.ServicePathInputBuilder;
  22 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.ServicePowerSetupInput;
  23 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.ServicePowerSetupInputBuilder;
  24 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.renderer.rev201125.ServiceDeleteOutput;
  25 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.renderer.rev201125.ServiceDeleteOutputBuilder;
  26 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.renderer.rev201125.ServiceImplementationRequestInput;
  27 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.renderer.rev201125.ServiceImplementationRequestOutput;
  28 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.renderer.rev201125.ServiceImplementationRequestOutputBuilder;
  29 import org.opendaylight.yang.gen.v1.http.org.openroadm.common.service.types.rev190531.configuration.response.common.ConfigurationResponseCommon;
  30 import org.opendaylight.yang.gen.v1.http.org.openroadm.common.service.types.rev190531.configuration.response.common.ConfigurationResponseCommonBuilder;
  31 import org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev190531.ServiceDeleteInput;
  32 import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.pathdescription.rev200629.PathDescription;
  33 import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.pathdescription.rev200629.path.description.atoz.direction.AToZ;
  34 import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.pathdescription.rev200629.path.description.ztoa.direction.ZToA;
  35 import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.pathdescription.rev200629.pce.resource.resource.resource.TerminationPoint;
  36 import org.opendaylight.yang.gen.v1.http.org.transportpce.common.types.rev200615.olm.renderer.input.Nodes;
  37 import org.opendaylight.yang.gen.v1.http.org.transportpce.common.types.rev200615.olm.renderer.input.NodesBuilder;
  38 import org.opendaylight.yang.gen.v1.http.org.transportpce.common.types.rev200615.olm.renderer.input.NodesKey;
  39 import org.opendaylight.yangtools.yang.common.RpcResult;
  40 import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
  41 import org.opendaylight.yangtools.yang.common.Uint32;
  42 import org.slf4j.Logger;
  43 import org.slf4j.LoggerFactory;
  44
  45
  46
  47 public final class ModelMappingUtils {
  48
  49     private static final Logger LOG = LoggerFactory.getLogger(ModelMappingUtils.class);
  50     private static final String TERMINATION_POINT = "TerminationPoint";
  51
  52     private ModelMappingUtils() {
  53     }
  54
  55     public static ServicePowerSetupInput createServicePowerSetupInput(List<Nodes> olmList,
  56         ServiceImplementationRequestInput input) {
  57         ServicePowerSetupInputBuilder olmSetupBldr = new ServicePowerSetupInputBuilder()
  58             .setNodes(olmList);
  59         if (input != null && input.getPathDescription() != null
  60                 && input.getPathDescription().getAToZDirection() != null) {
  61             olmSetupBldr.setWaveNumber(
  62                     input.getPathDescription().getAToZDirection().getAToZWavelengthNumber());
  63         }
  64         return olmSetupBldr.build();
  65     }
  66
  67     public static ServiceImplementationRequestOutput createServiceImplResponse(String responseCode, String message) {
  68         return new ServiceImplementationRequestOutputBuilder()
  69                 .setConfigurationResponseCommon(createCommonResponse(responseCode, message))
  70                 .build();
  71     }
  72
  73     public static ServiceDeleteOutput createServiceDeleteResponse(String responseCode, String message) {
  74         return new ServiceDeleteOutputBuilder()
  75                 .setConfigurationResponseCommon(createCommonResponse(responseCode, message))
  76                 .build();
  77     }
  78
  79     public static ConfigurationResponseCommon createCommonResponse(String responseCode, String message) {
  80         return new ConfigurationResponseCommonBuilder()
  81                 .setResponseMessage(message)
  82                 .setResponseCode(responseCode)
  83                 .build();
  84     }
  85
  86     public static ListenableFuture<RpcResult<ServiceImplementationRequestOutput>>
  87             createServiceImplementationRpcResponse(ServiceImplementationRequestOutput payload) {
  88         return RpcResultBuilder.success(payload).buildFuture();
  89     }
  90
  91     public static ListenableFuture<RpcResult<ServiceDeleteOutput>>
  92             createServiceDeleteRpcResponse(ServiceDeleteOutput payload) {
  93         return RpcResultBuilder.success(payload).buildFuture();
  94     }
  95
  96     public static ServicePathInputData rendererCreateServiceInputAToZ(String serviceName,
  97             PathDescription pathDescription) {
  98         NodeLists nodeLists = getNodesListAToZ(pathDescription.getAToZDirection().nonnullAToZ().values().iterator());
  99         ServicePathInputBuilder servicePathInputBuilder = new ServicePathInputBuilder()
 100             .setServiceName(serviceName)
 101             .setOperation(ServicePathInput.Operation.Create)
 102             .setNodes(nodeLists.getList());
 103         if (pathDescription.getAToZDirection().getAToZWavelengthNumber() != null) {
 104             servicePathInputBuilder
 105                 .setWaveNumber(Uint32.valueOf(pathDescription.getAToZDirection().getAToZWavelengthNumber().toJava()));
 106         }
 107         return new ServicePathInputData(servicePathInputBuilder.build(), nodeLists);
 108     }
 109
 110     public static ServicePathInputData rendererCreateServiceInputZToA(String serviceName,
 111             PathDescription pathDescription) {
 112         NodeLists nodeLists = getNodesListZtoA(pathDescription.getZToADirection().nonnullZToA().values().iterator());
 113         ServicePathInputBuilder servicePathInputBuilder = new ServicePathInputBuilder()
 114             .setOperation(ServicePathInput.Operation.Create)
 115             .setServiceName(serviceName)
 116             .setNodes(nodeLists.getList());
 117         if (pathDescription.getAToZDirection().getAToZWavelengthNumber() != null) {
 118             servicePathInputBuilder
 119                 .setWaveNumber(Uint32.valueOf(pathDescription.getAToZDirection().getAToZWavelengthNumber().toJava()));
 120         }
 121         return new ServicePathInputData(servicePathInputBuilder.build(), nodeLists);
 122     }
 123
 124     // Adding createOtnServiceInputpath for A-Z and Z-A directions as one method
 125     public static OtnServicePathInput rendererCreateOtnServiceInput(String serviceName, String serviceType,
 126         String serviceRate, PathDescription pathDescription, boolean asideToZside) {
 127         // If atoZ is set true use A-to-Z direction otherwise use Z-to-A
 128         List<org.opendaylight.yang.gen.v1.http.org.transportpce.common.types.rev200615.otn.renderer.input.Nodes> nodes =
 129             new ArrayList<>();
 130         NodeLists nodeLists = getNodesListAToZ(pathDescription.getAToZDirection().nonnullAToZ().values().iterator());
 131         if (!asideToZside) {
 132             nodeLists = getNodesListZtoA(pathDescription.getZToADirection().nonnullZToA().values().iterator());
 133         }
 134         LOG.info("These are node-lists {}, {}", nodeLists.getList(), nodeLists.getOlmList());
 135         for (Nodes node: nodeLists.getList()) {
 136             nodes.add(
 137                     new org.opendaylight.yang.gen.v1.http.org.transportpce.common.types.rev200615.otn.renderer.input
 138                         .NodesBuilder()
 139                             .setNodeId(node.getNodeId())
 140                             .setClientTp(node.getSrcTp())
 141                             .setNetworkTp(node.getDestTp())
 142                             .build());
 143         }
 144         OtnServicePathInputBuilder otnServicePathInputBuilder = new OtnServicePathInputBuilder()
 145             .setServiceName(serviceName)
 146             .setServiceType(serviceType)
 147             .setServiceRate(serviceRate)
 148             .setNodes(nodes);
 149
 150         // set the trib-slots and trib-ports for the lower oder odu
 151         if (serviceRate.equals("1G") || (serviceRate.equals("10G"))) {
 152             otnServicePathInputBuilder
 153                 .setTribPortNumber(pathDescription.getAToZDirection().getTribPortNumber().shortValue())
 154                 .setTribSlot(pathDescription.getAToZDirection().getTribSlotNumber().shortValue());
 155         }
 156         return otnServicePathInputBuilder.build();
 157     }
 158
 159     public static ServicePathInput rendererDeleteServiceInput(String serviceName,
 160             ServiceDeleteInput serviceDeleteInput) {
 161         //TODO: finish model-model mapping
 162         return new ServicePathInputBuilder().setServiceName(serviceName).build();
 163     }
 164
 165     private static NodeLists getNodesListZtoA(Iterator<ZToA> iterator) {
 166         Map<Integer, NodeIdPair> treeMap = new TreeMap<>();
 167         List<Nodes> olmList = new ArrayList<>();
 168         List<Nodes> list = new ArrayList<>();
 169         String resourceType;
 170         TerminationPoint tp;
 171         String tpID = "";
 172         String nodeID = "";
 173         String sortId = "";
 174         while (iterator.hasNext()) {
 175             ZToA pathDesObj = iterator.next();
 176             resourceType = pathDesObj.getResource().getResource().implementedInterface().getSimpleName();
 177             LOG.info("Inside ZtoA {}", resourceType);
 178
 179             try {
 180                 if (TERMINATION_POINT.equals(resourceType)) {
 181                     tp = (TerminationPoint) pathDesObj.getResource().getResource();
 182                     LOG.info(" TP is {} {}", tp.getTpId(),
 183                             tp.getTpNodeId());
 184                     tpID = tp.getTpId();
 185                     sortId = pathDesObj.getId();
 186
 187                     //TODO: do not rely on ID to be in certain format
 188                     if (tpID.contains("CTP") || tpID.contains("CP")) {
 189                         continue;
 190                     }
 191                     if (tpID.contains(StringConstants.TTP_TOKEN)) {
 192                         nodeID = tp.getTpNodeId().split("-DEG")[0];
 193                     } else if (tpID.contains(StringConstants.PP_TOKEN)) {
 194                         nodeID = tp.getTpNodeId().split("-SRG")[0];
 195                     } else if (tpID.contains(StringConstants.NETWORK_TOKEN)
 196                         || tpID.contains(StringConstants.CLIENT_TOKEN) || tpID.isEmpty()) {
 197                         nodeID = tp.getTpNodeId().split("-XPDR")[0];
 198                     } else {
 199                         continue;
 200                     }
 201                     int id = Integer.parseInt(sortId);
 202                     treeMap.put(id, new NodeIdPair(nodeID, tpID));
 203                 } else if ("Link".equals(resourceType)) {
 204                     LOG.info("The type is link");
 205                 } else {
 206                     LOG.info("The type is not identified: {}", resourceType);
 207                 }
 208             } catch (IllegalArgumentException | SecurityException e) {
 209                 LOG.error("Dont find the getResource method", e);
 210             }
 211         }
 212         populateNodeLists(treeMap, list, olmList, false);
 213         return new NodeLists(olmList, list);
 214     }
 215
 216     private static NodeLists getNodesListAToZ(Iterator<AToZ> iterator) {
 217         Map<Integer, NodeIdPair> treeMap = new TreeMap<>();
 218         List<Nodes> list = new ArrayList<>();
 219         List<Nodes> olmList = new ArrayList<>();
 220         String resourceType;
 221         TerminationPoint tp;
 222         String tpID = "";
 223         String nodeID = "";
 224         String sortId = "";
 225
 226         while (iterator.hasNext()) {
 227             AToZ pathDesObj = iterator.next();
 228             resourceType = pathDesObj.getResource().getResource().implementedInterface().getSimpleName();
 229             LOG.info("Inside AtoZ {}", resourceType);
 230             try {
 231                 if (TERMINATION_POINT.equals(resourceType)) {
 232                     tp = (TerminationPoint) pathDesObj.getResource().getResource();
 233                     LOG.info("TP is {} {}", tp.getTpId(),
 234                             tp.getTpNodeId());
 235                     tpID = tp.getTpId();
 236                     sortId = pathDesObj.getId();
 237
 238                     //TODO: do not rely on ID to be in certain format
 239                     if (tpID.contains("CTP") || tpID.contains("CP")) {
 240                         continue;
 241                     }
 242                     if (tpID.contains(StringConstants.TTP_TOKEN)) {
 243                         nodeID = tp.getTpNodeId().split("-DEG")[0];
 244                     } else if (tpID.contains(StringConstants.PP_TOKEN)) {
 245                         nodeID = tp.getTpNodeId().split("-SRG")[0];
 246                     } else if (tpID.contains(StringConstants.NETWORK_TOKEN)
 247                         || tpID.contains(StringConstants.CLIENT_TOKEN) || tpID.isEmpty()) {
 248                         nodeID = tp.getTpNodeId().split("-XPDR")[0];
 249                     } else {
 250                         continue;
 251                     }
 252                     int id = Integer.parseInt(sortId);
 253                     treeMap.put(id, new NodeIdPair(nodeID, tpID));
 254                 } else if ("Link".equals(resourceType)) {
 255                     LOG.info("The type is link");
 256                 } else {
 257                     LOG.info("The type is not identified: {}", resourceType);
 258                 }
 259             } catch (IllegalArgumentException | SecurityException e) {
 260                 //TODO: Auto-generated catch block
 261                 LOG.error("Did not find the getResource method", e);
 262             }
 263         }
 264         populateNodeLists(treeMap, list, olmList, true);
 265         return new NodeLists(olmList, list);
 266     }
 267
 268     @edu.umd.cs.findbugs.annotations.SuppressFBWarnings(
 269         value = {"NP_LOAD_OF_KNOWN_NULL_VALUE","RCN_REDUNDANT_NULLCHECK_OF_NULL_VALUE"},
 270         justification = "loop when value is not always null - "
 271                 + "TODO: check if something exists in Java lib")
 272     private static void populateNodeLists(Map<Integer, NodeIdPair> treeMap, List<Nodes> list, List<Nodes> olmList,
 273         boolean isAToz) {
 274         String desID = null;
 275         String srcID = null;
 276         LOG.info("treeMap values = {}", treeMap.values());
 277         for (NodeIdPair values : treeMap.values()) {
 278             if (srcID == null) {
 279                 srcID = values.getTpID();
 280             } else if (desID == null) {
 281                 desID = values.getTpID();
 282                 NodesBuilder olmNb = new NodesBuilder()
 283                     .setNodeId(values.getNodeID())
 284                     .setDestTp(desID)
 285                     .setSrcTp(srcID);
 286                 olmList.add(olmNb.build());
 287                 if (srcID.isEmpty()) {
 288                     srcID = null;
 289                 }
 290                 if (desID.isEmpty()) {
 291                     desID = new StringBuilder(srcID).toString();
 292                     srcID = null;
 293                 }
 294                 if (isAToz) {
 295                     NodesBuilder nb = new NodesBuilder()
 296                         .withKey(new NodesKey(values.getNodeID()))
 297                         .setDestTp(desID)
 298                         .setSrcTp(srcID);
 299                     if (srcID != null && desID != null && srcID.contains(StringConstants.NETWORK_TOKEN)) {
 300                         nb.setDestTp(srcID).setSrcTp(desID);
 301                     }
 302                     list.add(nb.build());
 303                 } else {
 304                     if (srcID != null && desID != null && !srcID.contains(StringConstants.NETWORK_TOKEN)
 305                         && !desID.contains(StringConstants.NETWORK_TOKEN)) {
 306                         NodesBuilder nb = new NodesBuilder()
 307                             .withKey(new NodesKey(values.getNodeID()))
 308                             .setDestTp(desID)
 309                             .setSrcTp(srcID);
 310                         list.add(nb.build());
 311                     }
 312                 }
 313                 srcID = null;
 314                 desID = null;
 315             } else {
 316                 LOG.warn("both, the source and destination id are null!");
 317             }
 318         }
 319     }
 320
 321
 322     @edu.umd.cs.findbugs.annotations.SuppressFBWarnings(
 323             value = "PZLA_PREFER_ZERO_LENGTH_ARRAYS",
 324             justification = "not relevant to return and zero length array"
 325                     + " as we need real pos")
 326     public static int[] findTheLongestSubstring(String s1, String s2) {
 327         if ((s1 == null) || (s2 == null)) {
 328             return null;
 329         }
 330         int[][] dp = new int[s1.length() + 1][s2.length() + 1];
 331         int maxLen = 0;
 332         int endPos = 0;
 333         for (int i = 1; i < dp.length; i++) {
 334             for (int j = 1; j < dp[0].length; j++) {
 335                 char ch1 = s1.charAt(i - 1);
 336                 char ch2 = s2.charAt(j - 1);
 337                 if (ch1 == ch2) {
 338                     dp[i][j] = dp[i - 1][j - 1] + 1;
 339                     if (dp[i][j] >= maxLen) {
 340                         maxLen = dp[i][j];
 341                         endPos = i;
 342                     }
 343                 }
 344             }
 345         }
 346         return new int[] { endPos - maxLen, endPos };
 347     }
 348
 349 }