<parent>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>binding-parent</artifactId>
- <version>11.0.7</version>
+ <version>12.0.0</version>
<relativePath/>
</parent>
<dependency>
<groupId>org.opendaylight.aaa</groupId>
<artifactId>aaa-artifacts</artifactId>
- <version>0.17.7</version>
+ <version>0.18.0</version>
<type>pom</type>
<scope>import</scope>
</dependency>
<dependency>
<groupId>org.opendaylight.infrautils</groupId>
<artifactId>infrautils-artifacts</artifactId>
- <version>5.0.3</version>
+ <version>6.0.0</version>
<type>pom</type>
<scope>import</scope>
</dependency>
<parent>
<groupId>org.opendaylight.controller</groupId>
<artifactId>mdsal-it-parent</artifactId>
- <version>7.0.4</version>
+ <version>8.0.0</version>
<relativePath/>
</parent>
<dependency>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>mdsal-artifacts</artifactId>
- <version>11.0.7</version>
+ <version>12.0.0</version>
<type>pom</type>
<scope>import</scope>
</dependency>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>12.0.3</version>
+ <version>13.0.3</version>
<relativePath/>
</parent>
</dependency>
<dependency>
<groupId>org.opendaylight.mdsal.binding.model.ietf</groupId>
- <artifactId>rfc6991</artifactId>
+ <artifactId>rfc6991-ietf-inet-types</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.mdsal.binding.model.ietf</groupId>
+ <artifactId>rfc6991-ietf-yang-types</artifactId>
</dependency>
<dependency>
<groupId>org.opendaylight.mdsal.model</groupId>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>12.0.3</version>
+ <version>13.0.3</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>feature-repo-parent</artifactId>
- <version>12.0.3</version>
+ <version>13.0.3</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>single-feature-parent</artifactId>
- <version>12.0.3</version>
+ <version>13.0.3</version>
<relativePath/>
</parent>
<dependency>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>mdsal-artifacts</artifactId>
- <version>11.0.7</version>
+ <version>12.0.0</version>
<type>pom</type>
<scope>import</scope>
</dependency>
-->
<features name="odl-ovsdb-hwvtepsouthbound-api-${project.version}" xmlns="http://karaf.apache.org/xmlns/features/v1.2.0">
<feature name="odl-ovsdb-hwvtepsouthbound-api" version="${project.version}">
- <feature version="[11,12)">odl-mdsal-model-draft-clemm-netmod-yang-network-topo-01-minimal</feature>
- <feature version="[11,12)">odl-mdsal-model-odl-l2-types</feature>
+ <feature version="[12,13)">odl-mdsal-model-draft-clemm-netmod-yang-network-topo-01-minimal</feature>
+ <feature version="[12,13)">odl-mdsal-model-odl-l2-types</feature>
</feature>
</features>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>single-feature-parent</artifactId>
- <version>12.0.3</version>
+ <version>13.0.3</version>
<relativePath/>
</parent>
<dependency>
<groupId>org.opendaylight.netconf</groupId>
<artifactId>odl-restconf</artifactId>
- <version>5.0.4</version>
+ <version>6.0.0</version>
<type>xml</type>
<classifier>features</classifier>
</dependency>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>single-feature-parent</artifactId>
- <version>12.0.3</version>
+ <version>13.0.3</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>single-feature-parent</artifactId>
- <version>12.0.3</version>
+ <version>13.0.3</version>
<relativePath/>
</parent>
</dependency>
<dependency>
<groupId>org.opendaylight.netconf</groupId>
- <artifactId>odl-mdsal-apidocs</artifactId>
- <version>5.0.4</version>
+ <artifactId>odl-restconf-openapi</artifactId>
+ <version>6.0.0</version>
<type>xml</type>
<classifier>features</classifier>
</dependency>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>single-feature-parent</artifactId>
- <version>12.0.3</version>
+ <version>13.0.3</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>12.0.3</version>
+ <version>13.0.3</version>
<relativePath/>
</parent>
<groupId>org.opendaylight.ovsdb</groupId>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>mdsal-eos-binding-api</artifactId>
</dependency>
+ <dependency>
+ <groupId>com.github.spotbugs</groupId>
+ <artifactId>spotbugs-annotations</artifactId>
+ <optional>true</optional>
+ </dependency>
<dependency>
<groupId>com.guicedee.services</groupId>
<artifactId>javax.inject</artifactId>
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.RemoteMcastMacs;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.RemoteUcastMacs;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPoint;
-import org.opendaylight.yangtools.yang.binding.Identifiable;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.binding.KeyAware;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
private static final Logger LOG = LoggerFactory.getLogger(HwvtepDeviceInfo.class);
- private Map<Class<? extends Identifiable>, Map<InstanceIdentifier, Boolean>> availableInOperDs =
+ private Map<Class<? extends KeyAware>, Map<InstanceIdentifier, Boolean>> availableInOperDs =
new ConcurrentHashMap<>();
- public void markAvailableInOperDs(Class<? extends Identifiable> cls, InstanceIdentifier key) {
+ public void markAvailableInOperDs(Class<? extends KeyAware> cls, InstanceIdentifier key) {
availableInOperDs.putIfAbsent(cls, new ConcurrentHashMap<>());
availableInOperDs.get(cls).put(key, Boolean.TRUE);
}
- public Boolean isAvailableInOperDs(Class<? extends Identifiable> cls, InstanceIdentifier key) {
+ public Boolean isAvailableInOperDs(Class<? extends KeyAware> cls, InstanceIdentifier key) {
availableInOperDs.putIfAbsent(cls, new ConcurrentHashMap<>());
return availableInOperDs.get(cls).getOrDefault(key, Boolean.FALSE);
}
- public Boolean clearOperDsAvailability(Class<? extends Identifiable> cls, InstanceIdentifier key) {
+ public Boolean clearOperDsAvailability(Class<? extends KeyAware> cls, InstanceIdentifier key) {
availableInOperDs.putIfAbsent(cls, new ConcurrentHashMap<>());
return availableInOperDs.get(cls).remove(key);
}
private final HwvtepConnectionInstance connectionInstance;
private Map<InstanceIdentifier, AtomicInteger> iidInQueueCount = new ConcurrentHashMap<>();
- private Map<Class<? extends Identifiable>, Map<InstanceIdentifier, DeviceData>> configKeyVsData =
+ private Map<Class<? extends KeyAware>, Map<InstanceIdentifier, DeviceData>> configKeyVsData =
new ConcurrentHashMap<>();
- private final Map<Class<? extends Identifiable>, Map<InstanceIdentifier, DeviceData>> opKeyVsData =
+ private final Map<Class<? extends KeyAware>, Map<InstanceIdentifier, DeviceData>> opKeyVsData =
new ConcurrentHashMap<>();
- private final Map<Class<? extends Identifiable>, Map<UUID, DeviceData>> uuidVsData = new ConcurrentHashMap<>();
+ private final Map<Class<? extends KeyAware>, Map<UUID, DeviceData>> uuidVsData = new ConcurrentHashMap<>();
private final DependencyQueue dependencyQueue;
private TransactionHistory controllerTxHistory;
private TransactionHistory deviceUpdateHistory;
return mapTunnelToPhysicalSwitch;
}
- public boolean isKeyInTransit(Class<? extends Identifiable> cls, InstanceIdentifier key) {
+ public boolean isKeyInTransit(Class<? extends KeyAware> cls, InstanceIdentifier key) {
DeviceData deviceData = HwvtepSouthboundUtil.getData(opKeyVsData, cls, key);
return deviceData != null && DeviceDataStatus.IN_TRANSIT == deviceData.status;
}
- public boolean isConfigDataAvailable(Class<? extends Identifiable> cls, InstanceIdentifier key) {
+ public boolean isConfigDataAvailable(Class<? extends KeyAware> cls, InstanceIdentifier key) {
return HwvtepSouthboundUtil.getData(configKeyVsData, cls, key) != null;
}
- public void updateConfigData(Class<? extends Identifiable> cls, InstanceIdentifier key, Object data) {
+ public void updateConfigData(Class<? extends KeyAware> cls, InstanceIdentifier key, Object data) {
HwvtepSouthboundUtil.updateData(configKeyVsData, cls, key,
new DeviceData(key, null, data, DeviceDataStatus.AVAILABLE));
}
- public DeviceData getConfigData(Class<? extends Identifiable> cls, InstanceIdentifier key) {
+ public DeviceData getConfigData(Class<? extends KeyAware> cls, InstanceIdentifier key) {
return HwvtepSouthboundUtil.getData(configKeyVsData, cls, key);
}
- public Map<Class<? extends Identifiable>, Map<InstanceIdentifier, DeviceData>> getConfigData() {
+ public Map<Class<? extends KeyAware>, Map<InstanceIdentifier, DeviceData>> getConfigData() {
return Collections.unmodifiableMap(configKeyVsData);
}
- public void clearConfigData(Class<? extends Identifiable> cls, InstanceIdentifier key) {
+ public void clearConfigData(Class<? extends KeyAware> cls, InstanceIdentifier key) {
HwvtepSouthboundUtil.clearData(configKeyVsData, cls, key);
}
- public void markKeyAsInTransit(Class<? extends Identifiable> cls, InstanceIdentifier key) {
+ public void markKeyAsInTransit(Class<? extends KeyAware> cls, InstanceIdentifier key) {
LOG.debug("Marking device data as intransit {}", key);
DeviceData deviceData = getDeviceOperData(cls, key);
UUID uuid = null;
new DeviceData(key, uuid, data, DeviceDataStatus.IN_TRANSIT));
}
- public void updateDeviceOperData(Class<? extends Identifiable> cls, InstanceIdentifier key,
+ public void updateDeviceOperData(Class<? extends KeyAware> cls, InstanceIdentifier key,
UUID uuid, Object data) {
LOG.debug("Updating device data {}", key);
DeviceData deviceData = new DeviceData(key, uuid, data, DeviceDataStatus.AVAILABLE);
HwvtepSouthboundUtil.updateData(uuidVsData, cls, uuid, deviceData);
}
- public void clearDeviceOperData(Class<? extends Identifiable> cls, InstanceIdentifier key) {
+ public void clearDeviceOperData(Class<? extends KeyAware> cls, InstanceIdentifier key) {
DeviceData deviceData = HwvtepSouthboundUtil.getData(opKeyVsData, cls, key);
if (deviceData != null && deviceData.uuid != null) {
HwvtepSouthboundUtil.clearData(uuidVsData, cls, deviceData.uuid);
HwvtepSouthboundUtil.clearData(opKeyVsData, cls, key);
}
- public void clearDeviceOperData(Class<? extends Identifiable> cls) {
+ public void clearDeviceOperData(Class<? extends KeyAware> cls) {
Map<InstanceIdentifier, DeviceData> iids = opKeyVsData.get(cls);
if (iids != null && !iids.isEmpty()) {
Iterator<Map.Entry<InstanceIdentifier, DeviceData>> it = iids.entrySet().iterator();
}
}
- public void clearDeviceOperUUID(Class<? extends Identifiable> cls, InstanceIdentifier key, UUID uuid) {
+ public void clearDeviceOperUUID(Class<? extends KeyAware> cls, InstanceIdentifier key, UUID uuid) {
LOG.debug("Clearing device data {}", key);
if (uuidVsData.containsKey(cls) && uuidVsData.get(cls).containsKey(uuid)) {
LOG.debug("Remove {} {} from device data.", connectionInstance.getNodeId().getValue(), cls.getSimpleName());
HwvtepSouthboundUtil.clearData(opKeyVsData, cls, key);
}
- public DeviceData getDeviceOperData(Class<? extends Identifiable> cls, UUID uuid) {
+ public DeviceData getDeviceOperData(Class<? extends KeyAware> cls, UUID uuid) {
return HwvtepSouthboundUtil.getData(uuidVsData, cls, uuid);
}
- public DeviceData getDeviceOperData(Class<? extends Identifiable> cls, InstanceIdentifier key) {
+ public DeviceData getDeviceOperData(Class<? extends KeyAware> cls, InstanceIdentifier key) {
return HwvtepSouthboundUtil.getData(opKeyVsData, cls, key);
}
- public Map<InstanceIdentifier, DeviceData> getDeviceOperData(Class<? extends Identifiable> cls) {
+ public Map<InstanceIdentifier, DeviceData> getDeviceOperData(Class<? extends KeyAware> cls) {
return opKeyVsData.get(cls);
}
- public InstanceIdentifier getDeviceOperKey(final Class<? extends Identifiable> cls, final UUID uuid) {
+ public InstanceIdentifier getDeviceOperKey(final Class<? extends KeyAware> cls, final UUID uuid) {
DeviceData deviceData = HwvtepSouthboundUtil.getData(uuidVsData, cls, uuid);
if (deviceData != null) {
return deviceData.getKey();
return null;
}
- public UUID getUUID(Class<? extends Identifiable> cls, InstanceIdentifier key) {
+ public UUID getUUID(Class<? extends KeyAware> cls, InstanceIdentifier key) {
DeviceData data = HwvtepSouthboundUtil.getData(opKeyVsData, cls, key);
if (data != null) {
return data.uuid;
return null;
}
- public <T extends Identifiable> void addJobToQueue(DependentJob<T> job) {
+ public <T extends KeyAware> void addJobToQueue(DependentJob<T> job) {
dependencyQueue.addToQueue(job);
}
dependencyQueue.submit(() -> connectionInstance.transact(transactCommand));
}
- public void clearInTransit(Class<? extends Identifiable> cls, InstanceIdentifier key) {
+ public void clearInTransit(Class<? extends KeyAware> cls, InstanceIdentifier key) {
DeviceData deviceData = getDeviceOperData(cls, key);
if (deviceData != null && deviceData.isInTransitState()) {
if (deviceData.getData() != null) {
return connectionInstance;
}
- public void setConfigKeyVsData(Map<Class<? extends Identifiable>, Map<InstanceIdentifier,
+ public void setConfigKeyVsData(Map<Class<? extends KeyAware>, Map<InstanceIdentifier,
DeviceData>> configKeyVsData) {
this.configKeyVsData = configKeyVsData;
}
deviceUpdateHistory.addToHistory(transactionType, object);
}
- public Map<Class<? extends Identifiable>, Map<InstanceIdentifier, DeviceData>> getOperData() {
+ public Map<Class<? extends KeyAware>, Map<InstanceIdentifier, DeviceData>> getOperData() {
return Collections.unmodifiableMap(opKeyVsData);
}
- public Map<Class<? extends Identifiable>, Map<UUID, DeviceData>> getUuidData() {
+ public Map<Class<? extends KeyAware>, Map<UUID, DeviceData>> getUuidData() {
return Collections.unmodifiableMap(uuidVsData);
}
}
public static IpAddress createIpAddress(final Inet4Address address) {
- return IetfInetUtil.INSTANCE.ipAddressFor(address);
+ return IetfInetUtil.ipAddressFor(address);
}
public static IpAddress createIpAddress(final Inet6Address address) {
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeKey;
import org.opendaylight.yangtools.yang.binding.DataObject;
-import org.opendaylight.yangtools.yang.binding.Identifiable;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.binding.KeyAware;
import org.opendaylight.yangtools.yang.data.impl.codec.DeserializationException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
LOG.debug(SCHEMA_VERSION_MISMATCH, column, table, "hw_vtep", ex.getMessage());
}
- public static <K, D> void updateData(Map<Class<? extends Identifiable>, Map<K, D>> map,
- Class<? extends Identifiable> cls, K key, D data) {
+ public static <K, D> void updateData(Map<Class<? extends KeyAware>, Map<K, D>> map,
+ Class<? extends KeyAware> cls, K key, D data) {
LOG.debug("Updating data {} {} {}", cls, key, data);
if (key == null) {
return;
map.get(cls).put(key, data);
}
- public static <K, D> D getData(Map<Class<? extends Identifiable>, Map<K, D>> map,
- Class<? extends Identifiable> cls, K key) {
+ public static <K, D> D getData(Map<Class<? extends KeyAware>, Map<K, D>> map,
+ Class<? extends KeyAware> cls, K key) {
if (key == null) {
return null;
}
return null;
}
- public static <K, D> boolean containsKey(Map<Class<? extends Identifiable>, Map<K, D>> map,
- Class<? extends Identifiable> cls, K key) {
+ public static <K, D> boolean containsKey(Map<Class<? extends KeyAware>, Map<K, D>> map,
+ Class<? extends KeyAware> cls, K key) {
if (key == null) {
return false;
}
return false;
}
- public static <K, D> void clearData(Map<Class<? extends Identifiable>, Map<K, D>> map,
- Class<? extends Identifiable> cls, K key) {
+ public static <K, D> void clearData(Map<Class<? extends KeyAware>, Map<K, D>> map,
+ Class<? extends KeyAware> cls, K key) {
LOG.debug("Clearing data {} {}", cls, key);
if (key == null) {
return;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPoint;
import org.opendaylight.yangtools.yang.binding.DataObject;
-import org.opendaylight.yangtools.yang.binding.Identifiable;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.binding.KeyAware;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
TerminationPoint.class, PhysicalLocator.class,
VlanBindings.class, PhysicalPort.class);
- private final ImmutableMap<Class<? extends Identifiable<?>>, WhereClauseGetter<?>> whereClauseGetters;
+ private final ImmutableMap<Class<? extends KeyAware<?>>, WhereClauseGetter<?>> whereClauseGetters;
private final ImmutableClassToInstanceMap<TypedBaseTable<?>> tables;
private final HwvtepConnectionInstance connectionInstance;
}
final Builder<TypedBaseTable<?>> tableBuilder = ImmutableClassToInstanceMap.<TypedBaseTable<?>>builder();
- final ImmutableMap.Builder<Class<? extends Identifiable<?>>, WhereClauseGetter<?>> whereBuilder =
+ final ImmutableMap.Builder<Class<? extends KeyAware<?>>, WhereClauseGetter<?>> whereBuilder =
ImmutableMap.builderWithExpectedSize(4);
if (dbSchema != null) {
}
@SuppressWarnings("checkstyle:IllegalCatch")
- public Optional<TypedBaseTable> getHwvtepTableEntryUUID(final Class<? extends Identifiable> cls,
+ public Optional<TypedBaseTable> getHwvtepTableEntryUUID(final Class<? extends KeyAware> cls,
final InstanceIdentifier iid,
final UUID existingUUID) {
final TypedDatabaseSchema dbSchema;
}
@SuppressWarnings("checkstyle:IllegalCatch")
- public List<TypedBaseTable> getHwvtepTableEntries(final Class<? extends Identifiable> cls) {
+ public List<TypedBaseTable> getHwvtepTableEntries(final Class<? extends KeyAware> cls) {
final TypedDatabaseSchema dbSchema;
try {
dbSchema = connectionInstance.getSchema(HwvtepSchemaConstants.HARDWARE_VTEP).get();
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeKey;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPoint;
-import org.opendaylight.yangtools.yang.binding.Identifiable;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.binding.KeyAware;
@Service
@Command(scope = "hwvtep", name = "cache", description = "Disply hwvtep cache")
}
- private static void printEntry(PrintStream console, Map.Entry<Class<? extends Identifiable>,
+ private static void printEntry(PrintStream console, Map.Entry<Class<? extends KeyAware>,
Map<InstanceIdentifier, HwvtepDeviceInfo.DeviceData>> entry) {
- Class<? extends Identifiable> cls = entry.getKey();
+ Class<? extends KeyAware> cls = entry.getKey();
Map<InstanceIdentifier, HwvtepDeviceInfo.DeviceData> map = entry.getValue();
String clsName = cls.getSimpleName();
console.println(clsName + " - ");
console.println(deviceData.getUuid());
}
- private static void printEntryUUID(PrintStream console, Map.Entry<Class<? extends Identifiable>, Map<UUID,
+ private static void printEntryUUID(PrintStream console, Map.Entry<Class<? extends KeyAware>, Map<UUID,
HwvtepDeviceInfo.DeviceData>> entry) {
- Class<? extends Identifiable> cls = entry.getKey();
+ Class<? extends KeyAware> cls = entry.getKey();
Map<UUID, HwvtepDeviceInfo.DeviceData> map = entry.getValue();
String clsName = cls.getSimpleName();
console.println(clsName + " - ");
import org.opendaylight.yangtools.yang.binding.ChildOf;
import org.opendaylight.yangtools.yang.binding.ChoiceIn;
import org.opendaylight.yangtools.yang.binding.DataObject;
-import org.opendaylight.yangtools.yang.binding.Identifiable;
-import org.opendaylight.yangtools.yang.binding.Identifier;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.binding.Key;
+import org.opendaylight.yangtools.yang.binding.KeyAware;
public class DataObjectModificationImpl<T extends DataObject> implements DataObjectModification<T> {
@Override
@SuppressWarnings("unchecked")
- public <C extends Identifiable<K> & ChildOf<? super T>, K extends Identifier<C>> DataObjectModification<C>
+ public <C extends KeyAware<K> & ChildOf<? super T>, K extends Key<C>> DataObjectModification<C>
getModifiedChildListItem(final Class<C> listItem, final K listKey) {
return (DataObjectModification<C>) getModifiedChild(InstanceIdentifier.IdentifiableItem.of(listItem, listKey));
}
@Override
- public <H extends ChoiceIn<? super T> & DataObject, C extends Identifiable<K> & ChildOf<? super H>,
- K extends Identifier<C>> DataObjectModification<C> getModifiedChildListItem(Class<H> caseType,
+ public <H extends ChoiceIn<? super T> & DataObject, C extends KeyAware<K> & ChildOf<? super H>,
+ K extends Key<C>> DataObjectModification<C> getModifiedChildListItem(Class<H> caseType,
Class<C> listItem, K listKey) {
return null;
}
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPoint;
import org.opendaylight.yangtools.yang.binding.Augmentation;
import org.opendaylight.yangtools.yang.binding.DataObject;
-import org.opendaylight.yangtools.yang.binding.Identifiable;
-import org.opendaylight.yangtools.yang.binding.Identifier;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.binding.Key;
+import org.opendaylight.yangtools.yang.binding.KeyAware;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-public abstract class AbstractTransactCommand<T extends Identifiable<I> & DataObject, I extends Identifier<T>,
+public abstract class AbstractTransactCommand<T extends KeyAware<I> & DataObject, I extends Key<T>,
A extends Augmentation<Node>> implements TransactCommand<T> {
private static final Logger LOG = LoggerFactory.getLogger(AbstractTransactCommand.class);
return changes;
}
- void updateCurrentTxDeleteData(final Class<? extends Identifiable> cls, final InstanceIdentifier key,
+ void updateCurrentTxDeleteData(final Class<? extends KeyAware> cls, final InstanceIdentifier key,
final T data) {
hwvtepOperationalState.updateCurrentTxDeleteData(cls, key);
markKeyAsInTransit(cls, key);
addToUpdates(key, data);
}
- void updateCurrentTxData(final Class<? extends Identifiable> cls, final InstanceIdentifier key, final UUID uuid,
+ void updateCurrentTxData(final Class<? extends KeyAware> cls, final InstanceIdentifier key, final UUID uuid,
final T data) {
hwvtepOperationalState.updateCurrentTxData(cls, key, uuid);
markKeyAsInTransit(cls, key);
T oldData = null;
Type type = getClass().getGenericSuperclass();
Type classType = ((ParameterizedType) type).getActualTypeArguments()[0];
- if (getConfigData((Class<? extends Identifiable>) classType, key) != null) {
- oldData = (T) getConfigData((Class<? extends Identifiable>) classType, key).getData();
+ if (getConfigData((Class<? extends KeyAware>) classType, key) != null) {
+ oldData = (T) getConfigData((Class<? extends KeyAware>) classType, key).getData();
}
updates.add(new MdsalUpdate<>(key, data, oldData));
}
Map confingDependencies = Collections.emptyMap();
if (isDeleteCmd()) {
- if (deviceInfo.isKeyInTransit((Class<? extends Identifiable>) classType, key)) {
+ if (deviceInfo.isKeyInTransit((Class<? extends KeyAware>) classType, key)) {
inTransitDependencies = new HashMap<>();
inTransitDependencies.put(classType, Lists.newArrayList(key));
}
confingDependencies.remove(TerminationPoint.class);
//If this key itself is in transit wait for the response of this key itself
- if (deviceInfo.isKeyInTransit((Class<? extends Identifiable>) classType, key)
+ if (deviceInfo.isKeyInTransit((Class<? extends KeyAware>) classType, key)
|| deviceInfo.isKeyInDependencyQueue(key)) {
inTransitDependencies.put(classType, Lists.newArrayList(key));
}
&& HwvtepSouthboundUtil.isEmptyMap(inTransitDependencies)) {
doDeviceTransaction(transaction, nodeIid, data, key, extraData);
if (isDeleteCmd()) {
- getDeviceInfo().clearConfigData((Class<? extends Identifiable>) classType, key);
+ getDeviceInfo().clearConfigData((Class<? extends KeyAware>) classType, key);
} else {
- getDeviceInfo().updateConfigData((Class<? extends Identifiable>) classType, key, data);
+ getDeviceInfo().updateConfigData((Class<? extends KeyAware>) classType, key, data);
}
}
final TransactionBuilder transactionBuilder) {
clone.hwvtepOperationalState = operationalState;
HwvtepDeviceInfo.DeviceData deviceData =
- getDeviceInfo().getConfigData((Class<? extends Identifiable>)getClassType(), key);
+ getDeviceInfo().getConfigData((Class<? extends KeyAware>)getClassType(), key);
T latest = data;
if (deviceData != null && deviceData.getData() != null) {
latest = (T) deviceData.getData();
final TransactionBuilder transactionBuilder) {
clone.hwvtepOperationalState = operationalState;
HwvtepDeviceInfo.DeviceData deviceData = getDeviceInfo()
- .getConfigData((Class<? extends Identifiable>)getClassType(), key);
+ .getConfigData((Class<? extends KeyAware>)getClassType(), key);
T latest = data;
if (deviceData != null && deviceData.getData() != null) {
latest = (T) deviceData.getData();
if (!Objects.equals(hwvtepOperationalState.getConnectionInstance().getInstanceIdentifier(), key)) {
continue;
}
- Class<? extends Identifiable> classType = (Class<? extends Identifiable>) getClassType();
+ Class<? extends KeyAware> classType = (Class<? extends KeyAware>) getClassType();
List<T> removed;
if (getOperationalState().isInReconciliation()) {
removed = getRemoved(change);
if (!Objects.equals(hwvtepOperationalState.getConnectionInstance().getInstanceIdentifier(), key)) {
continue;
}
- Class<? extends Identifiable> classType = (Class<? extends Identifiable>) getClassType();
+ Class<? extends KeyAware> classType = (Class<? extends KeyAware>) getClassType();
List<T> updated = null;
if (getOperationalState().isInReconciliation()) {
updated = getUpdated(change);
return HwvtepSouthboundUtil.isEmpty(list1) ? Collections.emptyList() : list1;
}
- Map<Object, T> map1 = list1.stream().collect(Collectors.toMap(Identifiable::key, ele -> ele));
- Map<Object, T> map2 = list2.stream().collect(Collectors.toMap(Identifiable::key, ele -> ele));
+ Map<Object, T> map1 = list1.stream().collect(Collectors.toMap(KeyAware::key, ele -> ele));
+ Map<Object, T> map2 = list2.stream().collect(Collectors.toMap(KeyAware::key, ele -> ele));
map1.entrySet().forEach(entry1 -> {
T val2 = map2.remove(entry1.getKey());
if (compareKeyOnly) {
getOperationalState().getDeviceInfo().addToControllerTx(transactionType, element);
}
- public <T> HwvtepDeviceInfo.DeviceData fetchDeviceData(final Class<? extends Identifiable> cls,
+ public <T> HwvtepDeviceInfo.DeviceData fetchDeviceData(final Class<? extends KeyAware> cls,
final InstanceIdentifier key) {
HwvtepDeviceInfo.DeviceData deviceData = getDeviceOpData(cls, key);
if (deviceData == null) {
return deviceData;
}
- public <K extends Identifiable> void addJobToQueue(final DependentJob<K> job) {
+ public <K extends KeyAware> void addJobToQueue(final DependentJob<K> job) {
hwvtepOperationalState.getDeviceInfo().putKeyInDependencyQueue(job.getKey());
hwvtepOperationalState.getDeviceInfo().addJobToQueue(job);
}
- public void markKeyAsInTransit(final Class<? extends Identifiable> cls, final InstanceIdentifier key) {
+ public void markKeyAsInTransit(final Class<? extends KeyAware> cls, final InstanceIdentifier key) {
hwvtepOperationalState.getDeviceInfo().markKeyAsInTransit(cls, key);
}
- public HwvtepDeviceInfo.DeviceData getDeviceOpData(final Class<? extends Identifiable> cls,
+ public HwvtepDeviceInfo.DeviceData getDeviceOpData(final Class<? extends KeyAware> cls,
final InstanceIdentifier key) {
return getOperationalState().getDeviceInfo().getDeviceOperData(cls, key);
}
- public void clearConfigData(final Class<? extends Identifiable> cls, final InstanceIdentifier key) {
+ public void clearConfigData(final Class<? extends KeyAware> cls, final InstanceIdentifier key) {
hwvtepOperationalState.getDeviceInfo().clearConfigData(cls, key);
}
- public HwvtepDeviceInfo.DeviceData getConfigData(final Class<? extends Identifiable> cls,
+ public HwvtepDeviceInfo.DeviceData getConfigData(final Class<? extends KeyAware> cls,
final InstanceIdentifier key) {
return hwvtepOperationalState.getDeviceInfo().getConfigData(cls, key);
}
- public void updateConfigData(final Class<? extends Identifiable> cls, final InstanceIdentifier key,
+ public void updateConfigData(final Class<? extends KeyAware> cls, final InstanceIdentifier key,
final Object data) {
hwvtepOperationalState.getDeviceInfo().updateConfigData(cls, key, data);
}
* 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 java.util.List;
import org.opendaylight.ovsdb.lib.operations.TransactionBuilder;
import org.opendaylight.ovsdb.lib.schema.typed.TypedBaseTable;
import org.opendaylight.yangtools.yang.binding.DataObject;
-import org.opendaylight.yangtools.yang.binding.Identifiable;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.binding.KeyAware;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-public abstract class DependentJob<T extends Identifiable> {
+public abstract class DependentJob<T extends KeyAware> {
private static final Logger LOG = LoggerFactory.getLogger(DependentJob.class);
public void onSuccess() {
}
- public abstract static class ConfigWaitingJob<T extends Identifiable> extends DependentJob<T> {
+ public abstract static class ConfigWaitingJob<T extends KeyAware> extends DependentJob<T> {
public ConfigWaitingJob(InstanceIdentifier key, T data,
Map<Class<? extends DataObject>, List<InstanceIdentifier>> dependencies) {
}
}
- public abstract static class OpWaitingJob<T extends Identifiable> extends DependentJob<T> {
+ public abstract static class OpWaitingJob<T extends KeyAware> extends DependentJob<T> {
public OpWaitingJob(InstanceIdentifier key, T data,
Map<Class<? extends DataObject>, List<InstanceIdentifier>> dependencies,
import java.util.Collections;
import java.util.List;
-import org.opendaylight.yangtools.yang.binding.Identifiable;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.binding.KeyAware;
public final class EmptyDependencyGetter extends UnMetDependencyGetter {
}
@Override
- public List<InstanceIdentifier<?>> getLogicalSwitchDependencies(Identifiable data) {
+ public List<InstanceIdentifier<?>> getLogicalSwitchDependencies(KeyAware data) {
return Collections.emptyList();
}
@Override
- public List<InstanceIdentifier<?>> getTerminationPointDependencies(Identifiable data) {
+ public List<InstanceIdentifier<?>> getTerminationPointDependencies(KeyAware data) {
return Collections.emptyList();
}
}
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPoint;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPointKey;
-import org.opendaylight.yangtools.yang.binding.Identifiable;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.binding.KeyAware;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
HashMap<InstanceIdentifier<TerminationPoint>, UUID> inflightLocators = new HashMap<>();
private final HwvtepDeviceInfo deviceInfo;
private final HwvtepConnectionInstance connectionInstance;
- private final Map<Class<? extends Identifiable>, Map<InstanceIdentifier, UUID>> currentTxUUIDs =
+ private final Map<Class<? extends KeyAware>, Map<InstanceIdentifier, UUID>> currentTxUUIDs =
new ConcurrentHashMap<>();
- private final Map<Class<? extends Identifiable>, Map<InstanceIdentifier, Boolean>> currentTxDeletedKeys =
+ private final Map<Class<? extends KeyAware>, Map<InstanceIdentifier, Boolean>> currentTxDeletedKeys =
new ConcurrentHashMap<>();
/* stores the modified and deleted data for each child type of each node id
child type is the child of hwvtep Global augmentation
*/
private Map<InstanceIdentifier<Node>,
- Pair<Map<Class<? extends Identifiable>, List<Identifiable>>,
- Map<Class<? extends Identifiable>, List<Identifiable>>>> modifiedData = new HashMap<>();
+ Pair<Map<Class<? extends KeyAware>, List<KeyAware>>,
+ Map<Class<? extends KeyAware>, List<KeyAware>>>> modifiedData = new HashMap<>();
private boolean inReconciliation = false;
private final DataBroker db;
private final Collection<DataTreeModification<Node>> changes;
return deviceInfo;
}
- public void updateCurrentTxData(final Class<? extends Identifiable> cls, final InstanceIdentifier key,
+ public void updateCurrentTxData(final Class<? extends KeyAware> cls, final InstanceIdentifier key,
final UUID uuid) {
HwvtepSouthboundUtil.updateData(currentTxUUIDs, cls, key, uuid);
}
- public void updateCurrentTxDeleteData(final Class<? extends Identifiable> cls, final InstanceIdentifier key) {
+ public void updateCurrentTxDeleteData(final Class<? extends KeyAware> cls, final InstanceIdentifier key) {
HwvtepSouthboundUtil.updateData(currentTxDeletedKeys, cls, key, Boolean.TRUE);
}
- public UUID getUUIDFromCurrentTx(final Class<? extends Identifiable> cls, final InstanceIdentifier key) {
+ public UUID getUUIDFromCurrentTx(final Class<? extends KeyAware> cls, final InstanceIdentifier key) {
return HwvtepSouthboundUtil.getData(currentTxUUIDs, cls, key);
}
- public boolean isKeyPartOfCurrentTx(final Class<? extends Identifiable> cls, final InstanceIdentifier key) {
+ public boolean isKeyPartOfCurrentTx(final Class<? extends KeyAware> cls, final InstanceIdentifier key) {
return HwvtepSouthboundUtil.containsKey(currentTxUUIDs, cls, key);
}
- public Set<InstanceIdentifier> getDeletedKeysInCurrentTx(final Class<? extends Identifiable> cls) {
+ public Set<InstanceIdentifier> getDeletedKeysInCurrentTx(final Class<? extends KeyAware> cls) {
if (currentTxDeletedKeys.containsKey(cls)) {
return currentTxDeletedKeys.get(cls).keySet();
}
return Collections.emptySet();
}
- public List<? extends Identifiable> getUpdatedData(final InstanceIdentifier<Node> key,
- final Class<? extends Identifiable> cls) {
- List<Identifiable> result = null;
+ public List<? extends KeyAware> getUpdatedData(final InstanceIdentifier<Node> key,
+ final Class<? extends KeyAware> cls) {
+ List<KeyAware> result = null;
if (modifiedData.get(key) != null && modifiedData.get(key).getLeft() != null) {
result = modifiedData.get(key).getLeft().get(cls);
}
return result;
}
- public List<? extends Identifiable> getDeletedData(final InstanceIdentifier<Node> key,
- final Class<? extends Identifiable> cls) {
- List<Identifiable> result = null;
+ public List<? extends KeyAware> getDeletedData(final InstanceIdentifier<Node> key,
+ final Class<? extends KeyAware> cls) {
+ List<KeyAware> result = null;
if (modifiedData.get(key) != null && modifiedData.get(key).getRight() != null) {
result = modifiedData.get(key).getRight().get(cls);
}
}
public void setModifiedData(final Map<InstanceIdentifier<Node>,
- Pair<Map<Class<? extends Identifiable>, List<Identifiable>>,
- Map<Class<? extends Identifiable>, List<Identifiable>>>> modifiedData) {
+ Pair<Map<Class<? extends KeyAware>, List<KeyAware>>,
+ Map<Class<? extends KeyAware>, List<KeyAware>>>> modifiedData) {
this.modifiedData = modifiedData;
}
* 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 org.opendaylight.yangtools.yang.binding.Identifiable;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.binding.KeyAware;
-public class MdsalUpdate<T extends Identifiable> {
+public class MdsalUpdate<T extends KeyAware> {
private InstanceIdentifier key;
private T newData;
* 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 org.opendaylight.ovsdb.lib.operations.TransactionBuilder;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
-import org.opendaylight.yangtools.yang.binding.Identifiable;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.binding.KeyAware;
-public interface TransactCommand<T extends Identifiable> {
+public interface TransactCommand<T extends KeyAware> {
void execute(TransactionBuilder transaction);
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.RemoteUcastMacs;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
import org.opendaylight.yangtools.yang.binding.DataObject;
-import org.opendaylight.yangtools.yang.binding.Identifiable;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.binding.KeyAware;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
child type is the child of hwvtep Global augmentation
*/
private final Map<InstanceIdentifier<Node>,
- Pair<Map<Class<? extends Identifiable>, List<Identifiable>>,
- Map<Class<? extends Identifiable>, List<Identifiable>>>> modifiedData = new HashMap<>();
+ Pair<Map<Class<? extends KeyAware>, List<KeyAware>>,
+ Map<Class<? extends KeyAware>, List<KeyAware>>>> modifiedData = new HashMap<>();
public TransactCommandAggregator(HwvtepOperationalState state, Collection<DataTreeModification<Node>> changes) {
}
@Override
- public void onConfigUpdate(TransactionBuilder transaction, InstanceIdentifier nodeIid, Identifiable data,
+ public void onConfigUpdate(TransactionBuilder transaction, InstanceIdentifier nodeIid, KeyAware data,
InstanceIdentifier key,
Object... extraData) {
}
@Override
- public void doDeviceTransaction(TransactionBuilder transaction, InstanceIdentifier nodeIid, Identifiable data,
+ public void doDeviceTransaction(TransactionBuilder transaction, InstanceIdentifier nodeIid, KeyAware data,
InstanceIdentifier key,
Object... extraData) {
}
for (DataTreeModification<Node> change : changes) {
final InstanceIdentifier<Node> key = change.getRootPath().getRootIdentifier();
final DataObjectModification<Node> mod = change.getRootNode();
- final Map<Class<? extends Identifiable>, List<Identifiable>> updatedData = new HashMap<>();
- final Map<Class<? extends Identifiable>, List<Identifiable>> deletedData = new HashMap<>();
+ final Map<Class<? extends KeyAware>, List<KeyAware>> updatedData = new HashMap<>();
+ final Map<Class<? extends KeyAware>, List<KeyAware>> deletedData = new HashMap<>();
extractDataChanged(key, mod, updatedData, deletedData);
modifiedData.put(key, Pair.of(updatedData, deletedData));
operationalState.setModifiedData(modifiedData);
}
}
- private static boolean isMacOnlyUpdate(final Map<Class<? extends Identifiable>, List<Identifiable>> updatedData,
- final Map<Class<? extends Identifiable>, List<Identifiable>> deletedData) {
+ private static boolean isMacOnlyUpdate(final Map<Class<? extends KeyAware>, List<KeyAware>> updatedData,
+ final Map<Class<? extends KeyAware>, List<KeyAware>> deletedData) {
return updatedData.containsKey(RemoteUcastMacs.class) && updatedData.size() == 1
|| deletedData.containsKey(RemoteUcastMacs.class) && deletedData.size() == 1;
}
private static void extractDataChanged(final InstanceIdentifier<Node> key,
final DataObjectModification<Node> mod,
- final Map<Class<? extends Identifiable>, List<Identifiable>> updatedData,
- final Map<Class<? extends Identifiable>, List<Identifiable>> deletedData) {
+ final Map<Class<? extends KeyAware>, List<KeyAware>> updatedData,
+ final Map<Class<? extends KeyAware>, List<KeyAware>> deletedData) {
extractDataChanged(mod.getModifiedChildren(), updatedData, deletedData);
DataObjectModification<HwvtepGlobalAugmentation> aug = mod.getModifiedAugmentation(
private static void extractDataChanged(
final Collection<? extends DataObjectModification<? extends DataObject>> children,
- final Map<Class<? extends Identifiable>, List<Identifiable>> updatedData,
- final Map<Class<? extends Identifiable>, List<Identifiable>> deletedData) {
+ final Map<Class<? extends KeyAware>, List<KeyAware>> updatedData,
+ final Map<Class<? extends KeyAware>, List<KeyAware>> deletedData) {
if (children == null) {
return;
}
for (DataObjectModification<? extends DataObject> child : children) {
- Class<? extends Identifiable> childClass = (Class<? extends Identifiable>) child.getDataType();
+ Class<? extends KeyAware> childClass = (Class<? extends KeyAware>) child.getDataType();
switch (child.getModificationType()) {
case WRITE:
case SUBTREE_MODIFIED:
DataObject dataAfter = child.getDataAfter();
- if (!(dataAfter instanceof Identifiable)) {
+ if (!(dataAfter instanceof KeyAware)) {
continue;
}
DataObject before = child.getDataBefore();
*/
continue;
}
- Identifiable identifiable = (Identifiable) dataAfter;
+ KeyAware identifiable = (KeyAware) dataAfter;
addToUpdatedData(updatedData, childClass, identifiable);
break;
case DELETE:
DataObject dataBefore = child.getDataBefore();
- if (!(dataBefore instanceof Identifiable)) {
+ if (!(dataBefore instanceof KeyAware)) {
continue;
}
- addToUpdatedData(deletedData, childClass, (Identifiable)dataBefore);
+ addToUpdatedData(deletedData, childClass, (KeyAware)dataBefore);
break;
default:
break;
}
}
- private static void addToUpdatedData(Map<Class<? extends Identifiable>, List<Identifiable>> updatedData,
- Class<? extends Identifiable> childClass, Identifiable identifiable) {
+ private static void addToUpdatedData(Map<Class<? extends KeyAware>, List<KeyAware>> updatedData,
+ Class<? extends KeyAware> childClass, KeyAware identifiable) {
updatedData.computeIfAbsent(childClass, (cls) -> new ArrayList<>());
updatedData.get(childClass).add(identifiable);
}
public boolean retry() {
return retryCount.decrementAndGet() > 0;
}
-
-
}
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.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPoint;
import org.opendaylight.yangtools.yang.binding.DataObject;
-import org.opendaylight.yangtools.yang.binding.Identifiable;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.binding.KeyAware;
/**
* Utility class to retrieve the unmet dependencies (config/operational) of the given object.
*/
-public abstract class UnMetDependencyGetter<T extends Identifiable> {
+public abstract class UnMetDependencyGetter<T extends KeyAware> {
private final ConfigDependencyGetter configDependencyGetter = new ConfigDependencyGetter();
private final InTransitDependencyGetter inTransitDependencyGetter = new InTransitDependencyGetter();
* @param data The data object
* @return The depenencies
*/
- public Map<Class<? extends Identifiable>, List<InstanceIdentifier>> getInTransitDependencies(
+ public Map<Class<? extends KeyAware>, List<InstanceIdentifier>> getInTransitDependencies(
HwvtepOperationalState opState, T data) {
return inTransitDependencyGetter.retrieveUnMetDependencies(opState, opState.getDeviceInfo(), data);
}
* @param data The data object
* @return the depenencies
*/
- public Map<Class<? extends Identifiable>, List<InstanceIdentifier>> getUnMetConfigDependencies(
+ public Map<Class<? extends KeyAware>, List<InstanceIdentifier>> getUnMetConfigDependencies(
HwvtepOperationalState opState, T data) {
return configDependencyGetter.retrieveUnMetDependencies(opState, opState.getDeviceInfo(), data);
}
abstract class DependencyGetter {
- Map<Class<? extends Identifiable>, List<InstanceIdentifier>> retrieveUnMetDependencies(
+ Map<Class<? extends KeyAware>, List<InstanceIdentifier>> retrieveUnMetDependencies(
HwvtepOperationalState opState, HwvtepDeviceInfo deviceInfo, T data) {
- Map<Class<? extends Identifiable>, List<InstanceIdentifier>> result = new HashMap<>();
- Map<Class<? extends Identifiable>, List<InstanceIdentifier<?>>> allKeys = new HashMap<>();
+ Map<Class<? extends KeyAware>, List<InstanceIdentifier>> result = new HashMap<>();
+ Map<Class<? extends KeyAware>, List<InstanceIdentifier<?>>> allKeys = new HashMap<>();
allKeys.put(LogicalSwitches.class, getLogicalSwitchDependencies(data));
allKeys.put(TerminationPoint.class, getTerminationPointDependencies(data));
- for (Entry<Class<? extends Identifiable>, List<InstanceIdentifier<?>>> entry : allKeys.entrySet()) {
- Class<? extends Identifiable> cls = entry.getKey();
+ for (Entry<Class<? extends KeyAware>, List<InstanceIdentifier<?>>> entry : allKeys.entrySet()) {
+ Class<? extends KeyAware> cls = entry.getKey();
List<InstanceIdentifier<? extends DataObject>> keysToCheck = entry.getValue();
for (InstanceIdentifier<? extends DataObject> key : keysToCheck) {
if (!isDependencyMet(opState, deviceInfo, cls, key)) {
return result;
}
- Map<Class<? extends Identifiable>, List<InstanceIdentifier>> addToResultMap(
- Map<Class<? extends Identifiable>, List<InstanceIdentifier>> result,
- Class<? extends Identifiable> cls, InstanceIdentifier<? extends DataObject> key) {
+ Map<Class<? extends KeyAware>, List<InstanceIdentifier>> addToResultMap(
+ Map<Class<? extends KeyAware>, List<InstanceIdentifier>> result,
+ Class<? extends KeyAware> cls, InstanceIdentifier<? extends DataObject> key) {
if (null == result) {
result = new HashMap<>();
}
}
abstract boolean isDependencyMet(HwvtepOperationalState opState, HwvtepDeviceInfo deviceInfo,
- Class<? extends Identifiable> cls, InstanceIdentifier<? extends DataObject> key);
+ Class<? extends KeyAware> cls, InstanceIdentifier<? extends DataObject> key);
}
class ConfigDependencyGetter extends DependencyGetter {
@Override
boolean isDependencyMet(HwvtepOperationalState opState, HwvtepDeviceInfo deviceInfo,
- Class<? extends Identifiable> cls, InstanceIdentifier<? extends DataObject> key) {
+ Class<? extends KeyAware> cls, InstanceIdentifier<? extends DataObject> key) {
return deviceInfo.isConfigDataAvailable(cls, key) || isConfigDataAvailable(opState, cls, key);
}
boolean isConfigDataAvailable(HwvtepOperationalState opState,
- Class<? extends Identifiable> cls,
+ Class<? extends KeyAware> cls,
InstanceIdentifier<? extends DataObject> key) {
DataBroker db = opState.getConnectionInstance().getDataBroker();
Optional data = HwvtepSouthboundUtil.readNode(db, LogicalDatastoreType.CONFIGURATION, key);
class InTransitDependencyGetter extends DependencyGetter {
@Override
boolean isDependencyMet(HwvtepOperationalState opState, HwvtepDeviceInfo deviceInfo,
- Class<? extends Identifiable> cls, InstanceIdentifier<? extends DataObject> key) {
+ Class<? extends KeyAware> cls, InstanceIdentifier<? extends DataObject> key) {
return opState.isKeyPartOfCurrentTx(cls, key) || !deviceInfo.isKeyInTransit(cls, key);
}
}
* 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 java.util.HashSet;
import org.opendaylight.ovsdb.utils.mdsal.utils.TransactionType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.ConnectionInfo;
import org.opendaylight.yangtools.yang.binding.DataObject;
-import org.opendaylight.yangtools.yang.binding.Identifiable;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.binding.KeyAware;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
private final TableUpdates updates;
private final DatabaseSchema dbSchema;
protected final HwvtepConnectionInstance key;
- protected Set<Pair<Class<? extends Identifiable>, InstanceIdentifier>> addedKeys = new HashSet<>();
- protected Set<Pair<Class<? extends Identifiable>, InstanceIdentifier>> deletedKeys = new HashSet<>();
+ protected Set<Pair<Class<? extends KeyAware>, InstanceIdentifier>> addedKeys = new HashSet<>();
+ protected Set<Pair<Class<? extends KeyAware>, InstanceIdentifier>> deletedKeys = new HashSet<>();
protected HwvtepDeviceInfo deviceInfo;
deviceInfo.addToDeviceUpdate(transactionType, element);
}
- public void clearDeviceOpUUID(Class<? extends Identifiable> cls, InstanceIdentifier iid, UUID uuid) {
+ public void clearDeviceOpUUID(Class<? extends KeyAware> cls, InstanceIdentifier iid, UUID uuid) {
deviceInfo.clearDeviceOperUUID(cls, iid, uuid);
}
- public void addToDeleteTx(ReadWriteTransaction tx, Class<? extends Identifiable> cls, InstanceIdentifier iid,
+ public void addToDeleteTx(ReadWriteTransaction tx, Class<? extends KeyAware> cls, InstanceIdentifier iid,
UUID uuid) {
if (deviceInfo.isAvailableInOperDs(cls, iid)) {
tx.delete(LogicalDatastoreType.OPERATIONAL, iid);
clearDeviceOpUUID(cls, iid, uuid);
}
- public void addToUpdateTx(Class<? extends Identifiable> cls, InstanceIdentifier iid, UUID uuid,
+ public void addToUpdateTx(Class<? extends KeyAware> cls, InstanceIdentifier iid, UUID uuid,
Object southboundData) {
addedKeys.add(Pair.of(cls, iid));
deviceInfo.updateDeviceOperData(cls, iid, uuid, southboundData);
import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.yang.binding.ChildOf;
import org.opendaylight.yangtools.yang.binding.DataObject;
-import org.opendaylight.yangtools.yang.binding.Identifiable;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.binding.KeyAware;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
}
private void updateDeviceOpData(InstanceIdentifier<Node> key, DataObjectModification<? extends DataObject> mod) {
- Class<? extends Identifiable> childClass = (Class<? extends Identifiable>) mod.getDataType();
+ Class<? extends KeyAware> childClass = (Class<? extends KeyAware>) mod.getDataType();
InstanceIdentifier instanceIdentifier = getKey(key, mod, mod.getDataAfter());
switch (mod.getModificationType()) {
case WRITE:
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.RemoteMcastMacs;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.RemoteMcastMacsKey;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPoint;
-import org.opendaylight.yangtools.yang.binding.Identifiable;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.binding.KeyAware;
@RunWith(MockitoJUnitRunner.Silent.class)
public class DependencyQueueTest extends DataChangeListenerTestBase {
RemoteMcastMacs mac;
InstanceIdentifier<RemoteMcastMacs> macIid;
InstanceIdentifier<LogicalSwitches> lsIid;
- Map<Class<? extends Identifiable>, List<InstanceIdentifier>> unMetDependencies;
+ Map<Class<? extends KeyAware>, List<InstanceIdentifier>> unMetDependencies;
void setupForTest() throws Exception {
mcastMacDataValidator = McastMacsRemoteUpdateCommand.MCAST_MAC_DATA_VALIDATOR;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.LogicalSwitchesKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.RemoteMcastMacs;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPoint;
-import org.opendaylight.yangtools.yang.binding.Identifiable;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.binding.KeyAware;
@RunWith(MockitoJUnitRunner.Silent.class)
public class UnMetDependencyGetterTest extends DataChangeListenerTestBase {
HwvtepOperationalState opState;
RemoteMcastMacs mac;
InstanceIdentifier<LogicalSwitches> lsIid;
- Map<Class<? extends Identifiable>, List<InstanceIdentifier>> unMetDependencies;
+ Map<Class<? extends KeyAware>, List<InstanceIdentifier>> unMetDependencies;
void setupForTest() {
mcastMacDataValidator = McastMacsRemoteUpdateCommand.MCAST_MAC_DATA_VALIDATOR;
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>karaf4-parent</artifactId>
- <version>12.0.3</version>
+ <version>13.0.3</version>
<relativePath/>
</parent>
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>12.0.3</version>
+ <version>13.0.3</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>12.0.3</version>
+ <version>13.0.3</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>feature-repo-parent</artifactId>
- <version>12.0.3</version>
+ <version>13.0.3</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>single-feature-parent</artifactId>
- <version>12.0.3</version>
+ <version>13.0.3</version>
<relativePath/>
</parent>
<dependency>
<groupId>org.opendaylight.aaa</groupId>
<artifactId>odl-aaa-cert</artifactId>
- <version>0.17.7</version>
+ <version>0.18.0</version>
<type>xml</type>
<classifier>features</classifier>
</dependency>
-->
<features name="odl-ovsdb-library-${project.version}" xmlns="http://karaf.apache.org/xmlns/features/v1.2.0">
<feature name="odl-ovsdb-library" version="${project.version}">
- <feature version="[12,13)">odl-jackson-2</feature>
- <feature version="[12,13)">odl-netty-4</feature>
- <feature version="[0.17,1)">odl-aaa-cert</feature>
+ <feature version="[13,14)">odl-jackson-2</feature>
+ <feature version="[13,14)">odl-netty-4</feature>
+ <feature version="[0.18,1)">odl-aaa-cert</feature>
<configfile finalname="etc/org.opendaylight.ovsdb.library.cfg">
mvn:org.opendaylight.ovsdb/library/${project.version}/cfg/config
</configfile>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>12.0.3</version>
+ <version>13.0.3</version>
<relativePath/>
</parent>
<groupId>org.opendaylight.ovsdb</groupId>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
</dependency>
+ <dependency>
+ <groupId>com.github.spotbugs</groupId>
+ <artifactId>spotbugs-annotations</artifactId>
+ <optional>true</optional>
+ </dependency>
<dependency>
<groupId>com.google.guava</groupId>
<artifactId>guava</artifactId>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>karaf4-parent</artifactId>
- <version>12.0.3</version>
+ <version>13.0.3</version>
<relativePath/>
</parent>
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>12.0.3</version>
+ <version>13.0.3</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>12.0.3</version>
+ <version>13.0.3</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>12.0.3</version>
+ <version>13.0.3</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>12.0.3</version>
+ <version>13.0.3</version>
<relativePath/>
</parent>
</dependency>
<dependency>
<groupId>org.opendaylight.mdsal.binding.model.ietf</groupId>
- <artifactId>rfc6991</artifactId>
+ <artifactId>rfc6991-ietf-inet-types</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.mdsal.binding.model.ietf</groupId>
+ <artifactId>rfc6991-ietf-yang-types</artifactId>
</dependency>
<dependency>
<groupId>org.opendaylight.mdsal.model</groupId>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>12.0.3</version>
+ <version>13.0.3</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>feature-repo-parent</artifactId>
- <version>12.0.3</version>
+ <version>13.0.3</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>single-feature-parent</artifactId>
- <version>12.0.3</version>
+ <version>13.0.3</version>
<relativePath/>
</parent>
<dependency>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>mdsal-artifacts</artifactId>
- <version>11.0.7</version>
+ <version>12.0.0</version>
<type>pom</type>
<scope>import</scope>
</dependency>
-->
<features name="odl-ovsdb-southbound-api-${project.version}" xmlns="http://karaf.apache.org/xmlns/features/v1.2.0">
<feature name="odl-ovsdb-southbound-api" version="${project.version}">
- <feature version="[11,12)">odl-mdsal-model-draft-clemm-netmod-yang-network-topo-01-minimal</feature>
- <feature version="[11,12)">odl-mdsal-model-odl-l2-types</feature>
+ <feature version="[12,13)">odl-mdsal-model-draft-clemm-netmod-yang-network-topo-01-minimal</feature>
+ <feature version="[12,13)">odl-mdsal-model-odl-l2-types</feature>
</feature>
</features>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>single-feature-parent</artifactId>
- <version>12.0.3</version>
+ <version>13.0.3</version>
<relativePath/>
</parent>
<dependency>
<groupId>org.opendaylight.netconf</groupId>
<artifactId>odl-restconf</artifactId>
- <version>5.0.4</version>
+ <version>6.0.0</version>
<type>xml</type>
<classifier>features</classifier>
</dependency>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>single-feature-parent</artifactId>
- <version>12.0.3</version>
+ <version>13.0.3</version>
<relativePath/>
</parent>
</dependency>
<dependency>
<groupId>org.opendaylight.netconf</groupId>
- <artifactId>odl-mdsal-apidocs</artifactId>
- <version>5.0.4</version>
+ <artifactId>odl-restconf-openapi</artifactId>
+ <version>6.0.0</version>
<type>xml</type>
<classifier>features</classifier>
</dependency>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>single-feature-parent</artifactId>
- <version>12.0.3</version>
+ <version>13.0.3</version>
<relativePath/>
</parent>
<dependency>
<groupId>org.opendaylight.infrautils</groupId>
<artifactId>infrautils-artifacts</artifactId>
- <version>5.0.3</version>
+ <version>6.0.1</version>
<type>pom</type>
<scope>import</scope>
</dependency>
-->
<features name="odl-ovsdb-southbound-impl-${project.version}" xmlns="http://karaf.apache.org/xmlns/features/v1.2.0">
<feature name="odl-ovsdb-southbound-impl" version="${project.version}">
- <feature version="[12,13)">odl-jackson-2</feature>
- <feature version="[5,6)">odl-infrautils-diagstatus</feature>
- <feature version="[5,6)">odl-infrautils-ready</feature>
+ <feature version="[13,14)">odl-jackson-2</feature>
+ <feature version="[6,7)">odl-infrautils-diagstatus</feature>
+ <feature version="[6,7)">odl-infrautils-ready</feature>
<configfile finalname="etc/org.opendaylight.ovsdb.southbound.cfg">
mvn:org.opendaylight.ovsdb/southbound-impl/${project.version}/cfg/config
</configfile>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>single-feature-parent</artifactId>
- <version>12.0.3</version>
+ <version>13.0.3</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>12.0.3</version>
+ <version>13.0.3</version>
<relativePath/>
</parent>
<groupId>org.opendaylight.infrautils</groupId>
<artifactId>diagstatus-api</artifactId>
</dependency>
+ <dependency>
+ <groupId>com.github.spotbugs</groupId>
+ <artifactId>spotbugs-annotations</artifactId>
+ <optional>true</optional>
+ </dependency>
<dependency>
<groupId>com.guicedee.services</groupId>
<artifactId>javax.inject</artifactId>
import org.opendaylight.infrautils.diagstatus.DiagStatusService;
import org.opendaylight.infrautils.diagstatus.ServiceDescriptor;
+import org.opendaylight.infrautils.diagstatus.ServiceRegistration;
import org.opendaylight.infrautils.diagstatus.ServiceState;
import org.opendaylight.infrautils.diagstatus.ServiceStatusProvider;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class OvsdbDiagStatusProvider implements ServiceStatusProvider {
-
private static final Logger LOG = LoggerFactory.getLogger(OvsdbDiagStatusProvider.class);
private static final String OVSDB_SERVICE_NAME = "OVSDB";
- private final DiagStatusService diagStatusService;
+ private final ServiceRegistration reg;
private volatile ServiceDescriptor serviceDescriptor;
public OvsdbDiagStatusProvider(final DiagStatusService diagStatusService) {
- this.diagStatusService = diagStatusService;
- diagStatusService.register(OVSDB_SERVICE_NAME);
+ reg = diagStatusService.register(OVSDB_SERVICE_NAME);
}
-
public void reportStatus(final ServiceState serviceState, final String description) {
LOG.debug("reporting status as {} for {}", serviceState, OVSDB_SERVICE_NAME);
serviceDescriptor = new ServiceDescriptor(OVSDB_SERVICE_NAME, serviceState, description);
- diagStatusService.report(serviceDescriptor);
+ reg.report(serviceDescriptor);
}
@Override
// TODO Check 6640 port status to report dynamic status
return serviceDescriptor;
}
+
+ void close() {
+ reg.close();
+ }
}
}
public static IpAddress createIpAddress(final Inet4Address address) {
- return IetfInetUtil.INSTANCE.ipAddressFor(address);
+ return IetfInetUtil.ipAddressFor(address);
}
public static IpAddress createIpAddress(final Inet6Address address) {
operTopologyRegistration = null;
}
ovsdbStatusProvider.reportStatus(ServiceState.UNREGISTERED, "OVSDB Service stopped");
+ ovsdbStatusProvider.close();
}
private static void initializeOvsdbTopology(final @NonNull LogicalDatastoreType type) {
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
import org.opendaylight.yangtools.yang.binding.ChildOf;
import org.opendaylight.yangtools.yang.binding.DataObject;
-import org.opendaylight.yangtools.yang.binding.Identifiable;
-import org.opendaylight.yangtools.yang.binding.Identifier;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.binding.Key;
+import org.opendaylight.yangtools.yang.binding.KeyAware;
// This class needs to be mocked
@SuppressWarnings("checkstyle:FinalClass")
* @param child The child modification to include.
* @return The extended path.
*/
- private static <N extends Identifiable<K> & ChildOf<? super T>, K extends Identifier<N>, T extends DataObject>
+ private static <N extends KeyAware<K> & ChildOf<? super T>, K extends Key<N>, T extends DataObject>
InstanceIdentifier<? extends DataObject> extendPath(
InstanceIdentifier<T> path,
DataObjectModification<?> child) {
import org.junit.Test;
import org.mockito.Mockito;
import org.opendaylight.infrautils.diagstatus.DiagStatusService;
+import org.opendaylight.infrautils.diagstatus.ServiceRegistration;
import org.opendaylight.infrautils.ready.testutils.TestSystemReadyMonitor;
import org.opendaylight.mdsal.binding.dom.adapter.test.AbstractConcurrentDataBrokerTest;
import org.opendaylight.mdsal.binding.dom.codec.api.BindingNormalizedNodeSerializer;
import org.opendaylight.yangtools.yang.binding.KeyedInstanceIdentifier;
public class SouthboundProviderTest extends AbstractConcurrentDataBrokerTest {
-
private EntityOwnershipService entityOwnershipService;
+ private DiagStatusService diagStatusService;
public SouthboundProviderTest() {
super(true);
mock(EntityOwnershipListenerRegistration.class));
when(entityOwnershipService.registerCandidate(any(Entity.class))).thenReturn(mock(
EntityOwnershipCandidateRegistration.class));
+
+ diagStatusService = Mockito.mock(DiagStatusService.class);
+ when(diagStatusService.register(any())).thenReturn(Mockito.mock(ServiceRegistration.class));
}
@Test
Mockito.mock(DOMSchemaService.class),
Mockito.mock(BindingNormalizedNodeSerializer.class),
new TestSystemReadyMonitor(IMMEDIATE),
- Mockito.mock(DiagStatusService.class))) {
+ diagStatusService)) {
// Initiate the session
southboundProvider.init();
Mockito.mock(DOMSchemaService.class),
Mockito.mock(BindingNormalizedNodeSerializer.class),
new TestSystemReadyMonitor(IMMEDIATE),
- Mockito.mock(DiagStatusService.class))) {
+ diagStatusService)) {
// Initiate the session
southboundProvider.init();
Mockito.mock(DOMSchemaService.class),
Mockito.mock(BindingNormalizedNodeSerializer.class),
new TestSystemReadyMonitor(IMMEDIATE),
- Mockito.mock(DiagStatusService.class))) {
+ diagStatusService)) {
southboundProvider.init();
Mockito.mock(DOMSchemaService.class),
Mockito.mock(BindingNormalizedNodeSerializer.class),
new TestSystemReadyMonitor(IMMEDIATE),
- Mockito.mock(DiagStatusService.class))) {
+ diagStatusService)) {
southboundProvider.init();
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPointBuilder;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPointKey;
import org.opendaylight.yangtools.yang.binding.DataObject;
-import org.opendaylight.yangtools.yang.binding.Identifiable;
-import org.opendaylight.yangtools.yang.binding.Identifier;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.binding.Key;
+import org.opendaylight.yangtools.yang.binding.KeyAware;
import org.opendaylight.yangtools.yang.binding.KeyedInstanceIdentifier;
import org.opendaylight.yangtools.yang.binding.util.BindingMap;
import org.opendaylight.yangtools.yang.common.Uint16;
}
}
- private static <I extends Identifier<T>, T extends Identifiable<I>> void assertExpectedExist(
+ private static <I extends Key<T>, T extends KeyAware<I>> void assertExpectedExist(
final Map<I, T> expected, final Map<I, T> test) {
if (expected != null && test != null) {
for (T exp : expected.values()) {
}
}
- private interface SouthboundTerminationPointHelper<I extends Identifier<T>, T extends Identifiable<I>> {
+ private interface SouthboundTerminationPointHelper<I extends Key<T>, T extends KeyAware<I>> {
void writeValues(OvsdbTerminationPointAugmentationBuilder builder, Map<I, T> values);
Map<I, T> readValues(OvsdbTerminationPointAugmentation augmentation);
*
* @see <code>SouthboundIT.generatePortExternalIdsTestCases()</code> for specific test case information
*/
- private static <I extends Identifier<T>, T extends Identifiable<I>> void testCRUDTerminationPoint(
+ private static <I extends Key<T>, T extends KeyAware<I>> void testCRUDTerminationPoint(
final KeyValueBuilder<T> builder, final String prefix, final SouthboundTerminationPointHelper<I, T> helper)
throws InterruptedException {
final int terminationPointTestIndex = 0;
new BridgeOtherConfigsSouthboundHelper());
}
- private interface SouthboundBridgeHelper<I extends Identifier<T>, T extends Identifiable<I>> {
+ private interface SouthboundBridgeHelper<I extends Key<T>, T extends KeyAware<I>> {
void writeValues(OvsdbBridgeAugmentationBuilder builder, Map<I, T> values);
Map<I, T> readValues(OvsdbBridgeAugmentation augmentation);
}
- private static <I extends Identifier<T>, T extends Identifiable<I>> void testCRUDBridge(final String prefix,
+ private static <I extends Key<T>, T extends KeyAware<I>> void testCRUDBridge(final String prefix,
final KeyValueBuilder<T> builder, final SouthboundBridgeHelper<I, T> helper) throws InterruptedException {
ConnectionInfo connectionInfo = getConnectionInfo(addressStr, portNumber);
// updateFromTestCases represent the original test case value. updateToTestCases represent the new value after
}
}
- private interface SouthboundQueueHelper<I extends Identifier<T>, T extends Identifiable<I>> {
+ private interface SouthboundQueueHelper<I extends Key<T>, T extends KeyAware<I>> {
void writeValues(QueuesBuilder builder, Map<I, T> values);
Map<I, T> readValues(Queues queue);
}
}
- private interface SouthboundQosHelper<I extends Identifier<T>, T extends Identifiable<I>> {
+ private interface SouthboundQosHelper<I extends Key<T>, T extends KeyAware<I>> {
void writeValues(QosEntriesBuilder builder, Map<I, T> values);
Map<I, T> readValues(QosEntries qos);
return null;
}
- private static <I extends Identifier<T>, T extends Identifiable<I>> void testCRUDQueue(
+ private static <I extends Key<T>, T extends KeyAware<I>> void testCRUDQueue(
final KeyValueBuilder<T> builder, final String prefix, final SouthboundQueueHelper<I, T> helper)
throws InterruptedException {
}
- private static <I extends Identifier<T>, T extends Identifiable<I>> void testCRUDQos(
+ private static <I extends Key<T>, T extends KeyAware<I>> void testCRUDQos(
final KeyValueBuilder<T> builder, final String prefix, final SouthboundQosHelper<I, T> helper)
throws InterruptedException {
*
* @param <T> The type of data used for the test case.
*/
- private static final class SouthboundTestCase<I extends Identifier<T>, T extends Identifiable<I>> {
+ private static final class SouthboundTestCase<I extends Key<T>, T extends KeyAware<I>> {
private final String name;
private final Map<I, T> inputValues;
private final Map<I, T> expectedValues;
*
* @param <T> The type of data used for the test case.
*/
- private static final class SouthboundTestCaseBuilder<I extends Identifier<T>, T extends Identifiable<I>> {
+ private static final class SouthboundTestCaseBuilder<I extends Key<T>, T extends KeyAware<I>> {
private String name;
private List<T> inputValues;
private List<T> expectedValues;
* Generates the test cases involved in testing key-value-based data. See inline comments for descriptions of
* the particular cases considered.
*/
- private static <I extends Identifier<T>, T extends Identifiable<I>> List<SouthboundTestCase<I, T>>
+ private static <I extends Key<T>, T extends KeyAware<I>> List<SouthboundTestCase<I, T>>
generateKeyValueTestCases(final KeyValueBuilder<T> builder, final String testName) {
List<SouthboundTestCase<I, T>> testCases = new ArrayList<>();
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>karaf4-parent</artifactId>
- <version>12.0.3</version>
+ <version>13.0.3</version>
<relativePath/>
</parent>
<modelVersion>4.0.0</modelVersion>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>mdsal-binding-api</artifactId>
</dependency>
+ <dependency>
+ <groupId>com.github.spotbugs</groupId>
+ <artifactId>spotbugs-annotations</artifactId>
+ <optional>true</optional>
+ </dependency>
<dependency>
<groupId>com.guicedee.services</groupId>
<artifactId>javax.inject</artifactId>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>single-feature-parent</artifactId>
- <version>12.0.3</version>
+ <version>13.0.3</version>
<relativePath/>
</parent>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>controller-artifacts</artifactId>
- <version>7.0.4</version>
+ <version>8.0.0</version>
<type>pom</type>
<scope>import</scope>
</dependency>
-->
<features name="odl-ovsdb-utils-${project.version}" xmlns="http://karaf.apache.org/xmlns/features/v1.2.0">
<feature name="odl-ovsdb-utils" version="${project.version}">
- <feature version="[7,8)">odl-mdsal-broker</feature>
+ <feature version="[8,9)">odl-mdsal-broker</feature>
</feature>
</features>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>12.0.3</version>
+ <version>13.0.3</version>
<relativePath/>
</parent>
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPointBuilder;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPointKey;
import org.opendaylight.yangtools.yang.binding.DataObject;
-import org.opendaylight.yangtools.yang.binding.Identifier;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.IdentifiableItem;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.Item;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.PathArgument;
+import org.opendaylight.yangtools.yang.binding.Key;
import org.opendaylight.yangtools.yang.binding.util.BindingMap;
import org.opendaylight.yangtools.yang.common.Uint16;
import org.opendaylight.yangtools.yang.common.Uint32;
}
public static IpAddress createIpAddress(Inet4Address address) {
- return IetfInetUtil.INSTANCE.ipAddressFor(address);
+ return IetfInetUtil.ipAddressFor(address);
}
public static IpAddress createIpAddress(Inet6Address address) {
InstanceIdentifier<?> bridgeIid = managedNode.getBridgeRef().getValue();
for (PathArgument bridgeIidPathArg : bridgeIid.getPathArguments()) {
if (bridgeIidPathArg instanceof IdentifiableItem<?, ?> identifiableItem) {
- Identifier<?> key = identifiableItem.getKey();
+ Key<?> key = identifiableItem.getKey();
if (key instanceof NodeKey nodeKey) {
if (nodeKey.getNodeId().getValue().contains(bridgeName)) {
return true;
} else if (key.toString().contains(bridgeName)) {
return true;
}
- } else if (bridgeIidPathArg instanceof Item<?>) {
- if (((Item<?>) bridgeIidPathArg).getType().getName().contains(bridgeName)) {
+ } else if (bridgeIidPathArg instanceof Item<?> item) {
+ if (item.getType().getName().contains(bridgeName)) {
return true;
}
} else {
import java.util.function.Function;
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.yangtools.yang.binding.Identifiable;
-import org.opendaylight.yangtools.yang.binding.Identifier;
+import org.opendaylight.yangtools.yang.binding.Key;
+import org.opendaylight.yangtools.yang.binding.KeyAware;
/**
* YANG utility functions.
* @param <V> The value type.
* @return The map.
*/
- public static <I extends Identifier<T>, T extends Identifiable<I>, K, V>
+ public static <I extends Key<T>, T extends KeyAware<I>, K, V>
@NonNull Map<K, V> copyYangKeyValueListToMap(@NonNull Map<K, V> map,
@Nullable Map<I, T> yangList, @NonNull Function<T, K> keyExtractor,
@NonNull Function<T, V> valueExtractor) {
* @param <V> The value type.
* @return The map.
*/
- public static <I extends Identifier<T>, T extends Identifiable<I>, K, V> @NonNull Map<K, V>
+ public static <I extends Key<T>, T extends KeyAware<I>, K, V> @NonNull Map<K, V>
convertYangKeyValueListToMap(@Nullable Map<I, T> yangList,
@NonNull Function<T, K> keyExtractor, @NonNull Function<T, V> valueExtractor) {
return copyYangKeyValueListToMap(new HashMap<>(), yangList, keyExtractor, valueExtractor);
Code Review / ovsdb.git / commitdiff