InterfaceAcl interfaceAclAfter = new InterfaceAclBuilder(interfaceAclBefore).setSecurityGroups(sgList)
.build();
Interface interfaceAfter = new InterfaceBuilder(interfaceBefore)
- .addAugmentation(InterfaceAcl.class,interfaceAclAfter).build();
+ .addAugmentation(interfaceAclAfter).build();
aclInterfaceListener.update(null, interfaceBefore, interfaceAfter);
aclInterfaceListener.update(null, interfaceAfter, interfaceBefore);
} else {
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.servicebinding.rev160406.ServiceModeBase;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.servicebinding.rev160406.ServiceModeEgress;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.servicebinding.rev160406.ServiceTypeFlowBased;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.servicebinding.rev160406.StypeOpenflow;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.servicebinding.rev160406.StypeOpenflowBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.servicebinding.rev160406.service.bindings.ServicesInfo;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.servicebinding.rev160406.service.bindings.ServicesInfoKey;
.setInstruction(instructions);
return new BoundServicesBuilder().withKey(new BoundServicesKey(servicePriority)).setServiceName(serviceName)
.setServicePriority(servicePriority).setServiceType(ServiceTypeFlowBased.class)
- .addAugmentation(StypeOpenflow.class, augBuilder.build()).build();
+ .addAugmentation(augBuilder.build()).build();
}
public static List<Uuid> getUpdatedAclList(List<Uuid> updatedAclList, List<Uuid> currentAclList) {
// matching both lportTag and aclTag. Hence performing "or"
// operation on both lportTag and aclTag metadata.
Uint64 metaData = Uint64.fromLongBits(MetaDataUtil.getLportTagMetaData(lportTag).longValue()
- | (getRemoteAclTagMetadata(BigInteger.valueOf(remoteAclTag)).longValue()));
+ | getRemoteAclTagMetadata(BigInteger.valueOf(remoteAclTag)).longValue());
Uint64 metaDataMask = Uint64.fromLongBits(MetaDataUtil.METADATA_MASK_LPORT_TAG.longValue()
| MetaDataUtil.METADATA_MASK_REMOTE_ACL_TAG.longValue());
matches.add(new MatchMetadata(metaData, metaDataMask));
// matching both lportTag and conntrackClassifierType. Hence performing "or"
// operation on both lportTag and conntrackClassifierType metadata.
Uint64 metaData = Uint64.fromLongBits(MetaDataUtil.getLportTagMetaData(lportTag).longValue()
- | (MetaDataUtil.getAclConntrackClassifierTypeFromMetaData(
- Uint64.valueOf(conntrackClassifierType.getValue()))).longValue());
+ | MetaDataUtil.getAclConntrackClassifierTypeFromMetaData(
+ Uint64.valueOf(conntrackClassifierType.getValue())).longValue());
Uint64 metaDataMask = Uint64.fromLongBits(MetaDataUtil.METADATA_MASK_LPORT_TAG.longValue()
| MetaDataUtil.METADATA_MASK_ACL_CONNTRACK_CLASSIFIER_TYPE.longValue());
matches.add(new MatchMetadata(metaData, metaDataMask));
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160218.access.lists.acl.access.list.entries.ace.actions.packet.handling.PermitBuilder;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.aclservice.rev160608.DirectionBase;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.aclservice.rev160608.SecurityRuleAttr;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.aclservice.rev160608.SecurityRuleAttrBuilder;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.common.Empty;
.setPermit(Empty.getInstance()).build()
).build()
)
- .addAugmentation(SecurityRuleAttr.class, new SecurityRuleAttrBuilder()
+ .addAugmentation(new SecurityRuleAttrBuilder()
.setDirection(direction)
.setRemoteGroupId(optRemoteGroupId.orElse(null)).build()
).build();
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.InterfaceBuilder;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.InterfaceKey;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.aclservice.rev160608.InterfaceAcl;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.aclservice.rev160608.InterfaceAclBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.aclservice.rev160608.interfaces._interface.AllowedAddressPairs;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.aclservice.rev160608.interfaces._interface.SubnetInfo;
@Override
public Interface dataObject() {
return new InterfaceBuilder()
- .addAugmentation(InterfaceAcl.class, new InterfaceAclBuilder()
+ .addAugmentation(new InterfaceAclBuilder()
.setPortSecurityEnabled(portSecurity)
.setSecurityGroups(newSecurityGroups)
.setAllowedAddressPairs(ifAllowedAddressPairs)
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>7.0.6</version>
+ <version>8.1.0</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>7.0.6</version>
+ <version>8.1.0</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>7.0.6</version>
+ <version>8.1.0</version>
<relativePath/>
</parent>
public void withdrawPrefixIfPresent(String rd, String prefix) {
InstanceIdentifier<Networks> networksId = InstanceIdentifier.builder(Bgp.class)
.child(NetworksContainer.class)
- .child(Networks.class,
- new NetworksKey(rd, prefix)).build();
+ .child(Networks.class, new NetworksKey(rd, prefix))
+ .build();
try (ReadTransaction tx = dataBroker.newReadOnlyTransaction()) {
Futures.addCallback(tx.read(LogicalDatastoreType.CONFIGURATION, networksId),
new FutureCallback<Optional<Networks>>() {
private static InstanceIdentifier<ExternalTeps> getExternalTepsIdentifier(String elanInstanceName, String tepIp) {
IpAddress tepAdress = tepIp == null ? null : new IpAddress(new Ipv4Address(tepIp));
return InstanceIdentifier.builder(ElanInstances.class).child(ElanInstance.class,
- new ElanInstanceKey(elanInstanceName)).child(ExternalTeps.class,
+ new ElanInstanceKey(elanInstanceName)).child(ExternalTeps.class,
new ExternalTepsKey(tepAdress)).build();
}
*/
package org.opendaylight.netvirt.bgpmanager;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
}
public synchronized void addEntryToFibMap(String rd, String prefix, String nextHop) {
- ArrayList<String> temp = new ArrayList<String>();
- if ((fibMap.get(appendrdtoprefix(rd, prefix)) != null)) {
+ ArrayList<String> temp = new ArrayList<>();
+ if (fibMap.get(appendrdtoprefix(rd, prefix)) != null) {
temp.addAll(fibMap.get(appendrdtoprefix(rd, prefix)));
}
temp.add(nextHop);
return;
}
- Preconditions.checkNotNull(nextHopList, "NextHopList can't be null");
+ requireNonNull(nextHopList, "NextHopList can't be null");
for (String nextHop : nextHopList) {
if (nextHop == null || nextHop.isEmpty()) {
LOG.error("nextHop list contains null element");
LOG.debug("addFibEntryToDS rd {} prefix {} NH {}",
rd, prefix, nextHopList.get(0));
- ArrayList<String> temp = new ArrayList<String>();
- if ((fibMap.get(appendrdtoprefix(rd, prefix)) != null)) {
+ ArrayList<String> temp = new ArrayList<>();
+ if (fibMap.get(appendrdtoprefix(rd, prefix)) != null) {
temp.addAll(fibMap.get(appendrdtoprefix(rd, prefix)));
}
if (!temp.contains(nextHopList.get(0))) {
return;
}
- Preconditions.checkNotNull(nextHopList, "NextHopList can't be null");
+ requireNonNull(nextHopList, "NextHopList can't be null");
for (String nextHop : nextHopList) {
if (StringUtils.isEmpty(nextHop)) {
LOG.error("nextHop list contains null element for macVrf");
String inputCmd = "show " + command;
outToSocket.println(inputCmd);
- StringBuffer output = new StringBuffer();
+ StringBuilder output = new StringBuilder();
String errorMsg = "";
while (true) {
char[] opBuf = new char[100];
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.netvirt.bgpmanager.oam;
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.net.Socket;
import java.net.SocketTimeoutException;
import java.net.UnknownHostException;
+import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
try (Socket socket = new Socket(bgpSdncMip, 2605);
PrintWriter toRouter = new PrintWriter(socket.getOutputStream(), true);
BufferedReader fromRouter = new BufferedReader(new InputStreamReader(socket.getInputStream()));
- BufferedWriter toFile = new BufferedWriter(new FileWriter(filename, true))) {
+ BufferedWriter toFile = new BufferedWriter(new FileWriter(filename, StandardCharsets.UTF_8, true))) {
socket.setSoTimeout(2 * 1000);
// Wait for the password prompt
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>7.0.6</version>
+ <version>8.1.0</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>7.0.6</version>
+ <version>8.1.0</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>7.0.6</version>
+ <version>8.1.0</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>binding-parent</artifactId>
- <version>6.0.5</version>
+ <version>7.0.5</version>
<relativePath/>
</parent>
<dependency>
<groupId>org.opendaylight.infrautils</groupId>
<artifactId>infrautils-artifacts</artifactId>
- <version>1.8.1</version>
+ <version>1.9.5</version>
<type>pom</type>
<scope>import</scope>
</dependency>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>controller-artifacts</artifactId>
- <version>2.0.4</version>
+ <version>3.0.6</version>
<type>pom</type>
<scope>import</scope>
</dependency>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent</artifactId>
- <version>7.0.6</version>
+ <version>8.1.0</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>7.0.6</version>
+ <version>8.1.0</version>
<relativePath/>
</parent>
int payloadStart = startOffset + numBits;
int payloadSize = data.length * Byte.SIZE - payloadStart;
- if (payloadClass != null) {
- try {
- payload = payloadClass.newInstance();
- } catch (InstantiationException | IllegalAccessException e) {
- throw new RuntimeException(
- "Error parsing payload for Ethernet packet", e);
- }
+ if (payloadFactory != null) {
+ payload = payloadFactory.get();
payload.deserialize(data, payloadStart, payloadSize);
payload.setParent(this);
} else {
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.servicebinding.rev160406.ServiceBindings;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.servicebinding.rev160406.ServiceModeIngress;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.servicebinding.rev160406.ServiceTypeFlowBased;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.servicebinding.rev160406.StypeOpenflow;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.servicebinding.rev160406.StypeOpenflowBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.servicebinding.rev160406.service.bindings.ServicesInfo;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.servicebinding.rev160406.service.bindings.ServicesInfoKey;
}
private static Map<InstructionKey, Instruction> getDhcpArpInstructions(Long elanTag, int lportTag) {
- Map<InstructionKey, Instruction> mkInstructions = new HashMap<InstructionKey, Instruction>();
+ Map<InstructionKey, Instruction> mkInstructions = new HashMap<>();
int instructionKey = 0;
mkInstructions.put(new InstructionKey(++instructionKey), MDSALUtil.buildAndGetWriteMetadaInstruction(
ElanHelper.getElanMetadataLabel(elanTag, lportTag), ElanHelper.getElanMetadataMask(),
return new BoundServicesBuilder().withKey(new BoundServicesKey(servicePriority))
.setServiceName(serviceName).setServicePriority(servicePriority)
.setServiceType(ServiceTypeFlowBased.class)
- .addAugmentation(StypeOpenflow.class, augBuilder.build()).build();
+ .addAugmentation(augBuilder.build()).build();
}
@SuppressWarnings("checkstyle:IllegalCatch")
BiConsumer<InstanceIdentifier<SubnetToDhcpPort>, SubnetToDhcpPort> consumer) {
java.util.Optional<String> ip4Address = getIpV4Address(port);
java.util.Optional<String> subnetId = getNeutronSubnetId(port);
- if (!(ip4Address.isPresent() && subnetId.isPresent())) {
+ if ((!ip4Address.isPresent() || !subnetId.isPresent())) {
return;
}
LOG.trace("Adding SubnetPortData entry for subnet {}", subnetId.get());
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>7.0.6</version>
+ <version>8.1.0</version>
<relativePath/>
</parent>
<packaging>bundle</packaging>
<modelVersion>4.0.0</modelVersion>
- <dependencyManagement>
- <dependencies>
- <dependency>
- <groupId>com.google.inject</groupId>
- <artifactId>guice</artifactId>
- <version>4.2.2</version>
- </dependency>
- </dependencies>
- </dependencyManagement>
+ <dependencyManagement>
+ <dependencies>
+ <dependency>
+ <groupId>com.google.inject</groupId>
+
<artifactId>guice</artifactId>
+ <version>4.2.2</version>
+ </dependency>
+ </dependencies>
+ </dependencyManagement>
<dependencies>
<dependency>
<scope>provided</scope>
<optional>true</optional>
</dependency>
+ <dependency>
+ <groupId>org.osgi</groupId>
+ <artifactId>osgi.core</artifactId>
+ </dependency>
<!-- Only for unit-test -->
<dependency>
<dependency>
<groupId>org.opendaylight.infrautils</groupId>
<artifactId>metrics-impl-test</artifactId>
- <version>1.8.1</version>
<scope>test</scope>
</dependency>
<dependency>
import static org.opendaylight.mdsal.binding.util.Datastore.OPERATIONAL;
import com.google.common.base.Function;
-import com.google.common.collect.Sets;
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.io.File;
import java.io.FileOutputStream;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
+import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
data1 = cmd.getData(node1);
data2 = cmd.getData(node2);
}
- data1 = data1 == null ? Collections.EMPTY_LIST : data1;
- data2 = data2 == null ? Collections.EMPTY_LIST : data2;
+ data1 = data1 == null ? Collections.emptyList() : data1;
+ data2 = data2 == null ? Collections.emptyList() : data2;
if (parentChildComparison) {
data2 = cmd.transform(nodeIid1, data2);
for (DataObject dataObject : data2) {
map2.put(cmd.getKey(dataObject), dataObject);
}
- Set<DataObject> diff = Sets.newHashSet();
+ Set<DataObject> diff = new HashSet<>();
for (Entry<Identifier<?>, DataObject> entry : map1.entrySet()) {
DataObject obj1 = entry.getValue();
}
}
- diff = Sets.newHashSet();
+ diff = new HashSet<>();
for (Entry<Identifier<?>, DataObject> entry : map2.entrySet()) {
DataObject obj1 = entry.getValue();
DataObject obj2 = map1.get(entry.getKey());
import com.google.common.base.Splitter;
import com.google.common.base.Strings;
-import com.google.common.collect.Lists;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
if (dpId != null) {
otherConfigs = new ArrayList<>(bridgeAug.nonnullBridgeOtherConfigs().values());
if (otherConfigs == null) {
- otherConfigs = Lists.newArrayList();
+ otherConfigs = new ArrayList<>();
}
if (otherConfigs.stream().noneMatch(otherConfig ->
.setBridgeOtherConfigValue(dpIdVal).build());
}
} else {
- otherConfigs = Lists.newArrayList();
+ otherConfigs = new ArrayList<>();
}
} else {
- otherConfigs = Lists.newArrayList();
+ otherConfigs = new ArrayList<>();
if (mac != null) {
otherConfigs.add(new BridgeOtherConfigsBuilder()
.setBridgeOtherConfigKey(OTHER_CONFIG_HWADDR)
package org.opendaylight.netvirt.elan.internal;
import static java.util.Collections.emptyList;
+import static java.util.Objects.requireNonNull;
import static org.opendaylight.infrautils.utils.concurrent.LoggingFutures.addErrorLogging;
import static org.opendaylight.mdsal.binding.util.Datastore.CONFIGURATION;
import static org.opendaylight.mdsal.binding.util.Datastore.OPERATIONAL;
import static org.opendaylight.netvirt.elan.utils.ElanUtils.isVxlanNetworkOrVxlanSegment;
-import com.google.common.base.Preconditions;
-import com.google.common.collect.Lists;
import com.google.common.util.concurrent.FluentFuture;
import com.google.common.util.concurrent.ListenableFuture;
import java.math.BigInteger;
@SuppressWarnings("checkstyle:ForbidCertainMethod")
List<ListenableFuture<?>> addElanInterface(ElanInterface elanInterface,
InterfaceInfo interfaceInfo, ElanInstance elanInstance) {
- Preconditions.checkNotNull(elanInstance, "elanInstance cannot be null");
- Preconditions.checkNotNull(interfaceInfo, "interfaceInfo cannot be null");
- Preconditions.checkNotNull(elanInterface, "elanInterface cannot be null");
+ requireNonNull(elanInstance, "elanInstance cannot be null");
+ requireNonNull(interfaceInfo, "interfaceInfo cannot be null");
+ requireNonNull(elanInterface, "elanInterface cannot be null");
String interfaceName = elanInterface.getName();
String elanInstanceName = elanInterface.getElanInstanceName();
isFirstInterfaceInDpn, confTx);
Map<StaticMacEntriesKey, StaticMacEntries> staticMacEntriesMap =
elanInterface.nonnullStaticMacEntries();
- List<PhysAddress> staticMacAddresses = Lists.newArrayList();
+ List<PhysAddress> staticMacAddresses = new ArrayList<>();
if (ElanUtils.isNotEmpty(staticMacEntriesMap.values())) {
for (StaticMacEntries staticMacEntry : staticMacEntriesMap.values()) {
InstanceIdentifier<MacEntry> macId = getMacEntryOperationalDataPath(elanInstanceName,
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.atomic.AtomicInteger;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.genius.utils.batching.ResourceBatchingManager;
+import org.opendaylight.mdsal.binding.api.query.QueryExpression;
+import org.opendaylight.mdsal.binding.api.query.QueryResult;
import org.opendaylight.mdsal.binding.util.Datastore;
import org.opendaylight.mdsal.binding.util.Datastore.Configuration;
import org.opendaylight.mdsal.binding.util.TypedReadWriteTransaction;
public void updateMetric(Boolean update) {
this.updateMetric = update;
}
+
+ @Override
+ public <T extends @NonNull DataObject> FluentFuture<QueryResult<T>> execute(QueryExpression<T> query) {
+ throw new UnsupportedOperationException();
+ }
}
}
return childSwitchIds;
}
- return Collections.EMPTY_SET;
+ return Collections.emptySet();
}
public static HwvtepGlobalAugmentation getGlobalAugmentationOfNode(Node node) {
List<T> getDataSafe(Z existingData) {
if (existingData == null) {
- return Collections.EMPTY_LIST;
+ return Collections.emptyList();
}
List<T> result = getData(existingData);
if (result == null) {
- return Collections.EMPTY_LIST;
+ return Collections.emptyList();
}
return result;
}
return psNodeId.startsWith(globalNodeId) && psNodeId.contains("physicalswitch");
};
- static Predicate<InstanceIdentifier<Node>> IS_NOT_HA_CHILD = (iid) -> hwvtepHACache.getParent(iid) == null;
+ static Predicate<InstanceIdentifier<Node>> IS_NOT_HA_CHILD = iid -> hwvtepHACache.getParent(iid) == null;
private final IHAEventHandler haEventHandler;
private final HAOpClusteredListener haOpClusteredListener;
}
}
+ @Override
public void deregisterListener() {
LOG.info("Deregistering HAOpNodeListener");
super.close();
Optional<Node> globalNodeOptional = configTx.read(haNodePath).get();
if (globalNodeOptional.isPresent()) {
//Also update the manager section in config which helps in cluster reboot scenarios
- managers.stream().forEach((manager) -> {
+ managers.stream().forEach(manager -> {
InstanceIdentifier<Managers> managerIid = haNodePath
.augmentation(HwvtepGlobalAugmentation.class)
.child(Managers.class, manager.key());
tpAugmentationBuilder.setVlanStats(operPPAugmentation.getVlanStats());
tpAugmentationBuilder.setVlanBindings(operPPAugmentation.getVlanBindings());
- tpBuilder.addAugmentation(HwvtepPhysicalPortAugmentation.class,
- tpAugmentationBuilder.build());
+ tpBuilder.addAugmentation(tpAugmentationBuilder.build());
configTPList.add(tpBuilder.build());
});
}
}
InstanceIdentifier<Node> haGlobalPath = hwvtepHACache.getParent(disconnectedChildGlobalPath);
Set<InstanceIdentifier<Node>> childPsPaths = hwvtepHACache.getChildrenForHANode(haGlobalPath).stream()
- .map((childGlobalPath) -> HwvtepHAUtil.convertPsPath(childPsNode, childGlobalPath))
+ .map(childGlobalPath -> HwvtepHAUtil.convertPsPath(childPsNode, childGlobalPath))
.collect(Collectors.toSet());
//TODO validate what if this is null
if (haOpClusteredListener.getConnected(childPsPaths).isEmpty()) {
|| HwvtepHAUtil.isEmpty(hwvtepGlobalAugmentation.nonnullSwitches().values())) {
haOpClusteredListener.getConnectedNodes()
.stream()
- .filter((connectedIid) -> IS_PS_CHILD_TO_GLOBAL_NODE.test(childGlobalNodeId, connectedIid))
- .forEach((connectedIid) -> childPsIids.add(connectedIid));
+ .filter(connectedIid -> IS_PS_CHILD_TO_GLOBAL_NODE.test(childGlobalNodeId, connectedIid))
+ .forEach(connectedIid -> childPsIids.add(connectedIid));
} else {
hwvtepGlobalAugmentation.getSwitches().values().forEach(
- (switches) -> childPsIids.add(switches.getSwitchRef().getValue()));
+ switches -> childPsIids.add(switches.getSwitchRef().getValue()));
}
if (childPsIids.isEmpty()) {
LOG.info("HAOpNodeListener No child ps found for global {}", childGlobalNodeId);
}
- childPsIids.forEach((psIid) -> {
+ childPsIids.forEach(psIid -> {
try {
InstanceIdentifier<Node> childPsIid = psIid;
Optional<Node> childPsNode = tx.read(childPsIid).get();
ElanInstance elanInstance = elanInstanceCache.get(elanName).orElse(null);
elanL2GatewayUtils.removeMacsFromElanExternalDevices(elanInstance,
Lists.newArrayList(del.getMacAddress()));
- return Collections.EMPTY_LIST;
+ return Collections.emptyList();
});
}
}
});
}
-}
\ No newline at end of file
+}
if (psNode.augmentation(PhysicalSwitchAugmentation.class) != null) {
return psNode.augmentation(PhysicalSwitchAugmentation.class).nonnullTunnelIps().values();
}
- return Collections.EMPTY_LIST;
+ return Collections.emptyList();
}
private List<Node> readAllConfigNodes(TypedReadTransaction<Configuration> tx) {
if (topologyOptional != null && topologyOptional.isPresent() && topologyOptional.get().getNode() != null) {
return new ArrayList<>(topologyOptional.get().nonnullNode().values());
}
- return Collections.EMPTY_LIST;
+ return Collections.emptyList();
}
}
public List<MacAddress> getL2GwDeviceLocalMacs(String elanName, L2GatewayDevice l2gwDevice) {
Set<MacAddress> macs = new HashSet<>();
if (l2gwDevice == null) {
- return Collections.EMPTY_LIST;
+ return Collections.emptyList();
}
Collection<LocalUcastMacs> lstUcastLocalMacs = l2gwDevice.getUcastLocalMacs();
if (lstUcastLocalMacs != null && !lstUcastLocalMacs.isEmpty()) {
import static java.util.Collections.emptyList;
import static java.util.Collections.emptyMap;
+import static java.util.Objects.requireNonNull;
import static org.opendaylight.mdsal.binding.util.Datastore.CONFIGURATION;
-import com.google.common.base.Preconditions;
import com.google.common.base.Strings;
import com.google.common.collect.Lists;
import com.google.common.primitives.Ints;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.servicebinding.rev160406.ServiceBindings;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.servicebinding.rev160406.ServiceModeIngress;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.servicebinding.rev160406.ServiceTypeFlowBased;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.servicebinding.rev160406.StypeOpenflow;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.servicebinding.rev160406.StypeOpenflowBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.servicebinding.rev160406.service.bindings.ServicesInfo;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.servicebinding.rev160406.service.bindings.ServicesInfoKey;
private final IITMProvider iitmProvider;
private final ElanGroupCache elanGroupCache;
- public static final FutureCallback<CommitInfo> DEFAULT_CALLBACK = new FutureCallback<CommitInfo>() {
+ public static final FutureCallback<CommitInfo> DEFAULT_CALLBACK = new FutureCallback<>() {
@Override
public void onSuccess(CommitInfo result) {
LOG.debug("Success in Datastore operation");
LOG.debug("RPC Call to Get egress actions for interface {} returned with Errors {}", ifName,
rpcResult.getErrors());
} else {
- listAction = new ArrayList<Action>(rpcResult.getResult().nonnullAction().values());
+ listAction = new ArrayList<>(rpcResult.getResult().nonnullAction().values());
}
} catch (Exception e) {
LOG.warn("Exception when egress actions for interface {}", ifName, e);
public List<DpnInterfaces> getElanDPNByName(String elanInstanceName) {
InstanceIdentifier<ElanDpnInterfacesList> elanIdentifier = getElanDpnOperationDataPath(elanInstanceName);
try {
- return new ArrayList<DpnInterfaces>((SingleTransactionDataBroker.syncReadOptional(broker,
+ return new ArrayList<>(SingleTransactionDataBroker.syncReadOptional(broker,
LogicalDatastoreType.OPERATIONAL, elanIdentifier).map(ElanDpnInterfacesList::nonnullDpnInterfaces)
- .orElse(emptyMap())).values());
+ .orElse(emptyMap()).values());
} catch (ExecutionException | InterruptedException e) {
LOG.error("getElanDPNByName: Exception while reading elanDpnInterfaceList DS for the elan "
+ "instance {}", elanInstanceName, e);
}
public static String getKnownDynamicmacFlowRef(Uint32 elanTag, String macAddress) {
- return new StringBuffer().append(elanTag).append(macAddress.toLowerCase(Locale.getDefault())).toString();
+ return new StringBuilder().append(elanTag).append(macAddress.toLowerCase(Locale.getDefault())).toString();
}
public static String getKnownDynamicmacFlowRef(short elanDmacTable, Uint64 dpId, String extDeviceNodeId,
.LEAVES_POSTFIX);
EtreeLeafTagName etreeLeafTagName = new EtreeLeafTagNameBuilder()
.setEtreeLeafTag(new EtreeLeafTag(etreeLeafTag)).build();
- elanTagNameBuilder.addAugmentation(EtreeLeafTagName.class, etreeLeafTagName);
+ elanTagNameBuilder.addAugmentation(etreeLeafTagName);
addTheLeafTagAsElanTag(elanInstanceName, etreeLeafTag, operTx);
}
ElanTagName elanTagName = elanTagNameBuilder.build();
if (isEtreeInstance(elanInstanceAdded)) {
EtreeInstance etreeInstance = new EtreeInstanceBuilder().setEtreeLeafTagVal(new EtreeLeafTag(etreeLeafTag))
.build();
- elanInstanceBuilder.addAugmentation(EtreeInstance.class, etreeInstance);
+ elanInstanceBuilder.addAugmentation(etreeInstance);
}
ElanInstance elanInstanceWithTag = elanInstanceBuilder.build();
LOG.trace("Updated elan Operational DS for elan: {} with elanTag: {} and interfaces: {}", elanInstanceName,
.setInstruction(instructions);
return new BoundServicesBuilder().withKey(new BoundServicesKey(servicePriority)).setServiceName(serviceName)
.setServicePriority(servicePriority).setServiceType(ServiceTypeFlowBased.class)
- .addAugmentation(StypeOpenflow.class, augBuilder.build()).build();
+ .addAugmentation(augBuilder.build()).build();
}
public static InstanceIdentifier<BoundServices> buildServiceId(String interfaceName, short serviceIndex) {
*/
public List<ExternalTunnel> getAllExternalTunnels(LogicalDatastoreType datastoreType) {
InstanceIdentifier<ExternalTunnelList> iid = InstanceIdentifier.builder(ExternalTunnelList.class).build();
- return new ArrayList<ExternalTunnel>(read(broker, datastoreType, iid).map(ExternalTunnelList
+ return new ArrayList<>(read(broker, datastoreType, iid).map(ExternalTunnelList
::nonnullExternalTunnel).orElse(Collections.emptyMap()).values());
}
}
public static List<PhysAddress> getPhysAddress(List<String> macAddress) {
- Preconditions.checkNotNull(macAddress, "macAddress cannot be null");
+ requireNonNull(macAddress, "macAddress cannot be null");
List<PhysAddress> physAddresses = new ArrayList<>();
for (String mac : macAddress) {
physAddresses.add(new PhysAddress(mac));
public static List<StaticMacEntries> getStaticMacEntries(List<String> staticMacAddresses) {
if (isEmpty(staticMacAddresses)) {
- return Collections.EMPTY_LIST;
+ return emptyList();
}
StaticMacEntriesBuilder staticMacEntriesBuilder = new StaticMacEntriesBuilder();
List<StaticMacEntries> staticMacEntries = new ArrayList<>();
public static <T> List<T> diffOf(List<T> orig, List<T> updated) {
if (isEmpty(orig)) {
- return Collections.EMPTY_LIST;
+ return emptyList();
}
List<T> diff = Lists.newArrayList(orig);
if (isNotEmpty(updated)) {
if (macTable == null) {
return emptyList();
}
- return new ArrayList<MacEntry>(macTable.nonnullMacEntry().values());
+ return new ArrayList<>(macTable.nonnullMacEntry().values());
}
public boolean isTunnelInLogicalGroup(String interfaceName) {
LOG.debug("Buckets are not sent for group {}. Skipping merge operation", groupIdInfo);
return;
}
- List<Bucket> newBuckets = new ArrayList<Bucket>(newGroup.getBuckets().nonnullBucket().values());
- List<Bucket> existingBuckets = new ArrayList<Bucket>(existingGroup.nonnullBucket().values());
+ List<Bucket> newBuckets = new ArrayList<>(newGroup.getBuckets().nonnullBucket().values());
+ List<Bucket> existingBuckets = new ArrayList<>(existingGroup.nonnullBucket().values());
LOG.debug("New Buckets {} and Existing Buckets {}", newBuckets, existingBuckets);
List<Bucket> combinedBuckets = new ArrayList<>(existingBuckets);
Map<String,Bucket> reg6ActionBucketMap = new HashMap<>();
// Add all buckets in the new group to a map with node connector/reg6 value as key
newBuckets.forEach(bucket -> {
- List<Action> actionList = new ArrayList<Action>(bucket.getAction().values());
+ List<Action> actionList = new ArrayList<>(bucket.getAction().values());
if (actionList != null && !actionList.isEmpty()) {
actionList.forEach(action -> {
if (action.getAction() instanceof OutputActionCase) {
//First, remove buckets with same nc id/reg6 value as in hashmap from combinedBuckets
//Next, add all the buckets in hashmap to combined buckets
existingBuckets.forEach(existingBucket -> {
- List<Action> actionList = new ArrayList<Action>(existingBucket.getAction().values());
+ List<Action> actionList = new ArrayList<>(existingBucket.getAction().values());
if (actionList != null && !actionList.isEmpty()) {
actionList.forEach(action -> {
if (action.getAction() instanceof OutputActionCase) {
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.HwvtepGlobalAugmentation;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.HwvtepGlobalAugmentationBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.HwvtepPhysicalSwitchRef;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.LocalMcastMacs;
hwvtepGlobalAugmentationBuilder.setLogicalSwitches(logicalSwitches);
NodeBuilder nodeBuilder = new NodeBuilder();
nodeBuilder.setNodeId(node.getNodeId());
- nodeBuilder.addAugmentation(HwvtepGlobalAugmentation.class, hwvtepGlobalAugmentationBuilder.build());
+ nodeBuilder.addAugmentation(hwvtepGlobalAugmentationBuilder.build());
return nodeBuilder.build();
}
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Address;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.HwvtepGlobalAugmentation;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.HwvtepGlobalAugmentationBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.HwvtepGlobalRef;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.HwvtepNodeName;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.PhysicalSwitchAugmentation;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.PhysicalSwitchAugmentationBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.physical._switch.attributes.TunnelIps;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.physical._switch.attributes.TunnelIpsBuilder;
GlobalAugmentationHelper.addSwitches(augmentationBuilder, psPath);
- nodeBuilder.addAugmentation(HwvtepGlobalAugmentation.class, augmentationBuilder.build());
+ nodeBuilder.addAugmentation(augmentationBuilder.build());
tx.put(path, nodeBuilder.build());
}
physicalSwitchAugmentationBuilder.setTunnelIps(tunnelIps);
NodeBuilder nodeBuilder = prepareOperationalNode(path);
- nodeBuilder.addAugmentation(PhysicalSwitchAugmentation.class, physicalSwitchAugmentationBuilder.build());
+ nodeBuilder.addAugmentation(physicalSwitchAugmentationBuilder.build());
PhysicalSwitchHelper.dId = parentPath;
nodeBuilder.setTerminationPoint(PhysicalSwitchHelper
.addPhysicalSwitchTerminationPoints(path, portNameList));
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.HwvtepGlobalAugmentation;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.HwvtepLogicalSwitchRef;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.HwvtepNodeName;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.HwvtepPhysicalPortAugmentation;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.HwvtepPhysicalPortAugmentationBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.LogicalSwitches;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.LogicalSwitchesKey;
HwvtepPhysicalPortAugmentationBuilder tpAugmentationBuilder =
new HwvtepPhysicalPortAugmentationBuilder();
buildTerminationPoint(tpAugmentationBuilder, portName, vlanBindingData);
- tpBuilder.addAugmentation(HwvtepPhysicalPortAugmentation.class, tpAugmentationBuilder.build());
+ tpBuilder.addAugmentation(tpAugmentationBuilder.build());
return tpBuilder.build();
}
*/
package org.opendaylight.netvirt.elan.l2gw.nodehandlertest;
-import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableBiMap;
import com.google.common.collect.ImmutableList;
import java.util.ArrayList;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.HwvtepGlobalAugmentation;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.HwvtepLogicalSwitchRef;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.HwvtepNodeName;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.HwvtepPhysicalLocatorAugmentation;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.HwvtepPhysicalLocatorAugmentationBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.HwvtepPhysicalLocatorRef;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.LocalMcastMacs;
tpAugmentationBuilder.setPhysicalLocatorUuid(getUUid(ip));
tpAugmentationBuilder.setEncapsulationType(createEncapsulationType("vxlan_over_ipv4"));
tpAugmentationBuilder.setDstIp(IpAddressBuilder.getDefaultInstance(ip));
- tpBuilder.addAugmentation(HwvtepPhysicalLocatorAugmentation.class, tpAugmentationBuilder.build());
+ tpBuilder.addAugmentation(tpAugmentationBuilder.build());
}
return tpBuilder.build();
}
}
public static Class<? extends EncapsulationTypeBase> createEncapsulationType(String type) {
- Preconditions.checkNotNull(type);
if (type.isEmpty()) {
return EncapsulationTypeVxlanOverIpv4.class;
- } else {
- ImmutableBiMap<Class<? extends EncapsulationTypeBase>, String> encapsTypeMap
- = new ImmutableBiMap.Builder<Class<? extends EncapsulationTypeBase>, String>()
- .put(EncapsulationTypeVxlanOverIpv4.class, "vxlan_over_ipv4")
- .build();
- ImmutableBiMap<String, Class<? extends EncapsulationTypeBase>> mapper =
- encapsTypeMap.inverse();
- return mapper.get(type);
}
+
+ ImmutableBiMap<Class<? extends EncapsulationTypeBase>, String> encapsTypeMap =
+ ImmutableBiMap.of(EncapsulationTypeVxlanOverIpv4.class, "vxlan_over_ipv4");
+ ImmutableBiMap<String, Class<? extends EncapsulationTypeBase>> mapper =
+ encapsTypeMap.inverse();
+ return mapper.get(type);
}
}
buildGroupInstanceIdentifier(long groupId,
org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node
nodeDpn) {
- InstanceIdentifier groupInstanceId =
- InstanceIdentifier.builder(Nodes.class)
- .child(org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node.class,
- nodeDpn.key()).augmentation(FlowCapableNode.class).child(Group.class,
- new GroupKey(new GroupId(Long.valueOf(groupId)))).build();
+ InstanceIdentifier groupInstanceId = InstanceIdentifier.builder(Nodes.class)
+ .child(org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node.class, nodeDpn.key())
+ .augmentation(FlowCapableNode.class).child(Group.class,
+ new GroupKey(new GroupId(Long.valueOf(groupId))))
+ .build();
return groupInstanceId;
}
}
*/
package org.opendaylight.netvirt.elanmanager.tests;
-import com.google.common.collect.Lists;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.TopologyKey;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.binding.util.BindingMap;
import org.opendaylight.yangtools.yang.common.Uint32;
import org.opendaylight.yangtools.yang.common.Uint64;
InstructionsBuilder builder = new InstructionsBuilder();
InstructionBuilder instructionBuilder = new InstructionBuilder(
new ArrayList<Instruction>(instructions.nonnullInstruction().values()).get(0));
- instructionBuilder.setInstruction(sortActions(instructionBuilder.getInstruction()));
- builder.setInstruction(Lists.newArrayList(instructionBuilder.build()));
+ instructionBuilder.setInstruction(sortActions(instructionBuilder.getInstruction())).setOrder(0);
+ builder.setInstruction(BindingMap.of(instructionBuilder.build()));
return flowBuilder.setInstructions(builder.build()).build();
}
import org.opendaylight.yang.gen.v1.urn.ericsson.params.xml.ns.yang.ebgp.rev150901.EncapType
import org.opendaylight.yang.gen.v1.urn.ericsson.params.xml.ns.yang.ebgp.rev150901.bgp.networkscontainer.Networks
import org.opendaylight.yang.gen.v1.urn.ericsson.params.xml.ns.yang.ebgp.rev150901.bgp.networkscontainer.NetworksBuilder
-import org.opendaylight.yang.gen.v1.urn.ericsson.params.xml.ns.yang.ebgp.rev150901.bgp.networkscontainer.NetworksKey
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.iana._if.type.rev170119.L2vlan
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Address
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.InterfaceBuilder
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.instruction.apply.actions._case.ApplyActionsBuilder
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.instruction.go.to.table._case.GoToTableBuilder
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list.InstructionBuilder
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.IfL2vlan
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.IfL2vlan.L2vlanMode
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.IfL2vlanBuilder
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.ParentRefs
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.ParentRefsBuilder
import org.opendaylight.yang.gen.v1.urn.opendaylight.l2.types.rev130827.VlanId
import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.ethernet.match.fields.EthernetDestinationBuilder
description = interfaceName
name = interfaceName
type = L2vlan
- addAugmentation(ParentRefs, new ParentRefsBuilder >> [
+ addAugmentation(new ParentRefsBuilder >> [
parentInterface = parentName
- ])addAugmentation(IfL2vlan, new IfL2vlanBuilder >> [
+ ])addAugmentation(new IfL2vlanBuilder >> [
l2vlanMode = L2vlanMode.Trunk
vlanId = new VlanId(0)
])
new NetworksBuilder >> [
bgpControlPlaneType = BgpControlPlaneType.PROTOCOLEVPN
encapType = EncapType.VXLAN
- ethtag = Uint32.valueOf(0L)
+ ethtag = Uint32.ZERO
l2vni = vni
- l3vni = Uint32.valueOf(0L)
- label = Uint32.valueOf(0L)
+ l3vni = Uint32.ZERO
+ label = Uint32.ZERO
macaddress = mac
nexthop = new Ipv4Address(tepip)
prefixLen = prefix
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.HwvtepGlobalAugmentationBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.HwvtepGlobalRef;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.HwvtepNodeName;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.PhysicalSwitchAugmentation;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.PhysicalSwitchAugmentationBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.LocalUcastMacs;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.LocalUcastMacsBuilder;
IpAddress ip = IpAddressBuilder.getDefaultInstance(tepIp);
tunnelIps.add(new TunnelIpsBuilder().withKey(new TunnelIpsKey(ip)).setTunnelIpsKey(ip).build());
physicalSwitchAugmentationBuilder.setTunnelIps(tunnelIps);
- nodeBuilder.addAugmentation(PhysicalSwitchAugmentation.class, physicalSwitchAugmentationBuilder.build());
+ nodeBuilder.addAugmentation(physicalSwitchAugmentationBuilder.build());
singleTransactionDataBroker.syncWrite(LogicalDatastoreType.OPERATIONAL, psNodePath, nodeBuilder.build());
nodeBuilder = new NodeBuilder();
builder.setDbVersion("1.6.0");
builder.setManagers(TestBuilders.buildManagers1());
GlobalAugmentationHelper.addSwitches(builder, psNodePath);
- nodeBuilder.addAugmentation(HwvtepGlobalAugmentation.class, builder.build());
+ nodeBuilder.addAugmentation(builder.build());
singleTransactionDataBroker.syncWrite(LogicalDatastoreType.OPERATIONAL, nodePath, nodeBuilder.build());
}
localUcastMacses.add(localUcastMacs);
HwvtepGlobalAugmentationBuilder builder1 =
new HwvtepGlobalAugmentationBuilder().setLocalUcastMacs(localUcastMacses) ;
- nodeBuilder.addAugmentation(HwvtepGlobalAugmentation.class, builder1.build());
+ nodeBuilder.addAugmentation(builder1.build());
singleTransactionDataBroker.syncUpdate(LogicalDatastoreType.OPERATIONAL, nodeId, nodeBuilder.build());
return localUcastMacs;
}
import org.opendaylight.yang.gen.v1.urn.ericsson.params.xml.ns.yang.ebgp.rev150901.bgp.NetworksContainer;
import org.opendaylight.yang.gen.v1.urn.ericsson.params.xml.ns.yang.ebgp.rev150901.bgp.networkscontainer.Networks;
import org.opendaylight.yang.gen.v1.urn.ericsson.params.xml.ns.yang.ebgp.rev150901.bgp.networkscontainer.NetworksKey;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.EvpnAugmentation;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.EvpnAugmentationBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.instances.ElanInstance;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.instances.ElanInstanceBuilder;
@Singleton
public class EvpnTestHelper {
private static final Logger LOG = LoggerFactory.getLogger(EvpnTestHelper.class);
- private SingleTransactionDataBroker singleTxdataBroker;
+ private final SingleTransactionDataBroker singleTxdataBroker;
@Inject
public EvpnTestHelper(SingleTransactionDataBroker singleTxdataBroker) {
public void updateEvpnNameInElan(String elanInstanceName, String evpnName)
throws ReadFailedException, TransactionCommitFailedException {
InstanceIdentifier<ElanInstance> elanIid = ElanHelper.getElanInstanceConfigurationDataPath(elanInstanceName);
- ElanInstance elanInstance = singleTxdataBroker.syncRead(LogicalDatastoreType.CONFIGURATION, elanIid);
+ ElanInstance elanInstance = singleTxdataBroker.syncRead(LogicalDatastoreType.CONFIGURATION, elanIid);
EvpnAugmentationBuilder evpnAugmentationBuilder = new EvpnAugmentationBuilder();
ElanInstanceBuilder elanInstanceBuilder = new ElanInstanceBuilder(elanInstance);
evpnAugmentationBuilder.setEvpnName(evpnName);
LOG.debug("Writing Elan-EvpnAugmentation evpnName {} with key {}", evpnName, elanInstanceName);
- elanInstanceBuilder.addAugmentation(EvpnAugmentation.class, evpnAugmentationBuilder.build());
+ elanInstanceBuilder.addAugmentation(evpnAugmentationBuilder.build());
singleTxdataBroker.syncWrite(LogicalDatastoreType.CONFIGURATION, elanIid, elanInstanceBuilder.build());
}
public void deleteEvpnNameInElan(String elanInstanceName)
throws ReadFailedException, TransactionCommitFailedException {
InstanceIdentifier<ElanInstance> elanIid = ElanHelper.getElanInstanceConfigurationDataPath(elanInstanceName);
- ElanInstance elanInstance = singleTxdataBroker.syncRead(LogicalDatastoreType.CONFIGURATION, elanIid);
+ ElanInstance elanInstance = singleTxdataBroker.syncRead(LogicalDatastoreType.CONFIGURATION, elanIid);
EvpnAugmentationBuilder evpnAugmentationBuilder = new EvpnAugmentationBuilder();
ElanInstanceBuilder elanInstanceBuilder = new ElanInstanceBuilder(elanInstance);
evpnAugmentationBuilder.setEvpnName(null);
LOG.debug("deleting evpn name from Elan-EvpnAugmentation {} ", elanInstanceName);
- elanInstanceBuilder.addAugmentation(EvpnAugmentation.class, evpnAugmentationBuilder.build());
+ elanInstanceBuilder.addAugmentation(evpnAugmentationBuilder.build());
singleTxdataBroker.syncWrite(LogicalDatastoreType.CONFIGURATION, elanIid, elanInstanceBuilder.build());
}
builder.setL2vni(l2vni);
List<RoutePaths> routePaths = nextHopList.stream()
.filter(StringUtils::isNotEmpty)
- .map(nextHop -> {
- return FibHelper.buildRoutePath(nextHop, null);
- }).collect(Collectors.toList());
+ .map(nextHop -> FibHelper.buildRoutePath(nextHop, null)).collect(Collectors.toList());
builder.setRoutePaths(routePaths);
}
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>7.0.6</version>
+ <version>8.1.0</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>feature-repo-parent</artifactId>
- <version>7.0.6</version>
+ <version>8.1.0</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>single-feature-parent</artifactId>
- <version>7.0.6</version>
+ <version>8.1.0</version>
<relativePath/>
</parent>
<dependency>
<groupId>org.opendaylight.infrautils</groupId>
<artifactId>infrautils-artifacts</artifactId>
- <version>1.8.1</version>
+ <version>1.9.5</version>
<scope>import</scope>
<type>pom</type>
</dependency>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>controller-artifacts</artifactId>
- <version>2.0.4</version>
+ <version>3.0.6</version>
<scope>import</scope>
<type>pom</type>
</dependency>
<dependency>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>mdsal-artifacts</artifactId>
- <version>6.0.5</version>
+ <version>7.0.5</version>
<scope>import</scope>
<type>pom</type>
</dependency>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>single-feature-parent</artifactId>
- <version>7.0.6</version>
+ <version>8.1.0</version>
<relativePath/>
</parent>
<dependency>
<groupId>org.opendaylight.infrautils</groupId>
<artifactId>infrautils-artifacts</artifactId>
- <version>1.8.1</version>
+ <version>1.9.5</version>
<scope>import</scope>
<type>pom</type>
</dependency>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>controller-artifacts</artifactId>
- <version>2.0.4</version>
+ <version>3.0.6</version>
<scope>import</scope>
<type>pom</type>
</dependency>
-->
<features name="odl-netvirt-${project.version}" xmlns="http://karaf.apache.org/xmlns/features/v1.2.0">
<feature name="odl-netvirt-impl" version="${project.version}">
- <feature version="[2,3)">odl-mdsal-broker</feature>
+ <feature version="[3,4)">odl-mdsal-broker</feature>
<bundle>wrap:mvn:org.apache.thrift/libthrift/0.9.3$overwrite=merge&Bundle-Version=0.9.3&Export-Package=*;-noimport:=true;version="0.9.3"</bundle>
<configfile finalname="etc/opendaylight/datastore/initial/config/netvirt-aclservice-config.xml">
mvn:org.opendaylight.netvirt/aclservice-impl/${project.version}/xml/config
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>single-feature-parent</artifactId>
- <version>7.0.6</version>
+ <version>8.1.0</version>
<relativePath/>
</parent>
<dependency>
<groupId>org.opendaylight.netconf</groupId>
<artifactId>odl-restconf</artifactId>
- <version>1.13.0-SNAPSHOT</version>
+ <version>1.13.0</version>
<type>xml</type>
<classifier>features</classifier>
</dependency>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>7.0.6</version>
+ <version>8.1.0</version>
<relativePath/>
</parent>
*/
package org.opendaylight.netvirt.fibmanager;
+import static com.google.common.base.Preconditions.checkNotNull;
import static org.opendaylight.mdsal.binding.util.Datastore.CONFIGURATION;
-import com.google.common.base.Preconditions;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-
public class EvpnVrfEntryHandler extends BaseVrfEntryHandler {
private static final Logger LOG = LoggerFactory.getLogger(EvpnVrfEntryHandler.class);
+
private final ManagedNewTransactionRunner txRunner;
private final VrfEntryListener vrfEntryListener;
private final BgpRouteVrfEntryHandler bgpRouteVrfEntryHandler;
final VpnInstanceOpDataEntry vpnInstance = getFibUtil().getVpnInstanceOpData(
vrfTableKey.getRouteDistinguisher()).get();
Uint32 vpnId = vpnInstance.getVpnId();
- Preconditions.checkNotNull(vpnInstance, "Vpn Instance not available " + vrfTableKey.getRouteDistinguisher());
- Preconditions.checkNotNull(vpnId, "Vpn Instance with rd " + vpnInstance.getVrfId()
- + " has null vpnId!");
+ checkNotNull(vpnInstance, "Vpn Instance not available %s", vrfTableKey.getRouteDistinguisher());
+ checkNotNull(vpnId, "Vpn Instance with rd %s has null vpnId!", vpnInstance.getVrfId());
if (RouteOrigin.value(vrfEntry.getOrigin()) == RouteOrigin.CONNECTED) {
SubnetRoute subnetRoute = vrfEntry.augmentation(SubnetRoute.class);
final Map<VpnToDpnListKey, VpnToDpnList> keyVpnToDpnListMap = vpnInstance.nonnullVpnToDpnList();
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.netvirt.fibmanager;
+import static java.util.Objects.requireNonNull;
import static java.util.stream.Collectors.joining;
import static java.util.stream.Collectors.toList;
-import com.google.common.base.Preconditions;
import com.google.common.net.InetAddresses;
import java.net.InetAddress;
import java.util.ArrayList;
String vpnName, String ipAddress) {
LOG.debug("getAdjacencyIdentifierOp vpninterface {} vpn {} ip {}", vpnInterfaceName, vpnName, ipAddress);
return getAdjListPathOp(vpnInterfaceName, vpnName).builder()
- .child(org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.l3vpn.rev200204
- .adjacency.list.Adjacency.class,
- new org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.l3vpn.rev200204
- .adjacency.list.AdjacencyKey(ipAddress)).build();
+ .child(org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.l3vpn.rev200204.adjacency
+ .list.Adjacency.class,
+ new org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.l3vpn.rev200204.adjacency
+ .list.AdjacencyKey(ipAddress))
+ .build();
}
static InstanceIdentifier<AdjacenciesOp> getAdjListPathOp(String vpnInterfaceName, String vpnName) {
return;
}
- Preconditions.checkNotNull(nextHopList, "NextHopList can't be null");
+ requireNonNull(nextHopList, "NextHopList can't be null");
try {
InstanceIdentifier<VrfEntry> vrfEntryId =
// Filling the nextHop with dummy nextHopAddress
VrfEntry vrfEntry = FibHelper.getVrfEntryBuilder(prefix, label,
FibConstants.DEFAULT_NEXTHOP_IP, RouteOrigin.LOCAL, null /* parentVpnRd */)
- .addAugmentation(RouterInterface.class, routerInterface).build();
+ .addAugmentation(routerInterface).build();
if (writeConfigTxn != null) {
writeConfigTxn.mergeParentStructureMerge(vrfEntryId, vrfEntry);
InstanceIdentifier.InstanceIdentifierBuilder<VrfEntry> idBuilder =
InstanceIdentifier.builder(FibEntries.class)
- .child(VrfTables.class, new VrfTablesKey(rd)).child(VrfEntry.class,
+ .child(VrfTables.class, new VrfTablesKey(rd)).child(VrfEntry.class,
new VrfEntryKey(prefix));
InstanceIdentifier<VrfEntry> vrfEntryId = idBuilder.build();
if (writeConfigTxn != null) {
prefix, rd, nextHopToRemove, e);
}
if (entry.isPresent()) {
- final List<RoutePaths> routePaths = new ArrayList<RoutePaths>(entry.get().nonnullRoutePaths().values());
+ final List<RoutePaths> routePaths = new ArrayList<>(entry.get().nonnullRoutePaths().values());
if (routePaths == null || routePaths.isEmpty()) {
LOG.warn("routePaths is null/empty for given rd {}, prefix {}", rd, prefix);
return;
}
public static java.util.Optional<Uint32> getLabelFromRoutePaths(final VrfEntry vrfEntry) {
- List<RoutePaths> routePaths = new ArrayList<RoutePaths>(vrfEntry.nonnullRoutePaths().values());
+ List<RoutePaths> routePaths = new ArrayList<>(vrfEntry.nonnullRoutePaths().values());
if (routePaths == null || routePaths.isEmpty()
- || new ArrayList<RoutePaths>(vrfEntry.nonnullRoutePaths().values()).get(0).getLabel() == null) {
+ || new ArrayList<>(vrfEntry.nonnullRoutePaths().values()).get(0).getLabel() == null) {
return java.util.Optional.empty();
}
- return java.util.Optional.of(new ArrayList<RoutePaths>(vrfEntry
+ return java.util.Optional.of(new ArrayList<>(vrfEntry
.nonnullRoutePaths().values()).get(0).getLabel());
}
public static java.util.Optional<String> getFirstNextHopAddress(final VrfEntry vrfEntry) {
- List<RoutePaths> routePaths = new ArrayList<RoutePaths>(vrfEntry.nonnullRoutePaths().values());
+ List<RoutePaths> routePaths = new ArrayList<>(vrfEntry.nonnullRoutePaths().values());
if (routePaths == null || routePaths.isEmpty()) {
return java.util.Optional.empty();
}
- return java.util.Optional.of(new ArrayList<RoutePaths>(vrfEntry.nonnullRoutePaths().values())
+ return java.util.Optional.of(new ArrayList<>(vrfEntry.nonnullRoutePaths().values())
.get(0).getNexthopAddress());
}
public static java.util.Optional<Uint32> getLabelForNextHop(final VrfEntry vrfEntry, String nextHopIp) {
- List<RoutePaths> routePaths = new ArrayList<RoutePaths>(vrfEntry.nonnullRoutePaths().values());
+ List<RoutePaths> routePaths = new ArrayList<>(vrfEntry.nonnullRoutePaths().values());
if (routePaths == null || routePaths.isEmpty()) {
return java.util.Optional.empty();
}
}
public static String getGreLbGroupKey(List<String> availableDcGws) {
- Preconditions.checkNotNull(availableDcGws, "AvailableDcGws is null");
+ requireNonNull(availableDcGws, "AvailableDcGws is null");
return "gre-" + availableDcGws.stream().sorted().collect(joining(":"));
}
try {
VpnToDpnList vpnToDpnList = SingleTransactionDataBroker.syncRead(dataBroker,
LogicalDatastoreType.OPERATIONAL, vpnToDpnListId);
- if (!(vpnToDpnList == null) && !(vpnToDpnList.getVpnInterfaces() == null)
+ if ((vpnToDpnList != null) && (vpnToDpnList.getVpnInterfaces() != null)
&& !vpnToDpnList.getVpnInterfaces().isEmpty()) {
return true;
}
*/
package org.opendaylight.netvirt.fibmanager;
+import static java.util.Objects.requireNonNull;
import static java.util.stream.Collectors.toList;
import static org.opendaylight.genius.mdsalutil.NWUtil.isIpv4Address;
import static org.opendaylight.mdsal.binding.util.Datastore.CONFIGURATION;
import static org.opendaylight.mdsal.binding.util.Datastore.OPERATIONAL;
-import com.google.common.base.Preconditions;
import com.google.common.util.concurrent.ListenableFuture;
import java.util.ArrayList;
import java.util.Arrays;
}
futures.add(txRunner.callWithNewWriteOnlyTransactionAndSubmit(CONFIGURATION, configTx -> {
List<String> availableDcGws = getDcGwIps();
- Preconditions.checkNotNull(availableDcGws, "There are no dc-gws present");
+ requireNonNull(availableDcGws, "There are no dc-gws present");
int noOfDcGws = availableDcGws.size();
if (noOfDcGws == 1) {
LOG.trace("There are no enough DC GateWays {} present to program LB group", availableDcGws);
*/
package org.opendaylight.netvirt.fibmanager;
+import static com.google.common.base.Preconditions.checkNotNull;
import static org.opendaylight.genius.mdsalutil.NWUtil.isIpv4Address;
-import com.google.common.base.Preconditions;
import java.util.Map;
import java.util.concurrent.locks.ReentrantLock;
import javax.inject.Inject;
@Singleton
public class RouterInterfaceVrfEntryHandler extends BaseVrfEntryHandler {
-
private static final Logger LOG = LoggerFactory.getLogger(RouterInterfaceVrfEntryHandler.class);
+
private final IMdsalApiManager mdsalManager;
private final IPv6Handler ipv6Handler;
private boolean installRouterFibEntries(VrfEntry vrfEntry, String rd, int addOrRemove,
RouterInterface routerInterface) {
final VpnInstanceOpDataEntry vpnInstance = getFibUtil().getVpnInstance(rd);
- Preconditions.checkNotNull(vpnInstance, "Vpn Instance not available " + rd);
- Preconditions.checkNotNull(vpnInstance.getVpnId(),
- "Vpn Instance with rd " + vpnInstance.getVrfId() + " has null vpnId!");
+ checkNotNull(vpnInstance, "Vpn Instance not available %s", rd);
+ checkNotNull(vpnInstance.getVpnId(), "Vpn Instance with rd %s has null vpnId!", vpnInstance.getVrfId());
// FIXME: separate this out somehow?
final ReentrantLock lock = JvmGlobalLocks.getLockForString(vpnInstance.getVpnInstanceName());
*/
package org.opendaylight.netvirt.fibmanager;
+import static com.google.common.base.Preconditions.checkNotNull;
+import static java.util.Objects.requireNonNull;
import static org.opendaylight.genius.mdsalutil.NWUtil.isIpv4Address;
import static org.opendaylight.mdsal.binding.util.Datastore.CONFIGURATION;
import static org.opendaylight.mdsal.binding.util.Datastore.OPERATIONAL;
-import com.google.common.base.Preconditions;
import com.google.common.collect.Lists;
import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.Futures;
@Override
public void add(final InstanceIdentifier<VrfEntry> identifier, final VrfEntry vrfEntry) {
- Preconditions.checkNotNull(vrfEntry, "VrfEntry should not be null or empty.");
+ requireNonNull(vrfEntry, "VrfEntry should not be null or empty.");
String rd = identifier.firstKeyOf(VrfTables.class).getRouteDistinguisher();
LOG.debug("ADD: Adding Fib Entry rd {} prefix {} route-paths {}",
rd, vrfEntry.getDestPrefix(), vrfEntry.getRoutePaths());
@Override
public void remove(InstanceIdentifier<VrfEntry> identifier, VrfEntry vrfEntry) {
- Preconditions.checkNotNull(vrfEntry, "VrfEntry should not be null or empty.");
+ requireNonNull(vrfEntry, "VrfEntry should not be null or empty.");
String rd = identifier.firstKeyOf(VrfTables.class).getRouteDistinguisher();
LOG.debug("REMOVE: Removing Fib Entry rd {} prefix {} route-paths {}",
rd, vrfEntry.getDestPrefix(), vrfEntry.getRoutePaths());
// originalRoutePath is a little dicey - safest to keep the checking even if not needed.
@SuppressFBWarnings("RCN_REDUNDANT_NULLCHECK_OF_NONNULL_VALUE")
public void update(InstanceIdentifier<VrfEntry> identifier, VrfEntry original, VrfEntry update) {
- Preconditions.checkNotNull(update, "VrfEntry should not be null or empty.");
+ requireNonNull(update, "VrfEntry should not be null or empty.");
final String rd = identifier.firstKeyOf(VrfTables.class).getRouteDistinguisher();
LOG.debug("UPDATE: Updating Fib Entries to rd {} prefix {} route-paths {} origin {} old-origin {}", rd,
update.getDestPrefix(), update.getRoutePaths(), update.getOrigin(), original.getOrigin());
List<SubTransaction> txnObjects = new ArrayList<>();
final VpnInstanceOpDataEntry vpnInstance =
fibUtil.getVpnInstance(vrfTableKey.getRouteDistinguisher());
- Preconditions.checkNotNull(vpnInstance, "Vpn Instance not available " + vrfTableKey.getRouteDistinguisher());
- Preconditions.checkNotNull(vpnInstance.getVpnId(), "Vpn Instance with rd " + vpnInstance.getVrfId()
- + " has null vpnId!");
+ checkNotNull(vpnInstance, "Vpn Instance not available %s", vrfTableKey.getRouteDistinguisher());
+ checkNotNull(vpnInstance.getVpnId(), "Vpn Instance with rd %s has null vpnId!", vpnInstance.getVrfId());
final Map<VpnToDpnListKey, VpnToDpnList> keyVpnToDpnListMap;
if (vrfEntry.getParentVpnRd() != null
&& FibHelper.isControllerManagedNonSelfImportedRoute(RouteOrigin.value(vrfEntry.getOrigin()))) {
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>7.0.6</version>
+ <version>8.1.0</version>
<relativePath/>
</parent>
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.ipv6.nd.packet.rev160620.NeighborSolicitationPacketBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.ipv6.nd.packet.rev160620.RouterSolicitationPacket;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.ipv6.nd.packet.rev160620.RouterSolicitationPacketBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.ipv6.nd.util.rev170210.PacketMetadata;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.ipv6.nd.util.rev170210.PacketMetadataBuilder;
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.packet.service.rev130709.TransmitPacketInputBuilder;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.common.Uint64;
+import org.opendaylight.yangtools.yang.common.Uint8;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
return;
}
- short tableId = packet.getTableId().getValue().toJava();
+ Uint8 tableId = packet.getTableId().getValue();
Uint64 metadata = packet.getMatch().getMetadata().getMetadata();
long portTag = MetaDataUtil.getLportFromMetadata(metadata).intValue();
String interfaceName = ifMgr.getInterfaceNameFromTag(portTag);
NeighborAdvertisePacket naPacket = new NeighborAdvertisePacketBuilder(naPdu)
- .addAugmentation(PacketMetadata.class, new PacketMetadataBuilder().setOfTableId((long) tableId)
+ .addAugmentation(new PacketMetadataBuilder().setOfTableId(tableId.toUint32())
.setMetadata(metadata).setInterface(interfaceName).build())
.build();
fireNaNotification(naPacket);
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.servicebinding.rev160406.ServiceBindings;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.servicebinding.rev160406.ServiceModeIngress;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.servicebinding.rev160406.ServiceTypeFlowBased;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.servicebinding.rev160406.StypeOpenflow;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.servicebinding.rev160406.StypeOpenflowBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.servicebinding.rev160406.service.bindings.ServicesInfo;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.servicebinding.rev160406.service.bindings.ServicesInfoKey;
return new BoundServicesBuilder().withKey(new BoundServicesKey(servicePriority))
.setServiceName(serviceName).setServicePriority(servicePriority)
.setServiceType(ServiceTypeFlowBased.class)
- .addAugmentation(StypeOpenflow.class, augBuilder.build()).build();
+ .addAugmentation(augBuilder.build()).build();
}
private InstanceIdentifier<BoundServices> buildServiceId(String interfaceName,
public ActionInfo getLearnActionForNsDrop(Long hardTimeoutinMs) {
int hardTimeout = (int)(hardTimeoutinMs / 1000);
- hardTimeout = (hardTimeout > 0) ? hardTimeout : 30;
+ hardTimeout = hardTimeout > 0 ? hardTimeout : 30;
List<ActionLearn.FlowMod> flowMods = Arrays.asList(
new ActionLearn.MatchFromValue(NwConstants.ETHTYPE_IPV6,
NwConstants.NxmOfFieldType.NXM_OF_ETH_TYPE.getType(),
package org.opendaylight.netvirt.ipv6service;
-import static org.mockito.Matchers.any;
-import static org.mockito.Matchers.anyLong;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyLong;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.Action;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.ipv6.nd.packet.rev160620.NeighborAdvertisePacket;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.ipv6.nd.packet.rev160620.NeighborAdvertisePacketBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.ipv6.nd.util.rev170210.PacketMetadata;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.ipv6.nd.util.rev170210.PacketMetadataBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorRef;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
NeighborAdvertisePacket naPdu = new Ipv6NaDecoder(data).decode();
NeighborAdvertisePacket naPacket =
new NeighborAdvertisePacketBuilder(naPdu)
- .addAugmentation(PacketMetadata.class, new PacketMetadataBuilder().setOfTableId((long) 45)
+ .addAugmentation(new PacketMetadataBuilder().setOfTableId((long) 45)
.setMetadata(mdata).setInterface("ddec9dba-d831-4ad7-84b9-00d7f65f052f").build())
.build();
verify(ipv6PktListener).onNaReceived(naPacket);
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>7.0.6</version>
+ <version>8.1.0</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>karaf4-parent</artifactId>
- <version>7.0.6</version>
+ <version>8.1.0</version>
<relativePath/>
</parent>
-->
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>odl-mdsal-trace</artifactId>
- <version>6.0.5</version>
+ <version>7.0.5</version>
<classifier>features</classifier>
<type>xml</type>
<scope>runtime</scope>
<!-- This ensures we have odl-jolokia in the distribution -->
<groupId>org.opendaylight.controller</groupId>
<artifactId>odl-jolokia</artifactId>
- <version>2.0.4</version>
+ <version>3.0.6</version>
<type>xml</type>
<classifier>features</classifier>
<scope>runtime</scope>
<!-- This ensures aaa-cli is available for the copy below -->
<groupId>org.opendaylight.aaa</groupId>
<artifactId>aaa-cli-jar</artifactId>
- <version>0.13.0-SNAPSHOT</version>
+ <version>0.13.1</version>
<!-- Use scope test (and not more!) just so we have the dependency for the maven-dependency-plugin below -->
<scope>test</scope>
</dependency>
<artifactItem>
<groupId>org.opendaylight.aaa</groupId>
<artifactId>aaa-cli-jar</artifactId>
- <version>0.13.0-SNAPSHOT</version>
+ <version>0.13.1</version>
</artifactItem>
</artifactItems>
<outputDirectory>${project.build.directory}/assembly/bin</outputDirectory>
Map<AdjacencyKey, Adjacency> keyAdjacencyMap =
adjs != null && adjs.getAdjacency() != null ? adjs.nonnullAdjacency()
- : new HashMap<AdjacencyKey, Adjacency>();
+ : new HashMap<>();
List<Adjacency> adjacencyListToImport = new ArrayList<>();
for (Adjacency adj : keyAdjacencyMap.values()) {
Subnetmap sn = VpnHelper.getSubnetmapFromItsUuid(dataBroker, adj.getSubnetId());
}
AdjacenciesOp adjacenciesOp = new AdjacenciesOpBuilder()
.setAdjacency(adjacencyListToImport).build();
- vpnIfOpDataEntryBuilder.addAugmentation(AdjacenciesOp.class, adjacenciesOp);
+ vpnIfOpDataEntryBuilder.addAugmentation(adjacenciesOp);
LOG.debug("onAddFloatingIp : Add vpnInterface {} to Operational l3vpn:vpn-interfaces-op-data ",
floatingIpInterface);
dpnId, l3Vni);
List<MatchInfo> mkMatches = new ArrayList<>();
mkMatches.add(new MatchTunnelId(Uint64.valueOf(l3Vni)));
- Map<InstructionKey, Instruction> customInstructionsMap = new HashMap<InstructionKey, Instruction>();
+ Map<InstructionKey, Instruction> customInstructionsMap = new HashMap<>();
int instructionKey = 0;
for (Instruction instructionObj : customInstructions) {
customInstructionsMap.put(new InstructionKey(++instructionKey), instructionObj);
package org.opendaylight.netvirt.natservice.internal;
import static java.util.Collections.emptyList;
+import static java.util.Objects.requireNonNull;
import static org.opendaylight.mdsal.binding.util.Datastore.CONFIGURATION;
-import com.google.common.base.Preconditions;
import com.google.common.base.Splitter;
import com.google.common.base.Strings;
import com.google.common.collect.Iterables;
return null;
}
InstanceIdentifier<RouterToNaptSwitch> id = buildNaptSwitchIdentifier(routerName);
- return (SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker,
- LogicalDatastoreType.CONFIGURATION, id).map(RouterToNaptSwitch::getPrimarySwitchId).orElse(
- Uint64.valueOf(0L)));
+ return SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker,
+ LogicalDatastoreType.CONFIGURATION, id).map(RouterToNaptSwitch::getPrimarySwitchId).orElse(Uint64.ZERO);
}
public static InstanceIdentifier<RouterToNaptSwitch> buildNaptSwitchIdentifier(String routerId) {
return null;
}
List<Uuid> routerIdsList = NeutronUtils.getVpnMapRouterIdsListUuid(
- new ArrayList<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602
- .vpnmaps.vpnmap.RouterIds>(optionalVpnMap.get().nonnullRouterIds().values()));
+ new ArrayList<>(optionalVpnMap.get().nonnullRouterIds().values()));
if (routerIdsList != null && !routerIdsList.isEmpty()) {
for (Uuid routerUuid : routerIdsList) {
InstanceIdentifier<Routers> id = buildRouterIdentifier(routerUuid.getValue());
@Nullable
static Uuid getVpnForRouter(DataBroker broker, String routerId) {
- Preconditions.checkNotNull(routerId, "getVpnForRouter: routerId not found!");
+ requireNonNull(routerId, "getVpnForRouter: routerId not found!");
InstanceIdentifier<VpnMaps> vpnMapsIdentifier = InstanceIdentifier.builder(VpnMaps.class).build();
Optional<VpnMaps> optionalVpnMaps =
SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker,
continue;
}
List<Uuid> routerIdsList = NeutronUtils.getVpnMapRouterIdsListUuid(
- new ArrayList<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602
- .vpnmaps.vpnmap.RouterIds>(vpnMap.nonnullRouterIds().values()));
+ new ArrayList<>(vpnMap.nonnullRouterIds().values()));
if (routerIdsList.isEmpty()) {
continue;
}
public static Uint32 getUniqueId(IdManagerService idManager, String poolName, String idKey) {
- AllocateIdInput getIdInput = (new AllocateIdInputBuilder()).setPoolName(poolName).setIdKey(idKey).build();
+ AllocateIdInput getIdInput = new AllocateIdInputBuilder().setPoolName(poolName).setIdKey(idKey).build();
try {
Future<RpcResult<AllocateIdOutput>> result = idManager.allocateId(getIdInput);
- RpcResult<AllocateIdOutput> rpcResult = (RpcResult)result.get();
+ RpcResult<AllocateIdOutput> rpcResult = result.get();
return rpcResult.isSuccessful() ? rpcResult.getResult().getIdValue()
: NatConstants.INVALID_ID;
} catch (InterruptedException | ExecutionException e) {
if (result == null || result.get() == null || !result.get().isSuccessful()) {
LOG.error("releaseId: RPC Call to release Id from pool {} with key {} returned with Errors {}",
poolName, idKey,
- (result != null && result.get() != null) ? result.get().getErrors() : "RpcResult is null");
+ result != null && result.get() != null ? result.get().getErrors() : "RpcResult is null");
} else {
return Uint32.ONE;
}
Routers routerData = NatUtil.getRoutersFromConfigDS(dataBroker, routerName);
if (routerData != null) {
return NatUtil.getIpsListFromExternalIps(
- new ArrayList<ExternalIps>(routerData.nonnullExternalIps().values()));
+ new ArrayList<>(routerData.nonnullExternalIps().values()));
}
return emptyList();
RoutersList routersList = new RoutersListBuilder().withKey(new RoutersListKey(routerName))
.setRouter(routerName).build();
Map<RoutersListKey, RoutersList> keyroutersMapFromDs = optionalDpnRoutersList.get().nonnullRoutersList();
- if (!keyroutersMapFromDs.values().contains(routersList)) {
+ if (!keyroutersMapFromDs.containsValue(routersList)) {
LOG.debug("addToDpnRoutersMap : Router {} not present for the DPN {}"
+ " in the ODL-L3VPN : DPNRouters map", routerName, dpId);
operTx.mergeParentStructureMerge(dpnRoutersListIdentifier
LOG.error("getEgressActionsForTunnels : RPC Call to Get egress actions for Tunnels {} "
+ "returned with Errors {}", ifName, rpcResult.getErrors());
} else {
- actions = new ArrayList<Action>(rpcResult.getResult().nonnullAction().values());
+ actions = new ArrayList<>(rpcResult.getResult().nonnullAction().values());
}
} else {
RpcResult<GetEgressActionsForInterfaceOutput> rpcResult =
LOG.error("getEgressActionsForInterface : RPC Call to Get egress actions for interface {} "
+ "returned with Errors {}", ifName, rpcResult.getErrors());
} else {
- actions = new ArrayList<Action>(rpcResult.getResult().nonnullAction().values());
+ actions = new ArrayList<>(rpcResult.getResult().nonnullAction().values());
}
}
List<ActionInfo> listActionInfo = new ArrayList<>();
return emptyList();
}
- return new ArrayList<Port>(portsOptional.get().nonnullPort().values());
+ return new ArrayList<>(portsOptional.get().nonnullPort().values());
}
@Nullable
@NonNull
public static List<Ports> getFloatingIpPortsForRouter(DataBroker broker, Uuid routerUuid) {
InstanceIdentifier<RouterPorts> routerPortsIdentifier = getRouterPortsId(routerUuid.getValue());
- List<Ports> portsList = new ArrayList<Ports>(SingleTransactionDataBroker
+ List<Ports> portsList = new ArrayList<>(SingleTransactionDataBroker
.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker, LogicalDatastoreType.CONFIGURATION,
routerPortsIdentifier).map(RouterPorts::nonnullPorts).orElse(Collections.emptyMap()).values());
LogicalDatastoreType.CONFIGURATION, id);
if (routerData.isPresent()) {
return NatUtil.getExternalSubnetIdsFromExternalIps(
- new ArrayList<ExternalIps>(routerData.get().nonnullExternalIps().values()));
+ new ArrayList<>(routerData.get().nonnullExternalIps().values()));
} else {
LOG.warn("getExternalSubnetIdsForRouter : No external router data for router {}", routerName);
return Collections.emptySet();
LOG.debug("makePreDnatToSnatTableEntry : Create Pre-DNAT table {} --> table {} flow on NAPT DpnId {} ",
NwConstants.PDNAT_TABLE, tableId, naptDpnId);
- Map<InstructionKey, Instruction> preDnatToSnatInstructionsMap = new HashMap<InstructionKey, Instruction>();
+ Map<InstructionKey, Instruction> preDnatToSnatInstructionsMap = new HashMap<>();
preDnatToSnatInstructionsMap.put(new InstructionKey(0),
new InstructionGotoTable(tableId).buildInstruction(0));
List<MatchInfo> matches = new ArrayList<>();
public static InstanceIdentifier<VpnInterfaceOpDataEntry> getVpnInterfaceOpDataEntryIdentifier(
String vpnInterfaceName, String vpnName) {
return InstanceIdentifier.builder(VpnInterfaceOpData.class).child(VpnInterfaceOpDataEntry.class,
- new VpnInterfaceOpDataEntryKey(vpnInterfaceName, vpnName)).build();
+ new VpnInterfaceOpDataEntryKey(vpnInterfaceName, vpnName)).build();
}
public static boolean checkForRoutersWithSameExtNetAndNaptSwitch(DataBroker broker, Uuid networkId,
}
Uint64 naptId = NatUtil.getPrimaryNaptfromRouterName(dataBroker, routerName);
if (naptId == null || naptId.equals(Uint64.ZERO)
- || (!NatUtil.getSwitchStatus(dataBroker, naptId) && (upgradeInProgress == false))) {
+ || !NatUtil.getSwitchStatus(dataBroker, naptId) && upgradeInProgress == false) {
LOG.debug("handleSNATForDPN : NaptSwitch is down or not selected for router {},naptId {}",
routerName, naptId);
naptSwitch = dpnId;
if (dpnInElanInterfaces.isPresent()) {
dpnInterface = dpnInElanInterfaces.get();
- elanInterfaceList = (dpnInterface.getInterfaces() != null && !dpnInterface.getInterfaces().isEmpty())
+ elanInterfaceList = dpnInterface.getInterfaces() != null && !dpnInterface.getInterfaces().isEmpty()
? new ArrayList<>(dpnInterface.getInterfaces()) : elanInterfaceList;
}
if (!elanInterfaceList.contains(pseudoPortId)) {
}
dpnInterface = dpnInElanInterfaces.get();
- elanInterfaceList = (dpnInterface.getInterfaces() != null && !dpnInterface.getInterfaces().isEmpty())
+ elanInterfaceList = dpnInterface.getInterfaces() != null && !dpnInterface.getInterfaces().isEmpty()
? new ArrayList<>(dpnInterface.getInterfaces()) : elanInterfaceList;
if (!elanInterfaceList.contains(pseudoPortId)) {
LOG.info("Router port not present in DPN {} for VPN {}", dpnId, elanInstanceName);
if (neutronPort == null) {
return Boolean.TRUE;
} else {
- return (NatConstants.NETWORK_ROUTER_INTERFACE.equalsIgnoreCase(neutronPort.getDeviceOwner()) ? Boolean.TRUE
- : Boolean.FALSE);
+ return NatConstants.NETWORK_ROUTER_INTERFACE.equalsIgnoreCase(neutronPort.getDeviceOwner()) ? Boolean.TRUE
+ : Boolean.FALSE;
}
}
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>7.0.6</version>
+ <version>8.1.0</version>
<relativePath/>
</parent>
*/
package org.opendaylight.netvirt.neutronvpn.api.utils;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import java.util.Collections;
import java.util.List;
import java.util.Locale;
}
public static boolean isUuid(String possibleUuid) {
- Preconditions.checkNotNull(possibleUuid, "possibleUuid == null");
+ requireNonNull(possibleUuid, "possibleUuid == null");
if (uuidPattern == null) {
// Thread safe because it really doesn't matter even if we were to do this initialization more than once
<packaging>bundle</packaging>
<modelVersion>4.0.0</modelVersion>
+ <properties>
+ <odlparent.modernizer.enforce>false</odlparent.modernizer.enforce>
+ </properties>
+
<dependencies>
<dependency>
<groupId>org.osgi</groupId>
<dependency>
<groupId>org.opendaylight.infrautils</groupId>
<artifactId>metrics-impl-test</artifactId>
- <version>1.8.1</version>
<scope>test</scope>
</dependency>
<dependency>
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.IfL2vlan;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.IfL2vlanBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.ParentRefs;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.ParentRefsBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.SplitHorizon;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.SplitHorizonBuilder;
// in order to validate the supported vnic types from the hostconfig
if (input.getFixedIps() != null
&& !input.getFixedIps().isEmpty()
- && !(isPortTypeSwitchdev(input) && !isPortBound(input))) {
+ && (!isPortTypeSwitchdev(input) || isPortBound(input))) {
handleNeutronPortCreated(input);
}
NeutronUtils.createPortStatus(input.getUuid().getValue(), portStatus, dataBroker);
handleFloatingIpPortUpdated(original, update);
}
} else {
- Set<FixedIps> oldIPs = getFixedIpSet(new ArrayList<FixedIps>(original.nonnullFixedIps().values()));
- Set<FixedIps> newIPs = getFixedIpSet(new ArrayList<FixedIps>(update.nonnullFixedIps().values()));
+ Set<FixedIps> oldIPs = getFixedIpSet(new ArrayList<>(original.nonnullFixedIps().values()));
+ Set<FixedIps> newIPs = getFixedIpSet(new ArrayList<>(update.nonnullFixedIps().values()));
if (!oldIPs.equals(newIPs)) {
handleNeutronPortUpdated(original, update);
}
if (origSecurityEnabled || updatedSecurityEnabled) {
InterfaceAcl infAcl = handlePortSecurityUpdated(original, update, origSecurityEnabled,
updatedSecurityEnabled, interfaceBuilder).build();
- interfaceBuilder.addAugmentation(InterfaceAcl.class, infAcl);
+ interfaceBuilder.addAugmentation(infAcl);
} else if (isDhcpServerPort) {
Set<FixedIps> oldIPs = getFixedIpSet(
- new ArrayList<FixedIps>(original.nonnullFixedIps().values()));
+ new ArrayList<>(original.nonnullFixedIps().values()));
Set<FixedIps> newIPs = getFixedIpSet(
- new ArrayList<FixedIps>(update.nonnullFixedIps().values()));
+ new ArrayList<>(update.nonnullFixedIps().values()));
if (!oldIPs.equals(newIPs)) {
InterfaceAcl infAcl = neutronvpnUtils.getDhcpInterfaceAcl(update);
- interfaceBuilder.addAugmentation(InterfaceAcl.class, infAcl);
+ interfaceBuilder.addAugmentation(infAcl);
}
}
LOG.info("update: Of-port-interface updation for port {}", portName);
// populate floating-ip uuid and floating-ip port attributes (uuid, mac and subnet id for the ONLY
// fixed IP) to be used by NAT, depopulated in NATService once mac is retrieved in the removal path
addToFloatingIpPortInfo(new Uuid(update.getDeviceId()), update.getUuid(),
- new ArrayList<FixedIps>(update.nonnullFixedIps().values()).get(0)
+ new ArrayList<>(update.nonnullFixedIps().values()).get(0)
.getSubnetId(), update.getMacAddress().getValue());
elanService.addKnownL3DmacAddress(update.getMacAddress().getValue(), update.getNetworkId().getValue());
}
if (NeutronConstants.IS_ODL_DHCP_PORT.test(port)) {
return;
}
- if (!(NeutronUtils.isPortVnicTypeNormal(port)
- || isPortTypeSwitchdev(port)
- && isSupportedVnicTypeByHost(port, NeutronConstants.VNIC_TYPE_DIRECT))) {
+ if (!NeutronUtils.isPortVnicTypeNormal(port)
+ && (!isPortTypeSwitchdev(port) || !isSupportedVnicTypeByHost(port, NeutronConstants.VNIC_TYPE_DIRECT))) {
for (FixedIps ip: keyFixedIpsMap.values()) {
nvpnManager.updateSubnetmapNodeWithPorts(ip.getSubnetId(), null, portId);
}
final String portName = port.getUuid().getValue();
final Uuid portId = port.getUuid();
final Map<FixedIpsKey, FixedIps> keyFixedIpsMap = port.nonnullFixedIps();
- if (!(NeutronUtils.isPortVnicTypeNormal(port) || isPortTypeSwitchdev(port))) {
+ if (!NeutronUtils.isPortVnicTypeNormal(port) && !isPortTypeSwitchdev(port)) {
for (FixedIps ip : keyFixedIpsMap.values()) {
// remove direct port from subnetMaps config DS
// TODO: for direct port as well, operations should be carried out per subnet based on port IP
NeutronvpnUtils.getUpdatedSecurityGroups(interfaceAcl.getSecurityGroups(),
portOriginal.getSecurityGroups(), portUpdated.getSecurityGroups()));
List<AllowedAddressPairs> updatedAddressPairs = NeutronvpnUtils.getUpdatedAllowedAddressPairs(
- new ArrayList<AllowedAddressPairs>(interfaceAcl.nonnullAllowedAddressPairs().values()),
+ new ArrayList<>(interfaceAcl.nonnullAllowedAddressPairs().values()),
new ArrayList<>(portOriginal.nonnullAllowedAddressPairs().values()),
- new ArrayList<org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.port
- .attributes.AllowedAddressPairs>(portUpdated.nonnullAllowedAddressPairs().values()));
+ new ArrayList<>(portUpdated.nonnullAllowedAddressPairs().values()));
interfaceAclBuilder.setAllowedAddressPairs(NeutronvpnUtils.getAllowedAddressPairsForFixedIps(
updatedAddressPairs, portOriginal.getMacAddress(), portOriginal.getFixedIps(),
portUpdated.nonnullFixedIps().values()));
ifL2vlanBuilder.setVlanId(new VlanId(portIdToSubport.getVlanId().intValue()));
String parentRefName = portIdToSubport.getTrunkPortId().getValue();
ParentRefsBuilder parentRefsBuilder = new ParentRefsBuilder().setParentInterface(parentRefName);
- interfaceBuilder.addAugmentation(ParentRefs.class, parentRefsBuilder.build());
+ interfaceBuilder.addAugmentation(parentRefsBuilder.build());
SplitHorizon splitHorizon =
new SplitHorizonBuilder().setOverrideSplitHorizonProtection(true).build();
- interfaceBuilder.addAugmentation(SplitHorizon.class, splitHorizon);
+ interfaceBuilder.addAugmentation(splitHorizon);
}
}
ifL2vlanBuilder.setL2vlanMode(l2VlanMode);
interfaceBuilder.setEnabled(true).setName(interfaceName).setType(L2vlan.class)
- .addAugmentation(IfL2vlan.class, ifL2vlanBuilder.build());
+ .addAugmentation(ifL2vlanBuilder.build());
if (NeutronvpnUtils.getPortSecurityEnabled(port)) {
InterfaceAclBuilder interfaceAclBuilder = new InterfaceAclBuilder();
interfaceAclBuilder.setPortSecurityEnabled(true);
neutronvpnUtils.populateInterfaceAclBuilder(interfaceAclBuilder, port);
- interfaceBuilder.addAugmentation(InterfaceAcl.class, interfaceAclBuilder.build());
+ interfaceBuilder.addAugmentation(interfaceAclBuilder.build());
} else if (neutronvpnConfig.isLimitBumtrafficToDhcpserver() && NeutronvpnUtils.isDhcpServerPort(port)) {
- interfaceBuilder.addAugmentation(InterfaceAcl.class, neutronvpnUtils.getDhcpInterfaceAcl(port));
+ interfaceBuilder.addAugmentation(neutronvpnUtils.getDhcpInterfaceAcl(port));
}
return interfaceBuilder.build();
}
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160218.access.lists.AclBuilder;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160218.access.lists.AclKey;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160218.access.lists.acl.AccessListEntriesBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.aclservice.rev160608.AclserviceAugmentation;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.aclservice.rev160608.AclserviceAugmentationBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.rev150712.Neutron;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.secgroups.rev150712.security.groups.attributes.SecurityGroups;
if (aclTag != NeutronSecurityGroupConstants.INVALID_ACL_TAG) {
AclserviceAugmentationBuilder aclserviceAugmentationBuilder = new AclserviceAugmentationBuilder();
aclserviceAugmentationBuilder.setAclTag(aclTag);
- aclBuilder.addAugmentation(AclserviceAugmentation.class, aclserviceAugmentationBuilder.build());
+ aclBuilder.addAugmentation(aclserviceAugmentationBuilder.build());
}
return aclBuilder;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv6Prefix;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.PortNumber;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.packet.fields.rev160218.acl.transport.header.fields.DestinationPortRangeBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.aclservice.rev160608.SecurityRuleAttr;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.aclservice.rev160608.SecurityRuleAttrBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.constants.rev150712.DirectionBase;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.constants.rev150712.DirectionEgress;
aceBuilder.setRuleName(securityRule.getUuid().getValue());
aceBuilder.setMatches(matchesBuilder.build());
aceBuilder.setActions(actionsBuilder.build());
- aceBuilder.addAugmentation(SecurityRuleAttr.class, securityRuleAttrBuilder.build());
+ aceBuilder.addAugmentation(securityRuleAttrBuilder.build());
return aceBuilder;
}
if (Objects.equals(original, update)) {
return;
}
- List<SubPorts> updatedSubPorts = new ArrayList<SubPorts>(update.nonnullSubPorts().values());
+ List<SubPorts> updatedSubPorts = new ArrayList<>(update.nonnullSubPorts().values());
if (updatedSubPorts == null) {
updatedSubPorts = Collections.emptyList();
}
- List<SubPorts> originalSubPorts = new ArrayList<SubPorts>(original.nonnullSubPorts().values());
+ List<SubPorts> originalSubPorts = new ArrayList<>(original.nonnullSubPorts().values());
if (originalSubPorts == null) {
originalSubPorts = Collections.emptyList();
}
.setVlanId(new VlanId(subPort.getSegmentationId().intValue())).build();
ParentRefs parentRefs = new ParentRefsBuilder().setParentInterface(parentName).build();
SplitHorizon splitHorizon = new SplitHorizonBuilder().setOverrideSplitHorizonProtection(true).build();
- interfaceBuilder.setName(portName).setType(L2vlan.class).addAugmentation(IfL2vlan.class, ifL2vlan)
- .addAugmentation(ParentRefs.class, parentRefs).addAugmentation(SplitHorizon.class, splitHorizon);
+ interfaceBuilder.setName(portName).setType(L2vlan.class).addAugmentation(ifL2vlan)
+ .addAugmentation(parentRefs).addAugmentation(splitHorizon);
Interface newIface = interfaceBuilder.build();
/*
* Interface is already created for parent NeutronPort. We're updating parent refs
interfaceBuilder.removeAugmentation(IfL2vlan.class).removeAugmentation(ParentRefs.class)
.removeAugmentation(SplitHorizon.class);
IfL2vlan ifL2vlan = new IfL2vlanBuilder().setL2vlanMode(IfL2vlan.L2vlanMode.Trunk).build();
- interfaceBuilder.addAugmentation(IfL2vlan.class, ifL2vlan);
+ interfaceBuilder.addAugmentation(ifL2vlan);
Interface newIface = interfaceBuilder.build();
/*
* There is no means to do an update to remove elements from a node.
@Nullable VpnInterface vpnIface) {
List<Adjacency> adjList = new ArrayList<>();
if (vpnIface != null) {
- adjList = new ArrayList<Adjacency>(vpnIface.augmentation(Adjacencies.class).getAdjacency().values());
+ adjList = new ArrayList<>(vpnIface.augmentation(Adjacencies.class).getAdjacency().values());
}
String infName = port.getUuid().getValue();
LOG.trace("neutronVpnManager: create config adjacencies for Port: {}", infName);
if (routerId != null) {
Router rtr = neutronvpnUtils.getNeutronRouter(routerId);
if (rtr != null && rtr.getRoutes() != null) {
- List<Routes> routeList = new ArrayList<Routes>(rtr.getRoutes().values());
+ List<Routes> routeList = new ArrayList<>(rtr.getRoutes().values());
// create extraroute Adjacence for each ipValue,
// because router can have IPv4 and IPv6 subnet ports, or can have
// more that one IPv4 subnet port or more than one IPv6 subnet port
Map<VpnInstanceNamesKey, VpnInstanceNames> keyVpnInstanceNamesMap = vpnInterface.getVpnInstanceNames();
if (keyVpnInstanceNamesMap != null
&& VpnHelper.doesVpnInterfaceBelongToVpnInstance(vpnId,
- new ArrayList<VpnInstanceNames>(keyVpnInstanceNamesMap.values()))) {
+ new ArrayList<>(keyVpnInstanceNamesMap.values()))) {
VpnHelper.removeVpnInterfaceVpnInstanceNamesFromList(vpnId,
- new ArrayList<VpnInstanceNames>(keyVpnInstanceNamesMap.values()));
+ new ArrayList<>(keyVpnInstanceNamesMap.values()));
if (!keyVpnInstanceNamesMap.isEmpty()) {
LOG.debug("Deleting vpn interface {} not immediately since vpnInstanceName "
+ "List not empty", infName);
= optionalVpnInterface.get().getVpnInstanceNames();
if (keyVpnInstanceNamesMap != null
&& VpnHelper.doesVpnInterfaceBelongToVpnInstance(vpnId.getValue(),
- new ArrayList<VpnInstanceNames>(keyVpnInstanceNamesMap.values()))) {
+ new ArrayList<>(keyVpnInstanceNamesMap.values()))) {
VpnHelper.removeVpnInterfaceVpnInstanceNamesFromList(vpnId.getValue(),
- new ArrayList<VpnInstanceNames>(keyVpnInstanceNamesMap.values()));
+ new ArrayList<>(keyVpnInstanceNamesMap.values()));
}
VpnInterfaceBuilder vpnIfBuilder = new VpnInterfaceBuilder(optionalVpnInterface.get())
.setVpnInstanceNames(keyVpnInstanceNamesMap);
if (!isBeingAssociated) {
Adjacencies adjs = vpnIfBuilder.augmentation(Adjacencies.class);
Map<AdjacencyKey, Adjacency> keyAdjacencyMap = adjs != null ? adjs.getAdjacency()
- : new HashMap<AdjacencyKey, Adjacency>();
+ : new HashMap<>();
Iterator<Adjacency> adjacencyIter = keyAdjacencyMap.values().iterator();
while (adjacencyIter.hasNext()) {
Adjacency adjacency = adjacencyIter.next();
}
}
Adjacencies adjacencies = new AdjacenciesBuilder().setAdjacency(keyAdjacencyMap).build();
- vpnIfBuilder.addAugmentation(Adjacencies.class, adjacencies);
+ vpnIfBuilder.addAugmentation(adjacencies);
}
for (FixedIps ip : port.nonnullFixedIps().values()) {
String ipValue = ip.getIpAddress().stringValue();
Uuid vpnId = new Uuid(vpnInstance.getVpnInstanceName());
// create VpnMaps id
L3vpnInstancesBuilder l3vpn = new L3vpnInstancesBuilder();
- List<String> rd = Collections.EMPTY_LIST;
+ List<String> rd = Collections.emptyList();
if (vpnInstance.getRouteDistinguisher() != null) {
rd = vpnInstance.getRouteDistinguisher();
}
List<String> irtList = new ArrayList<>();
if (vpnInstance.getVpnTargets() != null) {
- Map<VpnTargetKey, VpnTarget> keyVpnTargetMap = Collections.EMPTY_MAP;
+ Map<VpnTargetKey, VpnTarget> keyVpnTargetMap = Collections.emptyMap();
if (!vpnInstance.getVpnTargets().getVpnTarget().isEmpty()) {
keyVpnTargetMap = vpnInstance.getVpnTargets().getVpnTarget();
}
Adjacencies erAdjs =
new AdjacenciesBuilder().setAdjacency(getAdjacencyMap(newAdjList)).build();
VpnInterface vpnIf = new VpnInterfaceBuilder().withKey(new VpnInterfaceKey(infName))
- .addAugmentation(Adjacencies.class, erAdjs).build();
+ .addAugmentation(erAdjs).build();
SingleTransactionDataBroker.syncUpdate(dataBroker, LogicalDatastoreType.CONFIGURATION,
vpnIfIdentifier, vpnIf);
} else {
}
if (adjacencies != null) {
- vpnb.addAugmentation(Adjacencies.class, adjacencies);
+ vpnb.addAugmentation(adjacencies);
}
VpnInterface vpnIf = vpnb.build();
try {
if (adjacencies == null) {
return;
}
- vpnIfBuilder.addAugmentation(Adjacencies.class, adjacencies);
+ vpnIfBuilder.addAugmentation(adjacencies);
if (optionalVpnInterface.get().getVpnInstanceNames() != null) {
List<VpnInstanceNames> listVpnInstances = new ArrayList<>(
optionalVpnInterface.get().getVpnInstanceNames().values());
LOG.debug("Deleting Elan-EvpnAugmentation with key {}", elanInstanceName);
}
- elanInstanceBuilder.addAugmentation(EvpnAugmentation.class, evpnAugmentationBuilder.build());
+ elanInstanceBuilder.addAugmentation(evpnAugmentationBuilder.build());
tx.mergeParentStructurePut(elanIid, elanInstanceBuilder.build());
}), LOG, "Error updating ELAN with VPN info {}, {}, {}", elanInstanceName, vpnInstance, operation);
}
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.netvirt.neutronvpn;
-import static org.mockito.Matchers.any;
+import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.when;
IpAddress ipv6 = new IpAddress(new Ipv6Address("1::1"));
FixedIpsBuilder fib = new FixedIpsBuilder();
fib.setIpAddress(ipv6);
+ fib.setSubnetId(new Uuid("12345678-1234-1234-1234-123456789012"));
List<FixedIps> fixedIps = new ArrayList<>();
fixedIps.add(fib.build());
pb.setFixedIps(fixedIps);
IpAddress ipv4 = new IpAddress(new Ipv4Address("2.2.2.2"));
FixedIpsBuilder fib = new FixedIpsBuilder();
fib.setIpAddress(ipv4);
+ fib.setSubnetId(new Uuid("12345678-1234-1234-1234-123456789012"));
List<FixedIps> fixedIps = new ArrayList<>();
fixedIps.add(fib.build());
pb.setFixedIps(fixedIps);
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>7.0.6</version>
+ <version>8.1.0</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>7.0.6</version>
+ <version>8.1.0</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>7.0.6</version>
+ <version>8.1.0</version>
<relativePath/>
</parent>
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.servicebinding.rev160406.ServiceBindings;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.servicebinding.rev160406.ServiceModeIngress;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.servicebinding.rev160406.ServiceTypeFlowBased;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.servicebinding.rev160406.StypeOpenflow;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.servicebinding.rev160406.StypeOpenflowBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.servicebinding.rev160406.service.bindings.ServicesInfo;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.servicebinding.rev160406.service.bindings.ServicesInfoKey;
session.getConsole().println("No cache found");
return;
}
- if (!(qosPolicyMap.isEmpty())) {
+ if (!qosPolicyMap.isEmpty()) {
displayQosPolicyMap(session, gson);
}
- if (!(qosPortsMap.isEmpty())) {
+ if (!qosPortsMap.isEmpty()) {
displayQosPortsMap(session, gson);
}
- if (!(qosNetworksMap.isEmpty())) {
+ if (!qosNetworksMap.isEmpty()) {
displayQosNetworksMap(session, gson);
}
}
.child(NetworkMap.class, new NetworkMapKey(networkId)).build();
Optional<NetworkMap> optionalNetworkMap = MDSALUtil.read(LogicalDatastoreType.CONFIGURATION,
networkMapId, dataBroker);
- return (optionalNetworkMap.isPresent() && optionalNetworkMap.get().getSubnetIdList() != null)
+ return optionalNetworkMap.isPresent() && optionalNetworkMap.get().getSubnetIdList() != null
? optionalNetworkMap.get().getSubnetIdList() : emptyList();
}
.child(Subnetmap.class, new SubnetmapKey(subnetId)).build();
Optional<Subnetmap> optionalSubnetmap = MDSALUtil.read(LogicalDatastoreType.CONFIGURATION,
subnetMapId,dataBroker);
- return (optionalSubnetmap.isPresent() && optionalSubnetmap.get().getPortList() != null)
+ return optionalSubnetmap.isPresent() && optionalSubnetmap.get().getPortList() != null
? optionalSubnetmap.get().getPortList() : emptyList();
}
TerminationPointBuilder tpBuilder = new TerminationPointBuilder();
tpBuilder.withKey(tp.key());
- tpBuilder.addAugmentation(OvsdbTerminationPointAugmentation.class, tpAugmentationBuilder.build());
+ tpBuilder.addAugmentation(tpAugmentationBuilder.build());
try {
if (writeConfigTxn != null) {
writeConfigTxn.mergeParentStructureMerge(InstanceIdentifier
.setFlowPriority(priority).setInstruction(instructions);
return new BoundServicesBuilder().withKey(new BoundServicesKey(qosServiceIndex)).setServiceName(serviceName)
.setServicePriority(qosServiceIndex).setServiceType(ServiceTypeFlowBased.class)
- .addAugmentation(StypeOpenflow.class, augBuilder.build()).build();
+ .addAugmentation(augBuilder.build()).build();
}
@NonNull
@Nullable
public static String getPortNumberFromLowerLayerIf(String lowerLayerIf) {
try {
- return (lowerLayerIf.substring(lowerLayerIf.lastIndexOf(":") + 1));
+ return lowerLayerIf.substring(lowerLayerIf.lastIndexOf(":") + 1);
} catch (NullPointerException e) {
return null;
}
int versions = 0;
for (FixedIps fixedIp: port.nonnullFixedIps().values()) {
if (fixedIp.getIpAddress().getIpv4Address() != null) {
- versions |= (1 << QosConstants.IPV4_ADDR_MASK_BIT);
+ versions |= 1 << QosConstants.IPV4_ADDR_MASK_BIT;
} else if (fixedIp.getIpAddress().getIpv6Address() != null) {
- versions |= (1 << QosConstants.IPV6_ADDR_MASK_BIT);
+ versions |= 1 << QosConstants.IPV6_ADDR_MASK_BIT;
}
}
return versions;
}
public boolean hasIpv4Addr(int versions) {
- return (versions & (1 << QosConstants.IPV4_ADDR_MASK_BIT)) != 0;
+ return (versions & 1 << QosConstants.IPV4_ADDR_MASK_BIT) != 0;
}
public boolean hasIpv6Addr(int versions) {
- return (versions & (1 << QosConstants.IPV6_ADDR_MASK_BIT)) != 0;
+ return (versions & 1 << QosConstants.IPV6_ADDR_MASK_BIT) != 0;
}
public boolean isBindServiceDone(Optional<Uuid> uuid) {
*/
package org.opendaylight.netvirt.qosservice;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import java.util.Optional;
import java.util.regex.Pattern;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
private Pattern uuidPattern;
Optional<Uuid> newUuidIfValidPattern(String possibleUuid) {
- Preconditions.checkNotNull(possibleUuid, "possibleUuid == null");
+ requireNonNull(possibleUuid, "possibleUuid == null");
if (uuidPattern == null) {
// Thread safe because it really doesn't matter even if we were to do this initialization more than once
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>7.0.6</version>
+ <version>8.1.0</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>7.0.6</version>
+ <version>8.1.0</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>7.0.6</version>
+ <version>8.1.0</version>
<relativePath/>
</parent>
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.servicebinding.rev160406.ServiceBindings;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.servicebinding.rev160406.ServiceModeIngress;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.servicebinding.rev160406.ServiceTypeFlowBased;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.servicebinding.rev160406.StypeOpenflow;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.servicebinding.rev160406.StypeOpenflowBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.servicebinding.rev160406.service.bindings.ServicesInfo;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.servicebinding.rev160406.service.bindings.ServicesInfoKey;
new StypeOpenflowBuilder().setFlowCookie(cookie).setFlowPriority(flowPriority).setInstruction(instructions);
return new BoundServicesBuilder().withKey(new BoundServicesKey(servicePriority))
.setServiceName(serviceName).setServicePriority(servicePriority)
- .setServiceType(ServiceTypeFlowBased.class).addAugmentation(StypeOpenflow.class,
- augBuilder.build()).build();
+ .setServiceType(ServiceTypeFlowBased.class).addAugmentation(augBuilder.build()).build();
}
public static boolean isOperational(DataBroker dataBroker, String ifName) {
if (vpnInterfaces.isEmpty()) {
Map<IpAddressesKey, IpAddresses> ipAddressesMap = dpnInVpn.nonnullIpAddresses();
VpnToDpnListBuilder dpnInVpnBuilder =
- new VpnToDpnListBuilder(dpnInVpn).setVpnInterfaces(Collections.EMPTY_LIST);
+ new VpnToDpnListBuilder(dpnInVpn).setVpnInterfaces(Collections.emptyMap());
if (ipAddressesMap == null || ipAddressesMap.isEmpty()) {
dpnInVpnBuilder.setDpnState(VpnToDpnList.DpnState.Inactive);
lastDpnOnVpn.set(true);
package org.opendaylight.netvirt.vpnmanager;
import static java.util.Collections.emptyList;
+import static java.util.Objects.requireNonNull;
import static org.opendaylight.mdsal.binding.util.Datastore.CONFIGURATION;
import static org.opendaylight.mdsal.binding.util.Datastore.OPERATIONAL;
-import com.google.common.base.Preconditions;
import com.google.common.collect.Iterators;
import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.Futures;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data.vpn.instance.op.data.entry.VpnToDpnList;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data.vpn.instance.op.data.entry.vpntargets.VpnTarget;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.ext.routers.Routers;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.ext.routers.routers.ExternalIps;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.external.subnets.Subnets;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.l3vpn.rev200204.Adjacencies;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.l3vpn.rev200204.VpnInterfaces;
LOG.trace("Received VpnInterface add event: vpnInterface={}", vpnInterface);
LOG.info("add: intfName {} onto vpnName {}", vpnInterface.getName(),
VpnHelper.getVpnInterfaceVpnInstanceNamesString(
- new ArrayList<VpnInstanceNames>(vpnInterface.nonnullVpnInstanceNames().values())));
+ new ArrayList<>(vpnInterface.nonnullVpnInstanceNames().values())));
addVpnInterface(identifier, vpnInterface, null, null);
}
if (router != null) {
if (addOrRemove == NwConstants.ADD_FLOW) {
vpnManager.addArpResponderFlowsToExternalNetworkIps(routerName,
- VpnUtil.getIpsListFromExternalIps(new ArrayList<ExternalIps>(router
+ VpnUtil.getIpsListFromExternalIps(new ArrayList<>(router
.nonnullExternalIps().values())), router.getExtGwMacAddress(),
dpId, interfaceName, lportTag);
} else {
vpnManager.removeArpResponderFlowsToExternalNetworkIps(routerName,
- VpnUtil.getIpsListFromExternalIps(new ArrayList<ExternalIps>(router
+ VpnUtil.getIpsListFromExternalIps(new ArrayList<>(router
.nonnullExternalIps().values())),
dpId, interfaceName, lportTag);
}
}
Uuid intfnetworkUuid = null;
NetworkType networkType = null;
- Long segmentationId = Long.valueOf(-1);
+ long segmentationId = -1L;
Adjacencies adjacencies = null;
if (vpnInteface.isPresent()) {
intfnetworkUuid = vpnInteface.get().getNetworkId();
+ "on dpn {} for vpn {}", prefix, interfaceName, nhList, dpnId, vpnName);
Prefixes prefixes = intfnetworkUuid != null
- ? VpnUtil.getPrefixToInterface(dpnId, interfaceName, prefix, intfnetworkUuid ,networkType,
+ ? VpnUtil.getPrefixToInterface(dpnId, interfaceName, prefix, intfnetworkUuid, networkType,
segmentationId, prefixCue) :
VpnUtil.getPrefixToInterface(dpnId, interfaceName, prefix, prefixCue);
writeOperTxn.mergeParentStructureMerge(VpnUtil.getPrefixToInterfaceIdentifier(
AdjacenciesOp aug = VpnUtil.getVpnInterfaceOpDataEntryAugmentation(value);
VpnInterfaceOpDataEntry opInterface = new VpnInterfaceOpDataEntryBuilder(vpnInterface)
.withKey(new VpnInterfaceOpDataEntryKey(vpnInterface.getName(), vpnName))
- .addAugmentation(AdjacenciesOp.class, aug).build();
+ .addAugmentation(aug).build();
InstanceIdentifier<VpnInterfaceOpDataEntry> interfaceId =
VpnUtil.getVpnInterfaceOpDataEntryIdentifier(vpnInterface.getName(), vpnName);
writeOperTxn.mergeParentStructurePut(interfaceId, opInterface);
TypedWriteTransaction<Operational> writeOperTxn) {
AdjacenciesOp adjacencies = vpnInterface.augmentation(AdjacenciesOp.class);
- List<Adjacency> adjList = adjacencies != null ? new ArrayList<Adjacency>(adjacencies
+ List<Adjacency> adjList = adjacencies != null ? new ArrayList<>(adjacencies
.nonnullAdjacency().values()) : new ArrayList<>();
String prefix = null;
boolean isNextHopRemoveReqd = false;
AdjacenciesOp aug = VpnUtil.getVpnInterfaceOpDataEntryAugmentation(value);
VpnInterfaceOpDataEntry opInterface = new VpnInterfaceOpDataEntryBuilder(vpnInterface)
.withKey(new VpnInterfaceOpDataEntryKey(vpnInterface.getName(), vpnName))
- .addAugmentation(AdjacenciesOp.class, aug).build();
+ .addAugmentation(aug).build();
InstanceIdentifier<VpnInterfaceOpDataEntry> interfaceId =
VpnUtil.getVpnInterfaceOpDataEntryIdentifier(vpnInterface.getName(), vpnName);
writeOperTxn.mergeParentStructurePut(interfaceId, opInterface);
String interfaceName, Uint64 dpnId,
TypedWriteTransaction<Configuration> writeConfigTxn,
TypedWriteTransaction<Operational> writeOperTx) {
- return (nh) -> {
+ return nh -> {
String primaryRd = vpnUtil.getVpnRd(vpnName);
String prefix = nextHop.getIpAddress();
String vpnNamePrefixKey = VpnUtil.getVpnNamePrefixKey(vpnName, prefix);
TypedWriteTransaction<Operational> writeOperTx) {
List<VpnInstanceOpDataEntry> vpnsToImportRoute =
vpnUtil.getVpnsImportingMyRoute(vpnName);
- nhList.forEach((nh) -> {
+ nhList.forEach(nh -> {
//IRT: remove routes from other vpns importing it
if (isNonPrimaryAdjIp) {
removeLearntPrefixFromBGP(rd, nextHop.getIpAddress(), nh, writeConfigTxn);
+ "to newVpn(s) {}",
original.getName(), dpnId,
VpnHelper.getVpnInterfaceVpnInstanceNamesString(
- new ArrayList<VpnInstanceNames>(original.nonnullVpnInstanceNames().values())),
+ new ArrayList<>(original.nonnullVpnInstanceNames().values())),
VpnHelper.getVpnInterfaceVpnInstanceNamesString(
- new ArrayList<VpnInstanceNames>(update.nonnullVpnInstanceNames().values())));
+ new ArrayList<>(update.nonnullVpnInstanceNames().values())));
return emptyList();
}
updateVpnInstanceAdjChange(original, update, vpnInterfaceName, futures);
List<ListenableFuture<?>> futures) {
final Adjacencies origAdjs = original.augmentation(Adjacencies.class);
final List<Adjacency> oldAdjs = origAdjs != null && origAdjs.getAdjacency() != null
- ? new ArrayList<Adjacency>(origAdjs.getAdjacency().values()) : new ArrayList<>();
+ ? new ArrayList<>(origAdjs.getAdjacency().values()) : new ArrayList<>();
final Adjacencies updateAdjs = update.augmentation(Adjacencies.class);
final List<Adjacency> newAdjs = updateAdjs != null && updateAdjs.getAdjacency() != null
- ? new ArrayList<Adjacency>(updateAdjs.getAdjacency().values()) : new ArrayList<>();
+ ? new ArrayList<>(updateAdjs.getAdjacency().values()) : new ArrayList<>();
boolean isOldVpnRemoveCallExecuted = false;
for (String oldVpnName : oldVpnList) {
List<ListenableFuture<?>> futures) {
final Adjacencies origAdjs = original.augmentation(Adjacencies.class);
final List<Adjacency> oldAdjs = origAdjs != null && origAdjs.getAdjacency()
- != null ? new ArrayList<Adjacency>(origAdjs.getAdjacency().values()) : new ArrayList<>();
+ != null ? new ArrayList<>(origAdjs.getAdjacency().values()) : new ArrayList<>();
final Adjacencies updateAdjs = update.augmentation(Adjacencies.class);
final List<Adjacency> newAdjs = updateAdjs != null && updateAdjs.getAdjacency()
- != null ? new ArrayList<Adjacency>(updateAdjs.getAdjacency().values()) : new ArrayList<>();
+ != null ? new ArrayList<>(updateAdjs.getAdjacency().values()) : new ArrayList<>();
final Uint64 dpnId = InterfaceUtils.getDpnForInterface(ifaceMgrRpcService, vpnInterfaceName);
for (VpnInstanceNames vpnInterfaceVpnInstance : update.nonnullVpnInstanceNames().values()) {
}
private void updateLabelMapper(Uint32 label, List<String> nextHopIpList) {
- final String labelStr = Preconditions.checkNotNull(label, "updateLabelMapper: label cannot be null or empty!")
- .toString();
+ final String labelStr = requireNonNull(label, "updateLabelMapper: label cannot be null or empty!").toString();
// FIXME: separate this out somehow?
final ReentrantLock lock = JvmGlobalLocks.getLockForString(labelStr);
lock.lock();
RouteOrigin origin = RouteOrigin.SELF_IMPORTED;
VrfEntry vrfEntry = FibHelper.getVrfEntryBuilder(prefix, label, nextHop, origin, parentVpnRd)
- .addAugmentation(SubnetRoute.class, route).build();
+ .addAugmentation(route).build();
List<VrfEntry> vrfEntryList = Collections.singletonList(vrfEntry);
InstanceIdentifierBuilder<VrfTables> idBuilder =
InstanceIdentifier.builder(FibEntries.class).child(VrfTables.class, new VrfTablesKey(rd));
return false;
}
UnprocessedVpnInterfaceData other = (UnprocessedVpnInterfaceData) obj;
- if (identifier == null) {
- if (other.identifier != null) {
- return false;
- }
- } else if (!identifier.equals(other.identifier)) {
+ if (!Objects.equals(identifier, other.identifier)) {
return false;
}
- if (vpnInterface == null) {
- if (other.vpnInterface != null) {
- return false;
- }
- } else if (!vpnInterface.equals(other.vpnInterface)) {
+ if (!Objects.equals(vpnInterface, other.vpnInterface)) {
return false;
}
return true;
if (vpnInstanceOpData == null || vpnInstanceOpData.getVpnToDpnList() == null) {
return;
}
- List<VpnToDpnList> vpnToDpnLists = new ArrayList<VpnToDpnList>(vpnInstanceOpData.getVpnToDpnList().values());
+ List<VpnToDpnList> vpnToDpnLists = new ArrayList<>(vpnInstanceOpData.getVpnToDpnList().values());
if (vpnToDpnLists == null || vpnToDpnLists.isEmpty()) {
return;
}
LOG.debug("There is no adjacency available for vpnInterface:{}", vpnInterface);
return;
}
- List<Adjacency> operationVpnAdjacencies = new ArrayList<Adjacency>(vpnInterfaceOptional.get()
+ List<Adjacency> operationVpnAdjacencies = new ArrayList<>(vpnInterfaceOptional.get()
.augmentation(AdjacenciesOp.class).nonnullAdjacency().values());
// Due to insufficient rds, some of the extra route wont get processed when it is added.
// The unprocessed adjacencies will be present in config vpn interface DS but will be missing
*/
package org.opendaylight.netvirt.vpnmanager;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.util.ArrayList;
import java.util.Arrays;
Optional<SubnetOpDataEntry> optionalSubs = null;
Uint32 label;
- Preconditions.checkNotNull(subnetId,
- LOGGING_PREFIX + " onSubnetAddedToVpn: SubnetId cannot be null or empty!");
- Preconditions.checkNotNull(subnetIp,
- LOGGING_PREFIX + " onSubnetAddedToVpn: SubnetPrefix cannot be null or empty!");
- Preconditions.checkNotNull(elanTag,
- LOGGING_PREFIX + " onSubnetAddedToVpn: ElanTag cannot be null or empty!");
+ requireNonNull(subnetId, LOGGING_PREFIX + " onSubnetAddedToVpn: SubnetId cannot be null or empty!");
+ requireNonNull(subnetIp, LOGGING_PREFIX + " onSubnetAddedToVpn: SubnetPrefix cannot be null or empty!");
+ requireNonNull(elanTag, LOGGING_PREFIX + " onSubnetAddedToVpn: ElanTag cannot be null or empty!");
if (subnetmap.getVpnId() == null) {
LOG.error("onSubnetAddedToVpn: VpnId {} for subnet {} not found, bailing out", subnetmap.getVpnId(),
String vpnName = subnetmap.getVpnId().getValue();
String subnetIp = subnetmap.getSubnetIp();
- Preconditions.checkNotNull(subnetId,
- LOGGING_PREFIX + " onSubnetUpdatedInVpn: SubnetId cannot be null or empty!");
- Preconditions.checkNotNull(subnetIp,
- LOGGING_PREFIX + " onSubnetUpdatedInVpn: SubnetPrefix cannot be null or empty!");
- Preconditions.checkNotNull(vpnName, LOGGING_PREFIX + " onSubnetUpdatedInVpn: VpnName cannot be null or empty!");
- Preconditions.checkNotNull(elanTag, LOGGING_PREFIX + " onSubnetUpdatedInVpn: ElanTag cannot be null or empty!");
+ requireNonNull(subnetId, LOGGING_PREFIX + " onSubnetUpdatedInVpn: SubnetId cannot be null or empty!");
+ requireNonNull(subnetIp, LOGGING_PREFIX + " onSubnetUpdatedInVpn: SubnetPrefix cannot be null or empty!");
+ requireNonNull(vpnName, LOGGING_PREFIX + " onSubnetUpdatedInVpn: VpnName cannot be null or empty!");
+ requireNonNull(elanTag, LOGGING_PREFIX + " onSubnetUpdatedInVpn: ElanTag cannot be null or empty!");
try {
InstanceIdentifier<SubnetOpDataEntry> subOpIdentifier =
InstanceIdentifier.builder(SubnetOpData.class).child(SubnetOpDataEntry.class,
}
SubnetOpDataEntry subnetOpDataEntry = optionalSubs.get();
SubnetOpDataEntryBuilder subOpBuilder = new SubnetOpDataEntryBuilder(subnetOpDataEntry);
- List<SubnetToDpn> subnetToDpnList = concat(new ArrayList<SubnetToDpn>(subnetOpDataEntry
+ List<SubnetToDpn> subnetToDpnList = concat(new ArrayList<>(subnetOpDataEntry
.nonnullSubnetToDpn().values()), subDpn);
subOpBuilder.setSubnetToDpn(getSubnetToDpnMap(subnetToDpnList));
if (subOpBuilder.getRouteAdvState() != TaskState.Advertised) {
subOpBuilder.getRouteAdvState(), subOpBuilder.getLastAdvState());
boolean isExternalSubnetVpn = VpnUtil.isExternalSubnetVpn(subnetOpDataEntry.getVpnName(),
subnetId.getValue());
- List<SubnetToDpn> subnetToDpnList = concat(new ArrayList<SubnetToDpn>(subnetOpDataEntry
+ List<SubnetToDpn> subnetToDpnList = concat(new ArrayList<>(subnetOpDataEntry
.nonnullSubnetToDpn().values()), subDpn);
subOpBuilder.setSubnetToDpn(getSubnetToDpnMap(subnetToDpnList));
Uint32 label = optionalSubs.get().getLabel();
String vpnName, Long elanTag, Uint32 label, Uint32 l3vni,
Uuid subnetId, boolean isBgpVpn, String networkName) {
- Preconditions.checkNotNull(rd,
- LOGGING_PREFIX + " addSubnetRouteToFib: RouteDistinguisher cannot be null or empty!");
- Preconditions.checkNotNull(subnetIp,
- LOGGING_PREFIX + " addSubnetRouteToFib: SubnetRouteIp cannot be null or empty!");
- Preconditions.checkNotNull(vpnName, LOGGING_PREFIX + " addSubnetRouteToFib: vpnName cannot be null or empty!");
- Preconditions.checkNotNull(elanTag, LOGGING_PREFIX + " addSubnetRouteToFib: elanTag cannot be null or empty!");
- Preconditions.checkNotNull(label, LOGGING_PREFIX + " addSubnetRouteToFib: label cannot be null or empty!");
+ requireNonNull(rd, LOGGING_PREFIX + " addSubnetRouteToFib: RouteDistinguisher cannot be null or empty!");
+ requireNonNull(subnetIp, LOGGING_PREFIX + " addSubnetRouteToFib: SubnetRouteIp cannot be null or empty!");
+ requireNonNull(vpnName, LOGGING_PREFIX + " addSubnetRouteToFib: vpnName cannot be null or empty!");
+ requireNonNull(elanTag, LOGGING_PREFIX + " addSubnetRouteToFib: elanTag cannot be null or empty!");
+ requireNonNull(label, LOGGING_PREFIX + " addSubnetRouteToFib: label cannot be null or empty!");
VrfEntry.EncapType encapType = VpnUtil.getEncapType(VpnUtil.isL3VpnOverVxLan(l3vni));
VpnPopulator vpnPopulator = L3vpnRegistry.getRegisteredPopulator(encapType);
LOG.info("{} addSubnetRouteToFib: Adding SubnetRoute fib entry for vpnName {}, subnetIP {}, elanTag {}",
vpnPopulator.populateFib(input, null /*writeCfgTxn*/);
return true;
}
- Preconditions.checkNotNull(nextHopIp, LOGGING_PREFIX + "NextHopIp cannot be null or empty!");
+ requireNonNull(nextHopIp, LOGGING_PREFIX + "NextHopIp cannot be null or empty!");
vpnUtil.syncWrite(LogicalDatastoreType.OPERATIONAL, VpnUtil
.getPrefixToInterfaceIdentifier(vpnUtil.getVpnId(vpnName), subnetIp), VpnUtil
.getPrefixToInterface(nhDpnId, subnetId.getValue(), subnetIp, Prefixes.PrefixCue.SubnetRoute));
// TODO Clean up the exception handling
@SuppressWarnings("checkstyle:IllegalCatch")
private boolean deleteSubnetRouteFromFib(String rd, String subnetIp, String vpnName, boolean isBgpVpn) {
- Preconditions.checkNotNull(rd,
- LOGGING_PREFIX + " deleteSubnetRouteFromFib: RouteDistinguisher cannot be null or empty!");
- Preconditions.checkNotNull(subnetIp,
- LOGGING_PREFIX + " deleteSubnetRouteFromFib: SubnetRouteIp cannot be null or empty!");
+ requireNonNull(rd, LOGGING_PREFIX + " deleteSubnetRouteFromFib: RouteDistinguisher cannot be null or empty!");
+ requireNonNull(subnetIp, LOGGING_PREFIX + " deleteSubnetRouteFromFib: SubnetRouteIp cannot be null or empty!");
deleteSubnetRouteFibEntryFromDS(rd, subnetIp, vpnName);
if (isBgpVpn) {
try {
Uint64 dpnId, long lportTag,
String gwMac, String gwIp) {
return new VpnInterfaceOpDataEntryBuilder().withKey(new VpnInterfaceOpDataEntryKey(intfName, vpnName))
- .setDpnId(dpnId).addAugmentation(AdjacenciesOp.class, aug)
+ .setDpnId(dpnId).addAugmentation(aug)
.setLportTag(lportTag).setGatewayMacAddress(gwMac).setGatewayIpAddress(gwIp).build();
}
public List<VrfEntry> getAllVrfEntries(String rd) {
VrfTables vrfTables = getVrfTable(rd);
if (vrfTables != null && vrfTables.getVrfEntry() != null) {
- return new ArrayList<VrfEntry>(vrfTables.getVrfEntry().values());
+ return new ArrayList<>(vrfTables.getVrfEntry().values());
}
return emptyList();
}
return
vpnInstanceOpDataOptional.isPresent() && vpnInstanceOpDataOptional.get()
.getVpnInstanceOpDataEntry() != null
- ? new ArrayList<VpnInstanceOpDataEntry>(vpnInstanceOpDataOptional.get()
+ ? new ArrayList<>(vpnInstanceOpDataOptional.get()
.getVpnInstanceOpDataEntry().values()) : emptyList();
} catch (Exception e) {
LOG.error("getAllVpnInstanceOpData: Could not retrieve all vpn instance op data subtree...", e);
InstanceIdentifier<VpnToDpnList> dpnToVpnId = VpnHelper.getVpnToDpnListIdentifier(primaryRd, dpnId);
Optional<VpnToDpnList> dpnInVpn = read(LogicalDatastoreType.OPERATIONAL, dpnToVpnId);
return dpnInVpn.isPresent() && dpnInVpn.get().getVpnInterfaces() != null
- ? new ArrayList<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op
- .data.vpn.instance.op.data.entry.vpn.to.dpn.list.VpnInterfaces>(dpnInVpn.get()
+ ? new ArrayList<>(dpnInVpn.get()
.getVpnInterfaces().values())
: emptyList();
}
InstanceIdentifier<Adjacencies> path = identifier.augmentation(Adjacencies.class);
Optional<Adjacencies> adjacencies = read(LogicalDatastoreType.CONFIGURATION, path);
if (adjacencies.isPresent()) {
- return new ArrayList<Adjacency>(adjacencies.get().nonnullAdjacency().values());
+ return new ArrayList<>(adjacencies.get().nonnullAdjacency().values());
}
return null;
}
if (result == null || result.get() == null || !result.get().isSuccessful()) {
LOG.error("releaseId: RPC Call to release Id from pool {} with key {} returned with Errors {}",
poolName, idKey,
- (result != null && result.get() != null) ? result.get().getErrors() : "RpcResult is null");
+ result != null && result.get() != null ? result.get().getErrors() : "RpcResult is null");
} else {
return result.get().getResult().getIdValues().get(0).intValue();
}
public static String getVpnRd(TypedReadTransaction<Configuration> confTx, String vpnName) {
try {
return confTx.read(VpnOperDsUtils.getVpnInstanceToVpnIdIdentifier(vpnName)).get().map(
- vpnInstance -> vpnInstance.getVrfId()).orElse(null);
+ org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911
+ .vpn.instance.to.vpn.id.VpnInstance::getVrfId).orElse(null);
} catch (InterruptedException | ExecutionException e) {
throw new RuntimeException(e);
}
VpnInterface cfgVpnInterface = optConfiguredVpnInterface.get();
java.util.Optional<List<VpnInstanceNames>> optVpnInstanceList =
java.util.Optional.ofNullable(
- new ArrayList<VpnInstanceNames>(cfgVpnInterface.nonnullVpnInstanceNames().values()));
+ new ArrayList<>(cfgVpnInterface.nonnullVpnInstanceNames().values()));
if (optVpnInstanceList.isPresent()) {
List<String> vpnList = new ArrayList<>();
for (VpnInstanceNames vpnInstance : optVpnInstanceList.get()) {
}
static final FutureCallback<Void> DEFAULT_CALLBACK =
- new FutureCallback<Void>() {
+ new FutureCallback<>() {
@Override
public void onSuccess(Void result) {
LOG.debug("Success in Datastore operation");
elanInterfaceList = new ArrayList<>();
} else {
dpnInterface = dpnInElanInterfaces.get();
- elanInterfaceList = (dpnInterface.getInterfaces() != null && !dpnInterface.getInterfaces().isEmpty())
+ elanInterfaceList = dpnInterface.getInterfaces() != null && !dpnInterface.getInterfaces().isEmpty()
? new ArrayList<>(dpnInterface.getInterfaces()) : elanInterfaceList;
}
if (!elanInterfaceList.contains(routerInterfacePortId)) {
return;
} else {
dpnInterface = dpnInElanInterfaces.get();
- elanInterfaceList = (dpnInterface.getInterfaces() != null && !dpnInterface.getInterfaces().isEmpty())
+ elanInterfaceList = dpnInterface.getInterfaces() != null && !dpnInterface.getInterfaces().isEmpty()
? new ArrayList<>(dpnInterface.getInterfaces()) : elanInterfaceList;
}
if (!elanInterfaceList.contains(routerInterfacePortId)) {
if (subnetMapsData.isPresent()) {
List<Subnetmap> subnetMapList = new ArrayList<>();
Subnetmaps subnetMaps = subnetMapsData.get();
- subnetMapList = (subnetMaps.getSubnetmap() != null && !subnetMaps.getSubnetmap().isEmpty())
+ subnetMapList = subnetMaps.getSubnetmap() != null && !subnetMaps.getSubnetmap().isEmpty()
? new ArrayList<>(subnetMaps.getSubnetmap().values()) : subnetMapList;
if (subnetMapList != null && !subnetMapList.isEmpty()) {
*/
package org.opendaylight.netvirt.vpnmanager.intervpnlink;
+import static java.util.Objects.requireNonNull;
import static org.opendaylight.mdsal.binding.util.Datastore.CONFIGURATION;
-import com.google.common.base.Preconditions;
import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
}
private boolean checkVpnAvailability(InterVpnLinkKey key, String vpnName) {
- Preconditions.checkNotNull(vpnName);
+ requireNonNull(vpnName);
List<InterVpnLinkDataComposite> allInterVpnLinks = interVpnLinkCache.getAllInterVpnLinks();
if (allInterVpnLinks.isEmpty()) {
adjacencyList.add(newAdjBuilder.build());
Adjacencies aug = VpnUtil.getVpnInterfaceAugmentation(adjacencyList);
VpnInterface newVpnIntf = new VpnInterfaceBuilder(optVpnInterface.get())
- .addAugmentation(Adjacencies.class, aug).build();
+ .addAugmentation(aug).build();
SingleTransactionDataBroker.syncWrite(dataBroker, LogicalDatastoreType.CONFIGURATION, vpnIfId,
newVpnIntf, VpnUtil.SINGLE_TRANSACTION_BROKER_NO_RETRY);
LOG.debug(" Successfully stored subnetroute Adjacency into VpnInterface {}", vpnInterface);
*/
package org.opendaylight.netvirt.vpnmanager.populator.impl;
+import static java.util.Objects.requireNonNull;
import static org.opendaylight.infrautils.utils.concurrent.LoggingFutures.addErrorLogging;
import static org.opendaylight.mdsal.binding.util.Datastore.OPERATIONAL;
-import com.google.common.base.Preconditions;
import java.util.Collections;
import java.util.List;
import java.util.Optional;
SubnetRoute route = new SubnetRouteBuilder().setElantag(elantag).build();
RouteOrigin origin = RouteOrigin.CONNECTED; // Only case when a route is considered as directly connected
VrfEntry vrfEntry = FibHelper.getVrfEntryBuilder(prefix, label, nextHop, origin, networkName)
- .addAugmentation(SubnetRoute.class, route).setL3vni(l3vni).setGatewayMacAddress(gwMacAddress).build();
+ .addAugmentation(route).setL3vni(l3vni).setGatewayMacAddress(gwMacAddress).build();
LOG.debug("Created vrfEntry for {} nexthop {} label {} and elantag {}", prefix, nextHop, label, elantag);
InstanceIdentifier<VrfEntry> vrfEntryId =
InstanceIdentifier.builder(FibEntries.class)
List<VpnInstanceOpDataEntry> vpnsToImportRoute = vpnUtil.getVpnsImportingMyRoute(vpnName);
if (vpnsToImportRoute.size() > 0) {
VrfEntry importingVrfEntry = FibHelper.getVrfEntryBuilder(prefix, label, nextHop,
- RouteOrigin.SELF_IMPORTED, rd).addAugmentation(SubnetRoute.class, route).build();
+ RouteOrigin.SELF_IMPORTED, rd).addAugmentation(route).build();
List<VrfEntry> importingVrfEntryList = Collections.singletonList(importingVrfEntry);
for (VpnInstanceOpDataEntry vpnInstance : vpnsToImportRoute) {
String importingRd = vpnInstance.getVrfId();
public void addToLabelMapper(Uint32 label, Uint64 dpnId, String prefix, List<String> nextHopIpList, Uint32 vpnId,
@Nullable String vpnInterfaceName, @Nullable Uint32 elanTag,
boolean isSubnetRoute, String rd) {
- final String labelStr = Preconditions.checkNotNull(label, "addToLabelMapper: label cannot be null or empty!")
- .toString();
- Preconditions.checkNotNull(prefix, "addToLabelMapper: prefix cannot be null or empty!");
- Preconditions.checkNotNull(vpnId, "addToLabelMapper: vpnId cannot be null or empty!");
- Preconditions.checkNotNull(rd, "addToLabelMapper: rd cannot be null or empty!");
+ final String labelStr = requireNonNull(label, "addToLabelMapper: label cannot be null or empty!").toString();
+ requireNonNull(prefix, "addToLabelMapper: prefix cannot be null or empty!");
+ requireNonNull(vpnId, "addToLabelMapper: vpnId cannot be null or empty!");
+ requireNonNull(rd, "addToLabelMapper: rd cannot be null or empty!");
if (!isSubnetRoute) {
// NextHop must be present for non-subnetroute entries
- Preconditions.checkNotNull(nextHopIpList, "addToLabelMapper: nextHopIp cannot be null or empty!");
+ requireNonNull(nextHopIpList, "addToLabelMapper: nextHopIp cannot be null or empty!");
}
// FIXME: separate this out somehow?
InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.to.vpn.id
.VpnInstance> instVpnInstance = getVpnInstanceToVpnIdIdentifier(interfaceName);
InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.l3vpn.rev200204.vpn.instances
- .VpnInstance>
- vpnInstanceIdentifier = InstanceIdentifier.builder(VpnInstances.class).child(org.opendaylight.yang.gen.v1.urn
- .opendaylight.netvirt.neutronvpn.l3vpn.rev200204.vpn.instances.VpnInstance.class,
- new org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.l3vpn.rev200204.vpn.instances
- .VpnInstanceKey(interfaceName)).build();
+ .VpnInstance> vpnInstanceIdentifier = InstanceIdentifier.builder(VpnInstances.class)
+ .child(org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.l3vpn.rev200204.vpn.instances
+ .VpnInstance.class,
+ new org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.l3vpn.rev200204.vpn.instances
+ .VpnInstanceKey(interfaceName)).build();
InstanceIdentifier<Networks> netsIdentifier =
InstanceIdentifier.builder(ExternalNetworks.class).child(Networks.class, new NetworksKey(portId)).build();
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>7.0.6</version>
+ <version>8.1.0</version>
<relativePath/>
</parent>
Code Review / netvirt.git / commitdiff