import com.google.common.util.concurrent.ListeningExecutorService;
import com.google.common.util.concurrent.MoreExecutors;
import java.nio.charset.Charset;
+import java.util.ArrayList;
import java.util.List;
import java.util.UUID;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.Executors;
import java.util.stream.Collectors;
import org.eclipse.jdt.annotation.Nullable;
-import org.junit.BeforeClass;
+import org.junit.Before;
import org.junit.Ignore;
import org.junit.Test;
import org.opendaylight.transportpce.common.InstanceIdentifiers;
import org.opendaylight.transportpce.common.NetworkUtils;
import org.opendaylight.transportpce.tapi.utils.TopologyDataUtils;
import org.opendaylight.transportpce.test.AbstractTest;
-import org.opendaylight.transportpce.test.DataStoreContext;
-import org.opendaylight.transportpce.test.DataStoreContextImpl;
import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.AdministrativeState;
import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.CapacityUnit;
import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.ForwardingDirection;
import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.TerminationDirection;
import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.TerminationState;
import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.Uuid;
+import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.global._class.Name;
import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.dsr.rev181210.DIGITALSIGNALTYPE100GigE;
import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.dsr.rev181210.DIGITALSIGNALTYPE10GigELAN;
import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.odu.rev181210.ODUTYPEODU2E;
import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.node.NodeRuleGroup;
import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.node.OwnedNodeEdgePoint;
import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.node.rule.group.NodeEdgePoint;
+import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.node.rule.group.Rule;
import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.Link;
import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.Node;
import org.opendaylight.yangtools.yang.common.RpcResult;
private static ListeningExecutorService executorService;
private static CountDownLatch endSignal;
private static final int NUM_THREADS = 3;
- private static DataStoreContext dataStoreContextUtil;
- @BeforeClass
- public static void setUp() throws InterruptedException {
+ @Before
+ public void setUp() throws InterruptedException {
executorService = MoreExecutors.listeningDecorator(Executors.newFixedThreadPool(NUM_THREADS));
endSignal = new CountDownLatch(1);
- dataStoreContextUtil = new DataStoreContextImpl();
- TopologyDataUtils.writeTopologyFromFileToDatastore(dataStoreContextUtil,
+ TopologyDataUtils.writeTopologyFromFileToDatastore(getDataStoreContextUtil(),
TopologyDataUtils.OPENROADM_TOPOLOGY_FILE, InstanceIdentifiers.OVERLAY_NETWORK_II);
- TopologyDataUtils.writeTopologyFromFileToDatastore(dataStoreContextUtil,
+ TopologyDataUtils.writeTopologyFromFileToDatastore(getDataStoreContextUtil(),
TopologyDataUtils.OTN_TOPOLOGY_FILE, InstanceIdentifiers.OTN_NETWORK_II);
- TopologyDataUtils.writePortmappingFromFileToDatastore(dataStoreContextUtil);
+ TopologyDataUtils.writePortmappingFromFileToDatastore(getDataStoreContextUtil());
LOG.info("setup done");
}
@Test
public void getTopologyDetailsForOpenroadmTopologyWhenSuccessful() throws ExecutionException, InterruptedException {
GetTopologyDetailsInput input = TopologyDataUtils.buildGetTopologyDetailsInput(NetworkUtils.OVERLAY_NETWORK_ID);
- TapiTopologyImpl tapiTopoImpl = new TapiTopologyImpl(dataStoreContextUtil.getDataBroker());
+ TapiTopologyImpl tapiTopoImpl = new TapiTopologyImpl(getDataBroker());
ListenableFuture<RpcResult<GetTopologyDetailsOutput>> result = tapiTopoImpl.getTopologyDetails(input);
result.addListener(new Runnable() {
@Override
Topology topology = rpcResult.getResult().getTopology();
assertNotNull("Topology should not be null", topology);
assertEquals("Nodes list size should be 1", 1, topology.getNode().size());
+ List<Node> topologyNodeList = new ArrayList<>(topology.nonnullNode().values());
+ List<Node> nodeList = new ArrayList<>(topologyNodeList);
+ List<Name> nameList = new ArrayList<>(nodeList.get(0).nonnullName().values());
assertEquals("Node name should be TAPI Ethernet Node",
- "TAPI Ethernet Node", topology.getNode().get(0).getName().get(0).getValue());
+ "TAPI Ethernet Node", nameList.get(0).getValue());
Uuid topoUuid = new Uuid(UUID.nameUUIDFromBytes("Ethernet Topology".getBytes()).toString());
Uuid nodeUuid = new Uuid(UUID.nameUUIDFromBytes("TAPI Ethernet Node".getBytes()).toString());
assertEquals("incorrect topology uuid", topoUuid, topology.getUuid());
- assertEquals("incorrect node uuid", nodeUuid, topology.getNode().get(0).getUuid());
+ assertEquals("incorrect node uuid", nodeUuid, topologyNodeList.get(0).getUuid());
Uuid onep1Uuid = new Uuid(UUID.nameUUIDFromBytes("OwnedNodeEdgePoint 0".getBytes()).toString());
Uuid onep2Uuid = new Uuid(UUID.nameUUIDFromBytes("OwnedNodeEdgePoint 1".getBytes()).toString());
+ List<OwnedNodeEdgePoint> edgePointList = new ArrayList<>(topologyNodeList.get(0)
+ .nonnullOwnedNodeEdgePoint().values());
assertEquals("incorrect uuid for nep1",
- onep1Uuid, topology.getNode().get(0).getOwnedNodeEdgePoint().get(1).getUuid());
+ onep1Uuid, edgePointList.get(1).getUuid());
assertEquals("incorrect uuid for nep1",
- onep2Uuid, topology.getNode().get(0).getOwnedNodeEdgePoint().get(0).getUuid());
+ onep2Uuid, edgePointList.get(0).getUuid());
}
@Test
public void getTopologyDetailsForOtnTopologyWhenSuccessful() throws ExecutionException, InterruptedException {
GetTopologyDetailsInput input = TopologyDataUtils.buildGetTopologyDetailsInput(NetworkUtils.OTN_NETWORK_ID);
- TapiTopologyImpl tapiTopoImpl = new TapiTopologyImpl(dataStoreContextUtil.getDataBroker());
+ TapiTopologyImpl tapiTopoImpl = new TapiTopologyImpl(getDataBroker());
ListenableFuture<RpcResult<GetTopologyDetailsOutput>> result = tapiTopoImpl.getTopologyDetails(input);
result.addListener(new Runnable() {
@Override
assertEquals("incorrect topology uuid", topoUuid, topology.getUuid());
assertEquals("topology name should be T0 - Multi-layer topology",
"T0 - Multi-layer topology",
- topology.getName().get(0).getValue());
+ topology.nonnullName().values().stream().findFirst().get().getValue());
- List<Node> nodes = topology.getNode().values().stream()
+ List<Node> nodes = topology.nonnullNode().values().stream()
.sorted((n1,n2) -> n1.getUuid().getValue().compareTo(n2.getUuid().getValue()))
.collect(Collectors.toList());
Uuid node1Uuid = new Uuid(UUID.nameUUIDFromBytes("SPDR-SA1-XPDR1+DSR".getBytes(Charset.forName("UTF-8")))
.toString());
checkOtsiNode(nodes.get(3), node4Uuid, true);
- List<Link> links = topology.getLink().values().stream()
+ List<Link> links = topology.nonnullLink().values().stream()
.sorted((l1, l2) -> l1.getUuid().getValue().compareTo(l2.getUuid().getValue()))
.collect(Collectors.toList());
checkTransitionalLink(links.get(0), topoUuid, node1Uuid, node3Uuid, "DSR+XPDR1-NETWORK1",
assertEquals("life-cycle state should be INSTALLED", LifecycleState.INSTALLED, node.getLifecycleState());
assertEquals("operational state should be ENABLED", OperationalState.ENABLED, node.getOperationalState());
assertEquals("value-name should be 'dsr/odu node name'",
- "dsr/odu node name", node.getName().get(0).getValueName());
+ "dsr/odu node name", node.nonnullName().values().stream().findFirst().get().getValueName());
assertEquals("dsr node should manage 2 protocol layers : dsr and odu",
2, node.getLayerProtocolName().size());
assertThat("dsr node should manage 2 protocol layers : dsr and odu",
node.getLayerProtocolName(), hasItems(LayerProtocolName.DSR, LayerProtocolName.ODU));
- List<OwnedNodeEdgePoint> neps = node.getOwnedNodeEdgePoint().values().stream()
+ List<OwnedNodeEdgePoint> neps = node.nonnullOwnedNodeEdgePoint().values().stream()
.sorted((nep1, nep2) -> nep1.getUuid().getValue().compareTo(nep2.getUuid().getValue()))
.collect(Collectors.toList());
if (isSwitch) {
Uuid networkNepUuid = new Uuid(
UUID.nameUUIDFromBytes("DSR+XPDR2-NETWORK1".getBytes(Charset.forName("UTF-8"))).toString());
checkNepNetworkODU4(nep2, networkNepUuid, "XPDR2-NETWORK1", "NodeEdgePoint_N1");
- List<NodeRuleGroup> nrgList = node.getNodeRuleGroup().values().stream()
+ List<NodeRuleGroup> nrgList = node.nonnullNodeRuleGroup().values().stream()
.sorted((nrg1, nrg2) -> nrg1.getUuid().getValue().compareTo(nrg2.getUuid().getValue()))
.collect(Collectors.toList());
checkNodeRuleGroupForSwitchDSR(nrgList, client4NepUuid, networkNepUuid, nodeUuid);
Uuid networkNepUuid = new Uuid(
UUID.nameUUIDFromBytes("DSR+XPDR1-NETWORK1".getBytes(Charset.forName("UTF-8"))).toString());
checkNepNetworkODU4(nep2, networkNepUuid, "XPDR1-NETWORK1", "NodeEdgePoint_N1");
- List<NodeRuleGroup> nrgList = node.getNodeRuleGroup().values().stream()
+ List<NodeRuleGroup> nrgList = node.nonnullNodeRuleGroup().values().stream()
.sorted((nrg1, nrg2) -> nrg1.getUuid().getValue().compareTo(nrg2.getUuid().getValue()))
.collect(Collectors.toList());
checkNodeRuleGroupForMuxDSR(nrgList, client4NepUuid, networkNepUuid, nodeUuid);
assertEquals("life-cycle state should be INSTALLED", LifecycleState.INSTALLED, node.getLifecycleState());
assertEquals("operational state should be ENABLED", OperationalState.ENABLED, node.getOperationalState());
assertEquals("value-name should be 'dsr/odu node name'",
- "otsi node name", node.getName().get(0).getValueName());
+ "otsi node name", node.nonnullName().values().stream().findFirst().get().getValueName());
assertEquals("otsi node should manage a single protocol layer : PHOTONIC_MEDIA",
1, node.getLayerProtocolName().size());
assertEquals("otsi node should manage a single protocol layer : PHOTONIC_MEDIA",
LayerProtocolName.PHOTONICMEDIA, node.getLayerProtocolName().get(0));
- List<OwnedNodeEdgePoint> neps = node.getOwnedNodeEdgePoint().values().stream()
+ List<OwnedNodeEdgePoint> neps = node.nonnullOwnedNodeEdgePoint().values().stream()
.sorted((nep1, nep2) -> nep1.getUuid().getValue().compareTo(nep2.getUuid().getValue()))
.collect(Collectors.toList());
if (isSwitch) {
Uuid enepUuid = new Uuid(
UUID.nameUUIDFromBytes("eOTSi+XPDR2-NETWORK2".getBytes(Charset.forName("UTF-8"))).toString());
checkNepOtsiNode(nep2, enepUuid, "XPDR2-NETWORK2", "eNodeEdgePoint_2");
- List<NodeRuleGroup> nrgList = node.getNodeRuleGroup().values().stream()
+ List<NodeRuleGroup> nrgList = node.nonnullNodeRuleGroup().values().stream()
.sorted((nrg1, nrg2) -> nrg1.getUuid().getValue().compareTo(nrg2.getUuid().getValue()))
.collect(Collectors.toList());
checkNodeRuleGroupForSwitchOTSi(nrgList, enepUuid, inepUuid, nodeUuid);
Uuid inepUuid = new Uuid(
UUID.nameUUIDFromBytes("iOTSi+XPDR1-NETWORK1".getBytes(Charset.forName("UTF-8"))).toString());
checkNepOtsiNode(nep2, inepUuid, "XPDR1-NETWORK1", "iNodeEdgePoint_1");
- List<NodeRuleGroup> nrgList = node.getNodeRuleGroup().values().stream()
+ List<NodeRuleGroup> nrgList = node.nonnullNodeRuleGroup().values().stream()
.sorted((nrg1, nrg2) -> nrg1.getUuid().getValue().compareTo(nrg2.getUuid().getValue()))
.collect(Collectors.toList());
checkNodeRuleGroupForMuxOTSi(nrgList, enepUuid, inepUuid, nodeUuid);
private void checkNepClient10G(OwnedNodeEdgePoint nep, Uuid nepUuid, String portName, String nepName) {
assertEquals("bad uuid for " + portName, nepUuid, nep.getUuid());
+ List<Name> nameList = new ArrayList<>(nep.nonnullName().values());
+ Name name = nameList.get(0);
assertEquals("value of client nep should be '" + portName + "'",
- portName, nep.getName().get(0).getValue());
+ portName, name.getValue());
assertEquals("value-name of client nep for '" + portName + "' should be '" + nepName + "'",
- nepName, nep.getName().get(0).getValueName());
+ nepName, name.getValueName());
assertEquals("Client nep should support 2 kind of cep",
2, nep.getSupportedCepLayerProtocolQualifier().size());
assertThat("client nep should support 2 kind of cep",
private void checkNepNetworkODU4(OwnedNodeEdgePoint nep, Uuid nepUuid, String portName, String nepName) {
assertEquals("bad uuid for " + portName, nepUuid, nep.getUuid());
+ List<Name> nameList = new ArrayList<>(nep.nonnullName().values());
+ Name name = nameList.get(0);
assertEquals("value of network nep should be '" + portName + "'",
- portName, nep.getName().get(0).getValue());
+ portName, name.getValue());
assertEquals("value-name of client nep for '" + portName + "' should be '" + nepName + "'",
- nepName, nep.getName().get(0).getValueName());
+ nepName, name.getValueName());
assertEquals("Network nep should support 1 kind of cep",
1, nep.getSupportedCepLayerProtocolQualifier().size());
assertThat("network nep should support 1 kind of cep",
assertEquals("each node-rule-group should contain 2 NEP for muxponder DSR",
2, nodeRuleGroup.getNodeEdgePoint().size());
}
+ List<NodeEdgePoint> nodeEdgePointList = new ArrayList<>(nrgList.get(0).nonnullNodeEdgePoint().values());
assertThat("node-rule-group nb 2 should be between nep-client4 and nep-network1",
- nrgList.get(1).getNodeEdgePoint().get(0).getNodeEdgePointUuid().getValue(),
+ nodeEdgePointList.get(0).getNodeEdgePointUuid().getValue(),
either(containsString(networkNepUuid.getValue())).or(containsString(clientNepUuid.getValue())));
assertThat("node-rule-group nb 2 should be between nep-client4 and nep-network1",
- nrgList.get(1).getNodeEdgePoint().get(1).getNodeEdgePointUuid().getValue(),
+ nodeEdgePointList.get(1).getNodeEdgePointUuid().getValue(),
either(containsString(networkNepUuid.getValue())).or(containsString(clientNepUuid.getValue())));
assertEquals("node-rule-group nb 2 should be between nep-client4 and nep-network1 of the same node",
- nrgList.get(1).getNodeEdgePoint().get(0).getNodeUuid(), nodeUuid);
+ nodeEdgePointList.get(0).getNodeUuid(), nodeUuid);
assertEquals("node-rule-group nb 2 should be between nep-client4 and nep-network1 of the same node",
- nrgList.get(1).getNodeEdgePoint().get(1).getNodeUuid(), nodeUuid);
- assertEquals("node-rule-group nb 2 should contain a single rule", 1, nrgList.get(1).getRule().size());
+ nodeEdgePointList.get(1).getNodeUuid(), nodeUuid);
+ List<Rule> rule = new ArrayList<>(nrgList.get(1).nonnullRule().values());
+ assertEquals("node-rule-group nb 2 should contain a single rule", 1, rule.size());
assertEquals("local-id of the rule should be 'forward'",
- "forward", nrgList.get(1).getRule().get(0).getLocalId());
+ "forward", rule.get(0).getLocalId());
assertEquals("the forwarding rule should be 'MAYFORWARDACROSSGROUP'",
- ForwardingRule.MAYFORWARDACROSSGROUP, nrgList.get(1).getRule().get(0).getForwardingRule());
+ ForwardingRule.MAYFORWARDACROSSGROUP, rule.get(0).getForwardingRule());
assertEquals("the rule type should be 'FORWARDING'",
- RuleType.FORWARDING, nrgList.get(1).getRule().get(0).getRuleType());
+ RuleType.FORWARDING, rule.get(0).getRuleType());
}
private void checkNodeRuleGroupForSwitchDSR(List<NodeRuleGroup> nrgList, Uuid clientNepUuid, Uuid networkNepUuid,
Uuid nodeUuid) {
assertEquals("Switch-DSR should contain a single node rule group", 1, nrgList.size());
assertEquals("Switch-DSR node-rule-group should contain 8 NEP", 8, nrgList.get(0).getNodeEdgePoint().size());
- List<NodeEdgePoint> nrg = nrgList.get(0).getNodeEdgePoint().values().stream()
+ List<NodeEdgePoint> nrg = nrgList.get(0).nonnullNodeEdgePoint().values().stream()
.sorted((nrg1, nrg2) -> nrg1.getNodeEdgePointUuid().getValue()
.compareTo(nrg2.getNodeEdgePointUuid().getValue()))
.collect(Collectors.toList());
nodeUuid, nrg.get(1).getNodeUuid());
assertEquals("any item of the node-rule-group should have the same nodeUuid",
nodeUuid, nrg.get(5).getNodeUuid());
- assertEquals("node-rule-group should contain a single rule", 1, nrgList.get(0).getRule().size());
+ @Nullable
+ List<Rule> ruleList = new ArrayList<>(nrgList.get(0).nonnullRule().values());
+ assertEquals("node-rule-group should contain a single rule", 1, ruleList.size());
assertEquals("local-id of the rule should be 'forward'",
- "forward", nrgList.get(0).getRule().get(0).getLocalId());
+ "forward", ruleList.get(0).getLocalId());
assertEquals("the forwarding rule should be 'MAYFORWARDACROSSGROUP'",
- ForwardingRule.MAYFORWARDACROSSGROUP, nrgList.get(0).getRule().get(0).getForwardingRule());
+ ForwardingRule.MAYFORWARDACROSSGROUP, ruleList.get(0).getForwardingRule());
assertEquals("the rule type should be 'FORWARDING'",
- RuleType.FORWARDING, nrgList.get(0).getRule().get(0).getRuleType());
+ RuleType.FORWARDING, ruleList.get(0).getRuleType());
}
private void checkNodeRuleGroupForMuxOTSi(List<NodeRuleGroup> nrgList, Uuid enepUuid, Uuid inepUuid,
Uuid nodeUuid) {
assertEquals("Mux-OTSi should contain a single node rule group", 1, nrgList.size());
- assertEquals("Mux-OTSi node-rule-group should contain 2 NEP", 2, nrgList.get(0).getNodeEdgePoint().size());
+ List<NodeEdgePoint> nodeEdgePointList = new ArrayList<>(nrgList.get(0).getNodeEdgePoint().values());
+ assertEquals("Mux-OTSi node-rule-group should contain 2 NEP", 2, nodeEdgePointList.size());
assertThat("Mux-OTSi node-rule-group should be between eNEP and iNEP of XPDR1-NETWORK1",
- nrgList.get(0).getNodeEdgePoint().get(0).getNodeEdgePointUuid().getValue(),
+ nodeEdgePointList.get(0).getNodeEdgePointUuid().getValue(),
either(containsString(enepUuid.getValue())).or(containsString(inepUuid.getValue())));
assertThat("Mux-OTSi node-rule-group should be between eNEP and iNEP of XPDR1-NETWORK1",
- nrgList.get(0).getNodeEdgePoint().get(1).getNodeEdgePointUuid().getValue(),
+ nodeEdgePointList.get(1).getNodeEdgePointUuid().getValue(),
either(containsString(enepUuid.getValue())).or(containsString(inepUuid.getValue())));
assertEquals("any item of the node-rule-group should have the same nodeUuid",
- nodeUuid, nrgList.get(0).getNodeEdgePoint().get(0).getNodeUuid());
+ nodeUuid, nodeEdgePointList.get(0).getNodeUuid());
assertEquals("any item of the node-rule-group should have the same nodeUuid",
- nodeUuid, nrgList.get(0).getNodeEdgePoint().get(1).getNodeUuid());
- assertEquals("node-rule-group should contain a single rule", 1, nrgList.get(0).getRule().size());
+ nodeUuid, nodeEdgePointList.get(1).getNodeUuid());
+ List<Rule> ruleList = new ArrayList<>(nrgList.get(0).nonnullRule().values());
+ assertEquals("node-rule-group should contain a single rule", 1, ruleList.size());
assertEquals("local-id of the rule should be 'forward'",
- "forward", nrgList.get(0).getRule().get(0).getLocalId());
+ "forward", ruleList.get(0).getLocalId());
assertEquals("the forwarding rule should be 'MAYFORWARDACROSSGROUP'",
- ForwardingRule.MAYFORWARDACROSSGROUP, nrgList.get(0).getRule().get(0).getForwardingRule());
+ ForwardingRule.MAYFORWARDACROSSGROUP, ruleList.get(0).getForwardingRule());
assertEquals("the rule type should be 'FORWARDING'",
- RuleType.FORWARDING, nrgList.get(0).getRule().get(0).getRuleType());
+ RuleType.FORWARDING, ruleList.get(0).getRuleType());
}
private void checkNodeRuleGroupForSwitchOTSi(List<NodeRuleGroup> nrgList, Uuid enepUuid, Uuid inepUuid,
assertEquals("each node-rule-group should contain 2 NEP for Switch-OTSi",
2, nodeRuleGroup.getNodeEdgePoint().size());
}
+ List<NodeEdgePoint> nodeEdgePointList1 = new ArrayList<>(nrgList.get(3).nonnullNodeEdgePoint().values());
assertThat("Switch-OTSi node-rule-group nb 4 should be between eNEP and iNEP of XPDR2-NETWORK2",
- nrgList.get(1).getNodeEdgePoint().get(0).getNodeEdgePointUuid().getValue(),
+ nodeEdgePointList1.get(0).getNodeEdgePointUuid().getValue(),
either(containsString(enepUuid.getValue())).or(containsString(inepUuid.getValue())));
assertThat("Switch-OTSi node-rule-group nb 4 should be between eNEP and iNEP of XPDR2-NETWORK2",
- nrgList.get(1).getNodeEdgePoint().get(1).getNodeEdgePointUuid().getValue(),
+ nodeEdgePointList1.get(1).getNodeEdgePointUuid().getValue(),
either(containsString(enepUuid.getValue())).or(containsString(inepUuid.getValue())));
+ List<NodeEdgePoint> nodeEdgePointList0 = new ArrayList<>(nrgList.get(0).getNodeEdgePoint().values());
assertEquals("any item of the node-rule-group should have the same nodeUuid",
- nodeUuid, nrgList.get(0).getNodeEdgePoint().get(0).getNodeUuid());
+ nodeUuid, nodeEdgePointList0.get(0).getNodeUuid());
assertEquals("any item of the node-rule-group should have the same nodeUuid",
- nodeUuid, nrgList.get(0).getNodeEdgePoint().get(1).getNodeUuid());
- assertEquals("node-rule-group should contain a single rule", 1, nrgList.get(0).getRule().size());
+ nodeUuid, nodeEdgePointList0.get(1).getNodeUuid());
+ List<Rule> ruleList0 = new ArrayList<>(nrgList.get(0).nonnullRule().values());
+ assertEquals("node-rule-group should contain a single rule", 1, ruleList0.size());
assertEquals("local-id of the rule should be 'forward'",
- "forward", nrgList.get(0).getRule().get(0).getLocalId());
+ "forward", ruleList0.get(0).getLocalId());
assertEquals("the forwarding rule should be 'MAYFORWARDACROSSGROUP'",
- ForwardingRule.MAYFORWARDACROSSGROUP, nrgList.get(0).getRule().get(0).getForwardingRule());
+ ForwardingRule.MAYFORWARDACROSSGROUP, ruleList0.get(0).getForwardingRule());
assertEquals("the rule type should be 'FORWARDING'",
- RuleType.FORWARDING, nrgList.get(0).getRule().get(0).getRuleType());
+ RuleType.FORWARDING, ruleList0.get(0).getRuleType());
}
private void checkNepClient100G(OwnedNodeEdgePoint nep, Uuid nepUuid, String portName, String nepName) {
assertEquals("bad uuid for " + portName, nepUuid, nep.getUuid());
+ List<Name> nameList = new ArrayList<>(nep.nonnullName().values());
assertEquals("value of client nep should be '" + portName + "'",
- portName, nep.getName().get(0).getValue());
+ portName, nameList.get(0).getValue());
assertEquals("value-name of client nep for '" + portName + "' should be '" + nepName + "'",
- nepName, nep.getName().get(0).getValueName());
+ nepName, nameList.get(0).getValueName());
assertEquals("Client nep should support 2 kind of cep",
2, nep.getSupportedCepLayerProtocolQualifier().size());
assertThat("client nep should support 2 kind of cep",
private void checkNepOtsiNode(OwnedNodeEdgePoint nep, Uuid nepUuid, String portName, String nepName) {
assertEquals("bad uuid for " + portName, nepUuid, nep.getUuid());
+ List<Name> nameList = new ArrayList<>(nep.nonnullName().values());
assertEquals("value of OTSi nep should be '" + portName + "'",
- portName, nep.getName().get(0).getValue());
+ portName, nameList.get(0).getValue());
assertEquals("value-name of OTSi nep should be '" + nepName + "'",
- nepName, nep.getName().get(0).getValueName());
+ nepName, nameList.get(0).getValueName());
assertEquals("OTSi nep should support 2 kind of cep",
2, nep.getSupportedCepLayerProtocolQualifier().size());
assertThat("OTSi nep should support 2 kind of cep",
hasItems(LayerProtocolName.ODU.getName(), LayerProtocolName.PHOTONICMEDIA.getName()));
assertEquals("transitional link should be BIDIRECTIONAL",
ForwardingDirection.BIDIRECTIONAL, link.getDirection());
+ List<org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210
+ .link.NodeEdgePoint> nodeEdgePointList = new ArrayList<>(link.nonnullNodeEdgePoint().values());
assertEquals("topology uuid should be the same for the two termination point of the link",
- topoUuid, link.getNodeEdgePoint().get(0).getTopologyUuid());
+ topoUuid, nodeEdgePointList.get(0).getTopologyUuid());
assertEquals("topology uuid should be the same for the two termination point of the link",
- topoUuid, link.getNodeEdgePoint().get(1).getTopologyUuid());
+ topoUuid, nodeEdgePointList.get(1).getTopologyUuid());
assertThat("transitional links should terminate on DSR node and Photonic node",
- link.getNodeEdgePoint().get(0).getNodeUuid().getValue(),
+ nodeEdgePointList.get(0).getNodeUuid().getValue(),
either(containsString(node1Uuid.getValue())).or(containsString(node2Uuid.getValue())));
assertThat("transitional links should terminate on DSR node and Photonic node",
- link.getNodeEdgePoint().get(1).getNodeUuid().getValue(),
+ nodeEdgePointList.get(1).getNodeUuid().getValue(),
either(containsString(node1Uuid.getValue())).or(containsString(node2Uuid.getValue())));
Uuid nep1Uuid = new Uuid(UUID.nameUUIDFromBytes(tp1.getBytes(Charset.forName("UTF-8"))).toString());
Uuid nep2Uuid = new Uuid(UUID.nameUUIDFromBytes(tp2.getBytes(Charset.forName("UTF-8"))).toString());
assertThat("transitional links should terminate on " + tp1 + " and " + tp2 + " neps",
- link.getNodeEdgePoint().get(0).getNodeEdgePointUuid().getValue(),
+ nodeEdgePointList.get(0).getNodeEdgePointUuid().getValue(),
either(containsString(nep1Uuid.getValue())).or(containsString(nep2Uuid.getValue())));
assertThat("transitional links should terminate on DSR node and Photonic node",
- link.getNodeEdgePoint().get(1).getNodeEdgePointUuid().getValue(),
+ nodeEdgePointList.get(1).getNodeEdgePointUuid().getValue(),
either(containsString(nep1Uuid.getValue())).or(containsString(nep2Uuid.getValue())));
}
}
*/
package org.opendaylight.transportpce.test;
-import com.google.common.collect.ClassToInstanceMap;
-import com.google.common.collect.ImmutableClassToInstanceMap;
import com.google.common.collect.ImmutableMap;
-import com.google.common.util.concurrent.ListeningExecutorService;
import com.google.common.util.concurrent.MoreExecutors;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.ServiceLoader;
import java.util.concurrent.Executors;
-import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.binding.runtime.spi.BindingRuntimeHelpers;
import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.mdsal.binding.api.NotificationPublishService;
import org.opendaylight.mdsal.binding.api.NotificationService;
-import org.opendaylight.mdsal.binding.dom.adapter.AdapterContext;
-import org.opendaylight.mdsal.binding.dom.adapter.BindingDOMDataBrokerAdapter;
-import org.opendaylight.mdsal.binding.dom.adapter.BindingDOMNotificationPublishServiceAdapter;
-import org.opendaylight.mdsal.binding.dom.adapter.BindingDOMNotificationServiceAdapter;
+import org.opendaylight.mdsal.binding.dom.adapter.BindingAdapterFactory;
import org.opendaylight.mdsal.binding.dom.adapter.ConstantAdapterContext;
import org.opendaylight.mdsal.binding.dom.codec.api.BindingNormalizedNodeSerializer;
+import org.opendaylight.mdsal.binding.dom.codec.impl.BindingCodecContext;
+import org.opendaylight.mdsal.binding.dom.codec.spi.BindingDOMCodecServices;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.mdsal.dom.api.DOMDataBroker;
-import org.opendaylight.mdsal.dom.api.DOMSchemaService;
-import org.opendaylight.mdsal.dom.api.DOMSchemaServiceExtension;
import org.opendaylight.mdsal.dom.broker.DOMNotificationRouter;
import org.opendaylight.mdsal.dom.broker.SerializedDOMDataBroker;
+import org.opendaylight.mdsal.dom.spi.FixedDOMSchemaService;
import org.opendaylight.mdsal.dom.spi.store.DOMStore;
-import org.opendaylight.mdsal.dom.store.inmemory.InMemoryDOMDataStore;
-import org.opendaylight.yangtools.concepts.ListenerRegistration;
-import org.opendaylight.yangtools.util.ListenerRegistry;
+import org.opendaylight.mdsal.dom.store.inmemory.InMemoryDOMDataStoreFactory;
import org.opendaylight.yangtools.yang.binding.YangModelBindingProvider;
import org.opendaylight.yangtools.yang.binding.YangModuleInfo;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
-import org.opendaylight.yangtools.yang.model.api.EffectiveModelContextListener;
-import org.opendaylight.yangtools.yang.model.api.EffectiveModelContextProvider;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
public class DataStoreContextImpl implements DataStoreContext {
- private static final Logger LOG = LoggerFactory.getLogger(DataStoreContextImpl.class);
-
private final Map<LogicalDatastoreType, DOMStore> datastores;
- private final SchemaContextHolder mockedSchemaContext;
private final DOMNotificationRouter domNotificationRouter;
private final DOMDataBroker domDataBroker;
private final DataBroker dataBroker;
private final NotificationService notificationService;
private final NotificationPublishService notificationPublishService;
+ private EffectiveModelContext schemaCtx;
+ private BindingDOMCodecServices bindingDOMCodecServices;
+ private BindingAdapterFactory adapterFactory ;
public DataStoreContextImpl() {
- this.mockedSchemaContext = new SchemaContextHolder();
- this.datastores = createDatastores();
- this.domNotificationRouter = DOMNotificationRouter.create(16);
- this.domDataBroker = createDOMDataBroker();
- this.dataBroker = createDataBroker();
- this.notificationService = createNotificationService();
- this.notificationPublishService = createNotificationPublishService();
- this.mockedSchemaContext.listeners.streamListeners()
- .forEach(l -> l.onModelContextUpdated(this.mockedSchemaContext.schemaContext));
+ List<YangModuleInfo> moduleInfos = new LinkedList<>();
+ ServiceLoader<YangModelBindingProvider> yangProviderLoader = ServiceLoader.load(YangModelBindingProvider.class);
+ for (YangModelBindingProvider yangModelBindingProvider : yangProviderLoader) {
+ moduleInfos.add(yangModelBindingProvider.getModuleInfo());
+ }
+ schemaCtx = BindingRuntimeHelpers.createEffectiveModel(moduleInfos);
+ bindingDOMCodecServices = new BindingCodecContext(BindingRuntimeHelpers.createRuntimeContext());
+ adapterFactory = new BindingAdapterFactory(new ConstantAdapterContext(bindingDOMCodecServices));
+ domNotificationRouter = DOMNotificationRouter.create(16);
+ datastores = createDatastores();
+ domDataBroker = createDOMDataBroker();
+ dataBroker = createDataBroker();
+ notificationService = createNotificationService();
+ notificationPublishService = createNotificationPublishService();
}
@Override
public DataBroker getDataBroker() {
- return this.dataBroker;
+ return dataBroker;
}
@Override
public DOMDataBroker getDOMDataBroker() {
- return this.domDataBroker;
+ return domDataBroker;
}
@Override
public NotificationService createNotificationService() {
- return new BindingDOMNotificationServiceAdapter(this.mockedSchemaContext.adapterContext,
- this.domNotificationRouter);
+ return adapterFactory.createNotificationService(domNotificationRouter);
}
@Override
public NotificationPublishService createNotificationPublishService() {
- return new BindingDOMNotificationPublishServiceAdapter(this.mockedSchemaContext.adapterContext,
- this.domNotificationRouter);
+ return adapterFactory.createNotificationPublishService(domNotificationRouter);
}
@Override
public EffectiveModelContext getSchemaContext() {
- return this.mockedSchemaContext.schemaContext;
+ return schemaCtx;
}
@Override
public BindingNormalizedNodeSerializer getBindingToNormalizedNodeCodec() {
- return this.mockedSchemaContext.adapterContext.currentSerializer();
+ return bindingDOMCodecServices;
}
@Override
public NotificationService getNotificationService() {
- return this.notificationService;
+ return notificationService;
}
@Override
public NotificationPublishService getNotificationPublishService() {
- return this.notificationPublishService;
+ return notificationPublishService;
}
private DOMDataBroker createDOMDataBroker() {
- return new SerializedDOMDataBroker(this.datastores,
+ return new SerializedDOMDataBroker(datastores,
MoreExecutors.listeningDecorator(Executors.newSingleThreadExecutor()));
}
- private ListeningExecutorService getDataTreeChangeListenerExecutor() {
- return MoreExecutors.newDirectExecutorService();
- }
-
private DataBroker createDataBroker() {
- return new BindingDOMDataBrokerAdapter(this.mockedSchemaContext.adapterContext, getDOMDataBroker());
+ return adapterFactory.createDataBroker(getDOMDataBroker());
}
private Map<LogicalDatastoreType, DOMStore> createDatastores() {
}
private DOMStore createConfigurationDatastore() {
- final InMemoryDOMDataStore store = new InMemoryDOMDataStore("CFG", getDataTreeChangeListenerExecutor());
- this.mockedSchemaContext.registerSchemaContextListener(store);
- return store;
+ return InMemoryDOMDataStoreFactory.create("CFG",
+ FixedDOMSchemaService.of(bindingDOMCodecServices.getRuntimeContext()));
}
private DOMStore createOperationalDatastore() {
- final InMemoryDOMDataStore store = new InMemoryDOMDataStore("OPER", getDataTreeChangeListenerExecutor());
- this.mockedSchemaContext.registerSchemaContextListener(store);
- return store;
+ return InMemoryDOMDataStoreFactory.create("OPER",
+ FixedDOMSchemaService.of(bindingDOMCodecServices.getRuntimeContext()));
}
- private static final class SchemaContextHolder implements DOMSchemaService, EffectiveModelContextProvider {
-
- private final EffectiveModelContext schemaContext;
- private final ListenerRegistry<EffectiveModelContextListener> listeners;
- private final AdapterContext adapterContext;
-
- private SchemaContextHolder() {
- List<YangModuleInfo> moduleInfos = loadModuleInfos();
- this.schemaContext = BindingRuntimeHelpers.createEffectiveModel(moduleInfos);
- this.listeners = ListenerRegistry.create();
- this.adapterContext = new ConstantAdapterContext();
- }
-
- @Override
- public EffectiveModelContext getGlobalContext() {
- return this.schemaContext;
- }
-
- /**
- * Loads all {@link YangModelBindingProvider} on the classpath.
- *
- * @return list of known {@link YangModuleInfo}
- */
- private List<YangModuleInfo> loadModuleInfos() {
- List<YangModuleInfo> moduleInfos = new LinkedList<>();
- ServiceLoader<YangModelBindingProvider> yangProviderLoader =
- ServiceLoader.load(YangModelBindingProvider.class);
- for (YangModelBindingProvider yangModelBindingProvider : yangProviderLoader) {
- moduleInfos.add(yangModelBindingProvider.getModuleInfo());
- LOG.debug("Adding [{}] module into known modules", yangModelBindingProvider.getModuleInfo());
- }
- return moduleInfos;
- }
-
- @Override
- public ListenerRegistration<EffectiveModelContextListener> registerSchemaContextListener(
- EffectiveModelContextListener listener) {
- return this.listeners.register(listener);
- }
-
- @Override
- public @NonNull EffectiveModelContext getEffectiveModelContext() {
- return this.schemaContext;
- }
-
- @Override
- public @NonNull ClassToInstanceMap<DOMSchemaServiceExtension> getExtensions() {
- return ImmutableClassToInstanceMap.of();
- }
-
-
- }
}
Code Review / transportpce.git / commitdiff