import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
}
@Override
- public void connected(@Nonnull final OvsdbClient externalClient) {
+ public void connected(@NonNull final OvsdbClient externalClient) {
LOG.info("Library connected {} from {}:{} to {}:{}",
externalClient.getConnectionInfo().getType(),
externalClient.getConnectionInfo().getRemoteAddress(),
return globalRow;
}
- private Entity getEntityFromConnectionInstance(@Nonnull HwvtepConnectionInstance hwvtepConnectionInstance) {
+ private Entity getEntityFromConnectionInstance(@NonNull HwvtepConnectionInstance hwvtepConnectionInstance) {
InstanceIdentifier<Node> iid = hwvtepConnectionInstance.getInstanceIdentifier();
if (iid == null) {
//TODO: Is Global the right one?
Futures.addCallback(readNodeFuture, new FutureCallback<Optional<Node>>() {
@Override
- public void onSuccess(@Nonnull Optional<Node> node) {
+ public void onSuccess(@NonNull Optional<Node> node) {
if (node.isPresent()) {
HwvtepGlobalAugmentation augmentation = node.get()
.augmentation(HwvtepGlobalAugmentation.class);
import java.util.Objects;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
return Collections.emptyList();
}
- @Nonnull
+ @NonNull
protected Map<InstanceIdentifier<Node>, List<T>> extractRemoved(
Collection<DataTreeModification<Node>> modification, Class<T> class1) {
Map<InstanceIdentifier<Node>, List<T>> result = new HashMap<>();
return result;
}
- @Nonnull
+ @NonNull
protected Map<InstanceIdentifier<Node>, List<T>> extractUpdated(
Collection<DataTreeModification<Node>> modification, Class<T> class1) {
Map<InstanceIdentifier<Node>, List<T>> result = new HashMap<>();
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepConnectionInstance;
Futures.addCallback(transaction.read(LogicalDatastoreType.CONFIGURATION, tpPath),
new FutureCallback<Optional<TerminationPoint>>() {
@Override
- public void onSuccess(@Nonnull Optional<TerminationPoint> optionalConfigTp) {
+ public void onSuccess(@NonNull Optional<TerminationPoint> optionalConfigTp) {
if (!optionalConfigTp.isPresent() || optionalConfigTp.get().augmentation(
HwvtepPhysicalPortAugmentation.class) == null) {
//TODO port came with some vlan bindings clean them up use PortRemovedCommand
import java.util.List;
import java.util.Map;
import java.util.Set;
-import javax.annotation.Nonnull;
-import javax.annotation.Nullable;
+import org.eclipse.jdt.annotation.NonNull;
+import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepConnectionInstance;
return psIid.augmentation(PhysicalSwitchAugmentation.class).child(TunnelIps.class, tunnelIps.key());
}
- private void updateTunnelIps(@Nonnull final PhysicalSwitch newPSwitch, @Nullable final PhysicalSwitch oldPSwitch,
+ private void updateTunnelIps(@NonNull final PhysicalSwitch newPSwitch, @Nullable final PhysicalSwitch oldPSwitch,
final ReadWriteTransaction transaction) {
Set<String> oldTunnelIps = oldPSwitch != null && oldPSwitch.getTunnelIpsColumn() != null ? oldPSwitch
.getTunnelIpsColumn().getData() : Collections.emptySet();
import java.util.List;
import java.util.Properties;
import java.util.Set;
-import javax.annotation.Nullable;
import javax.inject.Inject;
+import org.eclipse.jdt.annotation.Nullable;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicBoolean;
-import javax.annotation.Nullable;
import javax.inject.Inject;
import javax.inject.Singleton;
import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLPeerUnverifiedException;
import org.apache.aries.blueprint.annotation.service.Reference;
import org.apache.aries.blueprint.annotation.service.Service;
+import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.aaa.cert.api.ICertificateManager;
import org.opendaylight.ovsdb.lib.OvsdbClient;
import org.opendaylight.ovsdb.lib.OvsdbConnection;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ExecutionException;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
import org.opendaylight.mdsal.eos.binding.api.Entity;
import org.opendaylight.mdsal.eos.binding.api.EntityOwnershipCandidateRegistration;
}
}
- public void setDeviceOwnershipCandidateRegistration(@Nonnull EntityOwnershipCandidateRegistration registration) {
+ public void setDeviceOwnershipCandidateRegistration(@NonNull EntityOwnershipCandidateRegistration registration) {
this.deviceOwnershipCandidateRegistration = registration;
}
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
}
@Override
- public void connected(@Nonnull final OvsdbClient externalClient) {
+ public void connected(@NonNull final OvsdbClient externalClient) {
LOG.info("Library connected {} from {}:{} to {}:{}",
externalClient.getConnectionInfo().getType(),
externalClient.getConnectionInfo().getRemoteAddress(),
return openVSwitchRow;
}
- private Entity getEntityFromConnectionInstance(@Nonnull OvsdbConnectionInstance ovsdbConnectionInstance) {
+ private Entity getEntityFromConnectionInstance(@NonNull OvsdbConnectionInstance ovsdbConnectionInstance) {
InstanceIdentifier<Node> iid = ovsdbConnectionInstance.getInstanceIdentifier();
if (iid == null) {
/* Switch initiated connection won't have iid, till it gets OpenVSwitch
}
Futures.addCallback(readNodeFuture, new FutureCallback<Optional<Node>>() {
@Override
- public void onSuccess(@Nonnull Optional<Node> node) {
+ public void onSuccess(@NonNull Optional<Node> node) {
if (node.isPresent()) {
LOG.info("Disconnected/Failed connection {} was controller initiated, attempting "
+ "reconnection", ovsdbNode.getConnectionInfo());
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.controller.md.sal.binding.api.ClusteredDataTreeChangeListener;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
}
@Override
- public void onDataTreeChanged(@Nonnull Collection<DataTreeModification<Node>> changes) {
+ public void onDataTreeChanged(@NonNull Collection<DataTreeModification<Node>> changes) {
LOG.trace("onDataTreeChanged: {}", changes);
// Connect first if necessary
LOG.trace("onDataTreeChanged: exit");
}
- private void connect(@Nonnull Collection<DataTreeModification<Node>> changes) {
+ private void connect(@NonNull Collection<DataTreeModification<Node>> changes) {
for (DataTreeModification<Node> change : changes) {
if (change.getRootNode().getModificationType() == DataObjectModification.ModificationType.WRITE || change
.getRootNode().getModificationType() == DataObjectModification.ModificationType.SUBTREE_MODIFIED) {
}
}
- private void disconnect(@Nonnull Collection<DataTreeModification<Node>> changes) {
+ private void disconnect(@NonNull Collection<DataTreeModification<Node>> changes) {
for (DataTreeModification<Node> change : changes) {
if (change.getRootNode().getModificationType() == DataObjectModification.ModificationType.DELETE) {
DataObjectModification<OvsdbNodeAugmentation> ovsdbNodeModification =
}
}
- private void updateConnections(@Nonnull Collection<DataTreeModification<Node>> changes) {
+ private void updateConnections(@NonNull Collection<DataTreeModification<Node>> changes) {
for (DataTreeModification<Node> change : changes) {
if (change.getRootNode().getModificationType() == DataObjectModification.ModificationType.WRITE || change
.getRootNode().getModificationType() == DataObjectModification.ModificationType.SUBTREE_MODIFIED) {
}
}
- private void updateData(@Nonnull Collection<DataTreeModification<Node>> changes) {
+ private void updateData(@NonNull Collection<DataTreeModification<Node>> changes) {
for (Entry<OvsdbConnectionInstance, Collection<DataTreeModification<Node>>> connectionInstanceEntry :
changesPerConnectionInstance(changes).entrySet()) {
OvsdbConnectionInstance connectionInstance = connectionInstanceEntry.getKey();
}
private Map<OvsdbConnectionInstance, Collection<DataTreeModification<Node>>> changesPerConnectionInstance(
- @Nonnull Collection<DataTreeModification<Node>> changes) {
+ @NonNull Collection<DataTreeModification<Node>> changes) {
Map<OvsdbConnectionInstance, Collection<DataTreeModification<Node>>> result = new HashMap<>();
for (DataTreeModification<Node> change : changes) {
OvsdbConnectionInstance client = null;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
import org.opendaylight.ovsdb.lib.notation.UUID;
import org.opendaylight.ovsdb.lib.operations.Insert;
bridge.setExternalIds(externalIdMap);
}
- private void setOpenDaylightOtherConfig(@Nonnull Bridge bridge, @Nonnull OvsdbBridgeAugmentation ovsdbManagedNode) {
+ private void setOpenDaylightOtherConfig(@NonNull Bridge bridge, @NonNull OvsdbBridgeAugmentation ovsdbManagedNode) {
try {
bridge.setOtherConfig(YangUtils.convertYangKeyValueListToMap(ovsdbManagedNode.getBridgeOtherConfigs(),
BridgeOtherConfigs::getBridgeOtherConfigKey, BridgeOtherConfigs::getBridgeOtherConfigValue));
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.TimeUnit;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.controller.md.sal.binding.api.ClusteredDataTreeChangeListener;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
*/
class BridgeCreatedDataTreeChangeListener implements ClusteredDataTreeChangeListener<Node> {
@Override
- public void onDataTreeChanged(@Nonnull Collection<DataTreeModification<Node>> changes) {
+ public void onDataTreeChanged(@NonNull Collection<DataTreeModification<Node>> changes) {
bridgeNodeCache.cleanUp();
if (!bridgeNodeCache.asMap().isEmpty()) {
Map<InstanceIdentifier<OvsdbBridgeAugmentation>, OvsdbBridgeAugmentation> nodes =
import java.util.List;
import java.util.Map;
import java.util.Set;
-import javax.annotation.Nullable;
+import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
import org.opendaylight.ovsdb.southbound.InstanceIdentifierCodec;
import java.util.List;
import java.util.Properties;
import java.util.Set;
-import javax.annotation.Nullable;
import javax.inject.Inject;
+import org.eclipse.jdt.annotation.Nullable;
import org.junit.After;
import org.junit.Assert;
import org.junit.Assume;
import java.util.HashMap;
import java.util.Map;
import java.util.function.Function;
-import javax.annotation.Nonnull;
-import javax.annotation.Nullable;
+import org.eclipse.jdt.annotation.NonNull;
+import org.eclipse.jdt.annotation.Nullable;
/**
* YANG utility functions.
* @param <V> The value type.
* @return The map.
*/
- @Nonnull
- public static <T, K, V> Map<K, V> copyYangKeyValueListToMap(@Nonnull Map<K, V> map, @Nullable Iterable<T> yangList,
- @Nonnull Function<T, K> keyExtractor,
- @Nonnull Function<T, V> valueExtractor) {
+ @NonNull
+ public static <T, K, V> Map<K, V> copyYangKeyValueListToMap(@NonNull Map<K, V> map, @Nullable Iterable<T> yangList,
+ @NonNull Function<T, K> keyExtractor,
+ @NonNull Function<T, V> valueExtractor) {
if (yangList != null) {
for (T yangValue : yangList) {
K key = keyExtractor.apply(yangValue);
* @param <V> The value type.
* @return The map.
*/
- @Nonnull
+ @NonNull
public static <T, K, V> Map<K, V> convertYangKeyValueListToMap(@Nullable Iterable<T> yangList,
- @Nonnull Function<T, K> keyExtractor,
- @Nonnull Function<T, V> valueExtractor) {
+ @NonNull Function<T, K> keyExtractor,
+ @NonNull Function<T, V> valueExtractor) {
return copyYangKeyValueListToMap(new HashMap<>(), yangList, keyExtractor, valueExtractor);
}
}