*/
package org.opendaylight.netconf.callhome.mount;
-import com.google.common.collect.Iterables;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.net.SocketAddress;
import java.security.GeneralSecurityException;
import java.security.PublicKey;
-import java.util.Collection;
+import java.util.List;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import javax.inject.Singleton;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.mdsal.binding.api.DataBroker;
-import org.opendaylight.mdsal.binding.api.DataObjectModification;
-import org.opendaylight.mdsal.binding.api.DataObjectModification.ModificationType;
import org.opendaylight.mdsal.binding.api.DataTreeChangeListener;
import org.opendaylight.mdsal.binding.api.DataTreeIdentifier;
import org.opendaylight.mdsal.binding.api.DataTreeModification;
public CallHomeMountSshAuthProvider(final @Reference DataBroker broker,
final @Reference CallHomeMountStatusReporter statusReporter) {
configReg = broker.registerDataTreeChangeListener(
- DataTreeIdentifier.create(LogicalDatastoreType.CONFIGURATION,
+ DataTreeIdentifier.of(LogicalDatastoreType.CONFIGURATION,
InstanceIdentifier.create(NetconfCallhomeServer.class).child(Global.class)),
globalConfig);
InstanceIdentifier.create(NetconfCallhomeServer.class).child(AllowedDevices.class).child(Device.class);
deviceReg = broker.registerDataTreeChangeListener(
- DataTreeIdentifier.create(LogicalDatastoreType.CONFIGURATION, allowedDeviceWildcard),
+ DataTreeIdentifier.of(LogicalDatastoreType.CONFIGURATION, allowedDeviceWildcard),
deviceConfig);
deviceOpReg = broker.registerDataTreeChangeListener(
- DataTreeIdentifier.create(LogicalDatastoreType.OPERATIONAL, allowedDeviceWildcard),
+ DataTreeIdentifier.of(LogicalDatastoreType.OPERATIONAL, allowedDeviceWildcard),
deviceOp);
this.statusReporter = statusReporter;
private abstract static class AbstractDeviceListener implements DataTreeChangeListener<Device> {
@Override
- public final void onDataTreeChanged(final Collection<DataTreeModification<Device>> mods) {
- for (DataTreeModification<Device> dataTreeModification : mods) {
- final DataObjectModification<Device> deviceMod = dataTreeModification.getRootNode();
- final ModificationType modType = deviceMod.getModificationType();
+ public final void onDataTreeChanged(final List<DataTreeModification<Device>> mods) {
+ for (var dataTreeModification : mods) {
+ final var deviceMod = dataTreeModification.getRootNode();
+ final var modType = deviceMod.modificationType();
switch (modType) {
case DELETE:
- deleteDevice(deviceMod.getDataBefore());
+ deleteDevice(deviceMod.dataBefore());
break;
case SUBTREE_MODIFIED:
case WRITE:
- deleteDevice(deviceMod.getDataBefore());
- writeDevice(deviceMod.getDataAfter());
+ deleteDevice(deviceMod.dataBefore());
+ writeDevice(deviceMod.dataAfter());
break;
default:
throw new IllegalStateException("Unhandled modification type " + modType);
private volatile Global current = null;
@Override
- public void onDataTreeChanged(final Collection<DataTreeModification<Global>> mods) {
+ public void onDataTreeChanged(final List<DataTreeModification<Global>> mods) {
if (!mods.isEmpty()) {
- current = Iterables.getLast(mods).getRootNode().getDataAfter();
+ current = mods.get(mods.size() - 1).getRootNode().dataAfter();
}
}
import java.security.cert.CertificateException;
import java.security.cert.CertificateFactory;
import java.util.Base64;
-import java.util.Collection;
+import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.mdsal.binding.api.ClusteredDataTreeChangeListener;
import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.mdsal.binding.api.DataObjectModification;
+import org.opendaylight.mdsal.binding.api.DataTreeChangeListener;
import org.opendaylight.mdsal.binding.api.DataTreeIdentifier;
import org.opendaylight.mdsal.binding.api.DataTreeModification;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
public CallHomeMountTlsAuthProvider(
final @Reference SslHandlerFactoryProvider sslHandlerFactoryProvider,
final @Reference DataBroker dataBroker) {
- this.sslHandlerFactory = sslHandlerFactoryProvider.getSslHandlerFactory(null);
- allowedDevicesReg = dataBroker.registerDataTreeChangeListener(
- DataTreeIdentifier.create(LogicalDatastoreType.CONFIGURATION,
+ sslHandlerFactory = sslHandlerFactoryProvider.getSslHandlerFactory(null);
+ allowedDevicesReg = dataBroker.registerTreeChangeListener(
+ DataTreeIdentifier.of(LogicalDatastoreType.CONFIGURATION,
InstanceIdentifier.create(NetconfCallhomeServer.class).child(AllowedDevices.class).child(Device.class)),
new AllowedDevicesMonitor());
- certificatesReg = dataBroker.registerDataTreeChangeListener(
- DataTreeIdentifier.create(LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(Keystore.class)),
+ certificatesReg = dataBroker.registerTreeChangeListener(
+ DataTreeIdentifier.of(LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(Keystore.class)),
new CertificatesMonitor());
}
// In real world scenario it is not possible to have multiple certificates with the same private/public key,
// but in theory/synthetic tests it is practically possible to generate multiple certificates from a single
// private key. In such case it's not possible to pin certificate to particular device.
- if (deviceNames.size() > 1) {
- LOG.error("Unable to find device by provided certificate. Possible reason: one certificate configured "
- + "with multiple devices/names or multiple certificates contain same public key");
- return null;
- }
- return deviceNames.isEmpty() ? null : deviceNames.get(0);
+ return switch (deviceNames.size()) {
+ case 0 -> null;
+ case 1 -> deviceNames.get(0);
+ default -> {
+ LOG.error("Unable to find device by provided certificate. Possible reason: one certificate configured "
+ + "with multiple devices/names or multiple certificates contain same public key");
+ yield null;
+ }
+ };
}
@Override
return sslHandlerFactory.createSslHandler(Set.copyOf(deviceToPrivateKey.values()));
}
- private final class CertificatesMonitor implements ClusteredDataTreeChangeListener<Keystore> {
+ private final class CertificatesMonitor implements DataTreeChangeListener<Keystore> {
@Override
- public void onDataTreeChanged(@NonNull final Collection<DataTreeModification<Keystore>> changes) {
- changes.stream().map(DataTreeModification::getRootNode)
- .flatMap(v -> v.getModifiedChildren().stream())
- .filter(v -> v.getDataType().equals(TrustedCertificate.class))
+ public void onDataTreeChanged(final List<DataTreeModification<Keystore>> changes) {
+ changes.stream()
+ .map(DataTreeModification::getRootNode)
+ .flatMap(v -> v.modifiedChildren().stream())
+ .filter(v -> v.dataType().equals(TrustedCertificate.class))
.map(v -> (DataObjectModification<TrustedCertificate>) v)
.forEach(this::updateCertificate);
}
private void updateCertificate(final DataObjectModification<TrustedCertificate> change) {
- switch (change.getModificationType()) {
- case DELETE:
- deleteCertificate(change.getDataBefore());
- break;
- case SUBTREE_MODIFIED:
- case WRITE:
- deleteCertificate(change.getDataBefore());
- writeCertificate(change.getDataAfter());
- break;
- default:
- break;
+ switch (change.modificationType()) {
+ case DELETE -> deleteCertificate(change.dataBefore());
+ case SUBTREE_MODIFIED, WRITE -> {
+ deleteCertificate(change.dataBefore());
+ writeCertificate(change.dataAfter());
+ }
+ default -> {
+ // Should never happen
+ }
}
}
}
}
- private final class AllowedDevicesMonitor implements ClusteredDataTreeChangeListener<Device> {
+ private final class AllowedDevicesMonitor implements DataTreeChangeListener<Device> {
@Override
- public void onDataTreeChanged(final Collection<DataTreeModification<Device>> mods) {
- for (final DataTreeModification<Device> dataTreeModification : mods) {
- final DataObjectModification<Device> deviceMod = dataTreeModification.getRootNode();
- switch (deviceMod.getModificationType()) {
- case DELETE:
- deleteDevice(deviceMod.getDataBefore());
- break;
- case SUBTREE_MODIFIED:
- case WRITE:
- deleteDevice(deviceMod.getDataBefore());
- writeDevice(deviceMod.getDataAfter());
- break;
- default:
- break;
+ public void onDataTreeChanged(final List<DataTreeModification<Device>> mods) {
+ for (var dataTreeModification : mods) {
+ final var deviceMod = dataTreeModification.getRootNode();
+ switch (deviceMod.modificationType()) {
+ case DELETE -> deleteDevice(deviceMod.dataBefore());
+ case SUBTREE_MODIFIED, WRITE -> {
+ deleteDevice(deviceMod.dataBefore());
+ writeDevice(deviceMod.dataAfter());
+ }
+ default -> {
+ // Should never happen
+ }
}
}
}
package org.opendaylight.netconf.topology.impl;
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
-import java.util.Collection;
+import java.util.List;
import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
mountPointService, builderFactory, deviceActionFactory, baseSchemas);
LOG.debug("Registering datastore listener");
- dtclReg = dataBroker.registerDataTreeChangeListener(DataTreeIdentifier.create(
+ dtclReg = dataBroker.registerLegacyTreeChangeListener(DataTreeIdentifier.of(
LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.builder(NetworkTopology.class)
.child(Topology.class, new TopologyKey(new TopologyId(topologyId)))
.child(Node.class)
}
@Override
- public void onDataTreeChanged(final Collection<DataTreeModification<Node>> changes) {
+ public void onDataTreeChanged(final List<DataTreeModification<Node>> changes) {
for (var change : changes) {
final var rootNode = change.getRootNode();
- final var modType = rootNode.getModificationType();
+ final var modType = rootNode.modificationType();
switch (modType) {
- case SUBTREE_MODIFIED -> ensureNode("updated", rootNode.getDataAfter());
- case WRITE -> ensureNode("created", rootNode.getDataAfter());
+ case SUBTREE_MODIFIED -> ensureNode("updated", rootNode.dataAfter());
+ case WRITE -> ensureNode("created", rootNode.dataAfter());
case DELETE -> {
- final var nodeId = InstanceIdentifier.keyOf(change.getRootPath().getRootIdentifier()).getNodeId();
+ final var nodeId = InstanceIdentifier.keyOf(change.getRootPath().path()).getNodeId();
LOG.debug("Config for node {} deleted", nodeId);
deleteNode(nodeId);
}
.build())
.build();
- doReturn(DataObjectModification.ModificationType.WRITE).when(objMod).getModificationType();
- doReturn(node).when(objMod).getDataAfter();
+ doReturn(DataObjectModification.ModificationType.WRITE).when(objMod).modificationType();
+ doReturn(node).when(objMod).dataAfter();
- doReturn(DataTreeIdentifier.create(LogicalDatastoreType.CONFIGURATION,
+ doReturn(DataTreeIdentifier.of(LogicalDatastoreType.CONFIGURATION,
TOPOLOGY_PATH.child(Node.class, key))).when(treeMod).getRootPath();
final var changes = List.of(treeMod);
spyTopology.onDataTreeChanged(changes);
verify(spyTopology).ensureNode(node);
- doReturn(DataObjectModification.ModificationType.DELETE).when(objMod).getModificationType();
+ doReturn(DataObjectModification.ModificationType.DELETE).when(objMod).modificationType();
spyTopology.onDataTreeChanged(changes);
verify(spyTopology).deleteNode(key.getNodeId());
- doReturn(DataObjectModification.ModificationType.SUBTREE_MODIFIED).when(objMod).getModificationType();
+ doReturn(DataObjectModification.ModificationType.SUBTREE_MODIFIED).when(objMod).modificationType();
spyTopology.onDataTreeChanged(changes);
// one in previous creating and deleting node and one in updating
</dependency>
<dependency>
<groupId>org.opendaylight.mdsal</groupId>
- <artifactId>mdsal-singleton-common-api</artifactId>
+ <artifactId>mdsal-singleton-api</artifactId>
</dependency>
<dependency>
<groupId>org.opendaylight.mdsal.model</groupId>
</dependency>
<dependency>
<groupId>org.opendaylight.mdsal</groupId>
- <artifactId>mdsal-singleton-dom-impl</artifactId>
+ <artifactId>mdsal-singleton-impl</artifactId>
<scope>test</scope>
</dependency>
<dependency>
import org.opendaylight.netconf.topology.spi.NetconfDeviceTopologyAdapter;
import org.opendaylight.netconf.topology.spi.NetconfNodeUtils;
import org.opendaylight.yangtools.yang.data.api.schema.MountPointContext;
-import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
+import org.opendaylight.yangtools.yang.model.api.source.SourceIdentifier;
import org.opendaylight.yangtools.yang.model.util.SchemaContextUtil;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
actorResponseWaitTime);
final NetconfDataTreeService proxyNetconfService = new ProxyNetconfDataTreeService(id, masterActorRef,
actorSystem.dispatcher(), actorResponseWaitTime);
- mount.onDeviceConnected(mountContext.getEffectiveModelContext(), deviceServices,
- proxyDataBroker, proxyNetconfService);
+ mount.onDeviceConnected(mountContext.modelContext(), deviceServices, proxyDataBroker, proxyNetconfService);
}
protected DOMDataBroker newDeviceDataBroker(final MountPointContext mountContext,
private Future<Object> sendInitialDataToActor() {
final List<SourceIdentifier> sourceIdentifiers = List.copyOf(SchemaContextUtil.getConstituentModuleIdentifiers(
- currentSchema.mountContext().getEffectiveModelContext()));
+ currentSchema.mountContext().modelContext()));
LOG.debug("{}: Sending CreateInitialMasterActorData with sourceIdentifiers {} to {}", id, sourceIdentifiers,
masterActorRef);
import akka.pattern.AskTimeoutException;
import akka.pattern.Patterns;
import akka.util.Timeout;
-import java.util.Collection;
+import java.util.List;
import org.checkerframework.checker.lock.qual.GuardedBy;
import org.checkerframework.checker.lock.qual.Holding;
-import org.opendaylight.mdsal.binding.api.ClusteredDataTreeChangeListener;
import org.opendaylight.mdsal.binding.api.DataObjectModification;
+import org.opendaylight.mdsal.binding.api.DataTreeChangeListener;
import org.opendaylight.mdsal.binding.api.DataTreeIdentifier;
import org.opendaylight.mdsal.binding.api.DataTreeModification;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.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.concepts.ListenerRegistration;
+import org.opendaylight.yangtools.concepts.Registration;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
* Managing and reacting on data tree changes in specific netconf node when master writes status to the operational
* data store (e.g. handling lifecycle of slave mount point).
*/
-class NetconfNodeManager implements ClusteredDataTreeChangeListener<Node>, AutoCloseable {
+class NetconfNodeManager implements DataTreeChangeListener<Node>, AutoCloseable {
private static final Logger LOG = LoggerFactory.getLogger(NetconfNodeManager.class);
private final Timeout actorResponseWaitTime;
private final DOMMountPointService mountPointService;
private volatile NetconfTopologySetup setup;
- private volatile ListenerRegistration<NetconfNodeManager> dataChangeListenerRegistration;
+ private volatile Registration dataChangeListenerRegistration;
private volatile RemoteDeviceId id;
@GuardedBy("this")
}
@Override
- public void onDataTreeChanged(final Collection<DataTreeModification<Node>> changes) {
- for (final DataTreeModification<Node> change : changes) {
- final DataObjectModification<Node> rootNode = change.getRootNode();
- final NodeId nodeId = NetconfTopologyUtils.getNodeId(rootNode.getIdentifier());
- switch (rootNode.getModificationType()) {
+ public void onDataTreeChanged(final List<DataTreeModification<Node>> changes) {
+ for (var change : changes) {
+ final var rootNode = change.getRootNode();
+ final NodeId nodeId = NetconfTopologyUtils.getNodeId(rootNode.step());
+ switch (rootNode.modificationType()) {
case SUBTREE_MODIFIED:
- LOG.debug("{}: Operational state for node {} - subtree modified from {} to {}",
- id, nodeId, rootNode.getDataBefore(), rootNode.getDataAfter());
+ LOG.debug("{}: Operational state for node {} - subtree modified from {} to {}", id, nodeId,
+ rootNode.dataBefore(), rootNode.dataAfter());
handleSlaveMountPoint(rootNode);
break;
case WRITE:
- if (rootNode.getDataBefore() != null) {
- LOG.debug("{}: Operational state for node {} updated from {} to {}",
- id, nodeId, rootNode.getDataBefore(), rootNode.getDataAfter());
+ if (rootNode.dataBefore() != null) {
+ LOG.debug("{}: Operational state for node {} updated from {} to {}", id, nodeId,
+ rootNode.dataBefore(), rootNode.dataAfter());
} else {
- LOG.debug("{}: Operational state for node {} created: {}",
- id, nodeId, rootNode.getDataAfter());
+ LOG.debug("{}: Operational state for node {} created: {}", id, nodeId, rootNode.dataAfter());
}
handleSlaveMountPoint(rootNode);
break;
void registerDataTreeChangeListener(final String topologyId, final NodeKey key) {
final InstanceIdentifier<Node> path = NetconfTopologyUtils.createTopologyNodeListPath(key, topologyId);
LOG.debug("{}: Registering data tree change listener on path {}", id, path);
- dataChangeListenerRegistration = setup.getDataBroker().registerDataTreeChangeListener(
- DataTreeIdentifier.create(LogicalDatastoreType.OPERATIONAL, path), this);
+ dataChangeListenerRegistration = setup.getDataBroker().registerTreeChangeListener(
+ DataTreeIdentifier.of(LogicalDatastoreType.OPERATIONAL, path), this);
}
private synchronized void handleSlaveMountPoint(final DataObjectModification<Node> rootNode) {
}
@SuppressWarnings("ConstantConditions")
- final NetconfNode netconfNodeAfter = rootNode.getDataAfter().augmentation(NetconfNode.class);
+ final NetconfNode netconfNodeAfter = rootNode.dataAfter().augmentation(NetconfNode.class);
if (ConnectionStatus.Connected == netconfNodeAfter.getConnectionStatus()) {
lastUpdateCount++;
import com.google.common.util.concurrent.ListenableFuture;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.mdsal.dom.api.DOMMountPointService;
-import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonService;
-import org.opendaylight.mdsal.singleton.common.api.ServiceGroupIdentifier;
+import org.opendaylight.mdsal.singleton.api.ClusterSingletonService;
+import org.opendaylight.mdsal.singleton.api.ServiceGroupIdentifier;
import org.opendaylight.netconf.client.mdsal.api.DeviceActionFactory;
import org.opendaylight.netconf.client.mdsal.api.RemoteDeviceId;
import org.opendaylight.netconf.client.mdsal.api.SchemaResourceManager;
import com.google.common.util.concurrent.MoreExecutors;
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.time.Duration;
-import java.util.Collection;
+import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import javax.annotation.PreDestroy;
import javax.inject.Singleton;
import org.opendaylight.aaa.encrypt.AAAEncryptionService;
import org.opendaylight.controller.cluster.ActorSystemProvider;
-import org.opendaylight.mdsal.binding.api.ClusteredDataTreeChangeListener;
import org.opendaylight.mdsal.binding.api.DataBroker;
-import org.opendaylight.mdsal.binding.api.DataObjectModification;
+import org.opendaylight.mdsal.binding.api.DataTreeChangeListener;
import org.opendaylight.mdsal.binding.api.DataTreeIdentifier;
import org.opendaylight.mdsal.binding.api.DataTreeModification;
import org.opendaylight.mdsal.binding.api.RpcProviderService;
import org.opendaylight.mdsal.common.api.CommitInfo;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.mdsal.dom.api.DOMMountPointService;
-import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceProvider;
-import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceRegistration;
-import org.opendaylight.mdsal.singleton.common.api.ServiceGroupIdentifier;
+import org.opendaylight.mdsal.singleton.api.ClusterSingletonServiceProvider;
+import org.opendaylight.mdsal.singleton.api.ServiceGroupIdentifier;
import org.opendaylight.netconf.client.NetconfClientFactory;
import org.opendaylight.netconf.client.mdsal.api.BaseNetconfSchemas;
import org.opendaylight.netconf.client.mdsal.api.DeviceActionFactory;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.TopologyBuilder;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.TopologyKey;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
-import org.opendaylight.yangtools.concepts.ListenerRegistration;
+import org.opendaylight.yangtools.concepts.Registration;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.common.Uint16;
import org.osgi.service.component.annotations.Activate;
@Component(service = { }, configurationPid = "org.opendaylight.netconf.topology.singleton")
@Designate(ocd = NetconfTopologyManager.Configuration.class)
// Non-final for testing
-public class NetconfTopologyManager implements ClusteredDataTreeChangeListener<Node>, AutoCloseable {
+public class NetconfTopologyManager implements DataTreeChangeListener<Node>, AutoCloseable {
@ObjectClassDefinition
public @interface Configuration {
@AttributeDefinition(min = "1", description = "Name of the Network Topology instance to manage")
private static final Logger LOG = LoggerFactory.getLogger(NetconfTopologyManager.class);
private final Map<InstanceIdentifier<Node>, NetconfTopologyContext> contexts = new ConcurrentHashMap<>();
- private final Map<InstanceIdentifier<Node>, ClusterSingletonServiceRegistration>
- clusterRegistrations = new ConcurrentHashMap<>();
+ private final Map<InstanceIdentifier<Node>, Registration> clusterRegistrations = new ConcurrentHashMap<>();
private final BaseNetconfSchemas baseSchemas;
private final DataBroker dataBroker;
private final NetconfClientConfigurationBuilderFactory builderFactory;
private final SchemaResourceManager resourceManager;
- private ListenerRegistration<NetconfTopologyManager> dataChangeListenerRegistration;
+ private Registration dataChangeListenerRegistration;
private NetconfTopologyRPCProvider rpcProvider;
@Activate
}
@Override
- public void onDataTreeChanged(final Collection<DataTreeModification<Node>> changes) {
- for (final DataTreeModification<Node> change : changes) {
- final DataObjectModification<Node> rootNode = change.getRootNode();
- final InstanceIdentifier<Node> dataModifIdent = change.getRootPath().getRootIdentifier();
- final NodeId nodeId = NetconfTopologyUtils.getNodeId(rootNode.getIdentifier());
- switch (rootNode.getModificationType()) {
+ public void onDataTreeChanged(final List<DataTreeModification<Node>> changes) {
+ for (var change : changes) {
+ final var rootNode = change.getRootNode();
+ final var dataModifIdent = change.getRootPath().path();
+ final NodeId nodeId = NetconfTopologyUtils.getNodeId(rootNode.step());
+ switch (rootNode.modificationType()) {
case SUBTREE_MODIFIED:
LOG.debug("Config for node {} updated", nodeId);
- refreshNetconfDeviceContext(dataModifIdent, rootNode.getDataAfter());
+ refreshNetconfDeviceContext(dataModifIdent, rootNode.dataAfter());
break;
case WRITE:
if (contexts.containsKey(dataModifIdent)) {
LOG.debug("RemoteDevice{{}} was already configured, reconfiguring node...", nodeId);
- refreshNetconfDeviceContext(dataModifIdent, rootNode.getDataAfter());
+ refreshNetconfDeviceContext(dataModifIdent, rootNode.dataAfter());
} else {
LOG.debug("Config for node {} created", nodeId);
- startNetconfDeviceContext(dataModifIdent, rootNode.getDataAfter());
+ startNetconfDeviceContext(dataModifIdent, rootNode.dataAfter());
}
break;
case DELETE:
final Timeout actorResponseWaitTime = Timeout.create(
Duration.ofSeconds(netconfNode.getActorResponseWaitTime().toJava()));
- final ServiceGroupIdentifier serviceGroupIdent =
- ServiceGroupIdentifier.create(instanceIdentifier.toString());
+ final ServiceGroupIdentifier serviceGroupIdent = new ServiceGroupIdentifier(instanceIdentifier.toString());
final NetconfTopologyContext newNetconfTopologyContext = newNetconfTopologyContext(
createSetup(instanceIdentifier, node), serviceGroupIdent, actorResponseWaitTime, deviceActionFactory);
int tries = 3;
while (true) {
try {
- final ClusterSingletonServiceRegistration clusterSingletonServiceRegistration =
+ final var clusterSingletonServiceRegistration =
clusterSingletonServiceProvider.registerClusterSingletonService(newNetconfTopologyContext);
clusterRegistrations.put(instanceIdentifier, clusterSingletonServiceRegistration);
contexts.put(instanceIdentifier, newNetconfTopologyContext);
}
}
- private ListenerRegistration<NetconfTopologyManager> registerDataTreeChangeListener() {
+ private Registration registerDataTreeChangeListener() {
final WriteTransaction wtx = dataBroker.newWriteOnlyTransaction();
// FIXME: how does this play out with lifecycle? In a cluster, someone needs to ensure this call happens, but
// also we need to to make sure config -> oper is properly synchronized. Non-clustered case relies on
}, MoreExecutors.directExecutor());
LOG.debug("Registering datastore listener");
- return dataBroker.registerDataTreeChangeListener(DataTreeIdentifier.create(LogicalDatastoreType.CONFIGURATION,
+ return dataBroker.registerTreeChangeListener(DataTreeIdentifier.of(LogicalDatastoreType.CONFIGURATION,
NetconfTopologyUtils.createTopologyListPath(topologyId).child(Node.class)), this);
}
import akka.dispatch.OnComplete;
import akka.pattern.Patterns;
import akka.util.Timeout;
-import com.google.common.collect.ClassToInstanceMap;
-import com.google.common.collect.ImmutableClassToInstanceMap;
import com.google.common.collect.ImmutableList;
import com.google.common.util.concurrent.FluentFuture;
import com.google.common.util.concurrent.SettableFuture;
import java.util.Collection;
import org.opendaylight.mdsal.dom.api.DOMActionResult;
import org.opendaylight.mdsal.dom.api.DOMActionService;
-import org.opendaylight.mdsal.dom.api.DOMActionServiceExtension;
import org.opendaylight.mdsal.dom.api.DOMDataTreeIdentifier;
import org.opendaylight.mdsal.dom.spi.SimpleDOMActionResult;
import org.opendaylight.netconf.client.mdsal.api.RemoteDeviceId;
return FluentFuture.from(settableFuture);
}
-
- @Override
- public ClassToInstanceMap<DOMActionServiceExtension> getExtensions() {
- return ImmutableClassToInstanceMap.of();
- }
}
import akka.actor.ActorRef;
import akka.pattern.Patterns;
import akka.util.Timeout;
-import com.google.common.collect.ClassToInstanceMap;
-import com.google.common.collect.ImmutableClassToInstanceMap;
-import org.opendaylight.mdsal.dom.api.DOMDataBrokerExtension;
import org.opendaylight.mdsal.dom.api.DOMDataTreeReadTransaction;
import org.opendaylight.mdsal.dom.api.DOMDataTreeReadWriteTransaction;
import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteTransaction;
import org.opendaylight.mdsal.dom.api.DOMTransactionChain;
-import org.opendaylight.mdsal.dom.api.DOMTransactionChainListener;
import org.opendaylight.mdsal.dom.spi.PingPongMergingDOMDataBroker;
import org.opendaylight.netconf.client.mdsal.api.RemoteDeviceId;
import org.opendaylight.netconf.topology.singleton.impl.tx.ProxyReadTransaction;
}
@Override
- public DOMTransactionChain createTransactionChain(final DOMTransactionChainListener listener) {
+ public DOMTransactionChain createTransactionChain() {
throw new UnsupportedOperationException(id + ": Transaction chains not supported for netconf mount point");
}
-
- @Override
- public ClassToInstanceMap<DOMDataBrokerExtension> getExtensions() {
- return ImmutableClassToInstanceMap.of();
- }
}
import org.opendaylight.netconf.topology.singleton.messages.rpc.InvokeRpcMessage;
import org.opendaylight.netconf.topology.singleton.messages.rpc.InvokeRpcMessageReply;
import org.opendaylight.netconf.topology.singleton.messages.transactions.EmptyResultResponse;
-import org.opendaylight.yangtools.concepts.ListenerRegistration;
+import org.opendaylight.yangtools.concepts.Registration;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.RpcError;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
}
@Override
- public <T extends DOMRpcAvailabilityListener> ListenerRegistration<T> registerRpcListener(final T listener) {
+ public Registration registerRpcListener(final DOMRpcAvailabilityListener listener) {
// NOOP, only proxy
throw new UnsupportedOperationException("RegisterRpcListener: DOMRpc service not working in cluster.");
}
import org.opendaylight.controller.cluster.schema.provider.RemoteYangTextSourceProvider;
import org.opendaylight.controller.cluster.schema.provider.impl.YangTextSchemaSourceSerializationProxy;
import org.opendaylight.netconf.topology.singleton.messages.YangTextSchemaSourceRequest;
-import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
+import org.opendaylight.yangtools.yang.model.api.source.SourceIdentifier;
import scala.concurrent.ExecutionContext;
import scala.concurrent.Future;
import org.opendaylight.netconf.topology.singleton.messages.transactions.NewReadTransactionRequest;
import org.opendaylight.netconf.topology.singleton.messages.transactions.NewReadWriteTransactionRequest;
import org.opendaylight.netconf.topology.singleton.messages.transactions.NewWriteTransactionRequest;
+import org.opendaylight.yangtools.concepts.Registration;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
+import org.opendaylight.yangtools.yang.model.api.source.SourceIdentifier;
+import org.opendaylight.yangtools.yang.model.api.source.YangTextSource;
import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier.Absolute;
import org.opendaylight.yangtools.yang.model.repo.api.EffectiveModelContextFactory;
import org.opendaylight.yangtools.yang.model.repo.api.SchemaRepository;
-import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
-import org.opendaylight.yangtools.yang.model.repo.api.YangTextSchemaSource;
import org.opendaylight.yangtools.yang.model.repo.spi.PotentialSchemaSource;
-import org.opendaylight.yangtools.yang.model.repo.spi.SchemaSourceRegistration;
import org.opendaylight.yangtools.yang.model.repo.spi.SchemaSourceRegistry;
public class NetconfNodeActor extends AbstractUntypedActor {
private NetconfDataTreeService netconfService;
//readTxActor can be shared
private ActorRef readTxActor;
- private List<SchemaSourceRegistration<YangTextSchemaSource>> registeredSchemas;
+ private List<Registration> registeredSchemas;
public static Props props(final NetconfTopologySetup setup, final RemoteDeviceId id,
final Timeout actorResponseWaitTime, final DOMMountPointService mountPointService) {
}
private void sendYangTextSchemaSourceProxy(final SourceIdentifier sourceIdentifier, final ActorRef sender) {
- final var schemaSourceFuture = schemaRepository.getSchemaSource(sourceIdentifier, YangTextSchemaSource.class);
- Futures.addCallback(schemaSourceFuture, new FutureCallback<>() {
- @Override
- public void onSuccess(final YangTextSchemaSource yangTextSchemaSource) {
- try {
- LOG.debug("{}: getSchemaSource for {} succeeded", id, sourceIdentifier);
- sender.tell(new YangTextSchemaSourceSerializationProxy(yangTextSchemaSource), getSelf());
- } catch (IOException e) {
- sender.tell(new Failure(e), getSelf());
+ Futures.addCallback(schemaRepository.getSchemaSource(sourceIdentifier, YangTextSource.class),
+ new FutureCallback<>() {
+ @Override
+ public void onSuccess(final YangTextSource yangTextSchemaSource) {
+ try {
+ LOG.debug("{}: getSchemaSource for {} succeeded", id, sourceIdentifier);
+ sender.tell(new YangTextSchemaSourceSerializationProxy(yangTextSchemaSource), getSelf());
+ } catch (IOException e) {
+ sender.tell(new Failure(e), getSelf());
+ }
}
- }
- @Override
- public void onFailure(final Throwable throwable) {
- LOG.debug("{}: getSchemaSource for {} failed", id, sourceIdentifier, throwable);
- sender.tell(new Failure(throwable), getSelf());
- }
- }, MoreExecutors.directExecutor());
+ @Override
+ public void onFailure(final Throwable throwable) {
+ LOG.debug("{}: getSchemaSource for {} failed", id, sourceIdentifier, throwable);
+ sender.tell(new Failure(throwable), getSelf());
+ }
+ }, MoreExecutors.directExecutor());
}
private void invokeSlaveRpc(final QName qname, final NormalizedNodeMessage normalizedNodeMessage,
registeredSchemas = sourceIdentifiers.stream()
.map(sourceId ->
schemaRegistry.registerSchemaSource(remoteProvider, PotentialSchemaSource.create(sourceId,
- YangTextSchemaSource.class, PotentialSchemaSource.Costs.REMOTE_IO.getValue())))
+ YangTextSource.class, PotentialSchemaSource.Costs.REMOTE_IO.getValue())))
.collect(Collectors.toList());
return schemaRepository.createEffectiveModelContextFactory();
private void resolveSchemaContext(final EffectiveModelContextFactory schemaContextFactory,
final SlaveSalFacade localSlaveSalManager, final ActorRef masterReference, final int tries) {
- final ListenableFuture<EffectiveModelContext> schemaContextFuture =
- schemaContextFactory.createEffectiveModelContext(sourceIdentifiers);
+ final var schemaContextFuture = schemaContextFactory.createEffectiveModelContext(sourceIdentifiers);
Futures.addCallback(schemaContextFuture, new FutureCallback<>() {
@Override
public void onSuccess(final EffectiveModelContext result) {
// Make sure the slaveSalManager instance hasn't changed since we initiated the schema context
// resolution.
if (slaveSalManager == localSlaveSalManager) {
- LOG.info("{}: Schema context resolved: {} - registering slave mount point",
- id, result.getModules());
+ LOG.info("{}: Schema context resolved: {} - registering slave mount point", id,
+ result.getModules());
final var actorSystem = setup.getActorSystem();
final var rpcProxy = new ProxyDOMRpcService(actorSystem, masterReference, id,
actorResponseWaitTime);
private void closeSchemaSourceRegistrations() {
if (registeredSchemas != null) {
- registeredSchemas.forEach(SchemaSourceRegistration::close);
+ registeredSchemas.forEach(Registration::close);
registeredSchemas = null;
}
}
import com.google.common.util.concurrent.SettableFuture;
import java.util.Objects;
import java.util.Optional;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.mdsal.common.api.CommitInfo;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.mdsal.common.api.ReadFailedException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import scala.concurrent.ExecutionContext;
-import scala.concurrent.Future;
/**
* ProxyTransactionFacade implementation that interfaces with an actor.
class ActorProxyTransactionFacade implements ProxyTransactionFacade {
private static final Logger LOG = LoggerFactory.getLogger(ActorProxyTransactionFacade.class);
+ private final SettableFuture<CommitInfo> settableFuture = SettableFuture.create();
+ private final @NonNull FluentFuture<CommitInfo> fluentFuture = FluentFuture.from(settableFuture);
private final ActorRef masterTxActor;
private final RemoteDeviceId id;
private final ExecutionContext executionContext;
return id;
}
+ @Override
+ public FluentFuture<?> completionFuture() {
+ return fluentFuture;
+ }
+
@Override
public boolean cancel() {
LOG.debug("{}: Cancel via actor {}", id, masterTxActor);
- final Future<Object> future = Patterns.ask(masterTxActor, new CancelRequest(), askTimeout);
-
- future.onComplete(new OnComplete<>() {
+ Patterns.ask(masterTxActor, new CancelRequest(), askTimeout).onComplete(new OnComplete<>() {
@Override
public void onComplete(final Throwable failure, final Object response) {
if (failure != null) {
final YangInstanceIdentifier path) {
LOG.debug("{}: Read {} {} via actor {}", id, store, path, masterTxActor);
- final Future<Object> future = Patterns.ask(masterTxActor, new ReadRequest(store, path), askTimeout);
-
- final SettableFuture<Optional<NormalizedNode>> settableFuture = SettableFuture.create();
- future.onComplete(new OnComplete<>() {
+ final var future = SettableFuture.<Optional<NormalizedNode>>create();
+ Patterns.ask(masterTxActor, new ReadRequest(store, path), askTimeout).onComplete(new OnComplete<>() {
@Override
public void onComplete(final Throwable failure, final Object response) {
if (failure != null) {
final Throwable processedFailure = processFailure(failure);
if (processedFailure instanceof ReadFailedException) {
- settableFuture.setException(processedFailure);
+ future.setException(processedFailure);
} else {
- settableFuture.setException(new ReadFailedException("Read of store " + store + " path " + path
+ future.setException(new ReadFailedException("Read of store " + store + " path " + path
+ " failed", processedFailure));
}
return;
LOG.debug("{}: Read {} {} succeeded: {}", id, store, path, response);
if (response instanceof EmptyReadResponse) {
- settableFuture.set(Optional.empty());
+ future.set(Optional.empty());
return;
}
if (response instanceof NormalizedNodeMessage data) {
- settableFuture.set(Optional.of(data.getNode()));
+ future.set(Optional.of(data.getNode()));
}
}
}, executionContext);
- return FluentFuture.from(settableFuture);
+ return FluentFuture.from(future);
}
@Override
public FluentFuture<Boolean> exists(final LogicalDatastoreType store, final YangInstanceIdentifier path) {
LOG.debug("{}: Exists {} {} via actor {}", id, store, path, masterTxActor);
- final Future<Object> future = Patterns.ask(masterTxActor, new ExistsRequest(store, path), askTimeout);
+ final var future = SettableFuture.<Boolean>create();
- final SettableFuture<Boolean> settableFuture = SettableFuture.create();
- future.onComplete(new OnComplete<>() {
+ Patterns.ask(masterTxActor, new ExistsRequest(store, path), askTimeout).onComplete(new OnComplete<>() {
@Override
public void onComplete(final Throwable failure, final Object response) {
if (failure != null) {
final Throwable processedFailure = processFailure(failure);
if (processedFailure instanceof ReadFailedException) {
- settableFuture.setException(processedFailure);
+ future.setException(processedFailure);
} else {
- settableFuture.setException(new ReadFailedException("Exists of store " + store + " path " + path
+ future.setException(new ReadFailedException("Exists of store " + store + " path " + path
+ " failed", processedFailure));
}
return;
LOG.debug("{}: Exists {} {} succeeded: {}", id, store, path, response);
- settableFuture.set((Boolean) response);
+ future.set((Boolean) response);
}
}, executionContext);
- return FluentFuture.from(settableFuture);
+ return FluentFuture.from(future);
}
@Override
public FluentFuture<? extends CommitInfo> commit() {
LOG.debug("{}: Commit via actor {}", id, masterTxActor);
- final Future<Object> future = Patterns.ask(masterTxActor, new SubmitRequest(), askTimeout);
-
- final SettableFuture<CommitInfo> settableFuture = SettableFuture.create();
- future.onComplete(new OnComplete<>() {
+ Patterns.ask(masterTxActor, new SubmitRequest(), askTimeout).onComplete(new OnComplete<>() {
@Override
public void onComplete(final Throwable failure, final Object response) {
if (failure != null) {
class FailedProxyTransactionFacade implements ProxyTransactionFacade {
private static final Logger LOG = LoggerFactory.getLogger(FailedProxyTransactionFacade.class);
+ private final @NonNull FluentFuture<CommitInfo> completionFuture;
private final RemoteDeviceId id;
private final Throwable failure;
FailedProxyTransactionFacade(final RemoteDeviceId id, final Throwable failure) {
this.id = Objects.requireNonNull(id);
this.failure = Objects.requireNonNull(failure);
+ completionFuture = FluentFutures.immediateFailedFluentFuture(
+ failure instanceof TransactionCommitFailedException commitFailed ? commitFailed
+ : new TransactionCommitFailedException("commit", failure));
}
@Override
return id;
}
+ @Override
+ public FluentFuture<?> completionFuture() {
+ return completionFuture;
+ }
+
@Override
public boolean cancel() {
return true;
}
@Override
- public @NonNull FluentFuture<? extends @NonNull CommitInfo> commit() {
+ public FluentFuture<CommitInfo> commit() {
LOG.debug("{}: Commit - failure", id, failure);
- final TransactionCommitFailedException txCommitEx;
- if (failure instanceof TransactionCommitFailedException) {
- txCommitEx = (TransactionCommitFailedException) failure;
- } else {
- txCommitEx = new TransactionCommitFailedException("commit", failure);
- }
- return FluentFutures.immediateFailedFluentFuture(txCommitEx);
+ return completionFuture;
}
}
public class ProxyReadWriteTransaction implements DOMDataTreeReadWriteTransaction {
private static final Logger LOG = LoggerFactory.getLogger(ProxyReadWriteTransaction.class);
- private final RemoteDeviceId id;
- private final AtomicBoolean opened = new AtomicBoolean(true);
-
@GuardedBy("queuedTxOperations")
private final List<Consumer<ProxyTransactionFacade>> queuedTxOperations = new ArrayList<>();
+ private final SettableFuture<CommitInfo> settableFuture = SettableFuture.create();
+ private final @NonNull FluentFuture<CommitInfo> completionFuture = FluentFuture.from(settableFuture);
+ private final AtomicBoolean opened = new AtomicBoolean(true);
+ private final RemoteDeviceId id;
private volatile ProxyTransactionFacade transactionFacade;
}, executionContext);
}
+ @Override
+ public FluentFuture<?> completionFuture() {
+ return completionFuture;
+ }
+
@Override
public boolean cancel() {
if (!opened.compareAndSet(true, false)) {
}
@Override
- public @NonNull FluentFuture<? extends @NonNull CommitInfo> commit() {
+ public FluentFuture<CommitInfo> commit() {
Preconditions.checkState(opened.compareAndSet(true, false), "%s: Transaction is already closed", id);
LOG.debug("{}: Commit", id);
- final SettableFuture<CommitInfo> returnFuture = SettableFuture.create();
- processTransactionOperation(facade -> returnFuture.setFuture(facade.commit()));
- return FluentFuture.from(returnFuture);
+ processTransactionOperation(facade -> settableFuture.setFuture(facade.commit()));
+ return completionFuture;
}
@Override
import java.time.Duration;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.mdsal.binding.api.DataBroker;
-import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceProvider;
+import org.opendaylight.mdsal.singleton.api.ClusterSingletonServiceProvider;
import org.opendaylight.netconf.client.NetconfClientFactory;
import org.opendaylight.netconf.client.mdsal.NetconfDevice;
import org.opendaylight.netconf.client.mdsal.api.BaseNetconfSchemas;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.TopologyKey;
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.DataObjectStep;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.IdentifiableItem;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.PathArgument;
+import org.opendaylight.yangtools.yang.binding.KeyStep;
import org.opendaylight.yangtools.yang.binding.KeyedInstanceIdentifier;
import org.opendaylight.yangtools.yang.common.Decimal64;
import org.opendaylight.yangtools.yang.common.ErrorSeverity;
return masterAddress.replace("//", "") + "_" + name;
}
- public static @NonNull NodeId getNodeId(final PathArgument pathArgument) {
- if (pathArgument instanceof IdentifiableItem<?, ?> identifiableItem
- && identifiableItem.getKey() instanceof NodeKey nodeKey) {
+ public static @NonNull NodeId getNodeId(final DataObjectStep<?> pathArgument) {
+ if (pathArgument instanceof KeyStep identifiableItem && identifiableItem.key() instanceof NodeKey nodeKey) {
return nodeKey.getNodeId();
}
throw new IllegalStateException("Unable to create NodeId from: " + pathArgument);
import org.opendaylight.mdsal.dom.api.DOMDataBroker;
import org.opendaylight.netconf.client.mdsal.api.RemoteDeviceServices;
import org.opendaylight.netconf.dom.api.NetconfDataTreeService;
-import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
+import org.opendaylight.yangtools.yang.model.api.source.SourceIdentifier;
/**
* Master sends this message to the own actor to set necessary parameters.
* 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.netconf.topology.singleton.messages;
import akka.actor.ActorRef;
import java.io.Serial;
import java.io.Serializable;
import java.util.List;
-import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
+import org.opendaylight.yangtools.yang.model.api.source.SourceIdentifier;
/**
* Master sends the message to slave with necessary parameters for creating slave mount point.
private final List<SourceIdentifier> allSourceIdentifiers;
private final ActorRef masterActorRef;
- public RegisterMountPoint(final List<SourceIdentifier> allSourceIdentifiers, ActorRef masterActorRef) {
+ public RegisterMountPoint(final List<SourceIdentifier> allSourceIdentifiers, final ActorRef masterActorRef) {
this.allSourceIdentifiers = allSourceIdentifiers;
this.masterActorRef = masterActorRef;
}
* 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.netconf.topology.singleton.messages;
-import java.io.Serial;
import java.io.Serializable;
-import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
+import org.opendaylight.yangtools.yang.model.api.source.SourceIdentifier;
/**
* Slave sends message to master when tries to resolve schema with particular sourceIdentifier (proxy call).
* Master responds with resolved schema source.
*/
public class YangTextSchemaSourceRequest implements Serializable {
- @Serial
+ @java.io.Serial
private static final long serialVersionUID = 1L;
private final SourceIdentifier sourceIdentifier;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
import com.google.common.util.concurrent.FluentFuture;
+import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.SettableFuture;
import org.mockito.junit.MockitoJUnitRunner;
import org.opendaylight.aaa.encrypt.AAAEncryptionService;
import org.opendaylight.mdsal.binding.api.DataBroker;
-import org.opendaylight.mdsal.binding.api.DataObjectModification;
import org.opendaylight.mdsal.binding.api.DataTreeIdentifier;
-import org.opendaylight.mdsal.binding.api.DataTreeModification;
import org.opendaylight.mdsal.binding.api.ReadTransaction;
import org.opendaylight.mdsal.binding.api.RpcProviderService;
-import org.opendaylight.mdsal.binding.api.Transaction;
import org.opendaylight.mdsal.binding.api.TransactionChain;
-import org.opendaylight.mdsal.binding.api.TransactionChainListener;
import org.opendaylight.mdsal.binding.api.WriteTransaction;
import org.opendaylight.mdsal.binding.dom.adapter.test.AbstractConcurrentDataBrokerTest;
import org.opendaylight.mdsal.binding.dom.codec.api.BindingNormalizedNodeSerializer;
import org.opendaylight.mdsal.dom.broker.DOMRpcRouter;
import org.opendaylight.mdsal.dom.spi.DefaultDOMRpcResult;
import org.opendaylight.mdsal.dom.spi.FixedDOMSchemaService;
-import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceProvider;
-import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceRegistration;
-import org.opendaylight.mdsal.singleton.common.api.ServiceGroupIdentifier;
-import org.opendaylight.mdsal.singleton.dom.impl.DOMClusterSingletonServiceProviderImpl;
+import org.opendaylight.mdsal.eos.dom.simple.SimpleDOMEntityOwnershipService;
+import org.opendaylight.mdsal.singleton.api.ClusterSingletonServiceProvider;
+import org.opendaylight.mdsal.singleton.api.ServiceGroupIdentifier;
+import org.opendaylight.mdsal.singleton.impl.EOSClusterSingletonServiceProvider;
import org.opendaylight.netconf.api.CapabilityURN;
import org.opendaylight.netconf.client.NetconfClientFactory;
import org.opendaylight.netconf.client.mdsal.NetconfDeviceCapabilities;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.binding.KeyedInstanceIdentifier;
import org.opendaylight.yangtools.yang.binding.YangModuleInfo;
+import org.opendaylight.yangtools.yang.common.Empty;
import org.opendaylight.yangtools.yang.common.ErrorTag;
import org.opendaylight.yangtools.yang.common.ErrorType;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.RpcDefinition;
-import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
-import org.opendaylight.yangtools.yang.model.repo.api.YangTextSchemaSource;
+import org.opendaylight.yangtools.yang.model.api.source.SourceIdentifier;
+import org.opendaylight.yangtools.yang.model.api.source.YangTextSource;
import org.opendaylight.yangtools.yang.model.repo.spi.PotentialSchemaSource;
+import org.opendaylight.yangtools.yang.model.spi.source.DelegatedYangTextSource;
import org.opendaylight.yangtools.yang.parser.impl.DefaultYangParserFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
private final DOMMountPointService masterMountPointService = new DOMMountPointServiceImpl();
private Rpcs.Normalized deviceRpcService;
- private DOMClusterSingletonServiceProviderImpl masterClusterSingletonServiceProvider;
+ private EOSClusterSingletonServiceProvider masterClusterSingletonServiceProvider;
private DataBroker masterDataBroker;
private DOMDataBroker deviceDOMDataBroker;
private ActorSystem masterSystem;
@Mock
private ClusterSingletonServiceProvider mockSlaveClusterSingletonServiceProvider;
@Mock
- private ClusterSingletonServiceRegistration mockSlaveClusterSingletonServiceReg;
+ private Registration mockSlaveClusterSingletonServiceReg;
@Mock
private DOMMountPointListener slaveMountPointListener;
private final DOMMountPointService slaveMountPointService = new DOMMountPointServiceImpl();
deviceSchemaContext = BindingRuntimeHelpers.createEffectiveModel(Top.class);
- final var router = new DOMRpcRouter(FixedDOMSchemaService.of(deviceSchemaContext));
+ final var router = new DOMRpcRouter(new FixedDOMSchemaService(deviceSchemaContext));
putTopRpcSchemaPath = findRpcDefinition("put-top").getQName();
getTopRpcSchemaPath = findRpcDefinition("get-top").getQName();
- router.getRpcProviderService().registerRpcImplementation(topRpcImplementation,
+ router.rpcProviderService().registerRpcImplementation(topRpcImplementation,
DOMRpcIdentifier.create(putTopRpcSchemaPath), DOMRpcIdentifier.create(getTopRpcSchemaPath));
- final var rpcService = router.getRpcService();
+ final var rpcService = router.rpcService();
deviceRpcService = () -> rpcService;
builderFactory = new NetconfClientConfigurationBuilderFactoryImpl(mockEncryptionService, credentialProvider,
masterSystem = ActorSystem.create(ACTOR_SYSTEM_NAME, ConfigFactory.load().getConfig("Master"));
- masterClusterSingletonServiceProvider = new DOMClusterSingletonServiceProviderImpl();
- masterClusterSingletonServiceProvider.initializeProvider();
+ masterClusterSingletonServiceProvider = new EOSClusterSingletonServiceProvider(
+ new SimpleDOMEntityOwnershipService());
final var resources = resourceManager.getSchemaResources(TEST_DEFAULT_SUBDIR, "test");
resources.getSchemaRegistry().registerSchemaSource(
- id -> Futures.immediateFuture(YangTextSchemaSource.delegateForCharSource(id,
- topModuleInfo.getYangTextCharSource())),
+ id -> Futures.immediateFuture(new DelegatedYangTextSource(id, topModuleInfo.getYangTextCharSource())),
PotentialSchemaSource.create(new SourceIdentifier(TOP_MODULE_NAME,
topModuleInfo.getName().getRevision().map(Revision::toString).orElse(null)),
- YangTextSchemaSource.class, 1));
+ YangTextSource.class, 1));
masterNetconfTopologyManager = new NetconfTopologyManager(BASE_SCHEMAS, masterDataBroker,
masterClusterSingletonServiceProvider, mockTimer, schemaAssembler, masterSystem,
verifyTopologyNodesCreated(slaveDataBroker);
- slaveTxChain = slaveDataBroker.createTransactionChain(new TransactionChainListener() {
+ slaveTxChain = slaveDataBroker.createTransactionChain();
+ slaveTxChain.addCallback(new FutureCallback<Empty>() {
@Override
- public void onTransactionChainSuccessful(final TransactionChain chain) {
+ public void onSuccess(final Empty result) {
// No-op
}
@Override
- public void onTransactionChainFailed(final TransactionChain chain, final Transaction transaction,
- final Throwable cause) {
+ public void onFailure(final Throwable cause) {
LOG.error("Slave transaction chain failed", cause);
}
});
// Since the master and slave use separate DataBrokers we need to copy the master's oper node to the slave.
// This is essentially what happens in a clustered environment but we'll use a DTCL here.
- masterDataBroker.registerDataTreeChangeListener(
- DataTreeIdentifier.create(LogicalDatastoreType.OPERATIONAL, NODE_INSTANCE_ID), changes -> {
+ masterDataBroker.registerTreeChangeListener(
+ DataTreeIdentifier.of(LogicalDatastoreType.OPERATIONAL, NODE_INSTANCE_ID), changes -> {
final WriteTransaction slaveTx = slaveTxChain.newWriteOnlyTransaction();
- for (DataTreeModification<Node> dataTreeModification : changes) {
- DataObjectModification<Node> rootNode = dataTreeModification.getRootNode();
- InstanceIdentifier<Node> path = dataTreeModification.getRootPath().getRootIdentifier();
- switch (rootNode.getModificationType()) {
+ for (var dataTreeModification : changes) {
+ var rootNode = dataTreeModification.getRootNode();
+ var path = dataTreeModification.getRootPath().path();
+ switch (rootNode.modificationType()) {
case WRITE:
case SUBTREE_MODIFIED:
- slaveTx.merge(LogicalDatastoreType.OPERATIONAL, path, rootNode.getDataAfter());
+ slaveTx.merge(LogicalDatastoreType.OPERATIONAL, path, rootNode.dataAfter());
break;
case DELETE:
slaveTx.delete(LogicalDatastoreType.OPERATIONAL, path);
return getMountPointService(mountPoint, DOMActionService.class);
}
+ @SuppressWarnings({ "rawtypes", "unchecked" })
private static <T extends DOMService> T getMountPointService(final DOMMountPoint mountPoint,
final Class<T> serviceClass) {
- return mountPoint.getService(serviceClass).orElseThrow();
+ return (T) mountPoint.getService((Class) serviceClass).orElseThrow();
}
private DOMMountPoint awaitMountPoint(final DOMMountPointService mountPointService) {
import org.opendaylight.netconf.topology.singleton.messages.RegisterMountPoint;
import org.opendaylight.netconf.topology.singleton.messages.UnregisterSlaveMountPoint;
import org.opendaylight.yangtools.concepts.ObjectRegistration;
+import org.opendaylight.yangtools.concepts.Registration;
import org.opendaylight.yangtools.util.concurrent.FluentFutures;
import org.opendaylight.yangtools.yang.common.ErrorType;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+import org.opendaylight.yangtools.yang.model.api.source.SourceIdentifier;
+import org.opendaylight.yangtools.yang.model.api.source.YangTextSource;
import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier.Absolute;
import org.opendaylight.yangtools.yang.model.repo.api.EffectiveModelContextFactory;
import org.opendaylight.yangtools.yang.model.repo.api.MissingSchemaSourceException;
import org.opendaylight.yangtools.yang.model.repo.api.SchemaRepository;
import org.opendaylight.yangtools.yang.model.repo.api.SchemaResolutionException;
-import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
-import org.opendaylight.yangtools.yang.model.repo.api.YangTextSchemaSource;
import org.opendaylight.yangtools.yang.model.repo.spi.PotentialSchemaSource;
-import org.opendaylight.yangtools.yang.model.repo.spi.SchemaSourceRegistration;
import org.opendaylight.yangtools.yang.model.repo.spi.SchemaSourceRegistry;
+import org.opendaylight.yangtools.yang.model.spi.source.DelegatedYangTextSource;
import org.opendaylight.yangtools.yang.parser.repo.SharedSchemaRepository;
import org.opendaylight.yangtools.yang.parser.rfc7950.repo.TextToIRTransformer;
import scala.concurrent.Await;
@Mock
private NetconfDataTreeService netconfService;
@Mock
- private SchemaSourceRegistration<?> mockSchemaSourceReg1;
+ private Registration mockSchemaSourceReg1;
@Mock
- private SchemaSourceRegistration<?> mockSchemaSourceReg2;
+ private Registration mockSchemaSourceReg2;
@Mock
private SchemaSourceRegistry mockRegistry;
@Mock
doReturn(mockSchemaSourceReg1).when(mockRegistry).registerSchemaSource(any(), withSourceId(SOURCE_IDENTIFIER1));
- final SchemaSourceRegistration<?> newMockSchemaSourceReg = mock(SchemaSourceRegistration.class);
+ final var newMockSchemaSourceReg = mock(Registration.class);
final EffectiveModelContextFactory newMockSchemaContextFactory = mock(EffectiveModelContextFactory.class);
doReturn(Futures.immediateFuture(mockSchemaContext))
// Test unrecoverable failure.
- doReturn(Futures.immediateFailedFuture(new SchemaResolutionException("mock")))
+ doReturn(Futures.immediateFailedFuture(
+ new SchemaResolutionException("mock", new SourceIdentifier("foo"), null)))
.when(mockSchemaContextFactory).createEffectiveModelContext(anyCollection());
slaveRef.tell(new RegisterMountPoint(ImmutableList.of(SOURCE_IDENTIFIER1, SOURCE_IDENTIFIER2),
reset(mockSchemaSourceReg1, mockSchemaSourceReg2);
- doReturn(Futures.immediateFailedFuture(new SchemaResolutionException("mock",
+ doReturn(Futures.immediateFailedFuture(new SchemaResolutionException("mock", new SourceIdentifier("foo"),
new AskTimeoutException("timeout"))))
.doReturn(Futures.immediateFuture(mockSchemaContext))
.when(mockSchemaContextFactory).createEffectiveModelContext(anyCollection());
slaveRef.tell(new RegisterMountPoint(ImmutableList.of(SOURCE_IDENTIFIER1, SOURCE_IDENTIFIER2),
masterRef), testKit.getRef());
- future.setException(new SchemaResolutionException("mock", new AskTimeoutException("timeout")));
+ future.setException(new SchemaResolutionException("mock", new SourceIdentifier("foo"),
+ new AskTimeoutException("timeout")));
}).start();
return future;
}).when(mockSchemaContextFactory).createEffectiveModelContext(anyCollection());
final ProxyYangTextSourceProvider proxyYangProvider =
new ProxyYangTextSourceProvider(masterRef, system.dispatcher(), TIMEOUT);
- final YangTextSchemaSource yangTextSchemaSource = YangTextSchemaSource.delegateForCharSource(sourceIdentifier,
- CharSource.wrap("YANG"));
+ final YangTextSource yangTextSchemaSource = new DelegatedYangTextSource(sourceIdentifier,
+ CharSource.wrap("YANG"));
// Test success.
- final SchemaSourceRegistration<YangTextSchemaSource> schemaSourceReg = masterSchemaRepository
- .registerSchemaSource(id -> Futures.immediateFuture(yangTextSchemaSource),
- PotentialSchemaSource.create(sourceIdentifier, YangTextSchemaSource.class, 1));
+ final var schemaSourceReg = masterSchemaRepository.registerSchemaSource(
+ id -> Futures.immediateFuture(yangTextSchemaSource),
+ PotentialSchemaSource.create(sourceIdentifier, YangTextSource.class, 1));
final Future<YangTextSchemaSourceSerializationProxy> resolvedSchemaFuture =
proxyYangProvider.getYangTextSchemaSource(sourceIdentifier);
final YangTextSchemaSourceSerializationProxy success = Await.result(resolvedSchemaFuture, TIMEOUT.duration());
- assertEquals(sourceIdentifier, success.getRepresentation().getIdentifier());
+ assertEquals(sourceIdentifier, success.getRepresentation().sourceId());
assertEquals("YANG", success.getRepresentation().read());
// Test missing source failure.
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.NodeBuilder;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeKey;
-import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.concepts.ObjectRegistration;
+import org.opendaylight.yangtools.concepts.Registration;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.common.Uint16;
+import org.opendaylight.yangtools.yang.model.api.source.SourceIdentifier;
+import org.opendaylight.yangtools.yang.model.api.source.YangTextSource;
import org.opendaylight.yangtools.yang.model.repo.api.EffectiveModelContextFactory;
-import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
-import org.opendaylight.yangtools.yang.model.repo.api.YangTextSchemaSource;
import org.opendaylight.yangtools.yang.model.repo.spi.PotentialSchemaSource;
+import org.opendaylight.yangtools.yang.model.spi.source.DelegatedYangTextSource;
import org.opendaylight.yangtools.yang.parser.repo.SharedSchemaRepository;
import org.opendaylight.yangtools.yang.parser.rfc7950.repo.TextToIRTransformer;
SOURCE_IDENTIFIERS.stream().map(
sourceId -> masterSchemaRepository.registerSchemaSource(
- id -> Futures.immediateFuture(YangTextSchemaSource.delegateForCharSource(id,
+ id -> Futures.immediateFuture(new DelegatedYangTextSource(id,
CharSource.wrap(yangTemplate.replaceAll("ID", id.name().getLocalName())))),
- PotentialSchemaSource.create(sourceId, YangTextSchemaSource.class, 1)))
+ PotentialSchemaSource.create(sourceId, YangTextSource.class, 1)))
.collect(Collectors.toList());
NetconfTopologySetup masterSetup = NetconfTopologySetup.builder()
public void testSlaveMountPointRegistration() throws InterruptedException, ExecutionException, TimeoutException {
initializeMaster();
- ListenerRegistration<?> mockListenerReg = mock(ListenerRegistration.class);
- doReturn(mockListenerReg).when(mockDataBroker).registerDataTreeChangeListener(any(), any());
+ Registration mockListenerReg = mock(Registration.class);
+ doReturn(mockListenerReg).when(mockDataBroker).registerTreeChangeListener(any(), any());
final NodeId nodeId = new NodeId("device");
final NodeKey nodeKey = new NodeKey(nodeId);
nodeKey, topologyId);
netconfNodeManager.registerDataTreeChangeListener(topologyId, nodeKey);
- verify(mockDataBroker).registerDataTreeChangeListener(any(), eq(netconfNodeManager));
+ verify(mockDataBroker).registerTreeChangeListener(any(), eq(netconfNodeManager));
// Invoke onDataTreeChanged with a NetconfNode WRITE to simulate the master writing the operational state to
// Connected. Expect the slave mount point created and registered.
final Node node = new NodeBuilder().setNodeId(nodeId).addAugmentation(netconfNode).build();
DataObjectModification<Node> mockDataObjModification = mock(DataObjectModification.class);
- doReturn(Iterables.getLast(nodeListPath.getPathArguments())).when(mockDataObjModification).getIdentifier();
- doReturn(WRITE).when(mockDataObjModification).getModificationType();
- doReturn(node).when(mockDataObjModification).getDataAfter();
+ doReturn(Iterables.getLast(nodeListPath.getPathArguments())).when(mockDataObjModification).step();
+ doReturn(WRITE).when(mockDataObjModification).modificationType();
+ doReturn(node).when(mockDataObjModification).dataAfter();
netconfNodeManager.onDataTreeChanged(List.of(
- new NetconfTopologyManagerTest.CustomTreeModification(DataTreeIdentifier.create(
+ new NetconfTopologyManagerTest.CustomTreeModification(DataTreeIdentifier.of(
LogicalDatastoreType.OPERATIONAL, nodeListPath), mockDataObjModification)));
verify(mockMountPointBuilder, timeout(5000)).register();
// Notify that the NetconfNode operational state was deleted. Expect the slave mount point closed.
- doReturn(DELETE).when(mockDataObjModification).getModificationType();
+ doReturn(DELETE).when(mockDataObjModification).modificationType();
netconfNodeManager.onDataTreeChanged(List.of(
- new NetconfTopologyManagerTest.CustomTreeModification(DataTreeIdentifier.create(
+ new NetconfTopologyManagerTest.CustomTreeModification(DataTreeIdentifier.of(
LogicalDatastoreType.OPERATIONAL, nodeListPath), mockDataObjModification)));
verify(mockMountPointReg, timeout(5000)).close();
setupMountPointMocks();
- doReturn(WRITE).when(mockDataObjModification).getModificationType();
- doReturn(null).when(mockDataObjModification).getDataBefore();
- doReturn(node).when(mockDataObjModification).getDataAfter();
+ doReturn(WRITE).when(mockDataObjModification).modificationType();
+ doReturn(null).when(mockDataObjModification).dataBefore();
+ doReturn(node).when(mockDataObjModification).dataAfter();
netconfNodeManager.onDataTreeChanged(List.of(
- new NetconfTopologyManagerTest.CustomTreeModification(DataTreeIdentifier.create(
+ new NetconfTopologyManagerTest.CustomTreeModification(DataTreeIdentifier.of(
LogicalDatastoreType.OPERATIONAL, nodeListPath), mockDataObjModification)));
verify(mockMountPointBuilder, timeout(5000)).register();
setupMountPointMocks();
- doReturn(node).when(mockDataObjModification).getDataBefore();
+ doReturn(node).when(mockDataObjModification).dataBefore();
netconfNodeManager.onDataTreeChanged(List.of(
- new NetconfTopologyManagerTest.CustomTreeModification(DataTreeIdentifier.create(
+ new NetconfTopologyManagerTest.CustomTreeModification(DataTreeIdentifier.of(
LogicalDatastoreType.OPERATIONAL, nodeListPath), mockDataObjModification)));
verify(mockMountPointReg, timeout(5000)).close();
.build())
.build();
- doReturn(SUBTREE_MODIFIED).when(mockDataObjModification).getModificationType();
- doReturn(node).when(mockDataObjModification).getDataBefore();
- doReturn(updatedNode).when(mockDataObjModification).getDataAfter();
+ doReturn(SUBTREE_MODIFIED).when(mockDataObjModification).modificationType();
+ doReturn(node).when(mockDataObjModification).dataBefore();
+ doReturn(updatedNode).when(mockDataObjModification).dataAfter();
netconfNodeManager.onDataTreeChanged(List.of(
- new NetconfTopologyManagerTest.CustomTreeModification(DataTreeIdentifier.create(
+ new NetconfTopologyManagerTest.CustomTreeModification(DataTreeIdentifier.of(
LogicalDatastoreType.OPERATIONAL, nodeListPath), mockDataObjModification)));
verify(mockMountPointReg, timeout(5000)).close();
final Node node = new NodeBuilder().setNodeId(nodeId).addAugmentation(netconfNode).build();
DataObjectModification<Node> mockDataObjModification = mock(DataObjectModification.class);
- doReturn(Iterables.getLast(nodeListPath.getPathArguments())).when(mockDataObjModification).getIdentifier();
- doReturn(WRITE).when(mockDataObjModification).getModificationType();
- doReturn(node).when(mockDataObjModification).getDataAfter();
+ doReturn(Iterables.getLast(nodeListPath.getPathArguments())).when(mockDataObjModification).step();
+ doReturn(WRITE).when(mockDataObjModification).modificationType();
+ doReturn(node).when(mockDataObjModification).dataAfter();
// First try the registration where the perceived master hasn't been initialized as the master.
netconfNodeManager.onDataTreeChanged(List.of(
- new NetconfTopologyManagerTest.CustomTreeModification(DataTreeIdentifier.create(
+ new NetconfTopologyManagerTest.CustomTreeModification(DataTreeIdentifier.of(
LogicalDatastoreType.OPERATIONAL, nodeListPath), mockDataObjModification)));
verify(mockMountPointBuilder, after(1000).never()).register();
yangTextSchemaSourceRequestFuture);
netconfNodeManager.onDataTreeChanged(List.of(
- new NetconfTopologyManagerTest.CustomTreeModification(DataTreeIdentifier.create(
+ new NetconfTopologyManagerTest.CustomTreeModification(DataTreeIdentifier.of(
LogicalDatastoreType.OPERATIONAL, nodeListPath), mockDataObjModification)));
yangTextSchemaSourceRequestFuture.get(5, TimeUnit.SECONDS);
askForMasterMountPointFuture);
netconfNodeManager.onDataTreeChanged(List.of(
- new NetconfTopologyManagerTest.CustomTreeModification(DataTreeIdentifier.create(
+ new NetconfTopologyManagerTest.CustomTreeModification(DataTreeIdentifier.of(
LogicalDatastoreType.OPERATIONAL, nodeListPath), mockDataObjModification)));
askForMasterMountPointFuture.get(5, TimeUnit.SECONDS);
import org.opendaylight.mdsal.binding.runtime.spi.BindingRuntimeHelpers;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.mdsal.dom.api.DOMMountPointService;
-import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceProvider;
-import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceRegistration;
-import org.opendaylight.mdsal.singleton.common.api.ServiceGroupIdentifier;
+import org.opendaylight.mdsal.singleton.api.ClusterSingletonServiceProvider;
+import org.opendaylight.mdsal.singleton.api.ServiceGroupIdentifier;
import org.opendaylight.netconf.client.NetconfClientFactory;
import org.opendaylight.netconf.client.mdsal.api.DeviceActionFactory;
import org.opendaylight.netconf.client.mdsal.impl.DefaultSchemaResourceManager;
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.NodeBuilder;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeKey;
-import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.concepts.Registration;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.binding.KeyStep;
import org.opendaylight.yangtools.yang.binding.YangModuleInfo;
import org.opendaylight.yangtools.yang.common.Uint16;
import org.opendaylight.yangtools.yang.parser.impl.DefaultYangParserFactory;
@Mock
private ClusterSingletonServiceProvider clusterSingletonServiceProvider;
@Mock
- private ListenerRegistration<?> mockListenerReg;
+ private Registration mockListenerReg;
@Mock
private Registration mockRpcReg;
@Mock
dataBroker = spy(dataBrokerTest.getDataBroker());
doNothing().when(mockListenerReg).close();
- doReturn(mockListenerReg).when(dataBroker).registerDataTreeChangeListener(any(), any());
+ doReturn(mockListenerReg).when(dataBroker).registerTreeChangeListener(any(), any());
doReturn(mockRpcReg).when(rpcProviderService).registerRpcImplementations(any());
netconfTopologyManager = new NetconfTopologyManager(BASE_SCHEMAS, dataBroker, clusterSingletonServiceProvider,
// verify registration is called with right parameters
- verify(dataBroker).registerDataTreeChangeListener(
- DataTreeIdentifier.create(LogicalDatastoreType.CONFIGURATION, NetconfTopologyUtils
+ verify(dataBroker).registerTreeChangeListener(
+ DataTreeIdentifier.of(LogicalDatastoreType.CONFIGURATION, NetconfTopologyUtils
.createTopologyListPath(TOPOLOGY_ID).child(Node.class)), netconfTopologyManager);
netconfTopologyManager.close();
final Node node1 = new NodeBuilder().setNodeId(nodeId1).addAugmentation(netconfNode1).build();
final DataObjectModification<Node> dataObjectModification1 = mock(DataObjectModification.class);
- doReturn(WRITE).when(dataObjectModification1).getModificationType();
- doReturn(node1).when(dataObjectModification1).getDataAfter();
- doReturn(InstanceIdentifier.IdentifiableItem.of(Node.class, new NodeKey(nodeId1)))
- .when(dataObjectModification1).getIdentifier();
+ doReturn(WRITE).when(dataObjectModification1).modificationType();
+ doReturn(node1).when(dataObjectModification1).dataAfter();
+ doReturn(new KeyStep<>(Node.class, new NodeKey(nodeId1)))
+ .when(dataObjectModification1).step();
final NetconfNode netconfNode2 = new NetconfNodeBuilder()
.setHost(new Host(new IpAddress(new Ipv4Address("127.0.0.1"))))
final Node node2 = new NodeBuilder().setNodeId(nodeId2).addAugmentation(netconfNode2).build();
final DataObjectModification<Node> dataObjectModification2 = mock(DataObjectModification.class);
- doReturn(WRITE).when(dataObjectModification2).getModificationType();
- doReturn(node2).when(dataObjectModification2).getDataAfter();
- doReturn(InstanceIdentifier.IdentifiableItem.of(Node.class, new NodeKey(nodeId2)))
- .when(dataObjectModification2).getIdentifier();
+ doReturn(WRITE).when(dataObjectModification2).modificationType();
+ doReturn(node2).when(dataObjectModification2).dataAfter();
+ doReturn(new KeyStep<>(Node.class, new NodeKey(nodeId2))).when(dataObjectModification2).step();
final NetconfTopologyContext mockContext1 = mock(NetconfTopologyContext.class);
mockContextMap.put(nodeInstanceId1, setup -> {
return mockContext2;
});
- ClusterSingletonServiceRegistration mockClusterRegistration1 = mock(ClusterSingletonServiceRegistration.class);
- ClusterSingletonServiceRegistration mockClusterRegistration2 = mock(ClusterSingletonServiceRegistration.class);
+ final var mockClusterRegistration1 = mock(Registration.class);
+ final var mockClusterRegistration2 = mock(Registration.class);
doReturn(mockClusterRegistration1).when(clusterSingletonServiceProvider)
.registerClusterSingletonService(mockContext1);
.registerClusterSingletonService(mockContext2);
netconfTopologyManager.onDataTreeChanged(List.of(
- new CustomTreeModification(DataTreeIdentifier.create(LogicalDatastoreType.CONFIGURATION,
+ new CustomTreeModification(DataTreeIdentifier.of(LogicalDatastoreType.CONFIGURATION,
nodeInstanceId1), dataObjectModification1),
- new CustomTreeModification(DataTreeIdentifier.create(LogicalDatastoreType.CONFIGURATION,
+ new CustomTreeModification(DataTreeIdentifier.of(LogicalDatastoreType.CONFIGURATION,
nodeInstanceId2), dataObjectModification2)));
verify(clusterSingletonServiceProvider).registerClusterSingletonService(mockContext1);
.setPort(new PortNumber(Uint16.valueOf(33333))).build();
final Node updatedNode1 = new NodeBuilder().setNodeId(nodeId1).addAugmentation(updatedNetconfNode1).build();
- doReturn(WRITE).when(dataObjectModification1).getModificationType();
- doReturn(updatedNode1).when(dataObjectModification1).getDataAfter();
+ doReturn(WRITE).when(dataObjectModification1).modificationType();
+ doReturn(updatedNode1).when(dataObjectModification1).dataAfter();
- doReturn(SUBTREE_MODIFIED).when(dataObjectModification2).getModificationType();
- doReturn(node2).when(dataObjectModification2).getDataAfter();
+ doReturn(SUBTREE_MODIFIED).when(dataObjectModification2).modificationType();
+ doReturn(node2).when(dataObjectModification2).dataAfter();
doNothing().when(mockContext1).refresh(any());
doNothing().when(mockContext2).refresh(any());
netconfTopologyManager.onDataTreeChanged(List.of(
- new CustomTreeModification(DataTreeIdentifier.create(LogicalDatastoreType.CONFIGURATION,
+ new CustomTreeModification(DataTreeIdentifier.of(LogicalDatastoreType.CONFIGURATION,
nodeInstanceId1), dataObjectModification1),
- new CustomTreeModification(DataTreeIdentifier.create(LogicalDatastoreType.CONFIGURATION,
+ new CustomTreeModification(DataTreeIdentifier.of(LogicalDatastoreType.CONFIGURATION,
nodeInstanceId2), dataObjectModification2)));
ArgumentCaptor<NetconfTopologySetup> mockContext1Setup = ArgumentCaptor.forClass(NetconfTopologySetup.class);
verifyNoMoreInteractions(clusterSingletonServiceProvider);
// Notify of Node 1 deleted.
- doReturn(DELETE).when(dataObjectModification1).getModificationType();
+ doReturn(DELETE).when(dataObjectModification1).modificationType();
netconfTopologyManager.onDataTreeChanged(List.of(
- new CustomTreeModification(DataTreeIdentifier.create(LogicalDatastoreType.CONFIGURATION,
+ new CustomTreeModification(DataTreeIdentifier.of(LogicalDatastoreType.CONFIGURATION,
nodeInstanceId1), dataObjectModification1)));
verify(mockClusterRegistration1).close();
reset(clusterSingletonServiceProvider);
final NetconfTopologyContext newMockContext1 = mock(NetconfTopologyContext.class);
- final ClusterSingletonServiceRegistration newMockClusterRegistration1 =
- mock(ClusterSingletonServiceRegistration.class);
+ final var newMockClusterRegistration1 = mock(Registration.class);
doThrow(new RuntimeException("mock error")).doReturn(newMockClusterRegistration1)
.when(clusterSingletonServiceProvider).registerClusterSingletonService(newMockContext1);
- doReturn(WRITE).when(dataObjectModification1).getModificationType();
- doReturn(node1).when(dataObjectModification1).getDataAfter();
+ doReturn(WRITE).when(dataObjectModification1).modificationType();
+ doReturn(node1).when(dataObjectModification1).dataAfter();
mockContextMap.put(nodeInstanceId1, setup -> {
assertEquals(node1, setup.getNode());
});
netconfTopologyManager.onDataTreeChanged(List.of(
- new CustomTreeModification(DataTreeIdentifier.create(LogicalDatastoreType.CONFIGURATION,
+ new CustomTreeModification(DataTreeIdentifier.of(LogicalDatastoreType.CONFIGURATION,
nodeInstanceId1), dataObjectModification1)));
verify(clusterSingletonServiceProvider, times(2)).registerClusterSingletonService(newMockContext1);
.build();
final DataObjectModification<Node> dataObjectModification = mock(DataObjectModification.class);
- doReturn(WRITE).when(dataObjectModification).getModificationType();
- doReturn(node).when(dataObjectModification).getDataAfter();
- doReturn(InstanceIdentifier.IdentifiableItem.of(Node.class, new NodeKey(nodeId)))
- .when(dataObjectModification).getIdentifier();
+ doReturn(WRITE).when(dataObjectModification).modificationType();
+ doReturn(node).when(dataObjectModification).dataAfter();
+ doReturn(new KeyStep<>(Node.class, new NodeKey(nodeId))).when(dataObjectModification).step();
final NetconfTopologyContext mockContext = mock(NetconfTopologyContext.class);
mockContextMap.put(nodeInstanceId, setup -> mockContext);
.registerClusterSingletonService(mockContext);
netconfTopologyManager.onDataTreeChanged(List.of(
- new CustomTreeModification(DataTreeIdentifier.create(LogicalDatastoreType.CONFIGURATION,
+ new CustomTreeModification(DataTreeIdentifier.of(LogicalDatastoreType.CONFIGURATION,
nodeInstanceId), dataObjectModification)));
verify(clusterSingletonServiceProvider, times(3)).registerClusterSingletonService(mockContext);
package org.opendaylight.netconf.topology.singleton.impl;
import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.assertThrows;
import akka.actor.ActorSystem;
import akka.actor.Status.Success;
import akka.testkit.javadsl.TestKit;
import akka.util.Timeout;
import java.net.InetSocketAddress;
+import java.util.List;
import java.util.concurrent.TimeUnit;
import org.junit.AfterClass;
import org.junit.Test;
masterActor.expectMsgClass(ReadRequest.class);
}
- @Test(expected = UnsupportedOperationException.class)
+ @Test
public void testCreateTransactionChain() {
- proxy.createTransactionChain(null);
+ assertThrows(UnsupportedOperationException.class, proxy::createTransactionChain);
}
@Test
public void testGetSupportedExtensions() {
- assertTrue(proxy.getExtensions().isEmpty());
+ assertEquals(List.of(), proxy.supportedExtensions());
}
}
<artifactId>javax.inject</artifactId>
<optional>true</optional>
</dependency>
+ <dependency>
+ <groupId>org.bouncycastle</groupId>
+ <artifactId>bcpkix-jdk18on</artifactId>
+ </dependency>
<dependency>
<groupId>org.opendaylight.aaa</groupId>
<artifactId>aaa-encrypt-service</artifactId>
import com.google.common.base.Strings;
import java.io.IOException;
import java.io.StringReader;
+import java.nio.charset.StandardCharsets;
+import java.security.GeneralSecurityException;
import java.security.KeyPair;
import java.security.Provider;
import java.security.Security;
} else if (credentials instanceof LoginPw loginPw) {
final var loginPassword = loginPw.getLoginPassword();
final var username = loginPassword.getUsername();
- final var password = Base64.getEncoder().encodeToString(loginPassword.getPassword());
- sshParamsBuilder.setClientIdentity(loginPasswordIdentity(username, encryptionService.decrypt(password)));
+
+ final byte[] plainBytes;
+ try {
+ plainBytes = encryptionService.decrypt(loginPassword.getPassword());
+ } catch (GeneralSecurityException e) {
+ throw new IllegalStateException("Failed to decrypt password", e);
+ }
+
+ sshParamsBuilder.setClientIdentity(loginPasswordIdentity(username,
+ new String(plainBytes, StandardCharsets.UTF_8)));
} else if (credentials instanceof KeyAuth keyAuth) {
final var keyBased = keyAuth.getKeyBased();
sshParamsBuilder.setClientIdentity(new ClientIdentityBuilder().setUsername(keyBased.getUsername()).build());
}
final var passPhrase = Strings.isNullOrEmpty(dsKeypair.getPassphrase()) ? "" : dsKeypair.getPassphrase();
try {
- return decodePrivateKey(encryptionService.decrypt(dsKeypair.getPrivateKey()),
- encryptionService.decrypt(passPhrase));
+ return decodePrivateKey(decryptString(dsKeypair.getPrivateKey()), decryptString(passPhrase));
} catch (IOException e) {
throw new IllegalStateException("Could not decode private key with keyId=" + keyId, e);
}
}
+ private String decryptString(final String encrypted) {
+ final byte[] cryptobytes = Base64.getDecoder().decode(encrypted);
+ final byte[] clearbytes;
+ try {
+ clearbytes = encryptionService.decrypt(cryptobytes);
+ } catch (GeneralSecurityException e) {
+ throw new IllegalStateException("Failed to decrypt", e);
+ }
+ return new String(clearbytes, StandardCharsets.UTF_8);
+ }
+
+
@VisibleForTesting
static KeyPair decodePrivateKey(final String privateKey, final String passphrase) throws IOException {
try (var keyReader = new PEMParser(new StringReader(privateKey.replace("\\n", "\n")))) {
import org.checkerframework.checker.lock.qual.GuardedBy;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.mdsal.binding.api.DataBroker;
-import org.opendaylight.mdsal.binding.api.Transaction;
import org.opendaylight.mdsal.binding.api.TransactionChain;
-import org.opendaylight.mdsal.binding.api.TransactionChainListener;
import org.opendaylight.mdsal.binding.api.WriteTransaction;
import org.opendaylight.mdsal.common.api.CommitInfo;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-public final class NetconfDeviceTopologyAdapter implements TransactionChainListener {
+public final class NetconfDeviceTopologyAdapter implements FutureCallback<Empty> {
private static final Logger LOG = LoggerFactory.getLogger(NetconfDeviceTopologyAdapter.class);
private final @NonNull KeyedInstanceIdentifier<Topology, TopologyKey> topologyPath;
this.dataBroker = requireNonNull(dataBroker);
this.topologyPath = requireNonNull(topologyPath);
this.id = requireNonNull(id);
- txChain = dataBroker.createMergingTransactionChain(this);
+ txChain = dataBroker.createMergingTransactionChain();
+ txChain.addCallback(this);
final var tx = txChain.newWriteOnlyTransaction();
LOG.trace("{}: Init device state transaction {} putting if absent operational data started.", id,
}
@Override
- public synchronized void onTransactionChainFailed(final TransactionChain chain, final Transaction transaction,
- final Throwable cause) {
- LOG.warn("{}: TransactionChain({}) {} FAILED!", id, chain, transaction.getIdentifier(), cause);
+ public synchronized void onFailure(final Throwable cause) {
+ LOG.warn("{}: transaction chain FAILED!", id, cause);
if (closeFuture != null) {
closeFuture.setException(cause);
return;
}
// FIXME: move this up once we have MDSAL-838 fixed
- chain.close();
+ txChain.close();
- txChain = dataBroker.createMergingTransactionChain(this);
+ txChain = dataBroker.createMergingTransactionChain();
LOG.info("{}: TransactionChain reset to {}", id, txChain);
+ txChain.addCallback(this);
// FIXME: restart last update
}
@Override
- public synchronized void onTransactionChainSuccessful(final TransactionChain chain) {
- LOG.trace("{}: TransactionChain({}) SUCCESSFUL", id, chain);
+ public synchronized void onSuccess(final Empty result) {
+ LOG.trace("{}: transaction chain SUCCESSFUL", id);
closeFuture.set(Empty.value());
}
import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.node.topology.rev231121.NetconfNode;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;
import org.opendaylight.yangtools.concepts.AbstractRegistration;
-import org.opendaylight.yangtools.yang.model.repo.api.YangTextSchemaSource;
+import org.opendaylight.yangtools.concepts.Registration;
+import org.opendaylight.yangtools.yang.model.api.source.YangTextSource;
import org.opendaylight.yangtools.yang.model.repo.spi.PotentialSchemaSource;
-import org.opendaylight.yangtools.yang.model.repo.spi.SchemaSourceRegistration;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
private static final Logger LOG = LoggerFactory.getLogger(NetconfNodeHandler.class);
- private final @NonNull List<SchemaSourceRegistration<?>> yanglibRegistrations;
+ private final @NonNull List<Registration> yanglibRegistrations;
private final @NonNull NetconfClientFactory clientFactory;
private final @NonNull NetconfClientConfiguration clientConfig;
private final @NonNull NetconfDeviceCommunicator communicator;
communicator.close();
delegate.close();
- yanglibRegistrations.forEach(SchemaSourceRegistration::close);
+ yanglibRegistrations.forEach(Registration::close);
}
@Override
}
}
- private static List<SchemaSourceRegistration<?>> registerDeviceSchemaSources(final RemoteDeviceId remoteDeviceId,
+ private static List<Registration> registerDeviceSchemaSources(final RemoteDeviceId remoteDeviceId,
final NetconfNode node, final SchemaResourcesDTO resources) {
final var yangLibrary = node.getYangLibrary();
if (yangLibrary != null) {
final Uri uri = yangLibrary.getYangLibraryUrl();
if (uri != null) {
- final var registrations = new ArrayList<SchemaSourceRegistration<?>>();
+ final var registrations = new ArrayList<Registration>();
final var yangLibURL = uri.getValue();
final var schemaRegistry = resources.getSchemaRegistry();
for (var entry : schemas.getAvailableModels().entrySet()) {
registrations.add(schemaRegistry.registerSchemaSource(new LibrarySchemaSourceProvider(
remoteDeviceId, schemas.getAvailableModels()),
- PotentialSchemaSource.create(entry.getKey(), YangTextSchemaSource.class,
+ PotentialSchemaSource.create(entry.getKey(), YangTextSource.class,
PotentialSchemaSource.Costs.REMOTE_IO.getValue())));
}
return List.copyOf(registrations);
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.MoreExecutors;
import com.google.common.util.concurrent.SettableFuture;
-import java.util.Base64;
+import java.nio.charset.StandardCharsets;
+import java.security.GeneralSecurityException;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.aaa.encrypt.AAAEncryptionService;
import org.opendaylight.mdsal.binding.api.DataBroker;
final SettableFuture<RpcResult<DeleteDeviceOutput>> rpcFuture = SettableFuture.create();
wtx.commit().addCallback(new FutureCallback<CommitInfo>() {
-
@Override
public void onSuccess(final CommitInfo result) {
LOG.info("delete-device RPC: Removed netconf node successfully.");
private Credentials translate(final RpcCredentials credentialsRpc) {
if (credentialsRpc instanceof LoginPw loginPw) {
final var loginPassword = loginPw.getLoginPassword();
+ final byte[] cipherBytes;
+
+ try {
+ cipherBytes = encryptionService.encrypt(loginPassword.getPassword().getBytes(StandardCharsets.UTF_8));
+ } catch (GeneralSecurityException e) {
+ throw new IllegalArgumentException("Failed to encrypt password", e);
+ }
+
return new LoginPwBuilder()
.setLoginPassword(new LoginPasswordBuilder()
.setUsername(loginPassword.getUsername())
- .setPassword(Base64.getDecoder().decode(encryptionService.encrypt(loginPassword.getPassword())))
+ .setPassword(cipherBytes)
.build())
.build();
} else if (credentialsRpc instanceof LoginPwUnencrypted loginPwUnencrypted) {
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
+import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.Futures;
import java.net.InetSocketAddress;
import java.util.concurrent.ExecutionException;
import org.mockito.junit.MockitoJUnitRunner;
import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.mdsal.binding.api.TransactionChain;
-import org.opendaylight.mdsal.binding.api.TransactionChainListener;
import org.opendaylight.mdsal.binding.api.WriteTransaction;
import org.opendaylight.mdsal.common.api.CommitInfo;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
@Mock
private WriteTransaction mockTx;
@Captor
- private ArgumentCaptor<TransactionChainListener> listeners;
+ private ArgumentCaptor<FutureCallback<Empty>> listeners;
private NetconfDeviceTopologyAdapter adapter;
doReturn("test transaction").when(mockTx).getIdentifier();
doReturn(CommitInfo.emptyFluentFuture()).when(mockTx).commit();
- doReturn(mockChain).when(mockBroker).createMergingTransactionChain(listeners.capture());
+ doReturn(mockChain).when(mockBroker).createMergingTransactionChain();
+ doNothing().when(mockChain).addCallback(listeners.capture());
adapter = new NetconfDeviceTopologyAdapter(mockBroker, TEST_TOPOLOGY_ID, id);
}
public void replaceChainIfFailed() {
doNothing().when(mockChain).close();
doReturn("mockChain").when(mockChain).toString();
- adapter.onTransactionChainFailed(mockChain, mockTx, new Exception("chain failed"));
- verify(mockBroker, times(2)).createMergingTransactionChain(any());
+ adapter.onFailure(new Exception("chain failed"));
+ verify(mockBroker, times(2)).createMergingTransactionChain();
}
@Test
assertSame(future, adapter.shutdown());
// future completes
- listeners.getValue().onTransactionChainSuccessful(mockChain);
+ listeners.getValue().onSuccess(Empty.value());
assertSame(Empty.value(), Futures.getDone(future));
}
// future completes
final var cause = new Throwable();
- listeners.getValue().onTransactionChainFailed(mockChain, mockTx, cause);
+ listeners.getValue().onFailure(cause);
final var ex = assertThrows(ExecutionException.class, () -> Futures.getDone(future));
assertSame(cause, ex.getCause());
}
*/
package org.opendaylight.netconf.topology.spi;
+import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertInstanceOf;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.doReturn;
-import java.util.Base64;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
private NetconfTopologyRPCProvider rpcProvider;
@Before
- public void setUp() {
- doReturn(ENC_PWD).when(encryptionService).encrypt(TEST_PWD);
+ public void setUp() throws Exception {
+ doReturn(ENC_PWD.getBytes()).when(encryptionService).encrypt(TEST_PWD.getBytes());
doReturn(rpcReg).when(rpcProviderService).registerRpcImplementations(any());
rpcProvider = new NetconfTopologyRPCProvider(rpcProviderService, dataBroker, encryptionService, TOPOLOGY_ID);
}
@Test
public void testEncryptPassword() {
+ final var encryptedPwNode = rpcProvider.encryptPassword(getInput(true));
+ final var loginPw = assertInstanceOf(LoginPw.class, encryptedPwNode.getCredentials());
- final NetconfNode encryptedPwNode = rpcProvider.encryptPassword(getInput(true));
-
- final Credentials credentials = encryptedPwNode.getCredentials();
- assertTrue(credentials instanceof LoginPw);
- final LoginPw loginPw = (LoginPw) credentials;
-
- assertEquals(ENC_PWD, Base64.getEncoder().encodeToString(loginPw.getLoginPassword().getPassword()));
+ assertArrayEquals(ENC_PWD.getBytes(), loginPw.getLoginPassword().getPassword());
}
@Test
import static java.util.Objects.requireNonNull;
+import com.google.common.annotations.VisibleForTesting;
import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.MoreExecutors;
import java.util.concurrent.ExecutionException;
import org.opendaylight.yangtools.concepts.Registration;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
-import org.opendaylight.yangtools.yang.model.api.EffectiveModelContextListener;
import org.osgi.service.component.annotations.Activate;
import org.osgi.service.component.annotations.Component;
import org.osgi.service.component.annotations.Deactivate;
* state to operational data store.
*/
@Singleton
-@Component(immediate = true, configurationPid = "org.opendaylight.netconf.yanglib")
+@Component(service = { }, configurationPid = "org.opendaylight.netconf.yanglib")
@Designate(ocd = YangLibraryWriter.Configuration.class)
-public final class YangLibraryWriter implements EffectiveModelContextListener, AutoCloseable {
-
+public final class YangLibraryWriter implements AutoCloseable {
@ObjectClassDefinition
public @interface Configuration {
@AttributeDefinition(description = "Enables legacy content to be written")
@Inject
@Activate
public YangLibraryWriter(final @Reference DOMSchemaService schemaService,
- final @Reference DataBroker dataBroker, final Configuration configuration) {
+ final @Reference DataBroker dataBroker, final Configuration configuration) {
this.dataBroker = requireNonNull(dataBroker);
- this.writeLegacy = configuration.write$_$legacy();
- reg = schemaService.registerSchemaContextListener(this);
+ writeLegacy = configuration.write$_$legacy();
+ reg = schemaService.registerSchemaContextListener(this::onModelContextUpdated);
}
@Deactivate
future.get();
}
- @Override
- public void onModelContextUpdated(final EffectiveModelContext context) {
+ @VisibleForTesting void onModelContextUpdated(final EffectiveModelContext context) {
if (context.findModule(YangLibrary.QNAME.getModule()).isPresent()) {
updateYangLibrary(context);
} else {
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.library.rev190104.yang.library.parameters.ModuleSetBuilder;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.library.rev190104.yang.library.parameters.SchemaBuilder;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.YangIdentifier;
-import org.opendaylight.yangtools.concepts.ListenerRegistration;
+import org.opendaylight.yangtools.concepts.Registration;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.binding.util.BindingMap;
-import org.opendaylight.yangtools.yang.model.api.EffectiveModelContextListener;
@ExtendWith(MockitoExtension.class)
class YangLibraryWriterTest {
@Mock
private WriteTransaction writeTransaction;
@Mock
- private ListenerRegistration<EffectiveModelContextListener> registration;
+ private Registration registration;
@Mock
private YangLibraryWriter.Configuration config;
@Captor
-->
<features xmlns="http://karaf.apache.org/xmlns/features/v1.4.0" name="odl-aaa-netconf-plugin">
<feature name="odl-aaa-netconf-plugin">
- <feature version="[0.18,1)">odl-aaa-shiro</feature>
+ <feature version="[0.19,1)">odl-aaa-shiro</feature>
</feature>
</features>
<features xmlns="http://karaf.apache.org/xmlns/features/v1.4.0" name="odl-netconf-${project.version}">
<feature name="odl-netconf-api" version="${project.version}">
<feature version="[13,14)">odl-netty-4</feature>
- <feature version="[12,13)">odl-mdsal-model-rfc8525</feature>
+ <feature version="[13,14)">odl-mdsal-model-rfc8525</feature>
</feature>
</features>
-->
<features xmlns="http://karaf.apache.org/xmlns/features/v1.4.0" name="odl-netconf-${project.version}">
<feature name="odl-netconf-connector" version="${project.version}">
- <feature version="[12,13)">odl-mdsal-model-draft-clemm-netmod-yang-network-topo-01-minimal</feature>
- <feature version="[8,9)">odl-mdsal-broker</feature>
- <feature version="[0.18,1)">odl-aaa-encryption-service</feature>
+ <feature version="[13,14)">odl-mdsal-model-draft-clemm-netmod-yang-network-topo-01-minimal</feature>
+ <feature version="[9,10)">odl-mdsal-broker</feature>
+ <feature version="[0.19,1)">odl-aaa-encryption-service</feature>
</feature>
</features>
-->
<features xmlns="http://karaf.apache.org/xmlns/features/v1.6.0" name="odl-netconf-${project.version}">
<feature name="odl-netconf-model-rfc5277" version="${project.version}">
- <feature version="[12,13)">odl-mdsal-model-rfc6991</feature>
+ <feature version="[13,14)">odl-mdsal-model-rfc6991</feature>
</feature>
</features>
-->
<features xmlns="http://karaf.apache.org/xmlns/features/v1.6.0" name="odl-netconf-${project.version}">
<feature name="odl-netconf-model-rfc6022" version="${project.version}">
- <feature version="[12,13)">odl-mdsal-model-rfc6991</feature>
+ <feature version="[13,14)">odl-mdsal-model-rfc6991</feature>
</feature>
</features>
-->
<features xmlns="http://karaf.apache.org/xmlns/features/v1.6.0" name="odl-netconf-${project.version}">
<feature name="odl-netconf-model-rfc6241" version="${project.version}">
- <feature version="[12,13)">odl-mdsal-model-rfc6991</feature>
+ <feature version="[13,14)">odl-mdsal-model-rfc6991</feature>
</feature>
</features>
-->
<features xmlns="http://karaf.apache.org/xmlns/features/v1.6.0" name="odl-netconf-${project.version}">
<feature name="odl-netconf-model-rfc8040" version="${project.version}">
- <feature version="[12,13)">odl-mdsal-model-rfc6991</feature>
+ <feature version="[13,14)">odl-mdsal-model-rfc6991</feature>
</feature>
</features>
-->
<features xmlns="http://karaf.apache.org/xmlns/features/v1.6.0" name="odl-netconf-${project.version}">
<feature name="odl-netconf-model-rfc8341" version="${project.version}">
- <feature version="[12,13)">odl-mdsal-model-rfc6991</feature>
+ <feature version="[13,14)">odl-mdsal-model-rfc6991</feature>
</feature>
</features>
-->
<features xmlns="http://karaf.apache.org/xmlns/features/v1.6.0" name="odl-netconf-${project.version}">
<feature name="odl-netconf-model-rfc8526" version="${project.version}">
- <feature version="[12,13)">odl-mdsal-model-rfc8342</feature>
+ <feature version="[13,14)">odl-mdsal-model-rfc8342</feature>
</feature>
</features>
-->
<features xmlns="http://karaf.apache.org/xmlns/features/v1.6.0" name="odl-netconf-${project.version}">
<feature name="odl-netconf-model-rfc8639" version="${project.version}">
- <feature version="[12,13)">odl-mdsal-model-rfc8040</feature>
- <feature version="[12,13)">odl-mdsal-model-rfc8343</feature>
- <feature version="[12,13)">odl-mdsal-model-rfc8528</feature>
- <feature version="[12,13)">odl-mdsal-model-rfc8529</feature>
+ <feature version="[13,14)">odl-mdsal-model-rfc8040</feature>
+ <feature version="[13,14)">odl-mdsal-model-rfc8343</feature>
+ <feature version="[13,14)">odl-mdsal-model-rfc8528</feature>
+ <feature version="[13,14)">odl-mdsal-model-rfc8529</feature>
</feature>
</features>
-->
<features xmlns="http://karaf.apache.org/xmlns/features/v1.6.0" name="odl-netconf-${project.version}">
<feature name="odl-netconf-model-rfc8641" version="${project.version}">
- <feature version="[12,13)">odl-mdsal-model-rfc8072</feature>
- <feature version="[12,13)">odl-mdsal-model-rfc8342</feature>
+ <feature version="[13,14)">odl-mdsal-model-rfc8072</feature>
+ <feature version="[13,14)">odl-mdsal-model-rfc8342</feature>
</feature>
</features>
<features xmlns="http://karaf.apache.org/xmlns/features/v1.6.0" name="odl-netconf-${project.version}">
<feature name="odl-netconf-transport-api" version="${project.version}">
<feature version="[13,14)">odl-netty-4</feature>
- <feature version="[11,12)">odl-yangtools-common</feature>
+ <feature version="[13,14)">odl-yangtools-common</feature>
</feature>
</features>
-->
<features xmlns="http://karaf.apache.org/xmlns/features/v1.2.0" name="odl-netconf-${project.version}">
<feature name="odl-netconf-util" version="${project.version}">
- <feature version="[11,12)">odl-yangtools-codec</feature>
+ <feature version="[13,14)">odl-yangtools-codec</feature>
</feature>
</features>
<features xmlns="http://karaf.apache.org/xmlns/features/v1.4.0" name="odl-netconf-${project.version}">
<feature name="odl-restconf-common" version="${project.version}">
<feature version="[13,14)">odl-karaf-feat-jetty</feature>
- <feature version="[11,12)">odl-yangtools-export</feature>
- <feature version="[12,13)">odl-mdsal-model-rfc8040</feature>
- <feature version="[12,13)">odl-mdsal-model-rfc8072</feature>
- <feature version="[12,13)">odl-mdsal-model-rfc8525</feature>
- <feature version="[8,9)">odl-mdsal-broker</feature>
- <feature version="[0.18,1)">odl-aaa-shiro</feature>
+ <feature version="[13,14)">odl-yangtools-export</feature>
+ <feature version="[13,14)">odl-mdsal-model-rfc8040</feature>
+ <feature version="[13,14)">odl-mdsal-model-rfc8072</feature>
+ <feature version="[13,14)">odl-mdsal-model-rfc8525</feature>
+ <feature version="[9,10)">odl-mdsal-broker</feature>
+ <feature version="[0.19,1)">odl-aaa-shiro</feature>
</feature>
</features>
-->
<features xmlns="http://karaf.apache.org/xmlns/features/v1.4.0" name="odl-restconf-nb-${project.version}">
<feature name="odl-restconf-nb" version="${project.version}">
- <feature version="[12,13)">odl-mdsal-model-rfc8072</feature>
+ <feature version="[13,14)">odl-mdsal-model-rfc8072</feature>
</feature>
</features>
-->
<features xmlns="http://karaf.apache.org/xmlns/features/v1.4.0" name="odl-netconf-${project.version}">
<feature name="odl-yanglib-mdsal-writer" version="${project.version}">
- <feature version="[12,13)">odl-mdsal-model-rfc8525</feature>
- <feature version="[8,9)">odl-mdsal-broker</feature>
+ <feature version="[13,14)">odl-mdsal-model-rfc8525</feature>
+ <feature version="[9,10)">odl-mdsal-broker</feature>
</feature>
</features>
<features xmlns="http://karaf.apache.org/xmlns/features/v1.4.0" name="odl-netconf-${project.version}">
<feature name="odl-yanglib" version="${project.version}">
<feature version="[13,14)">odl-karaf-feat-jetty</feature>
- <feature version="[12,13)">odl-mdsal-model-rfc8525</feature>
+ <feature version="[13,14)">odl-mdsal-model-rfc8525</feature>
</feature>
</features>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>controller-artifacts</artifactId>
- <version>8.0.4</version>
+ <version>9.0.0</version>
<type>pom</type>
<scope>import</scope>
</dependency>
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.MoreExecutors;
-import java.util.Iterator;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import javax.annotation.PreDestroy;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.netconf.notification._1._0.rev080714.CreateSubscriptionInput;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.netconf.notification._1._0.rev080714.CreateSubscriptionInputBuilder;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.netconf.notification._1._0.rev080714.StreamNameType;
-import org.opendaylight.yangtools.concepts.ListenerRegistration;
+import org.opendaylight.yangtools.concepts.Registration;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
private static final QName CREATE_SUBSCRIPTION_QNAME = QName.create(CreateSubscriptionInput.QNAME,
"create-subscription");
- private final ConcurrentMap<YangInstanceIdentifier, ListenerRegistration<?>> listeners = new ConcurrentHashMap<>();
+ private final ConcurrentMap<YangInstanceIdentifier, Registration> listeners = new ConcurrentHashMap<>();
private final DOMMountPointService mountPointService;
private final BindingNormalizedNodeSerializer serializer;
- private final ListenerRegistration<?> reg;
+ private final Registration reg;
@Inject
@Activate
@Deactivate
public void stop() {
reg.close();
- final Iterator<ListenerRegistration<?>> it = listeners.values().iterator();
+ final var it = listeners.values().iterator();
while (it.hasNext()) {
it.next().close();
it.remove();
@Override
public void onMountPointRemoved(final YangInstanceIdentifier path) {
- final ListenerRegistration<?> listener = listeners.remove(path);
+ final var listener = listeners.remove(path);
if (listener != null) {
listener.close();
}
import java.util.Set;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
+import java.util.function.Consumer;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.mdsal.dom.api.DOMDataBroker;
import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteTransaction;
import org.opendaylight.mdsal.dom.api.DOMSchemaService;
+import org.opendaylight.mdsal.dom.api.DOMSchemaService.YangTextSourceExtension;
import org.opendaylight.mdsal.dom.broker.SerializedDOMDataBroker;
import org.opendaylight.mdsal.dom.spi.store.DOMStore;
import org.opendaylight.mdsal.dom.store.inmemory.InMemoryDOMDataStoreFactory;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.monitoring.rev101004.Yang;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.monitoring.rev101004.netconf.state.Schemas;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.monitoring.rev101004.netconf.state.schemas.Schema;
-import org.opendaylight.yangtools.concepts.AbstractListenerRegistration;
-import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.concepts.Registration;
import org.opendaylight.yangtools.util.concurrent.SpecialExecutors;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
-import org.opendaylight.yangtools.yang.model.api.EffectiveModelContextListener;
-import org.opendaylight.yangtools.yang.model.repo.api.YangTextSchemaSource;
-import org.opendaylight.yangtools.yang.model.repo.spi.SchemaSourceProvider;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
private final Set<Capability> caps;
private final EffectiveModelContext schemaContext;
- private final SchemaSourceProvider<YangTextSchemaSource> sourceProvider;
+ private final YangTextSourceExtension sourceProvider;
MdsalOperationProvider(final SessionIdProvider idProvider,
final Set<Capability> caps,
final EffectiveModelContext schemaContext,
- final SchemaSourceProvider<YangTextSchemaSource> sourceProvider) {
+ final YangTextSourceExtension sourceProvider) {
this.caps = caps;
this.schemaContext = schemaContext;
this.sourceProvider = sourceProvider;
private final Set<Capability> caps;
private final DOMSchemaService schemaService;
private final DOMDataBroker dataBroker;
- private final SchemaSourceProvider<YangTextSchemaSource> sourceProvider;
+ private final YangTextSourceExtension sourceProvider;
MdsalOperationService(final SessionIdType currentSessionId, final EffectiveModelContext schemaContext,
- final Set<Capability> caps,
- final SchemaSourceProvider<YangTextSchemaSource> sourceProvider) {
+ final Set<Capability> caps, final YangTextSourceExtension sourceProvider) {
this.currentSessionId = requireNonNull(currentSessionId);
this.schemaContext = schemaContext;
this.caps = caps;
schemaService = createSchemaService();
dataBroker = createDataStore(schemaService, currentSessionId);
-
}
@Override
}
@Override
- public ListenerRegistration<EffectiveModelContextListener> registerSchemaContextListener(
- final EffectiveModelContextListener listener) {
- listener.onModelContextUpdated(getGlobalContext());
- return new AbstractListenerRegistration<>(listener) {
- @Override
- protected void removeRegistration() {
- // No-op
- }
+ public Registration registerSchemaContextListener(final Consumer<EffectiveModelContext> listener) {
+ listener.accept(getGlobalContext());
+ return () -> {
+ // No-op
};
}
};
import java.util.Set;
import java.util.concurrent.ExecutionException;
import java.util.stream.IntStream;
+import org.opendaylight.mdsal.dom.api.DOMSchemaService.YangTextSourceExtension;
import org.opendaylight.netconf.api.CapabilityURN;
import org.opendaylight.netconf.api.TransportConstants;
import org.opendaylight.netconf.common.impl.DefaultNetconfTimer;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.ModuleLike;
import org.opendaylight.yangtools.yang.model.api.Submodule;
-import org.opendaylight.yangtools.yang.model.repo.api.SchemaSourceRepresentation;
-import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
-import org.opendaylight.yangtools.yang.model.repo.api.YangTextSchemaSource;
+import org.opendaylight.yangtools.yang.model.api.source.SourceIdentifier;
+import org.opendaylight.yangtools.yang.model.api.source.SourceRepresentation;
+import org.opendaylight.yangtools.yang.model.api.source.YangTextSource;
import org.opendaylight.yangtools.yang.model.repo.fs.FilesystemSchemaSourceCache;
import org.opendaylight.yangtools.yang.model.repo.spi.PotentialSchemaSource;
import org.opendaylight.yangtools.yang.model.repo.spi.SchemaSourceListener;
-import org.opendaylight.yangtools.yang.model.repo.spi.SchemaSourceProvider;
+import org.opendaylight.yangtools.yang.model.spi.source.URLYangTextSource;
import org.opendaylight.yangtools.yang.parser.repo.SharedSchemaRepository;
import org.opendaylight.yangtools.yang.parser.rfc7950.repo.TextToIRTransformer;
import org.slf4j.Logger;
}
private ServerTransportInitializer createTransportInitializer(final Set<Capability> capabilities,
- final SchemaSourceProvider<YangTextSchemaSource> sourceProvider) {
+ final YangTextSourceExtension sourceProvider) {
final var transformedCapabilities = new HashSet<>(Collections2.transform(capabilities, input -> {
if (sendFakeSchema) {
sendFakeSchema = false;
}
private NetconfOperationServiceFactory createOperationServiceFactory(
- final SchemaSourceProvider<YangTextSchemaSource> sourceProvider,
+ final YangTextSourceExtension sourceProvider,
final Set<Capability> transformedCapabilities, final NetconfMonitoringService monitoringService1,
final SessionIdProvider idProvider) {
final AggregatedNetconfOperationServiceFactory aggregatedNetconfOperationServiceFactory =
final var schemaRepo = new SharedSchemaRepository("netconf-simulator");
final var capabilities = parseSchemasToModuleCapabilities(schemaRepo);
final var transportInitializer = createTransportInitializer(capabilities,
- sourceIdentifier -> schemaRepo.getSchemaSource(sourceIdentifier, YangTextSchemaSource.class));
+ sourceIdentifier -> schemaRepo.getSchemaSource(sourceIdentifier, YangTextSource.class));
final var ipAddress = getIpAddress(configuration);
final var startingPort = getStartingPort(configuration);
consumer.registerSchemaSourceListener(TextToIRTransformer.create(consumer, consumer));
consumer.registerSchemaSourceListener(new SchemaSourceListener() {
@Override
- public void schemaSourceEncountered(final SchemaSourceRepresentation schemaSourceRepresentation) {
+ public void schemaSourceEncountered(final SourceRepresentation schemaSourceRepresentation) {
}
if (configuration.getSchemasDir() != null) {
LOG.info("Loading models from directory.");
- final FilesystemSchemaSourceCache<YangTextSchemaSource> cache = new FilesystemSchemaSourceCache<>(
- consumer, YangTextSchemaSource.class, configuration.getSchemasDir());
+ final FilesystemSchemaSourceCache<YangTextSource> cache = new FilesystemSchemaSourceCache<>(
+ consumer, YangTextSource.class, configuration.getSchemasDir());
consumer.registerSchemaSourceListener(cache);
} else if (configuration.getModels() != null) {
LOG.info("Loading models from classpath.");
- final SchemaSourceCache<YangTextSchemaSource> cache = new SchemaSourceCache<>(
- consumer, YangTextSchemaSource.class, configuration.getModels());
+ final SchemaSourceCache<YangTextSource> cache = new SchemaSourceCache<>(
+ consumer, YangTextSource.class, configuration.getModels());
consumer.registerSchemaSourceListener(cache);
} else {
LOG.info("Custom module loading skipped.");
final String moduleContent;
try {
- moduleContent = consumer.getSchemaSource(sourceId, YangTextSchemaSource.class).get().read();
+ moduleContent = consumer.getSchemaSource(sourceId, YangTextSource.class).get().read();
} catch (ExecutionException | InterruptedException | IOException e) {
throw new IllegalStateException(
"Cannot retrieve schema source for module " + sourceId + " from schema repository", e);
private static void registerSource(final SharedSchemaRepository consumer, final String resource,
final SourceIdentifier sourceId) {
consumer.registerSchemaSource(sourceIdentifier -> Futures.immediateFuture(
- YangTextSchemaSource.forResource(NetconfDeviceSimulator.class, resource)),
- PotentialSchemaSource.create(sourceId, YangTextSchemaSource.class,
+ new URLYangTextSource(NetconfDeviceSimulator.class.getResource(resource))),
+ PotentialSchemaSource.create(sourceId, YangTextSource.class,
PotentialSchemaSource.Costs.IMMEDIATE.getValue()));
}
import org.opendaylight.mdsal.binding.runtime.spi.BindingRuntimeHelpers;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.device.rev240120.credentials.Credentials;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.device.rev240120.credentials.credentials.login.pw.unencrypted.LoginPasswordUnencrypted;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.node.topology.rev231121.$YangModuleInfoImpl;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.node.topology.rev231121.NetconfNodeFields;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NetworkTopology;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.Topology;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
+import org.opendaylight.yang.svc.v1.urn.opendaylight.netconf.node.topology.rev231121.YangModuleInfoImpl;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.Uint16;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
final class PayloadCreator {
private static final Logger LOG = LoggerFactory.getLogger(PayloadCreator.class);
private static final EffectiveModelContext NETWORK_TOPOLOGY_SCHEMA_CONTEXT =
- BindingRuntimeHelpers.createEffectiveModel(List.of($YangModuleInfoImpl.getInstance()));
+ BindingRuntimeHelpers.createEffectiveModel(List.of(YangModuleInfoImpl.getInstance()));
private static final JSONCodecFactory NETWORK_TOPOLOGY_JSON_CODEC_FACTORY =
JSONCodecFactorySupplier.RFC7951.getShared(NETWORK_TOPOLOGY_SCHEMA_CONTEXT);
import org.opendaylight.yangtools.yang.binding.YangModuleInfo;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.Revision;
+import org.opendaylight.yangtools.yang.model.api.source.SourceIdentifier;
+import org.opendaylight.yangtools.yang.model.api.source.SourceRepresentation;
import org.opendaylight.yangtools.yang.model.repo.api.MissingSchemaSourceException;
-import org.opendaylight.yangtools.yang.model.repo.api.SchemaSourceRepresentation;
-import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
-import org.opendaylight.yangtools.yang.model.repo.api.YangTextSchemaSource;
import org.opendaylight.yangtools.yang.model.repo.spi.AbstractSchemaSourceCache;
import org.opendaylight.yangtools.yang.model.repo.spi.PotentialSchemaSource.Costs;
import org.opendaylight.yangtools.yang.model.repo.spi.SchemaSourceRegistry;
+import org.opendaylight.yangtools.yang.model.spi.source.DelegatedYangTextSource;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* Cache implementation that stores schemas in form of files under provided folder.
*/
-public final class SchemaSourceCache<T extends SchemaSourceRepresentation> extends AbstractSchemaSourceCache<T> {
-
+public final class SchemaSourceCache<T extends SourceRepresentation> extends AbstractSchemaSourceCache<T> {
private static final Logger LOG = LoggerFactory.getLogger(SchemaSourceCache.class);
private final Class<T> representation;
public synchronized ListenableFuture<? extends T> getSource(final SourceIdentifier sourceIdentifier) {
final YangModuleInfo yangModuleInfo = cachedSchemas.get(sourceIdentifier);
if (yangModuleInfo != null) {
- final YangTextSchemaSource yangTextSchemaSource = YangTextSchemaSource.delegateForCharSource(
- sourceIdentifier, yangModuleInfo.getYangTextCharSource());
+ final var yangTextSchemaSource = new DelegatedYangTextSource(sourceIdentifier,
+ yangModuleInfo.getYangTextCharSource());
return Futures.immediateFuture(representation.cast(yangTextSchemaSource));
}
LOG.debug("Source {} not found in cache", sourceIdentifier);
- return Futures.immediateFailedFuture(new MissingSchemaSourceException("Source not found", sourceIdentifier));
+ return Futures.immediateFailedFuture(new MissingSchemaSourceException(sourceIdentifier, "Source not found"));
}
@Override
protected synchronized void offer(final T source) {
- LOG.trace("Source {} offered to cache", source.getIdentifier());
+ LOG.trace("Source {} offered to cache", source.sourceId());
}
}
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.library.rev190104.module.list.ModuleKey;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.YangIdentifier;
import org.opendaylight.yanglib.api.YangLibService;
+import org.opendaylight.yangtools.concepts.Registration;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.common.Uint32;
+import org.opendaylight.yangtools.yang.model.api.source.SourceIdentifier;
+import org.opendaylight.yangtools.yang.model.api.source.SourceRepresentation;
+import org.opendaylight.yangtools.yang.model.api.source.YangTextSource;
import org.opendaylight.yangtools.yang.model.repo.api.MissingSchemaSourceException;
-import org.opendaylight.yangtools.yang.model.repo.api.SchemaSourceRepresentation;
-import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
-import org.opendaylight.yangtools.yang.model.repo.api.YangTextSchemaSource;
import org.opendaylight.yangtools.yang.model.repo.fs.FilesystemSchemaSourceCache;
import org.opendaylight.yangtools.yang.model.repo.spi.PotentialSchemaSource;
-import org.opendaylight.yangtools.yang.model.repo.spi.SchemaListenerRegistration;
import org.opendaylight.yangtools.yang.model.repo.spi.SchemaSourceListener;
import org.opendaylight.yangtools.yang.parser.api.YangParserFactory;
import org.opendaylight.yangtools.yang.parser.repo.SharedSchemaRepository;
private static final Logger LOG = LoggerFactory.getLogger(YangLibProvider.class);
private static final Predicate<PotentialSchemaSource<?>> YANG_SCHEMA_SOURCE =
- input -> YangTextSchemaSource.class.isAssignableFrom(input.getRepresentation());
+ input -> YangTextSource.class.isAssignableFrom(input.getRepresentation());
private final DataBroker dataBroker;
private final String bindingAddress;
private final Uint32 bindingPort;
private final SharedSchemaRepository schemaRepository;
-
- private final SchemaListenerRegistration schemaListenerRegistration;
+ private final Registration schemaListenerRegistration;
@Inject
@Activate
checkArgument(cacheFolderFile.isDirectory(), "cache-folder %s is not a directory", cacheFolderFile);
schemaRepository = new SharedSchemaRepository("yang-library", parserFactory);
- final var cache = new FilesystemSchemaSourceCache<>(schemaRepository, YangTextSchemaSource.class,
- cacheFolderFile);
+ final var cache = new FilesystemSchemaSourceCache<>(schemaRepository, YangTextSource.class, cacheFolderFile);
schemaRepository.registerSchemaSourceListener(cache);
schemaListenerRegistration = schemaRepository.registerSchemaSourceListener(this);
}
@Override
- public void schemaSourceEncountered(final SchemaSourceRepresentation source) {
+ public void schemaSourceEncountered(final SourceRepresentation source) {
// NOOP
}
private String getYangModel(final String name, final String revision) {
final var sourceId = new SourceIdentifier(name, revision);
- final var yangTextSchemaFuture = schemaRepository.getSchemaSource(sourceId, YangTextSchemaSource.class);
+ final var yangTextSchemaFuture = schemaRepository.getSchemaSource(sourceId, YangTextSource.class);
try {
final var yangTextSchemaSource = yangTextSchemaFuture.get();
return yangTextSchemaSource.read();
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.binding.util.BindingMap;
import org.opendaylight.yangtools.yang.common.Uint32;
-import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
-import org.opendaylight.yangtools.yang.model.repo.api.YangIRSchemaSource;
-import org.opendaylight.yangtools.yang.model.repo.api.YangTextSchemaSource;
-import org.opendaylight.yangtools.yang.model.repo.api.YinSchemaSourceRepresentation;
+import org.opendaylight.yangtools.yang.model.api.source.SourceIdentifier;
+import org.opendaylight.yangtools.yang.model.api.source.YangTextSource;
+import org.opendaylight.yangtools.yang.model.api.source.YinSourceRepresentation;
import org.opendaylight.yangtools.yang.model.repo.spi.PotentialSchemaSource;
import org.opendaylight.yangtools.yang.model.repo.spi.PotentialSchemaSource.Costs;
+import org.opendaylight.yangtools.yang.model.spi.source.YangIRSource;
import org.opendaylight.yangtools.yang.parser.impl.DefaultYangParserFactory;
@RunWith(MockitoJUnitRunner.StrictStubs.class)
// test list of non yang schema sources registered
yangLibProvider.schemaSourceRegistered(List.of(
PotentialSchemaSource.create(new SourceIdentifier("yin-source-representation"),
- YinSchemaSourceRepresentation.class, Costs.IMMEDIATE.getValue()),
+ YinSourceRepresentation.class, Costs.IMMEDIATE.getValue()),
PotentialSchemaSource.create(new SourceIdentifier("asts-schema-source"),
- YangIRSchemaSource.class, Costs.IMMEDIATE.getValue())));
+ YangIRSource.class, Costs.IMMEDIATE.getValue())));
// expected behavior is to do nothing
verifyNoMoreInteractions(dataBroker, writeTransaction);
// try to unregister YANG source with revision
final var schemaSourceWithRevision = PotentialSchemaSource.create(
new SourceIdentifier("unregistered-yang-with-revision", "2016-04-28"),
- YangTextSchemaSource.class, Costs.LOCAL_IO.getValue());
+ YangTextSource.class, Costs.LOCAL_IO.getValue());
yangLibProvider.schemaSourceUnregistered(schemaSourceWithRevision);
// source is unregistered
// try to unregister YANG source without revision
final var schemaSourceWithoutRevision = PotentialSchemaSource.create(
- new SourceIdentifier("unregistered-yang-schema-without-revision"), YangTextSchemaSource.class,
+ new SourceIdentifier("unregistered-yang-schema-without-revision"), YangTextSource.class,
Costs.LOCAL_IO.getValue());
yangLibProvider.schemaSourceUnregistered(schemaSourceWithoutRevision);
// try to unregister non-YANG source
final var nonYangSources = PotentialSchemaSource.create(new SourceIdentifier("yin-source-representation"),
- YinSchemaSourceRepresentation.class, Costs.IMMEDIATE.getValue());
+ YinSourceRepresentation.class, Costs.IMMEDIATE.getValue());
yangLibProvider.schemaSourceUnregistered(nonYangSources);
// expected behaviour is to do nothing if non yang based source is unregistered
<parent>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>binding-parent</artifactId>
- <version>12.0.4</version>
+ <version>13.0.0</version>
<relativePath/>
</parent>
<dependency>
<groupId>org.opendaylight.aaa</groupId>
<artifactId>aaa-artifacts</artifactId>
- <version>0.18.4</version>
+ <version>0.19.1</version>
<type>pom</type>
<scope>import</scope>
</dependency>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>bundle-parent</artifactId>
- <version>8.0.4</version>
+ <version>9.0.0</version>
<type>pom</type>
<scope>import</scope>
</dependency>
<packaging>bundle</packaging>
<dependencies>
+ <dependency>
+ <groupId>com.github.spotbugs</groupId>
+ <artifactId>spotbugs-annotations</artifactId>
+ <optional>true</optional>
+ </dependency>
<dependency>
<groupId>com.google.code.gson</groupId>
<artifactId>gson</artifactId>
import com.google.common.base.MoreObjects;
import java.io.Reader;
import java.io.StringReader;
-import java.util.Optional;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.netconf.client.mdsal.api.RemoteDeviceId;
-import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
-import org.opendaylight.yangtools.yang.model.repo.api.YangTextSchemaSource;
+import org.opendaylight.yangtools.yang.model.api.source.SourceIdentifier;
+import org.opendaylight.yangtools.yang.model.api.source.YangTextSource;
/**
- * A {@link YangTextSchemaSource} cached from a remote service.
+ * A {@link YangTextSource} cached from a remote service.
*/
-public final class CachedYangTextSchemaSource extends YangTextSchemaSource {
- private final RemoteDeviceId id;
- private final String schemaString;
- private final String symbolicName;
+// FIXME: subclass StringYangTextSource and cleanup addToStringAttributes()
+public final class CachedYangTextSchemaSource extends YangTextSource {
+ private final @NonNull SourceIdentifier sourceId;
+ private final @NonNull RemoteDeviceId id;
+ private final @NonNull String symbolicName;
+ private final @NonNull String schemaString;
- public CachedYangTextSchemaSource(final RemoteDeviceId id, final SourceIdentifier sourceIdentifier,
+ public CachedYangTextSchemaSource(final RemoteDeviceId id, final SourceIdentifier sourceId,
final String symbolicName, final String schemaString) {
- super(sourceIdentifier);
- this.symbolicName = requireNonNull(symbolicName);
this.id = requireNonNull(id);
+ this.sourceId = requireNonNull(sourceId);
+ this.symbolicName = requireNonNull(symbolicName);
this.schemaString = requireNonNull(schemaString);
}
@Override
- protected MoreObjects.ToStringHelper addToStringAttributes(final MoreObjects.ToStringHelper toStringHelper) {
- return toStringHelper.add("device", id);
+ public Reader openStream() {
+ return new StringReader(schemaString);
}
@Override
- public Reader openStream() {
- return new StringReader(schemaString);
+ public SourceIdentifier sourceId() {
+ return sourceId;
+ }
+
+ @Override
+ public String symbolicName() {
+ return symbolicName;
}
@Override
- public Optional<String> getSymbolicName() {
- return Optional.of(symbolicName);
+ protected MoreObjects.ToStringHelper addToStringAttributes(final MoreObjects.ToStringHelper toStringHelper) {
+ return toStringHelper.add("device", id);
}
}
\ No newline at end of file
import org.opendaylight.yangtools.yang.data.api.schema.MountPointContextFactory;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.model.api.Module;
-import org.opendaylight.yangtools.yang.model.spi.AbstractEffectiveModelContextProvider;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
// TODO: this should really come from rfc8528-data-util
-final class DeviceMountPointContext extends AbstractEffectiveModelContextProvider implements Immutable,
- MountPointContext {
+final class DeviceMountPointContext implements Immutable, MountPointContext {
private static final Logger LOG = LoggerFactory.getLogger(DeviceMountPointContext.class);
private static final NodeIdentifier MOUNT_POINT = NodeIdentifier.create(
QName.create(SchemaMountConstants.RFC8528_MODULE, "mount-point").intern());
QName.create(SchemaMountConstants.RFC8528_MODULE, "parent-reference").intern());
private final ImmutableMap<MountPointLabel, NetconfMountPointContextFactory> mountPoints;
+ private final @NonNull EffectiveModelContext modelContext;
- private DeviceMountPointContext(final EffectiveModelContext schemaContext,
+ private DeviceMountPointContext(final EffectiveModelContext modelContext,
final Map<MountPointLabel, NetconfMountPointContextFactory> mountPoints) {
- super(schemaContext);
+ this.modelContext = requireNonNull(modelContext);
this.mountPoints = ImmutableMap.copyOf(mountPoints);
}
return emptyContext;
}
- final EffectiveModelContext schemaContext = emptyContext.getEffectiveModelContext();
+ final EffectiveModelContext schemaContext = emptyContext.modelContext();
final DataContainerChild mountPoint = optMountPoint.orElseThrow();
checkArgument(mountPoint instanceof MapNode, "mount-point list %s is not a MapNode", mountPoint);
return new DeviceMountPointContext(schemaContext, mountPoints);
}
+ @Override
+ public EffectiveModelContext modelContext() {
+ return modelContext;
+ }
+
@Override
public Optional<MountPointContextFactory> findMountPoint(@NonNull final MountPointLabel label) {
return Optional.ofNullable(mountPoints.get(requireNonNull(label)));
import org.opendaylight.yangtools.concepts.Registration;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.Revision;
-import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
-import org.opendaylight.yangtools.yang.model.repo.api.YangTextSchemaSource;
+import org.opendaylight.yangtools.yang.model.api.source.SourceIdentifier;
+import org.opendaylight.yangtools.yang.model.api.source.YangTextSource;
import org.opendaylight.yangtools.yang.model.repo.spi.PotentialSchemaSource;
import org.opendaylight.yangtools.yang.model.repo.spi.SchemaSourceProvider;
import org.opendaylight.yangtools.yang.model.repo.spi.SchemaSourceRegistry;
final class DeviceSources {
private final Set<QName> requiredSources;
private final Set<QName> providedSources;
- private final SchemaSourceProvider<YangTextSchemaSource> sourceProvider;
+ private final SchemaSourceProvider<YangTextSource> sourceProvider;
DeviceSources(final Set<QName> requiredSources, final Set<QName> providedSources,
- final SchemaSourceProvider<YangTextSchemaSource> sourceProvider) {
+ final SchemaSourceProvider<YangTextSource> sourceProvider) {
this.requiredSources = requireNonNull(requiredSources);
this.providedSources = requireNonNull(providedSources);
this.sourceProvider = requireNonNull(sourceProvider);
return providedSources.stream()
.map(DeviceSources::toSourceId)
.map(sourceId -> schemaRegistry.registerSchemaSource(sourceProvider,
- PotentialSchemaSource.create(sourceId, YangTextSchemaSource.class,
+ PotentialSchemaSource.create(sourceId, YangTextSource.class,
PotentialSchemaSource.Costs.REMOTE_IO.getValue())))
.collect(Collectors.toUnmodifiableList());
}
@Override
public DeviceSources call() {
final var availableSchemas = stateSchemasResolver.resolve(deviceRpc, remoteSessionCapabilities, id,
- baseSchema.getEffectiveModelContext());
+ baseSchema.modelContext());
LOG.debug("{}: Schemas exposed by ietf-netconf-monitoring: {}", id,
availableSchemas.getAvailableYangSchemasQNames());
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNormalizedNodeStreamWriter;
import org.opendaylight.yangtools.yang.data.impl.schema.NormalizationResultHolder;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
-import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
+import org.opendaylight.yangtools.yang.model.api.source.SourceIdentifier;
import org.opendaylight.yangtools.yang.model.util.SchemaInferenceStack;
import org.opendaylight.yangtools.yang.model.util.SchemaInferenceStack.Inference;
import org.slf4j.Logger;
import java.nio.charset.StandardCharsets;
import java.util.Map;
import org.opendaylight.netconf.client.mdsal.api.RemoteDeviceId;
+import org.opendaylight.yangtools.yang.model.api.source.SourceIdentifier;
+import org.opendaylight.yangtools.yang.model.api.source.YangTextSource;
import org.opendaylight.yangtools.yang.model.repo.api.SchemaSourceException;
-import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
-import org.opendaylight.yangtools.yang.model.repo.api.YangTextSchemaSource;
import org.opendaylight.yangtools.yang.model.repo.spi.SchemaSourceProvider;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
* Provides YANG schema sources from YANG library. The set of available sources is pre-determined when this provider
* is created, but each source is acquired on demand.
*/
-public final class LibrarySchemaSourceProvider implements SchemaSourceProvider<YangTextSchemaSource> {
+public final class LibrarySchemaSourceProvider implements SchemaSourceProvider<YangTextSource> {
private static final Logger LOG = LoggerFactory.getLogger(LibrarySchemaSourceProvider.class);
private final ImmutableMap<SourceIdentifier, URL> availableSources;
}
@Override
- public ListenableFuture<? extends YangTextSchemaSource> getSource(final SourceIdentifier sourceIdentifier) {
+ public ListenableFuture<? extends YangTextSource> getSource(final SourceIdentifier sourceIdentifier) {
final var url = availableSources.get(requireNonNull(sourceIdentifier));
checkArgument(url != null);
schemaContent = in.readAllBytes();
} catch (IOException e) {
LOG.warn("Unable to download source {} from a yang library's url {}", sourceIdentifier, url, e);
- return Futures.immediateFailedFuture(new SchemaSourceException(
+ return Futures.immediateFailedFuture(new SchemaSourceException(sourceIdentifier,
"Unable to download remote schema for " + sourceIdentifier + " from " + url, e));
}
import org.opendaylight.yangtools.yang.data.api.schema.LeafNode;
import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
-import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
-import org.opendaylight.yangtools.yang.model.repo.api.YangTextSchemaSource;
+import org.opendaylight.yangtools.yang.model.api.source.SourceIdentifier;
+import org.opendaylight.yangtools.yang.model.api.source.YangTextSource;
import org.opendaylight.yangtools.yang.model.repo.spi.SchemaSourceProvider;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.w3c.dom.Element;
/**
- * A {@link SchemaSourceProvider} producing {@link YangTextSchemaSource}s based on a device's
+ * A {@link SchemaSourceProvider} producing {@link YangTextSource}s based on a device's
* {@code ietf-netconf-monitoring} interface. The set of available sources is not pre-determined and each request is
* dispatched to the device, i.e. this provider reflects real-time updates to available schemas.
*/
-public final class MonitoringSchemaSourceProvider implements SchemaSourceProvider<YangTextSchemaSource> {
+public final class MonitoringSchemaSourceProvider implements SchemaSourceProvider<YangTextSource> {
private static final Logger LOG = LoggerFactory.getLogger(MonitoringSchemaSourceProvider.class);
private static final NodeIdentifier FORMAT_PATHARG =
NodeIdentifier.create(QName.create(GetSchema.QNAME, "format").intern());
}
@Override
- public ListenableFuture<YangTextSchemaSource> getSource(final SourceIdentifier sourceIdentifier) {
+ public ListenableFuture<YangTextSource> getSource(final SourceIdentifier sourceIdentifier) {
final String moduleName = sourceIdentifier.name().getLocalName();
final Optional<String> revision = Optional.ofNullable(sourceIdentifier.revision()).map(Revision::toString);
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.MountPointContext;
import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
+import org.opendaylight.yangtools.yang.data.spi.node.ImmutableNodes;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
+import org.opendaylight.yangtools.yang.model.api.source.SourceIdentifier;
+import org.opendaylight.yangtools.yang.model.api.source.YangTextSource;
import org.opendaylight.yangtools.yang.model.repo.api.EffectiveModelContextFactory;
import org.opendaylight.yangtools.yang.model.repo.api.MissingSchemaSourceException;
import org.opendaylight.yangtools.yang.model.repo.api.SchemaRepository;
import org.opendaylight.yangtools.yang.model.repo.api.SchemaResolutionException;
-import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
-import org.opendaylight.yangtools.yang.model.repo.api.YangTextSchemaSource;
import org.opendaylight.yangtools.yang.model.repo.spi.SchemaSourceRegistry;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
LOG.debug("{}: Session to remote device established with {}", id, remoteSessionCapabilities);
final BaseSchema baseSchema = resolveBaseSchema(remoteSessionCapabilities.isNotificationsSupported());
- final NetconfDeviceRpc initRpc = new NetconfDeviceRpc(baseSchema.getEffectiveModelContext(), listener,
+ final NetconfDeviceRpc initRpc = new NetconfDeviceRpc(baseSchema.modelContext(), listener,
new NetconfMessageTransformer(baseSchema.getMountPointContext(), false, baseSchema));
final var sourceResolverFuture = Futures.submit(new DeviceSourcesResolver(id, baseSchema, initRpc,
remoteSessionCapabilities, stateSchemasResolver), processingExecutor);
final NetconfDeviceRpc deviceRpc = new NetconfDeviceRpc(schemaContext, listener,
new NetconfMessageTransformer(emptyContext, false, baseSchema));
- return Futures.transform(deviceRpc.domRpcService().invokeRpc(Get.QNAME, Builders.containerBuilder()
+ return Futures.transform(deviceRpc.domRpcService().invokeRpc(Get.QNAME, ImmutableNodes.newContainerBuilder()
.withNodeIdentifier(NETCONF_GET_NODEID)
.withChild(NetconfMessageTransformUtil.toFilterStructure(RFC8528_SCHEMA_MOUNTS, schemaContext))
.build()), rpcResult -> processSchemaMounts(rpcResult, emptyContext), MoreExecutors.directExecutor());
protected NetconfDeviceRpc getDeviceSpecificRpc(final MountPointContext result,
final RemoteDeviceCommunicator listener, final BaseSchema schema) {
- return new NetconfDeviceRpc(result.getEffectiveModelContext(), listener,
+ return new NetconfDeviceRpc(result.modelContext(), listener,
new NetconfMessageTransformer(result, true, schema));
}
if (remoteSessionCapabilities.containsNonModuleCapability(CapabilityURN.NOTIFICATION)) {
// FIXME: mutable collection modification!
deviceSources.getRequiredSourcesQName().addAll(List.of(
- org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.netconf.notification._1._0.rev080714
- .$YangModuleInfoImpl.getInstance().getName(),
- org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715
- .$YangModuleInfoImpl.getInstance().getName())
+ org.opendaylight.yang.svc.v1.urn.ietf.params.xml.ns.netconf.notification._1._0.rev080714
+ .YangModuleInfoImpl.getInstance().getName(),
+ org.opendaylight.yang.svc.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715
+ .YangModuleInfoImpl.getInstance().getName())
);
}
private List<SourceIdentifier> filterMissingSources(final Collection<SourceIdentifier> origSources) {
return origSources.parallelStream().filter(sourceIdentifier -> {
try {
- schemaRepository.getSchemaSource(sourceIdentifier, YangTextSchemaSource.class).get();
+ schemaRepository.getSchemaSource(sourceIdentifier, YangTextSource.class).get();
return false;
} catch (InterruptedException | ExecutionException e) {
return true;
private List<SourceIdentifier> handleMissingSchemaSourceException(
final MissingSchemaSourceException exception) {
// In case source missing, try without it
- final SourceIdentifier missingSource = exception.getSourceId();
+ final SourceIdentifier missingSource = exception.sourceId();
LOG.warn("{}: Unable to build schema context, missing source {}, will reattempt without it",
id, missingSource);
LOG.debug("{}: Unable to build schema context, missing source {}, will reattempt without it",
// In case resolution error, try only with resolved sources
// There are two options why schema resolution exception occurred : unsatisfied imports or flawed model
// FIXME Do we really have assurance that these two cases cannot happen at once?
- if (resolutionException.getFailedSource() != null) {
+ final var failedSourceId = resolutionException.sourceId();
+ if (failedSourceId != null) {
// flawed model - exclude it
- final SourceIdentifier failedSourceId = resolutionException.getFailedSource();
LOG.warn("{}: Unable to build schema context, failed to resolve source {}, will reattempt without it",
id, failedSourceId);
LOG.warn("{}: Unable to build schema context, failed to resolve source {}, will reattempt without it",
id, failedSourceId, resolutionException);
addUnresolvedCapabilities(getQNameFromSourceIdentifiers(List.of(failedSourceId)),
UnavailableCapability.FailureReason.UnableToResolve);
- return stripUnavailableSource(resolutionException.getFailedSource());
+ return stripUnavailableSource(failedSourceId);
}
// unsatisfied imports
addUnresolvedCapabilities(
import org.opendaylight.netconf.client.mdsal.api.NetconfSessionPreferences;
import org.opendaylight.netconf.client.mdsal.api.RemoteDeviceId;
import org.opendaylight.netconf.client.mdsal.spi.NetconfDeviceRpc;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.library.rev190104.$YangModuleInfoImpl;
+import org.opendaylight.yang.svc.v1.urn.ietf.params.xml.ns.yang.ietf.yang.library.rev190104.YangModuleInfoImpl;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.common.Revision;
* Default implementation resolving schemas QNames from netconf-state or from modules-state.
*/
public final class NetconfStateSchemasResolverImpl implements NetconfDeviceSchemasResolver {
- private static final QName RFC8525_YANG_LIBRARY_CAPABILITY = $YangModuleInfoImpl.getInstance().getName();
+ private static final QName RFC8525_YANG_LIBRARY_CAPABILITY = YangModuleInfoImpl.getInstance().getName();
private static final QName RFC7895_YANG_LIBRARY_CAPABILITY = RFC8525_YANG_LIBRARY_CAPABILITY
.bindTo(QNameModule.create(RFC8525_YANG_LIBRARY_CAPABILITY.getNamespace(), Revision.of("2016-06-21"))).intern();
import com.google.common.util.concurrent.ListenableFuture;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.mdsal.dom.api.DOMExtensibleService;
import org.opendaylight.mdsal.dom.api.DOMRpcException;
import org.opendaylight.mdsal.dom.api.DOMRpcResult;
import org.opendaylight.mdsal.dom.api.DOMService;
-import org.opendaylight.mdsal.dom.api.DOMServiceExtension;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.netconf.base._1._0.rev110601.CancelCommit;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.netconf.base._1._0.rev110601.CloseSession;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.netconf.base._1._0.rev110601.Commit;
* A {@link DOMService} capturing the ability to invoke NETCONF RPCs through
* {@link #invokeNetconf(QName, ContainerNode)}.
*/
-public interface NetconfRpcService extends DOMExtensibleService<NetconfRpcService, NetconfRpcService.Extension> {
+public interface NetconfRpcService extends DOMService<NetconfRpcService, NetconfRpcService.Extension> {
/**
* Invoke a well-known RPC. This method is guaranteed to support the following RPCs:
* <ul>
* </ul>
*
* <p>
- * The support for other RPCs is advertized through {@link #getExtensions()}.
+ * The support for other RPCs is advertized through {@link #supportedExtensions()}.
*
* @param type QName of the RPC to be invoked
* @param input Input arguments, null if the RPC does not take any.
* Extensions to {@link NetconfRpcService} defining additional RPC availability.
*/
// Note: This is not an interface on purpose, to make the set of extensions well-known
- enum Extension implements DOMServiceExtension<NetconfRpcService, Extension> {
+ enum Extension implements DOMService.Extension<NetconfRpcService, Extension> {
/**
* This device supports
* <a href="https://www.rfc-editor.org/rfc/rfc4741#section-8.3">Candidate Configuration Capability</a>.
import org.opendaylight.netconf.client.NetconfClientSession;
import org.opendaylight.netconf.client.mdsal.impl.NetconfMessageTransformUtil;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.netconf.base._1._0.rev110601.SessionIdType;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.notifications.rev120206.$YangModuleInfoImpl;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.device.rev240120.connection.oper.available.capabilities.AvailableCapability.CapabilityOrigin;
+import org.opendaylight.yang.svc.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.notifications.rev120206.YangModuleInfoImpl;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.slf4j.Logger;
public boolean isNotificationsSupported() {
return containsPartialNonModuleCapability(CapabilityURN.NOTIFICATION)
- || containsModuleCapability($YangModuleInfoImpl.getInstance().getName());
+ || containsModuleCapability(YangModuleInfoImpl.getInstance().getName());
}
public boolean isMonitoringSupported() {
import com.google.common.util.concurrent.ListenableFuture;
import javax.xml.transform.dom.DOMSource;
import org.eclipse.jdt.annotation.NonNull;
+import org.opendaylight.mdsal.dom.api.DOMRpcService;
import org.opendaylight.mdsal.dom.api.DOMService;
import org.opendaylight.yangtools.yang.common.QName;
* A {@link DOMService} exposing RPC invocation model based either {@code ContainerNode} or {@code AnyxmlNode}.
*/
@Beta
-public interface SchemalessRpcService extends DOMService {
+public interface SchemalessRpcService extends DOMService<SchemalessRpcService, SchemalessRpcService.Extension> {
+ /**
+ * Marker interface for an extension to {@link DOMRpcService}.
+ */
+ interface Extension extends DOMService.Extension<SchemalessRpcService, Extension> {
+ // Marker interface
+ }
@NonNull ListenableFuture<? extends DOMSource> invokeRpc(@NonNull QName type, @NonNull DOMSource payload);
}
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.RpcResult;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
-import org.opendaylight.yangtools.yang.data.api.schema.DOMSourceAnyxmlNode;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
-import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
+import org.opendaylight.yangtools.yang.data.spi.node.ImmutableNodes;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.model.api.RpcDefinition;
import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier.Absolute;
public BaseRpcSchemalessTransformer(final BaseNetconfSchemas baseSchemas, final MessageCounter counter) {
final var baseSchema = baseSchemas.baseSchema();
mappedRpcs = baseSchema.getMappedRpcs();
- modelContext = baseSchema.getEffectiveModelContext();
+ modelContext = baseSchema.modelContext();
this.counter = counter;
}
final Element xmlData = NetconfMessageTransformUtil.getDataSubtree(message.getDocument());
final Document data = XmlUtil.newDocument();
data.appendChild(data.importNode(xmlData, true));
- DOMSourceAnyxmlNode xmlDataNode = Builders.anyXmlBuilder()
+
+ normalizedNode = ImmutableNodes.newContainerBuilder()
+ .withNodeIdentifier(NetconfMessageTransformUtil.NETCONF_RPC_REPLY_NODEID)
+ .withChild(ImmutableNodes.newAnyxmlBuilder(DOMSource.class)
.withNodeIdentifier(NetconfMessageTransformUtil.NETCONF_DATA_NODEID)
.withValue(new DOMSource(data))
- .build();
-
- normalizedNode = Builders.containerBuilder()
- .withNodeIdentifier(NetconfMessageTransformUtil.NETCONF_RPC_REPLY_NODEID)
- .withChild(xmlDataNode).build();
+ .build())
+ .build();
} else {
//other base rpcs don't have any output, we can simply construct the payload here
checkArgument(isOkPresent(message.getDocument()),
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.schema.MountPointContext;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
-import org.opendaylight.yangtools.yang.model.api.EffectiveModelContextProvider;
import org.opendaylight.yangtools.yang.model.api.RpcDefinition;
-public final class BaseSchema implements EffectiveModelContextProvider, Immutable {
+public final class BaseSchema implements Immutable {
private final @NonNull ImmutableMap<QName, ? extends RpcDefinition> mappedRpcs;
private final @NonNull MountPointContext mountContext;
mappedRpcs = Maps.uniqueIndex(context.getOperations(), RpcDefinition::getQName);
}
+ public @NonNull EffectiveModelContext modelContext() {
+ return mountContext.modelContext();
+ }
+
@NonNull ImmutableMap<QName, ? extends RpcDefinition> getMappedRpcs() {
return mappedRpcs;
}
public @NonNull MountPointContext getMountPointContext() {
return mountContext;
}
-
- @Override
- public @NonNull EffectiveModelContext getEffectiveModelContext() {
- return mountContext.getEffectiveModelContext();
- }
}
public DefaultBaseNetconfSchemas(@Reference final YangParserFactory parserFactory) throws YangParserException {
this(
new BaseSchema(BindingRuntimeHelpers.createEffectiveModel(parserFactory, List.of(
- org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.netconf.base._1._0.rev110601
- .$YangModuleInfoImpl.getInstance(),
- org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.monitoring.rev101004
- .$YangModuleInfoImpl.getInstance()))),
+ org.opendaylight.yang.svc.v1.urn.ietf.params.xml.ns.netconf.base._1._0.rev110601
+ .YangModuleInfoImpl.getInstance(),
+ org.opendaylight.yang.svc.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.monitoring.rev101004
+ .YangModuleInfoImpl.getInstance()))),
new BaseSchema(BindingRuntimeHelpers.createEffectiveModel(parserFactory, List.of(
- org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.netconf.notification._1._0.rev080714
- .$YangModuleInfoImpl.getInstance(),
- org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.netconf.base._1._0.rev110601
- .$YangModuleInfoImpl.getInstance(),
- org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.monitoring.rev101004
- .$YangModuleInfoImpl.getInstance(),
- org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.notifications.rev120206
- .$YangModuleInfoImpl.getInstance()))));
+ org.opendaylight.yang.svc.v1.urn.ietf.params.xml.ns.netconf.notification._1._0.rev080714
+ .YangModuleInfoImpl.getInstance(),
+ org.opendaylight.yang.svc.v1.urn.ietf.params.xml.ns.netconf.base._1._0.rev110601
+ .YangModuleInfoImpl.getInstance(),
+ org.opendaylight.yang.svc.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.monitoring.rev101004
+ .YangModuleInfoImpl.getInstance(),
+ org.opendaylight.yang.svc.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.notifications.rev120206
+ .YangModuleInfoImpl.getInstance()))));
}
}
*/
package org.opendaylight.netconf.client.mdsal.impl;
-import com.google.common.collect.Iterables;
-import java.util.Collection;
import java.util.Map;
import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.mdsal.binding.api.ClusteredDataTreeChangeListener;
import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataListener;
import org.opendaylight.mdsal.binding.api.DataTreeIdentifier;
-import org.opendaylight.mdsal.binding.api.DataTreeModification;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netconf.client.mdsal.api.CredentialProvider;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.keystore.rev171017.Keystore;
@Singleton
@Component(service = CredentialProvider.class)
-public final class DefaultCredentialProvider
- implements CredentialProvider, ClusteredDataTreeChangeListener<Keystore>, AutoCloseable {
+public final class DefaultCredentialProvider implements CredentialProvider, DataListener<Keystore>, AutoCloseable {
private static final Logger LOG = LoggerFactory.getLogger(DefaultCredentialProvider.class);
private final @NonNull Registration reg;
@Inject
@Activate
public DefaultCredentialProvider(@Reference final DataBroker dataBroker) {
- reg = dataBroker.registerDataTreeChangeListener(
- DataTreeIdentifier.create(LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(Keystore.class)),
- this);
+ reg = dataBroker.registerDataListener(
+ DataTreeIdentifier.of(LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(Keystore.class)), this);
}
@Deactivate
}
@Override
- public void onDataTreeChanged(final Collection<DataTreeModification<Keystore>> changes) {
- final var keystore = Iterables.getLast(changes).getRootNode().getDataAfter();
- final var newCredentials = keystore != null ? keystore.nonnullKeyCredential()
+ public void dataChangedTo(final Keystore data) {
+ final var newCredentials = data != null ? data.nonnullKeyCredential()
: Map.<KeyCredentialKey, KeyCredential>of();
LOG.debug("Updating to {} credentials", newCredentials.size());
credentials = newCredentials;
import org.opendaylight.netconf.client.mdsal.NetconfDevice.SchemaResourcesDTO;
import org.opendaylight.netconf.client.mdsal.NetconfStateSchemasResolverImpl;
import org.opendaylight.netconf.client.mdsal.api.SchemaResourceManager;
+import org.opendaylight.yangtools.yang.model.api.source.YangTextSource;
import org.opendaylight.yangtools.yang.model.repo.api.SchemaContextFactoryConfiguration;
-import org.opendaylight.yangtools.yang.model.repo.api.YangIRSchemaSource;
-import org.opendaylight.yangtools.yang.model.repo.api.YangTextSchemaSource;
import org.opendaylight.yangtools.yang.model.repo.fs.FilesystemSchemaSourceCache;
import org.opendaylight.yangtools.yang.model.repo.spi.SoftSchemaSourceCache;
+import org.opendaylight.yangtools.yang.model.spi.source.YangIRSource;
import org.opendaylight.yangtools.yang.parser.api.YangParserFactory;
import org.opendaylight.yangtools.yang.parser.repo.SharedSchemaRepository;
import org.opendaylight.yangtools.yang.parser.rfc7950.repo.TextToIRTransformer;
// for a consistent set of modules, as it skips the need to re-parse the text sources multiple times. It also
// helps establishing different sets of contexts, as they can share this pre-made cache.
repository.registerSchemaSourceListener(
- new SoftSchemaSourceCache<>(repository, YangIRSchemaSource.class));
+ new SoftSchemaSourceCache<>(repository, YangIRSource.class));
// Attach the filesystem cache, providing persistence capability, so that restarts do not require us to
// re-populate the cache. This also acts as a side-load capability, as anything pre-populated into that
// directory will not be fetched from the device.
repository.registerSchemaSourceListener(new FilesystemSchemaSourceCache<>(repository,
- YangTextSchemaSource.class, new File(rootDirectory + File.separator + subdir)));
+ YangTextSource.class, new File(rootDirectory + File.separator + subdir)));
return new SchemaResourcesDTO(repository, repository,
repository.createEffectiveModelContextFactory(SchemaContextFactoryConfiguration.getDefault()),
import java.security.spec.InvalidKeySpecException;
import java.security.spec.PKCS8EncodedKeySpec;
import java.util.Base64;
-import java.util.Collection;
import java.util.HashMap;
+import java.util.List;
import java.util.Map;
import java.util.Set;
import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.mdsal.binding.api.ClusteredDataTreeChangeListener;
import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.mdsal.binding.api.DataObjectModification;
+import org.opendaylight.mdsal.binding.api.DataTreeChangeListener;
import org.opendaylight.mdsal.binding.api.DataTreeIdentifier;
import org.opendaylight.mdsal.binding.api.DataTreeModification;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
@Singleton
@Component(service = SslHandlerFactoryProvider.class)
public final class DefaultSslHandlerFactoryProvider
- implements SslHandlerFactoryProvider, ClusteredDataTreeChangeListener<Keystore>, AutoCloseable {
+ implements SslHandlerFactoryProvider, DataTreeChangeListener<Keystore>, AutoCloseable {
/**
* Internal state, updated atomically.
*/
@Inject
@Activate
public DefaultSslHandlerFactoryProvider(@Reference final DataBroker dataBroker) {
- reg = dataBroker.registerDataTreeChangeListener(
- DataTreeIdentifier.create(LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(Keystore.class)),
- this);
+ reg = dataBroker.registerTreeChangeListener(
+ DataTreeIdentifier.of(LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(Keystore.class)), this);
}
@Deactivate
}
@Override
- public void onDataTreeChanged(final Collection<DataTreeModification<Keystore>> changes) {
+ public void onDataTreeChanged(final List<DataTreeModification<Keystore>> changes) {
LOG.debug("Starting update with {} changes", changes.size());
final var builder = state.newBuilder();
onDataTreeChanged(builder, changes);
}
private static void onDataTreeChanged(final StateBuilder builder,
- final Collection<DataTreeModification<Keystore>> changes) {
+ final List<DataTreeModification<Keystore>> changes) {
for (var change : changes) {
LOG.debug("Processing change {}", change);
final var rootNode = change.getRootNode();
- for (var changedChild : rootNode.getModifiedChildren()) {
- if (changedChild.getDataType().equals(PrivateKey.class)) {
+ for (var changedChild : rootNode.modifiedChildren()) {
+ if (changedChild.dataType().equals(PrivateKey.class)) {
onPrivateKeyChanged(builder.privateKeys, (DataObjectModification<PrivateKey>)changedChild);
- } else if (changedChild.getDataType().equals(TrustedCertificate.class)) {
+ } else if (changedChild.dataType().equals(TrustedCertificate.class)) {
onTrustedCertificateChanged(builder.trustedCertificates,
(DataObjectModification<TrustedCertificate>)changedChild);
}
private static void onPrivateKeyChanged(final HashMap<String, PrivateKey> privateKeys,
final DataObjectModification<PrivateKey> objectModification) {
- switch (objectModification.getModificationType()) {
+ switch (objectModification.modificationType()) {
case SUBTREE_MODIFIED:
case WRITE:
- final var privateKey = objectModification.getDataAfter();
+ final var privateKey = objectModification.dataAfter();
privateKeys.put(privateKey.getName(), privateKey);
break;
case DELETE:
- privateKeys.remove(objectModification.getDataBefore().getName());
+ privateKeys.remove(objectModification.dataBefore().getName());
break;
default:
break;
private static void onTrustedCertificateChanged(final HashMap<String, TrustedCertificate> trustedCertificates,
final DataObjectModification<TrustedCertificate> objectModification) {
- switch (objectModification.getModificationType()) {
+ switch (objectModification.modificationType()) {
case SUBTREE_MODIFIED:
case WRITE:
- final var trustedCertificate = objectModification.getDataAfter();
+ final var trustedCertificate = objectModification.dataAfter();
trustedCertificates.put(trustedCertificate.getName(), trustedCertificate);
break;
case DELETE:
- trustedCertificates.remove(objectModification.getDataBefore().getName());
+ trustedCertificates.remove(objectModification.dataBefore().getName());
break;
default:
break;
return addCallback(requireNonNull(callback), rpc.invokeNetconf(Get.QNAME,
nonEmptyFilter(filterPath)
.map(path -> NetconfMessageTransformUtil.wrap(NETCONF_GET_NODEID,
- toFilterStructure(path, mountContext.getEffectiveModelContext())))
+ toFilterStructure(path, mountContext.modelContext())))
.orElse(NetconfMessageTransformUtil.GET_RPC_CONTENT)));
}
package org.opendaylight.netconf.client.mdsal.impl;
import static java.util.Objects.requireNonNull;
-import static org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.netconf.base._1._0.rev110601.$YangModuleInfoImpl.qnameOf;
+import static org.opendaylight.yang.svc.v1.urn.ietf.params.xml.ns.netconf.base._1._0.rev110601.YangModuleInfoImpl.qnameOf;
import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableList;
* @param lastChildOverride Optional of {@code NormalizedNode} data on which action will be invoked
* @return {@link DOMSourceAnyxmlNode} containing edit-config structure
*/
- public static DOMSourceAnyxmlNode createEditConfigAnyxml(
- final EffectiveModelContext ctx, final YangInstanceIdentifier dataPath,
- final Optional<EffectiveOperation> operation, final Optional<NormalizedNode> lastChildOverride) {
+ public static AnyxmlNode<DOMSource> createEditConfigAnyxml(final EffectiveModelContext ctx,
+ final YangInstanceIdentifier dataPath, final Optional<EffectiveOperation> operation,
+ final Optional<NormalizedNode> lastChildOverride) {
if (dataPath.isEmpty()) {
final var override = lastChildOverride.orElseThrow(() -> new IllegalArgumentException(
"Data has to be present when creating structure for top level element"));
final Element actionNS = document.createElementNS(YangConstants.RFC6020_YANG_NAMESPACE_STRING, "action");
final DataSchemaContext rootSchemaContextNode = dataSchemaContextTree.getRoot();
final Element actionData = prepareActionData(rootSchemaContextNode, actionNS,
- domDataTreeIdentifier.getRootIdentifier().getPathArguments().iterator(), document);
+ domDataTreeIdentifier.path().getPathArguments().iterator(), document);
final Element specificActionElement =
document.createElementNS(action.getNamespace().toString(), action.getLocalName());
import java.util.Collections;
import java.util.Deque;
import java.util.HashMap;
-import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
counter = new MessageCounter();
this.mountContext = requireNonNull(mountContext);
- final EffectiveModelContext schemaContext = mountContext.getEffectiveModelContext();
- contextTree = DataSchemaContextTree.from(schemaContext);
+ final EffectiveModelContext modelContext = mountContext.modelContext();
+ contextTree = DataSchemaContextTree.from(modelContext);
- mappedRpcs = Maps.uniqueIndex(schemaContext.getOperations(), SchemaNode::getQName);
- actions = getActions(schemaContext);
+ mappedRpcs = Maps.uniqueIndex(modelContext.getOperations(), SchemaNode::getQName);
+ actions = getActions(modelContext);
// RFC6020 normal notifications
- mappedNotifications = Multimaps.index(schemaContext.getNotifications(),
+ mappedNotifications = Multimaps.index(modelContext.getNotifications(),
node -> node.getQName().withoutRevision());
this.baseSchema = baseSchema;
this.strictParsing = strictParsing;
try {
final NormalizedNodeStreamWriter writer = ImmutableNormalizedNodeStreamWriter.from(resultHolder);
final XmlParserStream xmlParser = XmlParserStream.create(writer, mountContext,
- SchemaInferenceStack.of(mountContext.getEffectiveModelContext(), notificationPath).toInference(),
- strictParsing);
+ SchemaInferenceStack.of(mountContext.modelContext(), notificationPath).toInference(), strictParsing);
xmlParser.traverse(new DOMSource(element));
} catch (XMLStreamException | IOException | UnsupportedOperationException e) {
throw new IllegalArgumentException(String.format("Failed to parse notification %s", element), e);
private Optional<NestedNotificationInfo> findNestedNotification(final NetconfMessage message,
final Element element) {
- final Iterator<? extends Module> modules = mountContext.getEffectiveModelContext()
- .findModules(XMLNamespace.of(element.getNamespaceURI())).iterator();
+ final var modules = mountContext.modelContext().findModules(XMLNamespace.of(element.getNamespaceURI()))
+ .iterator();
if (!modules.hasNext()) {
throw new IllegalArgumentException(
"Unable to parse notification " + message + ", cannot find top level module");
schemaBuilder.add(schemaNode.getQName());
return new NestedNotificationInfo(Absolute.of(schemaBuilder),
- new DOMDataTreeIdentifier(LogicalDatastoreType.CONFIGURATION, instanceBuilder.build()), xmlNode);
+ DOMDataTreeIdentifier.of(LogicalDatastoreType.CONFIGURATION, instanceBuilder.build()), xmlNode);
}
throw new IllegalStateException("No notification found");
}
// If the schema context for netconf device does not contain model for base netconf operations,
// use default pre build context with just the base model
// This way operations like lock/unlock are supported even if the source for base model was not provided
- final EffectiveModelContext ctx = needToUseBaseCtx ? baseSchema.getEffectiveModelContext()
- : mountContext.getEffectiveModelContext();
- NetconfMessageTransformUtil.writeNormalizedOperationInput(payload, result, Absolute.of(rpc), ctx);
+ final var modelContext = needToUseBaseCtx ? baseSchema.modelContext() : mountContext.modelContext();
+ NetconfMessageTransformUtil.writeNormalizedOperationInput(payload, result, Absolute.of(rpc), modelContext);
} catch (final XMLStreamException | IOException | IllegalStateException e) {
throw new IllegalStateException("Unable to serialize input of " + rpc, e);
}
domDataTreeIdentifier, counter, actionDef.getQName());
try {
NetconfMessageTransformUtil.writeNormalizedOperationInput((ContainerNode) payload, result, action,
- mountContext.getEffectiveModelContext());
+ mountContext.modelContext());
} catch (final XMLStreamException | IOException | IllegalStateException e) {
throw new IllegalStateException("Unable to serialize input of " + action, e);
}
.add(operOutput.getQName())
.build());
// FIXME: we should have a cached inference here, or XMLParserStream should accept Absolute instead
- final var inference = SchemaInferenceStack.of(mountContext.getEffectiveModelContext(), outputPath)
- .toInference();
+ final var inference = SchemaInferenceStack.of(mountContext.modelContext(), outputPath).toInference();
final NormalizationResultHolder resultHolder = new NormalizationResultHolder();
final Element element = message.getDocument().getDocumentElement();
import java.util.List;
import java.util.Optional;
import javax.xml.stream.XMLStreamException;
+import javax.xml.transform.dom.DOMSource;
import org.opendaylight.netconf.api.EffectiveOperation;
import org.opendaylight.netconf.common.mdsal.NormalizedDataUtil;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
}
@Override
- public DOMSourceAnyxmlNode createEditConfigStructure(final Optional<NormalizedNode> data,
- final YangInstanceIdentifier dataPath,
- final Optional<EffectiveOperation> operation) {
+ public AnyxmlNode<DOMSource> createEditConfigStructure(final Optional<NormalizedNode> data,
+ final YangInstanceIdentifier dataPath, final Optional<EffectiveOperation> operation) {
// FIXME: propagate MountPointContext
- return NetconfMessageTransformUtil.createEditConfigAnyxml(mountContext.getEffectiveModelContext(), dataPath,
- operation, data);
+ return NetconfMessageTransformUtil.createEditConfigAnyxml(mountContext.modelContext(), dataPath, operation,
+ data);
}
@Override
public AnyxmlNode<?> toFilterStructure(final YangInstanceIdentifier path) {
// FIXME: propagate MountPointContext
- return NetconfMessageTransformUtil.toFilterStructure(path, mountContext.getEffectiveModelContext());
+ return NetconfMessageTransformUtil.toFilterStructure(path, mountContext.modelContext());
}
@Override
public AnyxmlNode<?> toFilterStructure(final List<FieldsFilter> fieldsFilters) {
// FIXME: propagate MountPointContext
- return NetconfMessageTransformUtil.toFilterStructure(fieldsFilters, mountContext.getEffectiveModelContext());
+ return NetconfMessageTransformUtil.toFilterStructure(fieldsFilters, mountContext.modelContext());
}
}
import com.google.common.annotations.VisibleForTesting;
import com.google.common.collect.ImmutableClassToInstanceMap;
import com.google.common.util.concurrent.FutureCallback;
+import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.MoreExecutors;
import com.google.common.util.concurrent.SettableFuture;
-import java.util.List;
-import java.util.stream.Collectors;
+import java.nio.charset.StandardCharsets;
+import java.security.GeneralSecurityException;
+import java.util.ArrayList;
+import java.util.Base64;
import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.opendaylight.mdsal.binding.api.WriteTransaction;
import org.opendaylight.mdsal.common.api.CommitInfo;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.dom.api.DefaultDOMRpcException;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.keystore.rev171017.AddKeystoreEntry;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.keystore.rev171017.AddKeystoreEntryInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.keystore.rev171017.AddKeystoreEntryOutput;
private ListenableFuture<RpcResult<AddKeystoreEntryOutput>> addKeystoreEntry(final AddKeystoreEntryInput input) {
LOG.debug("Adding keypairs: {}", input);
- final WriteTransaction writeTransaction = dataBroker.newWriteOnlyTransaction();
- final List<KeyCredential> keypairs = input.nonnullKeyCredential().values().stream()
- .map(keypair -> new KeyCredentialBuilder(keypair)
- .setPrivateKey(encryptionService.encrypt(keypair.getPrivateKey()))
- .setPassphrase(encryptionService.encrypt(keypair.getPassphrase()))
- .build())
- .collect(Collectors.toList());
-
- for (KeyCredential keypair : keypairs) {
+ final var plain = input.nonnullKeyCredential();
+ final var encrypted = new ArrayList<KeyCredential>(plain.size());
+ for (var credential : plain.values()) {
+ try {
+ encrypted.add(new KeyCredentialBuilder(credential)
+ .setPrivateKey(encryptString(credential.getPrivateKey()))
+ .setPassphrase(encryptString(credential.getPassphrase()))
+ .build());
+ } catch (GeneralSecurityException e) {
+ return Futures.immediateFailedFuture(new DefaultDOMRpcException("Failed to decrypt " + credential, e));
+ }
+ }
+
+ final var writeTransaction = dataBroker.newWriteOnlyTransaction();
+ for (var keypair : encrypted) {
writeTransaction.merge(LogicalDatastoreType.CONFIGURATION,
KEYSTORE_IID.child(KeyCredential.class, keypair.key()), keypair);
}
- final SettableFuture<RpcResult<AddKeystoreEntryOutput>> rpcResult = SettableFuture.create();
-
+ final var rpcResult = SettableFuture.<RpcResult<AddKeystoreEntryOutput>>create();
writeTransaction.commit().addCallback(new FutureCallback<CommitInfo>() {
@Override
public void onSuccess(final CommitInfo result) {
rpcResult.setException(throwable);
}
}, MoreExecutors.directExecutor());
-
return rpcResult;
}
+ private String encryptString(final String plain) throws GeneralSecurityException {
+ return Base64.getEncoder().encodeToString(encryptionService.encrypt(plain.getBytes(StandardCharsets.UTF_8)));
+ }
+
@VisibleForTesting
ListenableFuture<RpcResult<AddTrustedCertificateOutput>> addTrustedCertificate(
final AddTrustedCertificateInput input) {
import java.util.List;
import java.util.Optional;
+import javax.xml.transform.dom.DOMSource;
import org.opendaylight.netconf.api.EffectiveOperation;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.AnyxmlNode;
-import org.opendaylight.yangtools.yang.data.api.schema.DOMSourceAnyxmlNode;
import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
* @param operation operation
* @return config structure
*/
- DOMSourceAnyxmlNode createEditConfigStructure(Optional<NormalizedNode> data, YangInstanceIdentifier dataPath,
- Optional<EffectiveOperation> operation);
+ AnyxmlNode<DOMSource> createEditConfigStructure(Optional<NormalizedNode> data, YangInstanceIdentifier dataPath,
+ Optional<EffectiveOperation> operation);
/**
* Transforms path to filter structure.
*/
package org.opendaylight.netconf.client.mdsal.impl;
-import java.time.Instant;
-import java.util.Map;
import javax.xml.transform.dom.DOMSource;
import org.opendaylight.mdsal.dom.api.DOMNotification;
import org.opendaylight.netconf.api.messages.NetconfMessage;
import org.opendaylight.netconf.api.xml.MissingNameSpaceException;
-import org.opendaylight.netconf.api.xml.XmlElement;
import org.opendaylight.netconf.api.xml.XmlNetconfConstants;
import org.opendaylight.netconf.client.mdsal.api.NotificationTransformer;
import org.opendaylight.netconf.client.mdsal.api.RpcTransformer;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.RpcResult;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
-import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
-import org.opendaylight.yangtools.yang.data.api.schema.DOMSourceAnyxmlNode;
import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
@Override
public DOMNotification toNotification(final NetconfMessage message) {
- final Map.Entry<Instant, XmlElement> stripped = NetconfMessageTransformUtil.stripNotification(message);
+ final var stripped = NetconfMessageTransformUtil.stripNotification(message);
final QName notificationNoRev;
try {
notificationNoRev =
+ message + ", cannot find namespace", e);
}
- final DOMSourceAnyxmlNode notificationPayload = Builders.anyXmlBuilder()
+ return new NetconfMessageTransformer.NetconfDeviceNotification(Builders.containerBuilder()
+ .withNodeIdentifier(SCHEMALESS_NOTIFICATION_PAYLOAD)
+ .withChild(Builders.anyXmlBuilder()
.withNodeIdentifier(new NodeIdentifier(notificationNoRev))
.withValue(new DOMSource(stripped.getValue().getDomElement()))
- .build();
-
- final ContainerNode notificationBody = Builders.containerBuilder()
- .withNodeIdentifier(SCHEMALESS_NOTIFICATION_PAYLOAD)
- .withChild(notificationPayload)
- .build();
-
- return new NetconfMessageTransformer.NetconfDeviceNotification(notificationBody, stripped.getKey());
+ .build())
+ .build(), stripped.getKey());
}
@Override
* @return config structure
*/
@Override
- public DOMSourceAnyxmlNode createEditConfigStructure(final Optional<NormalizedNode> data,
+ public AnyxmlNode<DOMSource> createEditConfigStructure(final Optional<NormalizedNode> data,
final YangInstanceIdentifier dataPath, final Optional<EffectiveOperation> operation) {
final var dataValue = data.orElseThrow();
if (!(dataValue instanceof DOMSourceAnyxmlNode anxmlData)) {
package org.opendaylight.netconf.client.mdsal.spi;
import static com.google.common.base.Preconditions.checkState;
+import static java.util.Objects.requireNonNull;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.SettableFuture;
import java.util.HashMap;
import java.util.Map;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.mdsal.dom.api.DOMDataBroker;
import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteTransaction;
import org.opendaylight.mdsal.dom.api.DOMTransactionChain;
import org.opendaylight.mdsal.dom.api.DOMTransactionChainClosedException;
-import org.opendaylight.mdsal.dom.api.DOMTransactionChainListener;
import org.opendaylight.yangtools.concepts.Registration;
+import org.opendaylight.yangtools.yang.common.Empty;
/**
* {@link DOMTransactionChain} implementation for Netconf connector.
*/
abstract class AbstractTxChain implements DOMTransactionChain, TxListener {
- /**
- * Submitted transactions that haven't completed yet.
- */
+ // Submitted transactions that haven't completed yet.
private final Map<DOMDataTreeWriteTransaction, Registration> pendingTransactions = new HashMap<>();
+ private final @NonNull SettableFuture<Empty> future = SettableFuture.create();
final DOMDataBroker dataBroker;
- final DOMTransactionChainListener listener;
/**
* Transaction created by this chain that hasn't been submitted or cancelled yet.
private boolean closed = false;
private boolean successful = true;
- AbstractTxChain(final DOMDataBroker dataBroker, final DOMTransactionChainListener listener) {
- this.dataBroker = dataBroker;
- this.listener = listener;
+ AbstractTxChain(final DOMDataBroker dataBroker) {
+ this.dataBroker = requireNonNull(dataBroker);
+ }
+
+ @Override
+ public final ListenableFuture<Empty> future() {
+ return future;
}
@Override
public final synchronized AbstractWriteTx newWriteOnlyTransaction() {
checkOperationPermitted();
- final DOMDataTreeWriteTransaction writeTransaction = dataBroker.newWriteOnlyTransaction();
- checkState(writeTransaction instanceof AbstractWriteTx);
- final AbstractWriteTx pendingWriteTx = (AbstractWriteTx) writeTransaction;
+
+ final var writeTransaction = dataBroker.newWriteOnlyTransaction();
+ if (!(writeTransaction instanceof AbstractWriteTx pendingWriteTx)) {
+ throw new IllegalStateException("Unexpected transaction " + writeTransaction);
+ }
pendingTransactions.put(pendingWriteTx, pendingWriteTx.addListener(this));
currentTransaction = pendingWriteTx;
return pendingWriteTx;
if (currentTransaction != null) {
currentTransaction.cancel();
}
- listener.onTransactionChainFailed(this, transaction, cause);
+ future.setException(cause);
}
@Override
private void notifyChainListenerSuccess() {
if (closed && pendingTransactions.isEmpty() && successful) {
- listener.onTransactionChainSuccessful(this);
+ future.set(Empty.value());
}
}
}
import java.util.List;
import java.util.Optional;
import java.util.concurrent.CopyOnWriteArrayList;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.mdsal.common.api.CommitInfo;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.mdsal.common.api.TransactionCommitFailedException;
final boolean rollbackSupport;
final List<ListenableFuture<? extends DOMRpcResult>> resultsFutures = new ArrayList<>();
private final List<TxListener> listeners = new CopyOnWriteArrayList<>();
+ private final SettableFuture<CommitInfo> resultFuture = SettableFuture.create();
+ private final @NonNull FluentFuture<CommitInfo> completionFuture = FluentFuture.from(resultFuture);
+
// Allow commit to be called only once
volatile boolean finished = false;
final boolean isLockAllowed;
abstract void cleanup();
+ @Override
+ public final FluentFuture<?> completionFuture() {
+ return completionFuture;
+ }
+
@Override
public synchronized boolean cancel() {
if (isFinished()) {
@Override
// Non-final for testing
public FluentFuture<? extends CommitInfo> commit() {
- final SettableFuture<CommitInfo> resultFuture = SettableFuture.create();
- Futures.addCallback(commitConfiguration(), new FutureCallback<RpcResult<Void>>() {
+ Futures.addCallback(commitConfiguration(), new FutureCallback<>() {
@Override
public void onSuccess(final RpcResult<Void> result) {
if (!result.isSuccessful()) {
}
}, MoreExecutors.directExecutor());
- return FluentFuture.from(resultFuture);
+ return completionFuture;
}
final ListenableFuture<RpcResult<Void>> commitConfiguration() {
listeners.forEach(listener -> listener.onTransactionSubmitted(this));
checkNotFinished();
finished = true;
- final ListenableFuture<RpcResult<Void>> result = performCommit();
- Futures.addCallback(result, new FutureCallback<RpcResult<Void>>() {
+ final var result = performCommit();
+ Futures.addCallback(result, new FutureCallback<>() {
@Override
public void onSuccess(final RpcResult<Void> rpcResult) {
if (rpcResult.isSuccessful()) {
final ListenableFuture<RpcResult<Void>> resultsToTxStatus() {
final var transformed = SettableFuture.<RpcResult<Void>>create();
- Futures.addCallback(Futures.allAsList(resultsFutures), new FutureCallback<List<DOMRpcResult>>() {
+ Futures.addCallback(Futures.allAsList(resultsFutures), new FutureCallback<>() {
@Override
public void onSuccess(final List<DOMRpcResult> domRpcResults) {
if (!transformed.isDone()) {
import static java.util.Objects.requireNonNull;
import org.opendaylight.mdsal.dom.api.DOMDataBroker;
-import org.opendaylight.mdsal.dom.api.DOMTransactionChainListener;
import org.opendaylight.netconf.dom.api.tx.NetconfDOMDataBrokerFieldsExtension;
import org.opendaylight.netconf.dom.api.tx.NetconfDOMFieldsReadTransaction;
import org.opendaylight.netconf.dom.api.tx.NetconfDOMFieldsReadWriteTransaction;
public final class FieldsAwareTxChain extends AbstractTxChain implements NetconfDOMFieldsTransactionChain {
private final NetconfDOMDataBrokerFieldsExtension dataBrokerFieldsExtension;
- FieldsAwareTxChain(final DOMDataBroker dataBroker, final DOMTransactionChainListener listener,
- final NetconfDOMDataBrokerFieldsExtension dataBrokerFieldsExtension) {
- super(dataBroker, listener);
+ FieldsAwareTxChain(final DOMDataBroker dataBroker,
+ final NetconfDOMDataBrokerFieldsExtension dataBrokerFieldsExtension) {
+ super(dataBroker);
this.dataBrokerFieldsExtension = requireNonNull(dataBrokerFieldsExtension);
}
import org.opendaylight.netconf.client.mdsal.impl.NetconfMessageTransformUtil;
import org.opendaylight.netconf.common.NetconfTimer;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.netconf.base._1._0.rev110601.GetConfig;
-import org.opendaylight.yangtools.concepts.ListenerRegistration;
+import org.opendaylight.yangtools.concepts.Registration;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
import org.slf4j.Logger;
}
@Override
- public <T extends DOMRpcAvailabilityListener> ListenerRegistration<T> registerRpcListener(
- final T rpcListener) {
+ public Registration registerRpcListener(final DOMRpcAvailabilityListener rpcListener) {
// There is no real communication with the device (yet), hence no recordActivity() or anything
return delegate.registerRpcListener(rpcListener);
}
-
}
/**
import org.opendaylight.netconf.api.messages.NetconfMessage;
import org.opendaylight.netconf.client.mdsal.api.RemoteDeviceCommunicator;
import org.opendaylight.netconf.client.mdsal.api.RpcTransformer;
-import org.opendaylight.yangtools.concepts.ListenerRegistration;
-import org.opendaylight.yangtools.concepts.NoOpListenerRegistration;
+import org.opendaylight.yangtools.concepts.Registration;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.RpcResult;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
}
@Override
- public <T extends DOMRpcAvailabilityListener> ListenerRegistration<T> registerRpcListener(final T listener) {
+ public Registration registerRpcListener(final DOMRpcAvailabilityListener listener) {
listener.onRpcAvailable(Collections2.transform(modelContext.getOperations(),
input -> DOMRpcIdentifier.create(input.getQName())));
- return NoOpListenerRegistration.of(listener);
+ return () -> {
+ // No-op
+ };
}
}
\ No newline at end of file
import static com.google.common.base.Preconditions.checkArgument;
-import com.google.common.collect.ClassToInstanceMap;
-import com.google.common.collect.ImmutableClassToInstanceMap;
-import org.opendaylight.mdsal.dom.api.DOMDataBrokerExtension;
+import java.util.List;
import org.opendaylight.mdsal.dom.api.DOMDataTreeReadTransaction;
import org.opendaylight.mdsal.dom.api.DOMDataTreeReadWriteTransaction;
import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteTransaction;
import org.opendaylight.mdsal.dom.api.DOMTransactionChain;
-import org.opendaylight.mdsal.dom.api.DOMTransactionChainListener;
import org.opendaylight.mdsal.dom.spi.PingPongMergingDOMDataBroker;
import org.opendaylight.netconf.client.mdsal.api.NetconfSessionPreferences;
import org.opendaylight.netconf.client.mdsal.api.RemoteDeviceId;
}
@Override
- public DOMTransactionChain createTransactionChain(final DOMTransactionChainListener listener) {
- return new TxChain(this, listener);
+ public DOMTransactionChain createTransactionChain() {
+ return new TxChain(this);
}
@Override
- public ClassToInstanceMap<DOMDataBrokerExtension> getExtensions() {
- return ImmutableClassToInstanceMap.of(NetconfDOMDataBrokerFieldsExtension.class, fieldsExtension);
+ public List<Extension> supportedExtensions() {
+ return List.of(fieldsExtension);
}
private final class NetconfDOMDataBrokerFieldsExtensionImpl implements NetconfDOMDataBrokerFieldsExtension {
}
@Override
- public NetconfDOMFieldsTransactionChain createTransactionChain(final DOMTransactionChainListener listener) {
- return new FieldsAwareTxChain(NetconfDeviceDataBroker.this, listener, this);
+ public NetconfDOMFieldsTransactionChain createTransactionChain() {
+ return new FieldsAwareTxChain(NetconfDeviceDataBroker.this, this);
}
}
}
\ No newline at end of file
checkState(topologyRegistration == null, "Already initialized");
final var mountBuilder = mountService.createMountPoint(mountPath);
- mountBuilder.addService(DOMSchemaService.class, FixedDOMSchemaService.of(() -> initialCtx));
+ mountBuilder.addService(DOMSchemaService.class, new FixedDOMSchemaService(initialCtx));
final var rpcs = services.rpcs();
mountBuilder.addService(NetconfRpcService.class, rpcs);
import org.opendaylight.mdsal.dom.api.DOMNotification;
import org.opendaylight.mdsal.dom.api.DOMNotificationListener;
import org.opendaylight.mdsal.dom.api.DOMNotificationService;
-import org.opendaylight.yangtools.concepts.AbstractListenerRegistration;
import org.opendaylight.yangtools.concepts.AbstractRegistration;
-import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.concepts.Registration;
import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier.Absolute;
import org.slf4j.Logger;
}
@Override
- public <T extends DOMNotificationListener> ListenerRegistration<T> registerNotificationListener(final T listener,
+ public Registration registerNotificationListener(final DOMNotificationListener listener,
final Collection<Absolute> types) {
final var lsnr = requireNonNull(listener);
final var typesArray = types.stream().map(Objects::requireNonNull).distinct().toArray(Absolute[]::new);
return switch (typesArray.length) {
- case 0 -> new AbstractListenerRegistration<>(lsnr) {
- @Override
- protected void removeRegistration() {
- // No-op
- }
+ case 0 -> () -> {
+ // No-op
};
case 1 -> registerOne(lsnr, typesArray[0]);
default -> registerMultiple(lsnr, typesArray);
}
@Override
- public <T extends DOMNotificationListener> ListenerRegistration<T> registerNotificationListener(final T listener,
- final Absolute... types) {
+ public Registration registerNotificationListener(final DOMNotificationListener listener, final Absolute... types) {
return registerNotificationListener(listener, Arrays.asList(types));
}
return listeners.size();
}
- private synchronized <T extends DOMNotificationListener> @NonNull ListenerRegistration<T> registerOne(
- final @NonNull T listener, final Absolute type) {
+ private synchronized @NonNull Registration registerOne(final @NonNull DOMNotificationListener listener,
+ final Absolute type) {
listeners.put(type, listener);
- return new AbstractListenerRegistration<>(listener) {
+ return new AbstractRegistration() {
@Override
protected void removeRegistration() {
synchronized (NetconfDeviceNotificationService.this) {
- listeners.remove(type, getInstance());
+ listeners.remove(type, listener);
}
}
};
}
- private synchronized <T extends DOMNotificationListener> @NonNull ListenerRegistration<T> registerMultiple(
- final @NonNull T listener, final Absolute[] types) {
+ private synchronized @NonNull Registration registerMultiple(final @NonNull DOMNotificationListener listener,
+ final Absolute[] types) {
for (var type : types) {
listeners.put(type, listener);
}
- return new AbstractListenerRegistration<>(listener) {
+ return new AbstractRegistration() {
@Override
protected void removeRegistration() {
synchronized (NetconfDeviceNotificationService.this) {
for (var type : types) {
- listeners.remove(type, getInstance());
+ listeners.remove(type, listener);
}
}
}
public synchronized void onDeviceConnected(final NetconfDeviceSchema deviceSchema,
final NetconfSessionPreferences sessionPreferences, final RemoteDeviceServices services) {
final var mountContext = deviceSchema.mountContext();
- final var modelContext = mountContext.getEffectiveModelContext();
+ final var modelContext = mountContext.modelContext();
final var deviceRpc = services.rpcs();
*/
package org.opendaylight.netconf.client.mdsal.spi;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.util.concurrent.FluentFuture;
import java.util.Optional;
import org.eclipse.jdt.annotation.NonNull;
final T delegateReadTx;
ReadWriteTx(final T delegateReadTx, final DOMDataTreeWriteTransaction delegateWriteTx) {
- this.delegateReadTx = delegateReadTx;
- this.delegateWriteTx = delegateWriteTx;
+ this.delegateReadTx = requireNonNull(delegateReadTx);
+ this.delegateWriteTx = requireNonNull(delegateWriteTx);
+ }
+
+ @Override
+ public final FluentFuture<?> completionFuture() {
+ return delegateWriteTx.completionFuture();
}
@Override
import org.opendaylight.mdsal.dom.api.DOMDataTreeReadTransaction;
import org.opendaylight.mdsal.dom.api.DOMDataTreeReadWriteTransaction;
import org.opendaylight.mdsal.dom.api.DOMTransactionChain;
-import org.opendaylight.mdsal.dom.api.DOMTransactionChainListener;
/**
* {@link DOMTransactionChain} implementation for Netconf connector.
*/
final class TxChain extends AbstractTxChain {
- TxChain(final DOMDataBroker dataBroker, final DOMTransactionChainListener listener) {
- super(dataBroker, listener);
+ TxChain(final DOMDataBroker dataBroker) {
+ super(dataBroker);
}
@Override
import java.net.URL;
import java.util.Map;
import org.junit.Test;
-import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
+import org.opendaylight.yangtools.yang.model.api.source.SourceIdentifier;
public class LibraryModulesSchemasTest {
import org.junit.Before;
import org.junit.Test;
import org.opendaylight.netconf.client.mdsal.api.RemoteDeviceId;
+import org.opendaylight.yangtools.yang.model.api.source.SourceIdentifier;
import org.opendaylight.yangtools.yang.model.repo.api.SchemaSourceException;
-import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
public class LibrarySchemaYangSourceProviderTest {
private SourceIdentifier workingSid;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
-import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
-import org.opendaylight.yangtools.yang.model.repo.api.YangTextSchemaSource;
+import org.opendaylight.yangtools.yang.model.api.source.SourceIdentifier;
+import org.opendaylight.yangtools.yang.model.api.source.YangTextSource;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
@Test
public void testGetSource() throws Exception {
final SourceIdentifier identifier = new SourceIdentifier("test", "2016-02-08");
- final YangTextSchemaSource source = provider.getSource(identifier).get();
- assertEquals(identifier, source.getIdentifier());
+ final YangTextSource source = provider.getSource(identifier).get();
+ assertEquals(identifier, source.sourceId());
verify(service).invokeRpc(GetSchema.QNAME,
MonitoringSchemaSourceProvider.createGetSchemaRequest("test", Optional.of("2016-02-08")));
}
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
-import com.google.common.collect.ImmutableMultimap;
import com.google.common.collect.Sets;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.MoreExecutors;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.monitoring.rev101004.NetconfState;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.device.rev240120.connection.oper.available.capabilities.AvailableCapability;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.device.rev240120.connection.oper.available.capabilities.AvailableCapability.CapabilityOrigin;
+import org.opendaylight.yangtools.concepts.Registration;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+import org.opendaylight.yangtools.yang.model.api.source.SourceIdentifier;
+import org.opendaylight.yangtools.yang.model.api.source.YangTextSource;
import org.opendaylight.yangtools.yang.model.repo.api.EffectiveModelContextFactory;
import org.opendaylight.yangtools.yang.model.repo.api.MissingSchemaSourceException;
import org.opendaylight.yangtools.yang.model.repo.api.SchemaRepository;
import org.opendaylight.yangtools.yang.model.repo.api.SchemaResolutionException;
-import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
-import org.opendaylight.yangtools.yang.model.repo.api.YangTextSchemaSource;
-import org.opendaylight.yangtools.yang.model.repo.spi.SchemaSourceRegistration;
import org.opendaylight.yangtools.yang.model.repo.spi.SchemaSourceRegistry;
@RunWith(MockitoJUnitRunner.StrictStubs.class)
return new NetconfStateSchemas(Sets.newHashSet(source1, source2));
};
- doReturn(mock(SchemaSourceRegistration.class)).when(schemaRegistry).registerSchemaSource(any(), any());
+ doReturn(mock(Registration.class)).when(schemaRegistry).registerSchemaSource(any(), any());
final NetconfDevice.SchemaResourcesDTO schemaResourcesDTO = new NetconfDevice
.SchemaResourcesDTO(schemaRegistry, schemaRepository, schemaFactory, stateSchemasResolver);
// Make fallback attempt to fail due to empty resolved sources
final SchemaResolutionException schemaResolutionException = new SchemaResolutionException("fail first",
- List.of(), ImmutableMultimap.of());
+ new SourceIdentifier("test-module", "2013-07-22"), new Throwable());
doReturn(Futures.immediateFailedFuture(schemaResolutionException))
.when(schemaFactory).createEffectiveModelContext(anyCollection());
// Make fallback attempt to fail due to empty resolved sources
final MissingSchemaSourceException schemaResolutionException =
- new MissingSchemaSourceException("fail first", TEST_SID);
+ new MissingSchemaSourceException(TEST_SID, "fail first");
doReturn(Futures.immediateFailedFuture(schemaResolutionException))
- .when(schemaRepository).getSchemaSource(eq(TEST_SID), eq(YangTextSchemaSource.class));
+ .when(schemaRepository).getSchemaSource(eq(TEST_SID), eq(YangTextSource.class));
doAnswer(invocation -> {
- if (((Collection<?>) invocation.getArguments()[0]).size() == 2) {
+ if (invocation.getArgument(0, Collection.class).size() == 2) {
return Futures.immediateFailedFuture(schemaResolutionException);
} else {
return Futures.immediateFuture(SCHEMA_CONTEXT);
return new NetconfStateSchemas(Sets.newHashSet(source1, source2));
};
- doReturn(mock(SchemaSourceRegistration.class)).when(schemaRegistry).registerSchemaSource(any(), any());
+ doReturn(mock(Registration.class)).when(schemaRegistry).registerSchemaSource(any(), any());
final NetconfDevice.SchemaResourcesDTO schemaResourcesDTO = new NetconfDevice
.SchemaResourcesDTO(schemaRegistry, schemaRepository, schemaFactory, stateSchemasResolver);
private static SchemaRepository getSchemaRepository() {
final SchemaRepository mock = mock(SchemaRepository.class);
- final YangTextSchemaSource mockRep = mock(YangTextSchemaSource.class);
+ final YangTextSource mockRep = mock(YangTextSource.class);
doReturn(Futures.immediateFuture(mockRep))
- .when(mock).getSchemaSource(any(SourceIdentifier.class), eq(YangTextSchemaSource.class));
+ .when(mock).getSchemaSource(any(SourceIdentifier.class), eq(YangTextSource.class));
return mock;
}
any(RemoteDeviceServices.class));
List<String> notificationModulesName = List.of(
- org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.netconf.notification._1._0.rev080714
- .$YangModuleInfoImpl.getInstance().getName().toString(),
- org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715
- .$YangModuleInfoImpl.getInstance().getName().toString());
+ org.opendaylight.yang.svc.v1.urn.ietf.params.xml.ns.netconf.notification._1._0.rev080714
+ .YangModuleInfoImpl.getInstance().getName().toString(),
+ org.opendaylight.yang.svc.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715
+ .YangModuleInfoImpl.getInstance().getName().toString());
final Set<AvailableCapability> resolvedCapabilities = argument.getValue().capabilities().resolvedCapabilities();
final NetconfDeviceCapabilities netconfDeviceCaps = argument.getValue().capabilities();
List<String> notificationModulesName = List.of(
- org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.netconf.notification._1._0.rev080714
- .$YangModuleInfoImpl.getInstance().getName().toString(),
- org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715
- .$YangModuleInfoImpl.getInstance().getName().toString());
+ org.opendaylight.yang.svc.v1.urn.ietf.params.xml.ns.netconf.notification._1._0.rev080714
+ .YangModuleInfoImpl.getInstance().getName().toString(),
+ org.opendaylight.yang.svc.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715
+ .YangModuleInfoImpl.getInstance().getName().toString());
assertFalse(netconfDeviceCaps.resolvedCapabilities().stream()
.anyMatch(entry -> notificationModulesName.contains(entry.getCapability())));
final NetconfSessionPreferences sessionCaps = getSessionCaps(false, List.of());
- final Map<QName, CapabilityOrigin> moduleBasedCaps = new HashMap<>();
- moduleBasedCaps.put(org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.netconf.notification._1._0.rev080714
- .$YangModuleInfoImpl.getInstance().getName(),
+ final var moduleBasedCaps = new HashMap<QName, CapabilityOrigin>();
+ moduleBasedCaps.put(org.opendaylight.yang.svc.v1.urn.ietf.params.xml.ns.netconf.notification._1._0.rev080714
+ .YangModuleInfoImpl.getInstance().getName(),
CapabilityOrigin.DeviceAdvertised);
- moduleBasedCaps.put(org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715
- .$YangModuleInfoImpl.getInstance().getName(),
+ moduleBasedCaps.put(org.opendaylight.yang.svc.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715
+ .YangModuleInfoImpl.getInstance().getName(),
CapabilityOrigin.DeviceAdvertised);
netconfSpy.onRemoteSessionUp(sessionCaps.replaceModuleCaps(moduleBasedCaps), listener);
- final ArgumentCaptor<NetconfDeviceSchema> argument = ArgumentCaptor.forClass(NetconfDeviceSchema.class);
+ final var argument = ArgumentCaptor.forClass(NetconfDeviceSchema.class);
verify(facade, timeout(5000)).onDeviceConnected(argument.capture(), any(NetconfSessionPreferences.class),
any(RemoteDeviceServices.class));
final Set<AvailableCapability> resolvedCapabilities = argument.getValue().capabilities().resolvedCapabilities();
- List<String> notificationModulesName = List.of(
- org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.netconf.notification._1._0.rev080714
- .$YangModuleInfoImpl.getInstance().getName().toString(),
- org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715
- .$YangModuleInfoImpl.getInstance().getName().toString());
+ final var notificationModulesName = List.of(
+ org.opendaylight.yang.svc.v1.urn.ietf.params.xml.ns.netconf.notification._1._0.rev080714
+ .YangModuleInfoImpl.getInstance().getName().toString(),
+ org.opendaylight.yang.svc.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715
+ .YangModuleInfoImpl.getInstance().getName().toString());
assertEquals(2, resolvedCapabilities.size());
assertTrue(resolvedCapabilities.stream().anyMatch(entry -> notificationModulesName
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
import org.opendaylight.yangtools.yang.data.codec.xml.XmlParserStream;
-import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNormalizedNodeStreamWriter;
import org.opendaylight.yangtools.yang.data.impl.schema.NormalizationResultHolder;
+import org.opendaylight.yangtools.yang.data.spi.node.ImmutableNodes;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.model.util.SchemaInferenceStack;
import org.slf4j.Logger;
@Mock
private DOMRpcService rpc;
- private EffectiveModelContext schemaContext;
+ private EffectiveModelContext modelContext;
@Before
public void setUp() throws Exception {
- schemaContext = BASE_SCHEMAS.baseSchemaWithNotifications().getEffectiveModelContext();
+ modelContext = BASE_SCHEMAS.baseSchemaWithNotifications().modelContext();
final var resultHolder = new NormalizationResultHolder();
final var writer = ImmutableNormalizedNodeStreamWriter.from(resultHolder);
final var xmlParser = XmlParserStream.create(writer,
- SchemaInferenceStack.ofDataTreePath(schemaContext, NetconfState.QNAME, Schemas.QNAME).toInference(), false);
+ SchemaInferenceStack.ofDataTreePath(modelContext, NetconfState.QNAME, Schemas.QNAME).toInference(), false);
xmlParser.parse(UntrustedXML.createXMLStreamReader(getClass().getResourceAsStream(
"/netconf-state.schemas.payload.xml")));
@Ignore
@Test
public void testCreate2() throws Exception {
- final ContainerNode netconfState = Builders.containerBuilder()
+ final ContainerNode netconfState = ImmutableNodes.newContainerBuilder()
.withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(NetconfState.QNAME))
.withChild(compositeNodeSchemas)
.build();
- final ContainerNode data = Builders.containerBuilder()
+ final ContainerNode data = ImmutableNodes.newContainerBuilder()
.withNodeIdentifier(NetconfMessageTransformUtil.NETCONF_DATA_NODEID)
.withChild(netconfState)
.build();
- final ContainerNode rpcReply = Builders.containerBuilder()
+ final ContainerNode rpcReply = ImmutableNodes.newContainerBuilder()
.withNodeIdentifier(new YangInstanceIdentifier
.NodeIdentifier(NetconfMessageTransformUtil.NETCONF_RPC_REPLY_QNAME))
.withChild(data)
.build();
doReturn(Futures.immediateFuture(new DefaultDOMRpcResult(rpcReply))).when(rpc).invokeRpc(eq(Get.QNAME), any());
- final NetconfStateSchemas stateSchemas = NetconfStateSchemas.create(rpc, CAPS, deviceId, schemaContext);
+ final NetconfStateSchemas stateSchemas = NetconfStateSchemas.create(rpc, CAPS, deviceId, modelContext);
final Set<QName> availableYangSchemasQNames = stateSchemas.getAvailableYangSchemasQNames();
assertEquals(numberOfLegalSchemas, availableYangSchemasQNames.size());
@Test
public void testCreateMonitoringNotSupported() throws Exception {
final var caps = NetconfSessionPreferences.fromStrings(Set.of());
- final var stateSchemas = NetconfStateSchemas.create(rpc, caps, deviceId, schemaContext);
+ final var stateSchemas = NetconfStateSchemas.create(rpc, caps, deviceId, modelContext);
assertEquals(Set.of(), stateSchemas.getAvailableYangSchemasQNames());
}
public void testCreateFail() throws Exception {
when(rpc.invokeRpc(eq(Get.QNAME), any())).thenReturn(
Futures.immediateFailedFuture(new DOMRpcImplementationNotAvailableException("not available")));
- final var stateSchemas = NetconfStateSchemas.create(rpc, CAPS, deviceId, schemaContext);
+ final var stateSchemas = NetconfStateSchemas.create(rpc, CAPS, deviceId, modelContext);
assertEquals(Set.of(), stateSchemas.getAvailableYangSchemasQNames());
}
final RpcError rpcError = RpcResultBuilder.newError(ErrorType.RPC, new ErrorTag("fail"), "fail");
doReturn(Futures.immediateFuture(new DefaultDOMRpcResult(rpcError))).when(rpc)
.invokeRpc(eq(Get.QNAME), any());
- final var stateSchemas = NetconfStateSchemas.create(rpc, CAPS, deviceId, schemaContext);
+ final var stateSchemas = NetconfStateSchemas.create(rpc, CAPS, deviceId, modelContext);
assertEquals(Set.of(), stateSchemas.getAvailableYangSchemasQNames());
}
try {
when(interruptedFuture.get()).thenThrow(new InterruptedException("interrupted"));
doReturn(interruptedFuture).when(rpc).invokeRpc(eq(Get.QNAME), any());
- NetconfStateSchemas.create(rpc, CAPS, deviceId, schemaContext);
+ NetconfStateSchemas.create(rpc, CAPS, deviceId, modelContext);
} catch (final InterruptedException | ExecutionException e) {
LOG.info("Operation failed.", e);
}
import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.keystore.rev171017.trusted.certificates.TrustedCertificate;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.keystore.rev171017.trusted.certificates.TrustedCertificateBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.keystore.rev171017.trusted.certificates.TrustedCertificateKey;
-import org.opendaylight.yangtools.concepts.ListenerRegistration;
+import org.opendaylight.yangtools.concepts.Registration;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
@Mock
private DataBroker dataBroker;
@Mock
- private ListenerRegistration<?> listenerRegistration;
+ private Registration listenerRegistration;
@Before
public void setUp() {
doReturn(listenerRegistration).when(dataBroker)
- .registerDataTreeChangeListener(any(DataTreeIdentifier.class), any(DefaultSslHandlerFactoryProvider.class));
+ .registerTreeChangeListener(any(DataTreeIdentifier.class), any(DefaultSslHandlerFactoryProvider.class));
}
@Test
doReturn(keystoreObjectModification).when(dataTreeModification).getRootNode();
DataObjectModification<?> childObjectModification = mock(DataObjectModification.class);
- doReturn(List.of(childObjectModification)).when(keystoreObjectModification).getModifiedChildren();
- doReturn(PrivateKey.class).when(childObjectModification).getDataType();
+ doReturn(List.of(childObjectModification)).when(keystoreObjectModification).modifiedChildren();
+ doReturn(PrivateKey.class).when(childObjectModification).dataType();
- doReturn(DataObjectModification.ModificationType.WRITE).when(childObjectModification).getModificationType();
+ doReturn(DataObjectModification.ModificationType.WRITE).when(childObjectModification).modificationType();
final var privateKey = getPrivateKey();
- doReturn(privateKey).when(childObjectModification).getDataAfter();
+ doReturn(privateKey).when(childObjectModification).dataAfter();
final var keystoreAdapter = new DefaultSslHandlerFactoryProvider(dataBroker);
keystoreAdapter.onDataTreeChanged(List.of(dataTreeModification));
doReturn(keystoreObjectModification1).when(dataTreeModification1).getRootNode();
DataObjectModification<?> childObjectModification1 = mock(DataObjectModification.class);
- doReturn(List.of(childObjectModification1)).when(keystoreObjectModification1).getModifiedChildren();
- doReturn(PrivateKey.class).when(childObjectModification1).getDataType();
+ doReturn(List.of(childObjectModification1)).when(keystoreObjectModification1).modifiedChildren();
+ doReturn(PrivateKey.class).when(childObjectModification1).dataType();
- doReturn(DataObjectModification.ModificationType.WRITE).when(childObjectModification1).getModificationType();
+ doReturn(DataObjectModification.ModificationType.WRITE).when(childObjectModification1).modificationType();
final var privateKey = getPrivateKey();
- doReturn(privateKey).when(childObjectModification1).getDataAfter();
+ doReturn(privateKey).when(childObjectModification1).dataAfter();
// Prepare TrustedCertificate configuration
DataTreeModification<Keystore> dataTreeModification2 = mock(DataTreeModification.class);
doReturn(keystoreObjectModification2).when(dataTreeModification2).getRootNode();
DataObjectModification<?> childObjectModification2 = mock(DataObjectModification.class);
- doReturn(List.of(childObjectModification2)).when(keystoreObjectModification2).getModifiedChildren();
- doReturn(TrustedCertificate.class).when(childObjectModification2).getDataType();
+ doReturn(List.of(childObjectModification2)).when(keystoreObjectModification2).modifiedChildren();
+ doReturn(TrustedCertificate.class).when(childObjectModification2).dataType();
doReturn(DataObjectModification.ModificationType.WRITE)
- .when(childObjectModification2).getModificationType();
+ .when(childObjectModification2).modificationType();
final var trustedCertificate = geTrustedCertificate();
- doReturn(trustedCertificate).when(childObjectModification2).getDataAfter();
+ doReturn(trustedCertificate).when(childObjectModification2).dataAfter();
// Apply configurations
final var keystoreAdapter = new DefaultSslHandlerFactoryProvider(dataBroker);
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.netconf.base._1._0.rev110601.EditConfig;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.netconf.base._1._0.rev110601.Get;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.netconf.base._1._0.rev110601.GetConfig;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.netconf.base._1._0.rev110601.IetfNetconfService;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.netconf.base._1._0.rev110601.IetfNetconfData;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.netconf.base._1._0.rev110601.Lock;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.netconf.base._1._0.rev110601.get.config.output.Data;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.netconf.notification._1._0.rev080714.CreateSubscription;
@BeforeClass
public static void beforeClass() {
PARTIAL_SCHEMA = BindingRuntimeHelpers.createEffectiveModel(NetconfState.class);
- SCHEMA = BindingRuntimeHelpers.createEffectiveModel(IetfNetconfService.class, NetconfState.class,
+ SCHEMA = BindingRuntimeHelpers.createEffectiveModel(IetfNetconfData.class, NetconfState.class,
NetconfConfigChange.class);
ACTION_SCHEMA = YangParserTestUtils.parseYangResources(NetconfMessageTransformerTest.class,
"/schemas/example-server-farm.yang","/schemas/example-server-farm-2.yang",
.node(NetconfState.QNAME).node(Schemas.QNAME).node(Schema.QNAME)
.nodeWithKey(Schema.QNAME, keys).build();
final var editConfigStructure =
- createEditConfigStructure(BASE_SCHEMAS.baseSchemaWithNotifications().getEffectiveModelContext(), id,
+ createEditConfigStructure(BASE_SCHEMAS.baseSchemaWithNotifications().modelContext(), id,
Optional.empty(), Optional.ofNullable(schemaNode));
final var target = NetconfBaseOps.getTargetNode(NETCONF_CANDIDATE_NODEID);
YangInstanceIdentifier yangInstanceIdentifier =
YangInstanceIdentifier.builder().append(nodeIdentifiers).build();
DOMDataTreeIdentifier domDataTreeIdentifier =
- new DOMDataTreeIdentifier(org.opendaylight.mdsal.common.api.LogicalDatastoreType.CONFIGURATION,
+ DOMDataTreeIdentifier.of(org.opendaylight.mdsal.common.api.LogicalDatastoreType.CONFIGURATION,
yangInstanceIdentifier);
return domDataTreeIdentifier;
}
@Test
public void testCreateEditConfigStructure() throws Exception {
- DOMSourceAnyxmlNode data = Builders.anyXmlBuilder()
+ final var data = Builders.anyXmlBuilder()
.withNodeIdentifier(createNodeId(path.getLastPathArgument().getNodeType().getLocalName()))
.withValue(source)
.build();
import org.opendaylight.netconf.client.mdsal.api.RemoteDeviceServices;
import org.opendaylight.netconf.client.mdsal.api.RemoteDeviceServices.Rpcs;
import org.opendaylight.netconf.dom.api.NetconfDataTreeService;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.netconf.base._1._0.rev110601.IetfNetconfService;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.netconf.base._1._0.rev110601.IetfNetconfData;
import org.opendaylight.yangtools.concepts.ObjectRegistration;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
@BeforeClass
public static void suiteSetUp() throws Exception {
- SCHEMA_CONTEXT = BindingRuntimeHelpers.createEffectiveModel(IetfNetconfService.class);
+ SCHEMA_CONTEXT = BindingRuntimeHelpers.createEffectiveModel(IetfNetconfData.class);
}
@Before
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.netconf.base._1._0.rev110601.EditConfig;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.netconf.base._1._0.rev110601.Get;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.netconf.base._1._0.rev110601.GetConfig;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.netconf.base._1._0.rev110601.IetfNetconfService;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.netconf.base._1._0.rev110601.IetfNetconfData;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.netconf.base._1._0.rev110601.Lock;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.netconf.base._1._0.rev110601.Unlock;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.monitoring.rev101004.NetconfState;
public void setUp() {
doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(rpcService).invokeNetconf(any(), any());
netconService = getNetconService();
- final var model = BindingRuntimeHelpers.createEffectiveModel(IetfNetconfService.class, NetconfState.class);
+ final var model = BindingRuntimeHelpers.createEffectiveModel(IetfNetconfData.class, NetconfState.class);
netconfMessageTransformer = new NetconfMessageTransformer(MountPointContext.of(model), true,
BASE_SCHEMAS.baseSchema());
}
import org.opendaylight.netconf.dom.api.tx.NetconfDOMFieldsReadWriteTransaction;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.netconf.base._1._0.rev110601.Get;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.netconf.base._1._0.rev110601.GetConfig;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.netconf.base._1._0.rev110601.IetfNetconfService;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.netconf.base._1._0.rev110601.IetfNetconfData;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.netconf.monitoring.rev220718.NetconfTcp;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.MountPointContext;
@BeforeClass
public static void beforeClass() {
- SCHEMA_CONTEXT = BindingRuntimeHelpers.createEffectiveModel(IetfNetconfService.class, NetconfTcp.class);
+ SCHEMA_CONTEXT = BindingRuntimeHelpers.createEffectiveModel(IetfNetconfData.class, NetconfTcp.class);
}
@AfterClass
@Test
public void testDOMFieldsExtensions() {
- final NetconfDOMDataBrokerFieldsExtension fieldsExtension = dataBroker.getExtensions().getInstance(
- NetconfDOMDataBrokerFieldsExtension.class);
+ final var fieldsExtension = dataBroker.extension(NetconfDOMDataBrokerFieldsExtension.class);
assertNotNull(fieldsExtension);
// read-only transaction
*/
package org.opendaylight.netconf.client.mdsal.spi;
-import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.times;
import org.mockito.junit.jupiter.MockitoExtension;
import org.opendaylight.mdsal.dom.api.DOMNotification;
import org.opendaylight.mdsal.dom.api.DOMNotificationListener;
-import org.opendaylight.yangtools.concepts.ListenerRegistration;
+import org.opendaylight.yangtools.concepts.Registration;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier.Absolute;
private DOMNotification notification2;
private final NetconfDeviceNotificationService service = new NetconfDeviceNotificationService();
- private ListenerRegistration<DOMNotificationListener> registration;
+ private Registration registration;
@BeforeEach
void beforeEach() throws Exception {
@Test
void testCloseRegistration() throws Exception {
service.publishNotification(notification2);
- assertEquals(listener2, registration.getInstance());
registration.close();
service.publishNotification(notification2);
verify(listener2, times(1)).onNotification(notification2);
import org.opendaylight.netconf.client.mdsal.api.RpcTransformer;
import org.opendaylight.netconf.client.mdsal.impl.NetconfMessageTransformUtil;
import org.opendaylight.netconf.client.mdsal.impl.NetconfMessageTransformer;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.netconf.base._1._0.rev110601.IetfNetconfService;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.netconf.base._1._0.rev110601.IetfNetconfData;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.RpcResult;
import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
@BeforeClass
public static void beforeClass() {
- SCHEMA_CONTEXT = BindingRuntimeHelpers.createEffectiveModel(IetfNetconfService.class);
+ SCHEMA_CONTEXT = BindingRuntimeHelpers.createEffectiveModel(IetfNetconfData.class);
}
@AfterClass
@Test
public void getIdentifier() throws Exception {
- final ReadWriteTx<?> tx2 = new ReadWriteTx<>(null, null);
+ final ReadWriteTx<?> tx2 = new ReadWriteTx<>(delegateReadTx, delegateWriteTx);
assertNotEquals(tx.getIdentifier(), tx2.getIdentifier());
}
}
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
+import com.google.common.util.concurrent.FutureCallback;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.opendaylight.mdsal.dom.api.DOMDataBroker;
import org.opendaylight.mdsal.dom.api.DOMDataTreeReadTransaction;
import org.opendaylight.mdsal.dom.api.DOMTransactionChainClosedException;
-import org.opendaylight.mdsal.dom.api.DOMTransactionChainListener;
import org.opendaylight.yangtools.concepts.Registration;
+import org.opendaylight.yangtools.yang.common.Empty;
@RunWith(MockitoJUnitRunner.StrictStubs.class)
public class TxChainTest {
@Mock
private DOMDataBroker broker;
@Mock
- private DOMTransactionChainListener listener;
+ private FutureCallback<Empty> listener;
@Mock
private DOMDataTreeReadTransaction readOnlyTx;
@Mock
when(writeOnlyTx1.addListener(any())).thenReturn(registration1);
when(writeOnlyTx2.addListener(any())).thenReturn(registration2);
when(writeOnlyTx3.addListener(any())).thenReturn(registration3);
- chain = new TxChain(broker, listener);
+ chain = new TxChain(broker);
+ chain.addCallback(listener);
}
@Test
@Test
public void testCloseAfterFinished() {
chain.close();
- verify(listener).onTransactionChainSuccessful(chain);
+ verify(listener).onSuccess(Empty.value());
assertThrows(DOMTransactionChainClosedException.class, chain::newReadOnlyTransaction);
}
final TransactionCommitFailedException cause = new TransactionCommitFailedException("fail");
captor.getValue().onTransactionFailed(writeOnlyTx1, cause);
verify(registration1).close();
- verify(listener).onTransactionChainFailed(chain, writeOnlyTx1, cause);
+ verify(listener).onFailure(cause);
}
@Test
writeTx.commit();
captor.getValue().onTransactionSuccessful(writeOnlyTx1);
verify(registration1).close();
- verify(listener).onTransactionChainSuccessful(chain);
+ verify(listener).onSuccess(Empty.value());
}
@Test
public void testMultiplePendingTransactions() {
//create 1st tx
final AbstractWriteTx writeTx1 = chain.newWriteOnlyTransaction();
- final ArgumentCaptor<TxListener> captor1 = ArgumentCaptor.forClass(TxListener.class);
+ final var captor1 = ArgumentCaptor.forClass(TxListener.class);
verify(writeOnlyTx1).addListener(captor1.capture());
//submit 1st tx
writeTx1.commit();
//create 2nd tx
final AbstractWriteTx writeTx2 = chain.newWriteOnlyTransaction();
- final ArgumentCaptor<TxListener> captor2 = ArgumentCaptor.forClass(TxListener.class);
+ final var captor2 = ArgumentCaptor.forClass(TxListener.class);
verify(writeTx2).addListener(captor2.capture());
//submit 2nd tx
writeTx2.commit();
//create 3rd tx
final AbstractWriteTx writeTx3 = chain.newWriteOnlyTransaction();
- final ArgumentCaptor<TxListener> captor3 = ArgumentCaptor.forClass(TxListener.class);
+ final var captor3 = ArgumentCaptor.forClass(TxListener.class);
verify(writeTx3).addListener(captor3.capture());
//cancel 3rd tx
writeTx3.cancel();
verify(registration1).close();
verify(registration2).close();
verify(registration3).close();
- verify(listener).onTransactionChainSuccessful(chain);
+ verify(listener).onSuccess(Empty.value());
}
@Test
public void testMultiplePendingTransactionsFail() {
//create 1st tx
final AbstractWriteTx writeTx1 = chain.newWriteOnlyTransaction();
- final ArgumentCaptor<TxListener> captor1 = ArgumentCaptor.forClass(TxListener.class);
+ final var captor1 = ArgumentCaptor.forClass(TxListener.class);
verify(writeOnlyTx1).addListener(captor1.capture());
//submit 1st tx
writeTx1.commit();
//create 2nd tx
final AbstractWriteTx writeTx2 = chain.newWriteOnlyTransaction();
- final ArgumentCaptor<TxListener> captor2 = ArgumentCaptor.forClass(TxListener.class);
+ final var captor2 = ArgumentCaptor.forClass(TxListener.class);
verify(writeTx2).addListener(captor2.capture());
//submit 2nd tx
writeTx2.commit();
//create 3rd tx
final AbstractWriteTx writeTx3 = chain.newWriteOnlyTransaction();
- final ArgumentCaptor<TxListener> captor3 = ArgumentCaptor.forClass(TxListener.class);
+ final var captor3 = ArgumentCaptor.forClass(TxListener.class);
verify(writeTx3).addListener(captor3.capture());
chain.close();
verify(registration1).close();
verify(registration2).close();
verify(registration3).close();
- verify(listener).onTransactionChainFailed(chain, writeOnlyTx1, cause1);
+ verify(listener).onFailure(cause1);
// 1 transaction failed, onTransactionChainSuccessful must not be called
- verify(listener, never()).onTransactionChainSuccessful(chain);
+ verify(listener, never()).onSuccess(any());
}
}
}
@Override
- public EffectiveModelContext getEffectiveModelContext() {
- return new ProxyEffectiveModelContext(delegate.getEffectiveModelContext());
+ public EffectiveModelContext modelContext() {
+ return new ProxyEffectiveModelContext(delegate.modelContext());
}
@Override
import org.junit.Test;
import org.opendaylight.mdsal.binding.runtime.spi.BindingRuntimeHelpers;
import org.opendaylight.netconf.api.xml.XmlUtil;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.monitoring.rev101004.$YangModuleInfoImpl;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.monitoring.rev101004.NetconfState;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.monitoring.rev101004.netconf.state.Sessions;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.monitoring.rev101004.netconf.state.sessions.Session;
+import org.opendaylight.yang.svc.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.monitoring.rev101004.YangModuleInfoImpl;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
public class NormalizedDataUtilTest {
@Test
public void testWriteNormalizedNode() throws Exception {
- final var context = BindingRuntimeHelpers.createEffectiveModel(List.of($YangModuleInfoImpl.getInstance()));
+ final var context = BindingRuntimeHelpers.createEffectiveModel(List.of(YangModuleInfoImpl.getInstance()));
final var result = new DOMResult(XmlUtil.newDocument());
NormalizedDataUtil.writeNormalizedNode(Builders.containerBuilder()
.withNodeIdentifier(new NodeIdentifier(Sessions.QNAME))
* The {@code <edit-config>} operation is extended according its attributes (merge, replace, create, delete, remove), as
* per RFC6241.
*/
-public interface NetconfDataTreeService extends DOMService {
+public interface NetconfDataTreeService extends DOMService<NetconfDataTreeService, NetconfDataTreeService.Extension> {
+ /**
+ * Type capture of a {@link DOMService.Extension} applicable to {@link NetconfDataTreeService} implementations.
+ */
+ interface Extension extends DOMService.Extension<NetconfDataTreeService, Extension> {
+ // Marker interface
+ }
+
/**
* Return device identifier.
*
package org.opendaylight.netconf.dom.api.tx;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.mdsal.dom.api.DOMDataBrokerExtension;
-import org.opendaylight.mdsal.dom.api.DOMTransactionChainListener;
+import org.opendaylight.mdsal.dom.api.DOMDataBroker.Extension;
/**
* DOM data broker extension with an option to read only selected fields under parent data node.
*/
-public interface NetconfDOMDataBrokerFieldsExtension extends DOMDataBrokerExtension {
+public interface NetconfDOMDataBrokerFieldsExtension extends Extension {
/**
* Create a new read-only transaction with an option to read only selected fields from target data node.
*
/**
* Create a new transaction chain with an option to read only selected fields from target data node.
*
- * @param listener Transaction chain event listener.
* @return A new transaction chain.
- * @throws NullPointerException if {@code listener} is null
*/
- @NonNull NetconfDOMFieldsTransactionChain createTransactionChain(DOMTransactionChainListener listener);
+ @NonNull NetconfDOMFieldsTransactionChain createTransactionChain();
}
import java.util.concurrent.atomic.AtomicReference;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.mdsal.dom.api.DOMSchemaService;
+import org.opendaylight.mdsal.dom.api.DOMSchemaService.YangTextSourceExtension;
import org.opendaylight.netconf.server.api.monitoring.CapabilityListener;
import org.opendaylight.yangtools.concepts.Registration;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
-import org.opendaylight.yangtools.yang.model.api.EffectiveModelContextListener;
-import org.opendaylight.yangtools.yang.model.repo.api.YangTextSchemaSource;
-import org.opendaylight.yangtools.yang.model.repo.spi.SchemaSourceProvider;
// Non-final for mocking
@SuppressWarnings("checkstyle:FinalClass")
-public class CurrentSchemaContext implements EffectiveModelContextListener, AutoCloseable {
+public class CurrentSchemaContext implements AutoCloseable {
private final AtomicReference<EffectiveModelContext> currentContext = new AtomicReference<>();
private final Set<CapabilityListener> listeners = Collections.synchronizedSet(new HashSet<>());
- private final SchemaSourceProvider<YangTextSchemaSource> rootSchemaSourceProvider;
+ private final YangTextSourceExtension yangTextSourceExtension;
private Registration schemaContextListenerListenerRegistration;
- private CurrentSchemaContext(final SchemaSourceProvider<YangTextSchemaSource> rootSchemaSourceProvider) {
- this.rootSchemaSourceProvider = rootSchemaSourceProvider;
+ private CurrentSchemaContext(final YangTextSourceExtension yangTextSourceExtension) {
+ this.yangTextSourceExtension = yangTextSourceExtension;
}
// keep spotbugs from complaining about overridable method in constructor
public static CurrentSchemaContext create(final DOMSchemaService schemaService,
- final SchemaSourceProvider<YangTextSchemaSource> rootSchemaSourceProvider) {
- var context = new CurrentSchemaContext(rootSchemaSourceProvider);
- final Registration registration = schemaService.registerSchemaContextListener(context);
+ final YangTextSourceExtension yangTextSourceExtension) {
+ var context = new CurrentSchemaContext(yangTextSourceExtension);
+ final var registration = schemaService.registerSchemaContextListener(context::onModelContextUpdated);
context.setRegistration(registration);
return context;
}
return ret;
}
- @Override
- public void onModelContextUpdated(final EffectiveModelContext schemaContext) {
+ private void onModelContextUpdated(final EffectiveModelContext schemaContext) {
currentContext.set(schemaContext);
// FIXME is notifying all the listeners from this callback wise ?
final var addedCaps = MdsalNetconfOperationServiceFactory.transformCapabilities(schemaContext,
- rootSchemaSourceProvider);
+ yangTextSourceExtension);
for (var listener : listeners) {
listener.onCapabilitiesChanged(addedCaps, Set.of());
}
public Registration registerCapabilityListener(final CapabilityListener listener) {
listener.onCapabilitiesChanged(MdsalNetconfOperationServiceFactory.transformCapabilities(currentContext.get(),
- rootSchemaSourceProvider), Set.of());
+ yangTextSourceExtension), Set.of());
listeners.add(listener);
return () -> listeners.remove(listener);
}
import com.google.common.util.concurrent.FluentFuture;
import java.io.Serial;
import org.opendaylight.mdsal.dom.api.DOMDataBroker;
-import org.opendaylight.mdsal.dom.api.DOMDataBrokerExtension;
+import org.opendaylight.mdsal.dom.api.DOMDataBroker.Extension;
import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteTransaction;
-import org.opendaylight.mdsal.dom.api.DOMServiceExtension;
import org.opendaylight.yangtools.yang.common.ErrorTag;
import org.opendaylight.yangtools.yang.common.ErrorType;
import org.opendaylight.yangtools.yang.common.OperationFailedException;
import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
/**
- * A {@link DOMServiceExtension} which allows users to provide Validate capability for {@link DOMDataBroker}.
+ * A {@link DOMDataBroker} {@link Extension} which allows users to provide Validate capability.
*
* <p> See <a href="https://tools.ietf.org/html/rfc4741#section-8.6">RFC4741 section 8.6</a> for details.
*/
@Beta
-public interface DOMDataTransactionValidator extends DOMDataBrokerExtension {
+public interface DOMDataTransactionValidator extends Extension {
/**
* Validates state of the data tree associated with the provided {@link DOMDataTreeWriteTransaction}.
*
import org.opendaylight.mdsal.dom.api.DOMDataBroker;
import org.opendaylight.mdsal.dom.api.DOMRpcService;
import org.opendaylight.mdsal.dom.api.DOMSchemaService;
-import org.opendaylight.mdsal.dom.api.DOMYangTextSourceProvider;
+import org.opendaylight.mdsal.dom.api.DOMSchemaService.YangTextSourceExtension;
import org.opendaylight.netconf.api.CapabilityURN;
import org.opendaylight.netconf.server.api.monitoring.BasicCapability;
import org.opendaylight.netconf.server.api.monitoring.Capability;
import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.model.api.ModuleLike;
-import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
-import org.opendaylight.yangtools.yang.model.repo.api.YangTextSchemaSource;
-import org.opendaylight.yangtools.yang.model.repo.spi.SchemaSourceProvider;
+import org.opendaylight.yangtools.yang.model.api.source.SourceIdentifier;
import org.osgi.service.component.annotations.Activate;
import org.osgi.service.component.annotations.Component;
import org.osgi.service.component.annotations.Deactivate;
private final DOMRpcService rpcService;
private final CurrentSchemaContext currentSchemaContext;
- private final SchemaSourceProvider<YangTextSchemaSource> rootSchemaSourceProviderDependency;
+ private final YangTextSourceExtension yangTextSourceExtension;
private final NetconfOperationServiceFactoryListener netconfOperationServiceFactoryListener;
@Activate
this.rpcService = requireNonNull(rpcService);
this.netconfOperationServiceFactoryListener = requireNonNull(netconfOperationServiceFactoryListener);
- rootSchemaSourceProviderDependency = schemaService.getExtensions()
- .getInstance(DOMYangTextSourceProvider.class);
- currentSchemaContext = CurrentSchemaContext.create(requireNonNull(schemaService),
- rootSchemaSourceProviderDependency);
+ yangTextSourceExtension = schemaService.extension(YangTextSourceExtension.class);
+ currentSchemaContext = CurrentSchemaContext.create(requireNonNull(schemaService), yangTextSourceExtension);
netconfOperationServiceFactoryListener.onAddNetconfOperationServiceFactory(this);
}
@Override
public Set<Capability> getCapabilities() {
// FIXME: cache returned set
- return transformCapabilities(currentSchemaContext.getCurrentContext(), rootSchemaSourceProviderDependency);
+ return transformCapabilities(currentSchemaContext.getCurrentContext(), yangTextSourceExtension);
}
// FIXME: ImmutableSet
static Set<Capability> transformCapabilities(final EffectiveModelContext currentContext,
- final SchemaSourceProvider<YangTextSchemaSource> rootSchemaSourceProviderDependency) {
+ final YangTextSourceExtension rootSchemaSourceProviderDependency) {
final var capabilities = new HashSet<Capability>();
// Added by netconf-impl by default
}
private static Optional<YangModuleCapability> moduleToCapability(final ModuleLike module,
- final SchemaSourceProvider<YangTextSchemaSource> rootSchemaSourceProviderDependency) {
+ final YangTextSourceExtension yangTextSourceExtension) {
final String moduleNamespace = module.getNamespace().toString();
final String moduleName = module.getName();
final String revision = module.getRevision().map(Revision::toString).orElse(null);
String source;
try {
- source = rootSchemaSourceProviderDependency.getSource(moduleSourceIdentifier).get().read();
+ source = yangTextSourceExtension.getYangTexttSource(moduleSourceIdentifier).get().read();
} catch (ExecutionException | InterruptedException | IOException e) {
LOG.warn("Ignoring source for module {}. Unable to read content", moduleSourceIdentifier, e);
source = null;
@Override
public Registration registerCapabilityListener(final CapabilityListener listener) {
// Advertise validate capability only if DOMDataBroker provides DOMDataTransactionValidator
- if (dataBroker.getExtensions().get(DOMDataTransactionValidator.class) != null) {
+ if (dataBroker.extension(DOMDataTransactionValidator.class) != null) {
// FIXME: support VALIDATE_1_1 as well!
listener.onCapabilitiesChanged(Set.of(VALIDATE_CAPABILITY), Set.of());
}
public TransactionProvider(final DOMDataBroker dataBroker, final SessionIdType sessionId) {
this.dataBroker = dataBroker;
this.sessionId = sessionId;
- transactionValidator = dataBroker.getExtensions().getInstance(DOMDataTransactionValidator.class);
+ transactionValidator = dataBroker.extension(DOMDataTransactionValidator.class);
}
@Override
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.Sets;
-import java.util.Collection;
+import java.util.List;
import java.util.Set;
import org.opendaylight.mdsal.binding.api.DataBroker;
-import org.opendaylight.mdsal.binding.api.DataObjectModification;
import org.opendaylight.mdsal.binding.api.DataTreeChangeListener;
import org.opendaylight.mdsal.binding.api.DataTreeIdentifier;
import org.opendaylight.mdsal.binding.api.DataTreeModification;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.notifications.rev120206.NetconfCapabilityChangeBuilder;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.notifications.rev120206.changed.by.parms.ChangedByBuilder;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.notifications.rev120206.changed.by.parms.changed.by.server.or.user.ServerBuilder;
-import org.opendaylight.yangtools.concepts.ListenerRegistration;
+import org.opendaylight.yangtools.concepts.Registration;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.common.Empty;
import org.osgi.service.component.annotations.Activate;
private static final Logger LOG = LoggerFactory.getLogger(CapabilityChangeNotificationProducer.class);
private final BaseNotificationPublisherRegistration baseNotificationPublisherRegistration;
- private final ListenerRegistration<?> capabilityChangeListenerRegistration;
+ private final Registration capabilityChangeListenerRegistration;
@Activate
public CapabilityChangeNotificationProducer(
@Reference(target = "(type=netconf-notification-manager)") final NetconfNotificationCollector notifManager,
@Reference final DataBroker dataBroker) {
baseNotificationPublisherRegistration = notifManager.registerBaseNotificationPublisher();
- capabilityChangeListenerRegistration = dataBroker.registerDataTreeChangeListener(
- DataTreeIdentifier.create(LogicalDatastoreType.OPERATIONAL,
+ capabilityChangeListenerRegistration = dataBroker.registerTreeChangeListener(
+ DataTreeIdentifier.of(LogicalDatastoreType.OPERATIONAL,
InstanceIdentifier.builder(NetconfState.class).child(Capabilities.class).build()), this);
}
}
@Override
- public void onDataTreeChanged(final Collection<DataTreeModification<Capabilities>> changes) {
- for (DataTreeModification<Capabilities> change : changes) {
- final DataObjectModification<Capabilities> rootNode = change.getRootNode();
- final DataObjectModification.ModificationType modificationType = rootNode.getModificationType();
+ public void onDataTreeChanged(final List<DataTreeModification<Capabilities>> changes) {
+ for (var change : changes) {
+ final var rootNode = change.getRootNode();
+ final var modificationType = rootNode.modificationType();
switch (modificationType) {
case WRITE: {
- final Capabilities dataAfter = rootNode.getDataAfter();
- final Capabilities dataBefore = rootNode.getDataBefore();
+ final Capabilities dataAfter = rootNode.dataAfter();
+ final Capabilities dataBefore = rootNode.dataBefore();
final Set<Uri> before = dataBefore != null ? ImmutableSet.copyOf(dataBefore.getCapability())
: Set.of();
final Set<Uri> after = dataAfter != null ? ImmutableSet.copyOf(dataAfter.getCapability())
break;
}
case DELETE: {
- final Capabilities dataBeforeDelete = rootNode.getDataBefore();
+ final Capabilities dataBeforeDelete = rootNode.dataBefore();
if (dataBeforeDelete != null) {
final Set<Uri> removed = ImmutableSet.copyOf(dataBeforeDelete.getCapability());
publishNotification(Set.of(), removed);
import org.w3c.dom.Document;
final class NotificationsTransformUtil {
- private final EffectiveModelContext schemaContext;
+ private final EffectiveModelContext modelContext;
private final BindingNormalizedNodeSerializer serializer;
NotificationsTransformUtil(final YangParserFactory parserFactory, final BindingRuntimeGenerator generator,
final BindingDOMCodecFactory codecFactory) throws YangParserException {
final var ctx = BindingRuntimeHelpers.createRuntimeContext(parserFactory, generator,
Netconf.class, NetconfConfigChange.class, YangLibraryChange.class, YangLibraryUpdate.class);
- schemaContext = ctx.getEffectiveModelContext();
- verify(schemaContext.getOperations().stream()
+ modelContext = ctx.modelContext();
+ verify(modelContext.getOperations().stream()
.filter(input -> input.getQName().getLocalName().equals(CreateSubscription.CREATE_SUBSCRIPTION))
.findFirst()
.isPresent());
final var containerNode = serializer.toNormalizedNodeNotification(notification);
final var result = new DOMResult(XmlUtil.newDocument());
try {
- NormalizedDataUtil.writeNormalizedNode(containerNode, result, schemaContext, path);
+ NormalizedDataUtil.writeNormalizedNode(containerNode, result, modelContext, path);
} catch (final XMLStreamException | IOException e) {
throw new IllegalStateException("Unable to serialize " + notification, e);
}
*/
package org.opendaylight.netconf.server.mdsal.notifications;
-import java.util.Collection;
+import java.util.List;
import org.opendaylight.mdsal.binding.api.DataBroker;
-import org.opendaylight.mdsal.binding.api.DataObjectModification;
import org.opendaylight.mdsal.binding.api.DataTreeChangeListener;
import org.opendaylight.mdsal.binding.api.DataTreeIdentifier;
import org.opendaylight.mdsal.binding.api.DataTreeModification;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.monitoring.rev101004.netconf.state.sessions.Session;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.notifications.rev120206.NetconfSessionEndBuilder;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.notifications.rev120206.NetconfSessionStartBuilder;
-import org.opendaylight.yangtools.concepts.ListenerRegistration;
+import org.opendaylight.yangtools.concepts.Registration;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.osgi.service.component.annotations.Activate;
import org.osgi.service.component.annotations.Component;
private static final Logger LOG = LoggerFactory.getLogger(SessionNotificationProducer.class);
private final BaseNotificationPublisherRegistration baseNotificationPublisherRegistration;
- private final ListenerRegistration<?> sessionListenerRegistration;
+ private final Registration sessionListenerRegistration;
@Activate
public SessionNotificationProducer(
@Reference final DataBroker dataBroker) {
baseNotificationPublisherRegistration = notifManager.registerBaseNotificationPublisher();
sessionListenerRegistration = dataBroker.registerDataTreeChangeListener(
- DataTreeIdentifier.create(LogicalDatastoreType.OPERATIONAL,
+ DataTreeIdentifier.of(LogicalDatastoreType.OPERATIONAL,
InstanceIdentifier.builder(NetconfState.class).child(Sessions.class).child(Session.class).build()),
this);
}
}
@Override
- public void onDataTreeChanged(final Collection<DataTreeModification<Session>> changes) {
- for (DataTreeModification<Session> change : changes) {
- final DataObjectModification<Session> rootNode = change.getRootNode();
- final DataObjectModification.ModificationType modificationType = rootNode.getModificationType();
+ public void onDataTreeChanged(final List<DataTreeModification<Session>> changes) {
+ for (var change : changes) {
+ final var rootNode = change.getRootNode();
+ final var modificationType = rootNode.modificationType();
switch (modificationType) {
case WRITE:
- final Session created = rootNode.getDataAfter();
- if (created != null && rootNode.getDataBefore() == null) {
+ final Session created = rootNode.dataAfter();
+ if (created != null && rootNode.dataBefore() == null) {
publishStartedSession(created);
}
break;
case DELETE:
- final Session removed = rootNode.getDataBefore();
+ final Session removed = rootNode.dataBefore();
if (removed != null) {
publishEndedSession(removed);
}
*/
package org.opendaylight.netconf.server.mdsal.notifications;
-import java.util.Collection;
import org.opendaylight.mdsal.binding.api.DataBroker;
-import org.opendaylight.mdsal.binding.api.DataTreeChangeListener;
+import org.opendaylight.mdsal.binding.api.DataListener;
import org.opendaylight.mdsal.binding.api.DataTreeIdentifier;
-import org.opendaylight.mdsal.binding.api.DataTreeModification;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netconf.server.api.notifications.NetconfNotificationCollector;
import org.opendaylight.netconf.server.api.notifications.YangLibraryPublisherRegistration;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.library.rev190104.ModulesState;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.library.rev190104.YangLibraryChangeBuilder;
-import org.opendaylight.yangtools.concepts.ListenerRegistration;
+import org.opendaylight.yangtools.concepts.Registration;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.osgi.service.component.annotations.Activate;
import org.osgi.service.component.annotations.Component;
*/
@Component(service = { })
@Deprecated(forRemoval = true)
-public final class YangLibraryNotificationProducer implements DataTreeChangeListener<ModulesState>, AutoCloseable {
- private final ListenerRegistration<?> yangLibraryChangeListenerRegistration;
+public final class YangLibraryNotificationProducer implements DataListener<ModulesState>, AutoCloseable {
+ private final Registration yangLibraryChangeListenerRegistration;
private final YangLibraryPublisherRegistration yangLibraryPublisherRegistration;
@Activate
@Reference(target = "(type=netconf-notification-manager)") final NetconfNotificationCollector notifManager,
@Reference final DataBroker dataBroker) {
yangLibraryPublisherRegistration = notifManager.registerYangLibraryPublisher();
- yangLibraryChangeListenerRegistration = dataBroker.registerDataTreeChangeListener(
- DataTreeIdentifier.create(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(ModulesState.class)),
+ yangLibraryChangeListenerRegistration = dataBroker.registerDataListener(
+ DataTreeIdentifier.of(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(ModulesState.class)),
this);
}
}
@Override
- public void onDataTreeChanged(final Collection<DataTreeModification<ModulesState>> changes) {
- for (DataTreeModification<ModulesState> change : changes) {
- final ModulesState dataAfter = change.getRootNode().getDataAfter();
- if (dataAfter != null) {
- yangLibraryPublisherRegistration.onYangLibraryChange(new YangLibraryChangeBuilder()
- .setModuleSetId(dataAfter.getModuleSetId())
- .build());
- }
+ public void dataChangedTo(final ModulesState data) {
+ if (data != null) {
+ yangLibraryPublisherRegistration.onYangLibraryChange(new YangLibraryChangeBuilder()
+ .setModuleSetId(data.getModuleSetId())
+ .build());
}
}
}
*/
package org.opendaylight.netconf.server.mdsal.notifications;
-import java.util.Collection;
import org.opendaylight.mdsal.binding.api.DataBroker;
-import org.opendaylight.mdsal.binding.api.DataTreeChangeListener;
+import org.opendaylight.mdsal.binding.api.DataListener;
import org.opendaylight.mdsal.binding.api.DataTreeIdentifier;
-import org.opendaylight.mdsal.binding.api.DataTreeModification;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netconf.server.api.notifications.NetconfNotificationCollector;
import org.opendaylight.netconf.server.api.notifications.YangLibraryPublisherRegistration;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.library.rev190104.YangLibrary;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.library.rev190104.YangLibraryUpdateBuilder;
-import org.opendaylight.yangtools.concepts.ListenerRegistration;
+import org.opendaylight.yangtools.concepts.Registration;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.osgi.service.component.annotations.Activate;
import org.osgi.service.component.annotations.Component;
*/
@Component(service = { })
public final class YangLibraryNotificationProducerRFC8525
- implements DataTreeChangeListener<YangLibrary>, AutoCloseable {
- private final ListenerRegistration<?> yangLibraryChangeListenerRegistration;
+ implements DataListener<YangLibrary>, AutoCloseable {
+ private final Registration yangLibraryChangeListenerRegistration;
private final YangLibraryPublisherRegistration yangLibraryPublisherRegistration;
@Activate
@Reference(target = "(type=netconf-notification-manager)") final NetconfNotificationCollector notifManager,
@Reference final DataBroker dataBroker) {
yangLibraryPublisherRegistration = notifManager.registerYangLibraryPublisher();
- yangLibraryChangeListenerRegistration = dataBroker.registerDataTreeChangeListener(
- DataTreeIdentifier.create(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(YangLibrary.class)),
+ yangLibraryChangeListenerRegistration = dataBroker.registerDataListener(
+ DataTreeIdentifier.of(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(YangLibrary.class)),
this);
}
}
@Override
- public void onDataTreeChanged(final Collection<DataTreeModification<YangLibrary>> changes) {
- for (DataTreeModification<YangLibrary> change : changes) {
- final YangLibrary dataAfter = change.getRootNode().getDataAfter();
- if (dataAfter != null) {
- yangLibraryPublisherRegistration.onYangLibraryUpdate(new YangLibraryUpdateBuilder()
- .setContentId(dataAfter.getContentId())
- .build());
- }
+ public void dataChangedTo(final YangLibrary data) {
+ if (data != null) {
+ yangLibraryPublisherRegistration.onYangLibraryUpdate(new YangLibraryUpdateBuilder()
+ .setContentId(data.getContentId())
+ .build());
}
}
}
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.notifications.rev120206.NetconfCapabilityChangeBuilder;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.notifications.rev120206.changed.by.parms.ChangedByBuilder;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.notifications.rev120206.changed.by.parms.changed.by.server.or.user.ServerBuilder;
-import org.opendaylight.yangtools.concepts.ListenerRegistration;
+import org.opendaylight.yangtools.concepts.Registration;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.common.Empty;
@Mock
private BaseNotificationPublisherRegistration baseNotificationPublisherRegistration;
@Mock
- private ListenerRegistration<?> listenerRegistration;
+ private Registration listenerRegistration;
@Mock
private NetconfNotificationCollector netconfNotificationCollector;
@Mock
@Before
public void setUp() {
- doReturn(listenerRegistration).when(dataBroker).registerDataTreeChangeListener(any(DataTreeIdentifier.class),
+ doReturn(listenerRegistration).when(dataBroker).registerTreeChangeListener(any(DataTreeIdentifier.class),
any(DataTreeChangeListener.class));
doNothing().when(baseNotificationPublisherRegistration).onCapabilityChanged(any(NetconfCapabilityChange.class));
final NetconfCapabilityChange expectedChange) {
final DataTreeModification<Capabilities> treeChange2 = mock(DataTreeModification.class);
final DataObjectModification<Capabilities> objectChange2 = mock(DataObjectModification.class);
- doReturn(modificationType).when(objectChange2).getModificationType();
+ doReturn(modificationType).when(objectChange2).modificationType();
doReturn(objectChange2).when(treeChange2).getRootNode();
- doReturn(originalCapabilities).when(objectChange2).getDataBefore();
- doReturn(updatedCapabilities).when(objectChange2).getDataAfter();
+ doReturn(originalCapabilities).when(objectChange2).dataBefore();
+ doReturn(updatedCapabilities).when(objectChange2).dataAfter();
capabilityChangeNotificationProducer.onDataTreeChanged(List.of(treeChange2));
verify(baseNotificationPublisherRegistration).onCapabilityChanged(expectedChange);
}
final DataObjectModification<Session> changeObject = mock(DataObjectModification.class);
final Session sessionBefore = createSessionWithInRpcCount(Uint32.ONE, Uint32.ZERO);
final Session sessionAfter = createSessionWithInRpcCount(Uint32.ONE, Uint32.ONE);
- doReturn(sessionBefore).when(changeObject).getDataBefore();
- doReturn(sessionAfter).when(changeObject).getDataAfter();
- doReturn(ModificationType.WRITE).when(changeObject).getModificationType();
+ doReturn(sessionBefore).when(changeObject).dataBefore();
+ doReturn(sessionAfter).when(changeObject).dataAfter();
+ doReturn(ModificationType.WRITE).when(changeObject).modificationType();
doReturn(changeObject).when(treeChange).getRootNode();
publisher.onDataTreeChanged(List.of(treeChange));
//session didn't start, only stats changed. No notification should be produced
final DataObjectModification<Session> changeObject = mock(DataObjectModification.class);
switch (type) {
case WRITE:
- doReturn(null).when(changeObject).getDataBefore();
- doReturn(session).when(changeObject).getDataAfter();
+ doReturn(null).when(changeObject).dataBefore();
+ doReturn(session).when(changeObject).dataAfter();
break;
case DELETE:
- doReturn(session).when(changeObject).getDataBefore();
+ doReturn(session).when(changeObject).dataBefore();
break;
default:
LOG.debug("Received intentionally unhandled type: {}.", type);
}
- doReturn(type).when(changeObject).getModificationType();
+ doReturn(type).when(changeObject).modificationType();
doReturn(changeObject).when(treeChange).getRootNode();
return treeChange;
}
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.doNothing;
import static org.mockito.Mockito.doReturn;
-import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
-import java.util.List;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.junit.MockitoJUnitRunner;
import org.opendaylight.mdsal.binding.api.DataBroker;
-import org.opendaylight.mdsal.binding.api.DataObjectModification;
-import org.opendaylight.mdsal.binding.api.DataTreeModification;
import org.opendaylight.netconf.server.api.notifications.NetconfNotificationCollector;
import org.opendaylight.netconf.server.api.notifications.YangLibraryPublisherRegistration;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.monitoring.rev101004.netconf.state.Capabilities;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.library.rev190104.ModulesState;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.library.rev190104.ModulesStateBuilder;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.library.rev190104.YangLibraryChange;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.library.rev190104.YangLibraryChangeBuilder;
-import org.opendaylight.yangtools.concepts.ListenerRegistration;
+import org.opendaylight.yangtools.concepts.Registration;
@RunWith(MockitoJUnitRunner.StrictStubs.class)
public class YangLibraryNotificationProducerTest {
@Mock
private DataBroker dataBroker;
@Mock
- private ListenerRegistration<?> registration;
+ private Registration registration;
private YangLibraryNotificationProducer yangLibraryNotificationProducer;
doNothing().when(yangLibraryPublisherRegistration).onYangLibraryChange(any(YangLibraryChange.class));
doReturn(yangLibraryPublisherRegistration).when(netconfNotificationCollector)
.registerYangLibraryPublisher();
- doReturn(registration).when(dataBroker).registerDataTreeChangeListener(any(), any());
+ doReturn(registration).when(dataBroker).registerDataListener(any(), any());
- yangLibraryNotificationProducer = new YangLibraryNotificationProducer(netconfNotificationCollector,
- dataBroker);
+ yangLibraryNotificationProducer = new YangLibraryNotificationProducer(netconfNotificationCollector, dataBroker);
}
@Test
public void testOnDataTreeChanged() {
final String moduleSetId = "1";
- ModulesState modulesStateAfter = new ModulesStateBuilder().setModuleSetId(moduleSetId).build();
+ final var modulesStateAfter = new ModulesStateBuilder().setModuleSetId(moduleSetId).build();
- final DataTreeModification<ModulesState> treeChange = mock(DataTreeModification.class);
- final DataObjectModification<Capabilities> objectChange = mock(DataObjectModification.class);
- doReturn(objectChange).when(treeChange).getRootNode();
- doReturn(modulesStateAfter).when(objectChange).getDataAfter();
-
- YangLibraryChange yangLibraryChange = new YangLibraryChangeBuilder().setModuleSetId(moduleSetId).build();
- yangLibraryNotificationProducer.onDataTreeChanged(List.of(treeChange));
+ yangLibraryNotificationProducer.dataChangedTo(modulesStateAfter);
+ final var yangLibraryChange = new YangLibraryChangeBuilder().setModuleSetId(moduleSetId).build();
verify(yangLibraryPublisherRegistration).onYangLibraryChange(yangLibraryChange);
}
}
\ No newline at end of file
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.doNothing;
import static org.mockito.Mockito.doReturn;
-import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
-import java.util.List;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.junit.MockitoJUnitRunner;
import org.opendaylight.mdsal.binding.api.DataBroker;
-import org.opendaylight.mdsal.binding.api.DataObjectModification;
-import org.opendaylight.mdsal.binding.api.DataTreeModification;
import org.opendaylight.netconf.server.api.notifications.NetconfNotificationCollector;
import org.opendaylight.netconf.server.api.notifications.YangLibraryPublisherRegistration;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.monitoring.rev101004.netconf.state.Capabilities;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.library.rev190104.YangLibrary;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.library.rev190104.YangLibraryBuilder;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.library.rev190104.YangLibraryUpdate;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.library.rev190104.YangLibraryUpdateBuilder;
+import org.opendaylight.yangtools.concepts.Registration;
@RunWith(MockitoJUnitRunner.StrictStubs.class)
public class YangLibraryNotificationProducerTestRFC8525 {
private NetconfNotificationCollector netconfNotificationCollector;
@Mock
private DataBroker dataBroker;
+ @Mock
+ private Registration registration;
private YangLibraryNotificationProducerRFC8525 yangLibraryNotificationProducer;
@Before
public void setUp() {
- doNothing().when(yangLibraryPublisherRegistration).onYangLibraryUpdate(any(YangLibraryUpdate.class));
+ doNothing().when(yangLibraryPublisherRegistration).onYangLibraryUpdate(any());
doReturn(yangLibraryPublisherRegistration).when(netconfNotificationCollector).registerYangLibraryPublisher();
+ doReturn(registration).when(dataBroker).registerDataListener(any(), any());
yangLibraryNotificationProducer = new YangLibraryNotificationProducerRFC8525(netconfNotificationCollector,
dataBroker);
@Test
public void testOnDataTreeChanged() {
final String contentId = "1";
- YangLibrary yangLibraryAfter = new YangLibraryBuilder().setContentId(contentId).build();
- final DataTreeModification<YangLibrary> treeChange = mock(DataTreeModification.class);
- final DataObjectModification<Capabilities> objectChange = mock(DataObjectModification.class);
- doReturn(objectChange).when(treeChange).getRootNode();
- doReturn(yangLibraryAfter).when(objectChange).getDataAfter();
+ yangLibraryNotificationProducer.dataChangedTo(new YangLibraryBuilder().setContentId(contentId).build());
YangLibraryUpdate yangLibraryUpdate = new YangLibraryUpdateBuilder().setContentId(contentId).build();
- yangLibraryNotificationProducer.onDataTreeChanged(List.of(treeChange));
-
verify(yangLibraryPublisherRegistration).onYangLibraryUpdate(yangLibraryUpdate);
}
}
\ No newline at end of file
import org.opendaylight.yangtools.util.concurrent.SpecialExecutors;
import org.opendaylight.yangtools.yang.common.Uint32;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
-import org.opendaylight.yangtools.yang.model.repo.api.YangTextSchemaSource;
+import org.opendaylight.yangtools.yang.model.spi.source.DelegatedYangTextSource;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.w3c.dom.Document;
final DOMStore configStore = InMemoryDOMDataStoreFactory.create("DOM-CFG", schemaService);
currentSchemaContext = CurrentSchemaContext.create(schemaService,
- sourceIdentifier -> Futures.immediateFuture(YangTextSchemaSource.delegateForCharSource(sourceIdentifier,
+ sourceIdentifier -> Futures.immediateFuture(new DelegatedYangTextSource(sourceIdentifier,
CharSource.wrap("module test"))));
final var datastores = new EnumMap<LogicalDatastoreType, DOMStore>(LogicalDatastoreType.class);
import static org.mockito.Mockito.mock;
import com.google.common.collect.ImmutableMap;
-import java.math.BigDecimal;
-import java.math.BigInteger;
import org.junit.Test;
import org.opendaylight.netconf.api.xml.XmlElement;
import org.opendaylight.netconf.api.xml.XmlUtil;
import org.opendaylight.netconf.server.mdsal.CurrentSchemaContext;
+import org.opendaylight.yangtools.yang.common.Decimal64;
import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.common.Uint16;
+import org.opendaylight.yangtools.yang.common.Uint32;
+import org.opendaylight.yangtools.yang.common.Uint64;
+import org.opendaylight.yangtools.yang.common.Uint8;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
.put(QName.create(BASE, "id3"), Short.valueOf("-30000"))
.put(QName.create(BASE, "id4"), Integer.valueOf("-2000000000"))
.put(QName.create(BASE, "id5"), Long.valueOf("-2000000000000000"))
- .put(QName.create(BASE, "id6"), Short.valueOf("9"))
- .put(QName.create(BASE, "id7"), Integer.valueOf("30000"))
- .put(QName.create(BASE, "id8"), Long.valueOf("2000000000"))
- .put(QName.create(BASE, "id9"), BigInteger.valueOf(Long.parseLong("2000000000000000")))
+ .put(QName.create(BASE, "id6"), Uint8.valueOf(9))
+ .put(QName.create(BASE, "id7"), Uint16.valueOf(30000))
+ .put(QName.create(BASE, "id8"), Uint32.valueOf(2000000000))
+ .put(QName.create(BASE, "id9"), Uint64.valueOf(2000000000000000L))
.put(QName.create(BASE, "id10"), true)
- .put(QName.create(BASE, "id11"), BigDecimal.valueOf(128.55))
+ .put(QName.create(BASE, "id11"), Decimal64.valueOf("128.55"))
.put(id12, idExpected)
.put(QName.create(BASE, "id13"),
QName.create("urn:opendaylight:mdsal:mapping:test", "2015-02-26", "foo"))
import java.io.Serial;
import java.util.Collection;
import java.util.List;
+import java.util.function.Consumer;
import javax.xml.parsers.ParserConfigurationException;
import org.custommonkey.xmlunit.DetailedDiff;
import org.custommonkey.xmlunit.Diff;
import org.opendaylight.mdsal.dom.api.DOMRpcResult;
import org.opendaylight.mdsal.dom.api.DOMRpcService;
import org.opendaylight.mdsal.dom.api.DOMSchemaService;
+import org.opendaylight.mdsal.dom.api.DOMSchemaService.YangTextSourceExtension;
import org.opendaylight.mdsal.dom.spi.DefaultDOMRpcResult;
import org.opendaylight.netconf.api.DocumentedException;
import org.opendaylight.netconf.api.xml.XmlUtil;
import org.opendaylight.netconf.server.mdsal.CurrentSchemaContext;
import org.opendaylight.netconf.test.util.XmlFileLoader;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.netconf.base._1._0.rev110601.SessionIdType;
-import org.opendaylight.yangtools.concepts.ListenerRegistration;
-import org.opendaylight.yangtools.concepts.NoOpListenerRegistration;
+import org.opendaylight.yangtools.concepts.Registration;
import org.opendaylight.yangtools.yang.common.ErrorSeverity;
import org.opendaylight.yangtools.yang.common.ErrorTag;
import org.opendaylight.yangtools.yang.common.ErrorType;
import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild;
import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
-import org.opendaylight.yangtools.yang.model.api.EffectiveModelContextListener;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.RpcDefinition;
-import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
-import org.opendaylight.yangtools.yang.model.repo.api.YangTextSchemaSource;
-import org.opendaylight.yangtools.yang.model.repo.spi.SchemaSourceProvider;
+import org.opendaylight.yangtools.yang.model.api.source.SourceIdentifier;
+import org.opendaylight.yangtools.yang.model.spi.source.DelegatedYangTextSource;
import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
}
@Override
- public <T extends DOMRpcAvailabilityListener> ListenerRegistration<T> registerRpcListener(final T listener) {
- return NoOpListenerRegistration.of(listener);
+ public Registration registerRpcListener(final DOMRpcAvailabilityListener listener) {
+ return () -> { };
}
};
}
@Override
- public <T extends DOMRpcAvailabilityListener> ListenerRegistration<T> registerRpcListener(final T listener) {
- return NoOpListenerRegistration.of(listener);
+ public Registration registerRpcListener(final DOMRpcAvailabilityListener listener) {
+ return () -> { };
}
};
}
@Override
- public <T extends DOMRpcAvailabilityListener> ListenerRegistration<T> registerRpcListener(final T lsnr) {
- return NoOpListenerRegistration.of(lsnr);
+ public Registration registerRpcListener(final DOMRpcAvailabilityListener lsnr) {
+ return () -> { };
}
};
@Mock
private DOMSchemaService schemaService;
@Mock
- private EffectiveModelContextListener listener;
+ private Consumer<EffectiveModelContext> listener;
@Mock
- private ListenerRegistration<?> registration;
+ private Registration registration;
@Mock
- private SchemaSourceProvider<YangTextSchemaSource> sourceProvider;
+ private YangTextSourceExtension sourceProvider;
@BeforeClass
public static void beforeClass() {
public void setUp() throws Exception {
doNothing().when(registration).close();
doAnswer(invocationOnMock -> {
- ((EffectiveModelContextListener) invocationOnMock.getArguments()[0]).onModelContextUpdated(SCHEMA_CONTEXT);
+ ((Consumer<EffectiveModelContext>) invocationOnMock.getArgument(0)).accept(SCHEMA_CONTEXT);
return registration;
- }).when(schemaService).registerSchemaContextListener(any(EffectiveModelContextListener.class));
+ }).when(schemaService).registerSchemaContextListener(any());
XMLUnit.setIgnoreWhitespace(true);
XMLUnit.setIgnoreAttributeOrder(true);
- doAnswer(invocationOnMock -> Futures.immediateFuture(YangTextSchemaSource.delegateForCharSource(
- (SourceIdentifier) invocationOnMock.getArguments()[0], CharSource.wrap("module test"))))
- .when(sourceProvider).getSource(any(SourceIdentifier.class));
+ doAnswer(invocationOnMock -> Futures.immediateFuture(new DelegatedYangTextSource(
+ invocationOnMock.getArgument(0, SourceIdentifier.class), CharSource.wrap("module test"))))
+ .when(sourceProvider).getYangTexttSource(any(SourceIdentifier.class));
currentSchemaContext = CurrentSchemaContext.create(schemaService, sourceProvider);
}
import static java.util.Objects.requireNonNull;
-import com.google.common.collect.ClassToInstanceMap;
-import com.google.common.collect.ImmutableClassToInstanceMap;
+import java.util.function.Consumer;
import org.opendaylight.mdsal.dom.api.DOMSchemaService;
-import org.opendaylight.mdsal.dom.api.DOMSchemaServiceExtension;
-import org.opendaylight.yangtools.concepts.AbstractListenerRegistration;
-import org.opendaylight.yangtools.concepts.ListenerRegistration;
+import org.opendaylight.yangtools.concepts.Registration;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
-import org.opendaylight.yangtools.yang.model.api.EffectiveModelContextListener;
final class SchemaServiceStub implements DOMSchemaService {
private final EffectiveModelContext schemaContext;
}
@Override
- public ListenerRegistration<EffectiveModelContextListener> registerSchemaContextListener(
- final EffectiveModelContextListener listener) {
- listener.onModelContextUpdated(schemaContext);
- return new AbstractListenerRegistration<>(listener) {
- @Override
- protected void removeRegistration() {
- // No-op
- }
+ public Registration registerSchemaContextListener(final Consumer<EffectiveModelContext> listener) {
+ listener.accept(schemaContext);
+ return () -> {
+ // No-op
};
}
-
- @Override
- public ClassToInstanceMap<DOMSchemaServiceExtension> getExtensions() {
- return ImmutableClassToInstanceMap.of();
- }
}
import static org.opendaylight.netconf.server.mdsal.operations.AbstractNetconfOperationTest.executeOperation;
import static org.opendaylight.netconf.server.mdsal.operations.AbstractNetconfOperationTest.verifyResponse;
-import com.google.common.collect.ImmutableClassToInstanceMap;
+import java.util.List;
import org.custommonkey.xmlunit.XMLUnit;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
+import org.mockito.Answers;
import org.mockito.Mock;
import org.mockito.junit.MockitoJUnitRunner;
import org.opendaylight.mdsal.dom.api.DOMDataBroker;
private DOMDataTransactionValidator failingValidator;
@Mock
private DOMDataTreeReadWriteTransaction readWriteTx;
- @Mock
+ @Mock(answer = Answers.CALLS_REAL_METHODS)
private DOMDataBroker dataBroker;
@Before
}
private void whenValidatorIsNotDefined() {
- doReturn(ImmutableClassToInstanceMap.of()).when(dataBroker).getExtensions();
+ doReturn(List.of()).when(dataBroker).supportedExtensions();
}
private void whenUsingValidator(final DOMDataTransactionValidator validator) {
- doReturn(ImmutableClassToInstanceMap.of(DOMDataTransactionValidator.class, validator))
- .when(dataBroker).getExtensions();
+ doReturn(List.of(validator)).when(dataBroker).supportedExtensions();
}
private TransactionProvider initCandidateTransaction() {
final DataSchemaNode parentNode;
if (pathInference.isEmpty()) {
- parentNode = pathInference.getEffectiveModelContext();
+ parentNode = pathInference.modelContext();
} else {
final var hackStack = pathInference.toSchemaInferenceStack();
final var hackStmt = hackStack.currentStatement();
var schemaNode = parentNode;
final String docRootElm = doc.getDocumentElement().getLocalName();
final XMLNamespace docRootNamespace = XMLNamespace.of(doc.getDocumentElement().getNamespaceURI());
- final var context = pathInference.getEffectiveModelContext();
+ final var context = pathInference.modelContext();
final var it = context.findModuleStatements(docRootNamespace).iterator();
checkState(it.hasNext(), "Failed to find module for %s", docRootNamespace);
final var qname = QName.create(it.next().localQNameModule(), docRootElm);
final JsonWriter jsonWriter, final QueryParameters writerParameters,
final @Nullable XMLNamespace initialNamespace) {
// TODO: Performance: Cache JSON Codec factory and schema context
- final var codecs = JSONCodecFactorySupplier.RFC7951.getShared(inference.getEffectiveModelContext());
+ final var codecs = JSONCodecFactorySupplier.RFC7951.getShared(inference.modelContext());
return ParameterAwareNormalizedNodeWriter.forStreamWriter(
JSONNormalizedNodeStreamWriter.createNestedWriter(codecs, inference,
initialNamespace, jsonWriter), writerParameters.depth(), writerParameters.fields());
package org.opendaylight.restconf.nb.rfc8040.jersey.providers.errors;
import static java.util.Objects.requireNonNull;
-import static org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.restconf.rev170126.$YangModuleInfoImpl.qnameOf;
+import static org.opendaylight.yang.svc.v1.urn.ietf.params.xml.ns.yang.ietf.restconf.rev170126.YangModuleInfoImpl.qnameOf;
import com.google.common.annotations.VisibleForTesting;
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import org.opendaylight.mdsal.dom.api.DOMDataTreeReadWriteTransaction;
import org.opendaylight.mdsal.dom.api.DOMMountPointService;
import org.opendaylight.mdsal.dom.api.DOMRpcService;
+import org.opendaylight.mdsal.dom.api.DOMSchemaService.YangTextSourceExtension;
import org.opendaylight.mdsal.dom.api.DOMTransactionChain;
-import org.opendaylight.mdsal.dom.api.DOMYangTextSourceProvider;
import org.opendaylight.restconf.common.errors.RestconfDocumentedException;
import org.opendaylight.restconf.common.errors.RestconfFuture;
import org.opendaylight.restconf.common.errors.SettableRestconfFuture;
public MdsalRestconfStrategy(final DatabindContext databind, final DOMDataBroker dataBroker,
final @Nullable DOMRpcService rpcService, final @Nullable DOMActionService actionService,
- final @Nullable DOMYangTextSourceProvider sourceProvider,
+ final @Nullable YangTextSourceExtension sourceProvider,
final @Nullable DOMMountPointService mountPointService,
final ImmutableMap<QName, RpcImplementation> localRpcs) {
super(databind, localRpcs, rpcService, actionService, sourceProvider, mountPointService);
public MdsalRestconfStrategy(final DatabindContext databind, final DOMDataBroker dataBroker,
final @Nullable DOMRpcService rpcService, final @Nullable DOMActionService actionService,
- final @Nullable DOMYangTextSourceProvider sourceProvider,
+ final @Nullable YangTextSourceExtension sourceProvider,
final @Nullable DOMMountPointService mountPointService) {
this(databind, dataBroker, rpcService, actionService, sourceProvider, mountPointService, ImmutableMap.of());
}
final var inference = path.inference();
final var fields = params.fields();
final var translatedFields = fields == null ? null
- : WriterFieldsTranslator.translate(inference.getEffectiveModelContext(), path.schema(), fields);
+ : WriterFieldsTranslator.translate(inference.modelContext(), path.schema(), fields);
return completeDataGET(inference, QueryParameters.of(params, translatedFields),
readData(params.content(), path.instance(), params.withDefaults()), null);
}
import org.opendaylight.mdsal.dom.api.DOMActionService;
import org.opendaylight.mdsal.dom.api.DOMMountPointService;
import org.opendaylight.mdsal.dom.api.DOMRpcService;
+import org.opendaylight.mdsal.dom.api.DOMSchemaService.YangTextSourceExtension;
import org.opendaylight.mdsal.dom.api.DOMTransactionChain;
-import org.opendaylight.mdsal.dom.api.DOMYangTextSourceProvider;
import org.opendaylight.netconf.dom.api.NetconfDataTreeService;
import org.opendaylight.restconf.api.query.ContentParam;
import org.opendaylight.restconf.api.query.WithDefaultsParam;
public NetconfRestconfStrategy(final DatabindContext databind, final NetconfDataTreeService netconfService,
final @Nullable DOMRpcService rpcService, final @Nullable DOMActionService actionService,
- final @Nullable DOMYangTextSourceProvider sourceProvider,
+ final @Nullable YangTextSourceExtension sourceProvider,
final @Nullable DOMMountPointService mountPointService) {
super(databind, ImmutableMap.of(), rpcService, actionService, sourceProvider, mountPointService);
this.netconfService = requireNonNull(netconfService);
if (fields != null) {
final List<YangInstanceIdentifier> tmp;
try {
- tmp = NetconfFieldsTranslator.translate(inference.getEffectiveModelContext(), path.schema(), fields);
+ tmp = NetconfFieldsTranslator.translate(inference.modelContext(), path.schema(), fields);
} catch (RestconfDocumentedException e) {
return RestconfFuture.failed(e);
}
import org.opendaylight.mdsal.dom.api.DOMRpcResult;
import org.opendaylight.mdsal.dom.api.DOMRpcService;
import org.opendaylight.mdsal.dom.api.DOMSchemaService;
+import org.opendaylight.mdsal.dom.api.DOMSchemaService.YangTextSourceExtension;
import org.opendaylight.mdsal.dom.api.DOMTransactionChain;
-import org.opendaylight.mdsal.dom.api.DOMYangTextSourceProvider;
import org.opendaylight.mdsal.dom.spi.SimpleDOMActionResult;
import org.opendaylight.netconf.dom.api.NetconfDataTreeService;
import org.opendaylight.restconf.api.ApiPath;
import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
import org.opendaylight.yangtools.yang.model.api.RpcDefinition;
+import org.opendaylight.yangtools.yang.model.api.source.SourceIdentifier;
+import org.opendaylight.yangtools.yang.model.api.source.SourceRepresentation;
+import org.opendaylight.yangtools.yang.model.api.source.YangTextSource;
+import org.opendaylight.yangtools.yang.model.api.source.YinTextSource;
import org.opendaylight.yangtools.yang.model.api.stmt.ModuleEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.RpcEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.SubmoduleEffectiveStatement;
-import org.opendaylight.yangtools.yang.model.repo.api.SchemaSourceRepresentation;
-import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
-import org.opendaylight.yangtools.yang.model.repo.api.YangTextSchemaSource;
-import org.opendaylight.yangtools.yang.model.repo.api.YinTextSchemaSource;
import org.opendaylight.yangtools.yang.model.util.SchemaInferenceStack;
import org.opendaylight.yangtools.yang.model.util.SchemaInferenceStack.Inference;
import org.slf4j.Logger;
private final @NonNull ImmutableMap<QName, RpcImplementation> localRpcs;
private final @NonNull ApiPathNormalizer pathNormalizer;
private final @NonNull DatabindContext databind;
- private final DOMYangTextSourceProvider sourceProvider;
+ private final YangTextSourceExtension sourceProvider;
private final DOMMountPointService mountPointService;
private final DOMActionService actionService;
private final DOMRpcService rpcService;
RestconfStrategy(final DatabindContext databind, final ImmutableMap<QName, RpcImplementation> localRpcs,
final @Nullable DOMRpcService rpcService, final @Nullable DOMActionService actionService,
- final DOMYangTextSourceProvider sourceProvider, final @Nullable DOMMountPointService mountPointService) {
+ final YangTextSourceExtension sourceProvider, final @Nullable DOMMountPointService mountPointService) {
this.databind = requireNonNull(databind);
this.localRpcs = requireNonNull(localRpcs);
this.rpcService = rpcService;
final var rpcService = mountPoint.getService(DOMRpcService.class).orElse(null);
final var actionService = mountPoint.getService(DOMActionService.class).orElse(null);
final var sourceProvider = mountPoint.getService(DOMSchemaService.class)
- .flatMap(schema -> Optional.ofNullable(schema.getExtensions().getInstance(DOMYangTextSourceProvider.class)))
+ .flatMap(schema -> Optional.ofNullable(schema.extension(YangTextSourceExtension.class)))
.orElse(null);
final var netconfService = mountPoint.getService(NetconfDataTreeService.class);
return RestconfFuture.failed(e);
}
- return RestconfFuture.of(
- new OperationsGetResult.Leaf(rpc.inference().getEffectiveModelContext(), rpc.rpc().argument()));
+ return RestconfFuture.of(new OperationsGetResult.Leaf(rpc.inference().modelContext(), rpc.rpc().argument()));
}
public @NonNull RestconfFuture<OperationsPostResult> operationsPOST(final URI restconfURI, final ApiPath apiPath,
}
public @NonNull RestconfFuture<CharSource> resolveSource(final SourceIdentifier source,
- final Class<? extends SchemaSourceRepresentation> representation) {
+ final Class<? extends SourceRepresentation> representation) {
final var src = requireNonNull(source);
- if (YangTextSchemaSource.class.isAssignableFrom(representation)) {
+ if (YangTextSource.class.isAssignableFrom(representation)) {
if (sourceProvider != null) {
final var ret = new SettableRestconfFuture<CharSource>();
- Futures.addCallback(sourceProvider.getSource(src), new FutureCallback<YangTextSchemaSource>() {
+ Futures.addCallback(sourceProvider.getYangTexttSource(src), new FutureCallback<>() {
@Override
- public void onSuccess(final YangTextSchemaSource result) {
+ public void onSuccess(final YangTextSource result) {
ret.set(result);
}
}
return exportSource(modelContext(), src, YangCharSource::new, YangCharSource::new);
}
- if (YinTextSchemaSource.class.isAssignableFrom(representation)) {
+ if (YinTextSource.class.isAssignableFrom(representation)) {
return exportSource(modelContext(), src, YinCharSource.OfModule::new, YinCharSource.OfSubmodule::new);
}
return RestconfFuture.failed(new RestconfDocumentedException(
}
public @NonNull EffectiveModelContext modelContext() {
- return mountContext.getEffectiveModelContext();
+ return mountContext.modelContext();
}
public @NonNull DataSchemaContextTree schemaTree() {
}
private @NonNull JSONCodecFactory createJsonCodecs() {
- final var created = JSONCodecFactorySupplier.RFC7951.getShared(mountContext.getEffectiveModelContext());
+ final var created = JSONCodecFactorySupplier.RFC7951.getShared(mountContext.modelContext());
final var witness = (JSONCodecFactory) JSON_CODECS.compareAndExchangeRelease(this, null, created);
return witness != null ? witness : created;
}
package org.opendaylight.restconf.server.mdsal;
import static java.util.Objects.requireNonNull;
-import static org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.restconf.monitoring.rev170126.$YangModuleInfoImpl.qnameOf;
+import static org.opendaylight.yang.svc.v1.urn.ietf.params.xml.ns.yang.ietf.restconf.monitoring.rev170126.YangModuleInfoImpl.qnameOf;
import com.google.common.annotations.VisibleForTesting;
import com.google.common.util.concurrent.FutureCallback;
import org.opendaylight.mdsal.common.api.CommitInfo;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.mdsal.dom.api.DOMDataBroker;
-import org.opendaylight.mdsal.dom.api.DOMDataTreeTransaction;
import org.opendaylight.mdsal.dom.api.DOMSchemaService;
import org.opendaylight.mdsal.dom.api.DOMTransactionChain;
-import org.opendaylight.mdsal.dom.api.DOMTransactionChainListener;
import org.opendaylight.restconf.api.query.AbstractReplayParam;
import org.opendaylight.restconf.api.query.ChangedLeafNodesOnlyParam;
import org.opendaylight.restconf.api.query.ChildNodesOnlyParam;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.restconf.monitoring.rev170126.RestconfState;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.restconf.monitoring.rev170126.restconf.state.Capabilities;
import org.opendaylight.yangtools.concepts.Registration;
+import org.opendaylight.yangtools.yang.common.Empty;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.LeafSetNode;
-import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
+import org.opendaylight.yangtools.yang.data.spi.node.ImmutableNodes;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
-import org.opendaylight.yangtools.yang.model.api.EffectiveModelContextListener;
import org.osgi.service.component.annotations.Activate;
import org.osgi.service.component.annotations.Component;
import org.osgi.service.component.annotations.Deactivate;
*/
@Singleton
@Component(service = { })
-public final class CapabilitiesWriter
- implements AutoCloseable, EffectiveModelContextListener, DOMTransactionChainListener {
+public final class CapabilitiesWriter implements AutoCloseable, FutureCallback<Empty> {
private static final Logger LOG = LoggerFactory.getLogger(CapabilitiesWriter.class);
@VisibleForTesting
public CapabilitiesWriter(@Reference final DOMDataBroker dataBroker,
@Reference final DOMSchemaService schemaService) {
this.dataBroker = requireNonNull(dataBroker);
- reg = schemaService.registerSchemaContextListener(this);
+ reg = schemaService.registerSchemaContextListener(this::onModelContextUpdated);
}
@PreDestroy
}
@Override
- public synchronized void onTransactionChainFailed(final DOMTransactionChain chain,
- final DOMDataTreeTransaction transaction, final Throwable cause) {
+ public synchronized void onFailure(final Throwable cause) {
LOG.warn("Transaction chain failed, updates may not have been propagated", cause);
txChain = null;
}
@Override
- public synchronized void onTransactionChainSuccessful(final DOMTransactionChain chain) {
+ public synchronized void onSuccess(final Empty result) {
LOG.debug("Transaction chain closed successfully");
txChain = null;
}
- @Override
- public synchronized void onModelContextUpdated(final EffectiveModelContext newModelContext) {
+ private synchronized void onModelContextUpdated(final EffectiveModelContext newModelContext) {
if (reg != null) {
LOG.debug("Ignoring model context update");
return;
LOG.debug("Removing ietf-restconf-monitoring state");
if (txChain == null) {
- txChain = dataBroker.createMergingTransactionChain(this);
+ txChain = dataBroker.createMergingTransactionChain();
+ txChain.addCallback(this);
}
final var tx = txChain.newWriteOnlyTransaction();
LOG.debug("Updating state of ietf-restconf-monitoring");
if (txChain == null) {
- txChain = dataBroker.createMergingTransactionChain(this);
+ txChain = dataBroker.createMergingTransactionChain();
+ txChain.addCallback(this);
}
final var tx = txChain.newWriteOnlyTransaction();
*/
@VisibleForTesting
static @NonNull LeafSetNode<String> mapCapabilities() {
- return Builders.<String>leafSetBuilder()
+ return ImmutableNodes.<String>newSystemLeafSetBuilder()
.withNodeIdentifier(CAPABILITY)
.withChildValue(DepthParam.capabilityUri().toString())
.withChildValue(FieldsParam.capabilityUri().toString())
import org.opendaylight.mdsal.dom.api.DOMMountPointService;
import org.opendaylight.mdsal.dom.api.DOMRpcService;
import org.opendaylight.mdsal.dom.api.DOMSchemaService;
-import org.opendaylight.mdsal.dom.api.DOMYangTextSourceProvider;
+import org.opendaylight.mdsal.dom.api.DOMSchemaService.YangTextSourceExtension;
import org.opendaylight.restconf.api.ApiPath;
import org.opendaylight.restconf.common.errors.RestconfDocumentedException;
import org.opendaylight.restconf.common.errors.RestconfFuture;
import org.opendaylight.yangtools.yang.common.YangNames;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
-import org.opendaylight.yangtools.yang.model.api.EffectiveModelContextListener;
-import org.opendaylight.yangtools.yang.model.repo.api.SchemaSourceRepresentation;
-import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
-import org.opendaylight.yangtools.yang.model.repo.api.YangTextSchemaSource;
-import org.opendaylight.yangtools.yang.model.repo.api.YinTextSchemaSource;
+import org.opendaylight.yangtools.yang.model.api.source.SourceIdentifier;
+import org.opendaylight.yangtools.yang.model.api.source.SourceRepresentation;
+import org.opendaylight.yangtools.yang.model.api.source.YangTextSource;
+import org.opendaylight.yangtools.yang.model.api.source.YinTextSource;
import org.opendaylight.yangtools.yang.model.util.SchemaInferenceStack;
import org.osgi.service.component.annotations.Activate;
import org.osgi.service.component.annotations.Component;
*/
@Singleton
@Component(service = { RestconfServer.class, DatabindProvider.class })
-public final class MdsalRestconfServer
- implements RestconfServer, DatabindProvider, EffectiveModelContextListener, AutoCloseable {
+public final class MdsalRestconfServer implements RestconfServer, DatabindProvider, AutoCloseable {
private static final Logger LOG = LoggerFactory.getLogger(MdsalRestconfServer.class);
private static final QName YANG_LIBRARY_VERSION = QName.create(Restconf.QNAME, "yang-library-version").intern();
private static final VarHandle LOCAL_STRATEGY;
private final @NonNull DOMDataBroker dataBroker;
private final @Nullable DOMRpcService rpcService;
private final @Nullable DOMActionService actionService;
- private final @Nullable DOMYangTextSourceProvider sourceProvider;
+ private final @Nullable YangTextSourceExtension sourceProvider;
private final Registration reg;
this.actionService = requireNonNull(actionService);
this.mountPointService = requireNonNull(mountPointService);
this.localRpcs = Maps.uniqueIndex(localRpcs, RpcImplementation::qname);
- sourceProvider = schemaService.getExtensions().getInstance(DOMYangTextSourceProvider.class);
+ sourceProvider = schemaService.extension(YangTextSourceExtension.class);
localStrategy = createLocalStrategy(schemaService.getGlobalContext());
- reg = schemaService.registerSchemaContextListener(this);
+ reg = schemaService.registerSchemaContextListener(this::onModelContextUpdated);
}
public MdsalRestconfServer(final DOMSchemaService schemaService, final DOMDataBroker dataBroker,
return localStrategy().databind();
}
- @Override
- public void onModelContextUpdated(final EffectiveModelContext newModelContext) {
+ private void onModelContextUpdated(final EffectiveModelContext newModelContext) {
final var local = localStrategy();
if (!newModelContext.equals(local.modelContext())) {
LOCAL_STRATEGY.setRelease(this, createLocalStrategy(newModelContext));
@Override
public RestconfFuture<ModulesGetResult> modulesYangGET(final String fileName, final String revision) {
- return modulesGET(fileName, revision, YangTextSchemaSource.class);
+ return modulesGET(fileName, revision, YangTextSource.class);
}
@Override
public RestconfFuture<ModulesGetResult> modulesYangGET(final ApiPath mountPath, final String fileName,
final String revision) {
- return modulesGET(mountPath, fileName, revision, YangTextSchemaSource.class);
+ return modulesGET(mountPath, fileName, revision, YangTextSource.class);
}
@Override
public RestconfFuture<ModulesGetResult> modulesYinGET(final String fileName, final String revision) {
- return modulesGET(fileName, revision, YinTextSchemaSource.class);
+ return modulesGET(fileName, revision, YinTextSource.class);
}
@Override
public RestconfFuture<ModulesGetResult> modulesYinGET(final ApiPath mountPath, final String fileName,
final String revision) {
- return modulesGET(mountPath, fileName, revision, YinTextSchemaSource.class);
+ return modulesGET(mountPath, fileName, revision, YinTextSource.class);
}
private @NonNull RestconfFuture<ModulesGetResult> modulesGET(final String fileName, final String revision,
- final Class<? extends SchemaSourceRepresentation> representation) {
+ final Class<? extends SourceRepresentation> representation) {
return modulesGET(localStrategy(), fileName, revision, representation);
}
private @NonNull RestconfFuture<ModulesGetResult> modulesGET(final ApiPath mountPath, final String fileName,
- final String revision, final Class<? extends SchemaSourceRepresentation> representation) {
+ final String revision, final Class<? extends SourceRepresentation> representation) {
final var mountOffset = mountPath.indexOf("yang-ext", "mount");
if (mountOffset != mountPath.steps().size() - 1) {
return RestconfFuture.failed(new RestconfDocumentedException("Mount path has to end with yang-ext:mount"));
private static @NonNull RestconfFuture<ModulesGetResult> modulesGET(final RestconfStrategy strategy,
final String moduleName, final String revisionStr,
- final Class<? extends SchemaSourceRepresentation> representation) {
+ final Class<? extends SourceRepresentation> representation) {
if (moduleName == null) {
return RestconfFuture.failed(new RestconfDocumentedException("Module name must be supplied",
ErrorType.PROTOCOL, ErrorTag.INVALID_VALUE));
return RestconfFuture.failed(new RestconfDocumentedException("RESTCONF is not available"));
}
return RestconfFuture.of(new NormalizedNodePayload(stack.toInference(),
- ImmutableNodes.leafNode(YANG_LIBRARY_VERSION, stack.getEffectiveModelContext()
+ ImmutableNodes.leafNode(YANG_LIBRARY_VERSION, stack.modelContext()
.findModuleStatements("ietf-yang-library").iterator().next().localQNameModule().getRevision()
.map(Revision::toString).orElse(""))));
}
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.mdsal.dom.api.DOMDataBroker;
-import org.opendaylight.mdsal.dom.api.DOMDataTreeChangeService;
+import org.opendaylight.mdsal.dom.api.DOMDataBroker.DataTreeChangeExtension;
import org.opendaylight.restconf.common.errors.RestconfDocumentedException;
import org.opendaylight.restconf.common.errors.RestconfFuture;
import org.opendaylight.restconf.nb.rfc8040.utils.parser.YangInstanceIdentifierSerializer;
NodeIdentifier.create(CreateDataChangeEventSubscriptionOutput.QNAME);
private final DatabindProvider databindProvider;
- private final DOMDataTreeChangeService changeService;
+ private final DataTreeChangeExtension changeService;
private final RestconfStream.Registry streamRegistry;
@Inject
@Reference final DatabindProvider databindProvider, @Reference final DOMDataBroker dataBroker) {
super(CreateDataChangeEventSubscription.QNAME);
this.databindProvider = requireNonNull(databindProvider);
- changeService = dataBroker.getExtensions().getInstance(DOMDataTreeChangeService.class);
+ changeService = dataBroker.extension(DataTreeChangeExtension.class);
if (changeService == null) {
throw new UnsupportedOperationException("DOMDataBroker does not support the DOMDataTreeChangeService");
}
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.mdsal.dom.api.ClusteredDOMDataTreeChangeListener;
-import org.opendaylight.mdsal.dom.api.DOMDataTreeChangeService;
+import org.opendaylight.mdsal.dom.api.DOMDataBroker.DataTreeChangeExtension;
import org.opendaylight.mdsal.dom.api.DOMDataTreeIdentifier;
import org.opendaylight.restconf.server.spi.DatabindProvider;
import org.opendaylight.restconf.server.spi.RestconfStream;
EncodingName.RFC8040_JSON, JSONDataTreeCandidateFormatter.FACTORY,
EncodingName.RFC8040_XML, XMLDataTreeCandidateFormatter.FACTORY);
- private final @NonNull DOMDataTreeChangeService changeService;
+ private final @NonNull DataTreeChangeExtension changeService;
private final @NonNull DatabindProvider databindProvider;
private final @NonNull LogicalDatastoreType datastore;
private final @NonNull YangInstanceIdentifier path;
- public DataTreeChangeSource(final DatabindProvider databindProvider, final DOMDataTreeChangeService changeService,
+ public DataTreeChangeSource(final DatabindProvider databindProvider, final DataTreeChangeExtension changeService,
final LogicalDatastoreType datastore, final YangInstanceIdentifier path) {
super(ENCODINGS);
this.databindProvider = requireNonNull(databindProvider);
import javax.xml.xpath.XPathExpressionException;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.restconf.server.spi.TextParameters;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.md.sal.remote.rev140114.$YangModuleInfoImpl;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.md.sal.remote.rev140114.DataChangedNotification;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.md.sal.remote.rev140114.data.changed.notification.DataChangeEvent;
+import org.opendaylight.yang.svc.v1.urn.opendaylight.params.xml.ns.yang.controller.md.sal.remote.rev140114.YangModuleInfoImpl;
import org.opendaylight.yangtools.yang.data.tree.api.DataTreeCandidate;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
final class JSONDataTreeCandidateFormatter extends DataTreeCandidateFormatter {
private static final @NonNull String DATA_CHANGED_EVENT_NAME = DataChangeEvent.QNAME.getLocalName();
private static final @NonNull String DATA_CHANGED_NOTIFICATION_NAME =
- $YangModuleInfoImpl.getInstance().getName().getLocalName() + ":" + DataChangedNotification.QNAME.getLocalName();
+ YangModuleInfoImpl.getInstance().getName().getLocalName() + ":" + DataChangedNotification.QNAME.getLocalName();
private static final JSONDataTreeCandidateFormatter EMPTY =
new JSONDataTreeCandidateFormatter(TextParameters.EMPTY);
final var modificationType = candidate.modificationType();
if (modificationType != ModificationType.UNMODIFIED) {
- final var codecs = JSONCodecFactorySupplier.RFC7951.getShared(parent.getEffectiveModelContext());
+ final var codecs = JSONCodecFactorySupplier.RFC7951.getShared(parent.modelContext());
try (var writer = createNestedWriter(codecs, DATA_CHANGE_EVENT, SAL_REMOTE_NS, jsonWriter)) {
writer.startLeafNode(PATH_NID);
writer.scalarValue(YangInstanceIdentifier.of(dataPath));
final DataTreeCandidateNode candidate, final boolean skipData) throws Exception {
final var modificationType = candidate.modificationType();
if (modificationType != ModificationType.UNMODIFIED) {
- final var stack = SchemaInferenceStack.of(parent.getEffectiveModelContext());
+ final var stack = SchemaInferenceStack.of(parent.modelContext());
stack.enterSchemaTree(DataChangedNotification.QNAME);
final var writer = XMLStreamNormalizedNodeStreamWriter.create(xmlWriter, stack.toInference());
import com.google.common.collect.ImmutableMap;
import java.time.Instant;
+import java.util.function.Supplier;
import org.opendaylight.mdsal.dom.api.DOMEvent;
import org.opendaylight.mdsal.dom.api.DOMNotification;
import org.opendaylight.mdsal.dom.api.DOMNotificationListener;
import org.opendaylight.restconf.server.spi.RestconfStream.EncodingName;
import org.opendaylight.restconf.server.spi.RestconfStream.Sink;
import org.opendaylight.restconf.server.spi.RestconfStream.Source;
-import org.opendaylight.yangtools.yang.model.api.EffectiveModelContextProvider;
+import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
/**
* Abstract base class for functionality shared between {@link DOMNotification}-based sources.
public abstract class AbstractNotificationSource extends Source<DOMNotification> {
protected static final class Listener implements DOMNotificationListener {
private final Sink<DOMNotification> sink;
- private final EffectiveModelContextProvider modelContext;
+ private final Supplier<EffectiveModelContext> modelContext;
- public Listener(final Sink<DOMNotification> sink, final EffectiveModelContextProvider modelContext) {
+ public Listener(final Sink<DOMNotification> sink, final Supplier<EffectiveModelContext> modelContext) {
this.sink = requireNonNull(sink);
this.modelContext = requireNonNull(modelContext);
}
@Override
public void onNotification(final DOMNotification notification) {
- sink.publish(modelContext.getEffectiveModelContext(), notification,
+ sink.publish(modelContext.get(), notification,
notification instanceof DOMEvent domEvent ? domEvent.getEventInstant() : Instant.now());
}
}
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.mdsal.dom.api.DOMNotification;
import org.opendaylight.restconf.server.spi.TextParameters;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.restconf.rev170126.$YangModuleInfoImpl;
+import org.opendaylight.yang.svc.v1.urn.ietf.params.xml.ns.yang.ietf.restconf.rev170126.YangModuleInfoImpl;
import org.opendaylight.yangtools.yang.data.codec.gson.JSONCodecFactorySupplier;
import org.opendaylight.yangtools.yang.data.codec.gson.JSONNormalizedNodeStreamWriter;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
final class JSONNotificationFormatter extends NotificationFormatter {
private static final @NonNull String NOTIFICATION_NAME =
- $YangModuleInfoImpl.getInstance().getName().getLocalName() + ":notification";
+ YangModuleInfoImpl.getInstance().getName().getLocalName() + ":notification";
@VisibleForTesting
static final JSONNotificationFormatter EMPTY = new JSONNotificationFormatter(TextParameters.EMPTY);
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.restconf.server.api.DatabindContext;
+import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.common.XMLNamespace;
-import org.opendaylight.yangtools.yang.data.util.AbstractModuleStringInstanceIdentifierCodec;
+import org.opendaylight.yangtools.yang.data.util.AbstractStringInstanceIdentifierCodec;
import org.opendaylight.yangtools.yang.data.util.DataSchemaContextTree;
-import org.opendaylight.yangtools.yang.model.api.Module;
+import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.stmt.ModuleEffectiveStatement;
+import org.opendaylight.yangtools.yang.model.util.LeafrefResolver;
-final class ApiPathInstanceIdentifierCodec extends AbstractModuleStringInstanceIdentifierCodec {
+final class ApiPathInstanceIdentifierCodec extends AbstractStringInstanceIdentifierCodec {
private final @NonNull DatabindContext databind;
ApiPathInstanceIdentifierCodec(final DatabindContext databind) {
}
@Override
- protected Module moduleForPrefix(final String prefix) {
- return databind.modelContext().findModules(prefix).stream().findFirst().orElse(null);
+ protected QNameModule moduleForPrefix(final String prefix) {
+ return databind.modelContext().findModuleStatements(prefix).stream().findFirst()
+ .map(ModuleEffectiveStatement::localQNameModule)
+ .orElse(null);
}
@Override
protected String prefixForNamespace(final XMLNamespace namespace) {
- return databind.modelContext().findModule(namespace).stream().findFirst().map(Module::getName).orElse(null);
+ return databind.modelContext().findModuleStatements(namespace).stream().findFirst()
+ .map(module -> module.argument().getLocalName())
+ .orElse(null);
+ }
+
+ @Override
+ protected Object deserializeKeyValue(final DataSchemaNode schemaNode, final LeafrefResolver resolver,
+ final String value) {
+ throw new UnsupportedOperationException("FIXME: implement this method");
}
}
@BeforeEach
final void setupRestconf() {
- restconf = new JaxRsRestconf(new MdsalRestconfServer(FixedDOMSchemaService.of(modelContext()), dataBroker,
+ restconf = new JaxRsRestconf(new MdsalRestconfServer(new FixedDOMSchemaService(modelContext()), dataBroker,
rpcService, actionService, mountPointService));
}
Builders.containerBuilder().withNodeIdentifier(NodeIdentifier.create(OUTPUT_QNAME)).build())))
.when(actionService).invokeAction(eq(Absolute.of(CONT_QNAME, CONT1_QNAME, RESET_QNAME)), any(), any());
- final var restconf = new JaxRsRestconf(new MdsalRestconfServer(FixedDOMSchemaService.of(IID_SCHEMA), dataBroker,
- rpcService, actionService, mountPointService));
+ final var restconf = new JaxRsRestconf(new MdsalRestconfServer(new FixedDOMSchemaService(IID_SCHEMA),
+ dataBroker, rpcService, actionService, mountPointService));
doReturn(new MultivaluedHashMap<>()).when(uriInfo).getQueryParameters();
doReturn(true).when(asyncResponse).resume(captor.capture());
restconf.postDataJSON(ApiPath.parse("instance-identifier-module:cont/cont1/reset"),
@Test
public void testDeleteDataMountPoint() {
doReturn(Optional.of(mountPoint)).when(mountPointService).getMountPoint(any(YangInstanceIdentifier.class));
- doReturn(Optional.of(FixedDOMSchemaService.of(JUKEBOX_SCHEMA))).when(mountPoint)
+ doReturn(Optional.of(new FixedDOMSchemaService(JUKEBOX_SCHEMA))).when(mountPoint)
.getService(DOMSchemaService.class);
doReturn(Optional.of(dataBroker)).when(mountPoint).getService(DOMDataBroker.class);
doReturn(Optional.of(rpcService)).when(mountPoint).getService(DOMRpcService.class);
doReturn(Optional.of(mountPoint)).when(mountPointService)
.getMountPoint(any(YangInstanceIdentifier.class));
- doReturn(Optional.of(FixedDOMSchemaService.of(JUKEBOX_SCHEMA))).when(mountPoint)
+ doReturn(Optional.of(new FixedDOMSchemaService(JUKEBOX_SCHEMA))).when(mountPoint)
.getService(DOMSchemaService.class);
doReturn(Optional.of(dataBroker)).when(mountPoint).getService(DOMDataBroker.class);
doReturn(Optional.of(rpcService)).when(mountPoint).getService(DOMRpcService.class);
doReturn(immediateTrueFluentFuture()).when(readTx).exists(LogicalDatastoreType.CONFIGURATION, JUKEBOX_IID);
doNothing().when(rwTx).put(LogicalDatastoreType.CONFIGURATION, JUKEBOX_IID, EMPTY_JUKEBOX);
doReturn(Optional.of(mountPoint)).when(mountPointService).getMountPoint(any());
- doReturn(Optional.of(FixedDOMSchemaService.of(JUKEBOX_SCHEMA))).when(mountPoint)
- .getService(DOMSchemaService.class);
+ doReturn(Optional.of(new FixedDOMSchemaService(JUKEBOX_SCHEMA))).when(mountPoint)
+ .getService(DOMSchemaService.class);
doReturn(Optional.of(dataBroker)).when(mountPoint).getService(DOMDataBroker.class);
doReturn(Optional.of(rpcService)).when(mountPoint).getService(DOMRpcService.class);
doReturn(Optional.empty()).when(mountPoint).getService(DOMActionService.class);
import org.opendaylight.mdsal.dom.api.DOMMountPointService;
import org.opendaylight.mdsal.dom.api.DOMRpcService;
import org.opendaylight.mdsal.dom.api.DOMSchemaService;
-import org.opendaylight.mdsal.dom.api.DOMYangTextSourceProvider;
+import org.opendaylight.mdsal.dom.api.DOMSchemaService.YangTextSourceExtension;
import org.opendaylight.mdsal.dom.spi.FixedDOMSchemaService;
import org.opendaylight.netconf.dom.api.NetconfDataTreeService;
import org.opendaylight.restconf.api.ApiPath;
QName.create("mount:point", "2016-06-02", "point-number"));
@Mock
- private DOMYangTextSourceProvider sourceProvider;
+ private YangTextSourceExtension sourceProvider;
@Mock
private DOMSchemaService schemaService;
}
private void mockMountPoint() {
- doReturn(Optional.of(FixedDOMSchemaService.of(MODEL_CONTEXT_ON_MOUNT_POINT))).when(mountPoint)
+ doReturn(Optional.of(new FixedDOMSchemaService(MODEL_CONTEXT_ON_MOUNT_POINT))).when(mountPoint)
.getService(DOMSchemaService.class);
doReturn(Optional.of(mountPoint)).when(mountPointService).getMountPoint(MOUNT_IID);
doReturn(Optional.of(mountPointService)).when(mountPoint).getService(DOMMountPointService.class);
</operations>""";
private static final EffectiveModelContext MODEL_CONTEXT = BindingRuntimeHelpers.createRuntimeContext(
- Module1Data.class, Module2Data.class, NetworkTopology.class).getEffectiveModelContext();
+ Module1Data.class, Module2Data.class, NetworkTopology.class).modelContext();
@Override
EffectiveModelContext modelContext() {
}
private void mockMountPoint() {
- doReturn(Optional.of(FixedDOMSchemaService.of(MODEL_CONTEXT))).when(mountPoint)
+ doReturn(Optional.of(new FixedDOMSchemaService(MODEL_CONTEXT))).when(mountPoint)
.getService(DOMSchemaService.class);
doReturn(Optional.empty()).when(mountPoint).getService(DOMRpcService.class);
doReturn(Optional.empty()).when(mountPoint).getService(DOMActionService.class);
@Test
void invokeRpcViaMountPointTest() throws Exception {
- doReturn(Optional.of(FixedDOMSchemaService.of(MODEL_CONTEXT))).when(mountPoint)
+ doReturn(Optional.of(new FixedDOMSchemaService(MODEL_CONTEXT))).when(mountPoint)
.getService(DOMSchemaService.class);
doReturn(Optional.of(rpcService)).when(mountPoint).getService(DOMRpcService.class);
doReturn(Optional.empty()).when(mountPoint).getService(DOMActionService.class);
@Test
void invokeRpcMissingMountPointServiceTest() {
- doReturn(Optional.of(FixedDOMSchemaService.of(MODEL_CONTEXT))).when(mountPoint)
+ doReturn(Optional.of(new FixedDOMSchemaService(MODEL_CONTEXT))).when(mountPoint)
.getService(DOMSchemaService.class);
doReturn(Optional.empty()).when(mountPoint).getService(DOMRpcService.class);
doReturn(Optional.empty()).when(mountPoint).getService(DOMActionService.class);
package org.opendaylight.restconf.nb.jaxrs;
import static org.junit.Assert.assertEquals;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.doCallRealMethod;
import static org.mockito.Mockito.doReturn;
import static org.opendaylight.restconf.nb.jaxrs.AbstractRestconfTest.assertEntity;
import static org.opendaylight.restconf.nb.jaxrs.AbstractRestconfTest.assertError;
-import com.google.common.collect.ImmutableClassToInstanceMap;
import com.google.common.io.CharStreams;
import java.io.Reader;
+import java.util.List;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.opendaylight.mdsal.dom.api.DOMDataBroker;
import org.opendaylight.mdsal.dom.api.DOMRpcService;
import org.opendaylight.mdsal.dom.api.DOMSchemaService;
-import org.opendaylight.mdsal.dom.api.DOMYangTextSourceProvider;
+import org.opendaylight.mdsal.dom.api.DOMSchemaService.YangTextSourceExtension;
import org.opendaylight.mdsal.dom.broker.DOMMountPointServiceImpl;
import org.opendaylight.mdsal.dom.spi.FixedDOMSchemaService;
import org.opendaylight.restconf.api.ApiPath;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
-import org.opendaylight.yangtools.yang.model.repo.api.YangTextSchemaSource;
+import org.opendaylight.yangtools.yang.model.api.source.YangTextSource;
import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
/**
@Mock
private DOMSchemaService schemaService;
@Mock
- private DOMYangTextSourceProvider sourceProvider;
+ private YangTextSourceExtension sourceProvider;
@Mock
private DOMDataBroker dataBroker;
@Mock
@Mock
private DOMRpcService rpcService;
@Mock
- private YangTextSchemaSource yangSource;
+ private YangTextSource yangSource;
@Mock
private Reader yangReader;
// create and register mount points
mountPointService
.createMountPoint(YangInstanceIdentifier.of(QName.create("mount:point:1", "2016-01-01", "cont")))
- .addService(DOMSchemaService.class, FixedDOMSchemaService.of(SCHEMA_CONTEXT_BEHIND_MOUNT_POINT))
+ .addService(DOMSchemaService.class, new FixedDOMSchemaService(SCHEMA_CONTEXT_BEHIND_MOUNT_POINT))
.addService(DOMDataBroker.class, dataBroker)
.register();
mountPointService
.createMountPoint(YangInstanceIdentifier.of(QName.create("mount:point:2", "2016-01-01", "cont")))
.register();
- doReturn(ImmutableClassToInstanceMap.of(DOMYangTextSourceProvider.class, sourceProvider)).when(schemaService)
- .getExtensions();
+ doCallRealMethod().when(schemaService).extension(any());
+ doReturn(List.of(sourceProvider)).when(schemaService).supportedExtensions();
doReturn(SCHEMA_CONTEXT_WITH_MOUNT_POINTS).when(schemaService).getGlobalContext();
restconf = new JaxRsRestconf(new MdsalRestconfServer(schemaService, dataBroker, rpcService, actionService,
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertSame;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.doCallRealMethod;
import static org.mockito.Mockito.doReturn;
import static org.opendaylight.restconf.nb.jaxrs.AbstractRestconfTest.assertEntity;
import static org.opendaylight.restconf.nb.jaxrs.AbstractRestconfTest.assertError;
-import com.google.common.collect.ImmutableClassToInstanceMap;
import com.google.common.util.concurrent.Futures;
import java.io.Reader;
+import java.util.List;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.opendaylight.mdsal.dom.api.DOMMountPointService;
import org.opendaylight.mdsal.dom.api.DOMRpcService;
import org.opendaylight.mdsal.dom.api.DOMSchemaService;
-import org.opendaylight.mdsal.dom.api.DOMYangTextSourceProvider;
+import org.opendaylight.mdsal.dom.api.DOMSchemaService.YangTextSourceExtension;
import org.opendaylight.restconf.server.mdsal.MdsalRestconfServer;
import org.opendaylight.yangtools.yang.common.ErrorTag;
import org.opendaylight.yangtools.yang.common.ErrorType;
import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
-import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
-import org.opendaylight.yangtools.yang.model.repo.api.YangTextSchemaSource;
+import org.opendaylight.yangtools.yang.model.api.source.SourceIdentifier;
+import org.opendaylight.yangtools.yang.model.api.source.YangTextSource;
import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
/**
@Mock
private DOMSchemaService schemaService;
@Mock
- private DOMYangTextSourceProvider sourceProvider;
+ private YangTextSourceExtension sourceProvider;
@Mock
private DOMDataBroker dataBroker;
@Mock
@Mock
private DOMMountPointService mountPointService;
@Mock
- private YangTextSchemaSource yangSource;
+ private YangTextSource yangSource;
@Mock
private Reader yangReader;
@Before
public void setup() throws Exception {
doReturn(SCHEMA_CONTEXT).when(schemaService).getGlobalContext();
- doReturn(ImmutableClassToInstanceMap.of(DOMYangTextSourceProvider.class, sourceProvider)).when(schemaService)
- .getExtensions();
+ doCallRealMethod().when(schemaService).extension(any());
+ doReturn(List.of(sourceProvider)).when(schemaService).supportedExtensions();
restconf = new JaxRsRestconf(new MdsalRestconfServer(schemaService, dataBroker, rpcService, actionService,
mountPointService));
@Test
public void getSchemaTest() throws Exception {
doReturn(Futures.immediateFuture(yangSource)).when(sourceProvider)
- .getSource(new SourceIdentifier("module1", Revision.of("2014-01-01")));
+ .getYangTexttSource(new SourceIdentifier("module1", Revision.of("2014-01-01")));
doReturn(yangReader).when(yangSource).openStream();
assertSame(yangReader, assertEntity(Reader.class, 200,
@Before
public final void before() {
doReturn(Optional.of(mountPoint)).when(mountPointService).getMountPoint(any(YangInstanceIdentifier.class));
- doReturn(Optional.of(FixedDOMSchemaService.of(IID_SCHEMA))).when(mountPoint).getService(DOMSchemaService.class);
+ doReturn(Optional.of(new FixedDOMSchemaService(IID_SCHEMA))).when(mountPoint)
+ .getService(DOMSchemaService.class);
doReturn(Optional.of(dataBroker)).when(mountPoint).getService(DOMDataBroker.class);
doReturn(Optional.empty()).when(mountPoint).getService(DOMActionService.class);
doReturn(Optional.empty()).when(mountPoint).getService(DOMRpcService.class);
private void mockMount() {
doReturn(Optional.of(mountPoint)).when(mountPointService).getMountPoint(any(YangInstanceIdentifier.class));
- doReturn(Optional.of(FixedDOMSchemaService.of(IID_SCHEMA))).when(mountPoint)
+ doReturn(Optional.of(new FixedDOMSchemaService(IID_SCHEMA))).when(mountPoint)
.getService(DOMSchemaService.class);
doReturn(Optional.of(dataBroker)).when(mountPoint).getService(DOMDataBroker.class);
doReturn(Optional.empty()).when(mountPoint).getService(DOMActionService.class);
doReturn(Optional.empty()).when(mountPoint).getService(NetconfDataTreeService.class);
doReturn(Optional.of(dataBroker)).when(mountPoint).getService(DOMDataBroker.class);
doReturn(Optional.of(rpcService)).when(mountPoint).getService(DOMRpcService.class);
- doReturn(Optional.of(FixedDOMSchemaService.of(JUKEBOX_SCHEMA))).when(mountPoint)
+ doReturn(Optional.of(new FixedDOMSchemaService(JUKEBOX_SCHEMA))).when(mountPoint)
.getService(DOMSchemaService.class);
doReturn(Optional.empty()).when(mountPoint).getService(DOMMountPointService.class);
doReturn(Optional.empty()).when(mountPoint).getService(DOMActionService.class);
public void testGetRestconfStrategyMountNetconfService() throws Exception {
doReturn(Optional.of(netconfService)).when(mountPoint).getService(NetconfDataTreeService.class);
doReturn(Optional.of(rpcService)).when(mountPoint).getService(DOMRpcService.class);
- doReturn(Optional.of(FixedDOMSchemaService.of(JUKEBOX_SCHEMA))).when(mountPoint)
+ doReturn(Optional.of(new FixedDOMSchemaService(JUKEBOX_SCHEMA))).when(mountPoint)
.getService(DOMSchemaService.class);
doReturn(Optional.empty()).when(mountPoint).getService(DOMMountPointService.class);
doReturn(Optional.empty()).when(mountPoint).getService(DOMActionService.class);
doReturn(Optional.empty()).when(mountPoint).getService(DOMMountPointService.class);
doReturn(Optional.empty()).when(mountPoint).getService(DOMActionService.class);
doReturn(Optional.of(rpcService)).when(mountPoint).getService(DOMRpcService.class);
- doReturn(Optional.of(FixedDOMSchemaService.of(JUKEBOX_SCHEMA))).when(mountPoint)
+ doReturn(Optional.of(new FixedDOMSchemaService(JUKEBOX_SCHEMA))).when(mountPoint)
.getService(DOMSchemaService.class);
doReturn(Optional.of(mountPoint)).when(mountPointService).getMountPoint(YangInstanceIdentifier.of());
import org.opendaylight.yangtools.yang.common.ErrorTag;
import org.opendaylight.yangtools.yang.common.ErrorType;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
-import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.w3c.dom.DOMException;
@RunWith(MockitoJUnitRunner.StrictStubs.class)
@Test
public void testPutReplaceContainerData() {
- doReturn(immediateFluentFuture(Optional.of(mock(NormalizedNode.class)))).when(netconfService)
+ doReturn(immediateFluentFuture(Optional.of(mock(ContainerNode.class)))).when(netconfService)
.getConfig(JUKEBOX_IID);
doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(netconfService).commit();
doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(netconfService)
@Test
public void testPutReplaceLeafData() {
- doReturn(immediateFluentFuture(Optional.of(mock(NormalizedNode.class)))).when(netconfService)
+ doReturn(immediateFluentFuture(Optional.of(mock(ContainerNode.class)))).when(netconfService)
.getConfig(GAP_IID);
doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(netconfService).commit();
doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(netconfService)
@Test
public void testPutReplaceListData() {
- doReturn(immediateFluentFuture(Optional.of(mock(NormalizedNode.class)))).when(netconfService)
+ doReturn(immediateFluentFuture(Optional.of(mock(ContainerNode.class)))).when(netconfService)
.getConfig(JUKEBOX_IID);
doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(netconfService).commit();
doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(netconfService)
import org.opendaylight.mdsal.binding.dom.adapter.test.AbstractConcurrentDataBrokerTest;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.mdsal.dom.api.DOMDataBroker;
-import org.opendaylight.mdsal.dom.api.DOMDataTreeChangeService;
+import org.opendaylight.mdsal.dom.api.DOMDataBroker.DataTreeChangeExtension;
import org.opendaylight.restconf.api.query.ChangedLeafNodesOnlyParam;
import org.opendaylight.restconf.api.query.ChildNodesOnlyParam;
import org.opendaylight.restconf.api.query.LeafNodesOnlyParam;
final boolean changedLeafNodesOnly, final boolean childNodesOnly) throws Exception {
final var stream = streamRegistry.createStream(URI.create("baseURI"),
new DataTreeChangeSource(databindProvider,
- domDataBroker.getExtensions().getInstance(DOMDataTreeChangeService.class),
+ domDataBroker.extension(DataTreeChangeExtension.class),
LogicalDatastoreType.CONFIGURATION, path), "test")
.getOrThrow();
final var handler = new TestHandler();
import org.opendaylight.mdsal.common.api.CommitInfo;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.mdsal.dom.api.DOMDataBroker;
-import org.opendaylight.mdsal.dom.api.DOMDataTreeChangeService;
+import org.opendaylight.mdsal.dom.api.DOMDataBroker.DataTreeChangeExtension;
import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteTransaction;
import org.opendaylight.mdsal.dom.api.DOMMountPointService;
import org.opendaylight.mdsal.dom.api.DOMNotificationService;
@Mock
private DOMDataTreeWriteTransaction tx;
@Mock
- private DOMDataTreeChangeService changeService;
+ private DataTreeChangeExtension changeService;
@Mock
private DatabindProvider databindProvider;
@Mock
import org.opendaylight.mdsal.dom.broker.DOMMountPointServiceImpl;
import org.opendaylight.mdsal.dom.broker.DOMNotificationRouter;
import org.opendaylight.mdsal.dom.broker.DOMRpcRouter;
-import org.opendaylight.mdsal.dom.spi.DOMNotificationSubscriptionListenerRegistry;
-import org.opendaylight.yangtools.yang.model.api.EffectiveModelContextProvider;
/**
* Copy paste from org.opendaylight.controller.sal.restconf.impl.test.incubate.InMemoryMdsalModule.
};
dataBrokerTest.setup();
- domNotificationRouter = DOMNotificationRouter.create(NOTIFICATION_SERVICE_QUEUE_DEPTH);
+ domNotificationRouter = new DOMNotificationRouter(NOTIFICATION_SERVICE_QUEUE_DEPTH);
}
@Override
return dataBrokerTest.getDataBrokerTestCustomizer().getSchemaService();
}
- @Provides
- @Singleton EffectiveModelContextProvider getSchemaContextProvider() {
- DOMSchemaService schemaService = dataBrokerTest.getDataBrokerTestCustomizer().getSchemaService();
- if (schemaService instanceof EffectiveModelContextProvider) {
- return (EffectiveModelContextProvider) schemaService;
- }
- throw new IllegalStateException(
- "The schema service isn't a SchemaContextProvider, it's a " + schemaService.getClass());
- }
-
@Provides
@Singleton DOMMountPointService getDOMMountPoint() {
return new DOMMountPointServiceImpl();
@Provides
@Singleton DOMNotificationService getDOMNotificationService() {
- return domNotificationRouter;
+ return domNotificationRouter.notificationService();
}
@Provides
@Singleton DOMNotificationPublishService getDOMNotificationPublishService() {
- return domNotificationRouter;
- }
-
- @Provides
- @Singleton DOMNotificationSubscriptionListenerRegistry getDOMNotificationSubscriptionListenerRegistry() {
- return domNotificationRouter;
+ return domNotificationRouter.notificationPublishService();
}
@Provides
@Singleton DOMRpcService getDOMRpcService(final DOMSchemaService schemaService) {
- return new DOMRpcRouter(schemaService).getRpcService();
+ return new DOMRpcRouter(schemaService).rpcService();
}
@Provides
@Singleton
DOMActionService getDOMActionService(final DOMSchemaService schemaService) {
- return new DOMRpcRouter(schemaService).getActionService();
+ return new DOMRpcRouter(schemaService).actionService();
}
@PreDestroy
import static org.junit.jupiter.api.Assertions.assertInstanceOf;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.doCallRealMethod;
import static org.mockito.Mockito.doNothing;
import static org.mockito.Mockito.doReturn;
-import com.google.common.collect.ImmutableClassToInstanceMap;
import java.net.URI;
+import java.util.List;
import java.util.UUID;
import org.eclipse.jdt.annotation.Nullable;
import org.junit.jupiter.api.BeforeEach;
import org.opendaylight.mdsal.common.api.CommitInfo;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.mdsal.dom.api.DOMDataBroker;
-import org.opendaylight.mdsal.dom.api.DOMDataTreeChangeService;
+import org.opendaylight.mdsal.dom.api.DOMDataBroker.DataTreeChangeExtension;
import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteTransaction;
import org.opendaylight.restconf.common.errors.RestconfDocumentedException;
import org.opendaylight.restconf.server.api.DatabindContext;
@Mock
private DOMDataBroker dataBroker;
@Mock
- private DOMDataTreeChangeService treeChange;
+ private DataTreeChangeExtension treeChange;
@Mock
private DOMDataTreeWriteTransaction tx;
@Captor
public void before() {
databindProvider = () -> DatabindContext.ofModel(SCHEMA_CTX);
- doReturn(ImmutableClassToInstanceMap.of(DOMDataTreeChangeService.class, treeChange))
- .when(dataBroker).getExtensions();
+ doReturn(List.of(treeChange)).when(dataBroker).supportedExtensions();
+ doCallRealMethod().when(dataBroker).extension(any());
rpc = new CreateDataChangeEventSubscriptionRpc(new MdsalRestconfStreamRegistry(dataBroker), databindProvider,
dataBroker);
}
import java.util.Deque;
import java.util.List;
import java.util.stream.Collectors;
-import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.restconf.openapi.jaxrs.OpenApiBodyWriter;
import org.opendaylight.restconf.openapi.model.DeleteEntity;
import org.opendaylight.restconf.openapi.model.GetEntity;
}
@Override
- public int read(final byte @NonNull [] array, final int off, final int len) throws IOException {
+ public int read(final byte[] array, final int off, final int len) throws IOException {
return super.read(array, off, len);
}
} else if (leafTypeDef instanceof EnumTypeDefinition enumType) {
jsonType = processEnumType(enumType, def);
} else if (leafTypeDef instanceof IdentityrefTypeDefinition identityrefType) {
- jsonType = processIdentityRefType(identityrefType, stack.getEffectiveModelContext(), def);
+ jsonType = processIdentityRefType(identityrefType, stack.modelContext(), def);
} else if (leafTypeDef instanceof StringTypeDefinition stringType) {
jsonType = processStringType(stringType, schemaNode.getQName().getLocalName(), def);
} else if (leafTypeDef instanceof UnionTypeDefinition unionType) {
jsonType = processNumberType(rangeRestrictedType, def);
} else if (leafTypeDef instanceof InstanceIdentifierTypeDefinition instanceIdentifierType) {
jsonType = processInstanceIdentifierType(instanceIdentifierType, schemaNode,
- stack.getEffectiveModelContext(), def);
+ stack.modelContext(), def);
} else {
jsonType = STRING_TYPE;
}
import org.opendaylight.mdsal.dom.api.DOMSchemaService;
import org.opendaylight.restconf.openapi.impl.BaseYangOpenApiGenerator;
import org.opendaylight.restconf.openapi.impl.OpenApiInputStream;
-import org.opendaylight.yangtools.concepts.ListenerRegistration;
+import org.opendaylight.yangtools.concepts.Registration;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
private final AtomicLong idKey = new AtomicLong(0);
- private ListenerRegistration<DOMMountPointListener> registration;
+ private Registration registration;
public MountPointOpenApi(final DOMSchemaService globalSchema, final DOMMountPointService mountService,
final BaseYangOpenApiGenerator openApiGenerator) {
.values().getElement().toString();
}
- private OpenApiInputStream generateDataStoreOpenApi(EffectiveModelContext modelContext,
+ private OpenApiInputStream generateDataStoreOpenApi(final EffectiveModelContext modelContext,
final UriInfo uriInfo, final String urlPrefix, final String deviceName) throws IOException {
final var schema = openApiGenerator.createSchemaFromUriInfo(uriInfo);
final var host = openApiGenerator.createHostFromUriInfo(uriInfo);
<artifactId>commons-codec</artifactId>
<version>1.15</version>
</dependency>
+ <dependency>
+ <groupId>com.github.spotbugs</groupId>
+ <artifactId>spotbugs-annotations</artifactId>
+ <optional>true</optional>
+ </dependency>
<dependency>
<groupId>com.google.errorprone</groupId>
<artifactId>error_prone_annotations</artifactId>
Code Review / netconf.git / commitdiff