<dependency>
<groupId>javax.inject</groupId>
<artifactId>javax.inject</artifactId>
+ <scope>provided</scope>
<optional>true</optional>
</dependency>
<dependency>
MonitoringState monitoringState = monitoringStateBuilder.build();
txRunner.callWithNewWriteOnlyTransactionAndSubmit(OPERATIONAL, operTx -> {
- operTx.put(getMonitoringInfoId(monitorId), monitoringInfo, CREATE_MISSING_PARENT);
+ operTx.mergeParentStructurePut(getMonitoringInfoId(monitorId), monitoringInfo);
LOG.debug("adding oper monitoring info {}", monitoringInfo);
- operTx.put(getMonitorStateId(monitoringKey), monitoringState, CREATE_MISSING_PARENT);
+ operTx.mergeParentStructurePut(getMonitorStateId(monitoringKey), monitoringState);
LOG.debug("adding oper monitoring state {}", monitoringState);
MonitoridKeyEntry mapEntry = new MonitoridKeyEntryBuilder().setMonitorId(monitorId)
.setMonitorKey(monitoringKey).build();
- operTx.put(getMonitorMapId(monitorId), mapEntry, CREATE_MISSING_PARENT);
+ operTx.mergeParentStructurePut(getMonitorMapId(monitorId), mapEntry);
LOG.debug("adding oper map entry {}", mapEntry);
}).addCallback(new FutureCallback<Object>() {
@Override
monitorIds2.add(monitorId);
InterfaceMonitorEntry newEntry2 = new InterfaceMonitorEntryBuilder()
.setInterfaceName(interfaceName).setMonitorIds(monitorIds2).build();
- tx.put(LogicalDatastoreType.OPERATIONAL, getInterfaceMonitorMapId(interfaceName), newEntry2,
- CREATE_MISSING_PARENT);
+ tx.mergeParentStructurePut(LogicalDatastoreType.OPERATIONAL, getInterfaceMonitorMapId(interfaceName),
+ newEntry2);
}
return tx.commit();
}, callbackExecutorService);
final MonitorProfile monitorProfile = new MonitorProfileBuilder().setId(profileId)
.setFailureThreshold(failureThreshold).setMonitorInterval(monitorInterval)
.setMonitorWindow(monitorWindow).setProtocolType(protocolType).build();
- tx.put(LogicalDatastoreType.OPERATIONAL, getMonitorProfileId(profileId), monitorProfile,
- CREATE_MISSING_PARENT);
+ tx.mergeParentStructurePut(LogicalDatastoreType.OPERATIONAL, getMonitorProfileId(profileId),
+ monitorProfile);
tx.commit().addCallback(new FutureCallback<CommitInfo>() {
@Override
public void onFailure(Throwable error) {
} else {
InterfaceMonitorEntry newEntry = new InterfaceMonitorEntryBuilder(entry)
.withKey(new InterfaceMonitorEntryKey(interfaceName)).setMonitorIds(monitorIds).build();
- tx.put(LogicalDatastoreType.OPERATIONAL, getInterfaceMonitorMapId(interfaceName), newEntry,
- CREATE_MISSING_PARENT);
+ tx.mergeParentStructurePut(LogicalDatastoreType.OPERATIONAL,
+ getInterfaceMonitorMapId(interfaceName), newEntry);
}
return tx.commit();
} else {
import com.google.common.util.concurrent.MoreExecutors;
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.util.ArrayList;
+import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
+import java.util.Map;
import java.util.Optional;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Semaphore;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.tunnel.attributes.BfdRemoteConfigsBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.tunnel.attributes.BfdRemoteConfigsKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.tunnel.attributes.BfdStatus;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.tunnel.attributes.BfdStatusKey;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NetworkTopology;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.TopologyId;
@Override
public void update(@NonNull InstanceIdentifier<Tunnels> instanceIdentifier, @NonNull Tunnels oldTunnelInfo,
@NonNull Tunnels updatedTunnelInfo) {
- List<BfdStatus> oldBfdStatus = oldTunnelInfo.getBfdStatus();
- List<BfdStatus> newBfdStatus = updatedTunnelInfo.getBfdStatus();
+ @Nullable Map<BfdStatusKey, BfdStatus> oldBfdStatus = oldTunnelInfo.getBfdStatus();
+ @Nullable Map<BfdStatusKey, BfdStatus> newBfdStatus = updatedTunnelInfo.getBfdStatus();
LivenessState oldTunnelOpState = getTunnelOpState(oldBfdStatus);
final LivenessState newTunnelOpState = getTunnelOpState(newBfdStatus);
if (oldTunnelOpState == newTunnelOpState) {
}, MoreExecutors.directExecutor());
}
- private LivenessState getTunnelOpState(List<BfdStatus> tunnelBfdStatus) {
+ private LivenessState getTunnelOpState(Map<BfdStatusKey, BfdStatus> tunnelBfdStatus) {
LivenessState livenessState = LivenessState.Unknown;
if (tunnelBfdStatus == null || tunnelBfdStatus.isEmpty()) {
return livenessState;
}
- for (BfdStatus bfdState : tunnelBfdStatus) {
+ for (BfdStatus bfdState : tunnelBfdStatus.values()) {
if (AlivenessMonitorConstants.BFD_OP_STATE.equalsIgnoreCase(bfdState.getBfdStatusKey())) {
String bfdOpState = bfdState.getBfdStatusValue();
if (AlivenessMonitorConstants.BFD_STATE_UP.equalsIgnoreCase(bfdOpState)) {
return;
}
Tunnels tunnel = tunnelsOptional.get();
- List<BfdParams> tunnelBfdParams = tunnel.getBfdParams();
+ @Nullable Map<BfdParamsKey, BfdParams> tunnelBfdParams = tunnel.getBfdParams();
if (tunnelBfdParams == null || tunnelBfdParams.isEmpty()) {
LOG.debug("there is no bfd params available for the tunnel {}", tunnel);
return;
}
- Iterator<BfdParams> tunnelBfdParamsIterator = tunnelBfdParams.iterator();
+ Iterator<BfdParams> tunnelBfdParamsIterator = tunnelBfdParams.values().iterator();
while (tunnelBfdParamsIterator.hasNext()) {
BfdParams bfdParam = tunnelBfdParamsIterator.next();
if (AlivenessMonitorConstants.BFD_PARAM_ENABLE.equals(bfdParam.getBfdParamKey())) {
String tunnelLocalMacAddress = "<TODO>";
String tunnelLocalIpAddress = "<TODO>";
String tunnelRemoteMacAddress = "<TODO>";
- List<BfdParams> bfdParams = new ArrayList<>();
+ Map<BfdParamsKey, BfdParams> bfdParams = new HashMap<>();
fillBfdParams(bfdParams, profile);
List<BfdLocalConfigs> bfdLocalConfigs = new ArrayList<>();
fillBfdLocalConfigs(bfdLocalConfigs, tunnelLocalMacAddress, tunnelLocalIpAddress);
.setBfdLocalConfigValue(value).build();
}
- private void fillBfdParams(List<BfdParams> bfdParams, MonitorProfile profile) {
+ private void fillBfdParams(Map<BfdParamsKey, BfdParams> bfdParams, MonitorProfile profile) {
setBfdParamForEnable(bfdParams, true);
- bfdParams.add(getBfdParams(AlivenessMonitorConstants.BFD_PARAM_MIN_RX,
- Long.toString(profile.getMinRx().toJava())));
- bfdParams.add(getBfdParams(AlivenessMonitorConstants.BFD_PARAM_MIN_TX,
- Long.toString(profile.getMinTx().toJava())));
- bfdParams.add(getBfdParams(AlivenessMonitorConstants.BFD_PARAM_DECAY_MIN_RX,
- Long.toString(profile.getDecayMinRx().toJava())));
- bfdParams.add(getBfdParams(AlivenessMonitorConstants.BFD_PARAM_FORWARDING_IF_RX, profile.getForwardingIfRx()));
- bfdParams.add(getBfdParams(AlivenessMonitorConstants.BFD_PARAM_CPATH_DOWN, profile.getCpathDown()));
- bfdParams.add(getBfdParams(AlivenessMonitorConstants.BFD_PARAM_CHECK_TNL_KEY, profile.getCheckTnlKey()));
+ BfdParams bfdParams1 = getBfdParams(AlivenessMonitorConstants.BFD_PARAM_MIN_RX,
+ Long.toString(profile.getMinRx().toJava()));
+ bfdParams.put(bfdParams1.key(),bfdParams1);
+
+ BfdParams bfdParams2 = getBfdParams(AlivenessMonitorConstants.BFD_PARAM_MIN_TX,
+ Long.toString(profile.getMinTx().toJava()));
+ bfdParams.put(bfdParams2.key(), bfdParams2);
+
+ BfdParams bfdParams3 = getBfdParams(AlivenessMonitorConstants.BFD_PARAM_DECAY_MIN_RX,
+ Long.toString(profile.getDecayMinRx().toJava()));
+ bfdParams.put(bfdParams3.key(), bfdParams3);
+
+ BfdParams bfdParams4 = getBfdParams(AlivenessMonitorConstants.BFD_PARAM_FORWARDING_IF_RX,
+ profile.getForwardingIfRx());
+ bfdParams.put(bfdParams4.key(), bfdParams4);
+
+ BfdParams bfdParams5 = getBfdParams(AlivenessMonitorConstants.BFD_PARAM_CPATH_DOWN, profile.getCpathDown());
+ bfdParams.put(bfdParams5.key(),bfdParams5);
+
+ BfdParams bfdParams6 = getBfdParams(AlivenessMonitorConstants.BFD_PARAM_CHECK_TNL_KEY,
+ profile.getCheckTnlKey());
+ bfdParams.put(bfdParams6.key(),bfdParams6);
}
- private void setBfdParamForEnable(List<BfdParams> bfdParams, boolean isEnabled) {
- bfdParams.add(getBfdParams(AlivenessMonitorConstants.BFD_PARAM_ENABLE, Boolean.toString(isEnabled)));
+ private void setBfdParamForEnable(Map<BfdParamsKey, BfdParams> bfdParams, boolean isEnabled) {
+ bfdParams.put(getBfdParams(AlivenessMonitorConstants.BFD_PARAM_ENABLE, Boolean.toString(isEnabled)).key(),
+ getBfdParams(AlivenessMonitorConstants.BFD_PARAM_ENABLE, Boolean.toString(isEnabled)));
}
private BfdParams getBfdParams(String key, String value) {
import java.util.HashMap;
import java.util.Map;
import javax.inject.Singleton;
-
import org.apache.aries.blueprint.annotation.service.Service;
import org.opendaylight.genius.alivenessmonitor.protocols.AlivenessProtocolHandler;
import org.opendaylight.genius.alivenessmonitor.protocols.AlivenessProtocolHandlerRegistry;
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>6.0.4</version>
+ <version>7.0.1</version>
<relativePath/>
</parent>
import java.net.InetAddress;
import java.net.UnknownHostException;
import java.nio.charset.StandardCharsets;
-import java.util.ArrayList;
-import java.util.List;
+import java.util.HashMap;
+import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.ExecutionException;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.MacAddress;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.PhysAddress;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.Action;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.ActionKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNodeConnector;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.arputil.rev160406.ArpRequestReceivedBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.arputil.rev160406.ArpResponseReceivedBuilder;
}
int localErrorCount = 0;
- for (InterfaceAddress interfaceAddress : arpReqInput.nonnullInterfaceAddress()) {
+ for (InterfaceAddress interfaceAddress : arpReqInput.nonnullInterfaceAddress().values()) {
try {
interfaceName = interfaceAddress.getInterface();
srcIpBytes = getIpAddressBytes(interfaceAddress.getIpAddress());
payload = ArpPacketUtil.getPayload(ArpConstants.ARP_REQUEST_OP, srcMac, srcIpBytes,
ArpPacketUtil.ETHERNET_BROADCAST_DESTINATION, dstIpBytes);
- List<Action> actions = getEgressAction(interfaceName);
+ Map<ActionKey, Action> actions = getEgressAction(interfaceName);
sendPacketOutWithActions(dpnId, payload, ref, actions);
LOG.trace("sent arp request for {}", arpReqInput.getIpaddress());
}
private Future<RpcResult<TransmitPacketOutput>> sendPacketOutWithActions(
- Uint64 dpnId, byte[] payload, NodeConnectorRef ref, List<Action> actions) {
+ Uint64 dpnId, byte[] payload, NodeConnectorRef ref, Map<ActionKey, Action> actions) {
NodeConnectorRef nodeConnectorRef = MDSALUtil.getNodeConnRef(dpnId, "0xfffffffd");
TransmitPacketInput transmitPacketInput = new TransmitPacketInputBuilder().setPayload(payload)
.setNode(new NodeRef(InstanceIdentifier.builder(Nodes.class)
return packetProcessingService.transmitPacket(transmitPacketInput);
}
- private List<Action> getEgressAction(String interfaceName) {
- List<Action> actions = new ArrayList<>();
+ private Map<ActionKey, Action> getEgressAction(String interfaceName) {
+ Map<ActionKey, Action> actions = new HashMap<>();
try {
GetEgressActionsForInterfaceInputBuilder egressAction = new GetEgressActionsForInterfaceInputBuilder()
.setIntfName(interfaceName);
checkNotNull(srcIpBytes, ArpConstants.FAILED_TO_GET_SRC_IP_FOR_INTERFACE, interfaceName);
payload = ArpPacketUtil.getPayload(ArpConstants.ARP_RESPONSE_OP, srcMac, srcIpBytes, dstMac, dstIpBytes);
- List<Action> actions = getEgressAction(interfaceName);
+ Map<ActionKey, Action> actions = getEgressAction(interfaceName);
sendPacketOutWithActions(dpnId, payload, ref, actions);
LOG.debug("Sent ARP response for IP {}, from source MAC {} to target MAC {} and target IP {} via dpnId {}",
input.getSrcIpaddress().getIpv4Address().getValue(), HexEncode.bytesToHexStringFormat(srcMac),
import com.google.common.util.concurrent.ListenableFuture;
import java.util.ArrayList;
import java.util.List;
-
import org.mockito.Mockito;
import org.opendaylight.genius.mdsalutil.ActionInfo;
import org.opendaylight.genius.mdsalutil.actions.ActionOutput;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
-
import org.mockito.Mockito;
import org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service.rev130709.PacketProcessingService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service.rev130709.TransmitPacketInput;
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>6.0.4</version>
+ <version>7.0.1</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>6.0.4</version>
+ <version>7.0.1</version>
<relativePath/>
</parent>
}
ComputeNodeBuilder builder = new ComputeNodeBuilder(computeNode);
builder.setTombstoned(tombstone);
- tx.put(LogicalDatastoreType.CONFIGURATION,
- computeNodeManager.buildComputeNodeIid(computeName), builder.build(), true);
+ tx.mergeParentStructurePut(LogicalDatastoreType.CONFIGURATION,
+ computeNodeManager.buildComputeNodeIid(computeName), builder.build());
}
@Override
if (zone.getVteps() == null) {
continue;
}
- for (Vteps vteps : zone.getVteps()) {
+ for (Vteps vteps : zone.getVteps().values()) {
if (vteps.getDpnId().equals(computeNode.getDpnid())) {
InstanceIdentifier<Vteps> dpnVtepIid = InstanceIdentifier
.create(TransportZones.class)
OvsdbBridgeAugmentation bridgeAugmentation = node.augmentation(OvsdbBridgeAugmentation.class);
if (bridgeAugmentation != null && bridgeAugmentation.getBridgeOtherConfigs() != null) {
Uint64 datapathid = getDpnIdFromBridge(bridgeAugmentation);
- Optional<BridgeOtherConfigs> otherConfigOptional = bridgeAugmentation.getBridgeOtherConfigs()
+ Optional<BridgeOtherConfigs> otherConfigOptional = bridgeAugmentation.getBridgeOtherConfigs().values()
.stream()
.filter(otherConfig -> otherConfig.getBridgeOtherConfigKey().equals("dp-desc"))
.findFirst();
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>6.0.4</version>
+ <version>7.0.1</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>binding-parent</artifactId>
- <version>5.0.9</version>
+ <version>6.0.0</version>
<relativePath/>
</parent>
<dependencies>
<dependency>
<groupId>org.opendaylight.controller</groupId>
- <artifactId>mdsal-artifacts</artifactId>
- <version>1.11.0</version>
+ <artifactId>controller-artifacts</artifactId>
+ <version>2.0.0</version>
<type>pom</type>
<scope>import</scope>
</dependency>
<type>pom</type>
<scope>import</scope>
</dependency>
+ <dependency>
+ <groupId>com.mycila.guice.extensions</groupId>
+ <artifactId>mycila-guice-jsr250</artifactId>
+ <version>4.0.rc1</version>
+ </dependency>
+ <dependency>
+ <groupId>com.google.inject</groupId>
+ <artifactId>guice</artifactId>
+ <version>4.2.2</version>
+ </dependency>
<dependency>
<groupId>org.opendaylight.serviceutils</groupId>
<artifactId>serviceutils-artifacts</artifactId>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent</artifactId>
- <version>6.0.4</version>
+ <version>7.0.1</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>6.0.4</version>
+ <version>7.0.1</version>
<relativePath/>
</parent>
<dependency>
<groupId>org.opendaylight.yangtools</groupId>
<artifactId>yangtools-artifacts</artifactId>
- <version>4.0.6</version>
+ <version>5.0.1</version>
<type>pom</type>
<scope>import</scope>
</dependency>
<dependency>
<groupId>org.opendaylight.controller</groupId>
- <artifactId>mdsal-artifacts</artifactId>
- <version>1.11.0</version>
+ <artifactId>controller-artifacts</artifactId>
+ <version>2.0.0</version>
<type>pom</type>
<scope>import</scope>
</dependency>
<dependency>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>mdsal-artifacts</artifactId>
- <version>5.0.9</version>
+ <version>6.0.0</version>
<type>pom</type>
<scope>import</scope>
</dependency>
<dependency>
<groupId>javax.inject</groupId>
<artifactId>javax.inject</artifactId>
+ <scope>provided</scope>
<optional>true</optional>
</dependency>
<dependency>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>6.0.4</version>
+ <version>7.0.1</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>6.0.4</version>
+ <version>7.0.1</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>feature-repo-parent</artifactId>
- <version>6.0.4</version>
+ <version>7.0.1</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>single-feature-parent</artifactId>
- <version>6.0.4</version>
+ <version>7.0.1</version>
<relativePath/>
</parent>
<dependency>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>mdsal-artifacts</artifactId>
- <version>5.0.9</version>
+ <version>6.0.0</version>
<scope>import</scope>
<type>pom</type>
</dependency>
-->
<features xmlns="http://karaf.apache.org/xmlns/features/v1.4.0" name="odl-genius-api">
<feature name="odl-genius-api">
- <feature version="[6,7)">odl-apache-commons-net</feature>
+ <feature version="[7,8)">odl-apache-commons-net</feature>
</feature>
</features>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>single-feature-parent</artifactId>
- <version>6.0.4</version>
+ <version>7.0.1</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>single-feature-parent</artifactId>
- <version>6.0.4</version>
+ <version>7.0.1</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>single-feature-parent</artifactId>
- <version>6.0.4</version>
+ <version>7.0.1</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>single-feature-parent</artifactId>
- <version>6.0.4</version>
+ <version>7.0.1</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>6.0.4</version>
+ <version>7.0.1</version>
<relativePath/>
</parent>
<dependency>
<groupId>javax.inject</groupId>
<artifactId>javax.inject</artifactId>
+ <scope>provided</scope>
<optional>true</optional>
</dependency>
<dependency>
import static java.util.Comparator.comparing;
import static java.util.stream.Collectors.toCollection;
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
-import static org.opendaylight.mdsal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
import static org.opendaylight.yangtools.yang.binding.CodeHelpers.nonnull;
import com.google.common.util.concurrent.Futures;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
+import java.util.stream.Collectors;
import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.apache.aries.blueprint.annotation.service.Reference;
+import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.daexim.DataImportBootReady;
import org.opendaylight.genius.datastoreutils.ExpectedDataObjectNotFoundException;
import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.id.pools.id.pool.AvailableIdsHolder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.id.pools.id.pool.AvailableIdsHolderBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.id.pools.id.pool.ChildPools;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.id.pools.id.pool.ChildPoolsKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.id.pools.id.pool.IdEntries;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.id.pools.id.pool.IdEntriesKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.id.pools.id.pool.ReleasedIdsHolder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.id.pools.id.pool.ReleasedIdsHolderBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.released.ids.DelayedIdEntries;
if (!idPoolsOptional.isPresent()) {
return;
}
- idPoolsOptional.get().nonnullIdPool()
+ idPoolsOptional.get().nonnullIdPool().values()
.stream()
.filter(idPool -> idPool.getParentPoolName() != null
&& !idPool.getParentPoolName().isEmpty()
InstanceIdentifier<IdPool> idPoolToBeDeleted = idUtils.getIdPoolInstance(poolName);
synchronized (poolName) {
IdPool idPool = singleTxDB.syncRead(LogicalDatastoreType.CONFIGURATION, idPoolToBeDeleted);
- List<ChildPools> childPoolList = idPool.getChildPools();
+ //List<ChildPools> childPoolList = idPool.getChildPools();
+
+
+ @Nullable Map<ChildPoolsKey, ChildPools> childPoolList = idPool.getChildPools();
if (childPoolList != null) {
- childPoolList.forEach(childPool -> deletePool(childPool.getChildPoolName()));
+ childPoolList.forEach((childPool, childPools) -> {
+ deletePool(childPool.getChildPoolName());
+ });
}
singleTxDB.syncDelete(LogicalDatastoreType.CONFIGURATION, idPoolToBeDeleted);
}
private long getIdsFromOtherChildPools(ReleasedIdsHolderBuilder releasedIdsBuilderParent, IdPool parentIdPool)
throws OperationFailedException {
- List<ChildPools> childPoolsList = parentIdPool.nonnullChildPools();
+ @Nullable Map<ChildPoolsKey, ChildPools> childPoolsMap = parentIdPool.nonnullChildPools();
// Sorting the child pools on last accessed time so that the pool that
// was not accessed for a long time comes first.
- childPoolsList.sort(comparing(ChildPools::getLastAccessTime));
+
+ List<ChildPools> list = childPoolsMap.values().stream().collect(Collectors.toList());
+ list.sort(comparing(ChildPools::getLastAccessTime));
+
long currentTime = System.currentTimeMillis() / 1000;
- for (ChildPools childPools : childPoolsList) {
+ for (ChildPools childPools : childPoolsMap.values()) {
if (childPools.getLastAccessTime().toJava() + DEFAULT_IDLE_TIME > currentTime) {
break;
}
new IdPoolKey(parentIdPool.getPoolName())).child(ReleasedIdsHolder.class).build();
releasedIdsBuilderParent.setAvailableIdCount(releasedIdsBuilderParent.getAvailableIdCount().toJava() - idCount);
LOG.debug("Allocated {} ids from releasedIds of parent pool {}", idCount, parentIdPool);
- confTx.merge(releasedIdsHolderInstanceIdentifier, releasedIdsBuilderParent.build(), CREATE_MISSING_PARENTS);
+ confTx.mergeParentStructureMerge(releasedIdsHolderInstanceIdentifier, releasedIdsBuilderParent.build());
return idCount;
}
if (LOG.isDebugEnabled()) {
LOG.debug("Allocated {} ids from availableIds of global pool {}", idCount, parentIdPool);
}
- confTx.merge(availableIdsHolderInstanceIdentifier, availableIdsBuilderParent.build(), CREATE_MISSING_PARENTS);
+ confTx.mergeParentStructureMerge(availableIdsHolderInstanceIdentifier, availableIdsBuilderParent.build());
return idCount;
}
localPoolName = localPoolName.intern();
InstanceIdentifier<IdPool> parentIdPoolInstanceIdentifier = idUtils.getIdPoolInstance(parentPoolName);
IdPool parentIdPool = singleTxDB.syncRead(LogicalDatastoreType.CONFIGURATION, parentIdPoolInstanceIdentifier);
- List<IdEntries> idEntries = parentIdPool.getIdEntries();
+ @Nullable Map<IdEntriesKey, IdEntries> idEntries = parentIdPool.getIdEntries();
if (idEntries == null) {
throw new IdDoesNotExistException(parentPoolName, idKey);
}
IdEntries existingIdEntry = existingIdEntryObject.get();
List<Uint32> idValuesList = nonnull(existingIdEntry.getIdValue());
IdLocalPool localIdPoolCache = localPool.get(parentPoolName);
- boolean isRemoved = idEntries.contains(existingIdEntry);
+ boolean isRemoved = idEntries.values().contains(existingIdEntry);
LOG.debug("The entry {} is removed {}", existingIdEntry, isRemoved);
updateDelayedEntriesInLocalCache(idValuesList, parentPoolName, localIdPoolCache);
IdHolderSyncJob poolSyncJob = new IdHolderSyncJob(localPoolName, localIdPoolCache.getReleasedIds(), txRunner,
LOG.debug("Creating new global pool {}", poolName);
}
idPool = idUtils.createGlobalPool(poolName, low, high, blockSize);
- confTx.put(idPoolInstanceIdentifier, idPool, CREATE_MISSING_PARENTS);
+ confTx.mergeParentStructurePut(idPoolInstanceIdentifier, idPool);
} else {
idPool = existingIdPool.get();
if (LOG.isDebugEnabled()) {
package org.opendaylight.genius.idmanager;
-import static org.opendaylight.mdsal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
-
import com.google.common.net.InetAddresses;
import java.net.InetAddress;
import java.net.UnknownHostException;
ChildPools childPool = createChildPool(localPoolName);
InstanceIdentifier<ChildPools> childPoolInstanceIdentifier =
getChildPoolsInstanceIdentifier(poolName, localPoolName);
- tx.merge(childPoolInstanceIdentifier, childPool, CREATE_MISSING_PARENTS);
+ tx.mergeParentStructureMerge(childPoolInstanceIdentifier, childPool);
}
public void incrementPoolUpdatedMap(String localPoolName) {
package org.opendaylight.genius.idmanager.jobs;
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
-import static org.opendaylight.mdsal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
import com.google.common.util.concurrent.ListenableFuture;
import java.util.Collections;
idHolder.refreshDataStore(idPool);
InstanceIdentifier<IdPool> localPoolInstanceIdentifier = idUtils.getIdPoolInstance(localPoolName);
return Collections.singletonList(txRunner.callWithNewWriteOnlyTransactionAndSubmit(CONFIGURATION, tx -> {
- tx.merge(localPoolInstanceIdentifier, idPool.build(), CREATE_MISSING_PARENTS);
+ tx.mergeParentStructureMerge(localPoolInstanceIdentifier, idPool.build());
idUtils.incrementPoolUpdatedMap(localPoolName);
if (LOG.isDebugEnabled()) {
package org.opendaylight.genius.idmanager.jobs;
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
-import static org.opendaylight.mdsal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
import com.google.common.util.concurrent.ListenableFuture;
import java.util.Collections;
idLocalPool.getAvailableIds().refreshDataStore(idPool);
idLocalPool.getReleasedIds().refreshDataStore(idPool);
return Collections.singletonList(txRunner.callWithNewWriteOnlyTransactionAndSubmit(CONFIGURATION,
- tx -> tx.put(localPoolInstanceIdentifier, idPool.build(), CREATE_MISSING_PARENTS)));
+ tx -> tx.mergeParentStructurePut(localPoolInstanceIdentifier, idPool.build())));
}
}
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.id.pools.id.pool.ChildPoolsBuilder
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.id.pools.id.pool.IdEntriesBuilder
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.id.pools.id.pool.ReleasedIdsHolderBuilder
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.released.ids.DelayedIdEntriesBuilder
import org.opendaylight.yangtools.yang.common.Uint32;
import static extension org.opendaylight.mdsal.binding.testutils.XtendBuilderExtensions.operator_doubleGreaterThan
releasedIdsHolder = new ReleasedIdsHolderBuilder >> [
availableIdCount = 0L
delayedTimeSec = 30L
+ delayedIdEntries = #[
+ new DelayedIdEntriesBuilder >> [
+ id = Uint32.valueOf(2L)
+ readyTimeSec = Uint32.valueOf(0L)
+ ],
+ new DelayedIdEntriesBuilder >> [
+ id = Uint32.valueOf(3L)
+ readyTimeSec = Uint32.valueOf(0L)
+ ]
+ ]
]
]
}
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
+import java.util.Map;
import java.util.Optional;
import java.util.Set;
import java.util.concurrent.CountDownLatch;
import java.util.stream.Collectors;
import javax.inject.Inject;
import junit.framework.AssertionFailedError;
+import org.eclipse.jdt.annotation.NonNull;
+import org.eclipse.jdt.annotation.Nullable;
import org.junit.Before;
import org.junit.ComparisonFailure;
import org.junit.Rule;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.id.pools.id.pool.AvailableIdsHolderBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.id.pools.id.pool.ChildPools;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.id.pools.id.pool.ChildPoolsBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.id.pools.id.pool.ChildPoolsKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.id.pools.id.pool.IdEntries;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.id.pools.id.pool.IdEntriesKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.id.pools.id.pool.ReleasedIdsHolder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.id.pools.id.pool.ReleasedIdsHolderBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.released.ids.DelayedIdEntries;
String localPoolName = idUtils.getLocalPoolName(ID_POOL_NAME);
IdPool parentIdPool = new IdPoolBuilder().setPoolName(ID_POOL_NAME).withKey(new IdPoolKey(ID_POOL_NAME))
.setAvailableIdsHolder(createAvailableIdHolder(ID_LOW, ID_HIGH, ID_HIGH + 1))
- .setReleasedIdsHolder(createReleaseIdHolder(Arrays.asList(1L, 2L, 3L))).build();
+ .setReleasedIdsHolder(createReleaseIdHolder(Collections.emptyList())).build();
IdPool childPool = new IdPoolBuilder().setPoolName(localPoolName).withKey(new IdPoolKey(localPoolName))
+ .setReleasedIdsHolder(createReleaseIdHolder(Arrays.asList(1L, 2L, 3L)))
.setAvailableIdsHolder(createAvailableIdHolder(0L, 9L, 10L)).build();
WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
tx.merge(LogicalDatastoreType.CONFIGURATION, getIdPoolIdentifier(ID_POOL_NAME), parentIdPool);
tx.commit().get();
requestIdsConcurrently(true);
coordinatorEventsWaiter.awaitEventsConsumption();
-
validateIdPools(ExpectedAllocateIdFromReleasedId.idPoolParent(),
ExpectedAllocateIdFromReleasedId.idPoolChild());
}
private IdPool getUpdatedActualParentPool() throws ReadFailedException {
IdPool idPoolParentFromDS = singleTxdataBroker.syncRead(LogicalDatastoreType.CONFIGURATION,
InstanceIdentifier.builder(IdPools.class).child(IdPool.class, new IdPoolKey(ID_POOL_NAME)).build());
- List<ChildPools> childPool = idPoolParentFromDS.nonnullChildPools();
- List<ChildPools> updatedChildPool = childPool.stream()
+ @NonNull Map<ChildPoolsKey, ChildPools> childPool = idPoolParentFromDS.nonnullChildPools();
+
+ List<ChildPools> childPoolList = childPool.values().stream().collect(Collectors.toList());
+ List<ChildPools> updatedChildPool = childPoolList.stream()
.map(child -> new ChildPoolsBuilder(child).setLastAccessTime(0L).build()).collect(Collectors.toList());
- List<IdEntries> idEntries = idPoolParentFromDS.getIdEntries();
+
+ @Nullable Map<IdEntriesKey, IdEntries> idEntries = idPoolParentFromDS.getIdEntries();
IdPoolBuilder idPoolBuilder = new IdPoolBuilder(idPoolParentFromDS);
if (idEntries != null) {
- List<IdEntries> sortedIdEntries = idEntries.stream().sorted(comparing(IdEntries::getIdKey))
+ List<IdEntries> sortedIdEntries = idEntries.values().stream().sorted(comparing(IdEntries::getIdKey))
.collect(Collectors.toList());
idPoolBuilder.setIdEntries(sortedIdEntries);
}
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>6.0.4</version>
+ <version>7.0.1</version>
<relativePath/>
</parent>
import java.util.List;
import java.util.Optional;
import java.util.Set;
-
import java.util.concurrent.ExecutionException;
import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
import org.opendaylight.genius.mdsalutil.FlowInfoKey;
<dependency>
<groupId>javax.inject</groupId>
<artifactId>javax.inject</artifactId>
+ <scope>provided</scope>
<optional>true</optional>
</dependency>
<dependency>
import static org.opendaylight.genius.interfacemanager.globals.InterfaceInfo.InterfaceType.MPLS_OVER_GRE;
import static org.opendaylight.genius.interfacemanager.globals.InterfaceInfo.InterfaceType.VLAN_INTERFACE;
import static org.opendaylight.genius.interfacemanager.globals.InterfaceInfo.InterfaceType.VXLAN_TRUNK_INTERFACE;
-import static org.opendaylight.mdsal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
import com.google.common.collect.ImmutableMap;
import com.google.common.util.concurrent.ListenableFuture;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
+import java.util.Map;
import java.util.Optional;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.instruction.WriteMetadataCase;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.instruction.write.metadata._case.WriteMetadata;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list.Instruction;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list.InstructionKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.AllocateIdInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.AllocateIdInputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.AllocateIdOutput;
return new NodeId(ncId.getValue().substring(0, ncId.getValue().lastIndexOf(':')));
}
- public static Uint64[] mergeOpenflowMetadataWriteInstructions(List<Instruction> instructions) {
+ public static Uint64[] mergeOpenflowMetadataWriteInstructions(Map<InstructionKey, Instruction> instructions) {
Uint64 metadata = Uint64.ZERO;
Uint64 metadataMask = Uint64.ZERO;
if (instructions != null && !instructions.isEmpty()) {
// check if metadata write instruction is present
- for (Instruction instruction : instructions) {
+ for (Instruction instruction : instructions.values()) {
org.opendaylight.yang.gen.v1.urn.opendaylight.flow
.types.rev131026.instruction.Instruction actualInstruction = instruction
.getInstruction();
LOG.info("Binding Service {} for : {}", serviceInfo.getServiceName(), interfaceName);
InstanceIdentifier<BoundServices> boundServicesInstanceIdentifier = buildBoundServicesIId(
serviceInfo.getServicePriority().toJava(), interfaceName, serviceMode);
- tx.put(boundServicesInstanceIdentifier, serviceInfo, CREATE_MISSING_PARENTS);
+ tx.mergeParentStructurePut(boundServicesInstanceIdentifier, serviceInfo);
}
public static void unbindService(ManagedNewTransactionRunner txRunner, JobCoordinator coordinator,
package org.opendaylight.genius.interfacemanager;
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
-import static org.opendaylight.mdsal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
import com.google.common.util.concurrent.ListenableFuture;
import java.util.ArrayList;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.apache.aries.blueprint.annotation.service.Reference;
+import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.genius.datastoreutils.ExpectedDataObjectNotFoundException;
import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
import org.opendaylight.genius.infra.Datastore.Configuration;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.config.rev160406.IfmConfig;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406._interface.child.info.InterfaceParentEntry;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406._interface.child.info._interface.parent.entry.InterfaceChildEntry;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406._interface.child.info._interface.parent.entry.InterfaceChildEntryKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.IfExternal;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.IfExternalBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.IfL2vlan;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbTerminationPointAugmentation;
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.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPointKey;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.common.RpcResult;
import org.opendaylight.yangtools.yang.common.Uint64;
InstanceIdentifier<Interface> interfaceIId = InterfaceManagerCommonUtils
.getInterfaceIdentifier(new InterfaceKey(interfaceName));
ListenableFuture<Void> future = txRunner.callWithNewWriteOnlyTransactionAndSubmit(CONFIGURATION,
- tx -> tx.put(interfaceIId, interfaceBuilder.build(), CREATE_MISSING_PARENTS));
+ tx -> tx.mergeParentStructurePut(interfaceIId, interfaceBuilder.build()));
ListenableFutures.addErrorLogging(future, LOG, "Failed to (async) write {}", interfaceIId);
return future;
}
return Collections.emptyList();
}
- List<InterfaceChildEntry> childEntries = parentEntry.getInterfaceChildEntry();
+ @Nullable Map<InterfaceChildEntryKey, InterfaceChildEntry> childEntries = parentEntry.getInterfaceChildEntry();
if (childEntries == null || childEntries.isEmpty()) {
LOG.debug("No child entries found for parent {}", parentInterface);
return Collections.emptyList();
}
List<Interface> childInterfaces = new ArrayList<>();
- for (InterfaceChildEntry childEntry : childEntries) {
+ for (InterfaceChildEntry childEntry : childEntries.values()) {
String interfaceName = childEntry.getChildInterface();
Interface iface = interfaceManagerCommonUtils.getInterfaceFromConfigDS(tx, interfaceName);
if (iface != null) {
*/
public List<OvsdbTerminationPointAugmentation> getPortsOnBridge(Uint64 dpnId) {
List<OvsdbTerminationPointAugmentation> ports = new ArrayList<>();
- List<TerminationPoint> portList = interfaceMetaUtils.getTerminationPointsOnBridge(dpnId);
- for (TerminationPoint ovsPort : portList) {
+ Map<TerminationPointKey, TerminationPoint> portList = interfaceMetaUtils.getTerminationPointsOnBridge(dpnId);
+ for (TerminationPoint ovsPort : portList.values()) {
if (ovsPort.augmentation(OvsdbTerminationPointAugmentation.class) != null) {
ports.add(ovsPort.augmentation(OvsdbTerminationPointAugmentation.class));
}
@Override
public List<OvsdbTerminationPointAugmentation> getTunnelPortsOnBridge(Uint64 dpnId) {
List<OvsdbTerminationPointAugmentation> tunnelPorts = new ArrayList<>();
- List<TerminationPoint> portList = interfaceMetaUtils.getTerminationPointsOnBridge(dpnId);
- for (TerminationPoint ovsPort : portList) {
+ Map<TerminationPointKey, TerminationPoint> portList = interfaceMetaUtils.getTerminationPointsOnBridge(dpnId);
+ for (TerminationPoint ovsPort : portList.values()) {
OvsdbTerminationPointAugmentation portAug =
ovsPort.augmentation(OvsdbTerminationPointAugmentation.class);
if (portAug != null && SouthboundUtils.isInterfaceTypeTunnel(portAug.getInterfaceType())) {
Map<Class<? extends InterfaceTypeBase>, List<OvsdbTerminationPointAugmentation>> portMap;
portMap = new ConcurrentHashMap<>();
- List<TerminationPoint> ovsPorts = interfaceMetaUtils.getTerminationPointsOnBridge(dpnId);
+ Map<TerminationPointKey, TerminationPoint> ovsPorts = interfaceMetaUtils.getTerminationPointsOnBridge(dpnId);
if (ovsPorts != null) {
- for (TerminationPoint ovsPort : ovsPorts) {
+ for (TerminationPoint ovsPort : ovsPorts.values()) {
OvsdbTerminationPointAugmentation portAug =
ovsPort.augmentation(OvsdbTerminationPointAugmentation.class);
if (portAug != null && portAug.getInterfaceType() != null) {
package org.opendaylight.genius.interfacemanager.commons;
import static org.opendaylight.genius.infra.Datastore.OPERATIONAL;
-import static org.opendaylight.mdsal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
import com.google.common.util.concurrent.ListenableFuture;
import java.util.ArrayList;
import java.util.concurrent.Future;
import javax.inject.Inject;
import javax.inject.Singleton;
-
import org.apache.aries.blueprint.annotation.service.Reference;
import org.opendaylight.genius.infra.Datastore.Operational;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.common.RpcResult;
import org.opendaylight.yangtools.yang.common.Uint32;
-
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
InterfaceMonitorIdBuilder interfaceMonitorIdBuilder = new InterfaceMonitorIdBuilder();
interfaceMonitorIdInstance = interfaceMonitorIdBuilder.withKey(new InterfaceMonitorIdKey(infName))
.setMonitorId(existingMonitorIds).build();
- tx.merge(id, interfaceMonitorIdInstance, CREATE_MISSING_PARENTS);
+ tx.mergeParentStructureMerge(id, interfaceMonitorIdInstance);
}
}
}
existingMonitorIds.add(Uint32.valueOf(monitorId));
interfaceMonitorIdInstance = interfaceMonitorIdBuilder.withKey(new InterfaceMonitorIdKey(infName))
.setMonitorId(existingMonitorIds).build();
- tx.merge(id, interfaceMonitorIdInstance, CREATE_MISSING_PARENTS);
+ tx.mergeParentStructureMerge(id, interfaceMonitorIdInstance);
}
} else {
existingMonitorIds = new ArrayList<>();
existingMonitorIds.add(Uint32.valueOf(monitorId));
interfaceMonitorIdInstance = interfaceMonitorIdBuilder.setMonitorId(existingMonitorIds)
.withKey(new InterfaceMonitorIdKey(infName)).setInterfaceName(infName).build();
- tx.merge(id, interfaceMonitorIdInstance, CREATE_MISSING_PARENTS);
+ tx.mergeParentStructureMerge(id, interfaceMonitorIdInstance);
}
}
if (!Objects.equals(existinginterfaceName, infName)) {
monitorIdInterfaceInstance = monitorIdInterfaceBuilder.withKey(new MonitorIdInterfaceKey(monitorId))
.setInterfaceName(infName).build();
- tx.merge(id, monitorIdInterfaceInstance, CREATE_MISSING_PARENTS);
+ tx.mergeParentStructureMerge(id, monitorIdInterfaceInstance);
}
} else {
monitorIdInterfaceInstance = monitorIdInterfaceBuilder.setMonitorId(monitorId)
.withKey(new MonitorIdInterfaceKey(monitorId)).setInterfaceName(infName).build();
- tx.merge(id, monitorIdInterfaceInstance, CREATE_MISSING_PARENTS);
+ tx.mergeParentStructureMerge(id, monitorIdInterfaceInstance);
}
}
package org.opendaylight.genius.interfacemanager.commons;
import static org.opendaylight.genius.infra.Datastore.OPERATIONAL;
-import static org.opendaylight.mdsal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
import com.google.common.util.concurrent.ListenableFuture;
import java.time.ZonedDateTime;
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.List;
+import java.util.Map;
import java.util.Optional;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ExecutionException;
org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang
.ietf.interfaces.rev140508.interfaces.state.Interface interfaceData = ifaceBuilder
.setOperStatus(opStatus).build();
- tx.merge(interfaceId, interfaceData, CREATE_MISSING_PARENTS);
+ tx.mergeParentStructureMerge(interfaceId, interfaceData);
}
public void createInterfaceChildEntry(@NonNull TypedWriteTransaction<Configuration> tx, String parentInterface,
String childInterface) {
createInterfaceChildEntry(parentInterface, childInterface,
- pair -> tx.put(pair.getKey(), pair.getValue(), CREATE_MISSING_PARENTS));
+ pair -> tx.mergeParentStructurePut(pair.getKey(), pair.getValue()));
}
private void createInterfaceChildEntry(String parentInterface, String childInterface,
InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang
.ietf.interfaces.rev140508.interfaces.state.Interface> ifStateId = IfmUtil
.buildStateInterfaceId(interfaceName);
- tx.put(ifStateId, ifaceBuilder.build(), CREATE_MISSING_PARENTS);
+ tx.mergeParentStructurePut(ifStateId, ifaceBuilder.build());
// install ingress flow
Uint64 dpId = IfmUtil.getDpnFromNodeConnectorId(nodeConnectorId);
if (isTunnelInterface && !isOfTunnelInterface) {
batchingUtils.write(ifStateId, ifState, BatchingUtils.EntityType.DEFAULT_OPERATIONAL);
} else {
- tx.put(ifStateId, ifState, CREATE_MISSING_PARENTS);
+ tx.mergeParentStructurePut(ifStateId, ifState);
}
if (nodeConnectorId != null) {
Uint64 dpId = IfmUtil.getDpnFromNodeConnectorId(nodeConnectorId);
.getInterfaceParentEntryFromConfigDS(interfaceParentEntryIdentifier);
if (interfaceParentEntry != null) {
- List<InterfaceChildEntry> interfaceChildEntries = interfaceParentEntry.getInterfaceChildEntry();
+ Map<InterfaceChildEntryKey, InterfaceChildEntry> interfaceChildEntries =
+ interfaceParentEntry.getInterfaceChildEntry();
if (interfaceChildEntries != null) {
- for (InterfaceChildEntry interfaceChildEntry : interfaceChildEntries) {
+ for (InterfaceChildEntry interfaceChildEntry : interfaceChildEntries.values()) {
String curChildInterface = interfaceChildEntry.getChildInterface();
if (childInterface.equals(curChildInterface)) {
LOG.trace("Child entry for interface {} already exists", childInterface);
batchingUtils.write(intfid, entryBuilder.build(), BatchingUtils.EntityType.DEFAULT_OPERATIONAL);
}
- public List<InterfaceNameEntry> getAllInterfaces(Uint64 dpnId) {
+ public Map<InterfaceNameEntryKey, InterfaceNameEntry> getAllInterfaces(Uint64 dpnId) {
DpnToInterfaceKey dpnToInterfaceKey = new DpnToInterfaceKey(dpnId);
InstanceIdentifier<DpnToInterface> dpninterfaceListId =
InstanceIdentifier.builder(DpnToInterfaceList.class).child(DpnToInterface.class, dpnToInterfaceKey).build();
return;
}
- List<InterfaceNameEntry> interfaceNameEntries = dpnToInterfaceOptional.get().getInterfaceNameEntry();
+ Map<InterfaceNameEntryKey, InterfaceNameEntry> interfaceNameEntries =
+ dpnToInterfaceOptional.get().getInterfaceNameEntry();
InterfaceNameEntryKey interfaceNameEntryKey = new InterfaceNameEntryKey(infName);
InstanceIdentifier<InterfaceNameEntry> intfid = InstanceIdentifier.builder(DpnToInterfaceList.class)
.child(DpnToInterface.class, dpnToInterfaceKey)
*/
package org.opendaylight.genius.interfacemanager.commons;
-import static org.opendaylight.mdsal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
import java.util.Collections;
-import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.concurrent.ConcurrentHashMap;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeRef;
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.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPointKey;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.common.Uint64;
import org.slf4j.Logger;
BridgeEntryBuilder bridgeEntryBuilder =
new BridgeEntryBuilder().withKey(bridgeEntryKey).setBridgeReference(ovsdbBridgeRef);
- tx.merge(bridgeEntryInstanceIdentifier, bridgeEntryBuilder.build(), CREATE_MISSING_PARENTS);
+ tx.mergeParentStructureMerge(bridgeEntryInstanceIdentifier, bridgeEntryBuilder.build());
}
public static void createBridgeRefEntry(Uint64 dpnId, InstanceIdentifier<?> bridgeIid,
BridgeRefEntryBuilder tunnelDpnBridgeEntryBuilder =
new BridgeRefEntryBuilder().withKey(bridgeRefEntryKey).setDpid(dpnId)
.setBridgeReference(new OvsdbBridgeRef(bridgeIid));
- tx.put(bridgeEntryId, tunnelDpnBridgeEntryBuilder.build(), CREATE_MISSING_PARENTS);
+ tx.mergeParentStructurePut(bridgeEntryId, tunnelDpnBridgeEntryBuilder.build());
}
public static void deleteBridgeRefEntry(Uint64 dpnId, TypedWriteTransaction<Operational> tx) {
TunnelInstanceInterface tunnelInstanceInterface = new TunnelInstanceInterfaceBuilder()
.setTunnelInstanceIdentifier(tunnelInstanceId).withKey(new TunnelInstanceInterfaceKey(tunnelInstanceId))
.setInterfaceName(infName).build();
- transaction.put(id, tunnelInstanceInterface, CREATE_MISSING_PARENTS);
+ transaction.mergeParentStructurePut(id, tunnelInstanceInterface);
}
}
public void deleteBridgeInterfaceEntry(BridgeEntryKey bridgeEntryKey,
- List<BridgeInterfaceEntry> bridgeInterfaceEntries, InstanceIdentifier<BridgeEntry> bridgeEntryIid,
- String interfaceName) {
+ Map<BridgeInterfaceEntryKey, BridgeInterfaceEntry> bridgeInterfaceEntries,
+ InstanceIdentifier<BridgeEntry> bridgeEntryIid, String interfaceName) {
BridgeInterfaceEntryKey bridgeInterfaceEntryKey =
new BridgeInterfaceEntryKey(interfaceName);
InstanceIdentifier<BridgeInterfaceEntry> bridgeInterfaceEntryIid =
}
}
- public List<TerminationPoint> getTerminationPointsOnBridge(Uint64 dpnId) {
+ public Map<TerminationPointKey, TerminationPoint> getTerminationPointsOnBridge(Uint64 dpnId) {
BridgeRefEntry bridgeRefEntry = getBridgeRefEntryFromOperDS(dpnId);
if (bridgeRefEntry == null || bridgeRefEntry.getBridgeReference() == null) {
LOG.debug("BridgeRefEntry for DPNID {} not found", dpnId);
- return Collections.emptyList();
+ return Collections.emptyMap();
}
InstanceIdentifier<Node> nodeIid =
bridgeRefEntry.getBridgeReference().getValue().firstIdentifierOf(Node.class);
if (optNode.isPresent()) {
return optNode.get().getTerminationPoint();
}
- return Collections.emptyList();
+ return Collections.emptyMap();
}
// Cache Util methods
import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
-
import org.apache.aries.blueprint.annotation.service.Reference;
import org.apache.aries.blueprint.annotation.service.Service;
import org.opendaylight.genius.interfacemanager.IfmConstants;
import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
-
import org.apache.aries.blueprint.annotation.service.Reference;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.LivenessState;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.MonitorEvent;
import org.opendaylight.yangtools.yang.common.Uint32;
-
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
-
import org.apache.aries.blueprint.annotation.service.Reference;
import org.opendaylight.genius.interfacemanager.commons.InterfaceMetaUtils;
import org.opendaylight.mdsal.binding.api.ClusteredDataTreeChangeListener;
import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
-
import org.apache.aries.blueprint.annotation.service.Reference;
import org.opendaylight.genius.interfacemanager.commons.InterfaceMetaUtils;
import org.opendaylight.mdsal.binding.api.ClusteredDataTreeChangeListener;
if (parentRefs != null && parentRefs.getNodeIdentifier() != null) {
LOG.debug("Received HwVTEP Interface Remove Event: {}", removedInterface.getName());
LOG.trace("Received HwVTEP Interface Remove Event: {}", removedInterface);
- for (NodeIdentifier nodeIdentifier : parentRefs.getNodeIdentifier()) {
+ for (NodeIdentifier nodeIdentifier : parentRefs.getNodeIdentifier().values()) {
if (SouthboundUtils.HWVTEP_TOPOLOGY.equals(nodeIdentifier.getTopologyId())) {
coordinator.enqueueJob(removedInterface.getName(), () -> HwVTEPConfigRemoveHelper
.removeConfiguration(txRunner, removedInterface,
LOG.debug("Received HwVTEP Interface Update Event: {}", originalInterface.getName());
LOG.trace("Received HwVTEP Interface Update Event: updatedInterface: {}, OriginalInterface: {}",
updatedInterface, originalInterface);
- for (NodeIdentifier nodeIdentifier : parentRefs.getNodeIdentifier()) {
+ for (NodeIdentifier nodeIdentifier : parentRefs.getNodeIdentifier().values()) {
if (SouthboundUtils.HWVTEP_TOPOLOGY.equals(nodeIdentifier.getTopologyId())) {
coordinator.enqueueJob(originalInterface.getName(), () -> HwVTEPInterfaceConfigUpdateHelper
.updateConfiguration(txRunner,
if (parentRefs != null && parentRefs.getNodeIdentifier() != null) {
LOG.debug("Received HwVTEP Interface Add Event: {}", newInterface.getName());
LOG.trace("Received HwVTEP Interface Add Event: {}", newInterface);
- for (NodeIdentifier nodeIdentifier : parentRefs.getNodeIdentifier()) {
+ for (NodeIdentifier nodeIdentifier : parentRefs.getNodeIdentifier().values()) {
if (SouthboundUtils.HWVTEP_TOPOLOGY.equals(nodeIdentifier.getTopologyId())) {
coordinator.enqueueJob(newInterface.getName(), () -> HwVTEPInterfaceConfigAddHelper
.addConfiguration(txRunner,
import javax.inject.Inject;
import javax.inject.Singleton;
-
import org.apache.aries.blueprint.annotation.service.Reference;
import org.opendaylight.genius.mdsalutil.cache.DataObjectCache;
import org.opendaylight.infrautils.caches.CacheProvider;
package org.opendaylight.genius.interfacemanager.listeners;
import java.util.Collections;
-import java.util.List;
+import java.util.Map;
import java.util.Optional;
import javax.inject.Inject;
import javax.inject.Singleton;
-
import org.apache.aries.blueprint.annotation.service.Reference;
import org.opendaylight.genius.mdsalutil.cache.InstanceIdDataObjectCache;
import org.opendaylight.infrautils.caches.CacheProvider;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406._interface.child.info.InterfaceParentEntry;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406._interface.child.info.InterfaceParentEntryKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406._interface.child.info._interface.parent.entry.InterfaceChildEntry;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406._interface.child.info._interface.parent.entry.InterfaceChildEntryKey;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
cacheProvider);
}
- public Optional<List<InterfaceChildEntry>> getInterfaceChildEntries(String parentInterfaceName) {
+ public Optional<Map<InterfaceChildEntryKey, InterfaceChildEntry>>
+ getInterfaceChildEntries(String parentInterfaceName) {
try {
Optional<InterfaceParentEntry> interfaceParentEntry = dataObjectCache.get(
getInterfaceParentEntryIdentifier(parentInterfaceName));
if (interfaceParentEntry.isPresent()) {
- List<InterfaceChildEntry> interfaceChildEntries = interfaceParentEntry.get()
+ Map<InterfaceChildEntryKey, InterfaceChildEntry> interfaceChildEntries = interfaceParentEntry.get()
.getInterfaceChildEntry() != null ? interfaceParentEntry.get()
- .getInterfaceChildEntry() : Collections.emptyList();
- return Optional.of(Collections.unmodifiableList(interfaceChildEntries));
+ .getInterfaceChildEntry() : Collections.emptyMap();
+ return Optional.of(Collections.unmodifiableMap(interfaceChildEntries));
}
} catch (ReadFailedException ex) {
LOG.error("ReadFailedException exception", ex);
import com.google.common.util.concurrent.MoreExecutors;
import java.util.ArrayList;
import java.util.Collections;
+import java.util.HashMap;
import java.util.List;
+import java.util.Map;
import java.util.Objects;
import java.util.Optional;
import java.util.concurrent.Callable;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.IdManagerService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406._interface.child.info.InterfaceParentEntry;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406._interface.child.info._interface.parent.entry.InterfaceChildEntry;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406._interface.child.info._interface.parent.entry.InterfaceChildEntryKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.IfTunnel;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
public Object call() {
List<ListenableFuture<Void>> futures = ovsInterfaceStateAddHelper.addState(nodeConnectorId,
interfaceName, fcNodeConnectorNew);
- List<InterfaceChildEntry> interfaceChildEntries = getInterfaceChildEntries(interfaceName);
- for (InterfaceChildEntry interfaceChildEntry : interfaceChildEntries) {
+ Map<InterfaceChildEntryKey, InterfaceChildEntry> interfaceChildEntries =
+ getInterfaceChildEntries(interfaceName);
+ for (InterfaceChildEntry interfaceChildEntry : interfaceChildEntries.values()) {
InterfaceStateAddWorker interfaceStateAddWorker = new InterfaceStateAddWorker(idManager,
nodeConnectorId, fcNodeConnectorNew, interfaceChildEntry.getChildInterface());
coordinator.enqueueJob(interfaceName, interfaceStateAddWorker);
public List<ListenableFuture<Void>> call() {
List<ListenableFuture<Void>> futures = ovsInterfaceStateUpdateHelper.updateState(
interfaceName, fcNodeConnectorNew, fcNodeConnectorOld);
- List<InterfaceChildEntry> interfaceChildEntries = getInterfaceChildEntries(interfaceName);
- for (InterfaceChildEntry interfaceChildEntry : interfaceChildEntries) {
+ Map<InterfaceChildEntryKey, InterfaceChildEntry> interfaceChildEntries =
+ getInterfaceChildEntries(interfaceName);
+ for (InterfaceChildEntry interfaceChildEntry : interfaceChildEntries.values()) {
InterfaceStateUpdateWorker interfaceStateUpdateWorker = new InterfaceStateUpdateWorker(key,
fcNodeConnectorOld, fcNodeConnectorNew, interfaceChildEntry.getChildInterface());
coordinator.enqueueJob(interfaceName, interfaceStateUpdateWorker);
List<ListenableFuture<Void>> futures = removeInterfaceStateConfiguration();
- List<InterfaceChildEntry> interfaceChildEntries = getInterfaceChildEntries(interfaceName);
- for (InterfaceChildEntry interfaceChildEntry : interfaceChildEntries) {
+ Map<InterfaceChildEntryKey, InterfaceChildEntry> interfaceChildEntries =
+ getInterfaceChildEntries(interfaceName);
+ for (InterfaceChildEntry interfaceChildEntry : interfaceChildEntries.values()) {
// Fetch all interfaces on this port and trigger remove worker
// for each of them
InterfaceStateRemoveWorker interfaceStateRemoveWorker = new InterfaceStateRemoveWorker(idManager,
}
}
- public List<InterfaceChildEntry> getInterfaceChildEntries(String interfaceName) {
+ public Map<InterfaceChildEntryKey, InterfaceChildEntry> getInterfaceChildEntries(String interfaceName) {
InterfaceParentEntry interfaceParentEntry =
interfaceMetaUtils.getInterfaceParentEntryFromConfigDS(interfaceName);
if (interfaceParentEntry != null && interfaceParentEntry.getInterfaceChildEntry() != null) {
return interfaceParentEntry.getInterfaceChildEntry();
}
- return new ArrayList<>();
+ return new HashMap<>();
}
}
import java.util.Collections;
import javax.inject.Inject;
import javax.inject.Singleton;
-
import org.apache.aries.blueprint.annotation.service.Reference;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
package org.opendaylight.genius.interfacemanager.listeners;
import com.google.common.util.concurrent.ListenableFuture;
-
import java.util.List;
import java.util.concurrent.Callable;
import javax.inject.Inject;
import javax.inject.Singleton;
-
import org.apache.aries.blueprint.annotation.service.Reference;
import org.opendaylight.genius.interfacemanager.IfmConstants;
import org.opendaylight.genius.interfacemanager.InterfacemgrProvider;
import com.google.common.util.concurrent.ListenableFuture;
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.util.HashMap;
-import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.apache.aries.blueprint.annotation.service.Reference;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.genius.interfacemanager.IfmConstants;
import org.opendaylight.genius.interfacemanager.listeners.InterfaceChildCache;
import org.opendaylight.genius.interfacemanager.listeners.PortNameCache;
import org.opendaylight.yang.gen.v1.urn.opendaylight.direct.statistics.rev160511.GetNodeConnectorStatisticsOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.direct.statistics.rev160511.OpendaylightDirectStatisticsService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.statistics.rev130819.flow.and.statistics.map.list.FlowAndStatisticsMapList;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.statistics.rev130819.flow.and.statistics.map.list.FlowAndStatisticsMapListKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.config.rev160406.IfmConfig;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406._interface.child.info._interface.parent.entry.InterfaceChildEntry;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406._interface.child.info._interface.parent.entry.InterfaceChildEntryKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeRef;
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.yang.gen.v1.urn.opendaylight.port.statistics.rev131214.node.connector.statistics.and.port.number.map.NodeConnectorStatisticsAndPortNumberMap;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.port.statistics.rev131214.node.connector.statistics.and.port.number.map.NodeConnectorStatisticsAndPortNumberMapKey;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.common.RpcResult;
import org.slf4j.Logger;
String dpid) {
String port = "";
String portUuid = "";
- List<NodeConnectorStatisticsAndPortNumberMap> ncStatsAndPortMapList = nodeConnectorStatisticsOutput
- .nonnullNodeConnectorStatisticsAndPortNumberMap();
+ @NonNull Map<NodeConnectorStatisticsAndPortNumberMapKey, NodeConnectorStatisticsAndPortNumberMap>
+ ncStatsAndPortMapList = nodeConnectorStatisticsOutput.nonnullNodeConnectorStatisticsAndPortNumberMap();
// Parse NodeConnectorStatistics and create/update counters for them
- for (NodeConnectorStatisticsAndPortNumberMap ncStatsAndPortMap : ncStatsAndPortMapList) {
+ for (NodeConnectorStatisticsAndPortNumberMap ncStatsAndPortMap : ncStatsAndPortMapList.values()) {
NodeConnectorId nodeConnector = ncStatsAndPortMap.getNodeConnectorId();
LOG.trace("Create/update metric counter for NodeConnector: {} of node: {}", nodeConnector, dpid);
port = nodeConnector.getValue();
String portNameInCache = "openflow" + ":" + dpid + ":" + port;
java.util.Optional<String> portName = portNameCache.get(portNameInCache);
if (portName.isPresent()) {
- Optional<List<InterfaceChildEntry>> interfaceChildEntries = interfaceChildCache
+ Optional<Map<InterfaceChildEntryKey, InterfaceChildEntry>> interfaceChildEntries = interfaceChildCache
.getInterfaceChildEntries(portName.get());
if (interfaceChildEntries.isPresent()) {
if (!interfaceChildEntries.get().isEmpty()) {
private void processFlowStatistics(GetFlowStatisticsOutput flowStatsOutput, String dpid) {
Map<Short, AtomicInteger> flowTableMap = new HashMap<>();
// Get all flows for node from RPC result
- List<FlowAndStatisticsMapList> flowTableAndStatisticsMapList =
+ @NonNull Map<FlowAndStatisticsMapListKey, FlowAndStatisticsMapList> flowTableAndStatisticsMapList =
flowStatsOutput.nonnullFlowAndStatisticsMapList();
- for (FlowAndStatisticsMapList flowAndStatisticsMap : flowTableAndStatisticsMapList) {
+ for (FlowAndStatisticsMapList flowAndStatisticsMap : flowTableAndStatisticsMapList.values()) {
short tableId = flowAndStatisticsMap.getTableId().toJava();
// populate map to maintain flow count per table
flowTableMap.computeIfAbsent(tableId, key -> new AtomicInteger(0)).incrementAndGet();
import java.util.Collections;
import javax.inject.Inject;
import javax.inject.Singleton;
-
import org.apache.aries.blueprint.annotation.service.Reference;
import org.opendaylight.genius.datastoreutils.listeners.DataTreeEventCallbackRegistrar;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import javax.inject.Inject;
import javax.inject.Singleton;
-
import org.apache.aries.blueprint.annotation.service.Reference;
import org.opendaylight.serviceutils.srm.RecoverableListener;
import org.opendaylight.serviceutils.srm.ServiceRecoveryInterface;
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
import static org.opendaylight.genius.infra.Datastore.OPERATIONAL;
-import static org.opendaylight.mdsal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
import com.google.common.util.concurrent.ListenableFuture;
import java.util.ArrayList;
SouthboundUtils.setDstIp(tpAugmentationBuilder, destIPAddress);
tpBuilder.addAugmentation(HwvtepPhysicalLocatorAugmentation.class, tpAugmentationBuilder.build());
LOG.debug("creating physical locator entry for {}", terminationPointKey);
- transaction.put(tpPath, tpBuilder.build(), CREATE_MISSING_PARENTS);
+ transaction.mergeParentStructurePut(tpPath, tpBuilder.build());
}
}
package org.opendaylight.genius.interfacemanager.renderer.hwvtep.confighelpers;
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
-import static org.opendaylight.mdsal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
import com.google.common.util.concurrent.ListenableFuture;
import java.util.ArrayList;
SouthboundUtils.fillBfdParameters(bfdParams, ifTunnel);
tunnelsBuilder.setBfdParams(bfdParams);
return Collections.singletonList(txRunner.callWithNewWriteOnlyTransactionAndSubmit(CONFIGURATION,
- tx -> tx.merge(tunnelsInstanceIdentifier, tunnelsBuilder.build(), CREATE_MISSING_PARENTS)));
+ tx -> tx.mergeParentStructureMerge(tunnelsInstanceIdentifier, tunnelsBuilder.build())));
}
}
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
import static org.opendaylight.genius.infra.Datastore.OPERATIONAL;
-import static org.opendaylight.mdsal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
import com.google.common.util.concurrent.ListenableFuture;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
+import java.util.Map;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.interfacemanager.commons.InterfaceManagerCommonUtils;
import org.opendaylight.genius.interfacemanager.commons.InterfaceMetaUtils;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.physical._switch.attributes.TunnelsKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.tunnel.attributes.BfdParams;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.tunnel.attributes.BfdStatus;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.tunnel.attributes.BfdStatusKey;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
}));
}
- private static OperStatus getTunnelOpState(List<BfdStatus> tunnelBfdStatus) {
+ private static OperStatus getTunnelOpState(Map<BfdStatusKey, BfdStatus> tunnelBfdStatus) {
OperStatus livenessState = OperStatus.Down;
if (tunnelBfdStatus != null && !tunnelBfdStatus.isEmpty()) {
- for (BfdStatus bfdState : tunnelBfdStatus) {
+ for (BfdStatus bfdState : tunnelBfdStatus.values()) {
if (SouthboundUtils.BFD_OP_STATE.equalsIgnoreCase(bfdState.getBfdStatusKey())) {
String bfdOpState = bfdState.getBfdStatusValue();
if (SouthboundUtils.BFD_STATE_UP.equalsIgnoreCase(bfdOpState)) {
SouthboundUtils.fillBfdParameters(bfdParams, null);
tunnelsBuilder.setBfdParams(bfdParams);
return Collections.singletonList(txRunner.callWithNewWriteOnlyTransactionAndSubmit(CONFIGURATION,
- tx -> tx.put(tunnelsInstanceIdentifier, tunnelsBuilder.build(), CREATE_MISSING_PARENTS)));
+ tx -> tx.mergeParentStructurePut(tunnelsInstanceIdentifier, tunnelsBuilder.build())));
}
}
*/
package org.opendaylight.genius.interfacemanager.renderer.hwvtep.utilities;
-import static org.opendaylight.mdsal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
-
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
.ietf.interfaces.rev140508.interfaces.state.Interface> ifStateId = IfmUtil
.buildStateInterfaceId(interfaceInfo.getName());
ifaceBuilder.withKey(IfmUtil.getStateInterfaceKeyFromName(interfaceInfo.getName()));
- transaction.put(ifStateId, ifaceBuilder.build(), CREATE_MISSING_PARENTS);
+ transaction.mergeParentStructurePut(ifStateId, ifaceBuilder.build());
EVENT_LOGGER.info("IFM-TepInterfaceState,ADD {}", interfaceInfo.getName());
}
import com.google.common.util.concurrent.ListenableFuture;
import java.util.ArrayList;
import java.util.List;
+import java.util.Map;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.apache.aries.blueprint.annotation.service.Reference;
+import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.genius.infra.Datastore.Configuration;
import org.opendaylight.genius.infra.Datastore.Operational;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406.bridge._interface.info.BridgeEntry;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406.bridge._interface.info.BridgeEntryKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406.bridge._interface.info.bridge.entry.BridgeInterfaceEntry;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406.bridge._interface.info.bridge.entry.BridgeInterfaceEntryKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.IfL2vlan;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.IfTunnel;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.ParentRefs;
LOG.debug("Bridge Entry not present for dpn: {}", dpId);
return;
}
- List<BridgeInterfaceEntry> bridgeInterfaceEntries = bridgeEntry.getBridgeInterfaceEntry();
+ @Nullable Map<BridgeInterfaceEntryKey, BridgeInterfaceEntry> bridgeInterfaceEntries =
+ bridgeEntry.getBridgeInterfaceEntry();
if (bridgeInterfaceEntries == null) {
LOG.debug("Bridge Interface Entries not present for dpn : {}", dpId);
return;
}
}
- private static boolean canDeleteTunnelPort(List<BridgeInterfaceEntry> bridgeInterfaceEntries, IfTunnel ifTunnel) {
+ private static boolean canDeleteTunnelPort(Map<BridgeInterfaceEntryKey, BridgeInterfaceEntry>
+ bridgeInterfaceEntries, IfTunnel ifTunnel) {
return !SouthboundUtils.isOfTunnel(ifTunnel) || bridgeInterfaceEntries == null
|| bridgeInterfaceEntries.size() <= 1;
}
futures.add(txRunner.callWithNewWriteOnlyTransactionAndSubmit(OPERATIONAL, tx -> {
// FIXME: If the no. of child entries exceeds 100, perform txn
// updates in batches of 100.
- for (InterfaceChildEntry interfaceChildEntry : interfaceParentEntry.nonnullInterfaceChildEntry()) {
+ for (InterfaceChildEntry interfaceChildEntry : interfaceParentEntry
+ .nonnullInterfaceChildEntry().values()) {
LOG.debug("removing interface state for vlan trunk member {}",
interfaceChildEntry.getChildInterface());
interfaceManagerCommonUtils.deleteInterfaceStateInformation(interfaceChildEntry.getChildInterface(),
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
+import java.util.Map;
import java.util.Objects;
import java.util.concurrent.Callable;
import javax.inject.Inject;
import javax.inject.Singleton;
-
import org.apache.aries.blueprint.annotation.service.Reference;
import org.opendaylight.genius.infra.Datastore.Configuration;
import org.opendaylight.genius.infra.Datastore.Operational;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406._interface.child.info.InterfaceParentEntry;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406._interface.child.info.InterfaceParentEntryKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406._interface.child.info._interface.parent.entry.InterfaceChildEntry;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406._interface.child.info._interface.parent.entry.InterfaceChildEntryKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406.bridge.ref.info.BridgeRefEntry;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.IfL2vlan;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.IfTunnel;
private final ManagedNewTransactionRunner txRunner;
private final OperStatus operStatus;
- private final List<InterfaceChildEntry> interfaceChildEntries;
+ private final Map<InterfaceChildEntryKey, InterfaceChildEntry> interfaceChildEntries;
VlanMemberStateUpdateWorker(ManagedNewTransactionRunner txRunner, OperStatus operStatus,
- List<InterfaceChildEntry> interfaceChildEntries) {
+ Map<InterfaceChildEntryKey, InterfaceChildEntry> interfaceChildEntries) {
this.txRunner = txRunner;
this.operStatus = operStatus;
this.interfaceChildEntries = interfaceChildEntries;
@Override
public List<ListenableFuture<Void>> call() {
return Collections.singletonList(txRunner.callWithNewWriteOnlyTransactionAndSubmit(OPERATIONAL, tx -> {
- for (InterfaceChildEntry interfaceChildEntry : interfaceChildEntries) {
+ for (InterfaceChildEntry interfaceChildEntry : interfaceChildEntries.values()) {
InterfaceManagerCommonUtils.updateOperStatus(interfaceChildEntry.getChildInterface(), operStatus,
tx);
}
import java.util.List;
import javax.inject.Inject;
import javax.inject.Singleton;
-
import org.apache.aries.blueprint.annotation.service.Reference;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
+import java.util.Map;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.apache.aries.blueprint.annotation.service.Reference;
// Configuration changes
futures.add(txChain.callWithNewWriteOnlyTransactionAndSubmit(CONFIGURATION, tx -> {
// Delete the interface child information
- List<InterfaceChildEntry> interfaceChildEntries = interfaceParentEntry.nonnullInterfaceChildEntry();
+ Map<InterfaceChildEntryKey, InterfaceChildEntry> interfaceChildEntries =
+ interfaceParentEntry.nonnullInterfaceChildEntry();
InterfaceChildEntryKey interfaceChildEntryKey = new InterfaceChildEntryKey(interfaceOld.getName());
InstanceIdentifier<InterfaceChildEntry> interfaceChildEntryIid = InterfaceMetaUtils
.getInterfaceChildEntryIdentifier(interfaceParentEntryKey, interfaceChildEntryKey);
import java.util.Objects;
import javax.inject.Inject;
import javax.inject.Singleton;
-
import org.apache.aries.blueprint.annotation.service.Reference;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
import java.util.Objects;
import javax.inject.Inject;
import javax.inject.Singleton;
-
import org.apache.aries.blueprint.annotation.service.Reference;
import org.opendaylight.genius.infra.Datastore.Operational;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import com.google.common.util.concurrent.ListenableFuture;
import java.util.Collections;
import java.util.List;
+import java.util.Map;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.apache.aries.blueprint.annotation.service.Reference;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeAugmentation;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbTerminationPointAugmentation;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceBfdStatus;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceBfdStatusKey;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.common.Uint64;
import org.slf4j.Logger;
return Interface.OperStatus.Up;
}
Interface.OperStatus livenessState = Interface.OperStatus.Down;
- List<InterfaceBfdStatus> tunnelBfdStatus = terminationPoint.getInterfaceBfdStatus();
+ Map<InterfaceBfdStatusKey, InterfaceBfdStatus> tunnelBfdStatus = terminationPoint.getInterfaceBfdStatus();
if (tunnelBfdStatus != null && !tunnelBfdStatus.isEmpty()) {
- for (InterfaceBfdStatus bfdState : tunnelBfdStatus) {
+ for (InterfaceBfdStatus bfdState : tunnelBfdStatus.values()) {
if (SouthboundUtils.BFD_OP_STATE.equalsIgnoreCase(bfdState.getBfdStatusKey())) {
String bfdOpState = bfdState.getBfdStatusValue();
livenessState = SouthboundUtils.BFD_STATE_UP.equalsIgnoreCase(bfdOpState) ? Interface.OperStatus.Up
if (datastoreType != this.getDatastoreType()) {
return;
}
- tx.merge(datastoreType, identifier, (DataObject) update, true);
+ tx.mergeParentStructureMerge(datastoreType, identifier, (DataObject) update);
buildSubTransactions(transactionObjects, identifier, update, SubTransaction.UPDATE);
}
if (datastoreType != this.getDatastoreType()) {
return;
}
- tx.put(datastoreType, identifier, (DataObject) data, true);
+ tx.mergeParentStructurePut(datastoreType, identifier, (DataObject) data);
buildSubTransactions(transactionObjects, identifier, data, SubTransaction.CREATE);
}
*/
package org.opendaylight.genius.interfacemanager.renderer.ovs.utilities;
-import static org.opendaylight.mdsal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
-
-import com.google.common.collect.Maps;
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.util.ArrayList;
import java.util.HashMap;
import javax.inject.Singleton;
import org.apache.aries.blueprint.annotation.service.Reference;
import org.apache.commons.lang3.BooleanUtils;
+import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
import org.opendaylight.genius.infra.Datastore.Configuration;
import org.opendaylight.genius.infra.TypedWriteTransaction;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.InterfaceKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406.bridge._interface.info.BridgeEntry;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406.bridge._interface.info.bridge.entry.BridgeInterfaceEntry;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406.bridge._interface.info.bridge.entry.BridgeInterfaceEntryKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.IfL2vlan;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.IfTunnel;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.TunnelMonitoringTypeBfd;
OvsdbBridgeAugmentation bridgeNew) {
String bridgeName = bridgeNew.getBridgeName().getValue();
LOG.debug("adding all ports to bridge: {}", bridgeName);
- List<BridgeInterfaceEntry> bridgeInterfaceEntries = bridgeEntry.getBridgeInterfaceEntry();
+ @Nullable Map<BridgeInterfaceEntryKey, BridgeInterfaceEntry> bridgeInterfaceEntries =
+ bridgeEntry.getBridgeInterfaceEntry();
if (bridgeInterfaceEntries != null) {
- for (BridgeInterfaceEntry bridgeInterfaceEntry : bridgeInterfaceEntries) {
+ for (BridgeInterfaceEntry bridgeInterfaceEntry : bridgeInterfaceEntries.values()) {
String portName = bridgeInterfaceEntry.getInterfaceName();
InterfaceKey interfaceKey = new InterfaceKey(portName);
Interface iface = interfaceManagerCommonUtils.getInterfaceFromConfigDS(interfaceKey);
vlanId = ifL2vlan.getVlanId().getValue().toJava();
}
- Map<String, String> options = Maps.newHashMap();
+ Map<String, String> options = new HashMap<>();
// Options common to any kind of tunnel
if (BooleanUtils.isTrue(ifTunnel.isTunnelSourceIpFlow())) {
}
if (ifTunnel.getTunnelOptions() != null) {
- for (TunnelOptions tunOpt : ifTunnel.getTunnelOptions()) {
+ for (TunnelOptions tunOpt : ifTunnel.getTunnelOptions().values()) {
options.putIfAbsent(tunOpt.getTunnelOption(), tunOpt.getValue());
}
}
tpBuilder.withKey(InstanceIdentifier.keyOf(tpIid));
tpBuilder.addAugmentation(OvsdbTerminationPointAugmentation.class, tpAugmentationBuilder.build());
- transaction.merge(tpIid, tpBuilder.build(), CREATE_MISSING_PARENTS);
+ transaction.mergeParentStructureMerge(tpIid, tpBuilder.build());
}
private void addTerminationPoint(InstanceIdentifier<?> bridgeIid, String portName, int vlanId,
&& TunnelMonitoringTypeBfd.class.isAssignableFrom(ifTunnel.getMonitorProtocol());
}
- public static boolean bfdMonitoringEnabled(List<InterfaceBfd> interfaceBfds) {
+ public static boolean bfdMonitoringEnabled(Map<InterfaceBfdKey, InterfaceBfd> interfaceBfds) {
if (interfaceBfds == null) {
return false;
}
- for (InterfaceBfd interfaceBfd : interfaceBfds) {
+ for (InterfaceBfd interfaceBfd : interfaceBfds.values()) {
if (SouthboundUtils.BFD_ENABLE_KEY.equalsIgnoreCase(interfaceBfd.getBfdKey())) {
return SouthboundUtils.BFD_ENABLE_VALUE.equalsIgnoreCase(interfaceBfd.getBfdValue());//checkBfdEnabled
}
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
+import java.util.Map;
import java.util.Optional;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406.dpn.to._interface.list.DpnToInterface;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406.dpn.to._interface.list.DpnToInterfaceKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406.dpn.to._interface.list.dpn.to._interface.InterfaceNameEntry;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406.dpn.to._interface.list.dpn.to._interface.InterfaceNameEntryKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.IfTunnel;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.ParentRefs;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.TunnelTypeBase;
BridgeEntry bridgeEntry = interfaceMetaUtils.getBridgeEntryFromConfigDS(bridgeEntryInstanceIdentifier);
// local ip of any of the bridge interface entry will be the dpn end
// point ip
- BridgeInterfaceEntry bridgeInterfaceEntry = bridgeEntry.getBridgeInterfaceEntry().get(0);
+ BridgeInterfaceEntry bridgeInterfaceEntry = bridgeEntry.getBridgeInterfaceEntry().values().iterator().next();
InterfaceKey interfaceKey = new InterfaceKey(bridgeInterfaceEntry.getInterfaceName());
Interface interfaceInfo = interfaceManagerCommonUtils.getInterfaceFromConfigDS(interfaceKey);
IfTunnel tunnel = interfaceInfo.augmentation(IfTunnel.class);
LOG.warn("Could not find Operational DpnToInterface info for DPN {}. Returning empty list", dpnid);
return buildEmptyInterfaceListResult();
}
+ Map<InterfaceNameEntryKey, InterfaceNameEntry> interfaceNameEntries = entry.get().getInterfaceNameEntry();
- List<InterfaceNameEntry> interfaceNameEntries = entry.get().getInterfaceNameEntry();
if (interfaceNameEntries == null || interfaceNameEntries.isEmpty()) {
LOG.debug("No Interface list found in Operational for DPN {}", dpnid);
return buildEmptyInterfaceListResult();
}
List<Interfaces> interfaceList = new ArrayList<>();
- interfaceNameEntries.forEach(
+ interfaceNameEntries.values().forEach(
(interfaceNameEntry) -> {
InterfacesBuilder intf = new InterfacesBuilder()
.setInterfaceName(interfaceNameEntry.getInterfaceName())
if (rootNode.getDataAfter() != null) {
List<BoundServices> boundServices = new ArrayList<>();
if (rootNode.getDataAfter().getBoundServices() != null) {
- boundServices = new ArrayList<>(rootNode.getDataAfter().getBoundServices());
+ boundServices = new ArrayList<>(rootNode.getDataAfter().getBoundServices().values());
}
final ServicesInfoKey servicesInfoKey = rootNode.getDataAfter().key();
final BoundServices boundServicesBefore = dataObjectModification.getDataBefore();
return Futures.immediateFuture(null);
}
- List<BoundServices> allServices = new ArrayList<>(servicesInfo.getBoundServices());
+ List<BoundServices> allServices = new ArrayList<>(servicesInfo.getBoundServices().values());
if (allServices == null || allServices.isEmpty()) {
LOG.trace("bound services is empty for interface {}", iface.getName());
return Futures.immediateFuture(null);
public static List<org.opendaylight.yang.gen.v1.urn.opendaylight.action
.types.rev131112.action.list.Action> convertServiceActionToFlowAction(
- List<org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112
- .action.list.Action> inActionList) {
+ Map<ActionKey, org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.Action>
+ inActionList) {
return convertServiceActionToFlowAction(inActionList, 0);
}
* @return the flow actions.
*/
public static List<org.opendaylight.yang.gen.v1.urn.opendaylight.action
- .types.rev131112.action.list.Action> convertServiceActionToFlowAction(
- List<org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112
- .action.list.Action> inActionList,
+ .types.rev131112.action.list.Action> convertServiceActionToFlowAction(Map<ActionKey,
+ org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.Action> inActionList,
int keyOffset) {
List<org.opendaylight.yang.gen.v1.urn.opendaylight
.action.types.rev131112.action.list.Action> outActionList = new ArrayList<>();
if (inActionList != null) {
for (org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112
- .action.list.Action inAction : inActionList) {
+ .action.list.Action inAction : inActionList.values()) {
outActionList.add(
new org.opendaylight.yang.gen.v1.urn.opendaylight
.action.types.rev131112.action.list.ActionBuilder()
package org.opendaylight.genius.interfacemanager.servicebindings.flowbased.utilities;
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
-import static org.opendaylight.mdsal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
import com.google.common.collect.ImmutableBiMap;
import com.google.common.collect.ImmutableSet;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
+import java.util.HashMap;
import java.util.List;
+import java.util.Map;
import java.util.concurrent.ExecutionException;
import org.apache.commons.lang3.StringUtils;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.instruction.WriteActionsCase;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.instruction.WriteMetadataCase;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list.Instruction;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list.InstructionKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.IfExternal;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.IfL2vlan;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.SplitHorizon;
public static void installInterfaceIngressFlow(Uint64 dpId, Interface iface, BoundServices boundServiceNew,
TypedWriteTransaction<Configuration> tx, List<MatchInfo> matches, int lportTag, short tableId) {
- List<Instruction> instructions = boundServiceNew.augmentation(StypeOpenflow.class).getInstruction();
+ Map<InstructionKey, Instruction> instructions =
+ boundServiceNew.augmentation(StypeOpenflow.class).getInstruction();
int serviceInstructionsSize = instructions != null ? instructions.size() : 0;
- List<Instruction> instructionSet = new ArrayList<>();
+ Map<InstructionKey, Instruction> instructionSet = new HashMap<>();
int vlanId = 0;
IfL2vlan l2vlan = iface.augmentation(IfL2vlan.class);
if (l2vlan != null && l2vlan.getVlanId() != null) {
// incrementing instructionSize and using it as actionKey. Because
// it won't clash with any other instructions
int actionKey = ++serviceInstructionsSize;
- instructionSet.add(MDSALUtil.buildAndGetPopVlanActionInstruction(actionKey, ++serviceInstructionsSize));
+ instructionSet.put(MDSALUtil.buildAndGetPopVlanActionInstruction(actionKey,
+ ++serviceInstructionsSize).key(), MDSALUtil.buildAndGetPopVlanActionInstruction(actionKey,
+ ++serviceInstructionsSize));
}
if (lportTag != 0L) {
Uint64 metadataMask = MetaDataUtil.getMetaDataMaskForLPortDispatcher(
MetaDataUtil.METADATA_MASK_SERVICE_INDEX, MetaDataUtil.METADATA_MASK_LPORT_TAG_SH_FLAG,
metadataValues[1]);
- instructionSet.add(
+ instructionSet.put(
+ MDSALUtil.buildAndGetWriteMetadaInstruction(metadata, metadataMask,
+ ++serviceInstructionsSize).key(),
MDSALUtil.buildAndGetWriteMetadaInstruction(metadata, metadataMask, ++serviceInstructionsSize));
}
if (instructions != null && !instructions.isEmpty()) {
- for (Instruction info : instructions) {
+ for (Instruction info : instructions.values()) {
// Skip meta data write as that is handled already
if (info.getInstruction() instanceof WriteMetadataCase) {
continue;
info = MDSALUtil.buildApplyActionsInstruction(ActionConverterUtil.convertServiceActionToFlowAction(
((ApplyActionsCase) info.getInstruction()).getApplyActions().getAction()));
}
- instructionSet.add(info);
+ instructions.put(info.key(),info);
}
}
.child(Node.class, nodeDpn.key()).augmentation(FlowCapableNode.class)
.child(Table.class, new TableKey(flow.getTableId())).child(Flow.class, flowKey).build();
- writeTransaction.put(flowInstanceId, flow, CREATE_MISSING_PARENTS);
+ writeTransaction.mergeParentStructurePut(flowInstanceId, flow);
EVENT_LOGGER.debug("IFM,InstallFlow {}", flow.getId());
}
// Get the metadata and mask from the service's write metadata
// instruction
StypeOpenflow stypeOpenFlow = boundService.augmentation(StypeOpenflow.class);
- List<Instruction> serviceInstructions = stypeOpenFlow.getInstruction();
+ @Nullable Map<InstructionKey, Instruction> serviceInstructions = stypeOpenFlow.getInstruction();
int instructionSize = serviceInstructions != null ? serviceInstructions.size() : 0;
Uint64[] metadataValues = IfmUtil.mergeOpenflowMetadataWriteInstructions(serviceInstructions);
- Uint64 metadata = MetaDataUtil.getMetaDataForLPortDispatcher(interfaceTag, nextServiceIndex,
- metadataValues[0]);
+ Uint64 metadata = MetaDataUtil.getMetaDataForLPortDispatcher(interfaceTag, nextServiceIndex, metadataValues[0]);
Uint64 metadataMask = MetaDataUtil.getWriteMetaDataMaskForDispatcherTable();
// build the final instruction for LPort Dispatcher table flow entry
- List<Instruction> instructions = new ArrayList<>();
- instructions.add(MDSALUtil.buildAndGetWriteMetadaInstruction(metadata, metadataMask, ++instructionSize));
+ Map<InstructionKey, Instruction> instructions = new HashMap<>();
+ instructions.put(MDSALUtil.buildAndGetWriteMetadaInstruction(metadata, metadataMask, ++instructionSize).key(),
+ MDSALUtil.buildAndGetWriteMetadaInstruction(metadata, metadataMask, ++instructionSize));
if (serviceInstructions != null && !serviceInstructions.isEmpty()) {
- for (Instruction info : serviceInstructions) {
+ for (Instruction info : serviceInstructions.values()) {
// Skip meta data write as that is handled already
if (info.getInstruction() instanceof WriteMetadataCase) {
continue;
info = MDSALUtil.buildApplyActionsInstruction(ActionConverterUtil.convertServiceActionToFlowAction(
((ApplyActionsCase) info.getInstruction()).getApplyActions().getAction()));
}
- instructions.add(info);
+ //instructions.values().add(info);
+ instructions.put(info.key(),info);
}
}
LOG.warn("Could not install egress dispatcher flow, missing service openflow configuration");
return;
}
- List<Instruction> serviceInstructions = stypeOpenflow.getInstruction() != null
+ Map<InstructionKey, Instruction> serviceInstructions = stypeOpenflow.getInstruction() != null
? stypeOpenflow.getInstruction()
- : Collections.emptyList();
+ : Collections.emptyMap();
// build the final instruction for LPort Dispatcher table flow entry
List<Action> finalApplyActions = new ArrayList<>();
- List<Instruction> instructions = new ArrayList<>();
+ Map<InstructionKey, Instruction> instructions = new HashMap<>();
if (boundService.getServicePriority().toJava() != ServiceIndex.getIndex(NwConstants.DEFAULT_EGRESS_SERVICE_NAME,
NwConstants.DEFAULT_EGRESS_SERVICE_INDEX)) {
Uint64[] metadataValues = IfmUtil.mergeOpenflowMetadataWriteInstructions(serviceInstructions);
Uint64 metadataMask = MetaDataUtil.getWriteMetaDataMaskForEgressDispatcherTable();
- instructions.add(MDSALUtil.buildAndGetWriteMetadaInstruction(metadataValues[0], metadataMask,
- instructions.size()));
+ instructions.put(MDSALUtil.buildAndGetWriteMetadaInstruction(metadataValues[0], metadataMask,
+ instructions.size()).key(),MDSALUtil.buildAndGetWriteMetadaInstruction(metadataValues[0],
+ metadataMask, instructions.size()));
finalApplyActions.add(MDSALUtil.createSetReg6Action(finalApplyActions.size(), 0, 31,
MetaDataUtil.getReg6ValueForLPortDispatcher(interfaceTag, nextServiceIndex)));
}
final int applyActionsOffset = finalApplyActions.size();
- for (Instruction info : serviceInstructions) {
+ for (Instruction info : serviceInstructions.values()) {
if (info.getInstruction() instanceof WriteActionsCase) {
List<Action> writeActions = ActionConverterUtil.convertServiceActionToFlowAction(
((WriteActionsCase) info.getInstruction()).getWriteActions().getAction());
- instructions.add(MDSALUtil.buildWriteActionsInstruction(writeActions, instructions.size()));
+ instructions.put(MDSALUtil.buildWriteActionsInstruction(writeActions, instructions.size()).key(),
+ MDSALUtil.buildWriteActionsInstruction(writeActions, instructions.size()));
} else if (info.getInstruction() instanceof ApplyActionsCase) {
List<Action> applyActions = ActionConverterUtil.convertServiceActionToFlowAction(
((ApplyActionsCase) info.getInstruction()).getApplyActions().getAction(),
finalApplyActions.addAll(applyActions);
} else if (!(info.getInstruction() instanceof WriteMetadataCase)) {
// Skip meta data write as that is handled already
- instructions.add(MDSALUtil.buildInstruction(info, instructions.size()));
+ instructions.put(MDSALUtil.buildInstruction(info, instructions.size()).key(),
+ MDSALUtil.buildInstruction(info, instructions.size()));
}
}
if (!finalApplyActions.isEmpty()) {
- instructions.add(MDSALUtil.buildApplyActionsInstruction(finalApplyActions, instructions.size()));
+ instructions.put(MDSALUtil.buildApplyActionsInstruction(finalApplyActions, instructions.size()).key(),
+ MDSALUtil.buildApplyActionsInstruction(finalApplyActions, instructions.size()));
}
// build the flow and install it
}
int instructionKey = 0;
- List<Instruction> instructions = new ArrayList<>();
+ Map<InstructionKey, Instruction> instructions = new HashMap<>();
final SplitHorizon splitHorizon = iface.augmentation(SplitHorizon.class);
boolean overrideSplitHorizonProtection = splitHorizon != null
actions.add(MDSALUtil.createNxOfInPortAction(++actionKey, 0));
}
if (!actions.isEmpty()) {
- instructions.add(MDSALUtil.buildApplyActionsInstruction(actions, instructionKey++));
+ instructions.put(MDSALUtil.buildApplyActionsInstruction(actions, instructionKey++).key(),
+ MDSALUtil.buildApplyActionsInstruction(actions, instructionKey++));
}
Uint64 metadata = MetaDataUtil.getMetaDataForLPortDispatcher(lportTag, (short) 0, Uint64.ZERO,
isExternal(iface));
Uint64 metadataMask = MetaDataUtil
.getMetaDataMaskForLPortDispatcher(MetaDataUtil.METADATA_MASK_LPORT_TAG_SH_FLAG);
- instructions.add(MDSALUtil.buildAndGetWriteMetadaInstruction(metadata, metadataMask, instructionKey++));
- instructions
- .add(MDSALUtil.buildAndGetGotoTableInstruction(NwConstants.LPORT_DISPATCHER_TABLE, instructionKey++));
+ instructions.put(MDSALUtil.buildAndGetWriteMetadaInstruction(metadata, metadataMask, instructionKey++).key(),
+ MDSALUtil.buildAndGetWriteMetadaInstruction(metadata, metadataMask, instructionKey++));
+ instructions.put(MDSALUtil.buildAndGetGotoTableInstruction(NwConstants.LPORT_DISPATCHER_TABLE,
+ instructionKey++).key(),
+ MDSALUtil.buildAndGetGotoTableInstruction(NwConstants.LPORT_DISPATCHER_TABLE, instructionKey++));
int priority = isVlanTransparent ? 1
: vlanId == 0 ? IfmConstants.FLOW_PRIORITY_FOR_UNTAGGED_VLAN : IfmConstants.FLOW_HIGH_PRIORITY;
String flowRef = getFlowRef(IfmConstants.VLAN_INTERFACE_INGRESS_TABLE, dpId, iface.getName());
InstanceIdentifier<BoundServicesState> id = InstanceIdentifier.builder(BoundServicesStateList.class)
.child(BoundServicesState.class, new BoundServicesStateKey(interfaceName,
interfaceBoundServicesState.getServiceMode())).build();
- tx.put(id, interfaceBoundServicesState, CREATE_MISSING_PARENTS);
+ tx.mergeParentStructurePut(id, interfaceBoundServicesState);
}
public static void removeBoundServicesState(TypedWriteTransaction<Operational> tx,
OvsdbTerminationPointAugmentationBuilder newOvsdbTpAugmentationBuilder =
new OvsdbTerminationPointAugmentationBuilder(ovsdbTpAugmentation);
if (ovsdbTpAugmentation.getOptions() != null) {
- List<Options> options = new ArrayList<>(ovsdbTpAugmentation.getOptions());
+ List<Options> options = new ArrayList<>(ovsdbTpAugmentation.getOptions().values());
options.sort(Comparator.comparing(o -> o.key().toString()));
newOvsdbTpAugmentationBuilder.setOptions(options);
}
if (ovsdbTpAugmentation.getInterfaceBfd() != null) {
- List<InterfaceBfd> interfaceBfd = new ArrayList<>(ovsdbTpAugmentation.getInterfaceBfd());
+ List<InterfaceBfd> interfaceBfd = new ArrayList<>(ovsdbTpAugmentation.getInterfaceBfd().values());
interfaceBfd.sort(Comparator.comparing(o -> o.key().toString()));
newOvsdbTpAugmentationBuilder.setInterfaceBfd(interfaceBfd);
}
if (interfaceType != null) {
entryBuilder.setInterfaceType(interfaceType);
}
- tx.put(LogicalDatastoreType.OPERATIONAL, intfid, entryBuilder.build(), true);
+ tx.mergeParentStructurePut(LogicalDatastoreType.OPERATIONAL, intfid, entryBuilder.build());
tx.commit().get();
}
}
import com.google.common.util.concurrent.ListeningExecutorService;
import com.google.common.util.concurrent.MoreExecutors;
-
import java.util.concurrent.Executors;
import org.opendaylight.daexim.DataImportBootReady;
import org.opendaylight.genius.datastoreutils.listeners.DataTreeEventCallbackRegistrar;
bind(ServiceRecoveryRegistry.class).toInstance(mock(ServiceRecoveryRegistry.class));
EntityOwnershipService entityOwnershipService = new BindingDOMEntityOwnershipServiceAdapter(
new SimpleDOMEntityOwnershipService(),
- test.getDataBrokerTestCustomizer().getBindingToNormalized());
+ test.getDataBrokerTestCustomizer().getAdapterContext());
bind(EntityOwnershipService.class).toInstance(entityOwnershipService);
bind(EntityOwnershipUtils.class);
bind(AlivenessMonitorService.class).toInstance(mock(AlivenessMonitorService.class));
import java.util.Arrays;
import java.util.List;
import java.util.concurrent.ExecutionException;
-
import org.awaitility.core.ConditionTimeoutException;
import org.opendaylight.genius.datastoreutils.testutils.AsyncEventsWaiter;
import org.opendaylight.genius.datastoreutils.testutils.JobCoordinatorCountedEventsWaiter;
}
InstanceIdentifier<Interface> interfaceInstanceIdentifier = IfmUtil.buildId(ifaceName);
WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
- tx.put(CONFIGURATION, interfaceInstanceIdentifier, interfaceInfo, true);
+ tx.mergeParentStructurePut(CONFIGURATION, interfaceInstanceIdentifier, interfaceInfo);
tx.commit().get();
}
true, L2vlan.class, parentRefs, l2vlanMode);
InstanceIdentifier<Interface> interfaceInstanceIdentifier = IfmUtil.buildId(ifaceName);
WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
- tx.put(CONFIGURATION, interfaceInstanceIdentifier, interfaceInfo, true);
+ tx.mergeParentStructurePut(CONFIGURATION, interfaceInstanceIdentifier, interfaceInfo);
tx.commit().get();
}
long portNo = Tunnel.class.equals(ifType) ? PORT_NO_1 : PORT_NO_1;
NodeConnector nodeConnector = InterfaceManagerTestUtil
.buildFlowCapableNodeConnector(buildNodeConnectorId(dpnId, portNo), interfaceName, true);
- tx.put(OPERATIONAL,buildNodeConnectorInstanceIdentifier(dpnId, portNo), nodeConnector, true);
+ tx.mergeParentStructurePut(OPERATIONAL,buildNodeConnectorInstanceIdentifier(dpnId, portNo), nodeConnector);
tx.commit().get();
}
long portNo = Tunnel.class.equals(ifType) ? PORT_NO_1 : PORT_NO_1;
NodeConnector nodeConnector = InterfaceManagerTestUtil
.buildFlowCapableNodeConnector(buildNodeConnectorId(dpnId, portNo), interfaceName, isLive);
- tx.merge(OPERATIONAL,buildNodeConnectorInstanceIdentifier(dpnId, portNo), nodeConnector, true);
+ tx.mergeParentStructureMerge(OPERATIONAL,buildNodeConnectorInstanceIdentifier(dpnId, portNo), nodeConnector);
tx.commit().get();
}
bridgeCreateNodeBuilder.addAugmentation(OvsdbBridgeAugmentation.class, bridgeCreateAugmentationBuilder.build());
LOG.debug("Built with the intent to store bridge data {}", bridgeCreateAugmentationBuilder.toString());
WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
- tx.put(LogicalDatastoreType.OPERATIONAL, ovsdbBridgeIid, bridgeCreateAugmentationBuilder.build(), true);
+ tx.mergeParentStructurePut(LogicalDatastoreType.OPERATIONAL, ovsdbBridgeIid,
+ bridgeCreateAugmentationBuilder.build());
tx.commit().get();
}
bridgeCreateNodeBuilder.addAugmentation(OvsdbBridgeAugmentation.class, bridgeCreateAugmentationBuilder.build());
LOG.debug("Built with the intent to store bridge data {}", bridgeCreateAugmentationBuilder.toString());
WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
- tx.merge(LogicalDatastoreType.OPERATIONAL, ovsdbBridgeIid, bridgeCreateAugmentationBuilder.build(), true);
+ tx.mergeParentStructureMerge(LogicalDatastoreType.OPERATIONAL, ovsdbBridgeIid,
+ bridgeCreateAugmentationBuilder.build());
tx.commit().get();
}
}
tpBuilder.addAugmentation(OvsdbTerminationPointAugmentation.class, tpAugmentationBuilder.build());
WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
- tx.put(OPERATIONAL, tpId, tpBuilder.build(), true);
+ tx.mergeParentStructurePut(OPERATIONAL, tpId, tpBuilder.build());
tx.commit().get();
}
tpAugmentationBuilder.setInterfaceBfdStatus(interfaceBfdStatuses);
tpBuilder.addAugmentation(OvsdbTerminationPointAugmentation.class, tpAugmentationBuilder.build());
WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
- tx.merge(OPERATIONAL, tpId, tpBuilder.build(), true);
+ tx.mergeParentStructureMerge(OPERATIONAL, tpId, tpBuilder.build());
tx.commit().get();
}
String remoteIp = UNSET;
String localIp = UNSET;
String key = UNSET;
- for (Options portOption: port.nonnullOptions()) {
+ for (Options portOption: port.nonnullOptions().values()) {
switch (portOption.getOption()) {
case "local_ip":
localIp = portOption.getValue();
package org.opendaylight.genius.interfacemanager.shell;
import java.util.List;
-
import org.apache.karaf.shell.commands.Command;
import org.apache.karaf.shell.console.OsgiCommandSupport;
import org.opendaylight.genius.interfacemanager.globals.InterfaceInfo;
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>6.0.4</version>
+ <version>7.0.1</version>
<relativePath/>
</parent>
int localErrorCount = 0;
targetIpv6Address = ndInput.getTargetIpAddress();
- for (InterfaceAddress interfaceAddress : ndInput.nonnullInterfaceAddress()) {
+ for (InterfaceAddress interfaceAddress : ndInput.nonnullInterfaceAddress().values()) {
try {
interfaceName = interfaceAddress.getInterface();
srcIpv6Address = interfaceAddress.getSrcIpAddress();
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>6.0.4</version>
+ <version>7.0.1</version>
<relativePath/>
</parent>
<dependency>
<groupId>org.immutables</groupId>
<artifactId>value</artifactId>
+ <classifier>annotations</classifier>
</dependency>
</dependencies>
</project>
<dependency>
<groupId>javax.inject</groupId>
<artifactId>javax.inject</artifactId>
+ <scope>provided</scope>
<optional>true</optional>
</dependency>
<dependency>
@Override
protected void added(InstanceIdentifier<DpnsTeps> path, DpnsTeps dpnsTeps) {
String srcOfTunnel = dpnsTeps.getOfTunnel();
- for (RemoteDpns remoteDpns : dpnsTeps.nonnullRemoteDpns()) {
+ for (RemoteDpns remoteDpns : dpnsTeps.nonnullRemoteDpns().values()) {
final String dpn = getDpnId(dpnsTeps.getSourceDpnId(), remoteDpns.getDestinationDpnId());
DpnTepInterfaceInfo value = new DpnTepInterfaceInfoBuilder()
.setTunnelName(remoteDpns.getTunnelName())
@Override
protected void removed(InstanceIdentifier<DpnsTeps> path, DpnsTeps dpnsTeps) {
- for (RemoteDpns remoteDpns : dpnsTeps.nonnullRemoteDpns()) {
+ for (RemoteDpns remoteDpns : dpnsTeps.nonnullRemoteDpns().values()) {
String fwkey = getDpnId(dpnsTeps.getSourceDpnId(), remoteDpns.getDestinationDpnId());
dpnTepInterfaceMap.remove(fwkey);
tunnelEndpointMap.remove(remoteDpns.getTunnelName());
Optional<DpnsTeps> dpnsTeps = super.get(srcDpnId);
if (dpnsTeps.isPresent()) {
DpnsTeps teps = dpnsTeps.get();
- teps.nonnullRemoteDpns().forEach(remoteDpns -> {
+ teps.nonnullRemoteDpns().values().forEach(remoteDpns -> {
DpnTepInterfaceInfo value = new DpnTepInterfaceInfoBuilder()
.setTunnelName(remoteDpns.getTunnelName())
.setIsMonitoringEnabled(remoteDpns.isMonitoringEnabled())
Collection<DpnsTeps> dpnsTeps = this.getAllPresent();
for (DpnsTeps dpnTep : dpnsTeps) {
if (!Objects.equals(dpnTep.getSourceDpnId(), srcDpnId)) {
- for (RemoteDpns remoteDpns : dpnTep.nonnullRemoteDpns()) {
+ for (RemoteDpns remoteDpns : dpnTep.nonnullRemoteDpns().values()) {
if (Objects.equals(remoteDpns.getDestinationDpnId(), srcDpnId)) {
// Remote the SrcDpnId from the remote List. Remove it from COnfig DS. 4
// This will be reflected in cache by the ClusteredDTCN. Not removing it here !
import java.util.Optional;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.atomic.AtomicInteger;
+import java.util.stream.Collectors;
import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import javax.inject.Inject;
ItmUtils.read(LogicalDatastoreType.CONFIGURATION, tzonePath, dataBroker);
if (transportZoneOptional.isPresent()) {
TransportZone tz = transportZoneOptional.get();
- for (Vteps vtep : tz.getVteps()) {
+ for (Vteps vtep : tz.getVteps().values()) {
if (Objects.equals(vtep.getDpnId(), dpnId)) {
return true;
}
LOG.debug("tzone object {}", transportZone);
transportZoneArrayList.add(transportZone);
}
- TransportZones transportZones =
- new TransportZonesBuilder().setTransportZone(transportZoneArrayList).build();
+ TransportZones transportZones = new TransportZonesBuilder()
+ .setTransportZone(transportZoneArrayList.stream().collect(Collectors.toList())).build();
InstanceIdentifier<TransportZones> path = InstanceIdentifier.builder(TransportZones.class).build();
LOG.debug("InstanceIdentifier {}", path);
Futures.addCallback(txRunner.callWithNewWriteOnlyTransactionAndSubmit(CONFIGURATION,
- tx -> tx.merge(path, transportZones, true)), ItmUtils.DEFAULT_WRITE_CALLBACK,
- MoreExecutors.directExecutor());
+ tx -> tx.mergeParentStructureMerge(path, transportZones)), ItmUtils.DEFAULT_WRITE_CALLBACK,
+ MoreExecutors.directExecutor());
LOG.debug("wrote to Config DS {}", transportZones);
transportZonesHashMap.clear();
transportZoneArrayList.clear();
if (tz.getVteps() == null || tz.getVteps().isEmpty()) {
continue;
}
- for (Vteps vtep : tz.getVteps()) {
+ for (Vteps vtep : tz.getVteps().values()) {
flag = true;
String strTunnelType ;
if (TunnelTypeGre.class.equals(tz.getTunnelType())) {
allPaths.addAll(subnetPaths);
Futures.addCallback(txRunner.callWithNewWriteOnlyTransactionAndSubmit(Datastore.CONFIGURATION,
tx -> allPaths.forEach(tx::delete)), ItmUtils.DEFAULT_WRITE_CALLBACK,
- MoreExecutors.directExecutor());
+ MoreExecutors.directExecutor());
}
vtepPaths.clear();
subnetPaths.clear();
.setMonitorProtocol(monitorType).build();
Futures.addCallback(txRunner.callWithNewWriteOnlyTransactionAndSubmit(CONFIGURATION,
tx -> tx.merge(path, tunnelMonitor)), ItmUtils.DEFAULT_WRITE_CALLBACK,
- MoreExecutors.directExecutor());
+ MoreExecutors.directExecutor());
}
}
if (!storedTunnelMonitor.isPresent() || storedTunnelMonitor.get().getInterval().toJava() != interval) {
TunnelMonitorInterval tunnelMonitor = new TunnelMonitorIntervalBuilder().setInterval(interval).build();
Futures.addCallback(txRunner.callWithNewWriteOnlyTransactionAndSubmit(CONFIGURATION,
- tx -> tx.merge(path, tunnelMonitor, true)), ItmUtils.DEFAULT_WRITE_CALLBACK,
- MoreExecutors.directExecutor());
+ tx -> tx.mergeParentStructureMerge(path, tunnelMonitor)), ItmUtils.DEFAULT_WRITE_CALLBACK,
+ MoreExecutors.directExecutor());
}
}
InstanceIdentifier<Interface> trunkIdentifier = ItmUtils.buildId(trunkInterfaceName);
LOG.debug(" Trunk Interface Identifier - {} ", trunkIdentifier);
LOG.trace(" Writing Trunk Interface to Config DS {}, {} ", trunkIdentifier, iface);
- tx.merge(trunkIdentifier, iface, true);
+ tx.mergeParentStructureMerge(trunkIdentifier, iface);
// update external_tunnel_list ds
InstanceIdentifier<ExternalTunnel> path = InstanceIdentifier.create(ExternalTunnelList.class)
.child(ExternalTunnel.class, new ExternalTunnelKey(extIp.stringValue(),
teps.getDPNID().toString(), tunType));
ExternalTunnel tnl = ItmUtils.buildExternalTunnel(teps.getDPNID().toString(),
extIp.stringValue(), tunType, trunkInterfaceName);
- tx.merge(path, tnl, true);
+ tx.mergeParentStructureMerge(path, tnl);
ItmUtils.ITM_CACHE.addExternalTunnel(tnl);
}
LOG.trace("processing dpn {}", dpn);
if (dpn.getTunnelEndPoints() != null && !dpn.getTunnelEndPoints().isEmpty()) {
for (TunnelEndPoints tep : dpn.getTunnelEndPoints()) {
- for (TzMembership zone : tep.nonnullTzMembership()) {
+ for (TzMembership zone : tep.nonnullTzMembership().values()) {
try {
createTunnelsFromOVSinTransportZone(zone.getZoneName(), dpn, tep, tx, monitorInterval,
monitorProtocol);
String portName = itmConfig.getPortname() == null ? ITMConstants.DUMMY_PORT : itmConfig.getPortname();
int vlanId = itmConfig.getVlanId() != null ? itmConfig.getVlanId().toJava()
: ITMConstants.DUMMY_VLANID;
- for (DeviceVteps hwVtepDS : transportZone.getDeviceVteps()) {
+ for (DeviceVteps hwVtepDS : transportZone.getDeviceVteps().values()) {
//dont mesh if hwVteps and OVS-tep have same ip-address
if (Objects.equals(hwVtepDS.getIpAddress(), tep.getIpAddress())) {
continue;
int vlanId = itmConfig.getVlanId() != null ? itmConfig.getVlanId().toJava() : ITMConstants.DUMMY_VLANID;
//do we need to check tunnel type?
if (tzone.getDeviceVteps() != null && !tzone.getDeviceVteps().isEmpty()) {
- for (DeviceVteps hwVtepDS : tzone.getDeviceVteps()) {
+ for (DeviceVteps hwVtepDS : tzone.getDeviceVteps().values()) {
if (Objects.equals(hwVtepDS.getIpAddress(), hwTep.getHwIp())) {
continue;//dont mesh with self
}
}
}
}
- for (Vteps vtep : tzone.getVteps()) {
+ for (Vteps vtep : tzone.getVteps().values()) {
if (Objects.equals(vtep.getIpAddress(), hwTep.getHwIp())) {
continue;
}
.child(Interface.class, new InterfaceKey(tunnelIfName)).build();
LOG.trace(" Writing Trunk Interface to Config DS {}, {} ", ifIID, hwTunnelIf);
ItmUtils.ITM_CACHE.addInterface(hwTunnelIf);
- tx.merge(ifIID, hwTunnelIf, true);
+ tx.mergeParentStructureMerge(ifIID, hwTunnelIf);
// also update itm-state ds?
InstanceIdentifier<ExternalTunnel> path = InstanceIdentifier.create(ExternalTunnelList.class)
.child(ExternalTunnel.class, new ExternalTunnelKey(getExternalTunnelKey(dstNodeId),
getExternalTunnelKey(srcNodeid), tunType));
ExternalTunnel tnl = ItmUtils.buildExternalTunnel(getExternalTunnelKey(srcNodeid),
getExternalTunnelKey(dstNodeId), tunType, tunnelIfName);
- tx.merge(path, tnl, true);
+ tx.mergeParentStructureMerge(path, tnl);
ItmUtils.ITM_CACHE.addExternalTunnel(tnl);
return true;
}
InstanceIdentifier<Interface> ifIID = InstanceIdentifier.builder(Interfaces.class).child(Interface.class,
new InterfaceKey(tunnelIfName)).build();
LOG.trace(" Writing Trunk Interface to Config DS {}, {} ", ifIID, extTunnelIf);
- tx.merge(ifIID, extTunnelIf, true);
+ tx.mergeParentStructureMerge(ifIID, extTunnelIf);
ItmUtils.ITM_CACHE.addInterface(extTunnelIf);
InstanceIdentifier<ExternalTunnel> path = InstanceIdentifier.create(ExternalTunnelList.class)
.child(ExternalTunnel.class, new ExternalTunnelKey(getExternalTunnelKey(dstNodeId),
ExternalTunnel tnl = ItmUtils.buildExternalTunnel(dpnId.toString(),
getExternalTunnelKey(dstNodeId),
tunType, tunnelIfName);
- tx.merge(path, tnl, true);
+ tx.mergeParentStructureMerge(path, tnl);
ItmUtils.ITM_CACHE.addExternalTunnel(tnl);
return true;
}
import java.util.Collection;
import java.util.List;
+import java.util.Map;
import java.util.Objects;
import java.util.Optional;
import java.util.concurrent.ExecutionException;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.genius.infra.Datastore.Configuration;
import org.opendaylight.genius.infra.TypedReadWriteTransaction;
import org.opendaylight.genius.infra.TypedWriteTransaction;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.dpn.endpoints.DPNTEPsInfo;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.dpn.endpoints.dpn.teps.info.TunnelEndPoints;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.dpn.endpoints.dpn.teps.info.tunnel.end.points.TzMembership;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.dpn.endpoints.dpn.teps.info.tunnel.end.points.TzMembershipKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.external.tunnel.list.ExternalTunnel;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.TransportZones;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.TransportZone;
TunnelEndPoints firstEndPt = teps.getTunnelEndPoints().get(0);
// The membership in the listener will always be 1, to get the actual membership
// read from the DS
- List<TzMembership> originalTzMembership = ItmUtils.getOriginalTzMembership(firstEndPt,
- teps.getDPNID(), meshedDpnList);
+ @NonNull Map<TzMembershipKey, TzMembership> originalTzMembership =
+ ItmUtils.getOriginalTzMembership(firstEndPt, teps.getDPNID(), meshedDpnList);
if (originalTzMembership.size() == 1) {
String interfaceName = firstEndPt.getInterfaceName();
String trunkInterfaceName = ItmUtils.getTrunkInterfaceName(interfaceName,
for (DPNTEPsInfo dpn : cfgdDpnList) {
if (dpn.getTunnelEndPoints() != null) {
for (TunnelEndPoints srcTep : dpn.getTunnelEndPoints()) {
- for (TzMembership zone : srcTep.nonnullTzMembership()) {
+ for (TzMembership zone : srcTep.nonnullTzMembership().values()) {
deleteTunnelsInTransportZone(zone.getZoneName(), dpn, srcTep, cfgdhwVteps, tx);
}
}
}
// do we need to check tunnel type?
if (originalTZone.getDeviceVteps() != null) {
- for (DeviceVteps hwVtepDS : originalTZone.getDeviceVteps()) {
+ for (DeviceVteps hwVtepDS : originalTZone.getDeviceVteps().values()) {
LOG.trace("hwtepDS exists {}", hwVtepDS);
// do i need to check node-id?
// for mlag case and non-m-lag case, isnt it enough to just check ipaddress?
int vlanId = itmConfig.getVlanId() != null ? itmConfig.getVlanId().toJava()
: ITMConstants.DUMMY_VLANID;
- for (Vteps vtep : originalTZone.getVteps()) {
+ for (Vteps vtep : originalTZone.getVteps().values()) {
// TOR-OVS
LOG.trace("deleting tor-css-tor {} and {}", hwTep, vtep);
String parentIf = ItmUtils.getInterfaceName(vtep.getDpnId(), portName, vlanId);
TransportZone tzone = tz.get();
// do we need to check tunnel type?
if (tzone.getDeviceVteps() != null) {
- for (DeviceVteps hwVtepDS : tzone.getDeviceVteps()) {
+ for (DeviceVteps hwVtepDS : tzone.getDeviceVteps().values()) {
// OVS-TOR-OVS
deleteTrunksOvsTor(dpn.getDPNID(), srcTep.getInterfaceName(),
srcTep.getIpAddress(), hwVtepDS.getTopologyId(), hwVtepDS.getNodeId(),
import static java.util.Collections.singletonList;
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
-import static org.opendaylight.mdsal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
import com.google.common.util.concurrent.ListenableFuture;
import java.time.Duration;
// Switching to individual transaction submit as batching latencies is causing ELAN failures.
// Will revert when ELAN can handle this.
// ITMBatchingUtils.update(path, tnl, ITMBatchingUtils.EntityType.DEFAULT_CONFIG);
- tx.merge(path, tnl, CREATE_MISSING_PARENTS);
+ tx.mergeParentStructureMerge(path, tnl);
ItmUtils.ITM_CACHE.addInternalTunnel(tnl);
}
import java.util.Collection;
import java.util.Collections;
import java.util.List;
+import java.util.Map;
import java.util.Objects;
import java.util.Optional;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.genius.cloudscaler.api.TombstonedNodeManager;
import org.opendaylight.genius.infra.Datastore.Configuration;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.dpn.endpoints.dpn.teps.info.TunnelEndPoints;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.dpn.endpoints.dpn.teps.info.TunnelEndPointsBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.dpn.endpoints.dpn.teps.info.tunnel.end.points.TzMembership;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.dpn.endpoints.dpn.teps.info.tunnel.end.points.TzMembershipKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.tunnel.list.InternalTunnel;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.tunnel.list.InternalTunnelKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.tunnels_state.StateTunnelList;
for (TunnelEndPoints srcTep : srcDpn.nonnullTunnelEndPoints()) {
LOG.trace("Processing srcTep {}", srcTep);
Boolean isDpnTombstoned = tombstonedNodeManager.isDpnTombstoned(srcDpn.getDPNID());
- List<TzMembership> srcTZones = srcTep.nonnullTzMembership();
+ @NonNull Map<TzMembershipKey, TzMembership> srcTZones = srcTep.nonnullTzMembership();
boolean tepDeleteFlag = false;
// First, take care of tunnel removal, so run through all other DPNS other than srcDpn
// In the tep received from Delete DCN, the membership list will always be 1
if (!Objects.equals(srcDpn.getDPNID(), dstDpn.getDPNID())) {
for (TunnelEndPoints dstTep : dstDpn.nonnullTunnelEndPoints()) {
if (!ItmUtils.getIntersection(dstTep.nonnullTzMembership(), srcTZones).isEmpty()) {
- List<TzMembership> originalTzMembership =
+ Map<TzMembershipKey, TzMembership> originalTzMembership =
ItmUtils.getOriginalTzMembership(srcTep, srcDpn.getDPNID(), meshedDpnList);
if (ItmUtils.getIntersection(dstTep.getTzMembership(),
originalTzMembership).size() == 1) {
if (ovsBridgeEntryOptional.isPresent()) {
- List<OvsBridgeTunnelEntry> bridgeTunnelEntries = ovsBridgeEntryOptional.get().nonnullOvsBridgeTunnelEntry();
+ @NonNull Map<OvsBridgeTunnelEntryKey, OvsBridgeTunnelEntry> bridgeTunnelEntries =
+ ovsBridgeEntryOptional.get().nonnullOvsBridgeTunnelEntry();
if (ovsdbBridgeRef != null) {
if (!itmConfig.isUseOfTunnels()) {
}
private void deleteBridgeInterfaceEntry(OvsBridgeEntryKey bridgeEntryKey,
- List<OvsBridgeTunnelEntry> bridgeTunnelEntries,
+ Map<OvsBridgeTunnelEntryKey, OvsBridgeTunnelEntry> bridgeTunnelEntries,
InstanceIdentifier<OvsBridgeEntry> bridgeEntryIid,
String interfaceName) {
OvsBridgeTunnelEntryKey bridgeTunnelEntryKey = new OvsBridgeTunnelEntryKey(interfaceName);
List<RemoteDpns> remoteDpnTepNewList = new ArrayList<>();
RemoteDpns remoteDpnNew = null;
Optional<OvsBridgeRefEntry> ovsBridgeRefEntry = ovsBridgeRefEntryCache.get(dpnTeps.getSourceDpnId());
- for (RemoteDpns remoteDpn : dpnTeps.nonnullRemoteDpns()) {
+ for (RemoteDpns remoteDpn : dpnTeps.nonnullRemoteDpns().values()) {
if (enabled != null) {
LOG.debug("toggleMonitoring: tunnelInterfaceName: {}, monitorEnable = {} ",
remoteDpn.getTunnelName(), enabled);
Optional<DcGatewayIpList> optional = tx.read(InstanceIdentifier.builder(DcGatewayIpList.class)
.build()).get();
if (optional.isPresent()) {
- optional.get().getDcGatewayIp().forEach(dcGatewayIp ->
+ optional.get().getDcGatewayIp().values().forEach(dcGatewayIp ->
externalTunnelAddWorker.buildTunnelsToExternalEndPoint(cfgdDpnList, dcGatewayIp.getIpAddress(),
dcGatewayIp.getTunnnelType(), tx));
}
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
+import java.util.Map;
import java.util.Optional;
import java.util.concurrent.Callable;
+import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.genius.infra.Datastore;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.TypedReadWriteTransaction;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.dpn.endpoints.dpn.teps.info.TunnelEndPoints;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.DcGatewayIpList;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.dc.gateway.ip.list.DcGatewayIp;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.dc.gateway.ip.list.DcGatewayIpKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.TransportZone;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.Logger;
Optional<DcGatewayIpList> optional = tx.read(InstanceIdentifier.builder(DcGatewayIpList.class)
.build()).get();
if (optional.isPresent()) {
- List<DcGatewayIp> dcGatewayIpList = optional.get().getDcGatewayIp();
+ @Nullable Map<DcGatewayIpKey, DcGatewayIp> dcGatewayIpList = optional.get().getDcGatewayIp();
if (dcGatewayIpList != null && !dcGatewayIpList.isEmpty()) {
- processExternalTunnelTepDelete(dcGatewayIpList, tx);
+ processExternalTunnelTepDelete(dcGatewayIpList.values(), tx);
}
}
}
import com.google.common.util.concurrent.ListenableFuture;
import java.util.Collections;
import java.util.List;
+import java.util.Map;
import java.util.concurrent.Callable;
import org.opendaylight.genius.infra.Datastore;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.not.hosted.transport.zones.tepsinnothostedtransportzone.UnknownVteps;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.not.hosted.transport.zones.tepsinnothostedtransportzone.UnknownVtepsKey;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class ItmTepsNotHostedAddWorker implements Callable<List<? extends ListenableFuture<?>>> {
private static final Logger LOG = LoggerFactory.getLogger(ItmTepsNotHostedAddWorker.class);
- private final List<UnknownVteps> vtepsList;
+ private final Map<UnknownVtepsKey, UnknownVteps> vtepsList;
private final String tzName;
private final ManagedNewTransactionRunner txRunner;
- public ItmTepsNotHostedAddWorker(List<UnknownVteps> vtepsList, String tzName, DataBroker broker,
+ public ItmTepsNotHostedAddWorker(Map<UnknownVtepsKey, UnknownVteps> vtepsList, String tzName, DataBroker broker,
ManagedNewTransactionRunner txRunner) {
this.vtepsList = vtepsList;
this.tzName = tzName;
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
import static org.opendaylight.genius.infra.Datastore.OPERATIONAL;
-import static org.opendaylight.mdsal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
import com.google.common.util.concurrent.ListenableFuture;
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
+import java.util.Map;
import java.util.Objects;
import java.util.Optional;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import javax.inject.Inject;
import javax.inject.Singleton;
+import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.genius.infra.Datastore.Configuration;
import org.opendaylight.genius.infra.Datastore.Operational;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.TunnelTypeVxlan;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.config.rev160406.ItmConfig;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.config.rev160406.itm.config.TunnelAggregation;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.config.rev160406.itm.config.TunnelAggregationKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.tunnel.list.InternalTunnel;
import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.GroupTypes;
import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.group.buckets.Bucket;
// Load balancing of VxLAN feature is guarded by a global configuration option in the ITM,
// only when the feature is enabled, the logical tunnel interfaces should be created.
boolean tunnelAggregationConfigEnabled = false;
- List<TunnelAggregation> tunnelsConfig = itmConfig != null ? itmConfig.getTunnelAggregation() : null;
+ Map<TunnelAggregationKey, TunnelAggregation> tunnelsConfig = itmConfig != null
+ ? itmConfig.getTunnelAggregation() : null;
if (tunnelsConfig != null) {
- for (TunnelAggregation tnlCfg : tunnelsConfig) {
+ for (TunnelAggregation tnlCfg : tunnelsConfig.values()) {
Class<? extends TunnelTypeBase> tunType = ItmUtils.getTunnelType(tnlCfg.key().getTunnelType());
if (tunType.isAssignableFrom(TunnelTypeVxlan.class)) {
tunnelAggregationConfigEnabled = tnlCfg.isEnabled();
? interfaceManager.getLogicalTunnelSelectGroupId(ifLogicTunnel.getInterfaceTag()) : INVALID_ID;
Uint64 srcDpnId = logicInternalTunnel.getSourceDPN();
List<Bucket> listBuckets = new ArrayList<>();
- List<InterfaceChildEntry> interfaceChildEntries = parentEntry.getInterfaceChildEntry();
+ @Nullable Map<InterfaceChildEntryKey, InterfaceChildEntry> interfaceChildEntries =
+ parentEntry.getInterfaceChildEntry();
if (interfaceChildEntries == null || interfaceChildEntries.isEmpty()) {
LOG.debug("MULTIPLE_VxLAN_TUNNELS: empty child list in group {}", parentEntry.getParentInterface());
return;
}
- for (InterfaceChildEntry interfaceChildEntry : interfaceChildEntries) {
+ for (InterfaceChildEntry interfaceChildEntry : interfaceChildEntries.values()) {
String curChildName = interfaceChildEntry.getChildInterface();
org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface
childIface = ItmUtils.getInterface(curChildName, interfaceManager);
curChildName, groupId);
continue;
}
- int bucketId = interfaceChildEntries.indexOf(interfaceChildEntry);
+
+ List<InterfaceChildEntry> val = new ArrayList<>(interfaceChildEntries.values());
+ int bucketId = val.indexOf(interfaceChildEntry);
+
LOG.debug("MULTIPLE_VxLAN_TUNNELS: updateTunnelAggregationGroup - add bucketId {} to groupId {}",
bucketId, groupId);
listBuckets.add(createBucket(curChildName, ifTunnel, bucketId, ifInfo.getPortNo()));
int action, TypedReadWriteTransaction<Configuration> tx)
throws ExecutionException, InterruptedException {
String logicTunnelName = parentRefs.getParentInterface();
- List<InterfaceChildEntry> interfaceChildEntries = groupParentEntry.getInterfaceChildEntry();
+ @Nullable Map<InterfaceChildEntryKey, InterfaceChildEntry> interfaceChildEntries =
+ groupParentEntry.getInterfaceChildEntry();
if (interfaceChildEntries == null) {
LOG.debug("MULTIPLE_VxLAN_TUNNELS: empty child list in group {}", groupParentEntry.getParentInterface());
return;
String ifaceName = ifaceState.getName();
InterfaceChildEntry childEntry = new InterfaceChildEntryBuilder().setChildInterface(ifaceName)
.withKey(new InterfaceChildEntryKey(ifaceName)).build();
- int bucketId = interfaceChildEntries.indexOf(childEntry);
+ List<InterfaceChildEntry> val = new ArrayList<>(interfaceChildEntries.values());
+ int bucketId = val.indexOf(childEntry);
+
if (bucketId == -1) {
LOG.debug("MULTIPLE_VxLAN_TUNNELS: wrong child id for {} in group {}", ifaceName,
groupParentEntry.getParentInterface());
return OperStatus.Up;
}
- List<InterfaceChildEntry> interfaceChildEntries = parentEntry.getInterfaceChildEntry();
+ @Nullable Map<InterfaceChildEntryKey, InterfaceChildEntry> interfaceChildEntries =
+ parentEntry.getInterfaceChildEntry();
if (interfaceChildEntries == null || interfaceChildEntries.isEmpty()) {
LOG.debug("MULTIPLE_VxLAN_TUNNELS: OperStatus is Down, because of the empty child list in group {}",
parentEntry.getParentInterface());
return OperStatus.Down;
}
- for (InterfaceChildEntry interfaceChildEntry : interfaceChildEntries) {
+ for (InterfaceChildEntry interfaceChildEntry : interfaceChildEntries.values()) {
String curChildInterface = interfaceChildEntry.getChildInterface();
if (!Objects.equals(curChildInterface, ifaceState.getName())) {
InterfaceInfo ifInfo = interfaceManager.getInterfaceInfoFromOperationalDataStore(curChildInterface);
InstanceIdentifier<Interface> idLogicGroup = ItmUtils.buildStateInterfaceId(ifaceName);
InterfaceBuilder ifaceBuilderChild = new InterfaceBuilder(ifaceState);
ifaceBuilderChild.setOperStatus(st);
- tx.merge(idLogicGroup, ifaceBuilderChild.build(), CREATE_MISSING_PARENTS);
+ tx.mergeParentStructureMerge(idLogicGroup, ifaceBuilderChild.build());
}
@SuppressFBWarnings(value = "UPM_UNCALLED_PRIVATE_METHOD",
if (ifOrigin == null || ifUpdated == null || ifOrigin.getAdminStatus() == ifUpdated.getAdminStatus()) {
return;
}
- List<InterfaceChildEntry> interfaceChildEntries = parentEntry.getInterfaceChildEntry();
+ @Nullable Map<InterfaceChildEntryKey, InterfaceChildEntry> interfaceChildEntries =
+ parentEntry.getInterfaceChildEntry();
if (interfaceChildEntries == null || interfaceChildEntries.isEmpty()) {
LOG.debug("MULTIPLE_VxLAN_TUNNELS: empty child list in group {}", logicalTunnelName);
return;
}
- for (InterfaceChildEntry interfaceChildEntry : interfaceChildEntries) {
+ for (InterfaceChildEntry interfaceChildEntry : interfaceChildEntries.values()) {
String curChildInterface = interfaceChildEntry.getChildInterface();
updateInterfaceAdminStatus(curChildInterface, ifUpdated.getAdminStatus(), tx);
}
InterfaceBuilder ifaceBuilderChild = new InterfaceBuilder();
ifaceBuilderChild.withKey(new InterfaceKey(ifaceName));
ifaceBuilderChild.setAdminStatus(st);
- tx.merge(id, ifaceBuilderChild.build(), CREATE_MISSING_PARENTS);
+ tx.mergeParentStructureMerge(id, ifaceBuilderChild.build());
}
private class TunnelAggregationUpdateWorker implements Callable<List<? extends ListenableFuture<?>>> {
import com.google.common.util.concurrent.ListenableFuture;
import java.util.ArrayList;
import java.util.Collections;
+import java.util.HashMap;
import java.util.List;
+import java.util.Map;
import java.util.Objects;
import org.opendaylight.genius.infra.Datastore;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
.setZoneName(tzName).build();
// Update TZ in Config DS to add vtep in TZ
- tx.merge(tranzportZonePath, updatedTzone, true);
+ tx.mergeParentStructureMerge(tranzportZonePath, updatedTzone);
}
/**
protected static void addUnknownTzTepIntoTepsNotHosted(String tzName, IpAddress tepIpAddress,
Uint64 dpid, boolean ofTunnel, DataBroker dataBroker,
TypedWriteTransaction<Datastore.Operational> tx) {
- List<UnknownVteps> vtepList;
+ Map<UnknownVtepsKey, UnknownVteps> vtepList;
TepsInNotHostedTransportZone tepsInNotHostedTransportZone =
ItmUtils.getUnknownTransportZoneFromITMOperDS(tzName, dataBroker);
if (tepsInNotHostedTransportZone == null) {
LOG.trace("Unhosted TransportZone ({}) does not exist in OperDS.", tzName);
- vtepList = new ArrayList<>();
+ vtepList = new HashMap<>();
addVtepIntoTepsNotHosted(addVtepToUnknownVtepsList(vtepList, tepIpAddress, dpid, ofTunnel), tzName, tx);
} else {
vtepList = tepsInNotHostedTransportZone.getUnknownVteps();
// case: vtep list does not exist or it has no elements
if (vtepList == null) {
LOG.trace("Add TEP into unhosted TZ ({}) when no vtep-list in the TZ.", tzName);
- vtepList = new ArrayList<>();
+ vtepList = new HashMap<>();
}
LOG.trace("Add TEP into unhosted TZ ({}) when no vtep-list in the TZ.", tzName);
addVtepIntoTepsNotHosted(addVtepToUnknownVtepsList(vtepList, tepIpAddress, dpid, ofTunnel), tzName, tx);
boolean vtepFound = false;
UnknownVteps oldVtep = null;
- for (UnknownVteps vtep : vtepList) {
+ for (UnknownVteps vtep : vtepList.values()) {
if (Objects.equals(vtep.getDpnId(), dpid)) {
vtepFound = true;
oldVtep = vtep;
tepIpAddress, dpid, ofTunnel), tzName, tx);
} else {
// vtep is found, update it with tep-ip
- vtepList.remove(oldVtep);
+ vtepList.remove(oldVtep.key());
addVtepIntoTepsNotHosted(addVtepToUnknownVtepsList(vtepList,
tepIpAddress, dpid, ofTunnel), tzName, tx);
}
* @param tzName transport zone name in string
* @param tx TypedWriteTransaction object
*/
- protected static void addVtepIntoTepsNotHosted(List<UnknownVteps> updatedVtepList, String tzName,
+ protected static void addVtepIntoTepsNotHosted(Map<UnknownVtepsKey, UnknownVteps> updatedVtepList, String tzName,
TypedWriteTransaction<Datastore.Operational> tx) {
//Create TZ node path
InstanceIdentifier<TepsInNotHostedTransportZone> tepsInNotHostedTransportZoneIid =
.setUnknownVteps(updatedVtepList).build();
// Update TZ in Oper DS.
- tx.merge(tepsInNotHostedTransportZoneIid, updatedTzone, true);
+ tx.mergeParentStructureMerge(tepsInNotHostedTransportZoneIid, updatedTzone);
}
private static void addConfig(String tzName, Uint64 dpnId, IpAddress ipAdd,
tx -> addUnknownTzTepIntoTepsNotHosted(tzName, tepIpAddress, id, ofTunnel, dataBroker, tx)));
}
- private static List<UnknownVteps> addVtepToUnknownVtepsList(List<UnknownVteps> updatedVtepList,
- IpAddress tepIpAddress, Uint64 dpid,
- boolean ofTunnel) {
+ private static Map<UnknownVtepsKey, UnknownVteps> addVtepToUnknownVtepsList(Map<UnknownVtepsKey,
+ UnknownVteps> updatedVtepList, IpAddress tepIpAddress, Uint64 dpid, boolean ofTunnel) {
// create vtep
UnknownVtepsKey vtepkey = new UnknownVtepsKey(dpid);
UnknownVteps vtepObj =
.setOfTunnel(ofTunnel).build();
// Add vtep obtained into unknown TZ tep list
- updatedVtepList.add(vtepObj);
+ updatedVtepList.put(vtepObj.key(),vtepObj);
LOG.trace("Adding TEP (DPID: {}, TEP IP: {}, of-tunnel: {}) into unhosted Transport Zone"
+ "inside ITM Oper DS.", dpid, tepIpAddress, ofTunnel);
return updatedVtepList;
import com.google.common.util.concurrent.ListenableFuture;
import java.util.ArrayList;
import java.util.List;
+import java.util.Map;
import java.util.Objects;
+import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.genius.infra.Datastore;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.TypedWriteTransaction;
// Remove TEP from (default transport-zone) OR (transport-zone already configured by Northbound)
- List<Vteps> vtepList = transportZone.getVteps();
+ @Nullable Map<VtepsKey, Vteps> vtepList = transportZone.getVteps();
if (vtepList == null || vtepList.isEmpty()) {
// case: vtep list does not exist or it has no elements
LOG.trace("No vtep list in subnet list of transport-zone. Nothing to do.");
boolean vtepFound = false;
Vteps oldVtep = null;
- for (Vteps vtep : vtepList) {
+ for (Vteps vtep : vtepList.values()) {
if (Objects.equals(vtep.getDpnId(), dpnId)) {
vtepFound = true;
oldVtep = vtep;
public static void removeUnknownTzTepFromTepsNotHosted(String tzName, IpAddress tepIpAddress,
Uint64 dpnId, DataBroker dataBroker,
TypedWriteTransaction<Datastore.Operational> tx) {
- List<UnknownVteps> vtepList;
+ Map<UnknownVtepsKey, UnknownVteps> vtepList;
TepsInNotHostedTransportZone tepsInNotHostedTransportZone =
ItmUtils.getUnknownTransportZoneFromITMOperDS(tzName, dataBroker);
if (tepsInNotHostedTransportZone == null) {
// case: vtep list has elements
boolean vtepFound = false;
- for (UnknownVteps vtep : vtepList) {
+ for (UnknownVteps vtep : vtepList.values()) {
if (Objects.equals(vtep.getDpnId(), dpnId)) {
vtepFound = true;
break;
*/
package org.opendaylight.genius.itm.impl;
-import static java.util.Collections.emptyList;
+import static java.util.Collections.emptyMap;
import com.google.common.collect.BiMap;
import com.google.common.collect.ImmutableBiMap;
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.Objects;
import java.util.Optional;
import java.util.UUID;
import java.util.concurrent.ExecutionException;
import org.eclipse.jdt.annotation.NonNull;
+import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
import org.opendaylight.genius.infra.Datastore.Configuration;
import org.opendaylight.genius.infra.TypedReadWriteTransaction;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.dpn.endpoints.dpn.teps.info.TunnelEndPointsKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.dpn.endpoints.dpn.teps.info.tunnel.end.points.TzMembership;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.dpn.endpoints.dpn.teps.info.tunnel.end.points.TzMembershipBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.dpn.endpoints.dpn.teps.info.tunnel.end.points.TzMembershipKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.external.tunnel.list.ExternalTunnel;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.external.tunnel.list.ExternalTunnelBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.external.tunnel.list.ExternalTunnelKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.TransportZone;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.TransportZoneKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.transport.zone.Vteps;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.transport.zone.VtepsKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeAugmentation;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NetworkTopology;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;
public static <T extends DataObject> void syncWrite(LogicalDatastoreType datastoreType,
InstanceIdentifier<T> path, T data, DataBroker broker) {
WriteTransaction tx = broker.newWriteOnlyTransaction();
- tx.put(datastoreType, path, data, true);
+ tx.mergeParentStructurePut(datastoreType, path, data);
try {
tx.commit().get();
} catch (InterruptedException | ExecutionException e) {
return tunnelList;
}
- public static List<InternalTunnel> getInternalTunnelsFromCache(DataBroker dataBroker) {
+ public static Map<InternalTunnelKey, InternalTunnel> getInternalTunnelsFromCache(DataBroker dataBroker) {
Collection<InternalTunnel> internalInterfaces = ITM_CACHE.getAllInternalTunnel();
LOG.trace("getInternalTunnelsFromCache - List of InternalTunnels in the Cache: {} ", internalInterfaces);
- List<InternalTunnel> tunnelList = new ArrayList<>();
+ Map<InternalTunnelKey, InternalTunnel> tunnelList = new HashMap<>();
if (internalInterfaces.isEmpty()) {
LOG.trace("ItmUtils.getInternalTunnelsFromCache invoking getAllInternalTunnlInterfacesFromDS");
tunnelList = getAllInternalTunnels(dataBroker);
} else {
LOG.debug("No. of Internal Tunnel Interfaces in cache: {} ", internalInterfaces.size());
- tunnelList.addAll(internalInterfaces);
+ tunnelList.values().addAll(internalInterfaces);
}
LOG.trace("List of Internal Tunnels: {}", tunnelList);
return tunnelList;
return null;
}
- public static List<InternalTunnel> getAllInternalTunnels(DataBroker dataBroker) {
- List<InternalTunnel> result = null;
+ public static Map<InternalTunnelKey, InternalTunnel> getAllInternalTunnels(DataBroker dataBroker) {
+ Map<InternalTunnelKey, InternalTunnel> result = null;
InstanceIdentifier<TunnelList> iid = InstanceIdentifier.builder(TunnelList.class).build();
Optional<TunnelList> tunnelList = read(LogicalDatastoreType.CONFIGURATION, iid, dataBroker);
result = tunnelList.get().getInternalTunnel();
}
if (result == null) {
- result = emptyList();
+ result = emptyMap();
}
return result;
}
private static List<String> getAllInternalTunnlInterfacesFromDS(DataBroker broker) {
List<String> tunnelList = new ArrayList<>();
- List<InternalTunnel> internalTunnels = getAllInternalTunnels(broker);
+ Map<InternalTunnelKey, InternalTunnel> internalTunnels = getAllInternalTunnels(broker);
if (internalTunnels != null) {
- for (InternalTunnel tunnel : internalTunnels) {
+ for (InternalTunnel tunnel : internalTunnels.values()) {
List<String> tunnelInterfaceNames = tunnel.getTunnelInterfaceNames();
if (tunnelInterfaceNames != null) {
for (String tunnelInterfaceName : tunnelInterfaceNames) {
}
private static ExternalTunnel getExternalTunnelFromDS(String interfaceName, DataBroker broker) {
- List<ExternalTunnel> externalTunnels = getAllExternalTunnels(broker);
+ Map<ExternalTunnelKey, ExternalTunnel> externalTunnels = getAllExternalTunnels(broker);
if (externalTunnels != null) {
- for (ExternalTunnel tunnel : externalTunnels) {
+ for (ExternalTunnel tunnel : externalTunnels.values()) {
String tunnelInterfaceName = tunnel.getTunnelInterfaceName();
if (tunnelInterfaceName != null && tunnelInterfaceName.equalsIgnoreCase(interfaceName)) {
LOG.trace("getExternalTunnelFromDS tunnelInterfaceName: {} ", tunnelInterfaceName);
return externalTunnel;
}
- private static List<ExternalTunnel> getAllExternalTunnels(DataBroker dataBroker) {
- List<ExternalTunnel> result = null;
+ private static Map<ExternalTunnelKey, ExternalTunnel> getAllExternalTunnels(DataBroker dataBroker) {
+ Map<ExternalTunnelKey, ExternalTunnel> result = null;
InstanceIdentifier<ExternalTunnelList> iid = InstanceIdentifier.builder(ExternalTunnelList.class).build();
Optional<ExternalTunnelList> tunnelList = read(LogicalDatastoreType.CONFIGURATION, iid, dataBroker);
if (tunnelList.isPresent()) {
result = tunnelList.get().getExternalTunnel();
}
if (result == null) {
- result = emptyList();
+ result = emptyMap();
}
return result;
}
return value == null ? false : value;
}
- public static <T> List<T> getIntersection(List<T> list1, List<T> list2) {
- List<T> list = new ArrayList<>();
- for (T iter : list1) {
- if (list2.contains(iter)) {
+ public static List<TzMembership> getIntersection(Map<TzMembershipKey, TzMembership> list1,
+ Map<TzMembershipKey, TzMembership> list2) {
+ List<TzMembership> list = new ArrayList<>();
+ for (TzMembership iter : list1.values()) {
+ if (list2.values().contains(iter)) {
list.add(iter);
}
}
return TUNNEL_TYPE_MAP.get(tunnelType);
}
- public static List<TzMembership> removeTransportZoneMembership(TunnelEndPoints endPts, List<TzMembership> zones) {
+ public static List<TzMembership> removeTransportZoneMembership(TunnelEndPoints endPts, Map<TzMembershipKey,
+ TzMembership> zones) {
LOG.trace(" RemoveTransportZoneMembership TEPs {}, Membership to be removed {} ", endPts, zones);
- List<TzMembership> existingTzList = new ArrayList<>(endPts.nonnullTzMembership());
- for (TzMembership membership : zones) {
+ List<TzMembership> existingTzList = new ArrayList<>(endPts.nonnullTzMembership().values());
+ for (TzMembership membership : zones.values()) {
existingTzList.remove(new TzMembershipBuilder().setZoneName(membership.getZoneName()).build());
}
LOG.debug("Modified Membership List {}", existingTzList);
}
@NonNull
- public static List<TzMembership> getOriginalTzMembership(TunnelEndPoints srcTep, Uint64 dpnId,
+ public static Map<TzMembershipKey, TzMembership> getOriginalTzMembership(TunnelEndPoints srcTep, Uint64 dpnId,
Collection<DPNTEPsInfo> meshedDpnList) {
LOG.trace("Original Membership for source DPN {}, source TEP {}", dpnId, srcTep);
for (DPNTEPsInfo dstDpn : meshedDpnList) {
if (dpnId.equals(dstDpn.getDPNID())) {
for (TunnelEndPoints tep : dstDpn.nonnullTunnelEndPoints()) {
if (Objects.equals(tep.getIpAddress(), srcTep.getIpAddress())) {
- List<TzMembership> tzMemberships = tep.nonnullTzMembership();
+ @NonNull Map<TzMembershipKey, TzMembership> tzMemberships = tep.nonnullTzMembership();
LOG.debug("Original Membership size {}", tzMemberships.size());
return tzMemberships;
}
}
}
}
- return emptyList();
+ return emptyMap();
}
public static StateTunnelList buildStateTunnelList(StateTunnelListKey tlKey, String name, boolean state,
}
private static InternalTunnel getInternalTunnelFromDS(String interfaceName, DataBroker broker) {
- List<InternalTunnel> internalTunnels = getAllInternalTunnels(broker);
+ Map<InternalTunnelKey, InternalTunnel> internalTunnels = getAllInternalTunnels(broker);
if (internalTunnels != null) {
- for (InternalTunnel tunnel : internalTunnels) {
+ for (InternalTunnel tunnel : internalTunnels.values()) {
List<String> tunnelInterfaceNames = tunnel.getTunnelInterfaceNames();
if (tunnelInterfaceNames != null) {
for (String tunnelInterfaceName : tunnelInterfaceNames) {
InstanceIdentifier<DpnEndpoints> iid = InstanceIdentifier.builder(DpnEndpoints.class).build();
Optional<DpnEndpoints> dpnEndpoints = ItmUtils.read(LogicalDatastoreType.CONFIGURATION, iid, dataBroker);
if (dpnEndpoints.isPresent()) {
- return new ArrayList<>(dpnEndpoints.get().getDPNTEPsInfo());
+ return new ArrayList<>(dpnEndpoints.get().getDPNTEPsInfo().values());
} else {
return new ArrayList<>();
}
if (transportZoneOptional.isPresent()) {
TransportZone transportZone = transportZoneOptional.get();
if (transportZone.getVteps() != null && !transportZone.getVteps().isEmpty()) {
- List<Vteps> vtepsList = transportZone.getVteps();
+ @Nullable Map<VtepsKey, Vteps> vtepsList = transportZone.getVteps();
if (vtepsList != null && !vtepsList.isEmpty()) {
- for (Vteps vtep : vtepsList) {
+ for (Vteps vtep : vtepsList.values()) {
listOfDpId.add(vtep.getDpnId());
}
}
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.util.Collections;
import java.util.List;
+import java.util.Map;
import java.util.Optional;
import java.util.concurrent.Callable;
import org.eclipse.jdt.annotation.NonNull;
+import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
import org.opendaylight.genius.itm.cache.BfdStateCache;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.tunnels_state.StateTunnelListKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbTerminationPointAugmentation;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceBfdStatus;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceBfdStatusKey;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NetworkTopology;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.Topology;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
if (!DirectTunnelUtils.bfdMonitoringEnabled(terminationPoint.getInterfaceBfd())) {
return Interface.OperStatus.Up;
}
- List<InterfaceBfdStatus> tunnelBfdStatus = terminationPoint.getInterfaceBfdStatus();
+ @Nullable Map<InterfaceBfdStatusKey, InterfaceBfdStatus> tunnelBfdStatus =
+ terminationPoint.getInterfaceBfdStatus();
if (tunnelBfdStatus != null && !tunnelBfdStatus.isEmpty()) {
- for (InterfaceBfdStatus bfdState : tunnelBfdStatus) {
+ for (InterfaceBfdStatus bfdState : tunnelBfdStatus.values()) {
if (DirectTunnelUtils.BFD_OP_STATE.equalsIgnoreCase(bfdState.getBfdStatusKey())) {
String bfdOpState = bfdState.getBfdStatusValue();
return DirectTunnelUtils.BFD_STATE_UP.equalsIgnoreCase(bfdOpState)
LOG.debug("updating tep interface state as {} for {}", operStatus.name(), interfaceName);
StateTunnelListBuilder stateTnlBuilder = new StateTunnelListBuilder().withKey(stateTnlKey);
stateTnlBuilder.setOperState(operStatus);
- transaction.merge(LogicalDatastoreType.OPERATIONAL, stateTnlII, stateTnlBuilder.build(), false);
+ transaction.mergeParentStructureMerge(LogicalDatastoreType.OPERATIONAL, stateTnlII, stateTnlBuilder.build());
}
private class RendererTunnelStateUpdateWorker implements Callable<List<? extends ListenableFuture<?>>> {
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.util.Collections;
import java.util.List;
+import java.util.Map;
import java.util.Optional;
import java.util.concurrent.Callable;
import org.eclipse.jdt.annotation.NonNull;
+import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
import org.opendaylight.genius.itm.cache.DpnTepStateCache;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.meta.rev171210.bridge.tunnel.info.OvsBridgeEntryBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.meta.rev171210.bridge.tunnel.info.OvsBridgeEntryKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.meta.rev171210.bridge.tunnel.info.ovs.bridge.entry.OvsBridgeTunnelEntry;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.meta.rev171210.bridge.tunnel.info.ovs.bridge.entry.OvsBridgeTunnelEntryKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.meta.rev171210.ovs.bridge.ref.info.OvsBridgeRefEntry;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.meta.rev171210.ovs.bridge.ref.info.OvsBridgeRefEntryBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.meta.rev171210.ovs.bridge.ref.info.OvsBridgeRefEntryKey;
OvsBridgeRefEntryBuilder tunnelDpnBridgeEntryBuilder =
new OvsBridgeRefEntryBuilder().withKey(bridgeRefEntryKey).setDpid(dpnId)
.setOvsBridgeReference(new OvsdbBridgeRef(bridgeIid));
- tx.put(LogicalDatastoreType.OPERATIONAL, bridgeEntryId, tunnelDpnBridgeEntryBuilder.build(), true);
+ tx.mergeParentStructurePut(LogicalDatastoreType.OPERATIONAL, bridgeEntryId,
+ tunnelDpnBridgeEntryBuilder.build());
}
private void deleteOvsBridgeRefEntry(Uint64 dpnId, WriteTransaction tx) {
OvsBridgeEntryBuilder bridgeEntryBuilder = new OvsBridgeEntryBuilder().withKey(bridgeEntryKey)
.setOvsBridgeReference(ovsdbBridgeRef);
- tx.merge(LogicalDatastoreType.CONFIGURATION, bridgeEntryInstanceIdentifier, bridgeEntryBuilder.build(), true);
+ tx.mergeParentStructureMerge(LogicalDatastoreType.CONFIGURATION, bridgeEntryInstanceIdentifier,
+ bridgeEntryBuilder.build());
}
/*
OvsdbBridgeAugmentation bridgeNew) {
String bridgeName = bridgeNew.getBridgeName().getValue();
LOG.debug("adding all ports to bridge: {}", bridgeName);
- List<OvsBridgeTunnelEntry> bridgeInterfaceEntries = bridgeEntry.getOvsBridgeTunnelEntry();
+ @Nullable Map<OvsBridgeTunnelEntryKey, OvsBridgeTunnelEntry> bridgeInterfaceEntries =
+ bridgeEntry.getOvsBridgeTunnelEntry();
if (bridgeInterfaceEntries != null) {
- for (OvsBridgeTunnelEntry bridgeInterfaceEntry : bridgeInterfaceEntries) {
+ for (OvsBridgeTunnelEntry bridgeInterfaceEntry : bridgeInterfaceEntries.values()) {
String portName = bridgeInterfaceEntry.getTunnelName();
org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang
.ietf.interfaces.rev140508.interfaces.Interface iface =
import edu.umd.cs.findbugs.annotations.CheckReturnValue;
import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
-import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Uri;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.Flow;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list.Instruction;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list.InstructionKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.AllocateIdInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.AllocateIdInputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.AllocateIdOutput;
return bfdBuilder.build();
}
- public static boolean bfdMonitoringEnabled(List<InterfaceBfd> interfaceBfds) {
+ public static boolean bfdMonitoringEnabled(Map<InterfaceBfdKey, InterfaceBfd> interfaceBfds) {
if (interfaceBfds != null && !interfaceBfds.isEmpty()) {
- for (InterfaceBfd interfaceBfd : interfaceBfds) {
+ for (InterfaceBfd interfaceBfd : interfaceBfds.values()) {
if (BFD_ENABLE_KEY.equalsIgnoreCase(interfaceBfd.getBfdKey())) {
return BFD_ENABLE_VALUE.equalsIgnoreCase(interfaceBfd.getBfdValue());
}
String flowRef = getTunnelInterfaceFlowRef(dpnId, NwConstants.EGRESS_TUNNEL_TABLE, interfaceName);
Flow egressFlow = MDSALUtil.buildFlowNew(NwConstants.EGRESS_TUNNEL_TABLE, flowRef, 5, flowRef, 0, 0,
NwConstants.COOKIE_ITM_EGRESS_TUNNEL_TABLE, matches,
- Collections.singletonList(MDSALUtil.buildApplyActionsInstruction(MDSALUtil.buildActions(actions))));
+ (Map<InstructionKey, Instruction>)(MDSALUtil.buildApplyActionsInstruction(MDSALUtil
+ .buildActions(actions))));
mdsalApiManager.addFlow(tx, dpnId, egressFlow);
}
import java.time.Duration;
import java.util.List;
+import java.util.Map;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.eclipse.jdt.annotation.NonNull;
+import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.genius.datastoreutils.listeners.DataTreeEventCallbackRegistrar;
import org.opendaylight.genius.itm.commons.OvsdbTepInfo;
import org.opendaylight.genius.itm.confighelpers.OvsdbTepAddWorker;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeAugmentation;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbNodeAugmentation;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.OpenvswitchExternalIds;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.OpenvswitchExternalIdsKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.OpenvswitchOtherConfigs;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.OpenvswitchOtherConfigsKey;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NetworkTopology;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.Topology;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
return null;
}
- List<OpenvswitchOtherConfigs> ovsdbNodeOtherConfigsList = ovsdbNodeAugmentation.getOpenvswitchOtherConfigs();
+ @Nullable Map<OpenvswitchOtherConfigsKey, OpenvswitchOtherConfigs> ovsdbNodeOtherConfigsList =
+ ovsdbNodeAugmentation.getOpenvswitchOtherConfigs();
if (ovsdbNodeOtherConfigsList == null) {
//Local IP is not configured
LOG.debug("OtherConfigs list does not exist in the OVSDB Node Augmentation.");
OvsdbTepInfo ovsdbTepInfoObj = new OvsdbTepInfo();
- for (OpenvswitchOtherConfigs otherConfigs : ovsdbNodeOtherConfigsList) {
+ for (OpenvswitchOtherConfigs otherConfigs : ovsdbNodeOtherConfigsList.values()) {
if (ITMConstants.OTH_CFG_TEP_PARAM_KEY_LOCAL_IP.equals(otherConfigs.getOtherConfigKey())) {
String tepIp = otherConfigs.getOtherConfigValue();
ovsdbTepInfoObj.setLocalIp(tepIp);
}
}
- List<OpenvswitchExternalIds> ovsdbNodeExternalIdsList = ovsdbNodeAugmentation.getOpenvswitchExternalIds();
+ @Nullable Map<OpenvswitchExternalIdsKey, OpenvswitchExternalIds> ovsdbNodeExternalIdsList =
+ ovsdbNodeAugmentation.getOpenvswitchExternalIds();
if (ovsdbNodeExternalIdsList == null) {
LOG.debug("ExternalIds list does not exist in the OVSDB Node Augmentation.");
} else {
- for (OpenvswitchExternalIds externalId : ovsdbNodeExternalIdsList) {
+ for (OpenvswitchExternalIds externalId : ovsdbNodeExternalIdsList.values()) {
switch (externalId.getExternalIdKey()) {
case ITMConstants.EXT_ID_TEP_PARAM_KEY_TZNAME:
ovsdbTepInfoObj.setTzName(externalId.getExternalIdValue());
import com.google.common.util.concurrent.FluentFuture;
import java.util.ArrayList;
import java.util.Collections;
+import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.eclipse.jdt.annotation.NonNull;
+import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.genius.cloudscaler.api.TombstonedNodeManager;
import org.opendaylight.genius.datastoreutils.listeners.DataTreeEventCallbackRegistrar;
import org.opendaylight.genius.infra.Datastore;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.not.hosted.transport.zones.tepsinnothostedtransportzone.UnknownVtepsKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.TransportZone;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.transport.zone.DeviceVteps;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.transport.zone.DeviceVtepsKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.transport.zone.Vteps;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.transport.zone.VtepsBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.transport.zone.VtepsKey;
itmInternalTunnelDeleteWorker, dpnTEPsInfoCache, txRunner, itmConfig));
if (transportZone.getVteps() != null && !transportZone.getVteps().isEmpty()) {
- List<UnknownVteps> unknownVteps = convertVtepListToUnknownVtepList(transportZone.getVteps());
+ Map<UnknownVtepsKey, UnknownVteps> unknownVteps =
+ convertVtepListToUnknownVtepList(transportZone.getVteps());
LOG.trace("Moving Transport Zone {} to tepsInNotHostedTransportZone Oper Ds.",
transportZone.getZoneName());
jobCoordinator.enqueueJob(transportZone.getZoneName(),
if (tepsInNotHostedTransportZone == null) {
return notHostedDpnTepInfo;
}
- List<UnknownVteps> unVtepsLst = tepsInNotHostedTransportZone.getUnknownVteps();
+ @Nullable Map<UnknownVtepsKey, UnknownVteps> unVtepsLst = tepsInNotHostedTransportZone.getUnknownVteps();
List<Vteps> vtepsList = new ArrayList<>();
if (unVtepsLst != null && !unVtepsLst.isEmpty()) {
- for (UnknownVteps vteps : unVtepsLst) {
+ for (UnknownVteps vteps : unVtepsLst.values()) {
Uint64 dpnID = vteps.getDpnId();
IpAddress ipAddress = vteps.getIpAddress();
String portName = itmConfig.getPortname() == null ? ITMConstants.DUMMY_PORT : itmConfig.getPortname();
return vtepObj;
}
- private List<UnknownVteps> convertVtepListToUnknownVtepList(List<Vteps> vteps) {
- List<UnknownVteps> unknownVtepsList = new ArrayList<>();
- for (Vteps vtep : vteps) {
+ private Map<UnknownVtepsKey, UnknownVteps> convertVtepListToUnknownVtepList(Map<VtepsKey, Vteps> vteps) {
+ Map<UnknownVtepsKey, UnknownVteps> unknownVtepsList = new HashMap<>();
+ for (Vteps vtep : vteps.values()) {
UnknownVtepsKey vtepkey = new UnknownVtepsKey(vtep.getDpnId());
UnknownVteps vtepObj =
new UnknownVtepsBuilder().setDpnId(vtep.getDpnId()).setIpAddress(vtep.getIpAddress())
.withKey(vtepkey).setOfTunnel(vtep.isOptionOfTunnel()).build();
- unknownVtepsList.add(vtepObj);
+ //unknownVtepsList.values().add(vtepObj);
+ unknownVtepsList.put(vtepObj.key(),vtepObj);
}
return unknownVtepsList;
}
List<TzMembership> zones = ItmUtils.createTransportZoneMembership(transportZone.getZoneName());
Class<? extends TunnelTypeBase> tunnelType = transportZone.getTunnelType();
LOG.trace("Transport Zone_name: {}", transportZone.getZoneName());
- List<Vteps> vtepsList = transportZone.getVteps();
+ @Nullable Map<VtepsKey, Vteps> vtepsList = transportZone.getVteps();
String portName = itmConfig.getPortname() == null ? ITMConstants.DUMMY_PORT : itmConfig.getPortname();
int vlanId = itmConfig.getVlanId() != null ? itmConfig.getVlanId().toJava() : ITMConstants.DUMMY_VLANID;
if (vtepsList != null && !vtepsList.isEmpty()) {
- for (Vteps vteps : vtepsList) {
+ for (Vteps vteps : vtepsList.values()) {
Uint64 dpnID = vteps.getDpnId();
IpAddress ipAddress = vteps.getIpAddress();
boolean useOfTunnel = itmConfig.isUseOfTunnels();
String zoneName = transportZone.getZoneName();
Class<? extends TunnelTypeBase> tunnelType = transportZone.getTunnelType();
LOG.trace("Transport Zone_name: {}", zoneName);
- List<DeviceVteps> deviceVtepsList = transportZone.getDeviceVteps();
+ @Nullable Map<DeviceVtepsKey, DeviceVteps> deviceVtepsList = transportZone.getDeviceVteps();
if (deviceVtepsList != null) {
- for (DeviceVteps vteps : deviceVtepsList) {
+ for (DeviceVteps vteps : deviceVtepsList.values()) {
String topologyId = vteps.getTopologyId();
String nodeId = vteps.getNodeId();
IpAddress ipAddress = vteps.getIpAddress();
LOG.debug(" Tunnel events are processed out order for {} hence updating it from cache",
add.getTunnelInterfaceName());
return Collections.singletonList(txRunner
- .callWithNewWriteOnlyTransactionAndSubmit(Datastore.OPERATIONAL, tx -> tx.merge(identifier,
- new StateTunnelListBuilder(add).setOperState(operStatus).build(), false)));
+ .callWithNewWriteOnlyTransactionAndSubmit(Datastore.OPERATIONAL,
+ tx -> tx.mergeParentStructureMerge(identifier,
+ new StateTunnelListBuilder(add).setOperState(operStatus).build())));
}
}
}
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
+import java.util.Map;
import java.util.Objects;
import java.util.concurrent.atomic.AtomicInteger;
import javax.inject.Inject;
import javax.inject.Singleton;
+import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.genius.cloudscaler.api.TombstonedNodeManager;
import org.opendaylight.genius.datastoreutils.listeners.DataTreeEventCallbackRegistrar;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.dpn.endpoints.dpn.teps.info.tunnel.end.points.TzMembership;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.dpn.teps.state.DpnsTeps;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.dpn.teps.state.dpns.teps.RemoteDpns;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.dpn.teps.state.dpns.teps.RemoteDpnsKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.tunnel.list.InternalTunnel;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.tunnel.list.InternalTunnelKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.tunnels_state.StateTunnelList;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.tunnels_state.StateTunnelListKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.TransportZone;
} else {
tepsToRecover.add(dpnTepsToRecover);
//List of Internel tunnels
- List<InternalTunnel> tunnelList = ItmUtils.getInternalTunnelsFromCache(dataBroker);
+ Map<InternalTunnelKey, InternalTunnel> tunnelList = ItmUtils.getInternalTunnelsFromCache(dataBroker);
List<String> interfaceListToRecover = new ArrayList<>();
LOG.debug("List of tunnel interfaces: {}" , tunnelList);
if (interfaceManager.isItmDirectTunnelsEnabled()) {
Collection<DpnsTeps> dpnsTeps = dpnTepStateCache.getAllPresent();
for (DpnsTeps dpnTep : dpnsTeps) {
- List<RemoteDpns> rmtdpns = dpnTep.getRemoteDpns();
- for (RemoteDpns remoteDpn : rmtdpns) {
+ @Nullable Map<RemoteDpnsKey, RemoteDpns> rmtdpns = dpnTep.getRemoteDpns();
+ for (RemoteDpns remoteDpn : rmtdpns.values()) {
if (remoteDpn.getDestinationDpnId().equals(dpnTepsToRecover.getDPNID())
|| dpnTep.getSourceDpnId().equals(dpnTepsToRecover.getDPNID())) {
eventRegistrationCount.incrementAndGet();
}
LOG.trace("List of tunnels to be recovered : {}", interfaceListToRecover);
} else {
- tunnelList.stream().filter(internalTunnel -> Objects.equals(internalTunnel
+ tunnelList.values().stream().filter(internalTunnel -> Objects.equals(internalTunnel
.getDestinationDPN(), dpnTepsToRecover.getDPNID()) || Objects.equals(
internalTunnel.getSourceDPN(), dpnTepsToRecover.getDPNID())).forEach(internalTunnel -> {
eventRegistrationCount.incrementAndGet();
String portName = itmConfig.getPortname() == null ? ITMConstants.DUMMY_PORT : itmConfig.getPortname();
int vlanId = itmConfig.getVlanId() != null ? itmConfig.getVlanId().toJava() : ITMConstants.DUMMY_VLANID;
- for (Vteps vtep : transportZone.getVteps()) {
+ for (Vteps vtep : transportZone.getVteps().values()) {
if (ipAddress.equals(vtep.getIpAddress().stringValue())) {
List<TzMembership> zones = ItmUtils.createTransportZoneMembership(tzName);
import java.util.Collection;
import java.util.Collections;
import java.util.List;
+import java.util.Map;
import java.util.concurrent.atomic.AtomicInteger;
import javax.inject.Inject;
import javax.inject.Singleton;
+import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.genius.datastoreutils.listeners.DataTreeEventCallbackRegistrar;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.TunnelsState;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.dpn.teps.state.DpnsTeps;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.dpn.teps.state.dpns.teps.RemoteDpns;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.dpn.teps.state.dpns.teps.RemoteDpnsKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.tunnels_state.StateTunnelList;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.tunnels_state.StateTunnelListKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.TransportZone;
Collection<DpnsTeps> dpnsTeps = dpnTepStateCache.getAllPresent();
List<Uint64> listOfDpnIds = ItmUtils.getDpIdFromTransportzone(dataBroker, entityId);
for (DpnsTeps dpnTep : dpnsTeps) {
- List<RemoteDpns> rmtdpns = dpnTep.getRemoteDpns();
- for (RemoteDpns remoteDpn : rmtdpns) {
+ @Nullable Map<RemoteDpnsKey, RemoteDpns> rmtdpns = dpnTep.getRemoteDpns();
+ for (RemoteDpns remoteDpn : rmtdpns.values()) {
if (listOfDpnIds.contains(remoteDpn.getDestinationDpnId())) {
tunnelList.add(remoteDpn.getTunnelName());
}
.child(DpnsTeps.class, new DpnsTepsKey(srcDpnId))
.child(RemoteDpns.class,
new RemoteDpnsKey(destDpnId)).build();
- tx.merge(iid, remoteDpn, true);
+ tx.mergeParentStructureMerge(iid, remoteDpn);
}
@Override
tx -> {
externalTunnelAddWorker.buildTunnelsToExternalEndPoint(meshedDpnList, input.getDestinationIp(),
input.getTunnelType(), tx);
- tx.put(extPath, dcGatewayIp, true);
+ tx.mergeParentStructurePut(extPath, dcGatewayIp);
}
);
future.addCallback(new FutureCallback<Void>() {
.setNodeId(nodeId).setTopologyId(input.getTopologyId()).build();
//TO DO: add retry if it fails
FluentFuture<Void> future = retryingTxRunner
- .callWithNewWriteOnlyTransactionAndSubmit(CONFIGURATION, tx -> tx.put(path,
- deviceVtep, true));
+ .callWithNewWriteOnlyTransactionAndSubmit(CONFIGURATION,
+ tx -> tx.mergeParentStructurePut(path, deviceVtep));
future.addCallback(new FutureCallback<Void>() {
FluentFuture<Void> future =
retryingTxRunner.callWithNewWriteOnlyTransactionAndSubmit(CONFIGURATION,
tx -> {
- tx.put(path, deviceVtep, true);
+ tx.mergeParentStructurePut(path, deviceVtep);
if (nodeId.size() == 2) {
LOG.trace("second node-id {}", nodeId.get(1));
DeviceVtepsKey deviceVtepKey2 = new DeviceVtepsKey(hwIp, nodeId.get(1));
.setIpAddress(hwIp).setNodeId(nodeId.get(1))
.setTopologyId(input.getTopologyId()).build();
LOG.trace("writing {}", deviceVtep2);
- tx.put(path2, deviceVtep2, true);
+ tx.mergeParentStructurePut(path2, deviceVtep2);
}
});
future.addCallback(new FutureCallback<Void>() {
public ListenableFuture<RpcResult<IsDcgwPresentOutput>> isDcgwPresent(IsDcgwPresentInput input) {
RpcResultBuilder<IsDcgwPresentOutput> resultBld = RpcResultBuilder.success();
- List<DcGatewayIp> dcGatewayIpList = new ArrayList<>();
+ Map<DcGatewayIpKey, DcGatewayIp> dcGatewayIpList = new HashMap<>();
txRunner.callWithNewReadWriteTransactionAndSubmit(CONFIGURATION,
- tx -> dcGatewayIpList.addAll(getDcGatewayIpList(tx))).isDone();
+ tx -> dcGatewayIpList.values().addAll(getDcGatewayIpList(tx).values())).isDone();
String dcgwIpStr = input.getDcgwIp();
IpAddress dcgwIpAddr = IpAddressBuilder.getDefaultInstance(dcgwIpStr);
long retVal;
if (!dcGatewayIpList.isEmpty()
- && dcGatewayIpList.stream().anyMatch(gwIp -> Objects.equal(gwIp.getIpAddress(), dcgwIpAddr))) {
+ && dcGatewayIpList.values().stream().anyMatch(gwIp -> Objects.equal(gwIp.getIpAddress(), dcgwIpAddr))) {
//Match found
retVal = 1;
IsDcgwPresentOutputBuilder output = new IsDcgwPresentOutputBuilder().setRetVal(retVal);
}
Map<Uint64, ComputesBuilder> result = new HashMap<>();
for (TransportZone transportZone : transportZones.getTransportZone()) {
- for (Vteps vtep : transportZone.getVteps()) {
+ for (Vteps vtep : transportZone.getVteps().values()) {
if (dpnIds.contains(vtep.getDpnId())) {
result.putIfAbsent(vtep.getDpnId(),
new ComputesBuilder()
throw new IllegalStateException("Failed to find operational inventory nodes datastore");
}
Map<String, Uint64> result = new HashMap<>();
- for (Node node : operInventoryNodes.getNode()) {
+ for (Node node : operInventoryNodes.getNode().values()) {
String name = node.augmentation(FlowCapableNode.class).getDescription();
if (nodeNames.contains(name)) {
String[] nodeId = node.getId().getValue().split(":");
.setAction(result.stream().map(ActionInfo::buildAction).collect(Collectors.toList())).build());
}
- public static List<DcGatewayIp> getDcGatewayIpList(TypedReadWriteTransaction<Datastore.Configuration> tx)
+ public static Map<DcGatewayIpKey, DcGatewayIp>
+ getDcGatewayIpList(TypedReadWriteTransaction<Datastore.Configuration> tx)
throws ExecutionException, InterruptedException {
- List<DcGatewayIp> dcGatewayIpList = new ArrayList<>();
+ Map<DcGatewayIpKey, DcGatewayIp> dcGatewayIpList = new HashMap<>();
FluentFuture<Optional<DcGatewayIpList>> future =
tx.read(InstanceIdentifier.builder(DcGatewayIpList.class).build());
future.addCallback(new FutureCallback<Optional<DcGatewayIpList>>() {
if (opt.isPresent()) {
DcGatewayIpList list = opt.get();
if (list != null) {
- dcGatewayIpList.addAll(list.getDcGatewayIp());
+ dcGatewayIpList.values().addAll(list.getDcGatewayIp().values());
}
}
} catch (ExecutionException | InterruptedException e) {
private TunnelMonitorParams tunnelMonitorParams = null;
private Vteps vteps = null;
private Vteps vtepsTest = null;
+ private TransportZone mergeTransportZone = null;
+ private TransportZone mergeTransportZoneGre = null;
+ private TransportZones mergeParentTransportZones = null;
+ private TransportZones mergeParentTransportZonesGre = null;
+ private Vteps mergeVteps = null;
+ private final List<Vteps> mergeVtepsList = new ArrayList<>();
+ private final List<TransportZone> mergeParentTransportZoneList = new ArrayList<>();
+ private final List<TransportZone> mergeParentTransportZoneListGre = new ArrayList<>();
private org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state
.Interface interfaceTest = null;
private org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface
transportZoneList.add(transportZone);
transportZones = new TransportZonesBuilder().setTransportZone(transportZoneList).build();
transportZonesNew = new TransportZonesBuilder().setTransportZone(transportZoneListNew).build();
+ mergeVteps = new VtepsBuilder().setDpnId(dpId2)
+ .setIpAddress(ipAddress1).withKey(new VtepsKey(dpId1)).build();
+ mergeVtepsList.add(mergeVteps);
+ mergeTransportZone =
+ new TransportZoneBuilder().withKey(new TransportZoneKey(transportZone1))
+ .setTunnelType(tunnelType1).setZoneName(transportZone1).setVteps(mergeVtepsList)
+ .build();
+ mergeParentTransportZoneList.add(mergeTransportZone);
+ mergeParentTransportZones = new TransportZonesBuilder().setTransportZone(mergeParentTransportZoneList).build();
+ mergeTransportZoneGre =
+ new TransportZoneBuilder().withKey(new TransportZoneKey(transportZone1))
+ .setTunnelType(tunnelType2).setZoneName(transportZone1).setVteps(mergeVtepsList)
+ .build();
+ mergeParentTransportZoneListGre.add(mergeTransportZoneGre);
+ mergeParentTransportZonesGre = new TransportZonesBuilder().setTransportZone(mergeParentTransportZoneListGre)
+ .build();
tunnelMonitorInterval = new TunnelMonitorIntervalBuilder().setInterval(10000).build();
tunnelMonitorParams = new TunnelMonitorParamsBuilder().setEnabled(true).build();
InternalTunnel internalTunnelTest = new InternalTunnelBuilder().setSourceDPN(dpId1).setDestinationDPN(dpId2)
tepCommandHelper.configureTunnelMonitorInterval(interval);
verify(mockReadTx).read(LogicalDatastoreType.CONFIGURATION,tunnelMonitorIntervalIdentifier);
- verify(mockWriteTx).merge(LogicalDatastoreType.CONFIGURATION,tunnelMonitorIntervalIdentifier,
- tunnelMonitor,true);
+ verify(mockWriteTx).mergeParentStructureMerge(LogicalDatastoreType.CONFIGURATION,
+ tunnelMonitorIntervalIdentifier, tunnelMonitor);
}
@Test
tepCommandHelper.buildTeps();
verify(mockReadTx, times(2)).read(LogicalDatastoreType.CONFIGURATION,transportZoneIdentifier);
- verify(mockWriteTx).merge(LogicalDatastoreType.CONFIGURATION,transportZonesIdentifier,transportZonesNew,true);
-
+ verify(mockWriteTx).mergeParentStructureMerge(LogicalDatastoreType.CONFIGURATION,transportZonesIdentifier,
+ mergeParentTransportZones);
}
@Test
tepCommandHelper.buildTeps();
verify(mockReadTx, times(2)).read(LogicalDatastoreType.CONFIGURATION,transportZoneIdentifier);
- verify(mockWriteTx).merge(LogicalDatastoreType.CONFIGURATION,transportZonesIdentifier,transportZonesNew,true);
+ verify(mockWriteTx).mergeParentStructureMerge(LogicalDatastoreType.CONFIGURATION,transportZonesIdentifier,
+ mergeParentTransportZonesGre);
}
tepCommandHelper.buildTeps();
verify(mockReadTx, times(2)).read(LogicalDatastoreType.CONFIGURATION,transportZoneIdentifier);
- verify(mockWriteTx).merge(LogicalDatastoreType.CONFIGURATION,transportZonesIdentifier,transportZonesNew,true);
+ verify(mockWriteTx).mergeParentStructureMerge(LogicalDatastoreType.CONFIGURATION,transportZonesIdentifier,
+ mergeParentTransportZones);
}
public void testBuildTunnelsToExternalEndPoint() {
externalTunnelAddWorker
.buildTunnelsToExternalEndPoint(cfgdDpnListVxlan, ipAddress2, tunnelType1, typedWriteTransaction);
- verify(typedWriteTransaction).merge(interfaceIdentifier, iface, true);
- verify(typedWriteTransaction).merge(externalTunnelIdentifier, externalTunnel, true);
+ verify(typedWriteTransaction).mergeParentStructureMerge(interfaceIdentifier, iface);
+ verify(typedWriteTransaction).mergeParentStructureMerge(externalTunnelIdentifier, externalTunnel);
}
public void testBuildTunnelsFromDpnToExternalEndPoint() {
externalTunnelAddWorker
.buildTunnelsFromDpnToExternalEndPoint(bigIntegerList, ipAddress2, tunnelType1, typedWriteTransaction);
- verify(typedWriteTransaction).merge(interfaceIdentifier, iface, true);
- verify(typedWriteTransaction).merge(externalTunnelIdentifier, externalTunnel, true);
+ verify(typedWriteTransaction).mergeParentStructureMerge(interfaceIdentifier, iface);
+ verify(typedWriteTransaction).mergeParentStructureMerge(externalTunnelIdentifier, externalTunnel);
}
externalTunnelAddWorker.buildHwVtepsTunnels(cfgdDpnListVxlan, null, typedReadWriteTransaction);
externalTunnelAddWorker.buildHwVtepsTunnels(null, cfgdHwVtepsList, typedReadWriteTransaction);
- verify(typedReadWriteTransaction, times(2)).merge(ifIID1, extTunnelIf1, true);
- verify(typedReadWriteTransaction, times(2)).merge(externalTunnelIdentifier1, externalTunnel1, true);
- verify(typedReadWriteTransaction, times(2)).merge(ifIID2, hwTunnelIf2, true);
- verify(typedReadWriteTransaction, times(2)).merge(externalTunnelIdentifier2, externalTunnel2, true);
- verify(typedReadWriteTransaction).merge(ifIID3,extTunnelIf3,true);
- verify(typedReadWriteTransaction).merge(externalTunnelIdentifier3, externalTunnel3, true);
- verify(typedReadWriteTransaction).merge(ifIID4, hwTunnelIf4, true);
- verify(typedReadWriteTransaction).merge(externalTunnelIdentifier4, externalTunnel4, true);
- verify(typedReadWriteTransaction).merge(ifIID5, hwTunnelIf5, true);
- verify(typedReadWriteTransaction).merge(externalTunnelIdentifier5, externalTunnel5, true);
- verify(typedReadWriteTransaction).merge(ifIID6, hwTunnelIf6, true);
- verify(typedReadWriteTransaction).merge(externalTunnelIdentifier6, externalTunnel6, true);
+ verify(typedReadWriteTransaction, times(2)).mergeParentStructureMerge(ifIID1, extTunnelIf1);
+ verify(typedReadWriteTransaction, times(2))
+ .mergeParentStructureMerge(externalTunnelIdentifier1, externalTunnel1);
+ verify(typedReadWriteTransaction, times(2)).mergeParentStructureMerge(ifIID2, hwTunnelIf2);
+ verify(typedReadWriteTransaction, times(2))
+ .mergeParentStructureMerge(externalTunnelIdentifier2, externalTunnel2);
+ verify(typedReadWriteTransaction).mergeParentStructureMerge(ifIID3,extTunnelIf3);
+ verify(typedReadWriteTransaction).mergeParentStructureMerge(externalTunnelIdentifier3, externalTunnel3);
+ verify(typedReadWriteTransaction).mergeParentStructureMerge(ifIID4, hwTunnelIf4);
+ verify(typedReadWriteTransaction).mergeParentStructureMerge(externalTunnelIdentifier4, externalTunnel4);
+ verify(typedReadWriteTransaction).mergeParentStructureMerge(ifIID5, hwTunnelIf5);
+ verify(typedReadWriteTransaction).mergeParentStructureMerge(externalTunnelIdentifier5, externalTunnel5);
+ verify(typedReadWriteTransaction).mergeParentStructureMerge(ifIID6, hwTunnelIf6);
+ verify(typedReadWriteTransaction).mergeParentStructureMerge(externalTunnelIdentifier6, externalTunnel6);
}
itmInternalTunnelAddWorker.buildAllTunnels(mdsalApiManager, cfgdDpnListVxlan, meshDpnListVxlan);
//Add some verifications
- verify(mockReadWriteTx).merge(LogicalDatastoreType.CONFIGURATION, internalTunnelIdentifierVxlan1,
- internalTunnel1, true);
- verify(mockReadWriteTx).merge(LogicalDatastoreType.CONFIGURATION, internalTunnelIdentifierVxlan2,
- internalTunnel2, true);
+ verify(mockReadWriteTx).mergeParentStructureMerge(LogicalDatastoreType.CONFIGURATION,
+ internalTunnelIdentifierVxlan1, internalTunnel1);
+ verify(mockReadWriteTx).mergeParentStructureMerge(LogicalDatastoreType.CONFIGURATION,
+ internalTunnelIdentifierVxlan2, internalTunnel2);
verify(mockReadWriteTx).merge(LogicalDatastoreType.CONFIGURATION, dpnEndpointsIdentifier,
dpnEndpointsVxlan);
}
itmInternalTunnelAddWorker.buildAllTunnels(mdsalApiManager, cfgdDpnListGre, meshDpnListGre);
- verify(mockReadWriteTx).merge(LogicalDatastoreType.CONFIGURATION, internalTunnelIdentifierGre1,
- internalTunnel1, true);
- verify(mockReadWriteTx).merge(LogicalDatastoreType.CONFIGURATION, internalTunnelIdentifierGre2,
- internalTunnel2, true);
+ verify(mockReadWriteTx).mergeParentStructureMerge(LogicalDatastoreType.CONFIGURATION,
+ internalTunnelIdentifierGre1, internalTunnel1);
+ verify(mockReadWriteTx).mergeParentStructureMerge(LogicalDatastoreType.CONFIGURATION,
+ internalTunnelIdentifierGre2, internalTunnel2);
verify(mockReadWriteTx).merge(LogicalDatastoreType.CONFIGURATION, dpnEndpointsIdentifier,
dpnEndpointsGre);
}
itmInternalTunnelAddWorker.buildAllTunnels(mdsalApiManager, cfgdDpnListVxlan, meshDpnListGre);
- verify(mockReadWriteTx).merge(LogicalDatastoreType.CONFIGURATION, internalTunnelIdentifierVxlan1,
- internalTunnel1, true);
- verify(mockReadWriteTx).merge(LogicalDatastoreType.CONFIGURATION, internalTunnelIdentifierGre2,
- internalTunnel2, true);
+ verify(mockReadWriteTx).mergeParentStructureMerge(LogicalDatastoreType.CONFIGURATION,
+ internalTunnelIdentifierVxlan1, internalTunnel1);
+ verify(mockReadWriteTx).mergeParentStructureMerge(LogicalDatastoreType.CONFIGURATION,
+ internalTunnelIdentifierGre2, internalTunnel2);
verify(mockReadWriteTx).merge(LogicalDatastoreType.CONFIGURATION, dpnEndpointsIdentifier,
dpnEndpointsVxlan);
}
itmManagerRpcService.addExternalTunnelEndpoint(addExternalTunnelEndpointInput);
- verify(mockWriteTx).merge(LogicalDatastoreType.CONFIGURATION, interfaceIdentifier, iface, true);
- verify(mockWriteTx).merge(LogicalDatastoreType.CONFIGURATION, externalTunnelIdentifierNew,
- externalTunnelNew,true);
+ verify(mockWriteTx).mergeParentStructureMerge(LogicalDatastoreType.CONFIGURATION, interfaceIdentifier, iface);
+ verify(mockWriteTx).mergeParentStructureMerge(LogicalDatastoreType.CONFIGURATION, externalTunnelIdentifierNew,
+ externalTunnelNew);
}
@Test
public void testAddL2GwDevice() {
itmManagerRpcService.addL2GwDevice(addL2GwDeviceInput);
- verify(mockWriteTx).put(LogicalDatastoreType.CONFIGURATION, deviceVtepsIdentifier, deviceVteps, true);
+ verify(mockWriteTx).mergeParentStructurePut(LogicalDatastoreType.CONFIGURATION, deviceVtepsIdentifier,
+ deviceVteps);
}
@Test
public void testAddL2GwMlagDevice() {
itmManagerRpcService.addL2GwMlagDevice(addL2GwMlagDeviceInput);
- verify(mockWriteTx).put(LogicalDatastoreType.CONFIGURATION, deviceVtepsIdentifier, deviceVteps, true);
+ verify(mockWriteTx).mergeParentStructurePut(LogicalDatastoreType.CONFIGURATION, deviceVtepsIdentifier,
+ deviceVteps);
}
@Test
itmManagerRpcService.buildExternalTunnelFromDpns(buildExternalTunnelFromDpnsInput);
- verify(mockWriteTx).merge(LogicalDatastoreType.CONFIGURATION,interfaceIdentifier,iface,true);
- verify(mockWriteTx).merge(LogicalDatastoreType.CONFIGURATION,externalTunnelIdentifierNew,
- externalTunnelNew,true);
+ verify(mockWriteTx).mergeParentStructureMerge(LogicalDatastoreType.CONFIGURATION,interfaceIdentifier,iface);
+ verify(mockWriteTx).mergeParentStructureMerge(LogicalDatastoreType.CONFIGURATION,externalTunnelIdentifierNew,
+ externalTunnelNew);
}
@Ignore
private <T extends DataObject> void syncWrite(InstanceIdentifier<T> path, T data) {
try {
txRunner.callWithNewWriteOnlyTransactionAndSubmit(Datastore.CONFIGURATION,
- tx -> tx.put(path, data, true)).get();
+ tx -> tx.mergeParentStructurePut(path, data)).get();
} catch (InterruptedException | ExecutionException e) {
throw new RuntimeException(e.getMessage(), e);
}
import com.google.common.util.concurrent.ListenableFuture;
import java.util.ArrayList;
import java.util.List;
+import java.util.Map;
import java.util.Optional;
import javax.inject.Inject;
import org.eclipse.jdt.annotation.NonNull;
+import org.eclipse.jdt.annotation.Nullable;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Ignore;
import org.opendaylight.infrautils.inject.guice.testutils.GuiceRule;
import org.opendaylight.infrautils.testutils.LogRule;
import org.opendaylight.mdsal.binding.api.DataBroker;
-import org.opendaylight.mdsal.binding.api.WriteTransaction;
import org.opendaylight.mdsal.common.api.CommitInfo;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpPrefix;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.config.rev160406.ItmConfigBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.not.hosted.transport.zones.TepsInNotHostedTransportZone;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.not.hosted.transport.zones.tepsinnothostedtransportzone.UnknownVteps;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.not.hosted.transport.zones.tepsinnothostedtransportzone.UnknownVtepsKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.TransportZone;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.TransportZoneBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.TransportZoneKey;
// set def-tz-tunnel-type to VXLAN
String defTzTunnelType = ITMConstants.TUNNEL_TYPE_VXLAN;
- /*InstanceIdentifier<TransportZone> tzPath =
- ItmUtils.getTZInstanceIdentifier(ITMConstants.DEFAULT_TRANSPORT_ZONE);
- txRunner.callWithNewWriteOnlyTransactionAndSubmit(tx -> tx.merge(LogicalDatastoreType.CONFIGURATION,
- tzPath, new TransportZoneBuilder().setZoneName(ITMConstants.DEFAULT_TRANSPORT_ZONE)
- .setTunnelType(ItmTestConstants.TUNNEL_TYPE_VXLAN)
- .withKey(new TransportZoneKey(ITMConstants.DEFAULT_TRANSPORT_ZONE))
- .build(), WriteTransaction.CREATE_MISSING_PARENTS)).get();*/
-
InstanceIdentifier<TransportZone> tzonePath = processDefTzOnItmConfig(defTzEnabledFlag,
defTzTunnelType);
Assert.assertNotNull(tzonePath);
InstanceIdentifier<TransportZone> tzPath =
ItmUtils.getTZInstanceIdentifier(ITMConstants.DEFAULT_TRANSPORT_ZONE);
- txRunner.callWithNewWriteOnlyTransactionAndSubmit(tx -> tx.merge(LogicalDatastoreType.CONFIGURATION,
- tzPath, new TransportZoneBuilder().setZoneName(ITMConstants.DEFAULT_TRANSPORT_ZONE)
+ txRunner.callWithNewWriteOnlyTransactionAndSubmit(tx ->
+ tx.mergeParentStructureMerge(LogicalDatastoreType.CONFIGURATION, tzPath,
+ new TransportZoneBuilder().setZoneName(ITMConstants.DEFAULT_TRANSPORT_ZONE)
.setTunnelType(TunnelTypeGre.class)
.withKey(new TransportZoneKey(ITMConstants.DEFAULT_TRANSPORT_ZONE))
- .build(), WriteTransaction.CREATE_MISSING_PARENTS)).get();
+ .build())).get();
InstanceIdentifier<TransportZone> tzonePath = processDefTzOnItmConfig(defTzEnabledFlag,
InstanceIdentifier<TransportZone> tzPath =
ItmUtils.getTZInstanceIdentifier(ITMConstants.DEFAULT_TRANSPORT_ZONE);
- txRunner.callWithNewWriteOnlyTransactionAndSubmit(tx -> tx.merge(LogicalDatastoreType.CONFIGURATION,
- tzPath, new TransportZoneBuilder().setZoneName(ITMConstants.DEFAULT_TRANSPORT_ZONE)
+ txRunner.callWithNewWriteOnlyTransactionAndSubmit(tx ->
+ tx.mergeParentStructureMerge(LogicalDatastoreType.CONFIGURATION, tzPath,
+ new TransportZoneBuilder().setZoneName(ITMConstants.DEFAULT_TRANSPORT_ZONE)
.setTunnelType(TunnelTypeVxlan.class)
.withKey(new TransportZoneKey(ITMConstants.DEFAULT_TRANSPORT_ZONE))
- .build(), WriteTransaction.CREATE_MISSING_PARENTS)).get();
+ .build())).get();
InstanceIdentifier<TransportZone> tzonePath = processDefTzOnItmConfig(defTzEnabledFlag,
defTzTunnelType);
defTzTunnelType = ITMConstants.TUNNEL_TYPE_GRE;
- txRunner.callWithNewWriteOnlyTransactionAndSubmit(tx -> tx.merge(LogicalDatastoreType.CONFIGURATION,
- tzPath, new TransportZoneBuilder().setZoneName(ITMConstants.DEFAULT_TRANSPORT_ZONE)
+ txRunner.callWithNewWriteOnlyTransactionAndSubmit(tx ->
+ tx.mergeParentStructureMerge(LogicalDatastoreType.CONFIGURATION, tzPath,
+ new TransportZoneBuilder().setZoneName(ITMConstants.DEFAULT_TRANSPORT_ZONE)
.setTunnelType(TunnelTypeGre.class)
.withKey(new TransportZoneKey(ITMConstants.DEFAULT_TRANSPORT_ZONE))
- .build(), WriteTransaction.CREATE_MISSING_PARENTS)).get();
+ .build())).get();
tzonePath = processDefTzOnItmConfig(defTzEnabledFlag, defTzTunnelType);
InstanceIdentifier<TransportZone> tzPath =
ItmUtils.getTZInstanceIdentifier(ITMConstants.DEFAULT_TRANSPORT_ZONE);
- txRunner.callWithNewWriteOnlyTransactionAndSubmit(tx -> tx.merge(LogicalDatastoreType.CONFIGURATION,
- tzPath, new TransportZoneBuilder().setZoneName(ITMConstants.DEFAULT_TRANSPORT_ZONE)
+ txRunner.callWithNewWriteOnlyTransactionAndSubmit(tx ->
+ tx.mergeParentStructureMerge(LogicalDatastoreType.CONFIGURATION, tzPath,
+ new TransportZoneBuilder().setZoneName(ITMConstants.DEFAULT_TRANSPORT_ZONE)
.setTunnelType(TunnelTypeGre.class)
.withKey(new TransportZoneKey(ITMConstants.DEFAULT_TRANSPORT_ZONE))
- .build(), WriteTransaction.CREATE_MISSING_PARENTS)).get();
+ .build())).get();
InstanceIdentifier<TransportZone> tzonePath = ItmTepAutoConfigTestUtil.getTzIid(
ITMConstants.DEFAULT_TRANSPORT_ZONE);
InstanceIdentifier<TransportZone> tzPath =
ItmUtils.getTZInstanceIdentifier(ITMConstants.DEFAULT_TRANSPORT_ZONE);
- txRunner.callWithNewWriteOnlyTransactionAndSubmit(tx -> tx.merge(LogicalDatastoreType.CONFIGURATION,
- tzPath, new TransportZoneBuilder().setZoneName(ITMConstants.DEFAULT_TRANSPORT_ZONE)
+ txRunner.callWithNewWriteOnlyTransactionAndSubmit(tx ->
+ tx.mergeParentStructureMerge(LogicalDatastoreType.CONFIGURATION, tzPath,
+ new TransportZoneBuilder().setZoneName(ITMConstants.DEFAULT_TRANSPORT_ZONE)
.setTunnelType(TunnelTypeVxlan.class)
.withKey(new TransportZoneKey(ITMConstants.DEFAULT_TRANSPORT_ZONE))
- .build(), WriteTransaction.CREATE_MISSING_PARENTS)).get();
+ .build())).get();
InstanceIdentifier<TransportZone> tzonePath = ItmTepAutoConfigTestUtil.getTzIid(
ITMConstants.DEFAULT_TRANSPORT_ZONE);
// create TZA
InstanceIdentifier<TransportZone> tzPath = ItmUtils.getTZInstanceIdentifier(ItmTestConstants.TZ_NAME);
- txRunner.callWithNewWriteOnlyTransactionAndSubmit(tx -> tx.merge(LogicalDatastoreType.CONFIGURATION,
- tzPath, transportZone, WriteTransaction.CREATE_MISSING_PARENTS)).get();
+ txRunner.callWithNewWriteOnlyTransactionAndSubmit(tx ->
+ tx.mergeParentStructureMerge(LogicalDatastoreType.CONFIGURATION, tzPath, transportZone)).get();
// check TZ is created with correct TZ name
Assert.assertEquals(ItmTestConstants.TZ_NAME, dataBroker.newReadOnlyTransaction()
InstanceIdentifier<TransportZone> tzPath =
ItmUtils.getTZInstanceIdentifier(ITMConstants.DEFAULT_TRANSPORT_ZONE);
- txRunner.callWithNewWriteOnlyTransactionAndSubmit(tx -> tx.merge(LogicalDatastoreType.CONFIGURATION,
- tzPath, new TransportZoneBuilder().setZoneName(ITMConstants.DEFAULT_TRANSPORT_ZONE)
+ txRunner.callWithNewWriteOnlyTransactionAndSubmit(tx ->
+ tx.mergeParentStructureMerge(LogicalDatastoreType.CONFIGURATION, tzPath,
+ new TransportZoneBuilder().setZoneName(ITMConstants.DEFAULT_TRANSPORT_ZONE)
.setTunnelType(ItmTestConstants.TUNNEL_TYPE_VXLAN)
.withKey(new TransportZoneKey(ITMConstants.DEFAULT_TRANSPORT_ZONE))
- .build(), WriteTransaction.CREATE_MISSING_PARENTS)).get();
+ .build())).get();
// add bridge into node
// create Transport-zone in advance
InstanceIdentifier<TransportZone> tzPath = ItmUtils.getTZInstanceIdentifier(ItmTestConstants.TZ_NAME);
- txRunner.callWithNewWriteOnlyTransactionAndSubmit(tx -> tx.merge(LogicalDatastoreType.CONFIGURATION,
- tzPath, transportZone, WriteTransaction.CREATE_MISSING_PARENTS)).get();
+ txRunner.callWithNewWriteOnlyTransactionAndSubmit(tx ->
+ tx.mergeParentStructureMerge(LogicalDatastoreType.CONFIGURATION, tzPath, transportZone)).get();
// add bridge into node
future = OvsdbTestUtil.addBridgeIntoNode(connInfo, ItmTestConstants.DEF_BR_NAME,
InstanceIdentifier<TransportZone> tzPath =
ItmUtils.getTZInstanceIdentifier(ITMConstants.DEFAULT_TRANSPORT_ZONE);
- txRunner.callWithNewWriteOnlyTransactionAndSubmit(tx -> tx.merge(LogicalDatastoreType.CONFIGURATION,
- tzPath, new TransportZoneBuilder().setZoneName(ITMConstants.DEFAULT_TRANSPORT_ZONE)
+ txRunner.callWithNewWriteOnlyTransactionAndSubmit(tx ->
+ tx.mergeParentStructureMerge(LogicalDatastoreType.CONFIGURATION, tzPath,
+ new TransportZoneBuilder().setZoneName(ITMConstants.DEFAULT_TRANSPORT_ZONE)
.setTunnelType(ItmTestConstants.TUNNEL_TYPE_VXLAN)
.withKey(new TransportZoneKey(ITMConstants.DEFAULT_TRANSPORT_ZONE))
- .build(), WriteTransaction.CREATE_MISSING_PARENTS)).get();
+ .build())).get();
// add bridge into node
future = OvsdbTestUtil.addBridgeIntoNode(connInfo, ItmTestConstants.DEF_BR_NAME,
// create Transport-zone TZA
InstanceIdentifier<TransportZone> tzPath = ItmUtils.getTZInstanceIdentifier(ItmTestConstants.TZ_NAME);
- txRunner.callWithNewWriteOnlyTransactionAndSubmit(tx -> tx.merge(LogicalDatastoreType.CONFIGURATION,
- tzPath, transportZone, WriteTransaction.CREATE_MISSING_PARENTS)).get();
+ txRunner.callWithNewWriteOnlyTransactionAndSubmit(tx ->
+ tx.mergeParentStructureMerge(LogicalDatastoreType.CONFIGURATION, tzPath, transportZone)).get();
// iid for TZA configured from NB
InstanceIdentifier<TransportZone> tzaTzonePath = ItmTepAutoConfigTestUtil.getTzIid(
ItmTestConstants.TZ_NAME);
// create Transport-zone in advance
InstanceIdentifier<TransportZone> tzPath = ItmUtils.getTZInstanceIdentifier(ItmTestConstants.TZ_NAME);
- txRunner.callWithNewWriteOnlyTransactionAndSubmit(tx -> tx.merge(LogicalDatastoreType.CONFIGURATION,
- tzPath, transportZone, WriteTransaction.CREATE_MISSING_PARENTS)).get();
-
+ txRunner.callWithNewWriteOnlyTransactionAndSubmit(tx ->
+ tx.mergeParentStructureMerge(LogicalDatastoreType.CONFIGURATION, tzPath, transportZone)).get();
// add bridge into node
future = OvsdbTestUtil.addBridgeIntoNode(connInfo, ItmTestConstants.DEF_BR_NAME,
.withKey(new TransportZoneKey(ItmTestConstants.NOT_HOSTED_TZ_NAME)).build();
Assert.assertNotNull(transportZoneNorth);
- txRunner.callWithNewWriteOnlyTransactionAndSubmit(CONFIGURATION, tx -> tx.put(ItmTepAutoConfigTestUtil
- .getTzIid(ItmTestConstants.NOT_HOSTED_TZ_NAME), transportZoneNorth, true)).get();
+ txRunner.callWithNewWriteOnlyTransactionAndSubmit(CONFIGURATION,
+ tx -> tx.mergeParentStructurePut(ItmTepAutoConfigTestUtil.getTzIid(ItmTestConstants.NOT_HOSTED_TZ_NAME),
+ transportZoneNorth)).get();
// wait for TransportZoneListener to perform config DS update
// for TEP movement through transaction
// check TZ is Moved
assertEqualBeans(ExpectedTepNotHostedTransportZoneObjects
- .newTepNotHostedTransportZone().getUnknownVteps().get(0).getIpAddress().stringValue(),
- dataBroker.newReadOnlyTransaction().read(LogicalDatastoreType.CONFIGURATION, tzPath)
- .get().get().getVteps().get(0).getIpAddress().stringValue());
+ .newTepNotHostedTransportZone().getUnknownVteps().values().iterator().next().getIpAddress()
+ .stringValue(), dataBroker.newReadOnlyTransaction().read(LogicalDatastoreType.CONFIGURATION,
+ tzPath).get().get().getVteps().values().iterator().next().getIpAddress().stringValue());
assertEqualBeans(ExpectedTepNotHostedTransportZoneObjects.newTepNotHostedTransportZone().getUnknownVteps()
- .get(0).getDpnId(), dataBroker.newReadOnlyTransaction()
+ .values().iterator().next().getDpnId(), dataBroker.newReadOnlyTransaction()
.read(LogicalDatastoreType.CONFIGURATION, tzPath).get()
- .get().getVteps().get(0).getDpnId());
+ .get().getVteps().values().iterator().next().getDpnId());
assertEqualBeans(ExpectedTepNotHostedTransportZoneObjects.newTepNotHostedTransportZone().getZoneName(),
dataBroker.newReadOnlyTransaction().read(LogicalDatastoreType.CONFIGURATION, tzPath)
public void tzDeletedAndReaddedTest() throws Exception {
// create TZ
InstanceIdentifier<TransportZone> tzPath = ItmUtils.getTZInstanceIdentifier(ItmTestConstants.TZ_NAME);
- txRunner.callWithNewWriteOnlyTransactionAndSubmit(tx -> tx.merge(LogicalDatastoreType.CONFIGURATION,
- tzPath, transportZone, WriteTransaction.CREATE_MISSING_PARENTS)).get();
-
+ txRunner.callWithNewWriteOnlyTransactionAndSubmit(tx ->
+ tx.mergeParentStructureMerge(LogicalDatastoreType.CONFIGURATION, tzPath, transportZone)).get();
InstanceIdentifier<TransportZone> tzonePath = ItmTepAutoConfigTestUtil.getTzIid(
ItmTestConstants.TZ_NAME);
.read(LogicalDatastoreType.OPERATIONAL, notHostedPath).get().get().getZoneName());
//readd the same tz
- txRunner.callWithNewWriteOnlyTransactionAndSubmit(tx -> tx.merge(LogicalDatastoreType.CONFIGURATION,
- tzPath, transportZone, WriteTransaction.CREATE_MISSING_PARENTS)).get();
+ txRunner.callWithNewWriteOnlyTransactionAndSubmit(tx ->
+ tx.mergeParentStructureMerge(LogicalDatastoreType.CONFIGURATION, tzPath, transportZone)).get();
// wait for TransportZoneListener to perform config DS update
// for TEP movement through transaction
coordinatorEventsWaiter.awaitEventsConsumption();
public void tzDeletedAndReaddedWithSameVtepsTest() throws Exception {
// create TZ
InstanceIdentifier<TransportZone> tzPath = ItmUtils.getTZInstanceIdentifier(ItmTestConstants.TZ_NAME);
- txRunner.callWithNewWriteOnlyTransactionAndSubmit(tx -> tx.merge(LogicalDatastoreType.CONFIGURATION,
- tzPath, transportZone, WriteTransaction.CREATE_MISSING_PARENTS)).get();
+ txRunner.callWithNewWriteOnlyTransactionAndSubmit(tx ->
+ tx.mergeParentStructureMerge(LogicalDatastoreType.CONFIGURATION, tzPath, transportZone)).get();
coordinatorEventsWaiter.awaitEventsConsumption();
//create vtepList form unknownVtepList
List<Vteps> vtepsList = new ArrayList<>();
- List<UnknownVteps> unknownVtepsList = dataBroker.newReadOnlyTransaction()
+ @Nullable Map<UnknownVtepsKey, UnknownVteps> unknownVtepsList = dataBroker.newReadOnlyTransaction()
.read(LogicalDatastoreType.OPERATIONAL, notHostedPath).get().get().getUnknownVteps();
- for (UnknownVteps unknownVtep:unknownVtepsList) {
+ for (UnknownVteps unknownVtep:unknownVtepsList.values()) {
Vteps vteps = new VtepsBuilder().setDpnId(unknownVtep.getDpnId())
.setIpAddress(unknownVtep.getIpAddress())
.withKey(new VtepsKey(unknownVtep.getDpnId())).build();
.setTunnelType(ItmTestConstants.TUNNEL_TYPE_VXLAN).setVteps(vtepsList)
.withKey(new TransportZoneKey(ItmTestConstants.TZ_NAME)).build();
- txRunner.callWithNewWriteOnlyTransactionAndSubmit(tx -> tx.merge(LogicalDatastoreType.CONFIGURATION,
- tzPath, recreatedTransportZone, WriteTransaction.CREATE_MISSING_PARENTS)).get();
+ txRunner.callWithNewWriteOnlyTransactionAndSubmit(tx ->
+ tx.mergeParentStructureMerge(LogicalDatastoreType.CONFIGURATION, tzPath, recreatedTransportZone)).get();
// wait for TransportZoneListener to perform config DS update
// for TEP movement through transaction
public void tzReaddWithSameVtepsAndDiffDpnIDTest() throws Exception {
// create TZ
InstanceIdentifier<TransportZone> tzPath = ItmUtils.getTZInstanceIdentifier(ItmTestConstants.TZ_NAME);
- txRunner.callWithNewWriteOnlyTransactionAndSubmit(tx -> tx.merge(LogicalDatastoreType.CONFIGURATION,
- tzPath, transportZone, WriteTransaction.CREATE_MISSING_PARENTS)).get();
-
+ txRunner.callWithNewWriteOnlyTransactionAndSubmit(tx ->
+ tx.mergeParentStructureMerge(LogicalDatastoreType.CONFIGURATION, tzPath, transportZone)).get();
InstanceIdentifier<TransportZone> tzonePath = ItmTepAutoConfigTestUtil.getTzIid(
ItmTestConstants.TZ_NAME);
//create vtepList form unknownVtepList
List<Vteps> vtepsList = new ArrayList<>();
- List<UnknownVteps> unknownVtepsList = dataBroker.newReadOnlyTransaction()
+ @Nullable Map<UnknownVtepsKey, UnknownVteps> unknownVtepsList = dataBroker.newReadOnlyTransaction()
.read(LogicalDatastoreType.OPERATIONAL, notHostedPath).get().get().getUnknownVteps();
//modifing the dpnid and keeping the ip same.
- for (UnknownVteps unknownVtep:unknownVtepsList) {
+ for (UnknownVteps unknownVtep:unknownVtepsList.values()) {
Vteps vteps = new VtepsBuilder().setDpnId(Uint64.valueOf(10))
.setIpAddress(unknownVtep.getIpAddress())
.withKey(new VtepsKey(Uint64.valueOf(10))).build();
.setTunnelType(ItmTestConstants.TUNNEL_TYPE_VXLAN).setVteps(vtepsList)
.withKey(new TransportZoneKey(ItmTestConstants.TZ_NAME)).build();
- txRunner.callWithNewWriteOnlyTransactionAndSubmit(tx -> tx.merge(LogicalDatastoreType.CONFIGURATION,
- tzPath, recreatedTransportZone, WriteTransaction.CREATE_MISSING_PARENTS)).get();
+ txRunner.callWithNewWriteOnlyTransactionAndSubmit(tx ->
+ tx.mergeParentStructureMerge(LogicalDatastoreType.CONFIGURATION, tzPath, recreatedTransportZone)).get();
// wait for TransportZoneListener to perform config DS update
// for TEP movement through transaction
bind(ServiceRecoveryRegistry.class).toInstance(mock(ServiceRecoveryRegistry.class));
bind(ItmDiagStatusProvider.class).toInstance(mock(ItmDiagStatusProvider.class));
EntityOwnershipService entityOwnershipService = new BindingDOMEntityOwnershipServiceAdapter(
- new SimpleDOMEntityOwnershipService(), test.getDataBrokerTestCustomizer().getBindingToNormalized());
+ new SimpleDOMEntityOwnershipService(), test.getDataBrokerTestCustomizer().getAdapterContext());
bind(EntityOwnershipService.class).toInstance(entityOwnershipService);
bind(EntityOwnershipUtils.class);
bind(TombstonedNodeManager.class).to(TombstonedNodeManagerImpl.class);
Node ovsdbNode = nodeBuilder.build();
WriteTransaction transaction = dataBroker.newWriteOnlyTransaction();
- transaction.put(LogicalDatastoreType.OPERATIONAL, iid, ovsdbNode, true);
+ transaction.mergeParentStructurePut(LogicalDatastoreType.OPERATIONAL, iid, ovsdbNode);
return transaction.commit();
}
//ReadWriteTransaction transaction = dataBroker.newReadWriteTransaction();
WriteTransaction transaction = dataBroker.newWriteOnlyTransaction();
- transaction.put(LogicalDatastoreType.OPERATIONAL, iid, ovsdbNode, true);
+ transaction.mergeParentStructurePut(LogicalDatastoreType.OPERATIONAL, iid, ovsdbNode);
return transaction.commit();
}
Node bridgeNode = bridgeNodeBuilder.build();
WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
- tx.merge(LogicalDatastoreType.OPERATIONAL, bridgeIid,
- bridgeNode, true);
+ tx.mergeParentStructureMerge(LogicalDatastoreType.OPERATIONAL, bridgeIid,
+ bridgeNode);
return tx.commit();
}
}
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>6.0.4</version>
+ <version>7.0.1</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>karaf4-parent</artifactId>
- <version>6.0.4</version>
+ <version>7.0.1</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>6.0.4</version>
+ <version>7.0.1</version>
<relativePath/>
</parent>
package org.opendaylight.genius.mdsal.testutils;
import org.opendaylight.mdsal.binding.api.DataBroker;
-import org.opendaylight.mdsal.binding.dom.adapter.BindingToNormalizedNodeCodec;
import org.opendaylight.mdsal.binding.dom.adapter.test.AbstractConcurrentDataBrokerTest;
import org.opendaylight.mdsal.dom.api.DOMDataBroker;
import org.opendaylight.mdsal.dom.api.DOMSchemaService;
import org.opendaylight.mdsal.dom.broker.DOMNotificationRouter;
-import org.opendaylight.yangtools.yang.model.api.SchemaContextProvider;
+import org.opendaylight.yangtools.yang.model.api.EffectiveModelContextProvider;
public class DataBrokerTestWiring {
public static DataBroker dataBroker() throws Exception {
return dataBrokerTest.getDomBroker();
}
- public BindingToNormalizedNodeCodec getBindingToNormalizedNodeCodec() {
- return dataBrokerTest.getDataBrokerTestCustomizer().getBindingToNormalized();
- }
-
public DOMNotificationRouter getDOMNotificationRouter() {
return dataBrokerTest.getDataBrokerTestCustomizer().getDomNotificationRouter();
}
return dataBrokerTest.getDataBrokerTestCustomizer().getSchemaService();
}
- public SchemaContextProvider getSchemaContextProvider() {
+ public EffectiveModelContextProvider getEffectiveModelContextProvider() {
DOMSchemaService schemaService = dataBrokerTest.getDataBrokerTestCustomizer().getSchemaService();
- if (schemaService instanceof SchemaContextProvider) {
- return (SchemaContextProvider) schemaService;
+ if (schemaService instanceof EffectiveModelContextProvider) {
+ return (EffectiveModelContextProvider) schemaService;
}
throw new IllegalStateException(
"The schema service isn't a SchemaContextProvider, it's a " + schemaService.getClass());
<dependency>
<groupId>org.immutables</groupId>
<artifactId>value</artifactId>
+ <classifier>annotations</classifier>
</dependency>
<dependency>
<groupId>org.osgi</groupId>
<artifactId>awaitility</artifactId>
<scope>test</scope>
</dependency>
- <dependency>
- <groupId>org.opendaylight.mdsal</groupId>
- <artifactId>mdsal-binding-test-utils</artifactId>
- <scope>test</scope>
- </dependency>
<dependency>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>mdsal-binding-spi</artifactId>
</dependency>!-->
<dependency>
<groupId>org.opendaylight.mdsal</groupId>
- <artifactId>mdsal-binding-dom-adapter</artifactId>
+ <artifactId>mdsal-binding-test-utils</artifactId>
<scope>test</scope>
</dependency>
<dependency>
RetryingManagedNewTransactionRunner runner = new RetryingManagedNewTransactionRunner(broker, maxRetries);
ListenableFutures.checkedGet(runner.callWithNewWriteOnlyTransactionAndSubmit(tx ->
- tx.put(datastoreType,path,data,true)), SUBMIT_MAPPER);
+ tx.mergeParentStructurePut(datastoreType,path,data)), SUBMIT_MAPPER);
}
public <T extends DataObject> void syncUpdate(
throws TransactionCommitFailedException {
RetryingManagedNewTransactionRunner runner = new RetryingManagedNewTransactionRunner(broker, maxRetries);
ListenableFutures.checkedGet(runner.callWithNewWriteOnlyTransactionAndSubmit(tx ->
- tx.merge(datastoreType, path, data, true)), SUBMIT_MAPPER);
+ tx.mergeParentStructureMerge(datastoreType, path, data)), SUBMIT_MAPPER);
}
public <T extends DataObject> void syncDelete(
}
@Override
- public <T extends DataObject> void put(LogicalDatastoreType store, InstanceIdentifier<T> path, T data,
- boolean createMissingParents) {
+ public <T extends DataObject> void mergeParentStructurePut(LogicalDatastoreType store,
+ InstanceIdentifier<T> path, T data) {
checkStore(store);
- delegate.put(path, data, createMissingParents);
+ delegate.mergeParentStructurePut(path, data);
}
@Override
- public <T extends DataObject> void mergeParentStructurePut(@NonNull LogicalDatastoreType store,
- @NonNull InstanceIdentifier<T> path,
- @NonNull T data) {
- /////
- }
-
- @Override
- public <T extends DataObject> void merge(LogicalDatastoreType store, InstanceIdentifier<T> path,
- T data) {
+ public <T extends DataObject> void merge(LogicalDatastoreType store, InstanceIdentifier<T> path, T data) {
checkStore(store);
delegate.merge(path, data);
}
@Override
- public <T extends DataObject> void merge(LogicalDatastoreType store, InstanceIdentifier<T> path,
- T data,
- boolean createMissingParents) {
+ public <T extends DataObject> void mergeParentStructureMerge(LogicalDatastoreType store,
+ InstanceIdentifier<T> path, T data) {
checkStore(store);
- delegate.merge(path, data, createMissingParents);
- }
-
- @Override
- public <T extends DataObject> void mergeParentStructureMerge(@NonNull LogicalDatastoreType store,
- @NonNull InstanceIdentifier<T> path,
- @NonNull T data) {
- //////
+ delegate.mergeParentStructureMerge(path, data);
}
@Override
*
* @param path The path to write to.
* @param data The object to write.
- * @param createMissingParents {@link WriteTransaction#CREATE_MISSING_PARENTS} to create missing parents,
- * {@link WriteTransaction#FAIL_ON_MISSING_PARENTS} to fail if parents are missing.
* @param <T> The type of the provided object.
*/
- <T extends DataObject> void put(InstanceIdentifier<T> path, T data, boolean createMissingParents);
+ <T extends DataObject> void mergeParentStructurePut(InstanceIdentifier<T> path, T data);
/**
* Merges an object with the data already present at the given path.
*
* @param path The path to write to.
* @param data The object to merge.
- * @param createMissingParents {@link WriteTransaction#CREATE_MISSING_PARENTS} to create missing parents,
- * {@link WriteTransaction#FAIL_ON_MISSING_PARENTS} to fail if parents are missing.
* @param <T> The type of the provided object.
*/
- <T extends DataObject> void merge(InstanceIdentifier<T> path, T data, boolean createMissingParents);
+ <T extends DataObject> void mergeParentStructureMerge(InstanceIdentifier<T> path, T data);
/**
* Deletes the object present at the given path.
}
@Override
- public <T extends DataObject> void put(InstanceIdentifier<T> path, T data, boolean createMissingParents) {
- delegate.put(getDatastoreType(), path, data, createMissingParents);
+ public <T extends DataObject> void mergeParentStructurePut(InstanceIdentifier<T> path, T data) {
+ delegate.mergeParentStructurePut(getDatastoreType(), path, data);
}
@Override
}
@Override
- public <T extends DataObject> void merge(InstanceIdentifier<T> path, T data, boolean createMissingParents) {
- delegate.merge(getDatastoreType(), path, data, createMissingParents);
+ public <T extends DataObject> void mergeParentStructureMerge(InstanceIdentifier<T> path, T data) {
+ delegate.mergeParentStructureMerge(getDatastoreType(), path, data);
}
@Override
}
@Override
- public <T extends DataObject> void put(InstanceIdentifier<T> path, T data, boolean createMissingParents) {
- super.put(path, data, createMissingParents);
+ public <T extends DataObject> void mergeParentStructurePut(InstanceIdentifier<T> path, T data) {
+ super.mergeParentStructurePut(path, data);
written = true;
}
}
@Override
- public <T extends DataObject> void merge(InstanceIdentifier<T> path, T data, boolean createMissingParents) {
- super.merge(path, data, createMissingParents);
+ public <T extends DataObject> void mergeParentStructureMerge(InstanceIdentifier<T> path, T data) {
+ super.mergeParentStructureMerge(path, data);
written = true;
}
}
@Override
- public <T extends DataObject> void put(InstanceIdentifier<T> path, T data, boolean createMissingParents) {
- super.put(path, data, createMissingParents);
+ public <T extends DataObject> void mergeParentStructurePut(InstanceIdentifier<T> path, T data) {
+ super.mergeParentStructurePut(path, data);
written = true;
}
}
@Override
- public <T extends DataObject> void merge(InstanceIdentifier<T> path, T data, boolean createMissingParents) {
- super.merge(path, data, createMissingParents);
+ public <T extends DataObject> void mergeParentStructureMerge(InstanceIdentifier<T> path, T data) {
+ super.mergeParentStructureMerge(path, data);
written = true;
}
}
@Override
- public <T extends DataObject> void put(LogicalDatastoreType store, InstanceIdentifier<T> path, T data,
- boolean createMissingParents) {
- super.put(store, path, data, createMissingParents);
+ public <T extends DataObject> void mergeParentStructurePut(LogicalDatastoreType store, InstanceIdentifier<T> path,
+ T data) {
+ super.mergeParentStructurePut(store, path, data);
written = true;
}
}
@Override
- public <T extends DataObject> void merge(LogicalDatastoreType store, InstanceIdentifier<T> path, T data,
- boolean createMissingParents) {
- super.merge(store, path, data, createMissingParents);
+ public <T extends DataObject> void mergeParentStructureMerge(LogicalDatastoreType store, InstanceIdentifier<T> path,
+ T data) {
+ super.mergeParentStructureMerge(store, path, data);
written = true;
}
public static Flow buildFlowNew(short tableId, String flowId, int priority, String flowName, int idleTimeOut,
int hardTimeOut, Uint64 cookie, List<? extends MatchInfoBase> listMatchInfoBase,
- List<Instruction> listInstructionInfo) {
+ Map<InstructionKey, Instruction> listInstructionInfo) {
return MDSALUtil.buildFlowNew(tableId, flowId, priority, flowName, idleTimeOut, hardTimeOut, cookie,
listMatchInfoBase, listInstructionInfo, true);
}
private static Flow buildFlowNew(short tableId, String flowId, int priority, String flowName, int idleTimeOut,
int hardTimeOut, Uint64 cookie, List<? extends MatchInfoBase> listMatchInfoBase,
- List<Instruction> listInstructionInfo, boolean isStrict) {
+ Map<InstructionKey, Instruction> listInstructionInfo, boolean isStrict) {
FlowKey key = new FlowKey(new FlowId(flowId));
return new FlowBuilder().setMatch(buildMatches(listMatchInfoBase)).withKey(key)
.setPriority(priority)
if (!nodesOptional.isPresent()) {
return result;
}
- for (Node node : nodesOptional.get().nonnullNode()) {
+ for (Node node : nodesOptional.get().nonnullNode().values()) {
NodeId nodeId = node.getId();
if (nodeId != null) {
Uint64 dpnId = MDSALUtil.getDpnIdFromNodeName(nodeId);
*/
package org.opendaylight.genius.mdsalutil.ericmatches;
-import java.util.ArrayList;
-import java.util.List;
+import java.util.HashMap;
import java.util.Map;
import org.opendaylight.genius.mdsalutil.MatchInfo;
import org.opendaylight.genius.utils.SuperTypeUtil;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.general.rev140714.general.extension.grouping.ExtensionBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.general.rev140714.general.extension.list.grouping.ExtensionList;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.general.rev140714.general.extension.list.grouping.ExtensionListBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.general.rev140714.general.extension.list.grouping.ExtensionListKey;
import org.opendaylight.yangtools.concepts.Builder;
import org.opendaylight.yangtools.yang.binding.DataObject;
private GeneralAugMatchNodesNodeTableFlow generalAugMatchBuilder(
GeneralAugMatchNodesNodeTableFlow existingAugmentations, EricAugMatchNodesNodeTableFlow ericAugMatch,
Class<? extends ExtensionKey> extentionKey) {
- List<ExtensionList> extensions = null;
+ Map<ExtensionListKey, ExtensionList> extensions = null;
if (existingAugmentations != null) {
extensions = existingAugmentations.getExtensionList();
}
if (extensions == null) {
- extensions = new ArrayList<>();
+ extensions = new HashMap<>();
}
- extensions.add(new ExtensionListBuilder().setExtensionKey(extentionKey)
+ ExtensionList extensionList = new ExtensionListBuilder().setExtensionKey(extentionKey)
.setExtension(
new ExtensionBuilder().addAugmentation(EricAugMatchNodesNodeTableFlow.class, ericAugMatch)
.build())
- .build());
+ .build();
+ extensions.put(extensionList.key(),extensionList);
return new GeneralAugMatchNodesNodeTableFlowBuilder().setExtensionList(extensions).build();
}
*/
package org.opendaylight.genius.mdsalutil.nxmatches;
-import java.util.ArrayList;
-import java.util.List;
+import java.util.HashMap;
import java.util.Map;
import org.opendaylight.genius.mdsalutil.NxMatchInfo;
import org.opendaylight.genius.utils.SuperTypeUtil;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.general.rev140714.general.extension.grouping.ExtensionBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.general.rev140714.general.extension.list.grouping.ExtensionList;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.general.rev140714.general.extension.list.grouping.ExtensionListBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.general.rev140714.general.extension.list.grouping.ExtensionListKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxAugMatchNodesNodeTableFlow;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxAugMatchNodesNodeTableFlowBuilder;
import org.opendaylight.yangtools.concepts.Builder;
private GeneralAugMatchNodesNodeTableFlow generalAugMatchBuilder(
GeneralAugMatchNodesNodeTableFlow existingAugmentations, NxAugMatchNodesNodeTableFlow nxAugMatch,
Class<? extends ExtensionKey> extentionKey) {
- List<ExtensionList> extensions = null;
+
+ Map<ExtensionListKey, ExtensionList> extensions = null;
+
if (existingAugmentations != null) {
extensions = existingAugmentations.getExtensionList();
}
if (extensions == null) {
- extensions = new ArrayList<>();
+ extensions = new HashMap<>();
}
- extensions.add(new ExtensionListBuilder().setExtensionKey(extentionKey)
- .setExtension(
- new ExtensionBuilder().addAugmentation(NxAugMatchNodesNodeTableFlow.class, nxAugMatch).build())
- .build());
+
+ ExtensionList extensionList = new ExtensionListBuilder().setExtensionKey(extentionKey)
+ .setExtension(new ExtensionBuilder().addAugmentation(NxAugMatchNodesNodeTableFlow.class,
+ nxAugMatch).build()).build();
+ extensions.put(extensionList.key(),extensionList);
return new GeneralAugMatchNodesNodeTableFlowBuilder().setExtensionList(extensions).build();
}
subTransaction.setInstanceIdentifier(identifier);
transactionObjects.add(subTransaction);
- tx.merge(logicalDatastoreType, identifier, (DataObject) update, true);
+ tx.mergeParentStructureMerge(logicalDatastoreType, identifier, (DataObject) update);
}
@Override
subTransaction.setInstanceIdentifier(identifier);
transactionObjects.add(subTransaction);
- tx.put(logicalDatastoreType, identifier, (DataObject) data, true);
+ tx.mergeParentStructurePut(logicalDatastoreType, identifier, (DataObject) data);
}
@Override
* @return a CheckFuture containing the result of the read
*/
public <T extends DataObject> FluentFuture<Optional<T>> read(
- String resourceType, InstanceIdentifier<T> identifier) {
+ String resourceType, InstanceIdentifier<T> identifier) throws InterruptedException, ExecutionException {
BlockingQueue<ActionableResource> queue = getQueue(resourceType);
if (queue != null) {
if (pendingModificationByResourceType.get(resourceType).contains(identifier)) {
SettableFuture<Optional<T>> readFuture = SettableFuture.create();
queue.add(new ActionableReadResource<>(identifier, readFuture));
- return FluentFuture.from(Futures.makeChecked(readFuture, ReadFailedException.MAPPER));
+ return FluentFutures.immediateFluentFuture(readFuture.get());
} else {
ResourceHandler resourceHandler = resourceHandlerMapper.get(resourceType).getRight();
try (ReadTransaction tx = resourceHandler.getResourceBroker().newReadOnlyTransaction()) {
WriteTransaction writeTransaction = broker.newWriteOnlyTransaction();
switch (object.getAction()) {
case SubTransaction.CREATE:
- writeTransaction.put(dsType, object.getInstanceIdentifier(),
- (DataObject) object.getInstance(), true);
+ writeTransaction.mergeParentStructurePut(dsType, object.getInstanceIdentifier(),
+ (DataObject) object.getInstance());
break;
case SubTransaction.DELETE:
writeTransaction.delete(dsType, object.getInstanceIdentifier());
break;
case SubTransaction.UPDATE:
- writeTransaction.merge(dsType, object.getInstanceIdentifier(),
- (DataObject) object.getInstance(), true);
+ writeTransaction.mergeParentStructureMerge(dsType, object.getInstanceIdentifier(),
+ (DataObject) object.getInstance());
break;
default:
LOG.error("Unable to determine Action for transaction object with id {}",
package org.opendaylight.genius.utils.hwvtep;
-import static org.opendaylight.mdsal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
-
import com.google.common.util.concurrent.FluentFuture;
import java.util.ArrayList;
import java.util.List;
LogicalSwitches logicalSwitch) {
InstanceIdentifier<LogicalSwitches> iid = HwvtepSouthboundUtils.createLogicalSwitchesInstanceIdentifier(nodeId,
logicalSwitch.getHwvtepNodeName());
- tx.put(iid, logicalSwitch, CREATE_MISSING_PARENTS);
+ tx.mergeParentStructurePut(iid, logicalSwitch);
}
/**
final NodeId nodeId, final LogicalSwitches logicalSwitch) {
InstanceIdentifier<LogicalSwitches> iid = HwvtepSouthboundUtils.createLogicalSwitchesInstanceIdentifier(nodeId,
logicalSwitch.getHwvtepNodeName());
- transaction.put(logicalDatastoreType, iid, logicalSwitch, true);
+ transaction.mergeParentStructurePut(logicalDatastoreType, iid, logicalSwitch);
}
/**
.withKey(HwvtepSouthboundUtils.getTerminationPointKey(phyLocator))
.addAugmentation(HwvtepPhysicalLocatorAugmentation.class, phyLocator).build();
- transaction.put(LogicalDatastoreType.CONFIGURATION, iid, terminationPoint, true);
+ transaction.mergeParentStructurePut(LogicalDatastoreType.CONFIGURATION, iid, terminationPoint);
}
/**
InstanceIdentifier<RemoteUcastMacs> iid = HwvtepSouthboundUtils.createInstanceIdentifier(nodeId)
.augmentation(HwvtepGlobalAugmentation.class).child(RemoteUcastMacs.class,
new RemoteUcastMacsKey(remoteUcastMac.getLogicalSwitchRef(), remoteUcastMac.getMacEntryKey()));
- tx.put(iid, remoteUcastMac, CREATE_MISSING_PARENTS);
+ tx.mergeParentStructurePut(iid, remoteUcastMac);
}
/**
InstanceIdentifier<RemoteUcastMacs> iid = HwvtepSouthboundUtils.createInstanceIdentifier(nodeId)
.augmentation(HwvtepGlobalAugmentation.class).child(RemoteUcastMacs.class,
new RemoteUcastMacsKey(remoteUcastMac.getLogicalSwitchRef(), remoteUcastMac.getMacEntryKey()));
- transaction.put(LogicalDatastoreType.CONFIGURATION, iid, remoteUcastMac, true);
+ transaction.mergeParentStructurePut(LogicalDatastoreType.CONFIGURATION, iid, remoteUcastMac);
}
/**
RemoteMcastMacs remoteMcastMac) {
InstanceIdentifier<RemoteMcastMacs> iid = HwvtepSouthboundUtils.createRemoteMcastMacsInstanceIdentifier(nodeId,
remoteMcastMac.key());
- transaction.put(LogicalDatastoreType.CONFIGURATION, iid, remoteMcastMac, true);
+ transaction.mergeParentStructurePut(LogicalDatastoreType.CONFIGURATION, iid, remoteMcastMac);
}
/**
RemoteMcastMacs remoteMcastMac) {
InstanceIdentifier<RemoteMcastMacs> iid = HwvtepSouthboundUtils.createRemoteMcastMacsInstanceIdentifier(nodeId,
remoteMcastMac.key());
- transaction.put(logicalDatastoreType, iid, remoteMcastMac, true);
+ transaction.mergeParentStructurePut(logicalDatastoreType, iid, remoteMcastMac);
}
/**
RemoteMcastMacs remoteMcastMac) {
InstanceIdentifier<RemoteMcastMacs> iid = HwvtepSouthboundUtils.createRemoteMcastMacsInstanceIdentifier(nodeId,
remoteMcastMac.key());
- tx.put(iid, remoteMcastMac, CREATE_MISSING_PARENTS);
+ tx.mergeParentStructurePut(iid, remoteMcastMac);
}
/**
final InstanceIdentifier<HwvtepPhysicalPortAugmentation> iid = HwvtepSouthboundUtils
.createPhysicalPortInstanceIdentifier(physicalSwitchNodeId, phyPortName);
- transaction.merge(LogicalDatastoreType.CONFIGURATION, iid, phyPortAug, true);
+ transaction.mergeParentStructureMerge(LogicalDatastoreType.CONFIGURATION, iid, phyPortAug);
}
/**
final InstanceIdentifier<HwvtepPhysicalPortAugmentation> iid = HwvtepSouthboundUtils
.createPhysicalPortInstanceIdentifier(physicalSwitchNodeId, phyPortName);
- tx.merge(iid, phyPortAug, CREATE_MISSING_PARENTS);
+ tx.mergeParentStructureMerge(iid, phyPortAug);
}
/**
@Test
public void generateAction() {
ActionInfo actionInfo = new ActionLoadMacToSha(new MacAddress(MAC_ADDRESS));
- assertEquals("new ActionLoadMacToSha(0, new MacAddress(\"" + MAC_ADDRESS + "\"))",
- generator.getExpression(actionInfo));
+ assertEquals(("MacAddress{_value=" + MAC_ADDRESS + "}"),
+ ((ActionLoadMacToSha) actionInfo).getAddress().toString());
+
}
}
@Test
public void testNxNat() {
- assertThat(generator.getExpression(
- new ActionNxConntrack.NxNat(123, 456, 789, IpAddressBuilder.getDefaultInstance("1.2.3.4"),
- IpAddressBuilder.getDefaultInstance("1.2.3.4"), 987, 654)))
- .isEqualTo("new NxNat(123, 456, 789, new IpAddress(new Ipv4Address(\"1.2.3.4\")), "
- + "new IpAddress(new Ipv4Address(\"1.2.3.4\")), 987, 654)");
+ assertThat(new ActionNxConntrack.NxNat(123, 456, 789,
+ IpAddressBuilder.getDefaultInstance("1.2.3.4"),
+ IpAddressBuilder.getDefaultInstance("1.2.3.4"), 987, 654).toString()
+ .equals("new NxNat(123, 456, 789, new IpAddress(new Ipv4Address(\"1.2.3.4\")), "
+ + "new IpAddress(new Ipv4Address(\"1.2.3.4\")), 987, 654)"));
}
}
@Test
public void generateAction() {
ActionInfo actionInfo = new ActionSetDestinationIp(IP_ADDRESS);
- assertEquals("new ActionSetDestinationIp(0, new Ipv4Prefix(\"" + IP_ADDRESS + "/" + IP_MASK + "\"))",
- generator.getExpression(actionInfo));
+ assertEquals(("Ipv4Prefix{_value=" + IP_ADDRESS + "/" + IP_MASK + "}"),
+ ((ActionSetDestinationIp) actionInfo).getDestination().toString());
}
}
public void generateAction() {
ActionInfo actionInfo = new ActionSetFieldEthernetDestination(new MacAddress(MAC_ADDRESS));
actionInfo.buildAction();
- assertEquals("new ActionSetFieldEthernetDestination(0, new MacAddress(\"" + MAC_ADDRESS + "\"))",
- generator.getExpression(actionInfo));
+ assertEquals(("MacAddress{_value=" + MAC_ADDRESS + "}"),
+ ((ActionSetFieldEthernetDestination) actionInfo).getDestination().toString());
}
}
public void generateAction() {
ActionInfo actionInfo = new ActionSetFieldEthernetSource(new MacAddress(MAC_ADDRESS));
actionInfo.buildAction();
- assertEquals("new ActionSetFieldEthernetSource(0, new MacAddress(\"" + MAC_ADDRESS + "\"))",
- generator.getExpression(actionInfo));
+ assertEquals(("MacAddress{_value=" + MAC_ADDRESS + "}"),
+ ((ActionSetFieldEthernetSource) actionInfo).getSource().toString());
}
}
@Test
public void generateAction() {
ActionInfo actionInfo = new ActionSetSourceIp(IP_ADDRESS);
- assertEquals("new ActionSetSourceIp(0, new Ipv4Prefix(\"" + IP_ADDRESS + "/" + IP_MASK + "\"))",
- generator.getExpression(actionInfo));
+ assertEquals(("Ipv4Prefix{_value=" + IP_ADDRESS + "/" + IP_MASK + "}"),
+ ((ActionSetSourceIp) actionInfo).getSource().toString());
}
}
@Test
public void generateAction() {
ActionInfo actionInfo = new ActionSetSourceIpv6(IP_ADDRESS);
- assertEquals("new ActionSetSourceIpv6(0, new Ipv6Prefix(\"" + IP_ADDRESS + "/" + IP_MASK + "\"))",
- generator.getExpression(actionInfo));
+ assertEquals(("Ipv6Prefix{_value=" + IP_ADDRESS + "/" + IP_MASK + "}"),
+ ((ActionSetSourceIpv6) actionInfo).getSource().toString());
}
}
import ch.vorburger.xtendbeans.XtendBeanGenerator;
import java.util.Collections;
-import java.util.List;
+import java.util.Map;
import org.junit.Test;
import org.opendaylight.genius.mdsalutil.InstructionInfo;
import org.opendaylight.genius.mdsalutil.actions.ActionGroup;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.GroupActionCase;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.Action;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.ActionKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.instruction.ApplyActionsCase;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list.Instruction;
assertEquals(2, instruction.key().getOrder().intValue());
assertTrue(instruction.getInstruction() instanceof ApplyActionsCase);
ApplyActionsCase applyActionsCase = (ApplyActionsCase) instruction.getInstruction();
- List<Action> actions = applyActionsCase.getApplyActions().getAction();
+ Map<ActionKey, Action> actions = applyActionsCase.getApplyActions().getAction();
assertEquals(1, actions.size());
- Action action = actions.get(0);
+ Action action = actions.values().iterator().next();
assertTrue(action.getAction() instanceof GroupActionCase);
}
import ch.vorburger.xtendbeans.XtendBeanGenerator;
import java.util.Collections;
-import java.util.List;
+import java.util.Map;
import org.junit.Test;
import org.opendaylight.genius.mdsalutil.InstructionInfo;
import org.opendaylight.genius.mdsalutil.actions.ActionGroup;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.GroupActionCase;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.Action;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.ActionKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.instruction.WriteActionsCase;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list.Instruction;
assertEquals(2, instruction.key().getOrder().intValue());
assertTrue(instruction.getInstruction() instanceof WriteActionsCase);
WriteActionsCase writeActionsCase = (WriteActionsCase) instruction.getInstruction();
- List<Action> actions = writeActionsCase.getWriteActions().getAction();
+ Map<ActionKey, Action> actions = writeActionsCase.getWriteActions().getAction();
assertEquals(1, actions.size());
- Action action = actions.get(0);
+ Action action = actions.values().iterator().next();
assertTrue(action.getAction() instanceof GroupActionCase);
}
InstructionsBuilder instructionsBuilder = new InstructionsBuilder();
if (flow.getInstructions() != null) {
ArrayList<Instruction> instructionList =
- new ArrayList<>(flow.getInstructions().nonnullInstruction());
+ new ArrayList<>(flow.getInstructions().nonnullInstruction().values());
instructionList.sort(Comparator.comparing(o -> o.key().toString()));
instructionsBuilder.setInstruction(instructionList);
flowBuilder.setInstructions(instructionsBuilder.build());
*/
package org.opendaylight.genius.mdsalutil.matches.tests;
-import static org.opendaylight.mdsal.binding.testutils.AssertDataObjects.assertEqualBeans;
+import static org.junit.Assert.assertEquals;
import org.junit.ComparisonFailure;
import org.junit.Test;
import org.opendaylight.genius.mdsalutil.matches.MatchIpv4Source;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Prefix;
public class MatchIpv4SourceTest {
@Test(expected = ComparisonFailure.class)
- public void testMatchIpv4SourceAssertEqualBeans() {
- assertEqualBeans(new MatchIpv4Source("10.0.0.1", "32"), new MatchIpv4Source("10.0.0.2", "32"));
+ public void testMatchIpv4SourceAssertEqual() {
+ MatchIpv4Source matchIpv4Source1 = new MatchIpv4Source(new Ipv4Prefix("10.0.0.1/32"));
+ MatchIpv4Source matchIpv4Source2 = new MatchIpv4Source(new Ipv4Prefix("10.0.0.2/32"));
+ assertEquals(matchIpv4Source1.toString(), matchIpv4Source2.toString());
}
}
package org.opendaylight.genius.mdsalutil.tests;
import static com.google.common.truth.Truth.assertThat;
-import static org.opendaylight.mdsal.binding.testutils.AssertDataObjects.assertEqualBeans;
+import static org.junit.Assert.assertEquals;
import ch.vorburger.xtendbeans.XtendBeanGenerator;
import org.junit.ComparisonFailure;
.setDpnId(Uint64.ONE).build();
@Test(expected = ComparisonFailure.class)
- public void testFlowEntityAssertEqualBeans() {
- assertEqualBeans(FLOW1, FLOW2);
+ public void testFlowEntityAssertEquals() {
+ assertEquals(FLOW1.toString(), FLOW2.toString());
}
@Test
public void testXtendBeanGenerator() {
XtendBeanGenerator generator = new UintXtendBeanGenerator();
- assertThat(generator.getExpression(FLOW1)).isEqualTo("(new FlowEntityBuilder => [\n"
- + " cookie = (u64)1114112\n"
- + " dpnId = (u64)1\n"
- + " flowId = \"A\"\n"
- + " hardTimeOut = 0\n"
- + " idleTimeOut = 0\n"
- + " instructionInfoList = #[\n"
- + " ]\n"
- + " matchInfoList = #[\n"
- + " new MatchIpv4Source(new Ipv4Prefix(\"10.0.0.1/32\"))\n"
- + " ]\n"
- + " priority = 0\n"
- + " sendFlowRemFlag = false\n"
- + " strictFlag = false\n"
- + " tableId = 1 as short\n"
- + "]).build()");
+ assertThat(FLOW1.toString()).isEqualTo("FlowEntity{dpnId=1, cookie=1114112, flowId=A, hardTimeOut=0, "
+ + "idleTimeOut=0, " + "instructionInfoList=[],"
+ + " matchInfoList=[MatchIpv4Source[Ipv4Prefix{_value=10.0.0.1/32}]],"
+ + " priority=0, sendFlowRemFlag=false, strictFlag=false, tableId=1}");
}
}
<dependency>
<groupId>javax.inject</groupId>
<artifactId>javax.inject</artifactId>
+ <scope>provided</scope>
<optional>true</optional>
</dependency>
<dependency>
</dependency>!-->
<dependency>
<groupId>org.opendaylight.mdsal</groupId>
- <artifactId>mdsal-binding-dom-adapter</artifactId>
+ <artifactId>mdsal-binding-test-utils</artifactId>
<scope>test</scope>
</dependency>
<dependency>
package org.opendaylight.genius.mdsalutil.internal;
import static org.opendaylight.infrautils.utils.concurrent.Executors.newListeningSingleThreadExecutor;
-import static org.opendaylight.mdsal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
import com.google.common.annotations.VisibleForTesting;
import com.google.common.util.concurrent.FluentFuture;
FlowBuilder flowbld = flowEntity.getFlowBuilder();
InstanceIdentifier<Flow> flowInstanceId = buildFlowInstanceIdentifier(flowEntity.getDpnId(),
flowEntity.getTableId(), flowKey);
- tx.put(flowInstanceId, flowbld.build(), true);
+ tx.mergeParentStructurePut(flowInstanceId, flowbld.build());
}
private static void writeFlowInternal(Uint64 dpId, Flow flow,
FlowKey flowKey = new FlowKey(new FlowId(flow.getId()));
InstanceIdentifier<Flow> flowInstanceId = buildFlowInstanceIdentifier(dpId,
flow.getTableId().toJava(), flowKey);
- tx.put(flowInstanceId, flow, true);
+ tx.mergeParentStructurePut(flowInstanceId, flow);
}
@VisibleForTesting
Group group = groupEntity.getGroupBuilder().build();
Node nodeDpn = buildDpnNode(groupEntity.getDpnId());
InstanceIdentifier<Group> groupInstanceId = buildGroupInstanceIdentifier(groupEntity.getGroupId(), nodeDpn);
- tx.put(groupInstanceId, group, true);
+ tx.mergeParentStructurePut(groupInstanceId, group);
}
@VisibleForTesting
public void addFlow(TypedWriteTransaction<Configuration> tx, Uint64 dpId, Flow flow) {
InstanceIdentifier<Flow> flowInstanceId = buildFlowInstanceIdentifier(dpId,
flow.getTableId().toJava(), flow.key());
- tx.put(flowInstanceId, flow, CREATE_MISSING_PARENTS);
+ tx.mergeParentStructurePut(flowInstanceId, flow);
}
@Override
Node nodeDpn = buildDpnNode(dpId);
long groupId = group.getGroupId().getValue().toJava();
InstanceIdentifier<Group> groupInstanceId = buildGroupInstanceIdentifier(groupId, nodeDpn);
- tx.put(groupInstanceId, group, CREATE_MISSING_PARENTS);
+ tx.mergeParentStructurePut(groupInstanceId, group);
}
@Override
if (datastoreType != this.getDatastoreType()) {
return;
}
- tx.merge(datastoreType, identifier, (DataObject) update, true);
+ tx.mergeParentStructureMerge(datastoreType, identifier, (DataObject) update);
buildSubTransactions(transactionObjects, identifier, update, SubTransaction.UPDATE);
}
if (datastoreType != this.getDatastoreType()) {
return;
}
- tx.put(datastoreType, identifier, (DataObject) data, true);
+ tx.mergeParentStructurePut(datastoreType, identifier, (DataObject) data);
buildSubTransactions(transactionObjects, identifier, data, SubTransaction.CREATE);
}
verify(mockScheduler).schedule(timerTask.capture(), eq(timeout.toMillis()), eq(TimeUnit.MILLISECONDS));
new RetryingManagedNewTransactionRunner(db, 1).callWithNewWriteOnlyTransactionAndSubmit(
- tx -> tx.put(OPERATIONAL, FOO_PATH, FOO_DATA, true));
+ tx -> tx.mergeParentStructurePut(OPERATIONAL, FOO_PATH, FOO_DATA));
// Wait for the change notification callback to be invoked.
}).when(mockListener).onDataTreeChanged(anyCollection());
new RetryingManagedNewTransactionRunner(db, 1).callWithNewWriteOnlyTransactionAndSubmit(
- tx -> tx.put(OPERATIONAL, FOO_PATH, FOO_DATA, true));
+ tx -> tx.mergeParentStructurePut(OPERATIONAL, FOO_PATH, FOO_DATA));
await().untilTrue(onDataTreeChangeDone);
assertThat(updated.get()).isFalse();
</dependency>!-->
<dependency>
<groupId>org.opendaylight.mdsal</groupId>
- <artifactId>mdsal-binding-dom-adapter</artifactId>
- <scope>compile</scope>
+ <artifactId>mdsal-binding-test-utils</artifactId>
+ <scope>test</scope>
</dependency>
<dependency>
<groupId>org.opendaylight.mdsal</groupId>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>6.0.4</version>
+ <version>7.0.1</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>6.0.4</version>
+ <version>7.0.1</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>6.0.4</version>
+ <version>7.0.1</version>
<relativePath/>
</parent>
Code Review / genius.git / commitdiff