build failure. Please do not modify this unless you have a good reason. -->
<name>ODL :: ovsdb :: ${project.artifactId}</name>
- <properties>
- <!-- FIXME: Remove this -->
- <odlparent.modernizer.enforce>false</odlparent.modernizer.enforce>
- </properties>
-
<dependencies>
<dependency>
<groupId>org.osgi</groupId>
* 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.ovsdb.hwvtepsouthbound;
+import static java.util.Objects.requireNonNull;
import static org.opendaylight.ovsdb.lib.operations.Operations.op;
-import com.google.common.base.Preconditions;
import com.google.common.util.concurrent.FluentFuture;
import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.MoreExecutors;
}
public HwvtepConnectionInstance getConnectionInstance(final Node node) {
- Preconditions.checkNotNull(node);
+ requireNonNull(node);
HwvtepGlobalAugmentation hwvtepGlobal = node.augmentation(HwvtepGlobalAugmentation.class);
PhysicalSwitchAugmentation switchNode = node.augmentation(PhysicalSwitchAugmentation.class);
if (hwvtepGlobal != null) {
}
@SuppressWarnings("checkstyle:IllegalCatch")
- private void registerCallbacks(HwvtepConnectionInstance hwvtepConnectionInstance) {
+ private void registerCallbacks(final HwvtepConnectionInstance hwvtepConnectionInstance) {
LOG.info("HWVTEP entity {} is owned by this controller registering callbacks",
hwvtepConnectionInstance.getConnectionInfo());
try {
}
- private void registerEntityForOwnership(HwvtepConnectionInstance hwvtepConnectionInstance) {
+ private void registerEntityForOwnership(final HwvtepConnectionInstance hwvtepConnectionInstance) {
Entity candidateEntity = getEntityFromConnectionInstance(hwvtepConnectionInstance);
if (entityConnectionMap.get(candidateEntity) != null) {
}
private void retryConnection(final InstanceIdentifier<Node> iid, final HwvtepGlobalAugmentation hwvtepNode,
- ConnectionReconciliationTriggers trigger) {
+ final ConnectionReconciliationTriggers trigger) {
if (hwvtepNode == null) {
//switch initiated connection
return;
return Collections.unmodifiableMap(nodeIidVsConnectionInstance);
}
- public void cleanupOperationalNode(InstanceIdentifier<Node> nodeIid) {
+ public void cleanupOperationalNode(final InstanceIdentifier<Node> nodeIid) {
txInvoker.invoke(new HwvtepGlobalRemoveCommand(nodeIid));
}
}
* 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.ovsdb.hwvtepsouthbound;
-import com.google.common.base.Preconditions;
-import com.google.common.collect.ImmutableBiMap;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.net.InetAddresses;
import java.net.Inet4Address;
import java.net.Inet6Address;
.build();
}
-
public static Class<? extends EncapsulationTypeBase> createEncapsulationType(String type) {
- Preconditions.checkNotNull(type);
- if (type.isEmpty()) {
+ if (requireNonNull(type).isEmpty()) {
return EncapsulationTypeVxlanOverIpv4.class;
- } else {
- ImmutableBiMap<String, Class<? extends EncapsulationTypeBase>> mapper =
- HwvtepSouthboundConstants.ENCAPS_TYPE_MAP.inverse();
- return mapper.get(type);
}
+
+ return HwvtepSouthboundConstants.ENCAPS_TYPE_MAP.inverse().get(type);
}
public static TerminationPointKey getTerminationPointKey(PhysicalLocator physicalLocator) {
*/
package org.opendaylight.ovsdb.hwvtepsouthbound;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.util.concurrent.ThreadFactoryBuilder;
import java.util.Collection;
import java.util.Map;
public static Optional<HwvtepGlobalAugmentation> getManagingNode(DataBroker db,
HwvtepPhysicalSwitchAttributes node) {
- Preconditions.checkNotNull(node);
Optional<HwvtepGlobalAugmentation> result = null;
- HwvtepGlobalRef ref = node.getManagedBy();
+ HwvtepGlobalRef ref = requireNonNull(node).getManagedBy();
if (ref != null && ref.getValue() != null) {
result = getManagingNode(db, ref);
} else {
*/
package org.opendaylight.ovsdb.hwvtepsouthbound.reconciliation;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepConnectionManager;
import org.opendaylight.ovsdb.hwvtepsouthbound.reconciliation.connection.ConnectionReconciliationTask;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
/**
* Copied from org.opendaylight.ovsdb.southbound.reconciliation.ReconciliationTask
* Created by Anil Vishnoi (avishnoi@Brocade.com) on 3/9/16.
*/
public abstract class ReconciliationTask implements Runnable {
-
- private static final Logger LOG = LoggerFactory.getLogger(ReconciliationTask.class);
-
protected final ReconciliationManager reconciliationManager;
protected final HwvtepConnectionManager connectionManager;
protected final InstanceIdentifier<?> nodeIid;
protected ReconciliationTask(ReconciliationManager reconciliationManager, HwvtepConnectionManager connectionManager,
InstanceIdentifier<?> nodeIid,
DataObject configData) {
- Preconditions.checkNotNull(reconciliationManager, "Reconciliation manager must not be null");
- Preconditions.checkNotNull(connectionManager, "Connection manager must not be null");
- Preconditions.checkNotNull(nodeIid, "Node Iid must not be null");
- this.reconciliationManager = reconciliationManager;
- this.connectionManager = connectionManager;
- this.nodeIid = nodeIid;
+ this.reconciliationManager = requireNonNull(reconciliationManager, "Reconciliation manager must not be null");
+ this.connectionManager = requireNonNull(connectionManager, "Connection manager must not be null");
+ this.nodeIid = requireNonNull(nodeIid, "Node Iid must not be null");
this.configData = configData;
}
* 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.ovsdb.hwvtepsouthbound.transact;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
}
public Optional<HwvtepGlobalAugmentation> getHwvtepGlobalAugmentation(final InstanceIdentifier<?> iid) {
- Preconditions.checkNotNull(iid);
- Optional<Node> nodeOptional = getGlobalNode(iid);
+ Optional<Node> nodeOptional = getGlobalNode(requireNonNull(iid));
if (nodeOptional.isPresent()) {
return Optional.ofNullable(nodeOptional.get().augmentation(HwvtepGlobalAugmentation.class));
}
}
public Optional<PhysicalSwitchAugmentation> getPhysicalSwitchAugmentation(final InstanceIdentifier<?> iid) {
- Preconditions.checkNotNull(iid);
- Optional<Node> nodeOptional = getGlobalNode(iid);
+ Optional<Node> nodeOptional = getGlobalNode(requireNonNull(iid));
if (nodeOptional.isPresent()) {
return Optional.ofNullable(nodeOptional.get().augmentation(PhysicalSwitchAugmentation.class));
}
public Optional<Map<TerminationPointKey, TerminationPoint>> getTerminationPointList(
final InstanceIdentifier<?> iid) {
- Preconditions.checkNotNull(iid);
- Optional<Node> nodeOptional = getGlobalNode(iid);
+ Optional<Node> nodeOptional = getGlobalNode(requireNonNull(iid));
if (nodeOptional.isPresent() && nodeOptional.get().getTerminationPoint() != null) {
return Optional.ofNullable(nodeOptional.get().getTerminationPoint());
}
public Optional<LogicalSwitches> getLogicalSwitches(final InstanceIdentifier<?> iid,
final LogicalSwitchesKey logicalSwitchesKey) {
- Preconditions.checkNotNull(iid);
- Optional<HwvtepGlobalAugmentation> nodeOptional = getHwvtepGlobalAugmentation(iid);
+ Optional<HwvtepGlobalAugmentation> nodeOptional = getHwvtepGlobalAugmentation(requireNonNull(iid));
if (nodeOptional.isPresent()) {
LogicalSwitches lswitch = nodeOptional.get().nonnullLogicalSwitches().get(logicalSwitchesKey);
if (lswitch != null) {
}
public Optional<Tunnels> getTunnels(final InstanceIdentifier<?> iid, final TunnelsKey tunnelsKey) {
- Preconditions.checkNotNull(iid);
- Optional<PhysicalSwitchAugmentation> psOptional = getPhysicalSwitchAugmentation(iid);
+ Optional<PhysicalSwitchAugmentation> psOptional = getPhysicalSwitchAugmentation(requireNonNull(iid));
if (psOptional.isPresent()) {
Tunnels tunnel = psOptional.get().nonnullTunnels().get(tunnelsKey);
if (tunnel != null) {
public Optional<HwvtepPhysicalPortAugmentation> getPhysicalPortAugmentation(final InstanceIdentifier<?> iid,
final HwvtepNodeName hwvtepNodeName) {
- Preconditions.checkNotNull(iid);
- Optional<Map<TerminationPointKey, TerminationPoint>> nodeOptional = getTerminationPointList(iid);
+ Optional<Map<TerminationPointKey, TerminationPoint>> nodeOptional =
+ getTerminationPointList(requireNonNull(iid));
if (nodeOptional.isPresent()) {
for (TerminationPoint tp : nodeOptional.get().values()) {
HwvtepPhysicalPortAugmentation hppAugmentation =
public Optional<HwvtepPhysicalLocatorAugmentation> getPhysicalLocatorAugmentation(final InstanceIdentifier<?> iid,
final IpAddress dstIp, final Class<? extends EncapsulationTypeBase> encapType) {
- Preconditions.checkNotNull(iid);
- Optional<Map<TerminationPointKey, TerminationPoint>> nodeOptional = getTerminationPointList(iid);
+ Optional<Map<TerminationPointKey, TerminationPoint>> nodeOptional =
+ getTerminationPointList(requireNonNull(iid));
if (nodeOptional.isPresent()) {
for (TerminationPoint tp : nodeOptional.get().values()) {
HwvtepPhysicalLocatorAugmentation hppAugmentation =
}
public Optional<LocalMcastMacs> getLocalMcastMacs(final InstanceIdentifier<?> iid, final LocalMcastMacsKey key) {
- Preconditions.checkNotNull(iid);
- Optional<HwvtepGlobalAugmentation> nodeOptional = getHwvtepGlobalAugmentation(iid);
+ Optional<HwvtepGlobalAugmentation> nodeOptional = getHwvtepGlobalAugmentation(requireNonNull(iid));
if (nodeOptional.isPresent()) {
LocalMcastMacs mac = nodeOptional.get().nonnullLocalMcastMacs().get(key);
if (mac != null) {
}
public Optional<RemoteMcastMacs> getRemoteMcastMacs(final InstanceIdentifier<?> iid, final RemoteMcastMacsKey key) {
- Preconditions.checkNotNull(iid);
- Optional<HwvtepGlobalAugmentation> nodeOptional = getHwvtepGlobalAugmentation(iid);
+ Optional<HwvtepGlobalAugmentation> nodeOptional = getHwvtepGlobalAugmentation(requireNonNull(iid));
if (nodeOptional.isPresent()) {
RemoteMcastMacs mac = nodeOptional.get().nonnullRemoteMcastMacs().get(key);
if (mac != null) {
}
public Optional<LocalUcastMacs> getLocalUcastMacs(final InstanceIdentifier<?> iid, final LocalUcastMacsKey key) {
- Preconditions.checkNotNull(iid);
- Optional<HwvtepGlobalAugmentation> nodeOptional = getHwvtepGlobalAugmentation(iid);
+ Optional<HwvtepGlobalAugmentation> nodeOptional = getHwvtepGlobalAugmentation(requireNonNull(iid));
if (nodeOptional.isPresent()) {
LocalUcastMacs mac = nodeOptional.get().nonnullLocalUcastMacs().get(key);
if (mac != null) {
}
public Optional<RemoteUcastMacs> getRemoteUcastMacs(final InstanceIdentifier<?> iid, final RemoteUcastMacsKey key) {
- Preconditions.checkNotNull(iid);
- Optional<HwvtepGlobalAugmentation> nodeOptional = getHwvtepGlobalAugmentation(iid);
+ Optional<HwvtepGlobalAugmentation> nodeOptional = getHwvtepGlobalAugmentation(requireNonNull(iid));
if (nodeOptional.isPresent()) {
RemoteUcastMacs mac = nodeOptional.get().nonnullRemoteUcastMacs().get(key);
if (mac != null) {
public Optional<LogicalRouters> getLogicalRouters(final InstanceIdentifier<?> iid,
final LogicalRoutersKey logicalRoutersKey) {
- Preconditions.checkNotNull(iid);
- Optional<HwvtepGlobalAugmentation> nodeOptional = getHwvtepGlobalAugmentation(iid);
+ Optional<HwvtepGlobalAugmentation> nodeOptional = getHwvtepGlobalAugmentation(requireNonNull(iid));
if (nodeOptional.isPresent()) {
LogicalRouters lrouter = nodeOptional.get().nonnullLogicalRouters().get(logicalRoutersKey);
if (lrouter != null) {
*/
package org.opendaylight.ovsdb.hwvtepsouthbound.transactions.md;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.collect.Lists;
import java.util.ArrayList;
import java.util.Collections;
private List<InstanceIdentifier<PortFaultStatus>> getPortFaultStatusToRemove(
final InstanceIdentifier<TerminationPoint> tpPath, final PhysicalPort port) {
- Preconditions.checkNotNull(tpPath);
- Preconditions.checkNotNull(port);
+ requireNonNull(tpPath);
+ requireNonNull(port);
List<InstanceIdentifier<PortFaultStatus>> result = new ArrayList<>();
PhysicalPort oldPort = oldPPRows.get(port.getUuid());
if (oldPort != null && oldPort.getPortFaultStatusColumn() != null) {
*/
package org.opendaylight.ovsdb.hwvtepsouthbound.transactions.md;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.collect.Sets;
import java.util.ArrayList;
import java.util.Collections;
private List<InstanceIdentifier<SwitchFaultStatus>> getSwitchFaultStatusToRemove(InstanceIdentifier<Node> psIid,
PhysicalSwitch phySwitch) {
- Preconditions.checkNotNull(psIid);
- Preconditions.checkNotNull(phySwitch);
+ requireNonNull(psIid);
+ requireNonNull(phySwitch);
List<InstanceIdentifier<SwitchFaultStatus>> result = new ArrayList<>();
PhysicalSwitch oldSwitch = oldPSRows.get(phySwitch.getUuid());
if (oldSwitch != null && oldSwitch.getSwitchFaultStatusColumn() != null) {
* 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.ovsdb.hwvtepsouthbound.transactions.md;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import java.util.List;
import java.util.Map;
import java.util.Optional;
}
private void updateTunnel(ReadWriteTransaction transaction, Tunnel tunnel) {
- Preconditions.checkNotNull(tunnel.getLocalColumn().getData());
- Preconditions.checkNotNull(tunnel.getRemoteColumn().getData());
+ final UUID localData = requireNonNull(tunnel.getLocalColumn().getData());
+ final UUID remoteData = requireNonNull(tunnel.getRemoteColumn().getData());
final InstanceIdentifier<Node> connectionIId = getOvsdbConnectionInstance().getInstanceIdentifier();
//TODO remove these reads
Optional<Node> connection = HwvtepSouthboundUtil.readNode(transaction, connectionIId);
if (connection.isPresent() && tunnelIid != null) {
TunnelsBuilder builder = new TunnelsBuilder();
builder.setLocalLocatorRef(new HwvtepPhysicalLocatorRef(getPhysicalLocatorRefFromUUID(
- getOvsdbConnectionInstance().getInstanceIdentifier(), tunnel.getLocalColumn().getData())));
+ getOvsdbConnectionInstance().getInstanceIdentifier(), localData)));
builder.setRemoteLocatorRef(new HwvtepPhysicalLocatorRef(getPhysicalLocatorRefFromUUID(
- getOvsdbConnectionInstance().getInstanceIdentifier(), tunnel.getRemoteColumn().getData())));
+ getOvsdbConnectionInstance().getInstanceIdentifier(), remoteData)));
builder.setTunnelUuid(new Uuid(tunnel.getUuid().toString()));
setBfdLocalConfigs(builder, tunnel);
setBfdRemoteConfigs(builder, tunnel);