import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.groupbasedpolicy.util.DataStoreHelper;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.Config;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.FlatNetwork;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.NetworkTypeBase;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.VlanNetwork;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.config.BridgeDomain;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.config.BridgeDomainBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.config.BridgeDomainKey;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.config.bridge.domain.PhysicalLocationRef;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.config.bridge.domain.PhysicalLocationRefBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.config.GbpBridgeDomain;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.config.GbpBridgeDomainBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.config.GbpBridgeDomainKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.config.gbp.bridge.domain.PhysicalLocationRef;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.config.gbp.bridge.domain.PhysicalLocationRefBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.l2.types.rev130827.VlanId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.networks.rev150712.NetworkTypeFlat;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.networks.rev150712.NetworkTypeVlan;
@Override
public void processCreatedNeutronDto(Network network) {
- BridgeDomain bridgeDomain = createBridgeDomain(network);
+ GbpBridgeDomain bridgeDomain = createGbpBridgeDomain(network);
if (bridgeDomain != null) {
ReadWriteTransaction rwTx = dataBroker.newReadWriteTransaction();
- rwTx.put(LogicalDatastoreType.CONFIGURATION, getBridgeDomainIid(bridgeDomain.getId()), bridgeDomain, true);
+ rwTx.put(LogicalDatastoreType.CONFIGURATION, getGbpBridgeDomainIid(bridgeDomain.getId()), bridgeDomain, true);
DataStoreHelper.submitToDs(rwTx);
}
}
@VisibleForTesting
- BridgeDomain createBridgeDomain(Network network) {
- BridgeDomainBuilder bridgeDomainBuilder = new BridgeDomainBuilder();
+ GbpBridgeDomain createGbpBridgeDomain(Network network) {
+ GbpBridgeDomainBuilder bridgeDomainBuilder = new GbpBridgeDomainBuilder();
String description = (network.getName() != null) ? network.getName() : "Neutron network";
bridgeDomainBuilder.setDescription(description);
bridgeDomainBuilder.setId(network.getUuid().getValue());
.build();
}
- InstanceIdentifier<BridgeDomain> getBridgeDomainIid(String id) {
- return InstanceIdentifier.builder(Config.class).child(BridgeDomain.class, new BridgeDomainKey(id)).build();
+ InstanceIdentifier<GbpBridgeDomain> getGbpBridgeDomainIid(String id) {
+ return InstanceIdentifier.builder(Config.class).child(GbpBridgeDomain.class, new GbpBridgeDomainKey(id)).build();
}
@Override
public void processUpdatedNeutronDto(Network originalNetwork, Network updatedNetwork) {
- InstanceIdentifier<BridgeDomain> bdIid = getBridgeDomainIid(originalNetwork.getUuid().getValue());
+ InstanceIdentifier<GbpBridgeDomain> bdIid = getGbpBridgeDomainIid(originalNetwork.getUuid().getValue());
ReadWriteTransaction rwTx = dataBroker.newReadWriteTransaction();
deleteBridgeDomainIfPresent(rwTx, bdIid);
- BridgeDomain updatedBridgeDomain = createBridgeDomain(updatedNetwork);
+ GbpBridgeDomain updatedBridgeDomain = createGbpBridgeDomain(updatedNetwork);
if (updatedBridgeDomain != null) {
rwTx.put(LogicalDatastoreType.CONFIGURATION, bdIid, updatedBridgeDomain, true);
}
DataStoreHelper.submitToDs(rwTx);
}
- private void deleteBridgeDomainIfPresent(ReadWriteTransaction rwTx, InstanceIdentifier<BridgeDomain> bdIid) {
- Optional<BridgeDomain> readFromDs = DataStoreHelper.readFromDs(LogicalDatastoreType.CONFIGURATION, bdIid, rwTx);
+ private void deleteBridgeDomainIfPresent(ReadWriteTransaction rwTx, InstanceIdentifier<GbpBridgeDomain> bdIid) {
+ Optional<GbpBridgeDomain> readFromDs = DataStoreHelper.readFromDs(LogicalDatastoreType.CONFIGURATION, bdIid, rwTx);
if (readFromDs.isPresent()) {
rwTx.delete(LogicalDatastoreType.CONFIGURATION, bdIid);
}
@Override
public void processDeletedNeutronDto(Network network) {
- InstanceIdentifier<BridgeDomain> bdIid = getBridgeDomainIid(network.getUuid().getValue());
+ InstanceIdentifier<GbpBridgeDomain> bdIid = getGbpBridgeDomainIid(network.getUuid().getValue());
ReadWriteTransaction rwTx = dataBroker.newReadWriteTransaction();
deleteBridgeDomainIfPresent(rwTx, bdIid);
DataStoreHelper.submitToDs(rwTx);
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;\r
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.FlatNetwork;\r
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.VlanNetwork;\r
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.config.BridgeDomain;\r
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.config.bridge.domain.PhysicalLocationRef;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.config.GbpBridgeDomain;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.config.gbp.bridge.domain.PhysicalLocationRef;\r
import org.opendaylight.yang.gen.v1.urn.opendaylight.l2.types.rev130827.VlanId;\r
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.networks.rev150712.NetworkTypeFlat;\r
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.networks.rev150712.NetworkTypeVlan;\r
Network network = createTestNetwork("net", netExtBuilder.build());\r
networkAware.processCreatedNeutronDto(network);\r
ReadOnlyTransaction rTx = dataBroker.newReadOnlyTransaction();\r
- Optional<BridgeDomain> optBrDomain = DataStoreHelper.readFromDs(LogicalDatastoreType.CONFIGURATION,\r
- networkAware.getBridgeDomainIid(network.getUuid().getValue()), rTx);\r
+ Optional<GbpBridgeDomain> optBrDomain = DataStoreHelper.readFromDs(LogicalDatastoreType.CONFIGURATION,\r
+ networkAware.getGbpBridgeDomainIid(network.getUuid().getValue()), rTx);\r
assertTrue(optBrDomain.isPresent());\r
}\r
\r
.build();\r
networkAware.processUpdatedNeutronDto(network1, network2);\r
ReadOnlyTransaction rTx = dataBroker.newReadOnlyTransaction();\r
- Optional<BridgeDomain> optBrDomain = DataStoreHelper.readFromDs(LogicalDatastoreType.CONFIGURATION,\r
- networkAware.getBridgeDomainIid(network2.getUuid().getValue()), rTx);\r
+ Optional<GbpBridgeDomain> optBrDomain = DataStoreHelper.readFromDs(LogicalDatastoreType.CONFIGURATION,\r
+ networkAware.getGbpBridgeDomainIid(network2.getUuid().getValue()), rTx);\r
assertTrue(optBrDomain.isPresent());\r
assertEquals(optBrDomain.get().getDescription(), "net2");\r
}\r
Network network = createTestNetwork("net1", netExtBuilder.build());\r
networkAware.processDeletedNeutronDto(network);\r
ReadOnlyTransaction rTx = dataBroker.newReadOnlyTransaction();\r
- Optional<BridgeDomain> optBrDomain = DataStoreHelper.readFromDs(LogicalDatastoreType.CONFIGURATION,\r
- networkAware.getBridgeDomainIid(network.getUuid().getValue()), rTx);\r
+ Optional<GbpBridgeDomain> optBrDomain = DataStoreHelper.readFromDs(LogicalDatastoreType.CONFIGURATION,\r
+ networkAware.getGbpBridgeDomainIid(network.getUuid().getValue()), rTx);\r
assertFalse(optBrDomain.isPresent());\r
}\r
\r
netExtBuilder.setNetworkType(NetworkTypeVlan.class);\r
netExtBuilder.setSegmentationId("2016");\r
Network vlanNetwork = createTestNetwork("VlanNet", netExtBuilder.build());\r
- BridgeDomain bridgeDomain = networkAware.createBridgeDomain(vlanNetwork);\r
+ GbpBridgeDomain bridgeDomain = networkAware.createGbpBridgeDomain(vlanNetwork);\r
assertEquals(bridgeDomain.getId(), vlanNetwork.getUuid().getValue());\r
assertEquals(bridgeDomain.getDescription(), vlanNetwork.getName());\r
assertEquals(bridgeDomain.getType(), VlanNetwork.class);\r
public void testCreateBridgeDomain_flatNetwork() {\r
netExtBuilder.setNetworkType(NetworkTypeFlat.class);\r
Network flatNetwork = createTestNetwork("FlatNet", netExtBuilder.build());\r
- BridgeDomain bridgeDomain = networkAware.createBridgeDomain(flatNetwork);\r
+ GbpBridgeDomain bridgeDomain = networkAware.createGbpBridgeDomain(flatNetwork);\r
assertEquals(bridgeDomain.getId(), flatNetwork.getUuid().getValue());\r
assertEquals(bridgeDomain.getDescription(), flatNetwork.getName());\r
assertEquals(bridgeDomain.getType(), FlatNetwork.class);\r
netExtBuilder.setNetworkType(NetworkTypeFlat.class);\r
netExtBuilder.setPhysicalNetwork(null);\r
Network flatNetwork = createTestNetwork("FlatNet", netExtBuilder.build());\r
- BridgeDomain bridgeDomain = networkAware.createBridgeDomain(flatNetwork);\r
+ GbpBridgeDomain bridgeDomain = networkAware.createGbpBridgeDomain(flatNetwork);\r
assertNull(bridgeDomain.getPhysicalLocationRef());\r
}\r
\r
@Test\r
public void testCreateBridgeDomain_noNetworkType() {\r
Network vlanNetwork = createTestNetwork("noTypeNet", new NetworkProviderExtensionBuilder().build());\r
- BridgeDomain bridgeDomain = networkAware.createBridgeDomain(vlanNetwork);\r
+ GbpBridgeDomain bridgeDomain = networkAware.createGbpBridgeDomain(vlanNetwork);\r
assertNull(bridgeDomain);\r
}\r
\r
package org.opendaylight.groupbasedpolicy.renderer.vpp.policy;
-import java.util.Arrays;
-import java.util.Collection;
-
import javax.annotation.Nonnull;
-
+import javax.annotation.Nullable;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeoutException;
+import com.google.common.base.Optional;
+import com.google.common.base.Preconditions;
+import com.google.common.util.concurrent.AsyncFunction;
+import com.google.common.util.concurrent.CheckedFuture;
+import com.google.common.util.concurrent.FutureCallback;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.SettableFuture;
import org.opendaylight.controller.md.sal.binding.api.ClusteredDataTreeChangeListener;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
import org.opendaylight.groupbasedpolicy.renderer.vpp.api.BridgeDomainManager;
import org.opendaylight.groupbasedpolicy.renderer.vpp.util.VppIidFactory;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.Config;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.config.BridgeDomain;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.config.BridgeDomainKey;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.config.bridge.domain.PhysicalLocationRef;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.config.GbpBridgeDomain;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.config.GbpBridgeDomainKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.config.gbp.bridge.domain.PhysicalLocationRef;
import org.opendaylight.yang.gen.v1.urn.opendaylight.l2.types.rev130827.VlanId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev150105.VxlanVni;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev150105.vpp.state.bridge.domains.BridgeDomain;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev150105.vpp.state.bridge.domains.BridgeDomainKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vbridge.status.rev161005.BridgeDomainStatusAugmentation;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vbridge.status.rev161005.BridgeDomainStatusFields.BridgeDomainStatus;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vbridge.topology.rev160129.NodeVbridgeAugment;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vbridge.topology.rev160129.TopologyTypesVbridgeAugment;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vbridge.topology.rev160129.TopologyTypesVbridgeAugmentBuilder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import com.google.common.base.Optional;
-import com.google.common.base.Preconditions;
-import com.google.common.util.concurrent.AsyncFunction;
-import com.google.common.util.concurrent.CheckedFuture;
-import com.google.common.util.concurrent.FutureCallback;
-import com.google.common.util.concurrent.Futures;
-import com.google.common.util.concurrent.ListenableFuture;
-import com.google.common.util.concurrent.SettableFuture;
-
public class BridgeDomainManagerImpl implements BridgeDomainManager {
private static final Logger LOG = LoggerFactory.getLogger(BridgeDomainManagerImpl.class);
private static final TopologyTypes VBRIDGE_TOPOLOGY_TYPE = new TopologyTypesBuilder().addAugmentation(
TopologyTypesVbridgeAugment.class,
new TopologyTypesVbridgeAugmentBuilder().setVbridgeTopology(new VbridgeTopologyBuilder().build()).build())
- .build();
- private final DataBroker dataProvder;
+ .build();
+ private final DataBroker dataProvider;
private static final class ListenableFutureSetter<T extends DataObject>
implements ClusteredDataTreeChangeListener<T> {
private final ListenerRegistration<ListenableFutureSetter<T>> registeredListener;
private ListenableFutureSetter(DataBroker dataProvider, SettableFuture<Void> future,
- DataTreeIdentifier<T> iid, ModificationType modificationForFutureSet) {
+ DataTreeIdentifier<T> iid, ModificationType modificationForFutureSet) {
this.future = Preconditions.checkNotNull(future);
Preconditions.checkArgument(!future.isDone());
this.modificationForFutureSet = Preconditions.checkNotNull(modificationForFutureSet);
}
@Override
- public void onDataTreeChanged(Collection<DataTreeModification<T>> changes) {
- changes.forEach(modif -> {
- DataObjectModification<T> rootNode = modif.getRootNode();
- ModificationType modificationType = rootNode.getModificationType();
+ public void onDataTreeChanged(@Nonnull final Collection<DataTreeModification<T>> changes) {
+ changes.forEach(modification -> {
+ final DataObjectModification<T> rootNode = modification.getRootNode();
+ final ModificationType modificationType = rootNode.getModificationType();
if (modificationType == modificationForFutureSet) {
LOG.debug("{} in OPER DS: {}", modificationType.name(), iid.getRootIdentifier());
- unregisterOnTrue(future.set(null));
+ final T data = rootNode.getDataAfter();
+ // If waiting for bridge domain creation, do more specific check about BD status
+ if (data != null && data instanceof BridgeDomain) {
+ final BridgeDomain domain = (BridgeDomain) data;
+ final BridgeDomainStatusAugmentation statusAugment =
+ domain.getAugmentation(BridgeDomainStatusAugmentation.class);
+ final BridgeDomainStatus status = statusAugment.getBridgeDomainStatus();
+ switch (status) {
+ case Started: {
+ LOG.debug("Bridge domain {} started", domain.getName());
+ unregister(future.set(null));
+ break;
+ }
+ case Failed: {
+ LOG.warn("Bridge domain {} failed to start", domain.getName());
+ unregister(future.set(null));
+ break;
+ }
+ case Starting:
+ case Stopped: {
+ LOG.debug("Bridge domain {} status changed to {}", domain.getName(), status.getName());
+ break;
+ }
+ }
+ } else {
+ unregister(future.set(null));
+ }
}
});
}
- private void unregisterOnTrue(boolean _true) {
+ private void unregister(boolean _true) {
if (_true) {
LOG.debug("Unregistering listener for path {}", iid.getRootIdentifier());
if (registeredListener != null) {
}
}
- public BridgeDomainManagerImpl(DataBroker dataProvder) {
- this.dataProvder = Preconditions.checkNotNull(dataProvder);
+ public BridgeDomainManagerImpl(DataBroker dataProvider) {
+ this.dataProvider = Preconditions.checkNotNull(dataProvider);
+ }
+
+ private static NodeBuilder createBasicVppNodeBuilder(NodeId nodeId) {
+ return new NodeBuilder().setNodeId(nodeId).setSupportingNode(Collections.singletonList(
+ new SupportingNodeBuilder().setTopologyRef(SUPPORTING_TOPOLOGY_NETCONF).setNodeRef(nodeId).build()));
}
@Override
- public ListenableFuture<Void> createVxlanBridgeDomainOnVppNode(@Nonnull String bridgeDomainName,
- @Nonnull VxlanVni vni, @Nonnull NodeId vppNodeId) {
- TopologyVbridgeAugment topoAug = new TopologyVbridgeAugmentBuilder().setTunnelType(TunnelTypeVxlan.class)
- .setArpTermination(false)
- .setFlood(true)
- .setForward(true)
- .setLearn(true)
- .setUnknownUnicastFlood(true)
- .setTunnelParameters(new VxlanTunnelParametersBuilder().setVni(vni).build())
- .build();
- return createBridgeDomainOnVppNode(bridgeDomainName, topoAug,
+ public ListenableFuture<Void> createVxlanBridgeDomainOnVppNode(@Nonnull final String bridgeDomainName,
+ @Nonnull final VxlanVni vni,
+ @Nonnull final NodeId vppNodeId) {
+ TopologyVbridgeAugment topologyAug = new TopologyVbridgeAugmentBuilder().setTunnelType(TunnelTypeVxlan.class)
+ .setArpTermination(false)
+ .setFlood(true)
+ .setForward(true)
+ .setLearn(true)
+ .setUnknownUnicastFlood(true)
+ .setTunnelParameters(new VxlanTunnelParametersBuilder().setVni(vni).build())
+ .build();
+ return createBridgeDomainOnVppNode(bridgeDomainName, topologyAug,
createBasicVppNodeBuilder(vppNodeId).build());
}
@Override
- public ListenableFuture<Void> createVlanBridgeDomainOnVppNode(@Nonnull String bridgeDomainName,
- @Nonnull VlanId vlanId, @Nonnull NodeId vppNodeId) {
- TopologyVbridgeAugment topoAug = new TopologyVbridgeAugmentBuilder().setTunnelType(TunnelTypeVlan.class)
- .setArpTermination(false)
- .setFlood(true)
- .setForward(true)
- .setLearn(true)
- .setUnknownUnicastFlood(true)
- .setTunnelParameters(
- new VlanNetworkParametersBuilder().setVlanId(vlanId).setVlanType(_802dot1q.class).build())
- .build();
- InstanceIdentifier<BridgeDomain> bridgeDomainConfigIid = InstanceIdentifier.builder(Config.class)
- .child(BridgeDomain.class, new BridgeDomainKey(bridgeDomainName))
- .build();
- ReadOnlyTransaction rTx = dataProvder.newReadOnlyTransaction();
- CheckedFuture<Optional<BridgeDomain>, ReadFailedException> futureTopology =
+ public ListenableFuture<Void> createVlanBridgeDomainOnVppNode(@Nonnull final String bridgeDomainName,
+ @Nonnull final VlanId vlanId,
+ @Nonnull final NodeId vppNodeId) {
+ TopologyVbridgeAugment topologyAug = new TopologyVbridgeAugmentBuilder().setTunnelType(TunnelTypeVlan.class)
+ .setArpTermination(false)
+ .setFlood(true)
+ .setForward(true)
+ .setLearn(true)
+ .setUnknownUnicastFlood(true)
+ .setTunnelParameters(
+ new VlanNetworkParametersBuilder().setVlanId(vlanId).setVlanType(_802dot1q.class).build())
+ .build();
+ InstanceIdentifier<GbpBridgeDomain> bridgeDomainConfigIid = InstanceIdentifier.builder(Config.class)
+ .child(GbpBridgeDomain.class, new GbpBridgeDomainKey(bridgeDomainName))
+ .build();
+ ReadOnlyTransaction rTx = dataProvider.newReadOnlyTransaction();
+ CheckedFuture<Optional<GbpBridgeDomain>, ReadFailedException> futureTopology =
rTx.read(LogicalDatastoreType.CONFIGURATION, bridgeDomainConfigIid);
rTx.close();
- return Futures.transform(futureTopology, new AsyncFunction<Optional<BridgeDomain>, Void>() {
+ return Futures.transform(futureTopology, new AsyncFunction<Optional<GbpBridgeDomain>, Void>() {
@Override
- public ListenableFuture<Void> apply(Optional<BridgeDomain> optBridgeDomainConf) throws Exception {
+ public ListenableFuture<Void> apply(@Nonnull Optional<GbpBridgeDomain> optBridgeDomainConf) throws Exception {
if (optBridgeDomainConf.isPresent() && optBridgeDomainConf.get().getPhysicalLocationRef() != null) {
for (PhysicalLocationRef ref : optBridgeDomainConf.get().getPhysicalLocationRef()) {
if (!ref.getNodeId().equals(vppNodeId)) continue; //not our referenced node skipping
if (ref.getInterface() != null && ref.getInterface().size() > 0) {
NodeVbridgeVlanAugment vppNodeVlanAug = new NodeVbridgeVlanAugmentBuilder()
- .setSuperInterface(ref.getInterface().get(0)).build();
+ .setSuperInterface(ref.getInterface().get(0)).build();
Node vppNode = createBasicVppNodeBuilder(vppNodeId)
- .addAugmentation(NodeVbridgeVlanAugment.class, vppNodeVlanAug).build();
- return createBridgeDomainOnVppNode(bridgeDomainName, topoAug, vppNode);
+ .addAugmentation(NodeVbridgeVlanAugment.class, vppNodeVlanAug).build();
+ return createBridgeDomainOnVppNode(bridgeDomainName, topologyAug, vppNode);
}
}
}
});
}
- private static NodeBuilder createBasicVppNodeBuilder(NodeId nodeId) {
- return new NodeBuilder().setNodeId(nodeId).setSupportingNode(Arrays.asList(
- new SupportingNodeBuilder().setTopologyRef(SUPPORTING_TOPOLOGY_NETCONF).setNodeRef(nodeId).build()));
- }
-
- private ListenableFuture<Void> createBridgeDomainOnVppNode(@Nonnull String bridgeDomainName,
- final TopologyVbridgeAugment vBridgeAug, Node vppNode) {
- TopologyKey topologyKey = new TopologyKey(new TopologyId(bridgeDomainName));
- ReadOnlyTransaction rTx = dataProvder.newReadOnlyTransaction();
- InstanceIdentifier<Topology> topologyIid = VppIidFactory.getTopologyIid(topologyKey);
- CheckedFuture<Optional<Topology>, ReadFailedException> futureTopology =
+ /**
+ * Method checks whether bridge domain already exists in topology under its {@link TopologyId}. If not, BD is
+ * written into CONF DS (request for VBD) and registers listener which awaits result from VBD. Result can be
+ * checked in OPER DS as a {@link BridgeDomainStatus}. If status is {@link BridgeDomainStatus#Started}, listener
+ * unregisters itself and bridge domain creation in VBD is considered successful.
+ * <p>
+ * Next part creates request for {@link BridgeMember} in topology CONF DS and registers listener listening on
+ * topology OPER DS. If bridge member is created in VBD, listener is closed.
+ * <p>
+ * This process has limited time, limit is defined in {@link ForwardingManager#WAIT_FOR_BD_CREATION} to prevent
+ * stuck if VBD processing fails in some point.
+ *
+ * @param bridgeDomainName serving as a topology-id
+ * @param vBridgeAug augmented data in BD
+ * @param vppNode transformed into bridge member
+ * @return composed future which serves as a marker for caller method that the computation is done. If future is
+ * not returned in time, {@link TimeoutException} will be thrown there.
+ */
+ private ListenableFuture<Void> createBridgeDomainOnVppNode(@Nonnull final String bridgeDomainName,
+ @Nonnull final TopologyVbridgeAugment vBridgeAug,
+ @Nonnull final Node vppNode) {
+ final TopologyKey topologyKey = new TopologyKey(new TopologyId(bridgeDomainName));
+ final ReadOnlyTransaction rTx = dataProvider.newReadOnlyTransaction();
+ final InstanceIdentifier<Topology> topologyIid = VppIidFactory.getTopologyIid(topologyKey);
+ final CheckedFuture<Optional<Topology>, ReadFailedException> optTopology =
rTx.read(LogicalDatastoreType.CONFIGURATION, topologyIid);
rTx.close();
- return Futures.transform(futureTopology, new AsyncFunction<Optional<Topology>, Void>() {
-
+ return Futures.transform(optTopology, new AsyncFunction<Optional<Topology>, Void>() {
@Override
- public ListenableFuture<Void> apply(Optional<Topology> optTopology) throws Exception {
- WriteTransaction wTx = dataProvder.newWriteOnlyTransaction();
+ public ListenableFuture<Void> apply(@Nonnull final Optional<Topology> optTopology)
+ throws InterruptedException, ExecutionException {
+ // Topology
+ final SettableFuture<Void> topologyFuture = SettableFuture.create();
if (!optTopology.isPresent()) {
- Topology topology = new TopologyBuilder().setKey(topologyKey)
- .setTopologyTypes(VBRIDGE_TOPOLOGY_TYPE)
- .addAugmentation(TopologyVbridgeAugment.class, vBridgeAug)
- .build();
- wTx.put(LogicalDatastoreType.CONFIGURATION, topologyIid,
- topology, true);
- }
- InstanceIdentifier<Node> nodeIid = VppIidFactory.getNodeIid(topologyKey, vppNode.getKey());
- wTx.put(LogicalDatastoreType.CONFIGURATION, nodeIid, vppNode);
- SettableFuture<Void> future = SettableFuture.create();
- Futures.addCallback(wTx.submit(), new FutureCallback<Void>() {
+ final WriteTransaction wTx = dataProvider.newWriteOnlyTransaction();
+ final Topology topology = new TopologyBuilder().setKey(topologyKey)
+ .setTopologyTypes(VBRIDGE_TOPOLOGY_TYPE)
+ .addAugmentation(TopologyVbridgeAugment.class, vBridgeAug)
+ .build();
+ wTx.put(LogicalDatastoreType.CONFIGURATION, topologyIid, topology, true);
+ Futures.addCallback(wTx.submit(), new FutureCallback<Void>() {
- @Override
- public void onSuccess(Void result) {
- DataTreeIdentifier<BridgeMember> bridgeMemberIid =
- new DataTreeIdentifier<>(LogicalDatastoreType.OPERATIONAL,
- nodeIid.augmentation(NodeVbridgeAugment.class).child(BridgeMember.class));
- LOG.debug("Request create node in topology for VBD was stored to CONF DS. {}", nodeIid);
- new ListenableFutureSetter<>(dataProvder, future, bridgeMemberIid,
- ModificationType.WRITE);
- }
+ @Override
+ public void onSuccess(@Nullable final Void result) {
+ final InstanceIdentifier<BridgeDomain> bridgeDomainStateIid =
+ VppIidFactory.getBridgeDomainStateIid(new BridgeDomainKey(bridgeDomainName));
+ final DataTreeIdentifier<BridgeDomain> bridgeDomainStateIidDTI = new DataTreeIdentifier<>(LogicalDatastoreType.OPERATIONAL,
+ bridgeDomainStateIid);
+ new ListenableFutureSetter<>(dataProvider, topologyFuture, bridgeDomainStateIidDTI, ModificationType.WRITE);
+ }
+ @Override
+ public void onFailure(@Nonnull Throwable t) {
+ LOG.warn("Request create topology for VBD was not stored to CONF DS. {}", topologyIid, t);
+ topologyFuture.setException(new Exception("Cannot send request to VBD."));
+ }
+ });
+ } else {
+ topologyFuture.set(null);
+ }
+ return Futures.transform(topologyFuture, new AsyncFunction<Void, Void>() {
@Override
- public void onFailure(Throwable t) {
- LOG.warn("Request create node in topology for VBD was not stored to CONF DS. {}", nodeIid, t);
- future.setException(new Exception("Cannot send request to VBD."));
+ public ListenableFuture<Void> apply(@Nonnull Void topologyInput) throws Exception {
+ // Bridge member
+ final SettableFuture<Void> futureBridgeMember = SettableFuture.create();
+ final InstanceIdentifier<Node> nodeIid = VppIidFactory.getNodeIid(topologyKey, vppNode.getKey());
+ final WriteTransaction wTx = dataProvider.newWriteOnlyTransaction();
+ wTx.put(LogicalDatastoreType.CONFIGURATION, nodeIid, vppNode);
+ Futures.addCallback(wTx.submit(), new FutureCallback<Void>() {
+
+ @Override
+ public void onSuccess(@Nullable final Void _void) {
+ final DataTreeIdentifier<BridgeMember> bridgeMemberIid =
+ new DataTreeIdentifier<>(LogicalDatastoreType.OPERATIONAL,
+ nodeIid.augmentation(NodeVbridgeAugment.class).child(BridgeMember.class));
+ LOG.debug("Request create node in topology for VBD was stored to CONF DS. {}", nodeIid);
+ new ListenableFutureSetter<>(dataProvider, futureBridgeMember, bridgeMemberIid,
+ ModificationType.WRITE);
+ }
+
+ @Override
+ public void onFailure(@Nonnull final Throwable t) {
+ LOG.warn("Request create node in topology for VBD was not stored to CONF DS. {}", nodeIid, t);
+ futureBridgeMember.setException(new Exception("Cannot send request to VBD."));
+ }
+ });
+ return futureBridgeMember;
}
});
- return future;
}
});
}
@Override
- public ListenableFuture<Void> removeBridgeDomainFromVppNode(@Nonnull String bridgeDomainName, NodeId vppNode) {
- WriteTransaction wTx = dataProvder.newWriteOnlyTransaction();
+ public ListenableFuture<Void> removeBridgeDomainFromVppNode(@Nonnull final String bridgeDomainName,
+ @Nonnull final NodeId vppNode) {
+ WriteTransaction wTx = dataProvider.newWriteOnlyTransaction();
InstanceIdentifier<Node> nodeIid =
VppIidFactory.getNodeIid(new TopologyKey(new TopologyId(bridgeDomainName)), new NodeKey(vppNode));
wTx.delete(LogicalDatastoreType.CONFIGURATION, nodeIid);
new DataTreeIdentifier<>(LogicalDatastoreType.OPERATIONAL,
nodeIid.augmentation(NodeVbridgeAugment.class).child(BridgeMember.class));
LOG.debug("Request delete node in topology for VBD was stored to CONF DS. {}", nodeIid);
- new ListenableFutureSetter<>(dataProvder, future, bridgeMemberIid, ModificationType.DELETE);
+ new ListenableFutureSetter<>(dataProvider, future, bridgeMemberIid, ModificationType.DELETE);
}
@Override
- public void onFailure(Throwable t) {
+ public void onFailure(@Nonnull Throwable t) {
LOG.warn("Request delete node in topology for VBD was not stored to CONF DS. {}", nodeIid, t);
future.setException(new Exception("Cannot send request to VBD."));
}
});
return future;
}
-
}
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.renderer.forwarding.renderer.forwarding.by.tenant.RendererNetworkDomainKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.Config;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.VlanNetwork;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.config.BridgeDomain;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.config.BridgeDomainKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.config.GbpBridgeDomain;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.config.GbpBridgeDomainKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.l2.types.rev130827.VlanId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev150105.VxlanVni;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;
private static final Logger LOG = LoggerFactory.getLogger(ForwardingManager.class);
@VisibleForTesting
- static long WAIT_FOR_BD_CREATION = 10; // seconds
+ private byte WAIT_FOR_BD_CREATION = 60; // seconds
private long lastVxlanVni = 1L;
private final Map<String, VxlanVni> vxlanVniByBridgeDomain = new HashMap<>();
private final InterfaceManager ifaceManager;
this.dataBroker = Preconditions.checkNotNull(dataBroker);
}
- public Optional<BridgeDomain> readBridgeDomainConfig(String name) {
- InstanceIdentifier<BridgeDomain> bdIid = InstanceIdentifier.builder(Config.class)
- .child(BridgeDomain.class, new BridgeDomainKey(name))
+ public Optional<GbpBridgeDomain> readGbpBridgeDomainConfig(String name) {
+ InstanceIdentifier<GbpBridgeDomain> bdIid = InstanceIdentifier.builder(Config.class)
+ .child(GbpBridgeDomain.class, new GbpBridgeDomainKey(name))
.build();
ReadOnlyTransaction rTx = dataBroker.newReadOnlyTransaction();
return DataStoreHelper.readFromDs(LogicalDatastoreType.CONFIGURATION, bdIid, rTx);
public void createBridgeDomainOnNodes(SetMultimap<String, NodeId> vppNodesByBridgeDomain) {
for (String bd : vppNodesByBridgeDomain.keySet()) {
- Optional<BridgeDomain> bdConfig = readBridgeDomainConfig(bd);
+ Optional<GbpBridgeDomain> bdConfig = readGbpBridgeDomainConfig(bd);
Set<NodeId> vppNodes = vppNodesByBridgeDomain.get(bd);
if (bdConfig.isPresent()) {
if (bdConfig.get().getType().equals(VlanNetwork.class)) {
}
}
- private void createVxlanBridgeDomains(String bd, VxlanVni vni, Set<NodeId> vppNodes) {
+ private void createVxlanBridgeDomains(final String bd, final VxlanVni vni, final Set<NodeId> vppNodes) {
for (NodeId vppNode : vppNodes) {
try {
LOG.debug("Creating VXLAN bridge-domain {} on node {} with VNI {}", bd, vppNode.getValue(),
vni);
- // TODO think about propagating ListenableFuture - timeout set as workaround
bdManager.createVxlanBridgeDomainOnVppNode(bd, vni, vppNode).get(WAIT_FOR_BD_CREATION,
TimeUnit.SECONDS);
} catch (InterruptedException | ExecutionException e) {
LOG.warn("VXLAN Bridge domain {} was not created on node {}", bd, vppNode.getValue(), e);
} catch (TimeoutException e) {
LOG.warn("Probably, VXLAN Bridge domain {} was not created on node {} because BridgeDomainManager "
- + "did not respond by {} seconds.", bd, vppNode.getValue(), WAIT_FOR_BD_CREATION, e);
+ + "did not respond by {} seconds. Check VBD log for more details",
+ bd, vppNode.getValue(), WAIT_FOR_BD_CREATION, e);
}
}
}
- private void createVlanBridgeDomains(String bd, VlanId vlanId, Set<NodeId> vppNodes) {
+ private void createVlanBridgeDomains(final String bd, final VlanId vlanId, final Set<NodeId> vppNodes) {
for (NodeId vppNode : vppNodes) {
try {
LOG.debug("Creating VLAN bridge-domain {} on node {} with VLAN ID {}", bd, vppNode.getValue(),
vlanId.getValue());
- // TODO think about propagating ListenableFuture - timeout set as workaround
bdManager.createVlanBridgeDomainOnVppNode(bd, vlanId, vppNode).get(WAIT_FOR_BD_CREATION,
TimeUnit.SECONDS);
} catch (InterruptedException | ExecutionException e) {
LOG.warn("VLAN Bridge domain {} was not created on node {}", bd, vppNode.getValue(), e);
} catch (TimeoutException e) {
LOG.warn("Probably, VLAN Bridge domain {} was not created on node {} because BridgeDomainManager "
- + "did not respond by {} seconds.", bd, vppNode.getValue(), WAIT_FOR_BD_CREATION, e);
+ + "did not respond by {} seconds. Check VBD log for more details",
+ bd, vppNode.getValue(), WAIT_FOR_BD_CREATION, e);
}
}
}
- public void removeBridgeDomainOnNodes(SetMultimap<String, NodeId> vppNodesByBridgeDomain) {
+ public void removeBridgeDomainOnNodes(final SetMultimap<String, NodeId> vppNodesByBridgeDomain) {
for (String bd : vppNodesByBridgeDomain.keySet()) {
Set<NodeId> vppNodes = vppNodesByBridgeDomain.get(bd);
for (NodeId vppNode : vppNodes) {
LOG.warn("Bridge domain {} was not removed from node {}", bd, vppNode.getValue(), e);
} catch (TimeoutException e) {
LOG.warn("Probably, bridge domain {} was not removed from node {} because BridgeDomainManager "
- + "did not respond by {} seconds.", bd, vppNode.getValue(), WAIT_FOR_BD_CREATION, e);
+ + "did not respond by {} seconds. Check VBD log for more details",
+ bd, vppNode.getValue(), WAIT_FOR_BD_CREATION, e);
}
}
}
ExternalLocationCase rEpLoc = resolveAndValidateLocation(rEp);
if (Strings.isNullOrEmpty(rEpLoc.getExternalNodeConnector())) {
// TODO add it to the status for renderer manager
- LOG.info("Rednerer endpoint does not have external-node-connector therefore it is ignored {}", rEp);
+ LOG.info("Renderer endpoint does not have external-node-connector therefore it is ignored {}", rEp);
return;
}
java.util.Optional<String> optL2FloodDomain = resolveL2FloodDomain(rEp, policyCtx);
if (!optL2FloodDomain.isPresent()) {
// TODO add it to the status for renderer manager
- LOG.info("Rednerer endpoint does not have l2FloodDomain as network containment {}", rEp);
+ LOG.info("Renderer endpoint does not have l2FloodDomain as network containment {}", rEp);
return;
}
String l2FloodDomain = optL2FloodDomain.get();
return java.util.Optional.empty();
}
- public static @Nonnull java.util.Optional<RendererForwardingContext> getForwardingCtxForParent(
+ private static @Nonnull java.util.Optional<RendererForwardingContext> getForwardingCtxForParent(
@Nullable TenantId tenant, @Nullable Parent parent,
Table<TenantId, RendererForwardingContextKey, RendererForwardingContext> forwardingCtxTable) {
if (tenant == null || parent == null) {
return java.util.Optional.empty();
}
+ @VisibleForTesting
+ void setTimer(byte time) {
+ WAIT_FOR_BD_CREATION = time;
+ }
}
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.RendererNodes;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.nodes.RendererNode;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.nodes.RendererNodeKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev150105.VppState;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev150105.vpp.state.BridgeDomains;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev150105.vpp.state.bridge.domains.BridgeDomain;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev150105.vpp.state.bridge.domains.BridgeDomainKey;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NetworkTopology;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.Topology;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.TopologyKey;
public static InstanceIdentifier<RendererNodes> getRendererNodesIid() {
return InstanceIdentifier.builder(Renderers.class)
- .child(Renderer.class, new RendererKey(VppRenderer.NAME))
- .child(RendererNodes.class)
- .build();
+ .child(Renderer.class, new RendererKey(VppRenderer.NAME))
+ .child(RendererNodes.class)
+ .build();
}
public static InstanceIdentifier<RendererNode> getRendererNodeIid(RendererNode rendererNode) {
return InstanceIdentifier.builder(Renderers.class)
- .child(Renderer.class, new RendererKey(VppRenderer.NAME))
- .child(RendererNodes.class)
- .child(RendererNode.class, new RendererNodeKey(rendererNode.getNodePath()))
- .build();
+ .child(Renderer.class, new RendererKey(VppRenderer.NAME))
+ .child(RendererNodes.class)
+ .child(RendererNode.class, new RendererNodeKey(rendererNode.getNodePath()))
+ .build();
}
public static InstanceIdentifier<Node> getNodeIid(TopologyKey topologyKey, NodeKey nodeKey) {
return InstanceIdentifier.builder(NetworkTopology.class)
- .child(Topology.class, topologyKey)
- .child(Node.class, nodeKey)
- .build();
+ .child(Topology.class, topologyKey)
+ .child(Node.class, nodeKey)
+ .build();
}
public static InstanceIdentifier<Topology> getTopologyIid(TopologyKey bridgeDomainKey) {
return InstanceIdentifier.builder(NetworkTopology.class)
.child(Topology.class, bridgeDomainKey).build();
}
+
+ public static InstanceIdentifier<BridgeDomain> getBridgeDomainStateIid(final BridgeDomainKey bridgeDomainStateKey) {
+ return InstanceIdentifier.builder(VppState.class)
+ .child(BridgeDomains.class)
+ .child(BridgeDomain.class, bridgeDomainStateKey)
+ .build();
+ }
}
}
}
- list bridge-domain {
+ list gbp-bridge-domain {
key "id";
leaf id {
description "Same as in VBD.";
package org.opendaylight.groupbasedpolicy.renderer.vpp.policy;
+import javax.annotation.Nonnull;
import java.util.Arrays;
import java.util.Collection;
+import java.util.Collections;
import java.util.concurrent.ExecutionException;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
+import org.mockito.Mockito;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.groupbasedpolicy.renderer.vpp.iface.InterfaceManager;
import org.opendaylight.groupbasedpolicy.renderer.vpp.util.VppIidFactory;
import org.opendaylight.groupbasedpolicy.test.CustomDataBrokerTest;
import org.opendaylight.groupbasedpolicy.util.DataStoreHelper;
private final static boolean BRIDGE_DOMAIN_ARP = false;
private final static NodeId VPP_NODE_ID = new NodeId("vppNode");
private final static Topology BASE_TOPOLOGY = new TopologyBuilder().setTopologyId(BASE_TOPOLOGY_ID)
- .setNode(Arrays.asList(new NodeBuilder().setNodeId(VPP_NODE_ID)
- .setSupportingNode(Arrays.asList(new SupportingNodeBuilder().setTopologyRef(SUPPORTING_TOPOLOGY_NETCONF)
- .setNodeRef(VPP_NODE_ID)
+ .setNode(Collections.singletonList(new NodeBuilder().setNodeId(VPP_NODE_ID)
+ .setSupportingNode(Collections.singletonList(new SupportingNodeBuilder().setTopologyRef(SUPPORTING_TOPOLOGY_NETCONF)
+ .setNodeRef(VPP_NODE_ID)
+ .build()))
.build()))
- .build()))
.setTopologyTypes(new TopologyTypesBuilder()
.addAugmentation(TopologyTypesVbridgeAugment.class, new TopologyTypesVbridgeAugmentBuilder()
.setVbridgeTopology(new VbridgeTopologyBuilder().build()).build())
private BridgeDomainManagerImpl bridgeDomainManager;
@Override
+ @Nonnull
public Collection<Class<?>> getClassesFromModules() {
return Arrays.asList(NetworkTopology.class, Topology.class, TopologyVbridgeAugment.class,
TunnelTypeVxlan.class);
public void init() {
dataBroker = getDataBroker();
bridgeDomainManager = new BridgeDomainManagerImpl(dataBroker);
+ final InterfaceManager interfaceManager = Mockito.mock(InterfaceManager.class);
+ final ForwardingManager fwManager = new ForwardingManager(interfaceManager, bridgeDomainManager, dataBroker);
+ fwManager.setTimer((byte) 1);
}
@Test
public void testCreateVxlanBridgeDomainOnVppNode() throws Exception {
bridgeDomainManager.createVxlanBridgeDomainOnVppNode(BRIDGE_DOMAIN_ID, BRIDGE_DOMAIN_VNI, VPP_NODE_ID);
-
// simulates VBD - when BD is created a node is stored to OPER DS
Thread vbdThread = new Thread(() -> {
WriteTransaction wTx = dataBroker.newWriteOnlyTransaction();
Assert.assertTrue(topologyOptional.isPresent());
Topology topology = topologyOptional.get();
- Assert.assertEquals(BASE_TOPOLOGY, topology);
+ Assert.assertEquals(BASE_TOPOLOGY.getAugmentation(TopologyVbridgeAugment.class),
+ topology.getAugmentation(TopologyVbridgeAugment.class));
}
@Test
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.Configuration;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.endpoints.AddressEndpointWithLocation;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.renderer.endpoints.RendererEndpoint;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.renderer.endpoints.RendererEndpointKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.Config;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.NetworkTypeBase;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.VlanNetwork;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.config.BridgeDomain;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.config.BridgeDomainBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.config.GbpBridgeDomain;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.config.GbpBridgeDomainBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.l2.types.rev130827.VlanId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev150105.VxlanVni;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;
@Override
public Collection<Class<?>> getClassesFromModules() {
- return Arrays.asList(BridgeDomain.class);
+ return Arrays.asList(GbpBridgeDomain.class);
}
@Test
public void testReadBridgeDomainConfig() throws Exception {
- BridgeDomain bd = new BridgeDomainBuilder().setId(BD_1).setType(NetworkTypeBase.class).build();
- InstanceIdentifier<BridgeDomain> bdIid =
- InstanceIdentifier.builder(Config.class).child(BridgeDomain.class, bd.getKey()).build();
- Optional<BridgeDomain> bdOptional = fwdManager.readBridgeDomainConfig(bd.getId());
+ GbpBridgeDomain bd = new GbpBridgeDomainBuilder().setId(BD_1).setType(NetworkTypeBase.class).build();
+ InstanceIdentifier<GbpBridgeDomain> bdIid =
+ InstanceIdentifier.builder(Config.class).child(GbpBridgeDomain.class, bd.getKey()).build();
+ Optional<GbpBridgeDomain> bdOptional = fwdManager.readGbpBridgeDomainConfig(bd.getId());
Assert.assertFalse(bdOptional.isPresent());
WriteTransaction wTx = getDataBroker().newWriteOnlyTransaction();
wTx.put(LogicalDatastoreType.CONFIGURATION, bdIid, bd);
wTx.submit().get();
- bdOptional = fwdManager.readBridgeDomainConfig(bd.getId());
+ bdOptional = fwdManager.readGbpBridgeDomainConfig(bd.getId());
Assert.assertTrue(bdOptional.isPresent());
Assert.assertEquals(bd, bdOptional.get());
}
Mockito.when(bdManager.createVlanBridgeDomainOnVppNode(Mockito.eq(BD_1), Mockito.any(VlanId.class),
Mockito.eq(NODE_1)))
.thenReturn(Futures.immediateFuture(null));
- BridgeDomain bd = new BridgeDomainBuilder().setId(BD_1).setType(VlanNetwork.class).setVlan(VLAN_1).build();
- InstanceIdentifier<BridgeDomain> bdIid =
- InstanceIdentifier.builder(Config.class).child(BridgeDomain.class, bd.getKey()).build();
+ GbpBridgeDomain bd = new GbpBridgeDomainBuilder().setId(BD_1).setType(VlanNetwork.class).setVlan(VLAN_1).build();
+ InstanceIdentifier<GbpBridgeDomain> bdIid =
+ InstanceIdentifier.builder(Config.class).child(GbpBridgeDomain.class, bd.getKey()).build();
WriteTransaction wTx = getDataBroker().newWriteOnlyTransaction();
wTx.put(LogicalDatastoreType.CONFIGURATION, bdIid, bd);
wTx.submit().get();
import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.groupbasedpolicy.renderer.vpp.DtoFactory;
-import org.opendaylight.groupbasedpolicy.renderer.vpp.api.BridgeDomainManager;
import org.opendaylight.groupbasedpolicy.renderer.vpp.event.RendererPolicyConfEvent;
import org.opendaylight.groupbasedpolicy.renderer.vpp.event.VppEndpointConfEvent;
import org.opendaylight.groupbasedpolicy.renderer.vpp.iface.InterfaceManager;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.config.VppEndpoint;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.config.VppEndpointBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.config.VppEndpointKey;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.config.bridge.domain.PhysicalLocationRef;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.config.gbp.bridge.domain.PhysicalLocationRef;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.config.vpp.endpoint._interface.type.choice.VhostUserCaseBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev150105.VppInterfaceAugmentation;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev150105.VxlanVni;
private DataBroker mountPointDataBroker;
private DataBroker dataBroker;
- private BridgeDomainManager bdManager;
+ private BridgeDomainManagerImpl bdManager;
private InterfaceManager ifaceManager;
private ForwardingManager fwManager;
private VppRendererPolicyManager vppRendererPolicyManager;
@Before
public void init() throws Exception {
- ForwardingManager.WAIT_FOR_BD_CREATION = 2;
mountedDataProviderMock = Mockito.mock(MountedDataBrokerProvider.class);
mountPointDataBroker = getDataBroker();
setup(); // initialize new data broker for ODL data store
bdManager = new BridgeDomainManagerImpl(mountPointDataBroker);
fwManager = new ForwardingManager(ifaceManager, bdManager, dataBroker);
vppRendererPolicyManager = new VppRendererPolicyManager(fwManager, dataBroker);
+ fwManager.setTimer((byte) 1);
}
@Test
Code Review / groupbasedpolicy.git / commitdiff