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.ServicePathInput;
  20 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.renderer.device.rev200128.ServicePathInputBuilder;
  21 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.renderer.rev171017.ServiceDeleteOutput;
  22 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.renderer.rev171017.ServiceDeleteOutputBuilder;
  23 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.renderer.rev171017.ServiceImplementationRequestInput;
  24 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.renderer.rev171017.ServiceImplementationRequestOutput;
  25 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.renderer.rev171017.ServiceImplementationRequestOutputBuilder;
  26 import org.opendaylight.yang.gen.v1.http.org.openroadm.common.service.types.rev190531.configuration.response.common.ConfigurationResponseCommon;
  27 import org.opendaylight.yang.gen.v1.http.org.openroadm.common.service.types.rev190531.configuration.response.common.ConfigurationResponseCommonBuilder;
  28 import org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev190531.ServiceDeleteInput;
  29 import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.pathdescription.rev171017.PathDescription;
  30 import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.pathdescription.rev171017.path.description.atoz.direction.AToZ;
  31 import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.pathdescription.rev171017.path.description.ztoa.direction.ZToA;
  32 import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.pathdescription.rev171017.pce.resource.resource.resource.TerminationPoint;
  33 import org.opendaylight.yang.gen.v1.http.org.transportpce.common.types.rev200128.olm.renderer.input.Nodes;
  34 import org.opendaylight.yang.gen.v1.http.org.transportpce.common.types.rev200128.olm.renderer.input.NodesBuilder;
  35 import org.opendaylight.yang.gen.v1.http.org.transportpce.common.types.rev200128.olm.renderer.input.NodesKey;
  36 import org.opendaylight.yangtools.yang.common.RpcResult;
  37 import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
  38 import org.slf4j.Logger;
  39 import org.slf4j.LoggerFactory;
  40
  41
  42
  43 public final class ModelMappingUtils {
  44
  45     private static final Logger LOG = LoggerFactory.getLogger(ModelMappingUtils.class);
  46     private static final String TERMINATION_POINT = "TerminationPoint";
  47
  48     private ModelMappingUtils() {
  49     }
  50
  51     public static ServicePowerSetupInput createServicePowerSetupInput(List<Nodes> olmList,
  52         ServiceImplementationRequestInput input) {
  53         ServicePowerSetupInputBuilder olmSetupBldr = new ServicePowerSetupInputBuilder()
  54             .setNodes(olmList);
  55         if (input != null && input.getPathDescription() != null
  56                 && input.getPathDescription().getAToZDirection() != null) {
  57             olmSetupBldr.setWaveNumber(
  58                     input.getPathDescription().getAToZDirection().getAToZWavelengthNumber());
  59         }
  60         return olmSetupBldr.build();
  61     }
  62
  63     public static ServiceImplementationRequestOutput createServiceImplResponse(String responseCode, String message) {
  64         ServiceImplementationRequestOutputBuilder outputBldr = new ServiceImplementationRequestOutputBuilder()
  65             .setConfigurationResponseCommon(createCommonResponse(responseCode, message));
  66         return outputBldr.build();
  67     }
  68
  69     public static ServiceDeleteOutput createServiceDeleteResponse(String responseCode, String message) {
  70         ServiceDeleteOutputBuilder outputBldr = new ServiceDeleteOutputBuilder()
  71             .setConfigurationResponseCommon(createCommonResponse(responseCode, message));
  72         return outputBldr.build();
  73     }
  74
  75     public static ConfigurationResponseCommon createCommonResponse(String responseCode, String message) {
  76         ConfigurationResponseCommonBuilder cmBldr = new ConfigurationResponseCommonBuilder()
  77             .setResponseMessage(message)
  78             .setResponseCode(responseCode);
  79         return cmBldr.build();
  80     }
  81
  82     public static ListenableFuture<RpcResult<ServiceImplementationRequestOutput>>
  83         createServiceImplementationRpcResponse(ServiceImplementationRequestOutput payload) {
  84         return RpcResultBuilder.success(payload).buildFuture();
  85     }
  86
  87     public static ListenableFuture<RpcResult<ServiceDeleteOutput>>
  88         createServiceDeleteRpcResponse(ServiceDeleteOutput payload) {
  89         return RpcResultBuilder.success(payload).buildFuture();
  90     }
  91
  92     public static ServicePathInputData rendererCreateServiceInputAToZ(String serviceName,
  93             PathDescription pathDescription) {
  94         NodeLists nodeLists = getNodesListAToZ(pathDescription.getAToZDirection().getAToZ().iterator());
  95         ServicePathInputBuilder servicePathInputBuilder = new ServicePathInputBuilder()
  96             .setServiceName(serviceName)
  97             .setOperation(ServicePathInput.Operation.Create)
  98             .setWaveNumber(Long.valueOf(pathDescription.getAToZDirection().getAToZWavelengthNumber().toJava()))
  99             .setNodes(nodeLists.getList());
 100         return new ServicePathInputData(servicePathInputBuilder.build(), nodeLists);
 101     }
 102
 103     public static ServicePathInputData rendererCreateServiceInputZToA(String serviceName,
 104             PathDescription pathDescription) {
 105         NodeLists nodeLists = getNodesListZtoA(pathDescription.getZToADirection().getZToA().iterator());
 106         ServicePathInputBuilder servicePathInputBuilder = new ServicePathInputBuilder()
 107             .setOperation(ServicePathInput.Operation.Create)
 108             .setServiceName(serviceName)
 109             .setWaveNumber(Long.valueOf(pathDescription.getZToADirection().getZToAWavelengthNumber().toJava()))
 110             .setNodes(nodeLists.getList());
 111         return new ServicePathInputData(servicePathInputBuilder.build(), nodeLists);
 112     }
 113
 114     public static ServicePathInput rendererDeleteServiceInput(String serviceName,
 115             ServiceDeleteInput serviceDeleteInput) {
 116         ServicePathInputBuilder servicePathInput = new ServicePathInputBuilder()
 117             .setServiceName(serviceName);
 118         //TODO: finish model-model mapping
 119         return servicePathInput.build();
 120     }
 121
 122     public static NodeLists getNodesListZtoA(Iterator<ZToA> iterator) {
 123         Map<Integer, NodeIdPair> treeMap = new TreeMap<>();
 124         List<Nodes> olmList = new ArrayList<>();
 125         List<Nodes> list = new ArrayList<>();
 126         String resourceType;
 127         TerminationPoint tp;
 128         String tpID = "";
 129         String nodeID = "";
 130         String sortId = "";
 131         while (iterator.hasNext()) {
 132             ZToA pathDesObj = iterator.next();
 133             resourceType = pathDesObj.getResource().getResource().implementedInterface().getSimpleName();
 134             LOG.info("Inside ZtoA {}", resourceType);
 135
 136             try {
 137                 if (TERMINATION_POINT.equals(resourceType)) {
 138                     tp = (TerminationPoint) pathDesObj.getResource().getResource();
 139                     LOG.info(" TP is {} {}", tp.getTpId(),
 140                             tp.getTpNodeId());
 141                     tpID = tp.getTpId();
 142                     nodeID = tp.getTpNodeId();
 143                     sortId = pathDesObj.getId();
 144
 145                     //TODO: do not rely on ID to be in certain format
 146                     if (tpID.contains("CTP") || tpID.contains("CP")) {
 147                         continue;
 148                     }
 149                     if (!tpID.contains("TTP") && !tpID.contains("PP") && !tpID.contains("NETWORK")
 150                             && !tpID.contains("CLIENT")) {
 151                         continue;
 152                     }
 153
 154                     int[] pos = findTheLongestSubstring(nodeID, tpID);
 155                     if (pos != null) {
 156                         //TODO: do not rely on nodeId to be integer
 157                         int id = Integer.parseInt(sortId);
 158                         treeMap.put(id, new NodeIdPair(nodeID.substring(0, pos[0] - 1), tpID));
 159                     }
 160                 } else if ("Link".equals(resourceType)) {
 161                     LOG.info("The type is link");
 162                 } else {
 163                     LOG.info("The type is not indentified: {}", resourceType);
 164                 }
 165             } catch (IllegalArgumentException | SecurityException e) {
 166                 LOG.error("Dont find the getResource method", e);
 167             }
 168         }
 169
 170         populateNodeLists(treeMap, list, olmList);
 171         return new NodeLists(olmList, list);
 172     }
 173
 174     public static NodeLists getNodesListAToZ(Iterator<AToZ> iterator) {
 175         Map<Integer, NodeIdPair> treeMap = new TreeMap<>();
 176         List<Nodes> list = new ArrayList<>();
 177         List<Nodes> olmList = new ArrayList<>();
 178         String resourceType;
 179         TerminationPoint tp;
 180         String tpID = "";
 181         String nodeID = "";
 182         String sortId = "";
 183
 184         while (iterator.hasNext()) {
 185             AToZ pathDesObj = iterator.next();
 186             resourceType = pathDesObj.getResource().getResource().implementedInterface().getSimpleName();
 187             LOG.info("Inside AtoZ {}", resourceType);
 188             try {
 189                 if (TERMINATION_POINT.equals(resourceType)) {
 190                     tp = (TerminationPoint) pathDesObj.getResource().getResource();
 191                     LOG.info(" TP is {} {}", tp.getTpId(),
 192                             tp.getTpNodeId());
 193                     tpID = tp.getTpId();
 194                     nodeID = tp.getTpNodeId();
 195                     sortId = pathDesObj.getId();
 196
 197                     //TODO: do not rely on ID to be in certain format
 198                     if (tpID.contains("CTP") || tpID.contains("CP")) {
 199                         continue;
 200                     }
 201                     if (!tpID.contains(StringConstants.TTP_TOKEN)
 202                         && !tpID.contains(StringConstants.PP_TOKEN)
 203                         && !tpID.contains(StringConstants.NETWORK_TOKEN)
 204                         && !tpID.contains(StringConstants.CLIENT_TOKEN)) {
 205                         continue;
 206                     }
 207
 208                     int[] pos = findTheLongestSubstring(nodeID, tpID);
 209                     if (pos != null) {
 210                         //TODO: do not rely on nodeId to be integer
 211                         int id = Integer.parseInt(sortId);
 212                         treeMap.put(id, new NodeIdPair(nodeID.substring(0, pos[0] - 1), tpID));
 213                     }
 214                 } else if ("Link".equals(resourceType)) {
 215                     LOG.info("The type is link");
 216                 } else {
 217                     LOG.info("The type is not indentified: {}", resourceType);
 218                 }
 219             } catch (IllegalArgumentException | SecurityException e) {
 220                 //TODO: Auto-generated catch block
 221                 LOG.error("Dont find the getResource method", e);
 222             }
 223         }
 224
 225         populateNodeLists(treeMap, list, olmList);
 226         return new NodeLists(olmList, list);
 227     }
 228
 229     @edu.umd.cs.findbugs.annotations.SuppressFBWarnings(
 230             value = {"NP_LOAD_OF_KNOWN_NULL_VALUE","RCN_REDUNDANT_NULLCHECK_OF_NULL_VALUE"},
 231             justification = "loop when value is not always null - "
 232                     + "TODO: check if something exists in Java lib")
 233     private static void populateNodeLists(Map<Integer, NodeIdPair> treeMap,
 234             List<Nodes> list, List<Nodes> olmList) {
 235         String desID = null;
 236         String srcID = null;
 237         for (NodeIdPair values : treeMap.values()) {
 238             if (srcID == null) {
 239                 srcID = values.getTpID();
 240             } else if (desID == null) {
 241                 desID = values.getTpID();
 242                 NodesBuilder nb = new NodesBuilder()
 243                     .withKey(new NodesKey(values.getNodeID()))
 244                     .setDestTp(desID)
 245                     .setSrcTp(srcID);
 246                 list.add(nb.build());
 247
 248                 NodesBuilder olmNb = new NodesBuilder()
 249                     .setNodeId(values.getNodeID())
 250                     .setDestTp(desID)
 251                     .setSrcTp(srcID);
 252                 olmList.add(olmNb.build());
 253                 srcID = null;
 254                 desID = null;
 255             } else {
 256                 LOG.warn("both, the source and destination id are null!");
 257             }
 258         }
 259     }
 260
 261     @edu.umd.cs.findbugs.annotations.SuppressFBWarnings(
 262             value = "PZLA_PREFER_ZERO_LENGTH_ARRAYS",
 263             justification = "not relevant to return and zero length array"
 264                     + " as we need real pos")
 265     public static int[] findTheLongestSubstring(String s1, String s2) {
 266         if ((s1 == null) || (s2 == null)) {
 267             return null;
 268         }
 269         int[][] dp = new int[s1.length() + 1][s2.length() + 1];
 270         int maxLen = 0;
 271         int endPos = 0;
 272         for (int i = 1; i < dp.length; i++) {
 273             for (int j = 1; j < dp[0].length; j++) {
 274                 char ch1 = s1.charAt(i - 1);
 275                 char ch2 = s2.charAt(j - 1);
 276                 if (ch1 == ch2) {
 277                     dp[i][j] = dp[i - 1][j - 1] + 1;
 278                     if (dp[i][j] >= maxLen) {
 279                         maxLen = dp[i][j];
 280                         endPos = i;
 281                     }
 282                 }
 283             }
 284         }
 285         return new int[] { endPos - maxLen, endPos };
 286     }
 287
 288 }