import static org.opendaylight.groupbasedpolicy.neutron.ovsdb.util.OvsdbHelper.getManagerNode;
import static org.opendaylight.groupbasedpolicy.neutron.ovsdb.util.OvsdbHelper.getOvsdbBridgeFromTerminationPoint;
import static org.opendaylight.groupbasedpolicy.neutron.ovsdb.util.OvsdbHelper.getTopologyNode;
-import static org.opendaylight.groupbasedpolicy.util.DataStoreHelper.readFromDs;
import java.util.ArrayList;
+import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
-import java.util.Map.Entry;
-
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.DataChangeListener;
+import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
+import org.opendaylight.controller.md.sal.binding.api.DataTreeChangeListener;
+import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
+import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker.DataChangeScope;
-import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.ovsdb.southbound.SouthboundConstants;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPoint;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
-import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import com.google.common.base.Optional;
-
-public class TerminationPointDataChangeListener implements DataChangeListener, AutoCloseable {
+public class TerminationPointDataChangeListener implements DataTreeChangeListener<OvsdbTerminationPointAugmentation>,
+ AutoCloseable {
private static final String NEUTRON_EXTERNAL_ID_KEY = "iface-id";
- private final ListenerRegistration<DataChangeListener> registration;
+ private final ListenerRegistration<?> registration;
private final DataBroker dataBroker;
private final EndpointService epService;
private static final Logger LOG = LoggerFactory.getLogger(TerminationPointDataChangeListener.class);
.child(Node.class)
.child(TerminationPoint.class)
.augmentation(OvsdbTerminationPointAugmentation.class);
- registration =
- dataBroker.registerDataChangeListener(LogicalDatastoreType.OPERATIONAL, iid, this, DataChangeScope.ONE);
+ registration = dataBroker.registerDataTreeChangeListener(new DataTreeIdentifier<>(
+ LogicalDatastoreType.OPERATIONAL, iid), this);
requiredTunnelTypes = createSupportedTunnelsList();
}
private List<AbstractTunnelType> createSupportedTunnelsList() {
- List<AbstractTunnelType> required = new ArrayList<AbstractTunnelType>();
+ List<AbstractTunnelType> required = new ArrayList<>();
required.add(new VxlanTunnelType());
required.add(new VxlanGpeTunnelType());
return Collections.unmodifiableList(required);
new HashMap<>();
@Override
- public void onDataChanged(AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> change) {
-
- /*
- * TerminationPoint notifications with OVSDB augmentations
- * vSwitch ports. Iterate through the list of new ports.
- */
- for (Entry<InstanceIdentifier<?>, DataObject> entry : change.getCreatedData().entrySet()) {
- if (entry.getValue() instanceof OvsdbTerminationPointAugmentation) {
- OvsdbTerminationPointAugmentation ovsdbTp = (OvsdbTerminationPointAugmentation) entry.getValue();
- @SuppressWarnings("unchecked")
- InstanceIdentifier<OvsdbTerminationPointAugmentation> ovsdbTpIid =
- (InstanceIdentifier<OvsdbTerminationPointAugmentation>) entry.getKey();
- OvsdbBridgeAugmentation ovsdbBridge = getOvsdbBridgeFromTerminationPoint(ovsdbTpIid, dataBroker);
- nodeIdByTerminPoint.put(ovsdbTpIid,
- new NodeId(getInventoryNodeIdString(ovsdbBridge, ovsdbTpIid, dataBroker)));
- processOvsdbBridge(ovsdbBridge, ovsdbTp, ovsdbTpIid);
- }
- }
-
- /*
- * Updates
- */
- for (Entry<InstanceIdentifier<?>, DataObject> entry : change.getUpdatedData().entrySet()) {
- if (entry.getValue() instanceof OvsdbTerminationPointAugmentation) {
- OvsdbTerminationPointAugmentation ovsdbTp = (OvsdbTerminationPointAugmentation) entry.getValue();
- @SuppressWarnings("unchecked")
- InstanceIdentifier<OvsdbTerminationPointAugmentation> ovsdbTpIid =
- (InstanceIdentifier<OvsdbTerminationPointAugmentation>) entry.getKey();
- OvsdbBridgeAugmentation ovsdbBridge = getOvsdbBridgeFromTerminationPoint(ovsdbTpIid, dataBroker);
- processOvsdbBridge(ovsdbBridge, ovsdbTp, ovsdbTpIid);
- }
- }
-
- /*
- * Deletions
- */
- for (InstanceIdentifier<?> iid : change.getRemovedPaths()) {
- DataObject old = change.getOriginalData().get(iid);
- if (old instanceof OvsdbTerminationPointAugmentation) {
- OvsdbTerminationPointAugmentation ovsdbTp = (OvsdbTerminationPointAugmentation) old;
- @SuppressWarnings("unchecked")
- InstanceIdentifier<OvsdbTerminationPointAugmentation> ovsdbTpIid =
- (InstanceIdentifier<OvsdbTerminationPointAugmentation>) iid;
- processRemovedTp(nodeIdByTerminPoint.get(ovsdbTpIid), ovsdbTp, ovsdbTpIid);
+ public void onDataTreeChanged(Collection<DataTreeModification<OvsdbTerminationPointAugmentation>> changes) {
+ for (DataTreeModification<OvsdbTerminationPointAugmentation> change: changes) {
+ DataObjectModification<OvsdbTerminationPointAugmentation> rootNode = change.getRootNode();
+ InstanceIdentifier<OvsdbTerminationPointAugmentation> ovsdbTpIid = change.getRootPath().getRootIdentifier();
+ OvsdbTerminationPointAugmentation origOvsdbTp = rootNode.getDataBefore();
+ switch (rootNode.getModificationType()) {
+ case SUBTREE_MODIFIED:
+ case WRITE:
+ OvsdbTerminationPointAugmentation updatedOvsdbTp = rootNode.getDataAfter();
+ OvsdbBridgeAugmentation ovsdbBridge = getOvsdbBridgeFromTerminationPoint(ovsdbTpIid, dataBroker);
+ if (origOvsdbTp == null) {
+ nodeIdByTerminPoint.put(ovsdbTpIid,
+ new NodeId(getInventoryNodeIdString(ovsdbBridge, ovsdbTpIid, dataBroker)));
+ }
+
+ processOvsdbBridge(ovsdbBridge, updatedOvsdbTp, ovsdbTpIid);
+ break;
+ case DELETE:
+ processRemovedTp(nodeIdByTerminPoint.get(ovsdbTpIid), origOvsdbTp, ovsdbTpIid);
+ break;
+ default:
+ break;
}
}
}
*/
OvsdbNodeAugmentation managerNode = getManagerNode(ovsdbBridge, dataBroker);
- if (managerNode == null)
+ if (managerNode == null) {
return null;
+ }
if (managerNode.getConnectionInfo() != null) {
return managerNode.getConnectionInfo().getRemoteIp();
package org.opendaylight.groupbasedpolicy.neutron.ovsdb;
import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.Map;
-import java.util.Set;
-import java.util.UUID;
-
import com.google.common.base.Optional;
import com.google.common.util.concurrent.CheckedFuture;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.UUID;
import org.junit.Before;
import org.junit.Test;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.DataChangeListener;
+import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
+import org.opendaylight.controller.md.sal.binding.api.DataTreeChangeListener;
+import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
+import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker.DataChangeScope;
-import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPoint;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
-import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
public class TerminationPointDataChangeListenerTest {
private DataBroker dataBroker;
private EndpointService epService;
- private ListenerRegistration<DataChangeListener> registration;
- private AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> change;
+ private ListenerRegistration<?> registration;
- private Map<InstanceIdentifier<?>, DataObject> dataMap;
- private Set<InstanceIdentifier<?>> dataSet;
+ private DataObjectModification<OvsdbTerminationPointAugmentation> mockModification;
+ private Collection<DataTreeModification<OvsdbTerminationPointAugmentation>> changeEvent;
private Node node;
private CheckedFuture<Optional<OvsdbBridgeAugmentation>, ReadFailedException> ovsdbBridgeFuture;
dataBroker = mock(DataBroker.class);
epService = mock(EndpointService.class);
registration = mock(ListenerRegistration.class);
- when(
- dataBroker.registerDataChangeListener(any(LogicalDatastoreType.class), any(InstanceIdentifier.class),
- any(DataChangeListener.class), any(DataChangeScope.class))).thenReturn(registration);
- change = mock(AsyncDataChangeEvent.class);
+ when(dataBroker.registerDataTreeChangeListener(any(DataTreeIdentifier.class),
+ any(DataTreeChangeListener.class))).thenReturn(registration);
InstanceIdentifier<OvsdbTerminationPointAugmentation> ovsdbTpIid = InstanceIdentifier.create(
NetworkTopology.class)
when(externalId.getExternalIdKey()).thenReturn("iface-id");
when(externalId.getExternalIdValue()).thenReturn(UUID.randomUUID().toString());
- dataMap = new HashMap<>();
- dataMap.put(ovsdbTpIid, ovsdbTp);
- dataSet = new HashSet<InstanceIdentifier<?>>(Collections.singletonList(ovsdbTpIid));
-
readTransaction = mock(ReadOnlyTransaction.class);
when(dataBroker.newReadOnlyTransaction()).thenReturn(readTransaction);
readWriteTransaction = mock(ReadWriteTransaction.class);
when(ofOverlayNodeConfigOptional.get()).thenReturn(ofOverlayNodeConfig);
listener = new TerminationPointDataChangeListener(dataBroker, epService);
+
+ DataTreeModification<OvsdbTerminationPointAugmentation> mockDataTreeModification =
+ mock(DataTreeModification.class);
+ mockModification = mock(DataObjectModification.class);
+ doReturn(mockModification).when(mockDataTreeModification).getRootNode();
+ doReturn(new DataTreeIdentifier<>(LogicalDatastoreType.OPERATIONAL, ovsdbTpIid))
+ .when(mockDataTreeModification).getRootPath();
+ changeEvent = Collections.singletonList(mockDataTreeModification);
}
@Test
@SuppressWarnings("unchecked")
@Test
public void testOnDataChanged_Creation() {
- when(change.getCreatedData()).thenReturn(dataMap);
+ doReturn(DataObjectModification.ModificationType.WRITE).when(mockModification).getModificationType();
+ doReturn(ovsdbTp).when(mockModification).getDataAfter();
+
when(readTransaction.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class))).thenReturn(
ovsdbBridgeFuture)
.thenReturn(endpointFuture)
when(readWriteTransaction.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class))).thenReturn(
endpointByPortFuture).thenReturn(ofOverlayNodeConfigFuture);
- listener.onDataChanged(change);
+ listener.onDataTreeChanged(changeEvent);
verify(readWriteTransaction).submit();
}
@SuppressWarnings("unchecked")
@Test
public void testOnDataChanged_CreationExternalIdNull() {
- when(change.getCreatedData()).thenReturn(dataMap);
+ doReturn(DataObjectModification.ModificationType.WRITE).when(mockModification).getModificationType();
+ doReturn(ovsdbTp).when(mockModification).getDataAfter();
+
when(readTransaction.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class))).thenReturn(
ovsdbBridgeFuture).thenReturn(nodeFuture);
when(ovsdbTp.getInterfaceExternalIds()).thenReturn(null);
- listener.onDataChanged(change);
+ listener.onDataTreeChanged(changeEvent);
verify(readWriteTransaction, never()).submit();
}
@SuppressWarnings("unchecked")
@Test
public void testOnDataChanged_Update() {
- when(change.getUpdatedData()).thenReturn(dataMap);
+ doReturn(DataObjectModification.ModificationType.WRITE).when(mockModification).getModificationType();
+ doReturn(ovsdbTp).when(mockModification).getDataBefore();
+ doReturn(ovsdbTp).when(mockModification).getDataAfter();
+
when(readTransaction.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class))).thenReturn(
ovsdbBridgeFuture)
.thenReturn(endpointFuture)
when(readWriteTransaction.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class))).thenReturn(
endpointByPortFuture).thenReturn(ofOverlayNodeConfigFuture);
- listener.onDataChanged(change);
+ listener.onDataTreeChanged(changeEvent);
verify(readWriteTransaction).submit();
}
@SuppressWarnings("unchecked")
@Test
public void testOnDataChanged_Removal() {
- when(change.getRemovedPaths()).thenReturn(dataSet);
- when(change.getOriginalData()).thenReturn(dataMap);
+ doReturn(DataObjectModification.ModificationType.DELETE).when(mockModification).getModificationType();
+ doReturn(ovsdbTp).when(mockModification).getDataBefore();
+
when(readWriteTransaction.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class))).thenReturn(
endpointByPortFuture);
when(readTransaction.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class))).thenReturn(
endpointFuture);
- listener.onDataChanged(change);
+ listener.onDataTreeChanged(changeEvent);
verify(readWriteTransaction).submit();
}
}
package org.opendaylight.groupbasedpolicy.renderer.faas;
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Optional;
import java.util.ArrayList;
+import java.util.Collection;
import java.util.List;
-import java.util.Map;
import java.util.UUID;
import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.ExecutionException;
-import java.util.concurrent.ScheduledExecutorService;
-
-import com.google.common.annotations.VisibleForTesting;
+import java.util.concurrent.Executor;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.DataChangeListener;
+import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
+import org.opendaylight.controller.md.sal.binding.api.DataTreeChangeListener;
+import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
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.AsyncDataChangeEvent;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.faas.uln.datastore.api.UlnDatastoreApi;
import org.opendaylight.groupbasedpolicy.util.DataStoreHelper;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.policy.subject.feature.instances.ActionInstanceKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.policy.subject.feature.instances.ClassifierInstance;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.policy.subject.feature.instances.ClassifierInstanceKey;
-import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import com.google.common.base.Optional;
-
-public class FaasContractManagerListener implements DataChangeListener {
+public class FaasContractManagerListener implements DataTreeChangeListener<Contract> {
private static final Logger LOG = LoggerFactory.getLogger(FaasContractManagerListener.class);
- private ConcurrentHashMap<ContractId, Uuid> mappedContracts = new ConcurrentHashMap<>();
- private final ScheduledExecutorService executor;
+ private final ConcurrentHashMap<ContractId, Uuid> mappedContracts = new ConcurrentHashMap<>();
+ private final Executor executor;
private final DataBroker dataProvider;
private final TenantId gbpTenantId;
private final Uuid faasTenantId;
public FaasContractManagerListener(DataBroker dataProvider, TenantId gbpTenantId, Uuid faasTenantId,
- ScheduledExecutorService executor) {
+ Executor executor) {
this.executor = executor;
this.gbpTenantId = gbpTenantId;
this.faasTenantId = faasTenantId;
}
@Override
- public void onDataChanged(final AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> change) {
- executor.execute(new Runnable() {
-
- public void run() {
- executeEvent(change);
- }
- });
+ public void onDataTreeChanged(Collection<DataTreeModification<Contract>> changes) {
+ executor.execute(() -> executeEvent(changes));
}
- @VisibleForTesting
- void executeEvent(final AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> change) {
- // Create
- for (DataObject dao : change.getCreatedData().values()) {
- if (dao instanceof Contract) {
- Contract contract = (Contract) dao;
- LOG.debug("Contract {} is Created.", contract.getId().getValue());
- UlnDatastoreApi.submitSecurityGroupsToDs(initSecurityGroupBuilder(contract).build());
- }
- }
- // Update
- Map<InstanceIdentifier<?>, DataObject> dao = change.getUpdatedData();
- for (Map.Entry<InstanceIdentifier<?>, DataObject> entry : dao.entrySet()) {
- if (entry.getValue() instanceof Contract) {
- Contract contract = (Contract) entry.getValue();
- LOG.debug("Contract {} is Updated.", contract.getId().getValue());
- UlnDatastoreApi.submitSecurityGroupsToDs(initSecurityGroupBuilder(contract).build());
- }
- }
- // Remove
- for (InstanceIdentifier<?> iid : change.getRemovedPaths()) {
- DataObject old = change.getOriginalData().get(iid);
- if (old == null) {
- continue;
- }
- if (old instanceof Contract) {
- Contract contract = (Contract) old;
- LOG.debug("Contract {} is removed.", contract.getId().getValue());
- ReadWriteTransaction rwTx = dataProvider.newReadWriteTransaction();
- Optional<MappedContract> op = DataStoreHelper.removeIfExists(LogicalDatastoreType.OPERATIONAL,
- FaasIidFactory.mappedContractIid(gbpTenantId, contract.getId()), rwTx);
- if (op.isPresent()) {
- DataStoreHelper.submitToDs(rwTx);
- }
- Uuid val = mappedContracts.remove(contract.getId());
- if (val != null) {
- UlnDatastoreApi.removeSecurityGroupsFromDsIfExists(faasTenantId, val);
- }
+ private void executeEvent(final Collection<DataTreeModification<Contract>> changes) {
+ for (DataTreeModification<Contract> change: changes) {
+ DataObjectModification<Contract> rootNode = change.getRootNode();
+ switch (rootNode.getModificationType()) {
+ case SUBTREE_MODIFIED:
+ case WRITE:
+ Contract updatedContract = rootNode.getDataAfter();
+ LOG.debug("Contract {} is Updated.", updatedContract.getId().getValue());
+ UlnDatastoreApi.submitSecurityGroupsToDs(initSecurityGroupBuilder(updatedContract).build());
+ break;
+ case DELETE:
+ Contract deletedContract = rootNode.getDataBefore();
+ LOG.debug("Contract {} is removed.", deletedContract.getId().getValue());
+ ReadWriteTransaction rwTx = dataProvider.newReadWriteTransaction();
+ Optional<MappedContract> op = DataStoreHelper.removeIfExists(LogicalDatastoreType.OPERATIONAL,
+ FaasIidFactory.mappedContractIid(gbpTenantId, deletedContract.getId()), rwTx);
+ if (op.isPresent()) {
+ DataStoreHelper.submitToDs(rwTx);
+ }
+ Uuid val = mappedContracts.remove(deletedContract.getId());
+ if (val != null) {
+ UlnDatastoreApi.removeSecurityGroupsFromDsIfExists(faasTenantId, val);
+ }
+ break;
+ default:
+ break;
}
}
}
SecurityRuleGroupsBuilder builder = new SecurityRuleGroupsBuilder();
builder.setUuid(getFaasSecurityRulesId(contract.getId()));
builder.setName(new Text(contract.getId().getValue()));
- if (contract.getDescription() != null)
+ if (contract.getDescription() != null) {
builder.setDescription(new Text("gbp-contract: " + contract.getDescription().getValue()));
- else
+ } else {
builder.setDescription(new Text("gbp-contract"));
+ }
builder.setTenantId(faasTenantId);
builder.setSecurityRuleGroup(buildSecurityRuleGroup(contract));
LOG.trace("Contract {} is mapped to Faas Security Rules {} ", contract.getId().getValue(), builder.getUuid()
import static com.google.common.base.Preconditions.checkNotNull;
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Optional;
import java.util.ArrayList;
+import java.util.Collection;
import java.util.List;
-import java.util.Map;
import java.util.UUID;
-import java.util.concurrent.ScheduledExecutorService;
-
+import java.util.concurrent.Executor;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.DataChangeListener;
+import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
+import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
+import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
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.AsyncDataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.faas.uln.datastore.api.UlnDatastoreApi;
import org.opendaylight.groupbasedpolicy.util.DataStoreHelper;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.endpoint.fields.L3Address;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.endpoints.Endpoint;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.endpoints.EndpointL3;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.endpoints.EndpointL3Prefix;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.faas.rev151009.mapped.tenants.entities.mapped.entity.MappedEndpoint;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.faas.rev151009.mapped.tenants.entities.mapped.entity.MappedEndpointBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.faas.rev151009.mapped.tenants.entities.mapped.entity.MappedEndpointKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.faas.rev151009.mapped.tenants.entities.mapped.entity.MappedSubnet;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
-import org.opendaylight.yangtools.yang.binding.DataObject;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import com.google.common.annotations.VisibleForTesting;
-import com.google.common.base.Optional;
-
-public class FaasEndpointManagerListener implements DataChangeListener, AutoCloseable {
+public class FaasEndpointManagerListener implements AutoCloseable {
private static final Logger LOG = LoggerFactory.getLogger(FaasEndpointManagerListener.class);
- private final ScheduledExecutorService executor;
- private final ListenerRegistration<DataChangeListener> registerListener;
+ private final List<ListenerRegistration<?>> listenerRegistrations = new ArrayList<>();
private final FaasPolicyManager policyManager;
private final DataBroker dataProvider;
public FaasEndpointManagerListener(FaasPolicyManager policyManager, DataBroker dataProvider,
- ScheduledExecutorService executor) {
- this.executor = executor;
+ Executor executor) {
this.policyManager = policyManager;
this.dataProvider = dataProvider;
- this.registerListener = checkNotNull(dataProvider).registerDataChangeListener(LogicalDatastoreType.OPERATIONAL,
- IidFactory.endpointsIidWildcard(), this, AsyncDataBroker.DataChangeScope.SUBTREE);
+
+ checkNotNull(dataProvider);
+ listenerRegistrations.add(dataProvider.registerDataTreeChangeListener(new DataTreeIdentifier<>(
+ LogicalDatastoreType.OPERATIONAL, IidFactory.endpointsIidWildcard().child(Endpoint.class)),
+ changes -> executor.execute(() -> onEndpointChanged(changes))));
+
+ listenerRegistrations.add(dataProvider.registerDataTreeChangeListener(new DataTreeIdentifier<>(
+ LogicalDatastoreType.OPERATIONAL, IidFactory.endpointsIidWildcard().child(EndpointL3.class)),
+ changes -> executor.execute(() -> onEndpointL3Changed(changes))));
}
@Override
public void close() throws Exception {
- if (registerListener != null)
- registerListener.close();
+ for (ListenerRegistration<?> reg: listenerRegistrations) {
+ reg.close();
+ }
}
- @Override
- public void onDataChanged(final AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> change) {
- executor.execute(new Runnable() {
-
- public void run() {
- executeEvent(change);
+ private void onEndpointChanged(Collection<DataTreeModification<Endpoint>> changes) {
+ for (DataTreeModification<Endpoint> change: changes) {
+ DataObjectModification<Endpoint> rootNode = change.getRootNode();
+ switch (rootNode.getModificationType()) {
+ case SUBTREE_MODIFIED:
+ case WRITE:
+ Endpoint updatedEndpoint = rootNode.getDataAfter();
+ LOG.debug("Updated Endpoint {}", updatedEndpoint);
+ if (validate(updatedEndpoint)) {
+ policyManager.registerTenant(updatedEndpoint.getTenant(), updatedEndpoint.getEndpointGroup());
+ processEndpoint(updatedEndpoint);
+ }
+ break;
+ case DELETE:
+ Endpoint deletedEndpoint = rootNode.getDataBefore();
+ LOG.debug("Removed Endpoint {}", deletedEndpoint);
+ removeFaasEndpointLocationIfExist(deletedEndpoint.getTenant(), deletedEndpoint.getL2Context(),
+ deletedEndpoint.getMacAddress());
+ break;
+ default:
+ break;
}
- });
+ }
}
- @VisibleForTesting
- void executeEvent(final AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> change) {
-
- // Create
- for (DataObject dao : change.getCreatedData().values()) {
- if (dao instanceof Endpoint) {
- Endpoint endpoint = (Endpoint) dao;
- LOG.debug("Created Endpoint {}", endpoint);
- if (validate(endpoint)) {
- policyManager.registerTenant(endpoint.getTenant(), endpoint.getEndpointGroup());
- processEndpoint(endpoint);
- }
- } else if (dao instanceof EndpointL3) {
- LOG.debug("Created EndpointL3 {}", dao);
- } else if (dao instanceof EndpointL3Prefix) {
- LOG.warn("Not Handled Event Yet by Faas Renderer. Created EndpointL3Prefix {}", dao);
- }
- }
- // Update
- Map<InstanceIdentifier<?>, DataObject> dao = change.getUpdatedData();
- for (Map.Entry<InstanceIdentifier<?>, DataObject> entry : dao.entrySet()) {
- if (entry.getValue() instanceof Endpoint) {
- Endpoint endpoint = (Endpoint) entry.getValue();
- LOG.debug("Updated Endpoint {}", endpoint);
- if (validate(endpoint)) {
- policyManager.registerTenant(endpoint.getTenant(), endpoint.getEndpointGroup());
- processEndpoint(endpoint);
- }
- } else if (entry.getValue() instanceof EndpointL3) {
- LOG.debug("Updated EndpointL3 {}", entry.getValue());
- } else if (entry.getValue() instanceof EndpointL3Prefix) {
- LOG.warn("Not Handled Event Yet by Faas Renderer. Updated EndpointL3Prefix {}", entry.getValue());
- }
- }
- // Remove
- for (InstanceIdentifier<?> iid : change.getRemovedPaths()) {
- DataObject old = change.getOriginalData().get(iid);
- if (old == null) {
- continue;
- }
- if (old instanceof Endpoint) {
- Endpoint endpoint = (Endpoint) old;
- LOG.debug("Removed Endpoint {}", endpoint);
- removeFaasEndpointLocationIfExist(endpoint.getTenant(), endpoint.getL2Context(),
- endpoint.getMacAddress());
- } else if (old instanceof EndpointL3) {
- EndpointL3 endpoint = (EndpointL3) old;
- LOG.debug("Removed EndpointL3 {}", endpoint);
- removeFaasEndpointLocationIfExist(endpoint.getTenant(), endpoint.getL2Context(),
- endpoint.getMacAddress());
- } else if (old instanceof EndpointL3Prefix) {
- LOG.warn("Not Handled Event Yet by Faas Renderer. Removed EndpointL3Prefix {}", old);
+ private void onEndpointL3Changed(Collection<DataTreeModification<EndpointL3>> changes) {
+ for (DataTreeModification<EndpointL3> change: changes) {
+ DataObjectModification<EndpointL3> rootNode = change.getRootNode();
+ switch (rootNode.getModificationType()) {
+ case SUBTREE_MODIFIED:
+ case WRITE:
+ LOG.debug("Updated EndpointL3 {}", rootNode.getDataAfter());
+ break;
+ case DELETE:
+ EndpointL3 endpoint = rootNode.getDataBefore();
+ LOG.debug("Removed EndpointL3 {}", endpoint);
+ removeFaasEndpointLocationIfExist(endpoint.getTenant(), endpoint.getL2Context(),
+ endpoint.getMacAddress());
+ break;
+ default:
+ break;
}
}
}
import static com.google.common.base.Preconditions.checkNotNull;
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Optional;
import java.util.ArrayList;
+import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.UUID;
import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.ScheduledExecutorService;
-
-import com.google.common.annotations.VisibleForTesting;
-import com.google.common.base.Optional;
+import java.util.concurrent.Executor;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.DataChangeListener;
+import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
+import org.opendaylight.controller.md.sal.binding.api.DataTreeChangeListener;
+import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
+import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
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.AsyncDataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker.DataChangeScope;
-import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.faas.uln.datastore.api.Pair;
import org.opendaylight.faas.uln.datastore.api.UlnDatastoreApi;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.resolved.policies.resolved.policy.PolicyRuleGroupWithEndpointConstraints;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.resolved.policies.resolved.policy.policy.rule.group.with.endpoint.constraints.PolicyRuleGroup;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
-import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-public class FaasPolicyManager implements DataChangeListener, AutoCloseable {
+public class FaasPolicyManager implements DataTreeChangeListener<ResolvedPolicy>, AutoCloseable {
private static final Logger LOG = LoggerFactory.getLogger(FaasPolicyManager.class);
private static final RendererName rendererName = new RendererName("faas");
- private final ListenerRegistration<DataChangeListener> registerListener;
- private final ScheduledExecutorService executor;
+ private final ListenerRegistration<?> registerListener;
+ private final Executor executor;
private final DataBroker dataProvider;
final Map<Pair<EndpointGroupId, TenantId>, List<SubnetId>> epgSubnetsMap = new HashMap<>();
private final ConcurrentHashMap<TenantId, Uuid> mappedTenants = new ConcurrentHashMap<>();
- final ConcurrentHashMap<TenantId, ArrayList<ListenerRegistration<DataChangeListener>>> registeredTenants =
+ final ConcurrentHashMap<TenantId, ArrayList<ListenerRegistration<?>>> registeredTenants =
new ConcurrentHashMap<>();
- public FaasPolicyManager(DataBroker dataBroker, ScheduledExecutorService executor) {
+ public FaasPolicyManager(DataBroker dataBroker, Executor executor) {
this.dataProvider = dataBroker;
this.executor = executor;
- this.registerListener = checkNotNull(dataProvider).registerDataChangeListener(LogicalDatastoreType.OPERATIONAL,
- InstanceIdentifier.builder(ResolvedPolicies.class).child(ResolvedPolicy.class).build(), this,
- AsyncDataBroker.DataChangeScope.SUBTREE);
+ this.registerListener = checkNotNull(dataProvider).registerDataTreeChangeListener(new DataTreeIdentifier<>(
+ LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.builder(ResolvedPolicies.class)
+ .child(ResolvedPolicy.class).build()), this);
RendererBuilder rendBuilder = new RendererBuilder();
rendBuilder.setName(rendererName);
@Override
public void close() throws Exception {
synchronized (registeredTenants) {
- for (ArrayList<ListenerRegistration<DataChangeListener>> list : registeredTenants.values()) {
+ for (ArrayList<ListenerRegistration<?>> list : registeredTenants.values()) {
list.forEach(ListenerRegistration::close);
}
registeredTenants.clear();
LOG.debug("Closed All Tenant Registerations");
}
- if (registerListener != null)
+ if (registerListener != null) {
registerListener.close();
+ }
}
@Override
- public void onDataChanged(final AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> change) {
- executor.execute(new Runnable() {
-
- public void run() {
- executeEvent(change);
- }
- });
+ public void onDataTreeChanged(Collection<DataTreeModification<ResolvedPolicy>> changes) {
+ executor.execute(() -> executeEvent(changes));
}
- private void executeEvent(final AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> change) {
- // Create
- for (DataObject dao : change.getCreatedData().values()) {
- if (dao instanceof ResolvedPolicy) {
- ResolvedPolicy newPolicy = (ResolvedPolicy) dao;
- if (handledPolicy(newPolicy)) {
- LOG.debug("Created Policy: Consumer EPG {}, Provider EPG {}", newPolicy.getConsumerEpgId(),
- newPolicy.getProviderEpgId());
- updateLogicalNetwork(newPolicy);
- }
- }
- }
- // Update
- Map<InstanceIdentifier<?>, DataObject> d = change.getUpdatedData();
- for (Map.Entry<InstanceIdentifier<?>, DataObject> entry : d.entrySet()) {
- if (entry.getValue() instanceof ResolvedPolicy) {
- ResolvedPolicy newPolicy = (ResolvedPolicy) entry.getValue();
- ResolvedPolicy oldPolicy = (ResolvedPolicy) change.getOriginalData().get(entry.getKey());
- if (!isEqualService(newPolicy, oldPolicy)) {
- removeLogicalNetwork(oldPolicy);
- }
- if (handledPolicy(newPolicy)) {
- LOG.debug("Updated Policy: Consumer EPG {}, Provider EPG {}", newPolicy.getConsumerEpgId(),
- newPolicy.getProviderEpgId());
- updateLogicalNetwork(newPolicy);
- }
- }
- }
+ private void executeEvent(final Collection<DataTreeModification<ResolvedPolicy>> changes) {
+ for (DataTreeModification<ResolvedPolicy> change: changes) {
+ DataObjectModification<ResolvedPolicy> rootNode = change.getRootNode();
+ ResolvedPolicy oldPolicy = rootNode.getDataBefore();
+ switch (rootNode.getModificationType()) {
+ case SUBTREE_MODIFIED:
+ case WRITE:
+ ResolvedPolicy newPolicy = rootNode.getDataAfter();
+ if (!isEqualService(newPolicy, oldPolicy)) {
+ removeLogicalNetwork(oldPolicy);
+ }
- // Remove
- for (InstanceIdentifier<?> iid : change.getRemovedPaths()) {
- DataObject old = change.getOriginalData().get(iid);
- if (old != null && old instanceof ResolvedPolicy) {
- ResolvedPolicy oldPolicy = (ResolvedPolicy) old;
- LOG.debug("Removed Policy: Consumer EPG {}, Provider EPG {}", oldPolicy.getConsumerEpgId(),
- oldPolicy.getProviderEpgId());
- removeLogicalNetwork(oldPolicy);
+ if (handledPolicy(newPolicy)) {
+ LOG.debug("Updated Policy: Consumer EPG {}, Provider EPG {}", newPolicy.getConsumerEpgId(),
+ newPolicy.getProviderEpgId());
+ updateLogicalNetwork(newPolicy);
+ }
+ break;
+ case DELETE:
+ LOG.debug("Removed Policy: Consumer EPG {}, Provider EPG {}", oldPolicy.getConsumerEpgId(),
+ oldPolicy.getProviderEpgId());
+ removeLogicalNetwork(oldPolicy);
+ break;
+ default:
+ break;
}
}
}
/*
* tenant registrations
*/
- ArrayList<ListenerRegistration<DataChangeListener>> list = new ArrayList<>();
- ListenerRegistration<DataChangeListener> reg;
+ ArrayList<ListenerRegistration<?>> list = new ArrayList<>();
+ ListenerRegistration<?> reg;
// contracts
- reg = dataProvider.registerDataChangeListener(LogicalDatastoreType.CONFIGURATION,
- IidFactory.contractWildcardIid(gbpTenantId), faasContractManagerListener, DataChangeScope.SUBTREE);
+ reg = dataProvider.registerDataTreeChangeListener(new DataTreeIdentifier<>(
+ LogicalDatastoreType.CONFIGURATION, IidFactory.contractWildcardIid(gbpTenantId)),
+ faasContractManagerListener);
list.add(reg);
// subnets
- reg = dataProvider.registerDataChangeListener(LogicalDatastoreType.CONFIGURATION,
- IidFactory.subnetWildcardIid(gbpTenantId), faasSubnetManagerListener, DataChangeScope.SUBTREE);
+ reg = dataProvider.registerDataTreeChangeListener(new DataTreeIdentifier<>(
+ LogicalDatastoreType.CONFIGURATION, IidFactory.subnetWildcardIid(gbpTenantId)),
+ faasSubnetManagerListener);
list.add(reg);
// tenant
- reg = dataProvider.registerDataChangeListener(LogicalDatastoreType.CONFIGURATION,
- IidFactory.tenantIid(gbpTenantId), new FaasTenantManagerListener(this, gbpTenantId, faasTenantId,
- executor), DataChangeScope.BASE);
+ reg = dataProvider.registerDataTreeChangeListener(new DataTreeIdentifier<>(
+ LogicalDatastoreType.CONFIGURATION, IidFactory.tenantIid(gbpTenantId)),
+ new FaasTenantManagerListener(this, gbpTenantId, faasTenantId, executor));
list.add(reg);
// Map previously resolved policy for this tenant
}
public static boolean isUUid(String value) {
- return (value != null && value.matches("[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}"));
+ return value != null && value.matches("[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}");
}
public void unregisterTenant(TenantId tenantId) {
- ArrayList<ListenerRegistration<DataChangeListener>> list = registeredTenants.remove(tenantId);
+ ArrayList<ListenerRegistration<?>> list = registeredTenants.remove(tenantId);
if (list != null) {
- for (ListenerRegistration<DataChangeListener> reg : list) {
- if (reg != null)
+ for (ListenerRegistration<?> reg : list) {
+ if (reg != null) {
reg.close();
+ }
}
LOG.debug("Unregistered tenant {}", tenantId);
}
LogicalRouterBuilder builder = new LogicalRouterBuilder();
builder.setAdminStateUp(true);
builder.setName(new Text(epg.getId().getValue()));
- if (epg.getDescription() != null)
+ if (epg.getDescription() != null) {
builder.setDescription(new Text("gbp-epg: " + epg.getDescription().getValue()));
- else
+ } else {
builder.setDescription(new Text("gbp-epg"));
+ }
builder.setPublic(isPublic);
builder.setTenantId(tenantId);
builder.setUuid(new Uuid(UUID.randomUUID().toString()));
LogicalSwitchBuilder builder = new LogicalSwitchBuilder();
builder.setAdminStateUp(true);
builder.setName(new Text(epg.getId().getValue()));
- if (epg.getDescription() != null)
+ if (epg.getDescription() != null) {
builder.setDescription(new Text("gbp-epg: " + epg.getDescription().getValue()));
- else
+ } else {
builder.setDescription(new Text("gbp-epg"));
+ }
builder.setTenantId(tenantId);
builder.setUuid(new Uuid(UUID.randomUUID().toString()));
return builder;
*/
package org.opendaylight.groupbasedpolicy.renderer.faas;
+import com.google.common.base.Optional;
import java.util.ArrayList;
+import java.util.Collection;
import java.util.List;
-import java.util.Map;
import java.util.UUID;
import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.ScheduledExecutorService;
-
+import java.util.concurrent.Executor;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.DataChangeListener;
+import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
+import org.opendaylight.controller.md.sal.binding.api.DataTreeChangeListener;
+import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
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.AsyncDataChangeEvent;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.faas.uln.datastore.api.UlnDatastoreApi;
import org.opendaylight.groupbasedpolicy.util.DataStoreHelper;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.forwarding.context.Subnet;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.forwarding.context.subnet.Gateways;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.forwarding.context.subnet.gateways.Prefixes;
-import org.opendaylight.yangtools.yang.binding.DataObject;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import com.google.common.annotations.VisibleForTesting;
-import com.google.common.base.Optional;
-
-public class FaasSubnetManagerListener implements DataChangeListener {
+public class FaasSubnetManagerListener implements DataTreeChangeListener<Subnet> {
private static final Logger LOG = LoggerFactory.getLogger(FaasSubnetManagerListener.class);
- private ConcurrentHashMap<SubnetId, Uuid> mappedSubnets = new ConcurrentHashMap<>();
- private final ScheduledExecutorService executor;
+ private final ConcurrentHashMap<SubnetId, Uuid> mappedSubnets = new ConcurrentHashMap<>();
+ private final Executor executor;
private final DataBroker dataProvider;
private final TenantId gbpTenantId;
private final Uuid faasTenantId;
public FaasSubnetManagerListener(DataBroker dataProvider, TenantId gbpTenantId, Uuid faasTenantId,
- ScheduledExecutorService executor) {
+ Executor executor) {
this.executor = executor;
this.faasTenantId = faasTenantId;
this.gbpTenantId = gbpTenantId;
}
@Override
- public void onDataChanged(final AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> change) {
- executor.execute(new Runnable() {
-
- public void run() {
- executeEvent(change);
- }
- });
+ public void onDataTreeChanged(Collection<DataTreeModification<Subnet>> changes) {
+ executor.execute(() -> executeEvent(changes));
}
- @VisibleForTesting
- void executeEvent(final AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> change) {
- // Create
- for (DataObject dao : change.getCreatedData().values()) {
- if (dao instanceof Subnet) {
- Subnet subnet = (Subnet) dao;
- LOG.debug("Subnet {} is Created.", subnet.getId().getValue());
- UlnDatastoreApi.submitSubnetToDs(initSubnetBuilder(subnet).build());
- }
- }
- // Update
- Map<InstanceIdentifier<?>, DataObject> dao = change.getUpdatedData();
- for (Map.Entry<InstanceIdentifier<?>, DataObject> entry : dao.entrySet()) {
- if (entry.getValue() instanceof Subnet) {
- Subnet subnet = (Subnet) entry.getValue();
- LOG.debug("Subnet {} is Updated.", subnet.getId().getValue());
- UlnDatastoreApi.submitSubnetToDs(initSubnetBuilder(subnet).build());
- }
- }
- // Remove
- for (InstanceIdentifier<?> iid : change.getRemovedPaths()) {
- DataObject old = change.getOriginalData().get(iid);
- if (old == null) {
- continue;
- }
- if (old instanceof Subnet) {
- Subnet subnet = (Subnet) old;
- ReadWriteTransaction rwTx = dataProvider.newReadWriteTransaction();
- Optional<MappedSubnet> op = DataStoreHelper.removeIfExists(LogicalDatastoreType.OPERATIONAL,
- FaasIidFactory.mappedSubnetIid(gbpTenantId, subnet.getId()), rwTx);
- if (op.isPresent()) {
- DataStoreHelper.submitToDs(rwTx);
- }
- Uuid faasSubnetId = mappedSubnets.remove(subnet.getId());
- if (faasSubnetId != null) {
- UlnDatastoreApi.removeSubnetFromDsIfExists(faasTenantId, faasSubnetId);
- }
+ private void executeEvent(final Collection<DataTreeModification<Subnet>> changes) {
+ for (DataTreeModification<Subnet> change: changes) {
+ DataObjectModification<Subnet> rootNode = change.getRootNode();
+ switch (rootNode.getModificationType()) {
+ case SUBTREE_MODIFIED:
+ case WRITE:
+ Subnet updatedSubnet = rootNode.getDataAfter();
+ LOG.debug("Subnet {} is Updated.", updatedSubnet.getId().getValue());
+ UlnDatastoreApi.submitSubnetToDs(initSubnetBuilder(updatedSubnet).build());
+ break;
+ case DELETE:
+ Subnet deletedSubnet = rootNode.getDataBefore();
+ ReadWriteTransaction rwTx = dataProvider.newReadWriteTransaction();
+ Optional<MappedSubnet> op = DataStoreHelper.removeIfExists(LogicalDatastoreType.OPERATIONAL,
+ FaasIidFactory.mappedSubnetIid(gbpTenantId, deletedSubnet.getId()), rwTx);
+ if (op.isPresent()) {
+ DataStoreHelper.submitToDs(rwTx);
+ }
+ Uuid faasSubnetId = mappedSubnets.remove(deletedSubnet.getId());
+ if (faasSubnetId != null) {
+ UlnDatastoreApi.removeSubnetFromDsIfExists(faasTenantId, faasSubnetId);
+ }
+ break;
+ default:
+ break;
}
}
}
builder.setIpPrefix(IetfModelCodec.ipPrefix2013(gbpSubnet.getIpPrefix()));
builder.setUuid(getFaasSubnetId(gbpSubnet.getId()));
builder.setName(new Text(gbpSubnet.getId().getValue()));
- if (gbpSubnet.getDescription() != null)
+ if (gbpSubnet.getDescription() != null) {
builder.setDescription(new Text("gbp-subnet: " + gbpSubnet.getDescription().getValue()));
- else
+ } else {
builder.setDescription(new Text("gbp-subnet"));
+ }
builder.setTenantId(faasTenantId);
builder.setVirtualRouterIp(IetfModelCodec.ipAddress2013(gbpSubnet.getVirtualRouterIp()));
// TODO DNS servers
}
return val;
}
-
}
*/
package org.opendaylight.groupbasedpolicy.renderer.faas;
-import java.util.concurrent.ScheduledExecutorService;
-
-import com.google.common.annotations.VisibleForTesting;
-import org.opendaylight.controller.md.sal.binding.api.DataChangeListener;
-import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent;
+import java.util.Collection;
+import java.util.concurrent.Executor;
+import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
+import org.opendaylight.controller.md.sal.binding.api.DataTreeChangeListener;
+import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
import org.opendaylight.yang.gen.v1.urn.opendaylight.faas.logical.faas.common.rev151013.Uuid;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.TenantId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.Tenant;
-import org.opendaylight.yangtools.yang.binding.DataObject;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-public class FaasTenantManagerListener implements DataChangeListener {
+public class FaasTenantManagerListener implements DataTreeChangeListener<Tenant> {
private static final Logger LOG = LoggerFactory.getLogger(FaasTenantManagerListener.class);
- private final ScheduledExecutorService executor;
+ private final Executor executor;
private final TenantId gbpTenantId;
private final Uuid faasTenantId;
private final FaasPolicyManager policyManager;
public FaasTenantManagerListener(FaasPolicyManager policyManager, TenantId gbpTenantId, Uuid faasTenantId,
- ScheduledExecutorService executor) {
+ Executor executor) {
this.executor = executor;
this.faasTenantId = faasTenantId;
this.gbpTenantId = gbpTenantId;
}
@Override
- public void onDataChanged(final AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> change) {
- executor.execute(new Runnable() {
-
- public void run() {
- executeEvent(change);
- }
- });
+ public void onDataTreeChanged(final Collection<DataTreeModification<Tenant>> changes) {
+ executor.execute(() -> executeEvent(changes));
}
- @VisibleForTesting
- void executeEvent(final AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> change) {
- // Remove
- for (InstanceIdentifier<?> iid : change.getRemovedPaths()) {
- DataObject old = change.getOriginalData().get(iid);
- if (old == null) {
- continue;
- }
- if (old instanceof Tenant) {
- Tenant tenant = (Tenant) old;
- if (tenant.getId().equals(gbpTenantId)) {
- LOG.info("Removed gbp Tenant {} -- faas Tenant {}", gbpTenantId.getValue(),
- faasTenantId.getValue());
- this.policyManager.removeTenantLogicalNetwork(gbpTenantId, faasTenantId);
- }
+ private void executeEvent(final Collection<DataTreeModification<Tenant>> changes) {
+ for (DataTreeModification<Tenant> change: changes) {
+ DataObjectModification<Tenant> rootNode = change.getRootNode();
+ switch (rootNode.getModificationType()) {
+ case DELETE:
+ final Tenant tenant = rootNode.getDataBefore();
+ if (tenant.getId().equals(gbpTenantId)) {
+ LOG.info("Removed gbp Tenant {} -- faas Tenant {}", gbpTenantId.getValue(),
+ faasTenantId.getValue());
+ this.policyManager.removeTenantLogicalNetwork(gbpTenantId, faasTenantId);
+ }
+ break;
+ default:
+ break;
}
}
}
import static org.junit.Assert.assertTrue;
import static org.mockito.Matchers.any;
import static org.mockito.Matchers.eq;
+import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
-import java.util.List;
-import java.util.concurrent.ExecutionException;
-import java.util.concurrent.Executors;
-import java.util.concurrent.ScheduledExecutorService;
-
import com.google.common.base.Optional;
import com.google.common.collect.ImmutableList;
import com.google.common.util.concurrent.CheckedFuture;
+import com.google.common.util.concurrent.MoreExecutors;
+import java.util.Collections;
+import java.util.List;
+import java.util.concurrent.ExecutionException;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mockito;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
+import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
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.ReadFailedException;
import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
import org.opendaylight.faas.uln.datastore.api.UlnDatastoreApi;
-import org.opendaylight.groupbasedpolicy.renderer.faas.test.DataChangeListenerTester;
import org.opendaylight.yang.gen.v1.urn.opendaylight.faas.logical.faas.common.rev151013.Uuid;
import org.opendaylight.yang.gen.v1.urn.opendaylight.faas.logical.faas.security.rules.rev151013.security.rule.groups.attributes.security.rule.groups.container.SecurityRuleGroups;
import org.opendaylight.yang.gen.v1.urn.opendaylight.faas.logical.faas.security.rules.rev151013.security.rule.groups.attributes.security.rule.groups.container.security.rule.groups.SecurityRuleGroup;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.policy.contract.subject.Rule;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.policy.contract.subject.RuleBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.policy.subject.feature.instances.ClassifierInstance;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.policy.subject.feature.instances.ClassifierInstanceBuilder;
-import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.powermock.api.mockito.PowerMockito;
import org.powermock.core.classloader.annotations.PrepareForTest;
private static final ClauseName CLAUSE_NAME = new ClauseName("clause-1");
public static final SubjectName SUBJECT_NAME = new SubjectName("subject-name");
private InstanceIdentifier<Contract> contractIid;
- private ContractId contractId = new ContractId("contractId");
+ private final ContractId contractId = new ContractId("contractId");
private FaasContractManagerListener listener;
- private final ScheduledExecutorService executor = Executors.newScheduledThreadPool(1);
- private TenantId gbpTenantId = new TenantId("b4511aac-ae43-11e5-bf7f-feff819cdc9f");
- private Uuid faasTenantId = new Uuid("b4511aac-ae43-11e5-bf7f-feff819cdc9f");
- private DataChangeListenerTester tester;
+ private final TenantId gbpTenantId = new TenantId("b4511aac-ae43-11e5-bf7f-feff819cdc9f");
+ private final Uuid faasTenantId = new Uuid("b4511aac-ae43-11e5-bf7f-feff819cdc9f");
private DataBroker dataProvider;
@SuppressWarnings("unchecked")
contractIid = mock(InstanceIdentifier.class);
dataProvider = mock(DataBroker.class);
- listener = new FaasContractManagerListener(dataProvider, gbpTenantId, faasTenantId, executor);
- tester = new DataChangeListenerTester(listener);
- tester.setRemovedPath(contractIid);
+ listener = new FaasContractManagerListener(dataProvider, gbpTenantId, faasTenantId,
+ MoreExecutors.directExecutor());
}
@SuppressWarnings("unchecked")
when(futureMappedContract.checkedGet()).thenReturn(optMappedContract);
Contract contract = new ContractBuilder().setId(contractId).build();
- tester.setDataObject(contractIid, contract);
- listener.executeEvent(tester.getChangeMock());
+
+ DataTreeModification<Contract> mockDataTreeModification = mock(DataTreeModification.class);
+ DataObjectModification<Contract> mockModification = mock(DataObjectModification.class);
+ doReturn(mockModification).when(mockDataTreeModification).getRootNode();
+ doReturn(DataObjectModification.ModificationType.WRITE).when(mockModification).getModificationType();
+ doReturn(contract).when(mockModification).getDataAfter();
+
+ listener.onDataTreeChanged(Collections.singletonList(mockDataTreeModification));
}
@Test
/*
* Copyright (c) 2016 Huawei Technologies and others. All rights reserved.
- *
+ *
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
+import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.Map;
-import java.util.Set;
-import java.util.concurrent.Executors;
-import java.util.concurrent.ScheduledExecutorService;
-import java.util.concurrent.TimeUnit;
-
+import com.google.common.util.concurrent.CheckedFuture;
+import com.google.common.util.concurrent.MoreExecutors;
+import java.util.Collections;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.ArgumentCaptor;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
+import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent;
import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
import org.opendaylight.faas.uln.datastore.api.UlnDatastoreApi;
import org.opendaylight.yang.gen.v1.urn.opendaylight.faas.logical.faas.common.rev151013.Uuid;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;
-import com.google.common.util.concurrent.CheckedFuture;
-
@PrepareForTest(UlnDatastoreApi.class)
@RunWith(PowerMockRunner.class)
public class FaasContractManagerListenerTest {
private InstanceIdentifier<DataObject> contractId;
- private AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> change;
private MockFaasContractManagerListener contractManagerListener;
- private final ScheduledExecutorService executor = Executors.newScheduledThreadPool(Runtime.getRuntime()
- .availableProcessors());
- private TenantId gbpTenantId = new TenantId("b4511aac-ae43-11e5-bf7f-feff819cdc9f");
- private Uuid faasTenantId = new Uuid("b4511aac-ae43-11e5-bf7f-feff819cdc9f");
+ private final TenantId gbpTenantId = new TenantId("b4511aac-ae43-11e5-bf7f-feff819cdc9f");
+ private final Uuid faasTenantId = new Uuid("b4511aac-ae43-11e5-bf7f-feff819cdc9f");
@SuppressWarnings("unchecked")
@Before
public void init() {
contractId = mock(InstanceIdentifier.class);
- change = mock(AsyncDataChangeEvent.class);
contractId = mock(InstanceIdentifier.class);
DataBroker dataProvider = mock(DataBroker.class);
PowerMockito.mockStatic(UlnDatastoreApi.class);
when(dataProvider.newWriteOnlyTransaction()).thenReturn(writeTransaction);
CheckedFuture<Void, TransactionCommitFailedException> checkedFuture = mock(CheckedFuture.class);
when(writeTransaction.submit()).thenReturn(checkedFuture);
- contractManagerListener = new MockFaasContractManagerListener(dataProvider, gbpTenantId, faasTenantId, executor);
-
- Set<InstanceIdentifier<?>> removedPaths = new HashSet<>();
- removedPaths.add(contractId);
- when(change.getRemovedPaths()).thenReturn(removedPaths);
+ contractManagerListener = new MockFaasContractManagerListener(dataProvider, gbpTenantId, faasTenantId,
+ MoreExecutors.directExecutor());
}
+ @SuppressWarnings("unchecked")
@Test
public void testOnDataChangeContract() {
// prepare input test data
} catch (Exception e) {
fail("testOnDataChangeContract: Exception = " + e.toString());
}
+
Uuid expectedFaasSecId = new Uuid("c4511aac-ae43-11e5-bf7f-feff819cdc9f");
contractManagerListener.setExpectedFaasSecId(expectedFaasSecId);
- DataObject testContract = makeTestContract();
- contractManagerListener.setExpectedContract((Contract) testContract);
- Map<InstanceIdentifier<?>, DataObject> testData = new HashMap<>();
- testData.put(contractId, testContract);
- when(change.getCreatedData()).thenReturn(testData);
- when(change.getOriginalData()).thenReturn(testData);
- when(change.getUpdatedData()).thenReturn(testData);
+ Contract testContract = makeTestContract();
+ contractManagerListener.setExpectedContract(testContract);
+
+ DataTreeModification<Contract> mockDataTreeModification = mock(DataTreeModification.class);
+ DataObjectModification<Contract> mockModification = mock(DataObjectModification.class);
+ doReturn(mockModification).when(mockDataTreeModification).getRootNode();
+ doReturn(DataObjectModification.ModificationType.WRITE).when(mockModification).getModificationType();
+ doReturn(testContract).when(mockModification).getDataAfter();
+
// invoke event -- expected data is verified in mocked classes
- contractManagerListener.onDataChanged(change);
- // make sure internal threads have completed
- try {
- executor.shutdown();
- executor.awaitTermination(10, TimeUnit.SECONDS);
- } catch (InterruptedException e) {
- fail("testOnDataChangeSubnet: Exception = " + e.toString());
- }
+ contractManagerListener.onDataTreeChanged(Collections.singletonList(mockDataTreeModification));
+
// Verify passed in values to fabric mapping engine
assertTrue("testOnDataChangeContract: Actual Faas Security Id is NOT as expected",
expectedFaasSecId.equals(captor.getValue().getUuid()));
}
- private DataObject makeTestContract() {
+ private Contract makeTestContract() {
ContractBuilder builder = new ContractBuilder();
builder.setId(new ContractId("b4511aac-ae43-11e5-bf7f-feff819cdc9f"));
return builder.build();
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import static org.mockito.Matchers.any;
+import static org.mockito.Matchers.eq;
import static org.mockito.Mockito.doNothing;
+import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
-import java.util.concurrent.Executors;
-import java.util.concurrent.ScheduledExecutorService;
-
import com.google.common.base.Optional;
import com.google.common.collect.ImmutableList;
import com.google.common.util.concurrent.CheckedFuture;
+import com.google.common.util.concurrent.MoreExecutors;
+import java.util.Collection;
+import java.util.Collections;
import org.junit.Before;
import org.junit.Test;
+import org.mockito.ArgumentCaptor;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
+import org.opendaylight.controller.md.sal.binding.api.DataTreeChangeListener;
+import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
+import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
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.controller.md.sal.common.api.data.ReadFailedException;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
-import org.opendaylight.groupbasedpolicy.renderer.faas.test.DataChangeListenerTester;
+import org.opendaylight.groupbasedpolicy.util.IidFactory;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.MacAddress;
import org.opendaylight.yang.gen.v1.urn.opendaylight.faas.faas.endpoint.rev151009.FaasEndpointContext;
import org.opendaylight.yang.gen.v1.urn.opendaylight.faas.faas.endpoint.rev151009.FaasEndpointContextBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.endpoint.fields.L3AddressBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.endpoints.Endpoint;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.endpoints.EndpointBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.endpoints.EndpointL3;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.endpoints.EndpointL3Builder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.endpoints.EndpointL3Prefix;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.endpoints.EndpointL3PrefixBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.faas.rev151009.mapped.tenants.entities.mapped.entity.MappedEndpoint;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.faas.rev151009.mapped.tenants.entities.mapped.entity.MappedEndpointKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.faas.rev151009.mapped.tenants.entities.mapped.entity.MappedSubnet;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.ResolvedPolicies;
+import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
private static final L2BridgeDomainId L_2_BRIDGE_DOMAIN_ID = new L2BridgeDomainId("L2BridgeDomainId");
private static final MacAddress MAC_ADDRESS = new MacAddress("00:00:00:00:35:02");
- private InstanceIdentifier<Endpoint> epIid;
private FaasEndpointManagerListener listener;
- private TenantId gbpTenantId = new TenantId("gbpTenantId");
- private Uuid faasTenantId = new Uuid("b4511aac-ae43-11e5-bf7f-feff819cdc9f");
- private final ScheduledExecutorService executor = Executors.newScheduledThreadPool(1);
- private DataChangeListenerTester tester;
- private DataBroker dataProvider;
- private FaasPolicyManager faasPolicyManager;
+ private final TenantId gbpTenantId = new TenantId("gbpTenantId");
+ private final Uuid faasTenantId = new Uuid("b4511aac-ae43-11e5-bf7f-feff819cdc9f");
+ private final DataBroker dataProvider = mock(DataBroker.class);
+ private final FaasPolicyManager faasPolicyManager = mock(FaasPolicyManager.class);
@SuppressWarnings("unchecked")
@Before
- public void init() throws ReadFailedException {
- MappedEndpointKey mappedEndpointKey = new MappedEndpointKey(L_2_BRIDGE_DOMAIN_ID, MAC_ADDRESS);
-
- dataProvider = mock(DataBroker.class);
-
- WriteTransaction woTx = mock(WriteTransaction.class);
- ReadWriteTransaction rwTx = mock(ReadWriteTransaction.class);
-
- CheckedFuture<Void, TransactionCommitFailedException> futureVoid = mock(CheckedFuture.class);
- when(woTx.submit()).thenReturn(futureVoid);
- when(rwTx.submit()).thenReturn(futureVoid);
- doNothing().when(woTx).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class),
- any(DataObject.class));
-
- CheckedFuture<Optional<MappedEndpoint>, ReadFailedException> futureMappedEndpoint = mock(CheckedFuture.class);
- Optional<MappedEndpoint> optMappedEndpoint = mock(Optional.class);
- when(optMappedEndpoint.isPresent()).thenReturn(false);
- when(futureMappedEndpoint.checkedGet()).thenReturn(optMappedEndpoint);
- when(rwTx.read(LogicalDatastoreType.OPERATIONAL,
- FaasIidFactory.mappedEndpointIid(gbpTenantId, mappedEndpointKey))).thenReturn(futureMappedEndpoint);
+ public void init() {
+ doNothing().when(faasPolicyManager).removeTenantLogicalNetwork(gbpTenantId, faasTenantId);
+ doNothing().when(faasPolicyManager).registerTenant(any(TenantId.class), any(EndpointGroupId.class));
- when(dataProvider.newWriteOnlyTransaction()).thenReturn(woTx);
- when(dataProvider.newReadWriteTransaction()).thenReturn(rwTx);
+ listener = new FaasEndpointManagerListener(faasPolicyManager, dataProvider, MoreExecutors.directExecutor());
- epIid = mock(InstanceIdentifier.class);
- faasPolicyManager = spy(new FaasPolicyManager(dataProvider, executor));
- doNothing().when(faasPolicyManager).removeTenantLogicalNetwork(gbpTenantId, faasTenantId);
- listener = new FaasEndpointManagerListener(faasPolicyManager, dataProvider, executor);
- tester = new DataChangeListenerTester(listener);
- tester.setRemovedPath(epIid);
+ doReturn(mock(ListenerRegistration.class)).when(dataProvider).registerDataTreeChangeListener(
+ any(DataTreeIdentifier.class), any(DataTreeChangeListener.class));
}
+ @SuppressWarnings({ "rawtypes", "unchecked" })
@Test
public void testOnDataChanged_Endpoint() {
- Endpoint ep = new EndpointBuilder().setTenant(gbpTenantId)
+ ArgumentCaptor<DataTreeChangeListener> dtclCaptor = ArgumentCaptor.forClass(DataTreeChangeListener.class);
+ verify(dataProvider).registerDataTreeChangeListener(eq(new DataTreeIdentifier<>(
+ LogicalDatastoreType.OPERATIONAL, IidFactory.endpointsIidWildcard().child(Endpoint.class))),
+ dtclCaptor.capture());
+
+ Endpoint endpoint = new EndpointBuilder().setTenant(gbpTenantId)
.setL2Context(L_2_BRIDGE_DOMAIN_ID)
.setMacAddress(MAC_ADDRESS)
+ .setL3Address(Collections.emptyList())
+ .setEndpointGroup(new EndpointGroupId("test"))
+ .addAugmentation(FaasEndpointContext.class, new FaasEndpointContextBuilder().setFaasPortRefId(
+ new Uuid("12345678-ae43-11e5-bf7f-feff819cdc9f")).build())
.build();
- tester.setDataObject(epIid, ep);
- tester.callOnDataChanged();
- listener.executeEvent(tester.getChangeMock());
+
+ dtclCaptor.getValue().onDataTreeChanged(newMockDataTreeModification(null, endpoint,
+ DataObjectModification.ModificationType.WRITE));
+
+ verify(faasPolicyManager).registerTenant(endpoint.getTenant(), endpoint.getEndpointGroup());
}
@Test
assertNull(listener.getFaasSubnetId(ep));
}
- @Test
- public void testOnDataChanged_EndpointL3() {
- EndpointL3 ep = new EndpointL3Builder().setTenant(gbpTenantId)
- .setL2Context(L_2_BRIDGE_DOMAIN_ID)
- .setMacAddress(MAC_ADDRESS)
- .build();
- tester.setDataObject(epIid, ep);
- tester.callOnDataChanged();
- listener.executeEvent(tester.getChangeMock());
- }
-
- @Test
- public void testOnDataChanged_EndpointL3Prefix() {
- EndpointL3Prefix ep = new EndpointL3PrefixBuilder().setTenant(gbpTenantId).build();
- tester.setDataObject(epIid, ep);
- tester.callOnDataChanged();
- listener.executeEvent(tester.getChangeMock());
+ @SuppressWarnings("unchecked")
+ private static <T extends DataObject> Collection<DataTreeModification<T>> newMockDataTreeModification(T dataBefore,
+ T dataAfter, DataObjectModification.ModificationType type) {
+ DataTreeModification<T> mockDataTreeModification = mock(DataTreeModification.class);
+ DataObjectModification<T> mockModification = mock(DataObjectModification.class);
+ doReturn(type).when(mockModification).getModificationType();
+ doReturn(dataBefore).when(mockModification).getDataBefore();
+ doReturn(dataAfter).when(mockModification).getDataAfter();
+ doReturn(mockModification).when(mockDataTreeModification).getRootNode();
+
+ return Collections.singletonList(mockDataTreeModification);
}
-
}
/*
* Copyright (c) 2016 Huawei Technologies and others. All rights reserved.
- *
+ *
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
package org.opendaylight.groupbasedpolicy.renderer.faas;
+import static org.mockito.Matchers.any;
+import static org.mockito.Matchers.eq;
+import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
+import com.google.common.util.concurrent.CheckedFuture;
+import com.google.common.util.concurrent.MoreExecutors;
import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.HashSet;
+import java.util.Collections;
import java.util.List;
-import java.util.Map;
-import java.util.Set;
-import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
-
import org.junit.Before;
import org.junit.Test;
+import org.mockito.ArgumentCaptor;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
+import org.opendaylight.controller.md.sal.binding.api.DataTreeChangeListener;
+import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
+import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent;
+import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
+import org.opendaylight.groupbasedpolicy.util.IidFactory;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.MacAddress;
import org.opendaylight.yang.gen.v1.urn.opendaylight.faas.faas.endpoint.rev151009.FaasEndpointContext;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.endpoint.fields.L3AddressBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.endpoints.Endpoint;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.endpoints.EndpointBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.policy.EndpointGroupBuilder;
+import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import com.google.common.util.concurrent.CheckedFuture;
-
public class FaasEndpointManagerListenerTest {
private InstanceIdentifier<DataObject> endpointId;
- private AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> change;
private MockFaasEndpointManagerListener endpointManagerListener;
private MockFaasPolicyManager policyManager;
- private final ScheduledExecutorService executor = Executors.newScheduledThreadPool(Runtime.getRuntime()
- .availableProcessors());
+ private final DataBroker dataProvider = mock(DataBroker.class);
@SuppressWarnings("unchecked")
@Before
public void init() {
endpointId = mock(InstanceIdentifier.class);
- change = mock(AsyncDataChangeEvent.class);
endpointId = mock(InstanceIdentifier.class);
- DataBroker dataProvider = mock(DataBroker.class);
WriteTransaction writeTransaction = mock(WriteTransaction.class);
when(dataProvider.newWriteOnlyTransaction()).thenReturn(writeTransaction);
CheckedFuture<Void, TransactionCommitFailedException> checkedFuture = mock(CheckedFuture.class);
when(writeTransaction.submit()).thenReturn(checkedFuture);
- policyManager = new MockFaasPolicyManager(dataProvider, executor);
- endpointManagerListener = new MockFaasEndpointManagerListener(policyManager, dataProvider, executor);
- Set<InstanceIdentifier<?>> removedPaths = new HashSet<>();
- removedPaths.add(endpointId);
- when(change.getRemovedPaths()).thenReturn(removedPaths);
+ policyManager = new MockFaasPolicyManager(dataProvider, mock(ScheduledExecutorService.class));
+ endpointManagerListener = new MockFaasEndpointManagerListener(policyManager, dataProvider,
+ MoreExecutors.directExecutor());
+
+ doReturn(mock(ListenerRegistration.class)).when(dataProvider).registerDataTreeChangeListener(
+ any(DataTreeIdentifier.class), any(DataTreeChangeListener.class));
}
+ @SuppressWarnings({ "unchecked", "rawtypes" })
@Test
public void testOnDataChangeEndpoint() {
// prepare input test data
- DataObject testEndpoint = makeTestEndpoint();
- endpointManagerListener.setExpectedEndpoint((Endpoint) testEndpoint);
- Map<InstanceIdentifier<?>, DataObject> testData = new HashMap<>();
- testData.put(endpointId, testEndpoint);
- when(change.getCreatedData()).thenReturn(testData);
- when(change.getOriginalData()).thenReturn(testData);
- when(change.getUpdatedData()).thenReturn(testData);
+ Endpoint testEndpoint = makeTestEndpoint();
+ policyManager.storeTestEpg(new EndpointGroupBuilder().setId(testEndpoint.getEndpointGroup()).build());
+ endpointManagerListener.setExpectedEndpoint(testEndpoint);
+
+ ArgumentCaptor<DataTreeChangeListener> dtclCaptor = ArgumentCaptor.forClass(DataTreeChangeListener.class);
+ verify(dataProvider).registerDataTreeChangeListener(eq(new DataTreeIdentifier<>(
+ LogicalDatastoreType.OPERATIONAL, IidFactory.endpointsIidWildcard().child(Endpoint.class))),
+ dtclCaptor.capture());
+
+ DataTreeModification<Endpoint> mockDataTreeModification = mock(DataTreeModification.class);
+ DataObjectModification<Endpoint> mockModification = mock(DataObjectModification.class);
+ doReturn(mockModification).when(mockDataTreeModification).getRootNode();
+ doReturn(DataObjectModification.ModificationType.WRITE).when(mockModification).getModificationType();
+ doReturn(testEndpoint).when(mockModification).getDataAfter();
+
// invoke event -- expected data is verified in mocked classes
- endpointManagerListener.onDataChanged(change);
+
+ dtclCaptor.getValue().onDataTreeChanged(Collections.singletonList(mockDataTreeModification));
}
- private DataObject makeTestEndpoint() {
+ private Endpoint makeTestEndpoint() {
EndpointBuilder builder = new EndpointBuilder();
builder.setL2Context(new L2BridgeDomainId("L2Context"));
- List<L3Address> l3Addrs = new ArrayList<L3Address>();
+ List<L3Address> l3Addrs = new ArrayList<>();
L3AddressBuilder addb = new L3AddressBuilder();
addb.setIpAddress(new IpAddress(new String("10.0.0.2").toCharArray()));
addb.setL3Context(new L3ContextId("L3Context"));
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
-import java.util.ArrayList;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Set;
-import java.util.concurrent.Executors;
-import java.util.concurrent.ScheduledExecutorService;
-
import com.google.common.base.Optional;
import com.google.common.util.concurrent.CheckedFuture;
+import com.google.common.util.concurrent.MoreExecutors;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.Executor;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
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.AsyncDataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
public class FaasPolicyManagerCovrgTest {
private InstanceIdentifier<DataObject> policyId;
- private AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> change;
DataBroker dataProvider;
- private final ScheduledExecutorService executor = Executors.newScheduledThreadPool(Runtime.getRuntime()
- .availableProcessors());
- private EndpointGroupId consumerEpgId = new EndpointGroupId("consumerEpgId");
- private SubnetId consumerSubnet = new SubnetId("consumerSubnet");
- private SubnetId providerSubnet = new SubnetId("providerSubnet");
- private EndpointGroupId providerEpgId = new EndpointGroupId("providerEpgId");
- private ContractId contractId = new ContractId("contractId");
- private TenantId tenantId = new TenantId("tenantId");
- private Uuid faasTenantId = new Uuid("0eb98cf5-086c-4a81-8a4e-0c3b4566108b");
- private Uuid faasSecRulesId = new Uuid("1eb98cf5-086c-4a81-8a4e-0c3b4566108b");
- private L3ContextId l3Context = new L3ContextId("l3ContextId");
- private EndpointGroupId epgId = new EndpointGroupId("epgId");
- private SubnetId subnetId = new SubnetId("subnetId");
- private Uuid dummyUuid1 = new Uuid("2eb98cf5-086c-4a81-8a4e-0c3b4566108b");
- private Uuid dummyUuid2 = new Uuid("3eb98cf5-086c-4a81-8a4e-0c3b4566108b");
+ private final Executor executor = MoreExecutors.directExecutor();
+ private final EndpointGroupId consumerEpgId = new EndpointGroupId("consumerEpgId");
+ private final SubnetId consumerSubnet = new SubnetId("consumerSubnet");
+ private final SubnetId providerSubnet = new SubnetId("providerSubnet");
+ private final EndpointGroupId providerEpgId = new EndpointGroupId("providerEpgId");
+ private final ContractId contractId = new ContractId("contractId");
+ private final TenantId tenantId = new TenantId("tenantId");
+ private final Uuid faasTenantId = new Uuid("0eb98cf5-086c-4a81-8a4e-0c3b4566108b");
+ private final Uuid faasSecRulesId = new Uuid("1eb98cf5-086c-4a81-8a4e-0c3b4566108b");
+ private final L3ContextId l3Context = new L3ContextId("l3ContextId");
+ private final EndpointGroupId epgId = new EndpointGroupId("epgId");
+ private final SubnetId subnetId = new SubnetId("subnetId");
+ private final Uuid dummyUuid1 = new Uuid("2eb98cf5-086c-4a81-8a4e-0c3b4566108b");
+ private final Uuid dummyUuid2 = new Uuid("3eb98cf5-086c-4a81-8a4e-0c3b4566108b");
@SuppressWarnings("unchecked")
@Before
public void init() throws Exception {
policyId = mock(InstanceIdentifier.class);
- change = mock(AsyncDataChangeEvent.class);
policyId = mock(InstanceIdentifier.class);
dataProvider = mock(DataBroker.class);
CheckedFuture<Void, TransactionCommitFailedException> futureVoid =
mock(CheckedFuture.class);
when(writeTransaction.submit()).thenReturn(futureVoid);
-
- Set<InstanceIdentifier<?>> removedPaths = new HashSet<>();
- removedPaths.add(policyId);
- when(change.getRemovedPaths()).thenReturn(removedPaths);
}
@Test
public void testConstructor() throws Exception {
FaasPolicyManager other = new MockFaasPolicyManager(dataProvider, executor);
- verify(dataProvider).registerDataChangeListener(LogicalDatastoreType.OPERATIONAL,
- InstanceIdentifier.builder(ResolvedPolicies.class)
- .child(ResolvedPolicy.class)
- .build(), other, AsyncDataBroker.DataChangeScope.SUBTREE);
+ verify(dataProvider).registerDataTreeChangeListener(new DataTreeIdentifier<>(LogicalDatastoreType.OPERATIONAL,
+ InstanceIdentifier.builder(ResolvedPolicies.class).child(ResolvedPolicy.class).build()), other);
other.close();
}
package org.opendaylight.groupbasedpolicy.renderer.faas;
import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
+import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
+import com.google.common.util.concurrent.CheckedFuture;
+import com.google.common.util.concurrent.MoreExecutors;
import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.HashSet;
+import java.util.Collections;
import java.util.List;
-import java.util.Map;
-import java.util.Set;
-import java.util.concurrent.Executors;
-import java.util.concurrent.ScheduledExecutorService;
-import java.util.concurrent.TimeUnit;
-
import org.junit.Before;
import org.junit.Test;
-import org.junit.runner.RunWith;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
+import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent;
import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
-import org.opendaylight.faas.uln.datastore.api.UlnDatastoreApi;
import org.opendaylight.yang.gen.v1.urn.opendaylight.faas.logical.faas.common.rev151013.Uuid;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ContractId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.EndpointGroupId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.resolved.policies.resolved.policy.policy.rule.group.with.endpoint.constraints.PolicyRuleGroupBuilder;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import org.powermock.api.mockito.PowerMockito;
-import org.powermock.core.classloader.annotations.PrepareForTest;
-import org.powermock.modules.junit4.PowerMockRunner;
-
-import com.google.common.util.concurrent.CheckedFuture;
public class FaasPolicyManagerTest {
private InstanceIdentifier<DataObject> policyId;
- private AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> change;
DataBroker dataProvider;
- private final ScheduledExecutorService executor = Executors.newScheduledThreadPool(Runtime.getRuntime()
- .availableProcessors());
EndpointGroupId consumerEpgId = new EndpointGroupId("consumerEpgId");
SubnetId consumerSubnet = new SubnetId("consumerSubnet");
SubnetId providerSubnet = new SubnetId("providerSubnet");
@Before
public void init() {
policyId = mock(InstanceIdentifier.class);
- change = mock(AsyncDataChangeEvent.class);
policyId = mock(InstanceIdentifier.class);
dataProvider = mock(DataBroker.class);
WriteTransaction writeTransaction = mock(WriteTransaction.class);
when(dataProvider.newWriteOnlyTransaction()).thenReturn(writeTransaction);
CheckedFuture<Void, TransactionCommitFailedException> checkedFuture = mock(CheckedFuture.class);
when(writeTransaction.submit()).thenReturn(checkedFuture);
-
- Set<InstanceIdentifier<?>> removedPaths = new HashSet<>();
- removedPaths.add(policyId);
- when(change.getRemovedPaths()).thenReturn(removedPaths);
}
@SuppressWarnings("resource")
@Test
public void testLayer2ResolvedPolicyWithImpExternalEpg() {
// prepare input test data
- MockFaasPolicyManager policyManager = new MockFaasPolicyManager(dataProvider, executor);
+ MockFaasPolicyManager policyManager = new MockFaasPolicyManager(dataProvider, MoreExecutors.directExecutor());
// mock input test policy
policyManager.storeTestEpg(makeTestEndpointGroup(consumerEpgId));
// input test resolved policy
DataObject testPolicy = makeTestResolvedPolicyWithImpExternalEpg();
- Map<InstanceIdentifier<?>, DataObject> testData = new HashMap<>();
- testData.put(policyId, testPolicy);
- when(change.getCreatedData()).thenReturn(testData);
- when(change.getOriginalData()).thenReturn(testData);
- when(change.getUpdatedData()).thenReturn(testData);
- // invoke event -- expected data is verified in mocked classes
- policyManager.onDataChanged(change);
- // make sure internal threads have completed
- try {
- executor.shutdown();
- executor.awaitTermination(10, TimeUnit.SECONDS);
- } catch (InterruptedException e) {
- fail("FaasPolicyManagerTest: Exception = " + e.toString());
- }
+ DataTreeModification<ResolvedPolicy> mockDataTreeModification = mock(DataTreeModification.class);
+ DataObjectModification<ResolvedPolicy> mockModification = mock(DataObjectModification.class);
+ doReturn(mockModification).when(mockDataTreeModification).getRootNode();
+ doReturn(DataObjectModification.ModificationType.WRITE).when(mockModification).getModificationType();
+ doReturn(testPolicy).when(mockModification).getDataAfter();
+
+ // invoke event -- expected data is verified in mocked classes
+ policyManager.onDataTreeChanged(Collections.singletonList(mockDataTreeModification));
// verify
assertTrue("FaasPolicyManagerTest", policyManager.getComLayer().equals(ServiceCommunicationLayer.Layer2));
@Test
public void testLayer3ResolvedPolicy() {
// prepare input test data
- MockFaasPolicyManager policyManager = new MockFaasPolicyManager(dataProvider, executor);
+ MockFaasPolicyManager policyManager = new MockFaasPolicyManager(dataProvider, MoreExecutors.directExecutor());
// mock input test policy
policyManager.storeTestL3Contextes(makeTestL3Context());
// input test resolved policy
DataObject testPolicy = makeTestResolvedPolicy();
- Map<InstanceIdentifier<?>, DataObject> testData = new HashMap<>();
- testData.put(policyId, testPolicy);
- when(change.getCreatedData()).thenReturn(testData);
- when(change.getOriginalData()).thenReturn(testData);
- when(change.getUpdatedData()).thenReturn(testData);
- // invoke event -- expected data is verified in mocked classes
- policyManager.onDataChanged(change);
- // make sure internal threads have completed
- try {
- executor.shutdown();
- executor.awaitTermination(10, TimeUnit.SECONDS);
- } catch (InterruptedException e) {
- fail("FaasPolicyManagerTest: Exception = " + e.toString());
- }
+ DataTreeModification<ResolvedPolicy> mockDataTreeModification = mock(DataTreeModification.class);
+ DataObjectModification<ResolvedPolicy> mockModification = mock(DataObjectModification.class);
+ doReturn(mockModification).when(mockDataTreeModification).getRootNode();
+ doReturn(DataObjectModification.ModificationType.WRITE).when(mockModification).getModificationType();
+ doReturn(testPolicy).when(mockModification).getDataAfter();
+
+ // invoke event -- expected data is verified in mocked classes
+ policyManager.onDataTreeChanged(Collections.singletonList(mockDataTreeModification));
// verify
assertTrue("FaasPolicyManagerTest", policyManager.getComLayer().equals(ServiceCommunicationLayer.Layer3));
import static org.mockito.Matchers.any;
import static org.mockito.Mockito.doNothing;
+import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import com.google.common.util.concurrent.CheckedFuture;
import org.junit.Test;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.controller.md.sal.binding.api.DataTreeChangeListener;
+import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
import org.opendaylight.groupbasedpolicy.api.EpRendererAugmentationRegistry;
+import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
@Test
public void testConstructor() throws Exception {
DataBroker dataProvider = mock(DataBroker.class);
+ doReturn(mock(ListenerRegistration.class)).when(dataProvider).registerDataTreeChangeListener(
+ any(DataTreeIdentifier.class), any(DataTreeChangeListener.class));
+
EpRendererAugmentationRegistry epRendererAugmentationRegistry = mock(EpRendererAugmentationRegistry.class);
WriteTransaction wTx = mock(WriteTransaction.class);
import static org.mockito.Matchers.any;
import static org.mockito.Matchers.eq;
import static org.mockito.Mockito.doNothing;
+import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.concurrent.Executors;
-import java.util.concurrent.ScheduledExecutorService;
-
import com.google.common.base.Optional;
import com.google.common.util.concurrent.CheckedFuture;
+import com.google.common.util.concurrent.MoreExecutors;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
+import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
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.controller.md.sal.common.api.data.ReadFailedException;
import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
import org.opendaylight.faas.uln.datastore.api.UlnDatastoreApi;
-import org.opendaylight.groupbasedpolicy.renderer.faas.test.DataChangeListenerTester;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpPrefix;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Address;
private InstanceIdentifier<Subnet> subnetIid;
private FaasSubnetManagerListener listener;
- private TenantId gbpTenantId = new TenantId("gbpTenantId");
- private SubnetId subnetId = new SubnetId("subnetId");
- private Uuid faasTenantId = new Uuid("b4511aac-ae43-11e5-bf7f-feff819cdc9f");
- private Uuid faasSubnetId = new Uuid("c4511aac-ae43-11e5-bf7f-feff819cdc9f");
- private final ScheduledExecutorService executor = Executors.newScheduledThreadPool(1);
- private DataChangeListenerTester tester;
+ private final TenantId gbpTenantId = new TenantId("gbpTenantId");
+ private final SubnetId subnetId = new SubnetId("subnetId");
+ private final Uuid faasTenantId = new Uuid("b4511aac-ae43-11e5-bf7f-feff819cdc9f");
+ private final Uuid faasSubnetId = new Uuid("c4511aac-ae43-11e5-bf7f-feff819cdc9f");
private DataBroker dataProvider;
@SuppressWarnings("unchecked")
public void init() {
dataProvider = mock(DataBroker.class);
subnetIid = mock(InstanceIdentifier.class);
- listener = new FaasSubnetManagerListener(dataProvider, gbpTenantId, faasTenantId, executor);
- tester = new DataChangeListenerTester(listener);
- tester.setRemovedPath(subnetIid);
+ listener = new FaasSubnetManagerListener(dataProvider, gbpTenantId, faasTenantId,
+ MoreExecutors.directExecutor());
}
@SuppressWarnings("unchecked")
when(dataProvider.newWriteOnlyTransaction()).thenReturn(woTx);
Subnet subnet = new SubnetBuilder().setId(subnetId).build();
- tester.setDataObject(subnetIid, subnet);
- tester.callOnDataChanged();
- listener.executeEvent(tester.getChangeMock());
+
+ DataTreeModification<Subnet> mockDataTreeModification = mock(DataTreeModification.class);
+ DataObjectModification<Subnet> mockModification = mock(DataObjectModification.class);
+ doReturn(mockModification).when(mockDataTreeModification).getRootNode();
+ doReturn(DataObjectModification.ModificationType.WRITE).when(mockModification).getModificationType();
+ doReturn(subnet).when(mockModification).getDataAfter();
+
+ listener.onDataTreeChanged(Collections.singletonList(mockDataTreeModification));
}
@Test
/*
* Copyright (c) 2016 Huawei Technologies and others. All rights reserved.
- *
+ *
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
+import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.Map;
-import java.util.Set;
-import java.util.concurrent.Executors;
-import java.util.concurrent.ScheduledExecutorService;
-import java.util.concurrent.TimeUnit;
-
+import com.google.common.util.concurrent.CheckedFuture;
+import com.google.common.util.concurrent.MoreExecutors;
+import java.util.Collections;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.ArgumentCaptor;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
+import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent;
import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
import org.opendaylight.faas.uln.datastore.api.UlnDatastoreApi;
import org.opendaylight.yang.gen.v1.urn.opendaylight.faas.logical.faas.common.rev151013.Uuid;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.faas.logical.faas.subnets.rev151013.subnets.container.subnets.Subnet;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.SubnetId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.TenantId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.forwarding.context.Subnet;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.forwarding.context.SubnetBuilder;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;
-import com.google.common.util.concurrent.CheckedFuture;
-
@PrepareForTest(UlnDatastoreApi.class)
@RunWith(PowerMockRunner.class)
public class FaasSubnetManagerListenerTest {
private InstanceIdentifier<DataObject> subnetId;
- private AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> change;
private MockFaasSubnetManagerListener subnetManagerListener;
- private final ScheduledExecutorService executor = Executors.newScheduledThreadPool(Runtime.getRuntime()
- .availableProcessors());
- private TenantId gbpTenantId = new TenantId("b4511aac-ae43-11e5-bf7f-feff819cdc9f");
- private Uuid faasTenantId = new Uuid("b4511aac-ae43-11e5-bf7f-feff819cdc9f");
+ private final TenantId gbpTenantId = new TenantId("b4511aac-ae43-11e5-bf7f-feff819cdc9f");
+ private final Uuid faasTenantId = new Uuid("b4511aac-ae43-11e5-bf7f-feff819cdc9f");
@SuppressWarnings("unchecked")
@Before
public void init() {
subnetId = mock(InstanceIdentifier.class);
- change = mock(AsyncDataChangeEvent.class);
subnetId = mock(InstanceIdentifier.class);
DataBroker dataProvider = mock(DataBroker.class);
PowerMockito.mockStatic(UlnDatastoreApi.class);
when(dataProvider.newWriteOnlyTransaction()).thenReturn(writeTransaction);
CheckedFuture<Void, TransactionCommitFailedException> checkedFuture = mock(CheckedFuture.class);
when(writeTransaction.submit()).thenReturn(checkedFuture);
- subnetManagerListener = new MockFaasSubnetManagerListener(dataProvider, gbpTenantId, faasTenantId, executor);
-
- Set<InstanceIdentifier<?>> removedPaths = new HashSet<>();
- removedPaths.add(subnetId);
- when(change.getRemovedPaths()).thenReturn(removedPaths);
+ subnetManagerListener = new MockFaasSubnetManagerListener(dataProvider, gbpTenantId, faasTenantId,
+ MoreExecutors.directExecutor());
}
+ @SuppressWarnings("unchecked")
@Test
public void testOnDataChangeSubnet() {
// prepare input test data
- ArgumentCaptor<Subnet> captor = ArgumentCaptor.forClass(Subnet.class);
+ ArgumentCaptor<org.opendaylight.yang.gen.v1.urn.opendaylight.faas.logical.faas.subnets.rev151013.subnets.container.subnets.Subnet> captor = ArgumentCaptor.forClass(
+ org.opendaylight.yang.gen.v1.urn.opendaylight.faas.logical.faas.subnets.rev151013.subnets.container.subnets.Subnet.class);
try {
PowerMockito.doNothing().when(UlnDatastoreApi.class, "submitSubnetToDs", captor.capture());
} catch (Exception e) {
}
Uuid expectedFaasSubnetId = new Uuid("c4511aac-ae43-11e5-bf7f-feff819cdc9f");
subnetManagerListener.setExpectedFaasSubnetId(expectedFaasSubnetId);
- DataObject testSubnet = makeTestSubnet();
+ Subnet testSubnet = makeTestSubnet();
subnetManagerListener.setExpectedGbpSubnet(testSubnet);
- Map<InstanceIdentifier<?>, DataObject> testData = new HashMap<>();
- testData.put(subnetId, testSubnet);
- when(change.getCreatedData()).thenReturn(testData);
- when(change.getOriginalData()).thenReturn(testData);
- when(change.getUpdatedData()).thenReturn(testData);
+
+ DataTreeModification<Subnet> mockDataTreeModification = mock(DataTreeModification.class);
+ DataObjectModification<Subnet> mockModification = mock(DataObjectModification.class);
+ doReturn(mockModification).when(mockDataTreeModification).getRootNode();
+ doReturn(DataObjectModification.ModificationType.WRITE).when(mockModification).getModificationType();
+ doReturn(testSubnet).when(mockModification).getDataAfter();
+
// invoke event -- expected data is verified in mocked classes
- subnetManagerListener.onDataChanged(change);
+ subnetManagerListener.onDataTreeChanged(Collections.singletonList(mockDataTreeModification));
- // make sure internal threads have completed
- try {
- executor.shutdown();
- executor.awaitTermination(10, TimeUnit.SECONDS);
- } catch (InterruptedException e) {
- fail("testOnDataChangeSubnet: Exception = " + e.toString());
- }
// Verify passed in values to fabric mapping engine
assertTrue("testOnDataChangeSubnet: Actual Faas SubnetId is NOT as expected",
expectedFaasSubnetId.equals(captor.getValue().getUuid()));
}
- private DataObject makeTestSubnet() {
+ private Subnet makeTestSubnet() {
SubnetBuilder builder = new SubnetBuilder();
builder.setId(new SubnetId("b4511aac-ae43-11e5-bf7f-feff819cdc9f"));
return builder.build();
*/
package org.opendaylight.groupbasedpolicy.renderer.faas;
-import static org.mockito.Matchers.any;
import static org.mockito.Mockito.doNothing;
+import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.spy;
-import static org.mockito.Mockito.when;
+import static org.mockito.Mockito.verify;
-import java.util.concurrent.Executors;
-import java.util.concurrent.ScheduledExecutorService;
-
-import com.google.common.util.concurrent.CheckedFuture;
+import com.google.common.util.concurrent.MoreExecutors;
+import java.util.Collections;
import org.junit.Before;
import org.junit.Test;
-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.controller.md.sal.common.api.data.TransactionCommitFailedException;
-import org.opendaylight.groupbasedpolicy.renderer.faas.test.DataChangeListenerTester;
+import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
+import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
import org.opendaylight.yang.gen.v1.urn.opendaylight.faas.logical.faas.common.rev151013.Uuid;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.TenantId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.Tenant;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.TenantBuilder;
-import org.opendaylight.yangtools.yang.binding.DataObject;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
public class FaasTenantManagerListenerCovrgTest {
- private InstanceIdentifier<Tenant> tenantIid;
- private FaasPolicyManager faasPolicyManager;
+ private final FaasPolicyManager faasPolicyManager = mock(FaasPolicyManager.class);
private FaasTenantManagerListener listener;
- private TenantId gbpTenantId = new TenantId("gbpTenantId");
- private Uuid faasTenantId = new Uuid("b4511aac-ae43-11e5-bf7f-feff819cdc9f");
- private final ScheduledExecutorService executor = Executors.newScheduledThreadPool(1);
- private DataChangeListenerTester tester;
- private DataBroker dataProvider;
+ private final TenantId gbpTenantId = new TenantId("gbpTenantId");
+ private final Uuid faasTenantId = new Uuid("b4511aac-ae43-11e5-bf7f-feff819cdc9f");
- @SuppressWarnings("unchecked")
@Before
public void init() {
- dataProvider = mock(DataBroker.class);
- WriteTransaction wTx = mock(WriteTransaction.class);
- CheckedFuture<Void, TransactionCommitFailedException> futureVoid = mock(CheckedFuture.class);
- when(wTx.submit()).thenReturn(futureVoid);
- doNothing().when(wTx).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class),
- any(DataObject.class));
- when(dataProvider.newWriteOnlyTransaction()).thenReturn(wTx);
-
- tenantIid = mock(InstanceIdentifier.class);
- faasPolicyManager = spy(new FaasPolicyManager(dataProvider, executor));
doNothing().when(faasPolicyManager).removeTenantLogicalNetwork(gbpTenantId, faasTenantId);
- listener = new FaasTenantManagerListener(faasPolicyManager, gbpTenantId, faasTenantId, executor);
- tester = new DataChangeListenerTester(listener);
- tester.setRemovedPath(tenantIid);
+ listener = new FaasTenantManagerListener(faasPolicyManager, gbpTenantId, faasTenantId,
+ MoreExecutors.directExecutor());
}
+ @SuppressWarnings("unchecked")
@Test
- public void testOnDataChanged() {
+ public void testOnDataTreeChanged() {
Tenant tenant = new TenantBuilder().setId(gbpTenantId).build();
- tester.setDataObject(tenantIid, tenant);
- tester.callOnDataChanged();
- listener.executeEvent(tester.getChangeMock());
+
+ DataTreeModification<Tenant> mockDataTreeModification = mock(DataTreeModification.class);
+ DataObjectModification<Tenant> mockModification = mock(DataObjectModification.class);
+ doReturn(mockModification).when(mockDataTreeModification).getRootNode();
+ doReturn(DataObjectModification.ModificationType.DELETE).when(mockModification).getModificationType();
+ doReturn(tenant).when(mockModification).getDataBefore();
+
+ listener.onDataTreeChanged(Collections.singletonList(mockDataTreeModification));
+
+ verify(faasPolicyManager).removeTenantLogicalNetwork(gbpTenantId, faasTenantId);
}
}
/*
* Copyright (c) 2016 Huawei Technologies and others. All rights reserved.
- *
+ *
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
import static org.junit.Assert.assertTrue;
-import java.util.concurrent.ScheduledExecutorService;
-
+import java.util.concurrent.Executor;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.yang.gen.v1.urn.opendaylight.faas.logical.faas.common.rev151013.Uuid;
import org.opendaylight.yang.gen.v1.urn.opendaylight.faas.logical.faas.security.rules.rev151013.security.rule.groups.attributes.security.rule.groups.container.SecurityRuleGroupsBuilder;
private Uuid expectedFaasSecId;
public MockFaasContractManagerListener(DataBroker dataProvider, TenantId gbpTenantId, Uuid faasTenantId,
- ScheduledExecutorService executor) {
+ Executor executor) {
super(dataProvider, gbpTenantId, faasTenantId, executor);
}
// *******************************************************
@Override
protected SecurityRuleGroupsBuilder initSecurityGroupBuilder(Contract contract) {
- if (expectedContract != null)
+ if (expectedContract != null) {
assertTrue("FaasContractManagerListener.initSecurityGroupBuilder", expectedContract.equals(contract));
+ }
SecurityRuleGroupsBuilder sec = new SecurityRuleGroupsBuilder();
sec.setUuid(expectedFaasSecId);
return sec;
/*
* Copyright (c) 2016 Huawei Technologies and others. All rights reserved.
- *
+ *
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
import static org.junit.Assert.assertTrue;
-import java.util.concurrent.ScheduledExecutorService;
-
+import java.util.concurrent.Executor;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.endpoints.Endpoint;
private Endpoint expectedEndpoint;
public MockFaasEndpointManagerListener(FaasPolicyManager policyManager, DataBroker dataProvider,
- ScheduledExecutorService executor) {
+ Executor executor) {
super(policyManager, dataProvider, executor);
}
// *******************************************************
@Override
protected void processEndpoint(Endpoint endpoint) {
- if (expectedEndpoint != null)
+ if (expectedEndpoint != null) {
assertTrue("FaasEndpointManagerListener.processEndpoint", expectedEndpoint.equals(endpoint));
+ }
}
// *******************************************************
/*
* Copyright (c) 2016 Huawei Technologies and others. All rights reserved.
- *
+ *
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
import java.util.HashMap;
import java.util.List;
import java.util.Map;
-import java.util.concurrent.ScheduledExecutorService;
-
+import java.util.concurrent.Executor;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.DataChangeListener;
import org.opendaylight.faas.uln.datastore.api.Pair;
import org.opendaylight.yang.gen.v1.urn.opendaylight.faas.logical.faas.common.rev151013.Uuid;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ContractId;
public class MockFaasPolicyManager extends FaasPolicyManager {
- private Map<EndpointGroupId, EndpointGroup> testEndpointGroups = new HashMap<>();
- private Map<SubnetId, Subnet> testSubnets = new HashMap<>();
- private Map<L2FloodDomainId, L2FloodDomain> testL2FloodDomains = new HashMap<>();
- private Map<L2BridgeDomainId, L2BridgeDomain> testL2BridgeDomains = new HashMap<>();
- private Map<L3ContextId, L3Context> testL3Contextes = new HashMap<>();
- private Map<ContractId, Uuid> testSecIdPerContract = new HashMap<>();
- private Map<TenantId, Uuid> testFaasTenantId = new HashMap<>();
+ private final Map<EndpointGroupId, EndpointGroup> testEndpointGroups = new HashMap<>();
+ private final Map<SubnetId, Subnet> testSubnets = new HashMap<>();
+ private final Map<L2FloodDomainId, L2FloodDomain> testL2FloodDomains = new HashMap<>();
+ private final Map<L2BridgeDomainId, L2BridgeDomain> testL2BridgeDomains = new HashMap<>();
+ private final Map<L3ContextId, L3Context> testL3Contextes = new HashMap<>();
+ private final Map<ContractId, Uuid> testSecIdPerContract = new HashMap<>();
+ private final Map<TenantId, Uuid> testFaasTenantId = new HashMap<>();
private ServiceCommunicationLayer comLayer;
private ExternalImplicitGroup externalImplicitGroup;
- public MockFaasPolicyManager(DataBroker dataBroker, ScheduledExecutorService executor) {
+ public MockFaasPolicyManager(DataBroker dataBroker, Executor executor) {
super(dataBroker, executor);
}
assertTrue("FaasPolicyManager.registerTenant: testEndpointGroups.containsKey(epgId)",
testEndpointGroups.containsKey(epgId));
- registeredTenants.putIfAbsent(tenantId, new ArrayList<ListenerRegistration<DataChangeListener>>());
+ registeredTenants.putIfAbsent(tenantId, new ArrayList<ListenerRegistration<?>>());
}
@Override
/*
* Copyright (c) 2016 Huawei Technologies and others. All rights reserved.
- *
+ *
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
import static org.junit.Assert.assertTrue;
-import java.util.concurrent.ScheduledExecutorService;
-
+import java.util.concurrent.Executor;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.yang.gen.v1.urn.opendaylight.faas.logical.faas.common.rev151013.Uuid;
import org.opendaylight.yang.gen.v1.urn.opendaylight.faas.logical.faas.subnets.rev151013.subnets.container.subnets.SubnetBuilder;
private Uuid expectedFaasSubnetId;
public MockFaasSubnetManagerListener(DataBroker dataProvider, TenantId gbpTenantId, Uuid faasTenantId,
- ScheduledExecutorService executor) {
+ Executor executor) {
super(dataProvider, gbpTenantId, faasTenantId, executor);
}
// *******************************************************
@Override
protected SubnetBuilder initSubnetBuilder(Subnet subnet) {
- if (expectedGbpSubnet != null)
+ if (expectedGbpSubnet != null) {
assertTrue("FaasSubnetManagerListener.initSubnetBuilder", expectedGbpSubnet.equals(subnet));
+ }
SubnetBuilder builder = new SubnetBuilder();
builder.setUuid(expectedFaasSubnetId);
return builder;
+++ /dev/null
-/*
- * Copyright (c) 2016 Cisco Systems, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.groupbasedpolicy.renderer.faas.test;
-
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.when;
-
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.Map;
-import java.util.Set;
-
-import org.opendaylight.controller.md.sal.binding.api.DataChangeListener;
-import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent;
-import org.opendaylight.yangtools.yang.binding.DataObject;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-
-public class DataChangeListenerTester {
-
- private AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> changeMock;
- private DataChangeListener listener;
-
- private Map<InstanceIdentifier<?>, DataObject> testData;
- private Set<InstanceIdentifier<?>> removedPaths;
-
- @SuppressWarnings("unchecked")
- public DataChangeListenerTester(DataChangeListener listener) {
- changeMock = mock(AsyncDataChangeEvent.class);
- testData = new HashMap<>();
- removedPaths = new HashSet<>();
-
- this.listener = listener;
-
- when(changeMock.getCreatedData()).thenReturn(testData);
- when(changeMock.getOriginalData()).thenReturn(testData);
- when(changeMock.getUpdatedData()).thenReturn(testData);
- when(changeMock.getRemovedPaths()).thenReturn(removedPaths);
- }
-
- public AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> getChangeMock() {
- return changeMock;
- }
-
- public DataChangeListenerTester setDataObject(InstanceIdentifier<? extends DataObject> iid, DataObject dataObject){
- testData.clear();
- return addDataObject(iid, dataObject);
- }
-
- public DataChangeListenerTester addDataObject(InstanceIdentifier<? extends DataObject> iid, DataObject dataObject){
- testData.put(iid, dataObject);
- return this;
- }
-
- public DataChangeListenerTester setRemovedPath(InstanceIdentifier<? extends DataObject> iid){
- removedPaths.clear();
- return addRemovedPath(iid);
- }
-
- public DataChangeListenerTester addRemovedPath(InstanceIdentifier<? extends DataObject> iid){
- removedPaths.add(iid);
- return this;
- }
-
- public void callOnDataChanged(){
- listener.onDataChanged(changeMock);
- }
-
-}
package org.opendaylight.groupbasedpolicy.renderer.iovisor.endpoint;
import java.util.Collection;
-
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.DataChangeListener;
import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
import org.opendaylight.groupbasedpolicy.renderer.iovisor.utils.IovisorModuleUtils;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.endpoints.Endpoint;
-import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.powermock.api.mockito.PowerMockito;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;
EndpointListener endpointListner;
@Mock
DataBroker dataBroker;
- @Mock
- ListenerRegistration<DataChangeListener> registerListener;
@Mock
Collection<DataTreeModification<Endpoint>> changes;
package org.opendaylight.groupbasedpolicy.renderer.ofoverlay;
+import com.google.common.base.Optional;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
import java.util.ArrayList;
+import java.util.Collection;
import java.util.List;
import java.util.Map.Entry;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
-
import javax.annotation.Nonnull;
-
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.DataChangeListener;
+import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
+import org.opendaylight.controller.md.sal.binding.api.DataTreeChangeListener;
+import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
+import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
import org.opendaylight.controller.md.sal.binding.api.NotificationService;
import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker.DataChangeScope;
-import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.groupbasedpolicy.api.EpRendererAugmentationRegistry;
import org.opendaylight.groupbasedpolicy.api.PolicyValidatorRegistry;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.RendererName;
import org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service.rev130709.PacketProcessingService;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
-import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import com.google.common.base.Optional;
-import com.google.common.util.concurrent.Futures;
-import com.google.common.util.concurrent.ListenableFuture;
-
/**
* Renderer that uses OpenFlow and OVSDB to implement an overlay network
* using Open vSwitch.
*/
-public class OFOverlayRenderer implements AutoCloseable, DataChangeListener {
+public class OFOverlayRenderer implements AutoCloseable, DataTreeChangeListener<OfOverlayConfig> {
private static final Logger LOG =
LoggerFactory.getLogger(OFOverlayRenderer.class);
private final PolicyManager policyManager;
private final ClassifierDefinitionListener classifierDefinitionListener;
private final SflowClientSettingsListener sflowClientSettingsListener;
- private ActionDefinitionListener actionDefinitionListener;
+ private final ActionDefinitionListener actionDefinitionListener;
private final OfOverlayAug ofOverlayAug;
private final OfOverlayL3NatAug ofOverlayL3NatAug;
private static final InstanceIdentifier<OfOverlayConfig> configIid =
InstanceIdentifier.builder(OfOverlayConfig.class).build();
- ListenerRegistration<DataChangeListener> configReg;
+ ListenerRegistration<?> configReg;
public OFOverlayRenderer(final DataBroker dataProvider,
PacketProcessingService packetProcessingService,
@Override
public void close() throws Exception {
executor.shutdownNow();
- if (configReg != null) configReg.close();
- if (switchManager != null) switchManager.close();
- if (endpointManager != null) endpointManager.close();
- if (classifierDefinitionListener != null) classifierDefinitionListener.close();
- if (actionDefinitionListener != null) actionDefinitionListener.close();
- if (ofOverlayAug != null) ofOverlayAug.close();
- if (ofOverlayL3NatAug != null) ofOverlayL3NatAug.close();
- if (policyManager != null) policyManager.close();
- if (sflowClientSettingsListener != null) sflowClientSettingsListener.close();
+ if (configReg != null) {
+ configReg.close();
+ }
+ if (switchManager != null) {
+ switchManager.close();
+ }
+ if (endpointManager != null) {
+ endpointManager.close();
+ }
+ if (classifierDefinitionListener != null) {
+ classifierDefinitionListener.close();
+ }
+ if (actionDefinitionListener != null) {
+ actionDefinitionListener.close();
+ }
+ if (ofOverlayAug != null) {
+ ofOverlayAug.close();
+ }
+ if (ofOverlayL3NatAug != null) {
+ ofOverlayL3NatAug.close();
+ }
+ if (policyManager != null) {
+ policyManager.close();
+ }
+ if (sflowClientSettingsListener != null) {
+ sflowClientSettingsListener.close();
+ }
}
// ******************
- // DataChangeListener
+ // DataTreeChangeListener
// ******************
@Override
- public void onDataChanged(AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> change) {
- OfOverlayConfig config;
+ public void onDataTreeChanged(Collection<DataTreeModification<OfOverlayConfig>> changes) {
try {
- for (Entry<InstanceIdentifier<?>, DataObject> entry : change.getCreatedData().entrySet()) {
- if (entry.getValue() instanceof OfOverlayConfig) {
- config = (OfOverlayConfig) entry.getValue();
- applyConfig(config).get();
- LOG.info("OF-Overlay config created: {}", config);
- }
- }
- for (Entry<InstanceIdentifier<?>, DataObject> entry : change.getUpdatedData().entrySet()) {
- if (entry.getValue() instanceof OfOverlayConfig) {
- config = (OfOverlayConfig) entry.getValue();
- applyConfig(config).get();
- LOG.info("OF-Overlay config updated: {}", config);
+ for (DataTreeModification<OfOverlayConfig> change: changes) {
+ DataObjectModification<OfOverlayConfig> rootNode = change.getRootNode();
+ switch (rootNode.getModificationType()) {
+ case SUBTREE_MODIFIED:
+ case WRITE:
+ final OfOverlayConfig config = rootNode.getDataAfter();
+ LOG.info("OF-Overlay config updated: {}", config);
+ applyConfig(config).get();
+ break;
+ default:
+ break;
}
}
} catch (InterruptedException | ExecutionException e) {
// **************
private void registerConfigListener(DataBroker dataProvider) {
- configReg =
- dataProvider.registerDataChangeListener(LogicalDatastoreType.CONFIGURATION,
- configIid,
- this,
- DataChangeScope.SUBTREE);
+ configReg = dataProvider.registerDataTreeChangeListener(new DataTreeIdentifier<>(
+ LogicalDatastoreType.CONFIGURATION, configIid), this);
}
private Optional<OfOverlayConfig> readConfig() {
package org.opendaylight.groupbasedpolicy.renderer.ofoverlay;
+import com.google.common.base.Optional;
+import com.google.common.util.concurrent.FutureCallback;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import java.util.Collection;
import java.util.HashSet;
import java.util.List;
-import java.util.Map.Entry;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Future;
-
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.DataChangeListener;
+import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
+import org.opendaylight.controller.md.sal.binding.api.DataTreeChangeListener;
+import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
+import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker.DataChangeScope;
-import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
import org.opendaylight.groupbasedpolicy.api.sf.ChainActionDefinition;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.policy.SubjectFeatureInstances;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.policy.subject.feature.instances.ActionInstance;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
-import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.common.RpcResult;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import com.google.common.base.Optional;
-import com.google.common.util.concurrent.FutureCallback;
-import com.google.common.util.concurrent.Futures;
-import com.google.common.util.concurrent.ListenableFuture;
-
/**
* Manage the state exchanged with SFC
*
* are retrieved from SFC.
*
*/
-public class SfcManager implements AutoCloseable, DataChangeListener {
+public class SfcManager implements AutoCloseable, DataTreeChangeListener<ActionInstance> {
private static final Logger LOG =
LoggerFactory.getLogger(SfcManager.class);
private final DataBroker dataBroker;
private final ExecutorService executor;
private final InstanceIdentifier<ActionInstance> allActionInstancesIid;
- private final ListenerRegistration<DataChangeListener> actionListener;
+ private final ListenerRegistration<?> actionListener;
/*
* local cache of the RSP first hops that we've requested from SFC,
/*
* Use thread-safe type only because we use an executor
*/
- this.rspMap = new ConcurrentHashMap<String, RenderedServicePathFirstHop>();
+ this.rspMap = new ConcurrentHashMap<>();
/*
* For now, listen to all changes in rules
.child(SubjectFeatureInstances.class)
.child(ActionInstance.class)
.build();
- actionListener = dataBroker.registerDataChangeListener(LogicalDatastoreType.CONFIGURATION,
- allActionInstancesIid, this, DataChangeScope.ONE);
+ actionListener = dataBroker.registerDataTreeChangeListener(new DataTreeIdentifier<>(
+ LogicalDatastoreType.CONFIGURATION, allActionInstancesIid), this);
LOG.debug("SfcManager: Started");
}
public Set<IpAddress> getSfcSourceIps() {
- if (rspMap.isEmpty()) return null;
+ if (rspMap.isEmpty()) {
+ return null;
+ }
- Set<IpAddress> ipAddresses = new HashSet<IpAddress>();
+ Set<IpAddress> ipAddresses = new HashSet<>();
for (RenderedServicePathFirstHop rsp: rspMap.values()) {
if (rsp.getIp() != null) {
ipAddresses.add(IetfModelCodec.ipAddress2010(rsp.getIp()));
}
}
- if (ipAddresses.isEmpty()) return null;
+ if (ipAddresses.isEmpty()) {
+ return null;
+ }
return ipAddresses;
}
@Override
- public void onDataChanged(
- AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> actionInstanceNotification) {
-
- for (DataObject dao : actionInstanceNotification.getCreatedData().values()) {
- if (dao instanceof ActionInstance) {
- ActionInstance ai = (ActionInstance)dao;
- LOG.debug("New ActionInstance created");
- executor.execute(new MatchActionDefTask(ai, null,
- ActionState.ADD));
- }
- }
-
- for (InstanceIdentifier<?> iid : actionInstanceNotification.getRemovedPaths()) {
- DataObject old = actionInstanceNotification.getOriginalData().get(iid);
- if (old instanceof ActionInstance) {
- ActionInstance ai = (ActionInstance)old;
- executor.execute(new MatchActionDefTask(null, ai,
- ActionState.DELETE));
- }
- }
-
- for (Entry<InstanceIdentifier<?>, DataObject> entry:
- actionInstanceNotification.getUpdatedData().entrySet()) {
- DataObject dao = entry.getValue();
- if (dao instanceof ActionInstance) {
- ActionInstance nai = (ActionInstance)dao;
- ActionInstance oai = null;
- InstanceIdentifier<?> iid = entry.getKey();
- DataObject orig = actionInstanceNotification.getOriginalData().get(iid);
- if (orig != null) {
- oai = (ActionInstance)orig;
- /*
- * We may have some cleanup here. If the reference to
- * the Action Definition changed, or if the Action Instance's
- * chain parameter then we're no longer
- * an action, and we may need to remove the RSP.
- */
- }
-
- executor.execute(new MatchActionDefTask(nai, oai,
- ActionState.CHANGE));
+ public void onDataTreeChanged(Collection<DataTreeModification<ActionInstance>> changes) {
+ for (DataTreeModification<ActionInstance> change: changes) {
+ DataObjectModification<ActionInstance> rootNode = change.getRootNode();
+ final ActionInstance dataBefore = rootNode.getDataBefore();
+ final ActionInstance dataAfter = rootNode.getDataAfter();
+ switch (rootNode.getModificationType()) {
+ case SUBTREE_MODIFIED:
+ case WRITE:
+ if (dataBefore == null) {
+ LOG.debug("New ActionInstance created");
+ executor.execute(new MatchActionDefTask(dataAfter, null, ActionState.ADD));
+ } else {
+ /*
+ We may have some cleanup here. If the reference to
+ the Action Definition changed, or if the Action Instance's
+ chain parameter then we're no longer
+ an action, and we may need to remove the RSP.
+ */
+ LOG.debug("ActionInstance updated");
+ executor.execute(new MatchActionDefTask(dataAfter, dataBefore, ActionState.CHANGE));
+ }
+ break;
+ case DELETE:
+ LOG.debug("ActionInstance deleted");
+ executor.execute(new MatchActionDefTask(null, dataBefore, ActionState.DELETE));
+ break;
+ default:
+ break;
}
}
}
@Override
public void onSuccess(Optional<ActionDefinition> dao) {
LOG.debug("Found ActionDefinition {}", id.getValue());
- if (!dao.isPresent()) return;
+ if (!dao.isPresent()) {
+ return;
+ }
ActionDefinition ad = dao.get();
if (ad.getId().getValue().equals(ChainActionDefinition.ID.getValue())) {
}
private ParameterValue getChainNameParameter(List<ParameterValue> pvl) {
- if (pvl == null) return null;
+ if (pvl == null) {
+ return null;
+ }
for (ParameterValue pv: actionInstance.getParameterValue()) {
if (pv.getName().getValue().equals(SFC_CHAIN_NAME)) {
return pv;
private void deleteSfcRsp() {
ParameterValue pv =
getChainNameParameter(originalInstance.getParameterValue());
- if (pv == null) return;
+ if (pv == null) {
+ return;
+ }
rspMap.remove(pv.getStringValue());
}
private void addSfcRsp() {
ParameterValue pv =
getChainNameParameter(actionInstance.getParameterValue());
- if (pv == null) return;
+ if (pv == null) {
+ return;
+ }
LOG.trace("Invoking RPC for chain {}", pv.getStringValue());
ReadRenderedServicePathFirstHopInputBuilder builder =
private void getSfcChain() {
ParameterValue pv =
getChainNameParameter(actionInstance.getParameterValue());
- if (pv == null) return;
+ if (pv == null) {
+ return;
+ }
LOG.trace("Invoking RPC for chain {}", pv.getStringValue());
SfcName chainName=new SfcName(pv.getStringValue());
@Override
public void close() throws Exception {
- if (actionListener != null) actionListener.close();
+ if (actionListener != null) {
+ actionListener.close();
+ }
}
}
import static com.google.common.base.Preconditions.checkNotNull;
-import java.util.Map;
-
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.DataChangeListener;
-import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent;
+import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
+import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
+import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.groupbasedpolicy.util.IidFactory;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.endpoints.Endpoint;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.endpoints.EndpointL3;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.endpoints.EndpointL3Prefix;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
-import org.opendaylight.yangtools.yang.binding.DataObject;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-public class EndpointManagerListener implements DataChangeListener, AutoCloseable {
+public class EndpointManagerListener implements AutoCloseable {
- private final ListenerRegistration<DataChangeListener> registerListener;
+ private final List<ListenerRegistration<?>> listenerRegistrations = new ArrayList<>();
private final EndpointManager endpointManager;
public EndpointManagerListener(DataBroker dataProvider, EndpointManager endpointManager) {
this.endpointManager = checkNotNull(endpointManager);
- this.registerListener = checkNotNull(dataProvider).registerDataChangeListener(
- LogicalDatastoreType.OPERATIONAL, IidFactory.endpointsIidWildcard(), this, AsyncDataBroker.DataChangeScope.SUBTREE);
+ checkNotNull(dataProvider);
+
+ listenerRegistrations.add(dataProvider.registerDataTreeChangeListener(new DataTreeIdentifier<>(
+ LogicalDatastoreType.OPERATIONAL, IidFactory.endpointsIidWildcard().child(Endpoint.class)),
+ changes -> onEndpointChanged(changes)));
+
+ listenerRegistrations.add(dataProvider.registerDataTreeChangeListener(new DataTreeIdentifier<>(
+ LogicalDatastoreType.OPERATIONAL, IidFactory.endpointsIidWildcard().child(EndpointL3.class)),
+ changes -> onEndpointL3Changed(changes)));
}
- @Override
- public void onDataChanged(AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> change) {
- //Create
- for (DataObject dao : change.getCreatedData().values()) {
- if (dao instanceof Endpoint) {
- endpointManager.processEndpoint(null, (Endpoint) dao);
- } else if (dao instanceof EndpointL3) {
- endpointManager.processL3Endpoint(null, (EndpointL3) dao);
- } else if (dao instanceof EndpointL3Prefix) {
- //noinspection UnnecessaryContinue
- continue;
- }
- }
- //Update
- Map<InstanceIdentifier<?>, DataObject> dao = change.getUpdatedData();
- for (Map.Entry<InstanceIdentifier<?>, DataObject> entry : dao.entrySet()) {
- if (entry.getValue() instanceof Endpoint) {
- Endpoint oldEp = (Endpoint) change.getOriginalData().get(entry.getKey());
- endpointManager.processEndpoint(oldEp, (Endpoint) entry.getValue());
- } else if (entry.getValue() instanceof EndpointL3) {
- EndpointL3 oldEp3 = (EndpointL3) change.getOriginalData().get(entry.getKey());
- endpointManager.processL3Endpoint(oldEp3, (EndpointL3) entry.getValue());
- } else if (entry.getValue() instanceof EndpointL3Prefix) {
- //noinspection UnnecessaryContinue
- continue;
+ private void onEndpointChanged(Collection<DataTreeModification<Endpoint>> changes) {
+ for (DataTreeModification<Endpoint> change: changes) {
+ DataObjectModification<Endpoint> rootNode = change.getRootNode();
+ switch (rootNode.getModificationType()) {
+ case SUBTREE_MODIFIED:
+ case WRITE:
+ endpointManager.processEndpoint(rootNode.getDataBefore(), rootNode.getDataAfter());
+ break;
+ case DELETE:
+ endpointManager.processEndpoint(rootNode.getDataBefore(), null);
+ break;
+ default:
+ break;
}
}
- //Remove
- for (InstanceIdentifier<?> iid : change.getRemovedPaths()) {
- DataObject old = change.getOriginalData().get(iid);
- if (old == null) {
- continue;
- }
- if (old instanceof Endpoint) {
- endpointManager.processEndpoint((Endpoint) old, null);
- } else if (old instanceof EndpointL3) {
- endpointManager.processL3Endpoint((EndpointL3) old, null);
- } else if (old instanceof EndpointL3Prefix) {
- //noinspection UnnecessaryContinue
- continue;
+ }
+
+ private void onEndpointL3Changed(Collection<DataTreeModification<EndpointL3>> changes) {
+ for (DataTreeModification<EndpointL3> change: changes) {
+ DataObjectModification<EndpointL3> rootNode = change.getRootNode();
+ switch (rootNode.getModificationType()) {
+ case SUBTREE_MODIFIED:
+ case WRITE:
+ endpointManager.processL3Endpoint(rootNode.getDataBefore(), rootNode.getDataAfter());
+ break;
+ case DELETE:
+ endpointManager.processL3Endpoint(rootNode.getDataBefore(), null);
+ break;
+ default:
+ break;
}
}
}
@Override
- public void close() throws Exception {
- if (registerListener != null)
- registerListener.close();
+ public void close() {
+ for (ListenerRegistration<?> reg: listenerRegistrations) {
+ reg.close();
+ }
}
}
package org.opendaylight.groupbasedpolicy.renderer.ofoverlay.node;
+import static com.google.common.base.Preconditions.checkNotNull;
+
import com.google.common.base.Objects;
import com.google.common.base.Optional;
import com.google.common.util.concurrent.Futures;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.DataChangeListener;
+import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
+import org.opendaylight.controller.md.sal.binding.api.DataTreeChangeListener;
+import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
+import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
import org.opendaylight.controller.md.sal.binding.api.ReadTransaction;
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.AsyncDataBroker.DataChangeScope;
-import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNodeConnector;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.Name;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeKey;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
-import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.Map;
-import java.util.Map.Entry;
-
-import static com.google.common.base.Preconditions.checkNotNull;
-
-public class FlowCapableNodeConnectorListener implements DataChangeListener, AutoCloseable {
+public class FlowCapableNodeConnectorListener implements DataTreeChangeListener<FlowCapableNodeConnector>,
+ AutoCloseable {
private static final Logger LOG = LoggerFactory.getLogger(FlowCapableNodeConnectorListener.class);
.build();
private final DataBroker dataProvider;
private final SwitchManager switchManager;
- private final ListenerRegistration<DataChangeListener> listenerRegistration;
+ private final ListenerRegistration<?> listenerRegistration;
public FlowCapableNodeConnectorListener(DataBroker dataProvider, SwitchManager switchManager) {
this.dataProvider = checkNotNull(dataProvider);
this.switchManager = checkNotNull(switchManager);
- listenerRegistration = dataProvider.registerDataChangeListener(LogicalDatastoreType.OPERATIONAL,
- fcNodeConnectorIid, this, DataChangeScope.BASE);
+ listenerRegistration = dataProvider.registerDataTreeChangeListener(new DataTreeIdentifier<>(
+ LogicalDatastoreType.OPERATIONAL, fcNodeConnectorIid), this);
}
@Override
- public void onDataChanged(AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> change) {
+ public void onDataTreeChanged(Collection<DataTreeModification<FlowCapableNodeConnector>> changes) {
ReadWriteTransaction rwTx = dataProvider.newReadWriteTransaction();
//endpoint and endpoint L3 maps
Map<Name, EndpointL3> l3EpWithOfOverlayAugByPortName = readL3EpsWithOfOverlayAugByPortName(rwTx);
boolean isDataPutToTx = false;
- for (Entry<InstanceIdentifier<?>, DataObject> fcncEntry : change.getCreatedData().entrySet()) {
- if (FlowCapableNodeConnector.class.equals(fcncEntry.getKey().getTargetType())) {
- InstanceIdentifier<NodeConnector> ncIid = fcncEntry.getKey().firstIdentifierOf(NodeConnector.class);
- FlowCapableNodeConnector fcnc = (FlowCapableNodeConnector) fcncEntry.getValue();
- LOG.trace(
- "FlowCapableNodeConnector created: NodeId: {} NodeConnectorId: {} FlowCapableNodeConnector: {}",
- ncIid.firstKeyOf(Node.class, NodeKey.class).getId().getValue(),
- ncIid.firstKeyOf(NodeConnector.class, NodeConnectorKey.class).getId().getValue(), fcnc);
- switchManager.updateSwitchNodeConnectorConfig(ncIid, fcnc);
- Name portName = getPortName(fcnc);
- boolean updated = updateEpWithNodeConnectorInfo(epWithOfOverlayAugByPortName.get(portName), ncIid, rwTx);
- boolean l3Updated = updateL3EpWithNodeConnectorInfo(l3EpWithOfOverlayAugByPortName.get(portName), ncIid, rwTx);
- if (updated || l3Updated) {
- isDataPutToTx = true;
- }
- }
- }
- for (Entry<InstanceIdentifier<?>, DataObject> fcncEntry : change.getUpdatedData().entrySet()) {
- if (FlowCapableNodeConnector.class.equals(fcncEntry.getKey().getTargetType())) {
- InstanceIdentifier<NodeConnector> ncIid = fcncEntry.getKey().firstIdentifierOf(NodeConnector.class);
- FlowCapableNodeConnector fcnc = (FlowCapableNodeConnector) fcncEntry.getValue();
- LOG.trace(
- "FlowCapableNodeConnector updated: NodeId: {} NodeConnectorId: {} FlowCapableNodeConnector: {}",
- ncIid.firstKeyOf(Node.class, NodeKey.class).getId().getValue(),
- ncIid.firstKeyOf(NodeConnector.class, NodeConnectorKey.class).getId().getValue(), fcnc);
- switchManager.updateSwitchNodeConnectorConfig(ncIid, fcnc);
- Name portName = getPortName(fcnc);
- boolean updated = updateEpWithNodeConnectorInfo(epWithOfOverlayAugByPortName.get(portName), ncIid, rwTx);
- boolean l3Updated = updateL3EpWithNodeConnectorInfo(l3EpWithOfOverlayAugByPortName.get(portName), ncIid, rwTx);
- if (updated || l3Updated) {
- isDataPutToTx = true;
- }
- FlowCapableNodeConnector originalFcnc = (FlowCapableNodeConnector) change.getOriginalData().get(
- fcncEntry.getKey());
- Name portNameFromOriginalFcnc = getPortName(originalFcnc);
- // port name already existed and then was changed
- if (portNameFromOriginalFcnc != null && !Objects.equal(portNameFromOriginalFcnc, portName)) {
- updated = updateEpWithNodeConnectorInfo(epWithOfOverlayAugByPortName
- .get(portNameFromOriginalFcnc), null, rwTx);
- l3Updated = updateL3EpWithNodeConnectorInfo(l3EpWithOfOverlayAugByPortName
- .get(portNameFromOriginalFcnc), null, rwTx);
+ for (DataTreeModification<FlowCapableNodeConnector> change: changes) {
+ DataObjectModification<FlowCapableNodeConnector> rootNode = change.getRootNode();
+ InstanceIdentifier<NodeConnector> ncIid = change.getRootPath().getRootIdentifier()
+ .firstIdentifierOf(NodeConnector.class);
+ final FlowCapableNodeConnector originalFcnc = rootNode.getDataBefore();
+ boolean updated;
+ boolean l3Updated;
+ switch (rootNode.getModificationType()) {
+ case SUBTREE_MODIFIED:
+ case WRITE:
+ FlowCapableNodeConnector fcnc = rootNode.getDataAfter();
+ LOG.trace(
+ "FlowCapableNodeConnector updated: NodeId: {} NodeConnectorId: {} FlowCapableNodeConnector: {}",
+ ncIid.firstKeyOf(Node.class, NodeKey.class).getId().getValue(),
+ ncIid.firstKeyOf(NodeConnector.class, NodeConnectorKey.class).getId().getValue(), fcnc);
+ switchManager.updateSwitchNodeConnectorConfig(ncIid, fcnc);
+ Name portName = getPortName(fcnc);
+ updated = updateEpWithNodeConnectorInfo(epWithOfOverlayAugByPortName.get(portName), ncIid, rwTx);
+ l3Updated = updateL3EpWithNodeConnectorInfo(l3EpWithOfOverlayAugByPortName.get(portName), ncIid, rwTx);
if (updated || l3Updated) {
isDataPutToTx = true;
}
- }
- }
- }
- for (InstanceIdentifier<?> fcncIid : change.getRemovedPaths()) {
- if (FlowCapableNodeConnector.class.equals(fcncIid.getTargetType())) {
- InstanceIdentifier<NodeConnector> ncIid = fcncIid.firstIdentifierOf(NodeConnector.class);
- FlowCapableNodeConnector originalFcnc = (FlowCapableNodeConnector) change.getOriginalData()
- .get(fcncIid);
- LOG.trace("FlowCapableNodeConnector removed: NodeId: {} NodeConnectorId: {}",
- ncIid.firstKeyOf(Node.class, NodeKey.class).getId().getValue(),
- ncIid.firstKeyOf(NodeConnector.class, NodeConnectorKey.class).getId().getValue());
- switchManager.updateSwitchNodeConnectorConfig(ncIid, null);
- Name portNameFromOriginalFcnc = getPortName(originalFcnc);
- boolean updated = updateEpWithNodeConnectorInfo(epWithOfOverlayAugByPortName.get(portNameFromOriginalFcnc), null, rwTx);
- boolean l3Updated = updateL3EpWithNodeConnectorInfo(l3EpWithOfOverlayAugByPortName.get(portNameFromOriginalFcnc), null, rwTx);
- if (updated || l3Updated) {
- isDataPutToTx = true;
- }
+
+ if (originalFcnc != null) {
+ Name portNameFromOriginalFcnc = getPortName(originalFcnc);
+ // port name already existed and then was changed
+ if (portNameFromOriginalFcnc != null && !Objects.equal(portNameFromOriginalFcnc, portName)) {
+ updated = updateEpWithNodeConnectorInfo(epWithOfOverlayAugByPortName
+ .get(portNameFromOriginalFcnc), null, rwTx);
+ l3Updated = updateL3EpWithNodeConnectorInfo(l3EpWithOfOverlayAugByPortName
+ .get(portNameFromOriginalFcnc), null, rwTx);
+ if (updated || l3Updated) {
+ isDataPutToTx = true;
+ }
+ }
+ }
+ break;
+ case DELETE:
+ LOG.trace("FlowCapableNodeConnector removed: NodeId: {} NodeConnectorId: {}",
+ ncIid.firstKeyOf(Node.class, NodeKey.class).getId().getValue(),
+ ncIid.firstKeyOf(NodeConnector.class, NodeConnectorKey.class).getId().getValue());
+ switchManager.updateSwitchNodeConnectorConfig(ncIid, null);
+ Name portNameFromOriginalFcnc = getPortName(originalFcnc);
+ updated = updateEpWithNodeConnectorInfo(epWithOfOverlayAugByPortName.get(portNameFromOriginalFcnc), null, rwTx);
+ l3Updated = updateL3EpWithNodeConnectorInfo(l3EpWithOfOverlayAugByPortName.get(portNameFromOriginalFcnc), null, rwTx);
+ if (updated || l3Updated) {
+ isDataPutToTx = true;
+ }
+ break;
+ default:
+ break;
}
}
+
if (isDataPutToTx) {
rwTx.submit();
} else {
listenerRegistration.close();
}
}
-
}
import static com.google.common.base.Preconditions.checkNotNull;
-import java.util.Map.Entry;
-
+import java.util.Collection;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.DataChangeListener;
-import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker.DataChangeScope;
-import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent;
+import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
+import org.opendaylight.controller.md.sal.binding.api.DataTreeChangeListener;
+import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
+import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNode;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeKey;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
-import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-public class FlowCapableNodeListener implements DataChangeListener, AutoCloseable {
+public class FlowCapableNodeListener implements DataTreeChangeListener<FlowCapableNode>, AutoCloseable {
private static final Logger LOG = LoggerFactory.getLogger(FlowCapableNodeListener.class);
.augmentation(FlowCapableNode.class)
.build();
private final SwitchManager switchManager;
- private final ListenerRegistration<DataChangeListener> listenerRegistration;
+ private final ListenerRegistration<?> listenerRegistration;
public FlowCapableNodeListener(DataBroker dataProvider, SwitchManager switchManager) {
this.switchManager = checkNotNull(switchManager);
- listenerRegistration = checkNotNull(dataProvider).registerDataChangeListener(LogicalDatastoreType.OPERATIONAL,
- fcNodeIid, this, DataChangeScope.BASE);
+ listenerRegistration = checkNotNull(dataProvider).registerDataTreeChangeListener(new DataTreeIdentifier<>(
+ LogicalDatastoreType.OPERATIONAL, fcNodeIid), this);
}
@Override
- public void onDataChanged(AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> change) {
- for (Entry<InstanceIdentifier<?>, DataObject> fcNodeEntry : change.getCreatedData().entrySet()) {
- if (FlowCapableNode.class.equals(fcNodeEntry.getKey().getTargetType())) {
- NodeId nodeId = fcNodeEntry.getKey().firstKeyOf(Node.class, NodeKey.class).getId();
- FlowCapableNode fcNode = (FlowCapableNode) fcNodeEntry.getValue();
- LOG.trace("FlowCapableNode created. NodeId: {} FlowCapableNode: {}", nodeId.getValue(), fcNode);
- switchManager.updateSwitch(nodeId, fcNode);
- }
- }
- for (Entry<InstanceIdentifier<?>, DataObject> fcNodeEntry : change.getUpdatedData().entrySet()) {
- if (FlowCapableNode.class.equals(fcNodeEntry.getKey().getTargetType())) {
- NodeId nodeId = fcNodeEntry.getKey().firstKeyOf(Node.class, NodeKey.class).getId();
- FlowCapableNode fcNode = (FlowCapableNode) fcNodeEntry.getValue();
- LOG.trace("FlowCapableNode updated. NodeId: {} FlowCapableNode: {}", nodeId.getValue(), fcNode);
- switchManager.updateSwitch(nodeId, fcNode);
- }
- }
- for (InstanceIdentifier<?> removedFcNodeIid : change.getRemovedPaths()) {
- if (FlowCapableNode.class.equals(removedFcNodeIid.getTargetType())) {
- NodeId nodeId = removedFcNodeIid.firstKeyOf(Node.class, NodeKey.class).getId();
- LOG.trace("FlowCapableNode removed. NodeId: {}", nodeId.getValue());
- switchManager.updateSwitch(nodeId, null);
+ public void onDataTreeChanged(Collection<DataTreeModification<FlowCapableNode>> changes) {
+ for (DataTreeModification<FlowCapableNode> change: changes) {
+ DataObjectModification<FlowCapableNode> rootNode = change.getRootNode();
+ NodeId nodeId = change.getRootPath().getRootIdentifier().firstKeyOf(Node.class, NodeKey.class).getId();
+ switch (rootNode.getModificationType()) {
+ case SUBTREE_MODIFIED:
+ case WRITE:
+ FlowCapableNode fcNode = rootNode.getDataAfter();
+ LOG.trace("FlowCapableNode updated. NodeId: {} FlowCapableNode: {}", nodeId.getValue(), fcNode);
+ switchManager.updateSwitch(nodeId, fcNode);
+ break;
+ case DELETE:
+ LOG.trace("FlowCapableNode removed. NodeId: {}", nodeId.getValue());
+ switchManager.updateSwitch(nodeId, null);
+ break;
+ default:
+ break;
}
}
}
import static com.google.common.base.Preconditions.checkNotNull;
-import java.util.Map.Entry;
-
+import java.util.Collection;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.DataChangeListener;
-import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker.DataChangeScope;
-import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent;
+import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
+import org.opendaylight.controller.md.sal.binding.api.DataTreeChangeListener;
+import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
+import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.ofoverlay.rev140528.OfOverlayNodeConfig;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeKey;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
-import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-public class OfOverlayNodeListener implements DataChangeListener, AutoCloseable {
+public class OfOverlayNodeListener implements DataTreeChangeListener<OfOverlayNodeConfig>, AutoCloseable {
private static final Logger LOG = LoggerFactory.getLogger(OfOverlayNodeListener.class);
.augmentation(OfOverlayNodeConfig.class)
.build();
private final SwitchManager switchManager;
- private final ListenerRegistration<DataChangeListener> listenerRegistration;
+ private final ListenerRegistration<?> listenerRegistration;
public OfOverlayNodeListener(DataBroker dataProvider, SwitchManager switchManager) {
this.switchManager = checkNotNull(switchManager);
- listenerRegistration = checkNotNull(dataProvider).registerDataChangeListener(
- LogicalDatastoreType.CONFIGURATION, ofOverlayNodeIid, this, DataChangeScope.ONE);
+ listenerRegistration = checkNotNull(dataProvider).registerDataTreeChangeListener(new DataTreeIdentifier<>(
+ LogicalDatastoreType.CONFIGURATION, ofOverlayNodeIid), this);
}
@Override
- public void onDataChanged(AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> change) {
- for (Entry<InstanceIdentifier<?>, DataObject> nodeConfigEntry : change.getCreatedData().entrySet()) {
- if (OfOverlayNodeConfig.class.equals(nodeConfigEntry.getKey().getTargetType())) {
- NodeId nodeId = nodeConfigEntry.getKey().firstKeyOf(Node.class, NodeKey.class).getId();
- OfOverlayNodeConfig nodeConfig = (OfOverlayNodeConfig) nodeConfigEntry.getValue();
- LOG.trace("OfOverlayNodeConfig created. NodeId: {} OfOverlayNodeConfig: {}", nodeId.getValue(),
- nodeConfig);
- switchManager.updateSwitchConfig(nodeId, nodeConfig);
- }
- }
- for (Entry<InstanceIdentifier<?>, DataObject> nodeConfigEntry : change.getUpdatedData().entrySet()) {
- if (OfOverlayNodeConfig.class.equals(nodeConfigEntry.getKey().getTargetType())) {
- NodeId nodeId = nodeConfigEntry.getKey().firstKeyOf(Node.class, NodeKey.class).getId();
- OfOverlayNodeConfig nodeConfig = (OfOverlayNodeConfig) nodeConfigEntry.getValue();
- LOG.trace("OfOverlayNodeConfig updated. NodeId: {} OfOverlayNodeConfig: {}", nodeId.getValue(),
- nodeConfig);
- switchManager.updateSwitchConfig(nodeId, nodeConfig);
- }
- }
- for (InstanceIdentifier<?> removedNodeConfigIid : change.getRemovedPaths()) {
- if (OfOverlayNodeConfig.class.equals(removedNodeConfigIid.getTargetType())) {
- NodeId nodeId = removedNodeConfigIid.firstKeyOf(Node.class, NodeKey.class).getId();
- LOG.trace("OfOverlayNodeConfig removed. NodeId: {}", nodeId.getValue());
- switchManager.updateSwitchConfig(nodeId, null);
+ public void onDataTreeChanged(Collection<DataTreeModification<OfOverlayNodeConfig>> changes) {
+ for (DataTreeModification<OfOverlayNodeConfig> change: changes) {
+ DataObjectModification<OfOverlayNodeConfig> rootNode = change.getRootNode();
+ NodeId nodeId = change.getRootPath().getRootIdentifier().firstKeyOf(Node.class, NodeKey.class).getId();
+ switch (rootNode.getModificationType()) {
+ case SUBTREE_MODIFIED:
+ case WRITE:
+ OfOverlayNodeConfig nodeConfig = rootNode.getDataAfter();
+ LOG.trace("OfOverlayNodeConfig updated. NodeId: {} OfOverlayNodeConfig: {}", nodeId.getValue(),
+ nodeConfig);
+ switchManager.updateSwitchConfig(nodeId, nodeConfig);
+ break;
+ case DELETE:
+ LOG.trace("OfOverlayNodeConfig removed. NodeId: {}", nodeId.getValue());
+ switchManager.updateSwitchConfig(nodeId, null);
+ break;
+ default:
+ break;
}
}
}
listenerRegistration.close();
}
}
-
}
package org.opendaylight.groupbasedpolicy.renderer.ofoverlay;
import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.atLeastOnce;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
+import com.google.common.base.Optional;
+import com.google.common.util.concurrent.CheckedFuture;
+import com.google.common.util.concurrent.Futures;
import java.lang.reflect.Method;
-
import org.junit.Before;
import org.junit.Test;
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.DataChangeListener;
import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
import org.opendaylight.controller.md.sal.binding.api.NotificationService;
import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker.DataChangeScope;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import com.google.common.base.Optional;
-import com.google.common.util.concurrent.CheckedFuture;
-import com.google.common.util.concurrent.Futures;
-
public class OFOverlayRendererTest {
private OFOverlayRenderer renderer;
private StatisticsManager statisticsManager;
private short tableOffset;
private CheckedFuture<Optional<OfOverlayConfig>, ReadFailedException> future;
- private ListenerRegistration<DataChangeListener> configReg;
+ private ListenerRegistration<?> configReg;
private ReadOnlyTransaction readTransaction;
@SuppressWarnings("unchecked")
statisticsManager = mock(StatisticsManager.class);
tableOffset = 5;
configReg = mock(ListenerRegistration.class);
- when(dataProvider.registerDataChangeListener(any(LogicalDatastoreType.class), any(InstanceIdentifier.class),
- any(DataChangeListener.class), any(DataChangeScope.class))).thenReturn(configReg);
when(dataProvider.registerDataTreeChangeListener(any(DataTreeIdentifier.class),
any(ClusteredDataTreeChangeListener.class))).thenReturn(configReg);
@Test
public void constructorTest() throws Exception {
renderer.close();
- verify(configReg, times(11)).close();
+ verify(configReg, atLeastOnce()).close();
}
@Test
package org.opendaylight.groupbasedpolicy.renderer.ofoverlay;
import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.when;
-import java.util.Arrays;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.Set;
+import java.util.Collection;
+import java.util.Collections;
import java.util.concurrent.ExecutorService;
-
import org.junit.Before;
import org.junit.Test;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.DataChangeListener;
-import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker.DataChangeScope;
-import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
+import org.opendaylight.controller.md.sal.binding.api.DataTreeChangeListener;
+import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
+import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.policy.subject.feature.instances.ActionInstance;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
-import org.opendaylight.yangtools.yang.binding.DataObject;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
public class SfcManagerTest {
private DataBroker dataBroker;
private RpcProviderRegistry rpcRegistry;
private ExecutorService executor;
- private ListenerRegistration<DataChangeListener> actionListener;
+ private ListenerRegistration<?> actionListener;
- private AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> actionInstanceNotification;
- private InstanceIdentifier<DataObject> pathIdentifier;
+ private DataObjectModification<ActionInstance> mockModification;
+ private Collection<DataTreeModification<ActionInstance>> changeEvent;
private ActionInstance dataObject;
- private HashMap<InstanceIdentifier<?>, DataObject> dataMap;
- private Set<InstanceIdentifier<?>> dataSet;
@SuppressWarnings("unchecked")
@Before
rpcRegistry = mock(RpcProviderRegistry.class);
executor = mock(ExecutorService.class);
actionListener = mock(ListenerRegistration.class);
- actionInstanceNotification = mock(AsyncDataChangeEvent.class);
- pathIdentifier = mock(InstanceIdentifier.class);
dataObject = mock(ActionInstance.class);
- when(
- dataBroker.registerDataChangeListener(any(LogicalDatastoreType.class), any(InstanceIdentifier.class),
- any(DataChangeListener.class), any(DataChangeScope.class))).thenReturn(actionListener);
- dataMap = new HashMap<InstanceIdentifier<?>, DataObject>();
- dataMap.put(pathIdentifier, dataObject);
- dataSet = new HashSet<InstanceIdentifier<?>>(Arrays.asList(pathIdentifier));
+ doReturn(actionListener).when(dataBroker).registerDataTreeChangeListener(
+ any(DataTreeIdentifier.class), any(DataTreeChangeListener.class));
manager = new SfcManager(dataBroker, rpcRegistry, executor);
+
+ DataTreeModification<ActionInstance> mockDataTreeModification = mock(DataTreeModification.class);
+ mockModification = mock(DataObjectModification.class);
+ doReturn(mockModification).when(mockDataTreeModification).getRootNode();
+ changeEvent = Collections.singletonList(mockDataTreeModification);
}
@Test
@Test
public void onDataChangedTestAdd() {
- when(actionInstanceNotification.getCreatedData()).thenReturn(dataMap);
- manager.onDataChanged(actionInstanceNotification);
+ doReturn(DataObjectModification.ModificationType.WRITE).when(mockModification).getModificationType();
+ doReturn(dataObject).when(mockModification).getDataAfter();
+
+ manager.onDataTreeChanged(changeEvent);
verify(executor).execute(any(Runnable.class));
}
@Test
public void onDataChangedTestDelete() {
- when(actionInstanceNotification.getRemovedPaths()).thenReturn(dataSet);
- when(actionInstanceNotification.getOriginalData()).thenReturn(dataMap);
- manager.onDataChanged(actionInstanceNotification);
+ doReturn(DataObjectModification.ModificationType.DELETE).when(mockModification).getModificationType();
+ doReturn(dataObject).when(mockModification).getDataBefore();
+
+ manager.onDataTreeChanged(changeEvent);
verify(executor).execute(any(Runnable.class));
}
@Test
public void onDataChangedTestChange() {
- when(actionInstanceNotification.getOriginalData()).thenReturn(dataMap);
- when(actionInstanceNotification.getUpdatedData()).thenReturn(dataMap);
- manager.onDataChanged(actionInstanceNotification);
+ doReturn(DataObjectModification.ModificationType.SUBTREE_MODIFIED).when(mockModification).getModificationType();
+ doReturn(dataObject).when(mockModification).getDataBefore();
+ doReturn(dataObject).when(mockModification).getDataAfter();
+
+ manager.onDataTreeChanged(changeEvent);
verify(executor).execute(any(Runnable.class));
}
}
package org.opendaylight.groupbasedpolicy.renderer.ofoverlay.endpoint;
import static org.mockito.Matchers.any;
+import static org.mockito.Matchers.eq;
+import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
-import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
+import java.util.Collection;
+import java.util.Collections;
import org.junit.Before;
import org.junit.Test;
+import org.mockito.ArgumentCaptor;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent;
-import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.test.DataChangeListenerTester;
+import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
+import org.opendaylight.controller.md.sal.binding.api.DataTreeChangeListener;
+import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
+import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
+import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.groupbasedpolicy.util.IidFactory;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.endpoints.Endpoint;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.endpoints.EndpointL3;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.endpoints.EndpointL3Prefix;
+import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.yang.binding.DataObject;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
public class EndpointManagerListenerTest {
- private InstanceIdentifier<DataObject> endpointId;
- private AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> change;
+ private EndpointManagerListener endpointManagerListener;
private EndpointManager endpointManager;
- private DataChangeListenerTester tester;
+ private DataBroker mockBroker;
@SuppressWarnings("unchecked")
@Before
public void init() {
- endpointId = mock(InstanceIdentifier.class);
endpointManager = mock(EndpointManager.class);
- DataBroker dataProvider = mock(DataBroker.class);
+ mockBroker = mock(DataBroker.class);
+ endpointManagerListener = new EndpointManagerListener(mockBroker, endpointManager);
- EndpointManagerListener endpointManagerListener = new EndpointManagerListener(dataProvider, endpointManager);
- tester = new DataChangeListenerTester(endpointManagerListener);
- tester.setRemovedPath(endpointId);
+ doReturn(mock(ListenerRegistration.class)).when(mockBroker).registerDataTreeChangeListener(
+ any(DataTreeIdentifier.class), any(DataTreeChangeListener.class));
}
+ @SuppressWarnings({ "unchecked", "rawtypes" })
@Test
- public void testOnDataChangeEndpoint() {
- DataObject endpoint = mock(Endpoint.class);
- tester.setDataObject(endpointId, endpoint);
+ public void testEndpointCreated() {
+ ArgumentCaptor<DataTreeChangeListener> dtclCaptor = ArgumentCaptor.forClass(DataTreeChangeListener.class);
+ verify(mockBroker).registerDataTreeChangeListener(eq(new DataTreeIdentifier<>(
+ LogicalDatastoreType.OPERATIONAL, IidFactory.endpointsIidWildcard().child(Endpoint.class))),
+ dtclCaptor.capture());
- tester.callOnDataChanged();
+ Endpoint endpoint = mock(Endpoint.class);
- verify(endpointManager, times(3)).processEndpoint(any(Endpoint.class), any(Endpoint.class));
+ dtclCaptor.getValue().onDataTreeChanged(newMockDataTreeModification(null, endpoint,
+ DataObjectModification.ModificationType.WRITE));
+
+ verify(endpointManager).processEndpoint(null, endpoint);
+ verify(endpointManager, never()).processL3Endpoint(any(EndpointL3.class), any(EndpointL3.class));
+ }
+
+ @SuppressWarnings({ "unchecked", "rawtypes" })
+ @Test
+ public void testEndpointUpdated() {
+ ArgumentCaptor<DataTreeChangeListener> dtclCaptor = ArgumentCaptor.forClass(DataTreeChangeListener.class);
+ verify(mockBroker).registerDataTreeChangeListener(eq(new DataTreeIdentifier<>(
+ LogicalDatastoreType.OPERATIONAL, IidFactory.endpointsIidWildcard().child(Endpoint.class))),
+ dtclCaptor.capture());
+
+ Endpoint endpoint = mock(Endpoint.class);
+
+ dtclCaptor.getValue().onDataTreeChanged(newMockDataTreeModification(endpoint, endpoint,
+ DataObjectModification.ModificationType.WRITE));
+
+ verify(endpointManager).processEndpoint(endpoint, endpoint);
verify(endpointManager, never()).processL3Endpoint(any(EndpointL3.class), any(EndpointL3.class));
}
+ @SuppressWarnings({ "unchecked", "rawtypes" })
@Test
- public void testOnDataChangeEndpointL3() {
- DataObject endpoint = mock(EndpointL3.class);
- tester.setDataObject(endpointId, endpoint);
+ public void testEndpointDeleted() {
+ ArgumentCaptor<DataTreeChangeListener> dtclCaptor = ArgumentCaptor.forClass(DataTreeChangeListener.class);
+ verify(mockBroker).registerDataTreeChangeListener(eq(new DataTreeIdentifier<>(
+ LogicalDatastoreType.OPERATIONAL, IidFactory.endpointsIidWildcard().child(Endpoint.class))),
+ dtclCaptor.capture());
+
+ Endpoint endpoint = mock(Endpoint.class);
- tester.callOnDataChanged();
+ dtclCaptor.getValue().onDataTreeChanged(newMockDataTreeModification(endpoint, null,
+ DataObjectModification.ModificationType.DELETE));
+
+ verify(endpointManager).processEndpoint(endpoint, null);
+ verify(endpointManager, never()).processL3Endpoint(any(EndpointL3.class), any(EndpointL3.class));
+ }
+
+ @SuppressWarnings({ "unchecked", "rawtypes" })
+ @Test
+ public void testEndpointL3Created() {
+ ArgumentCaptor<DataTreeChangeListener> dtclCaptor = ArgumentCaptor.forClass(DataTreeChangeListener.class);
+ verify(mockBroker).registerDataTreeChangeListener(eq(new DataTreeIdentifier<>(
+ LogicalDatastoreType.OPERATIONAL, IidFactory.endpointsIidWildcard().child(EndpointL3.class))),
+ dtclCaptor.capture());
+ EndpointL3 endpoint = mock(EndpointL3.class);
+
+ dtclCaptor.getValue().onDataTreeChanged(newMockDataTreeModification(null, endpoint,
+ DataObjectModification.ModificationType.WRITE));
+
+ verify(endpointManager).processL3Endpoint(null, endpoint);
verify(endpointManager, never()).processEndpoint(any(Endpoint.class), any(Endpoint.class));
- verify(endpointManager, times(3)).processL3Endpoint(any(EndpointL3.class), any(EndpointL3.class));
}
+ @SuppressWarnings({ "unchecked", "rawtypes" })
@Test
- public void testOnDataChangeEndpointL3Prefix() {
- DataObject endpoint = mock(EndpointL3Prefix.class);
- tester.setDataObject(endpointId, endpoint);
+ public void testEndpointL3Updated() {
+ ArgumentCaptor<DataTreeChangeListener> dtclCaptor = ArgumentCaptor.forClass(DataTreeChangeListener.class);
+ verify(mockBroker).registerDataTreeChangeListener(eq(new DataTreeIdentifier<>(
+ LogicalDatastoreType.OPERATIONAL, IidFactory.endpointsIidWildcard().child(EndpointL3.class))),
+ dtclCaptor.capture());
- tester.callOnDataChanged();
+ EndpointL3 endpoint = mock(EndpointL3.class);
+ dtclCaptor.getValue().onDataTreeChanged(newMockDataTreeModification(endpoint, endpoint,
+ DataObjectModification.ModificationType.WRITE));
+
+ verify(endpointManager).processL3Endpoint(endpoint, endpoint);
verify(endpointManager, never()).processEndpoint(any(Endpoint.class), any(Endpoint.class));
- verify(endpointManager, never()).processL3Endpoint(any(EndpointL3.class), any(EndpointL3.class));
}
+ @SuppressWarnings({ "unchecked", "rawtypes" })
+ @Test
+ public void testEndpointL3Deleted() {
+ ArgumentCaptor<DataTreeChangeListener> dtclCaptor = ArgumentCaptor.forClass(DataTreeChangeListener.class);
+ verify(mockBroker).registerDataTreeChangeListener(eq(new DataTreeIdentifier<>(
+ LogicalDatastoreType.OPERATIONAL, IidFactory.endpointsIidWildcard().child(EndpointL3.class))),
+ dtclCaptor.capture());
+
+ EndpointL3 endpoint = mock(EndpointL3.class);
+
+ dtclCaptor.getValue().onDataTreeChanged(newMockDataTreeModification(endpoint, null,
+ DataObjectModification.ModificationType.DELETE));
+
+ verify(endpointManager).processL3Endpoint(endpoint, null);
+ verify(endpointManager, never()).processEndpoint(any(Endpoint.class), any(Endpoint.class));
+ }
+
+ @SuppressWarnings("unchecked")
+ private static <T extends DataObject> Collection<DataTreeModification<T>> newMockDataTreeModification(T dataBefore,
+ T dataAfter, DataObjectModification.ModificationType type) {
+ DataTreeModification<T> mockDataTreeModification = mock(DataTreeModification.class);
+ DataObjectModification<T> mockModification = mock(DataObjectModification.class);
+ doReturn(type).when(mockModification).getModificationType();
+ doReturn(dataBefore).when(mockModification).getDataBefore();
+ doReturn(dataAfter).when(mockModification).getDataAfter();
+ doReturn(mockModification).when(mockDataTreeModification).getRootNode();
+
+ return Collections.singletonList(mockDataTreeModification);
+ }
}
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
+import com.google.common.base.Optional;
+import com.google.common.util.concurrent.CheckedFuture;
import java.util.Collection;
import java.util.Collections;
-import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ScheduledExecutorService;
-
import org.junit.Before;
import org.junit.Test;
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.DataChangeListener;
import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
import org.opendaylight.controller.md.sal.binding.api.NotificationService;
import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker.DataChangeScope;
-import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service.rev130709.PacketProcessingService;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
-import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import com.google.common.base.Optional;
-import com.google.common.util.concurrent.CheckedFuture;
-
public class EndpointManagerTest {
private EndpointManager manager;
private NotificationService notificationService;
private ScheduledExecutorService executor;
private SwitchManager switchManager;
- private ListenerRegistration<DataChangeListener> listenerReg;
private EndpointListener endpointListener;
private Endpoint endpoint1;
private Endpoint endpoint2;
when(writeTransaction.submit()).thenReturn(checkedFutureWrite);
BindingAwareBroker.RpcRegistration<EndpointService> rpcRegistration =
mock(BindingAwareBroker.RpcRegistration.class);
- listenerReg = mock(ListenerRegistration.class);
- when(dataProvider.registerDataChangeListener(any(LogicalDatastoreType.class), any(InstanceIdentifier.class),
- any(DataChangeListener.class), any(DataChangeScope.class))).thenReturn(listenerReg);
when(dataProvider.registerDataTreeChangeListener(any(DataTreeIdentifier.class),
- any(ClusteredDataTreeChangeListener.class))).thenReturn(listenerReg);
+ any(ClusteredDataTreeChangeListener.class))).thenReturn(mock(ListenerRegistration.class));
manager = spy(new EndpointManager(dataProvider, packetService, flowService, notificationService, executor, switchManager));
endpointListener = mock(EndpointListener.class);
when(nodeId1.getValue()).thenReturn("nodeValue1");
when(nodeId2.getValue()).thenReturn("nodeValue2");
- // onDataChanged
- AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> change = mock(AsyncDataChangeEvent.class);
- InstanceIdentifier<DataObject> endpointId = mock(InstanceIdentifier.class);
- Set<InstanceIdentifier<?>> removedPaths = new HashSet<>();
- removedPaths.add(endpointId);
- when(change.getRemovedPaths()).thenReturn(removedPaths);
-
// updateEndpointL3
oldL3Ep = mock(EndpointL3.class);
newL3Ep = mock(EndpointL3.class);
@Test
public void closeTest() throws Exception {
manager.close();
- verify(listenerReg, times(3)).close();
}
// **************
package org.opendaylight.groupbasedpolicy.renderer.ofoverlay.node;
import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
+import com.google.common.base.Optional;
+import com.google.common.util.concurrent.CheckedFuture;
import java.util.Arrays;
-import java.util.HashMap;
-import java.util.HashSet;
+import java.util.Collection;
+import java.util.Collections;
import java.util.List;
-import java.util.Map;
-import java.util.Set;
-
import org.junit.Before;
import org.junit.Test;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.DataChangeListener;
+import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
+import org.opendaylight.controller.md.sal.binding.api.DataTreeChangeListener;
+import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
+import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker.DataChangeScope;
-import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNodeConnector;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeKey;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
-import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import com.google.common.base.Optional;
-import com.google.common.util.concurrent.CheckedFuture;
-
public class FlowCapableNodeConnectorListenerTest {
private FlowCapableNodeConnectorListener listener;
private DataBroker dataProvider;
private SwitchManager switchManager;
- private ListenerRegistration<DataChangeListener> listenerRegistration;
- private AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> asyncDataChangeEvent;
+ private ListenerRegistration<?> listenerRegistration;
private FlowCapableNodeConnector entryValue;
private String portName;
private NodeId childNodeId;
private OfOverlayContext ofOverlayEp;
private EndpointKey endpointKey;
private Name name;
+ private DataObjectModification<FlowCapableNodeConnector> mockModification;
+ private Collection<DataTreeModification<FlowCapableNodeConnector>> changeEvent;
@SuppressWarnings("unchecked")
@Before
dataProvider = mock(DataBroker.class);
switchManager = mock(SwitchManager.class);
listenerRegistration = mock(ListenerRegistration.class);
- when(
- dataProvider.registerDataChangeListener(any(LogicalDatastoreType.class), any(InstanceIdentifier.class),
- any(DataChangeListener.class), any(DataChangeScope.class))).thenReturn(listenerRegistration);
- asyncDataChangeEvent = mock(AsyncDataChangeEvent.class);
+ when(dataProvider.registerDataTreeChangeListener(any(DataTreeIdentifier.class),
+ any(DataTreeChangeListener.class))).thenReturn(listenerRegistration);
entryValue = mock(FlowCapableNodeConnector.class);
portName = "portName";
when(entryValue.getName()).thenReturn(portName);
when(ofOverlayEp.getPortName()).thenReturn(name);
listener = new FlowCapableNodeConnectorListener(dataProvider, switchManager);
+
+ DataTreeModification<FlowCapableNodeConnector> mockDataTreeModification = mock(DataTreeModification.class);
+ mockModification = mock(DataObjectModification.class);
+ doReturn(mockModification).when(mockDataTreeModification).getRootNode();
+ doReturn(new DataTreeIdentifier<>(LogicalDatastoreType.OPERATIONAL, entryKey)).when(mockDataTreeModification)
+ .getRootPath();
+ changeEvent = Collections.singletonList(mockDataTreeModification);
}
@Test
@Test
public void onDataChangeTestCreatedDataSubmit() {
- Map<InstanceIdentifier<?>, DataObject> entrySet = new HashMap<InstanceIdentifier<?>, DataObject>();
- entrySet.put(entryKey, entryValue);
- when(asyncDataChangeEvent.getCreatedData()).thenReturn(entrySet);
+ doReturn(DataObjectModification.ModificationType.WRITE).when(mockModification).getModificationType();
+ doReturn(entryValue).when(mockModification).getDataAfter();
- listener.onDataChanged(asyncDataChangeEvent);
+ listener.onDataTreeChanged(changeEvent);
verify(rwTx).submit();
}
@Test
public void onDataChangeTestUpdatedDataSubmit() {
- Map<InstanceIdentifier<?>, DataObject> entrySet = new HashMap<InstanceIdentifier<?>, DataObject>();
- entrySet.put(entryKey, entryValue);
- when(asyncDataChangeEvent.getUpdatedData()).thenReturn(entrySet);
- when(asyncDataChangeEvent.getOriginalData()).thenReturn(entrySet);
+ doReturn(DataObjectModification.ModificationType.SUBTREE_MODIFIED).when(mockModification).getModificationType();
+ doReturn(entryValue).when(mockModification).getDataBefore();
+ doReturn(entryValue).when(mockModification).getDataAfter();
- listener.onDataChanged(asyncDataChangeEvent);
+ listener.onDataTreeChanged(changeEvent);
verify(rwTx).submit();
}
@Test
public void onDataChangeTestRemovedPaths() {
- Set<InstanceIdentifier<?>> removedPaths = new HashSet<InstanceIdentifier<?>>();
- removedPaths.add(entryKey);
- when(asyncDataChangeEvent.getRemovedPaths()).thenReturn(removedPaths);
-
- Map<InstanceIdentifier<?>, DataObject> entrySet = new HashMap<InstanceIdentifier<?>, DataObject>();
- entrySet.put(entryKey, entryValue);
- when(asyncDataChangeEvent.getOriginalData()).thenReturn(entrySet);
+ doReturn(DataObjectModification.ModificationType.DELETE).when(mockModification).getModificationType();
+ doReturn(entryValue).when(mockModification).getDataBefore();
when(ofOverlayEp.getNodeConnectorId()).thenReturn(childNodeConnectorId);
- listener.onDataChanged(asyncDataChangeEvent);
+ listener.onDataTreeChanged(changeEvent);
verify(rwTx).submit();
}
}
package org.opendaylight.groupbasedpolicy.renderer.ofoverlay.node;
import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.Map;
-import java.util.Set;
-
+import java.util.Collection;
+import java.util.Collections;
import org.junit.Before;
import org.junit.Test;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.DataChangeListener;
-import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker.DataChangeScope;
-import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent;
+import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
+import org.opendaylight.controller.md.sal.binding.api.DataTreeChangeListener;
+import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
+import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNode;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeKey;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
-import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
public class FlowCapableNodeListenerTest {
private DataBroker dataProvider;
private SwitchManager switchManager;
- private ListenerRegistration<DataChangeListener> listenerRegistration;
+ private ListenerRegistration<?> listenerRegistration;
+ private DataTreeModification<FlowCapableNode> mockDataTreeModification;
+ private DataObjectModification<FlowCapableNode> mockModification;
+ private Collection<DataTreeModification<FlowCapableNode>> changeEvent;
@SuppressWarnings("unchecked")
@Before
dataProvider = mock(DataBroker.class);
switchManager = mock(SwitchManager.class);
listenerRegistration = mock(ListenerRegistration.class);
- when(
- dataProvider.registerDataChangeListener(any(LogicalDatastoreType.class), any(InstanceIdentifier.class),
- any(DataChangeListener.class), any(DataChangeScope.class))).thenReturn(listenerRegistration);
+ when(dataProvider.registerDataTreeChangeListener(any(DataTreeIdentifier.class),
+ any(DataTreeChangeListener.class))).thenReturn(listenerRegistration);
listener = new FlowCapableNodeListener(dataProvider, switchManager);
+
+ mockDataTreeModification = mock(DataTreeModification.class);
+ mockModification = mock(DataObjectModification.class);
+ doReturn(mockModification).when(mockDataTreeModification).getRootNode();
+ changeEvent = Collections.singletonList(mockDataTreeModification);
}
@Test
@SuppressWarnings("unchecked")
@Test
public void onDataChangeTestCreatedData() {
- AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> change = mock(AsyncDataChangeEvent.class);
FlowCapableNode entryValue = mock(FlowCapableNode.class);
NodeId childNodeId = mock(NodeId.class);
.augmentation(FlowCapableNode.class)
.build();
- Map<InstanceIdentifier<?>, DataObject> entrySet = new HashMap<InstanceIdentifier<?>, DataObject>();
- entrySet.put(entryKey, entryValue);
- when(change.getCreatedData()).thenReturn(entrySet);
+ doReturn(new DataTreeIdentifier<>(LogicalDatastoreType.OPERATIONAL, entryKey)).when(mockDataTreeModification)
+ .getRootPath();
+ doReturn(DataObjectModification.ModificationType.WRITE).when(mockModification).getModificationType();
+ doReturn(entryValue).when(mockModification).getDataAfter();
- listener.onDataChanged(change);
+ listener.onDataTreeChanged(changeEvent);
verify(switchManager).updateSwitch(childNodeId, entryValue);
}
@SuppressWarnings("unchecked")
@Test
public void onDataChangeTestUpdatedData() {
- AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> change = mock(AsyncDataChangeEvent.class);
FlowCapableNode entryValue = mock(FlowCapableNode.class);
NodeId childNodeId = mock(NodeId.class);
.augmentation(FlowCapableNode.class)
.build();
- Map<InstanceIdentifier<?>, DataObject> entrySet = new HashMap<InstanceIdentifier<?>, DataObject>();
- entrySet.put(entryKey, entryValue);
- when(change.getUpdatedData()).thenReturn(entrySet);
+ doReturn(new DataTreeIdentifier<>(LogicalDatastoreType.OPERATIONAL, entryKey)).when(mockDataTreeModification)
+ .getRootPath();
+ doReturn(DataObjectModification.ModificationType.SUBTREE_MODIFIED).when(mockModification).getModificationType();
+ doReturn(entryValue).when(mockModification).getDataAfter();
- listener.onDataChanged(change);
+ listener.onDataTreeChanged(changeEvent);
verify(switchManager).updateSwitch(childNodeId, entryValue);
}
@SuppressWarnings("unchecked")
@Test
public void onDataChangeTestRemovedPaths() {
- AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> change = mock(AsyncDataChangeEvent.class);
NodeId childNodeId = mock(NodeId.class);
InstanceIdentifier<FlowCapableNode> entryKey = InstanceIdentifier.builder(Nodes.class)
.augmentation(FlowCapableNode.class)
.build();
- Set<InstanceIdentifier<?>> removedPaths = new HashSet<InstanceIdentifier<?>>();
- removedPaths.add(entryKey);
- when(change.getRemovedPaths()).thenReturn(removedPaths);
+ doReturn(new DataTreeIdentifier<>(LogicalDatastoreType.OPERATIONAL, entryKey)).when(mockDataTreeModification)
+ .getRootPath();
+ doReturn(DataObjectModification.ModificationType.DELETE).when(mockModification).getModificationType();
- listener.onDataChanged(change);
+ listener.onDataTreeChanged(changeEvent);
verify(switchManager).updateSwitch(childNodeId, null);
}
package org.opendaylight.groupbasedpolicy.renderer.ofoverlay.node;
import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.Map;
-import java.util.Set;
-
+import java.util.Collection;
+import java.util.Collections;
import org.junit.Before;
import org.junit.Test;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.DataChangeListener;
-import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker.DataChangeScope;
-import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent;
+import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
+import org.opendaylight.controller.md.sal.binding.api.DataTreeChangeListener;
+import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
+import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.ofoverlay.rev140528.OfOverlayNodeConfig;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeKey;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
-import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
public class OfOverlayNodeListenerTest {
private DataBroker dataProvider;
private SwitchManager switchManager;
- private ListenerRegistration<DataChangeListener> listenerRegistration;
+ private ListenerRegistration<?> listenerRegistration;
- private AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> change;
private OfOverlayNodeConfig entryValue;
private NodeId childNodeId;
private InstanceIdentifier<OfOverlayNodeConfig> entryKey;
+ private DataObjectModification<OfOverlayNodeConfig> mockModification;
+ private Collection<DataTreeModification<OfOverlayNodeConfig>> changeEvent;
@SuppressWarnings("unchecked")
@Before
dataProvider = mock(DataBroker.class);
switchManager = mock(SwitchManager.class);
listenerRegistration = mock(ListenerRegistration.class);
- when(
- dataProvider.registerDataChangeListener(any(LogicalDatastoreType.class), any(InstanceIdentifier.class),
- any(DataChangeListener.class), any(DataChangeScope.class))).thenReturn(listenerRegistration);
+ when(dataProvider.registerDataTreeChangeListener(any(DataTreeIdentifier.class),
+ any(DataTreeChangeListener.class))).thenReturn(listenerRegistration);
- change = mock(AsyncDataChangeEvent.class);
entryValue = mock(OfOverlayNodeConfig.class);
childNodeId = mock(NodeId.class);
entryKey = InstanceIdentifier.builder(Nodes.class)
.build();
listener = new OfOverlayNodeListener(dataProvider, switchManager);
+
+ DataTreeModification<OfOverlayNodeConfig> mockDataTreeModification = mock(DataTreeModification.class);
+ mockModification = mock(DataObjectModification.class);
+ doReturn(mockModification).when(mockDataTreeModification).getRootNode();
+ doReturn(new DataTreeIdentifier<>(LogicalDatastoreType.CONFIGURATION, entryKey))
+ .when(mockDataTreeModification).getRootPath();
+ changeEvent = Collections.singletonList(mockDataTreeModification);
}
@Test
@Test
public void onDataChangedTestCreatedData() {
- Map<InstanceIdentifier<?>, DataObject> entrySet = new HashMap<InstanceIdentifier<?>, DataObject>();
- entrySet.put(entryKey, entryValue);
- when(change.getCreatedData()).thenReturn(entrySet);
+ doReturn(DataObjectModification.ModificationType.WRITE).when(mockModification).getModificationType();
+ doReturn(entryValue).when(mockModification).getDataAfter();
- listener.onDataChanged(change);
+ listener.onDataTreeChanged(changeEvent);
verify(switchManager).updateSwitchConfig(childNodeId, entryValue);
}
@Test
public void onDataChangedTestUpdatedData() {
- Map<InstanceIdentifier<?>, DataObject> entrySet = new HashMap<InstanceIdentifier<?>, DataObject>();
- entrySet.put(entryKey, entryValue);
- when(change.getUpdatedData()).thenReturn(entrySet);
+ doReturn(DataObjectModification.ModificationType.SUBTREE_MODIFIED).when(mockModification).getModificationType();
+ doReturn(entryValue).when(mockModification).getDataAfter();
- listener.onDataChanged(change);
+ listener.onDataTreeChanged(changeEvent);
verify(switchManager).updateSwitchConfig(childNodeId, entryValue);
}
@Test
public void onDataChangedTestRemovedPaths() {
- Set<InstanceIdentifier<?>> removedPaths = new HashSet<InstanceIdentifier<?>>();
- removedPaths.add(entryKey);
- when(change.getRemovedPaths()).thenReturn(removedPaths);
+ doReturn(DataObjectModification.ModificationType.DELETE).when(mockModification).getModificationType();
+ doReturn(entryValue).when(mockModification).getDataBefore();
- listener.onDataChanged(change);
+ listener.onDataTreeChanged(changeEvent);
verify(switchManager).updateSwitchConfig(childNodeId, null);
}
}
+++ /dev/null
-/*
- * Copyright (c) 2016 Cisco Systems, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.groupbasedpolicy.renderer.ofoverlay.test;
-
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.when;
-
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.Map;
-import java.util.Set;
-
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.DataChangeListener;
-import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent;
-import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.endpoint.EndpointManager;
-import org.opendaylight.yangtools.yang.binding.DataObject;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-
-public class DataChangeListenerTester {
-
- private AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> changeMock;
- private DataChangeListener listener;
-
- private Map<InstanceIdentifier<?>, DataObject> testData;
- private Set<InstanceIdentifier<?>> removedPaths;
-
- @SuppressWarnings("unchecked")
- public DataChangeListenerTester(DataChangeListener listener) {
- changeMock = mock(AsyncDataChangeEvent.class);
- testData = new HashMap<>();
- removedPaths = new HashSet<>();
-
- this.listener = listener;
-
- when(changeMock.getCreatedData()).thenReturn(testData);
- when(changeMock.getOriginalData()).thenReturn(testData);
- when(changeMock.getUpdatedData()).thenReturn(testData);
- when(changeMock.getRemovedPaths()).thenReturn(removedPaths);
- }
-
- public DataChangeListenerTester setDataObject(InstanceIdentifier<DataObject> iid, DataObject dataObject){
- testData.clear();
- return addDataObject(iid, dataObject);
- }
-
- public DataChangeListenerTester addDataObject(InstanceIdentifier<DataObject> iid, DataObject dataObject){
- testData.put(iid, dataObject);
- return this;
- }
-
- public DataChangeListenerTester setRemovedPath(InstanceIdentifier<DataObject> iid){
- removedPaths.clear();
- return addRemovedPath(iid);
- }
-
- public DataChangeListenerTester addRemovedPath(InstanceIdentifier<DataObject> iid){
- removedPaths.add(iid);
- return this;
- }
-
- public void callOnDataChanged(){
- listener.onDataChanged(changeMock);
- }
-}
Code Review / groupbasedpolicy.git / commitdiff