networkmodel/src/test/java/org/opendaylight/transportpce/networkmodel/service/FrequenciesServiceTest.java

   1 /*
   2  * Copyright © 2020 Orange, Inc. 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
   9 package org.opendaylight.transportpce.networkmodel.service;
  10
  11
  12 import static org.junit.jupiter.api.Assertions.assertEquals;
  13 import static org.junit.jupiter.api.Assertions.assertNull;
  14 import static org.junit.jupiter.api.Assertions.fail;
  15
  16 import java.io.FileNotFoundException;
  17 import java.io.FileReader;
  18 import java.io.IOException;
  19 import java.io.Reader;
  20 import java.nio.charset.StandardCharsets;
  21 import java.util.BitSet;
  22 import java.util.Optional;
  23 import java.util.concurrent.ExecutionException;
  24 import java.util.concurrent.TimeUnit;
  25 import java.util.concurrent.TimeoutException;
  26 import org.junit.jupiter.api.BeforeAll;
  27 import org.junit.jupiter.api.Disabled;
  28 import org.junit.jupiter.api.Test;
  29 import org.opendaylight.mdsal.binding.api.ReadTransaction;
  30 import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
  31 import org.opendaylight.transportpce.common.InstanceIdentifiers;
  32 import org.opendaylight.transportpce.common.NetworkUtils;
  33 import org.opendaylight.transportpce.common.Timeouts;
  34 import org.opendaylight.transportpce.common.fixedflex.GridConstant;
  35 import org.opendaylight.transportpce.networkmodel.util.OpenRoadmTopology;
  36 import org.opendaylight.transportpce.test.AbstractTest;
  37 import org.opendaylight.transportpce.test.converter.DataObjectConverter;
  38 import org.opendaylight.transportpce.test.converter.JSONDataObjectConverter;
  39 import org.opendaylight.transportpce.test.utils.TopologyDataUtils;
  40 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.pce.rev220808.service.path.rpc.result.PathDescription;
  41 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev211210.Node1;
  42 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev211210.TerminationPoint1;
  43 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.types.rev211210.available.freq.map.AvailFreqMapsKey;
  44 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  45 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
  46 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
  47 import org.slf4j.Logger;
  48 import org.slf4j.LoggerFactory;
  49
  50 @Disabled
  51 public class FrequenciesServiceTest extends AbstractTest {
  52     private static final Logger LOG = LoggerFactory.getLogger(FrequenciesServiceTest.class);
  53     private static final String OPENROADM_TOPOLOGY_FILE = "src/test/resources/openroadm-topology.xml";
  54     private static final String PATH_DESCRIPTION_FILE = "src/test/resources/path_description.json";
  55     private static PathDescription pathDescription;
  56     private final AvailFreqMapsKey availFreqMapKey = new AvailFreqMapsKey(GridConstant.C_BAND);
  57     private final BitSet usedBits = new BitSet(8);
  58     private static BitSet availableBits = new BitSet(8);
  59
  60     @BeforeAll
  61     static void setUp() throws InterruptedException, ExecutionException, FileNotFoundException {
  62         availableBits.set(0, 8, true);
  63         TopologyDataUtils.writeTopologyFromFileToDatastore(getDataStoreContextUtil(), OPENROADM_TOPOLOGY_FILE,
  64                 InstanceIdentifiers.OVERLAY_NETWORK_II);
  65         DataObjectConverter dataObjectConverter = JSONDataObjectConverter
  66                 .createWithDataStoreUtil(getDataStoreContextUtil());
  67         try (Reader reader = new FileReader(PATH_DESCRIPTION_FILE, StandardCharsets.UTF_8)) {
  68             NormalizedNode normalizedNode = dataObjectConverter
  69                     .transformIntoNormalizedNode(reader).get();
  70             pathDescription = (PathDescription) getDataStoreContextUtil()
  71                     .getBindingDOMCodecServices().fromNormalizedNode(YangInstanceIdentifier
  72                             .of(PathDescription.QNAME), normalizedNode).getValue();
  73         } catch (IOException e) {
  74             LOG.error("Cannot load path description ", e);
  75             fail("Cannot load path description ");
  76         }
  77     }
  78
  79     @Test
  80     void allocateFrequenciesTest() throws IOException {
  81         FrequenciesService service = new FrequenciesServiceImpl(getDataBroker());
  82         service.allocateFrequencies(pathDescription.getAToZDirection(), pathDescription.getZToADirection());
  83         TerminationPoint1 terminationPoint = getNetworkTerminationPointFromDatastore("ROADM-A1-DEG2", "DEG2-CTP-TXRX");
  84         assertEquals(
  85             BitSet.valueOf(terminationPoint.getCtpAttributes().getAvailFreqMaps().get(availFreqMapKey).getFreqMap())
  86                 .get(760, 768),
  87             usedBits,
  88             "Lambda 1 should not be available for ctp-attributes");
  89         assertNull(terminationPoint.getCpAttributes(), "cp-attributes should be null");
  90         terminationPoint = getNetworkTerminationPointFromDatastore("ROADM-A1-SRG1", "SRG1-PP1-TXRX");
  91         assertEquals(
  92             BitSet.valueOf(terminationPoint.getPpAttributes().getAvailFreqMaps().get(availFreqMapKey).getFreqMap())
  93                 .get(760, 768),
  94             usedBits,
  95             "Lambda 1 should not be available for pp-attributes");
  96         Node1 node = getNetworkNodeFromDatastore("ROADM-A1-SRG1");
  97         assertEquals(
  98             BitSet.valueOf(node.getSrgAttributes().getAvailFreqMaps().get(availFreqMapKey).getFreqMap())
  99                 .get(760, 768),
 100             usedBits,
 101             "Lambda 1 should not be available for srg-attributes");
 102     }
 103
 104     @Test
 105     void releaseFrequenciesTest() throws IOException {
 106         FrequenciesService service = new FrequenciesServiceImpl(getDataBroker());
 107         service.allocateFrequencies(pathDescription.getAToZDirection(), pathDescription.getZToADirection());
 108         service.releaseFrequencies(pathDescription.getAToZDirection(), pathDescription.getZToADirection());
 109         TerminationPoint1 terminationPoint = getNetworkTerminationPointFromDatastore("ROADM-A1-DEG2", "DEG2-CTP-TXRX");
 110         assertEquals(
 111             BitSet.valueOf(terminationPoint.getCtpAttributes().getAvailFreqMaps().get(availFreqMapKey)
 112                 .getFreqMap()).get(760, 768),
 113             availableBits,
 114             "Lambda 1 should be available for ctp-attributes");
 115         terminationPoint = getNetworkTerminationPointFromDatastore("ROADM-A1-SRG1", "SRG1-PP1-TXRX");
 116         assertEquals(
 117             BitSet.valueOf(terminationPoint.getPpAttributes().getAvailFreqMaps().get(availFreqMapKey)
 118                 .getFreqMap()).get(760, 768),
 119             availableBits,
 120             "Lambda 1 should be available for pp-attributes");
 121         Node1 node = getNetworkNodeFromDatastore("ROADM-A1-SRG1");
 122         assertEquals(
 123             BitSet.valueOf(node.getSrgAttributes().getAvailFreqMaps().get(availFreqMapKey)
 124                 .getFreqMap()).get(760, 768),
 125             availableBits,
 126             "Lambda 1 should be available for srg-attributes");
 127     }
 128
 129     private TerminationPoint1 getNetworkTerminationPointFromDatastore(String nodeId, String tpId) {
 130         InstanceIdentifier<TerminationPoint1> tpIID = InstanceIdentifiers
 131                 .createNetworkTerminationPoint1IIDBuilder(nodeId, tpId);
 132         try (ReadTransaction readTx = getDataBroker().newReadOnlyTransaction()) {
 133             Optional<TerminationPoint1> optionalTerminationPoint = readTx
 134                     .read(LogicalDatastoreType.CONFIGURATION, tpIID)
 135                     .get(Timeouts.DATASTORE_READ, TimeUnit.MILLISECONDS);
 136             if (optionalTerminationPoint.isPresent()) {
 137                 return optionalTerminationPoint.get();
 138             } else {
 139                 return null;
 140             }
 141         } catch (ExecutionException | TimeoutException e) {
 142             LOG.warn("Exception while getting termination {} for node id {} point from {} topology", tpId, nodeId,
 143                     NetworkUtils.OVERLAY_NETWORK_ID, e);
 144             return null;
 145         } catch (InterruptedException e) {
 146             LOG.warn("Getting termination {} for node id {} point from {} topology was interrupted", tpId, nodeId,
 147                     NetworkUtils.OVERLAY_NETWORK_ID, e);
 148             Thread.currentThread().interrupt();
 149             return null;
 150         }
 151     }
 152
 153     private Node1 getNetworkNodeFromDatastore(String nodeId) {
 154         InstanceIdentifier<Node1> nodeIID = OpenRoadmTopology.createNetworkNodeIID(nodeId);
 155         try (ReadTransaction nodeReadTx = getDataBroker().newReadOnlyTransaction()) {
 156             Optional<Node1> optionalNode = nodeReadTx.read(LogicalDatastoreType.CONFIGURATION, nodeIID)
 157                     .get(Timeouts.DATASTORE_READ, TimeUnit.MILLISECONDS);
 158             if (optionalNode.isPresent()) {
 159                 return optionalNode.get();
 160             } else {
 161                 LOG.error("Unable to get network node for node id {}from topology {}", nodeId,
 162                         NetworkUtils.OVERLAY_NETWORK_ID);
 163                 return null;
 164             }
 165         } catch (ExecutionException | TimeoutException e) {
 166             LOG.warn("Exception while getting network node for node id {} from {} topology", nodeId,
 167                     NetworkUtils.OVERLAY_NETWORK_ID, e);
 168             return null;
 169         } catch (InterruptedException e) {
 170             LOG.warn("Getting network node for node id {} from {} topology was interrupted", nodeId,
 171                     NetworkUtils.OVERLAY_NETWORK_ID, e);
 172             Thread.currentThread().interrupt();
 173             return null;
 174         }
 175     }
 176 }