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