This patch mass-migrates netconf components to use MD-SAL APIs.
Change-Id: I2ddd0004ef0e72a7fa1fc7a9d7df26515326ca4c
Signed-off-by: Robert Varga <robert.varga@pantheon.tech>
Signed-off-by: Jakub Morvay <jmorvay@frinx.io>
<properties>
<commons.opendaylight.version>1.12.0-SNAPSHOT</commons.opendaylight.version>
- <controller.mdsal.version>1.9.0-SNAPSHOT</controller.mdsal.version>
<mdsal.version>3.0.2</mdsal.version>
<netconf.version>1.6.0-SNAPSHOT</netconf.version>
<netconf.connector.version>1.9.0-SNAPSHOT</netconf.connector.version>
<classifier>features</classifier>
<type>xml</type>
</dependency>
- <dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>features-mdsal</artifactId>
- <version>${controller.mdsal.version}</version>
- <classifier>features</classifier>
- <type>xml</type>
- <scope>runtime</scope>
- </dependency>
<dependency>
<groupId>${project.groupId}</groupId>
<artifactId>features-netconf</artifactId>
<properties>
<netconf.version>1.6.0-SNAPSHOT</netconf.version>
- <controller.mdsal.version>${project.version}</controller.mdsal.version>
</properties>
<dependencyManagement>
<type>xml</type>
<classifier>features</classifier>
</dependency>
- <dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>odl-mdsal-broker</artifactId>
- <version>${controller.mdsal.version}</version>
- <type>xml</type>
- <classifier>features</classifier>
- </dependency>
<dependency>
<groupId>${project.groupId}</groupId>
<artifactId>mdsal-netconf-ssh</artifactId>
<dependencies>
<dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>sal-binding-api</artifactId>
+ <groupId>org.opendaylight.mdsal</groupId>
+ <artifactId>mdsal-binding-api</artifactId>
</dependency>
<dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>sal-binding-broker-impl</artifactId>
+ <groupId>org.opendaylight.mdsal</groupId>
+ <artifactId>mdsal-binding-dom-adapter</artifactId>
<type>test-jar</type>
<scope>test</scope>
</dependency>
* 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.callhome.mount;
import io.netty.util.concurrent.EventExecutor;
import org.opendaylight.aaa.encrypt.AAAEncryptionService;
import org.opendaylight.controller.config.threadpool.ScheduledThreadPool;
import org.opendaylight.controller.config.threadpool.ThreadPool;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.dom.api.DOMMountPointService;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.dom.api.DOMMountPointService;
import org.opendaylight.netconf.client.NetconfClientDispatcher;
import org.opendaylight.netconf.sal.connect.api.DeviceActionFactory;
import org.opendaylight.netconf.topology.AbstractNetconfTopology;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import javax.annotation.Nonnull;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeChangeListener;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+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;
import org.opendaylight.netconf.callhome.protocol.AuthorizedKeysDecoder;
import org.opendaylight.netconf.callhome.protocol.CallHomeAuthorization;
import org.opendaylight.netconf.callhome.protocol.CallHomeAuthorization.Builder;
private static final InstanceIdentifier<Global> GLOBAL_PATH =
InstanceIdentifier.create(NetconfCallhomeServer.class).child(Global.class);
private static final DataTreeIdentifier<Global> GLOBAL =
- new DataTreeIdentifier<>(LogicalDatastoreType.CONFIGURATION, GLOBAL_PATH);
+ DataTreeIdentifier.create(LogicalDatastoreType.CONFIGURATION, GLOBAL_PATH);
private static final InstanceIdentifier<Device> ALLOWED_DEVICES_PATH =
InstanceIdentifier.create(NetconfCallhomeServer.class).child(AllowedDevices.class).child(Device.class);
private static final DataTreeIdentifier<Device> ALLOWED_DEVICES =
- new DataTreeIdentifier<>(LogicalDatastoreType.CONFIGURATION, ALLOWED_DEVICES_PATH);
+ DataTreeIdentifier.create(LogicalDatastoreType.CONFIGURATION, ALLOWED_DEVICES_PATH);
private static final DataTreeIdentifier<Device> ALLOWED_OP_DEVICES =
- new DataTreeIdentifier<>(LogicalDatastoreType.OPERATIONAL, ALLOWED_DEVICES_PATH);
+ DataTreeIdentifier.create(LogicalDatastoreType.OPERATIONAL, ALLOWED_DEVICES_PATH);
private final GlobalConfig globalConfig = new GlobalConfig();
private final DeviceConfig deviceConfig = new DeviceConfig();
* 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.callhome.mount;
import io.netty.util.concurrent.EventExecutor;
import org.opendaylight.aaa.encrypt.AAAEncryptionService;
import org.opendaylight.controller.config.threadpool.ScheduledThreadPool;
import org.opendaylight.controller.config.threadpool.ThreadPool;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.dom.api.DOMMountPointService;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.dom.api.DOMMountPointService;
import org.opendaylight.netconf.callhome.mount.CallHomeMountSessionContext.CloseCallback;
import org.opendaylight.netconf.callhome.protocol.CallHomeChannelActivator;
import org.opendaylight.netconf.callhome.protocol.CallHomeNetconfSubsystemListener;
protected CallHomeTopology topology;
- private final CloseCallback onCloseHandler = new CloseCallback() {
- @Override
- public void onClosed(final CallHomeMountSessionContext deviceContext) {
- LOG.info("Removing {} from Netconf Topology.", deviceContext.getId());
- topology.disconnectNode(deviceContext.getId());
- }
+ private final CloseCallback onCloseHandler = deviceContext -> {
+ LOG.info("Removing {} from Netconf Topology.", deviceContext.getId());
+ topology.disconnectNode(deviceContext.getId());
};
- private DeviceActionFactory deviceActionFactory;
+ private final DeviceActionFactory deviceActionFactory;
public CallHomeMountDispatcher(final String topologyId, final EventExecutor eventExecutor,
final ScheduledThreadPool keepaliveExecutor, final ThreadPool processingExecutor,
final ScheduledThreadPool keepaliveExecutor, final ThreadPool processingExecutor,
final SchemaRepositoryProvider schemaRepositoryProvider, final DataBroker dataBroker,
final DOMMountPointService mountService,
- final AAAEncryptionService encryptionService, DeviceActionFactory deviceActionFactory) {
+ final AAAEncryptionService encryptionService, final DeviceActionFactory deviceActionFactory) {
this.topologyId = topologyId;
this.eventExecutor = eventExecutor;
this.keepaliveExecutor = keepaliveExecutor;
* 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.callhome.mount;
import io.netty.util.concurrent.EventExecutor;
import org.opendaylight.aaa.encrypt.AAAEncryptionService;
import org.opendaylight.controller.config.threadpool.ScheduledThreadPool;
import org.opendaylight.controller.config.threadpool.ThreadPool;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.dom.api.DOMMountPointService;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.dom.api.DOMMountPointService;
import org.opendaylight.netconf.client.NetconfClientDispatcher;
import org.opendaylight.netconf.sal.connect.api.DeviceActionFactory;
import org.opendaylight.netconf.sal.connect.api.RemoteDeviceHandler;
* 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.callhome.mount;
-import com.google.common.base.Optional;
+import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.MoreExecutors;
import java.io.IOException;
import java.security.GeneralSecurityException;
import java.security.PublicKey;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
+import java.util.Optional;
import java.util.concurrent.ExecutionException;
-import javax.annotation.Nonnull;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeChangeListener;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
-import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
-import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+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.ReadTransaction;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
+import org.opendaylight.mdsal.common.api.CommitInfo;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netconf.callhome.protocol.AuthorizedKeysDecoder;
import org.opendaylight.netconf.callhome.protocol.StatusRecorder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.callhome.device.status.rev170112.Device1;
CallhomeStatusReporter(final DataBroker broker) {
this.dataBroker = broker;
- this.reg = dataBroker.registerDataTreeChangeListener(new DataTreeIdentifier<>(LogicalDatastoreType.OPERATIONAL,
+ this.reg = dataBroker.registerDataTreeChangeListener(DataTreeIdentifier.create(LogicalDatastoreType.OPERATIONAL,
NETCONF_TOPO_IID.child(Node.class)), this);
}
@Override
- public void onDataTreeChanged(@Nonnull final Collection<DataTreeModification<Node>> changes) {
+ public void onDataTreeChanged(final Collection<DataTreeModification<Node>> changes) {
for (DataTreeModification<Node> change: changes) {
final DataObjectModification<Node> rootNode = change.getRootNode();
final InstanceIdentifier<Node> identifier = change.getRootPath().getRootIdentifier();
}
private Device readAndGetDevice(final NodeId nodeId) {
- return readDevice(nodeId).orNull();
+ return readDevice(nodeId).orElse(null);
}
- @Nonnull
private Optional<Device> readDevice(final NodeId nodeId) {
- ReadOnlyTransaction opTx = dataBroker.newReadOnlyTransaction();
+ ReadTransaction opTx = dataBroker.newReadOnlyTransaction();
InstanceIdentifier<Device> deviceIID = buildDeviceInstanceIdentifier(nodeId);
ListenableFuture<Optional<Device>> devFuture = opTx.read(LogicalDatastoreType.OPERATIONAL, deviceIID);
try {
return devFuture.get();
} catch (InterruptedException | ExecutionException e) {
- return Optional.absent();
+ return Optional.empty();
}
}
private void writeDevice(final NodeId nodeId, final Device modifiedDevice) {
- ReadWriteTransaction opTx = dataBroker.newReadWriteTransaction();
+ WriteTransaction opTx = dataBroker.newWriteOnlyTransaction();
opTx.merge(LogicalDatastoreType.OPERATIONAL, buildDeviceInstanceIdentifier(nodeId), modifiedDevice);
- opTx.commit();
+ commit(opTx, modifiedDevice.key());
}
private static InstanceIdentifier<Device> buildDeviceInstanceIdentifier(final NodeId nodeId) {
private void setDeviceStatus(final Device device) {
WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
- InstanceIdentifier<Device> deviceIId =
- InstanceIdentifier.create(NetconfCallhomeServer.class)
+ InstanceIdentifier<Device> deviceIId = InstanceIdentifier.create(NetconfCallhomeServer.class)
.child(AllowedDevices.class)
.child(Device.class, device.key());
tx.merge(LogicalDatastoreType.OPERATIONAL, deviceIId, device);
- tx.commit();
+ commit(tx, device.key());
+ }
+
+ private static void commit(WriteTransaction tx, DeviceKey device) {
+ tx.commit().addCallback(new FutureCallback<CommitInfo>() {
+ @Override
+ public void onSuccess(CommitInfo result) {
+ LOG.debug("Device {} committed", device);
+ }
+
+ @Override
+ public void onFailure(Throwable cause) {
+ LOG.warn("Failed to commit device {}", device, cause);
+ }
+ }, MoreExecutors.directExecutor());
}
private AllowedDevices getDevices() {
- ReadOnlyTransaction rxTransaction = dataBroker.newReadOnlyTransaction();
+ ReadTransaction rxTransaction = dataBroker.newReadOnlyTransaction();
ListenableFuture<Optional<AllowedDevices>> devicesFuture =
rxTransaction.read(LogicalDatastoreType.OPERATIONAL, IetfZeroTouchCallHomeServerProvider.ALL_DEVICES);
try {
- return devicesFuture.get().orNull();
+ return devicesFuture.get().orElse(null);
} catch (ExecutionException | InterruptedException e) {
LOG.error("Error trying to read the whitelist devices: {}", e);
return null;
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.netconf.callhome.mount;
import com.google.common.annotations.VisibleForTesting;
-import com.google.common.base.Optional;
+import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.MoreExecutors;
import io.netty.channel.nio.NioEventLoopGroup;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
+import java.util.Optional;
import java.util.Set;
import java.util.concurrent.ExecutionException;
-import javax.annotation.Nonnull;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeChangeListener;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
-import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
-import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+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.ReadTransaction;
+import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
+import org.opendaylight.mdsal.common.api.CommitInfo;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netconf.callhome.protocol.CallHomeAuthorizationProvider;
import org.opendaylight.netconf.callhome.protocol.NetconfCallHomeServer;
import org.opendaylight.netconf.callhome.protocol.NetconfCallHomeServerBuilder;
LOG.info("Initializing provider for {}", APPNAME);
initializeServer();
listenerReg = dataBroker.registerDataTreeChangeListener(
- new DataTreeIdentifier<>(LogicalDatastoreType.CONFIGURATION, ALL_DEVICES), this);
+ DataTreeIdentifier.create(LogicalDatastoreType.CONFIGURATION, ALL_DEVICES), this);
LOG.info("Initialization complete for {}", APPNAME);
} catch (IOException | Configuration.ConfigurationException e) {
LOG.error("Unable to successfully initialize", e);
}
@Override
- public void onDataTreeChanged(
@Nonnull final Collection<DataTreeModification<AllowedDevices>> changes) {
+ public void onDataTreeChanged(final Collection<DataTreeModification<AllowedDevices>> changes) {
// In case of any changes to the devices datatree, register the changed values with callhome server
// As of now, no way to add a new callhome client key to the CallHomeAuthorization instance since
// its created under CallHomeAuthorizationProvider.
// Will have to redesign a bit here.
// CallHomeAuthorization.
- ReadOnlyTransaction roConfigTx = dataBroker.newReadOnlyTransaction();
+ ReadTransaction roConfigTx = dataBroker.newReadOnlyTransaction();
ListenableFuture<Optional<AllowedDevices>> devicesFuture = roConfigTx
.read(LogicalDatastoreType.CONFIGURATION, IetfZeroTouchCallHomeServerProvider.ALL_DEVICES);
return;
}
- ReadWriteTransaction opTx = dataBroker.newReadWriteTransaction();
+ WriteTransaction opTx = dataBroker.newWriteOnlyTransaction();
for (InstanceIdentifier<?> removedIID : deletedDevices) {
LOG.info("Deleting the entry for callhome device {}", removedIID);
opTx.delete(LogicalDatastoreType.OPERATIONAL, removedIID);
}
- opTx.commit();
+ opTx.commit().addCallback(new FutureCallback<CommitInfo>() {
+ @Override
+ public void onSuccess(CommitInfo result) {
+ LOG.debug("Device deletions committed");
+ }
+
+ @Override
+ public void onFailure(Throwable cause) {
+ LOG.warn("Failed to commit device deletions", cause);
+ }
+ }, MoreExecutors.directExecutor());
}
private static List<Device> getReadDevices(final ListenableFuture<Optional<AllowedDevices>> devicesFuture)
throws InterruptedException, ExecutionException {
- Optional<AllowedDevices> opt = devicesFuture.get();
- return opt.isPresent() ? opt.get().getDevice() : Collections.emptyList();
+ return devicesFuture.get().map(AllowedDevices::getDevice).orElse(Collections.emptyList());
}
private void readAndUpdateStatus(Device cfgDevice) throws InterruptedException, ExecutionException {
ReadWriteTransaction tx = dataBroker.newReadWriteTransaction();
ListenableFuture<Optional<Device>> deviceFuture = tx.read(LogicalDatastoreType.OPERATIONAL, deviceIID);
+ final Device1 devStatus;
Optional<Device> opDevGet = deviceFuture.get();
- Device1 devStatus = new Device1Builder().setDeviceStatus(Device1.DeviceStatus.DISCONNECTED).build();
if (opDevGet.isPresent()) {
- Device opDevice = opDevGet.get();
- devStatus = opDevice.augmentation(Device1.class);
+ devStatus = opDevGet.get().augmentation(Device1.class);
+ } else {
+ devStatus = new Device1Builder().setDeviceStatus(Device1.DeviceStatus.DISCONNECTED).build();
}
- cfgDevice = new DeviceBuilder().addAugmentation(Device1.class, devStatus)
- .setSshHostKey(cfgDevice.getSshHostKey()).setUniqueId(cfgDevice.getUniqueId()).build();
+ tx.merge(LogicalDatastoreType.OPERATIONAL, deviceIID, new DeviceBuilder()
+ .addAugmentation(Device1.class, devStatus).setSshHostKey(cfgDevice.getSshHostKey())
+ .setUniqueId(cfgDevice.getUniqueId()).build());
+ tx.commit().addCallback(new FutureCallback<CommitInfo>() {
+ @Override
+ public void onSuccess(CommitInfo result) {
+ LOG.debug("Device {} status update committed", cfgDevice.key());
+ }
- tx.merge(LogicalDatastoreType.OPERATIONAL, deviceIID, cfgDevice);
- tx.commit();
+ @Override
+ public void onFailure(Throwable cause) {
+ LOG.warn("Failed to commit device {} status update", cfgDevice.key(), cause);
+ }
+ }, MoreExecutors.directExecutor());
}
}
interface="io.netty.util.concurrent.EventExecutor"
odl:type="global-event-executor"/>
<reference id="dataBroker"
- interface="org.opendaylight.controller.md.sal.binding.api.DataBroker"/>
+ interface="org.opendaylight.mdsal.binding.api.DataBroker"/>
<reference id="domMountPointService"
- interface="org.opendaylight.controller.md.sal.dom.api.DOMMountPointService"/>
+ interface="org.opendaylight.mdsal.dom.api.DOMMountPointService"/>
<reference id="encryptionService"
interface="org.opendaylight.aaa.encrypt.AAAEncryptionService" />
import org.opendaylight.aaa.encrypt.AAAEncryptionService;
import org.opendaylight.controller.config.threadpool.ScheduledThreadPool;
import org.opendaylight.controller.config.threadpool.ThreadPool;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.dom.api.DOMMountPointService;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.dom.api.DOMMountPointService;
import org.opendaylight.netconf.api.messages.NetconfHelloMessageAdditionalHeader;
import org.opendaylight.netconf.callhome.protocol.CallHomeChannelActivator;
import org.opendaylight.netconf.callhome.protocol.CallHomeProtocolSessionContext;
* 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.mdsal.connector;
import com.google.common.annotations.Beta;
import com.google.common.util.concurrent.CheckedFuture;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataBroker;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataBrokerExtension;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataWriteTransaction;
-import org.opendaylight.controller.md.sal.dom.api.DOMServiceExtension;
+import org.opendaylight.mdsal.dom.api.DOMDataBroker;
+import org.opendaylight.mdsal.dom.api.DOMDataBrokerExtension;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteTransaction;
+import org.opendaylight.mdsal.dom.api.DOMServiceExtension;
import org.opendaylight.yangtools.yang.common.OperationFailedException;
import org.opendaylight.yangtools.yang.common.RpcError;
import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
@Beta
public interface DOMDataTransactionValidator extends DOMDataBrokerExtension {
/**
- * Validates state of the data tree associated with the provided {@link DOMDataWriteTransaction}.
+ * Validates state of the data tree associated with the provided {@link DOMDataTreeWriteTransaction}.
*
* <p>The operation should not have any side-effects on the transaction state.
*
* operation is complete. A successful validate returns nothing. On failure, the Future will fail
* with a {@link ValidationFailedException} or an exception derived from ValidationFailedException.
*/
- CheckedFuture<Void, ValidationFailedException> validate(DOMDataWriteTransaction transaction);
+ CheckedFuture<Void, ValidationFailedException> validate(DOMDataTreeWriteTransaction transaction);
/**
* Failed validation of asynchronous transaction. This exception is raised and returned when transaction validation
* 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.mdsal.connector;
import java.util.Set;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataBroker;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcService;
+import org.opendaylight.mdsal.dom.api.DOMDataBroker;
+import org.opendaylight.mdsal.dom.api.DOMRpcService;
import org.opendaylight.netconf.mapping.api.NetconfOperation;
import org.opendaylight.netconf.mapping.api.NetconfOperationService;
import java.util.Optional;
import java.util.Set;
import java.util.concurrent.ExecutionException;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataBroker;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcService;
+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.netconf.api.capability.BasicCapability;
@Override
public AutoCloseable registerCapabilityListener(final CapabilityListener listener) {
// Advertise validate capability only if DOMDataBroker provides DOMDataTransactionValidator
- if (dataBroker.getSupportedExtensions().get(DOMDataTransactionValidator.class) != null) {
+ if (dataBroker.getExtensions().get(DOMDataTransactionValidator.class) != null) {
listener.onCapabilitiesChanged(Collections.singleton(VALIDATE_CAPABILITY), Collections.emptySet());
}
// Advertise namespaces of supported YANG models as NETCONF capabilities
* 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.mdsal.connector;
import com.google.common.collect.ImmutableSet;
import java.util.Set;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataBroker;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcService;
+import org.opendaylight.mdsal.dom.api.DOMDataBroker;
+import org.opendaylight.mdsal.dom.api.DOMRpcService;
import org.opendaylight.netconf.mapping.api.NetconfOperation;
import org.opendaylight.netconf.mdsal.connector.ops.Commit;
import org.opendaylight.netconf.mdsal.connector.ops.CopyConfig;
* 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.mdsal.connector;
-import static org.opendaylight.netconf.mdsal.connector.DOMDataTransactionValidator.ValidationFailedException;
-
import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
-import com.google.common.util.concurrent.CheckedFuture;
+import com.google.common.util.concurrent.FluentFuture;
import java.util.ArrayList;
import java.util.List;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataBroker;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataReadWriteTransaction;
+import java.util.concurrent.ExecutionException;
+import org.opendaylight.mdsal.common.api.CommitInfo;
+import org.opendaylight.mdsal.dom.api.DOMDataBroker;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeReadWriteTransaction;
import org.opendaylight.netconf.api.DocumentedException;
import org.opendaylight.netconf.api.DocumentedException.ErrorSeverity;
import org.opendaylight.netconf.api.DocumentedException.ErrorTag;
import org.opendaylight.netconf.api.DocumentedException.ErrorType;
+import org.opendaylight.netconf.mdsal.connector.DOMDataTransactionValidator.ValidationFailedException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class TransactionProvider implements AutoCloseable {
-
private static final Logger LOG = LoggerFactory.getLogger(TransactionProvider.class);
private final DOMDataBroker dataBroker;
- private DOMDataReadWriteTransaction candidateTransaction = null;
- private DOMDataReadWriteTransaction runningTransaction = null;
- private final List<DOMDataReadWriteTransaction> allOpenReadWriteTransactions = new ArrayList<>();
+ private DOMDataTreeReadWriteTransaction candidateTransaction = null;
+ private DOMDataTreeReadWriteTransaction runningTransaction = null;
+ private final List<DOMDataTreeReadWriteTransaction> allOpenReadWriteTransactions = new ArrayList<>();
private final DOMDataTransactionValidator transactionValidator;
private final String netconfSessionIdForReporting;
public TransactionProvider(final DOMDataBroker dataBroker, final String netconfSessionIdForReporting) {
this.dataBroker = dataBroker;
this.netconfSessionIdForReporting = netconfSessionIdForReporting;
- this.transactionValidator = (DOMDataTransactionValidator)dataBroker.getSupportedExtensions()
- .get(DOMDataTransactionValidator.class);
+ this.transactionValidator = dataBroker.getExtensions().getInstance(DOMDataTransactionValidator.class);
}
@Override
public synchronized void close() {
- for (final DOMDataReadWriteTransaction rwt : allOpenReadWriteTransactions) {
+ for (final DOMDataTreeReadWriteTransaction rwt : allOpenReadWriteTransactions) {
rwt.cancel();
}
allOpenReadWriteTransactions.clear();
}
- public synchronized Optional<DOMDataReadWriteTransaction> getCandidateTransaction() {
+ public synchronized Optional<DOMDataTreeReadWriteTransaction> getCandidateTransaction() {
if (candidateTransaction == null) {
return Optional.absent();
}
return Optional.of(candidateTransaction);
}
- public synchronized DOMDataReadWriteTransaction getOrCreateTransaction() {
+ public synchronized DOMDataTreeReadWriteTransaction getOrCreateTransaction() {
if (getCandidateTransaction().isPresent()) {
return getCandidateTransaction().get();
}
} catch (final ValidationFailedException e) {
LOG.debug("Candidate transaction validation {} failed on session {}", candidateTransaction,
netconfSessionIdForReporting, e);
- final String cause = e.getCause() != null ? (" Cause: " + e.getCause().getMessage()) : "";
- throw new DocumentedException(
- "Candidate transaction validate failed [sessionId=" + netconfSessionIdForReporting + "]: "
- + e.getMessage() + cause,
- e, ErrorType.APPLICATION, ErrorTag.OPERATION_FAILED, ErrorSeverity.ERROR);
+ final String cause = e.getCause() != null ? " Cause: " + e.getCause().getMessage() : "";
+ throw new DocumentedException("Candidate transaction validate failed [sessionId="
+ + netconfSessionIdForReporting + "]: " + e.getMessage() + cause, e, ErrorType.APPLICATION,
+ ErrorTag.OPERATION_FAILED, ErrorSeverity.ERROR);
}
}
return true;
}
- final CheckedFuture<Void, TransactionCommitFailedException> future = candidateTransaction.submit();
+ final FluentFuture<? extends CommitInfo> future = candidateTransaction.commit();
try {
- future.checkedGet();
- } catch (final TransactionCommitFailedException e) {
+ future.get();
+ } catch (final InterruptedException | ExecutionException e) {
LOG.debug("Transaction {} failed on", candidateTransaction, e);
final String cause = e.getCause() != null ? " Cause: " + e.getCause().getMessage() : "";
- throw new DocumentedException(
- "Transaction commit failed on " + e.getMessage() + " " + netconfSessionIdForReporting + cause, e,
- ErrorType.APPLICATION, ErrorTag.OPERATION_FAILED, ErrorSeverity.ERROR);
+ throw new DocumentedException("Transaction commit failed on " + e.getMessage() + " "
+ + netconfSessionIdForReporting + cause, e, ErrorType.APPLICATION, ErrorTag.OPERATION_FAILED,
+ ErrorSeverity.ERROR);
} finally {
allOpenReadWriteTransactions.remove(candidateTransaction);
candidateTransaction = null;
public synchronized void abortTransaction() {
LOG.debug("Aborting current candidateTransaction");
- final Optional<DOMDataReadWriteTransaction> otx = getCandidateTransaction();
+ final Optional<DOMDataTreeReadWriteTransaction> otx = getCandidateTransaction();
if (!otx.isPresent()) {
LOG.warn("discard-changes triggerd on an empty transaction for session: {}", netconfSessionIdForReporting);
return;
candidateTransaction = null;
}
- public synchronized DOMDataReadWriteTransaction createRunningTransaction() {
+ public synchronized DOMDataTreeReadWriteTransaction createRunningTransaction() {
runningTransaction = dataBroker.newReadWriteTransaction();
allOpenReadWriteTransactions.add(runningTransaction);
return runningTransaction;
}
- public synchronized void abortRunningTransaction(final DOMDataReadWriteTransaction tx) {
+ public synchronized void abortRunningTransaction(final DOMDataTreeReadWriteTransaction tx) {
LOG.debug("Aborting current running Transaction");
Preconditions.checkState(runningTransaction != null,
NO_TRANSACTION_FOUND_FOR_SESSION + netconfSessionIdForReporting);
tx.cancel();
allOpenReadWriteTransactions.remove(tx);
}
-
}
* 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.mdsal.connector.ops;
import static org.opendaylight.netconf.api.xml.XmlNetconfConstants.URN_IETF_PARAMS_XML_NS_NETCONF_BASE_1_0;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.List;
+import java.util.concurrent.ExecutionException;
import javax.xml.stream.XMLOutputFactory;
import javax.xml.stream.XMLStreamException;
import javax.xml.stream.XMLStreamWriter;
import javax.xml.transform.dom.DOMResult;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataReadWriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeReadWriteTransaction;
import org.opendaylight.netconf.api.DocumentedException;
import org.opendaylight.netconf.api.DocumentedException.ErrorSeverity;
import org.opendaylight.netconf.api.DocumentedException.ErrorTag;
// <copy-config>, unlike <edit-config>, always replaces entire configuration,
// so remove old configuration first:
- final DOMDataReadWriteTransaction rwTx = transactionProvider.getOrCreateTransaction();
+ final DOMDataTreeReadWriteTransaction rwTx = transactionProvider.getOrCreateTransaction();
rwTx.put(LogicalDatastoreType.CONFIGURATION, YangInstanceIdentifier.EMPTY, EMPTY_ROOT_NODE);
// Then create nodes present in the <config> element:
private ContainerNode readData(final XmlElement source) throws DocumentedException {
final Datastore sourceDatastore = getDatastore(source);
- final DOMDataReadWriteTransaction rwTx = getTransaction(sourceDatastore);
+ final DOMDataTreeReadWriteTransaction rwTx = getTransaction(sourceDatastore);
final YangInstanceIdentifier dataRoot = YangInstanceIdentifier.EMPTY;
try {
- final Optional<NormalizedNode<?, ?>> normalizedNodeOptional = rwTx.read(
- LogicalDatastoreType.CONFIGURATION, dataRoot).checkedGet();
+ final java.util.Optional<NormalizedNode<?, ?>> normalizedNodeOptional = rwTx.read(
+ LogicalDatastoreType.CONFIGURATION, dataRoot).get();
if (sourceDatastore == Datastore.running) {
transactionProvider.abortRunningTransaction(rwTx);
}
return (ContainerNode) normalizedNodeOptional.get();
- } catch (ReadFailedException e) {
+ } catch (InterruptedException | ExecutionException e) {
throw new IllegalStateException("Unable to read data " + dataRoot, e);
}
}
}
}
- private DOMDataReadWriteTransaction getTransaction(final Datastore datastore) throws DocumentedException {
+ private DOMDataTreeReadWriteTransaction getTransaction(final Datastore datastore) throws DocumentedException {
if (datastore == Datastore.candidate) {
return transactionProvider.getOrCreateTransaction();
} else if (datastore == Datastore.running) {
* 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.mdsal.connector.ops;
import com.google.common.base.Optional;
import java.util.ListIterator;
import java.util.concurrent.ExecutionException;
import java.util.stream.Collectors;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataReadWriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeReadWriteTransaction;
import org.opendaylight.netconf.api.DocumentedException;
import org.opendaylight.netconf.api.DocumentedException.ErrorSeverity;
import org.opendaylight.netconf.api.DocumentedException.ErrorTag;
}
private void executeOperations(final DataTreeChangeTracker changeTracker) throws DocumentedException {
- final DOMDataReadWriteTransaction rwTx = transactionProvider.getOrCreateTransaction();
+ final DOMDataTreeReadWriteTransaction rwTx = transactionProvider.getOrCreateTransaction();
final List<DataTreeChange> aa = changeTracker.getDataTreeChanges();
final ListIterator<DataTreeChange> iterator = aa.listIterator(aa.size());
}
}
- private void executeChange(final DOMDataReadWriteTransaction rwtx, final DataTreeChange change)
+ private void executeChange(final DOMDataTreeReadWriteTransaction rwtx, final DataTreeChange change)
throws DocumentedException {
final YangInstanceIdentifier path = YangInstanceIdentifier.create(change.getPath());
final NormalizedNode<?, ?> changeData = change.getChangeRoot();
break;
case CREATE:
try {
- final Optional<NormalizedNode<?, ?>> readResult =
- rwtx.read(LogicalDatastoreType.CONFIGURATION, path).get();
- if (readResult.isPresent()) {
+ if (rwtx.read(LogicalDatastoreType.CONFIGURATION, path).get().isPresent()) {
throw new DocumentedException("Data already exists, cannot execute CREATE operation",
ErrorType.PROTOCOL, ErrorTag.DATA_EXISTS, ErrorSeverity.ERROR);
}
break;
case DELETE:
try {
- final Optional<NormalizedNode<?, ?>> readResult =
- rwtx.read(LogicalDatastoreType.CONFIGURATION, path).get();
- if (!readResult.isPresent()) {
+ if (!rwtx.read(LogicalDatastoreType.CONFIGURATION, path).get().isPresent()) {
throw new DocumentedException("Data is missing, cannot execute DELETE operation",
ErrorType.PROTOCOL, ErrorTag.DATA_MISSING, ErrorSeverity.ERROR);
}
}
}
- private void mergeParentMixin(final DOMDataReadWriteTransaction rwtx, final YangInstanceIdentifier path,
+ private void mergeParentMixin(final DOMDataTreeReadWriteTransaction rwtx, final YangInstanceIdentifier path,
final NormalizedNode<?, ?> change) {
final YangInstanceIdentifier parentNodeYid = path.getParent();
if (change instanceof MapEntryNode) {
protected String getOperationName() {
return OPERATION_NAME;
}
-
}
* 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.mdsal.connector.ops;
import com.google.common.base.Optional;
-import com.google.common.util.concurrent.CheckedFuture;
import java.io.IOException;
import java.net.URI;
import java.util.Collection;
import java.util.Collections;
import java.util.Map;
+import java.util.concurrent.ExecutionException;
import javax.annotation.Nullable;
import javax.xml.stream.XMLOutputFactory;
import javax.xml.stream.XMLStreamException;
import javax.xml.stream.XMLStreamWriter;
import javax.xml.transform.dom.DOMResult;
import javax.xml.transform.dom.DOMSource;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcException;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcResult;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcService;
+import org.opendaylight.mdsal.dom.api.DOMRpcResult;
+import org.opendaylight.mdsal.dom.api.DOMRpcService;
import org.opendaylight.netconf.api.DocumentedException;
import org.opendaylight.netconf.api.DocumentedException.ErrorSeverity;
import org.opendaylight.netconf.api.DocumentedException.ErrorTag;
final SchemaPath schemaPath = SchemaPath.create(Collections.singletonList(rpcDefinition.getQName()), true);
final NormalizedNode<?, ?> inputNode = rpcToNNode(operationElement, rpcDefinition.getInput());
- final CheckedFuture<DOMRpcResult, DOMRpcException> rpcFuture = rpcService.invokeRpc(schemaPath, inputNode);
+ final DOMRpcResult result;
try {
- final DOMRpcResult result = rpcFuture.checkedGet();
- if (result.getResult() == null) {
- return XmlUtil.createElement(document, XmlNetconfConstants.OK,
- Optional.of(XmlNetconfConstants.URN_IETF_PARAMS_XML_NS_NETCONF_BASE_1_0));
- }
- return (Element) transformNormalizedNode(document, result.getResult(), rpcDefinition.getOutput().getPath());
- } catch (final DOMRpcException e) {
+ result = rpcService.invokeRpc(schemaPath, inputNode).get();
+ } catch (final InterruptedException | ExecutionException e) {
throw DocumentedException.wrap(e);
}
+ if (result.getResult() == null) {
+ return XmlUtil.createElement(document, XmlNetconfConstants.OK,
+ Optional.of(XmlNetconfConstants.URN_IETF_PARAMS_XML_NS_NETCONF_BASE_1_0));
+ }
+ return (Element) transformNormalizedNode(document, result.getResult(), rpcDefinition.getOutput().getPath());
}
@Override
* 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.mdsal.connector.ops.get;
import com.google.common.base.Optional;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataReadWriteTransaction;
+import java.util.concurrent.ExecutionException;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeReadWriteTransaction;
import org.opendaylight.netconf.api.DocumentedException;
import org.opendaylight.netconf.api.DocumentedException.ErrorSeverity;
import org.opendaylight.netconf.api.DocumentedException.ErrorTag;
final YangInstanceIdentifier dataRoot = dataRootOptional.get();
- final DOMDataReadWriteTransaction rwTx = getTransaction(Datastore.running);
+ final DOMDataTreeReadWriteTransaction rwTx = getTransaction(Datastore.running);
try {
- final Optional<NormalizedNode<?, ?>> normalizedNodeOptional = rwTx.read(
- LogicalDatastoreType.OPERATIONAL, dataRoot).checkedGet();
+ final java.util.Optional<NormalizedNode<?, ?>> normalizedNodeOptional = rwTx.read(
+ LogicalDatastoreType.OPERATIONAL, dataRoot).get();
transactionProvider.abortRunningTransaction(rwTx);
if (!normalizedNodeOptional.isPresent()) {
}
return serializeNodeWithParentStructure(document, dataRoot, normalizedNodeOptional.get());
- } catch (final ReadFailedException e) {
+ } catch (final InterruptedException | ExecutionException e) {
LOG.warn("Unable to read data: {}", dataRoot, e);
throw new IllegalStateException("Unable to read data " + dataRoot, e);
}
}
- private DOMDataReadWriteTransaction getTransaction(final Datastore datastore) throws DocumentedException {
+ private DOMDataTreeReadWriteTransaction getTransaction(final Datastore datastore) throws DocumentedException {
if (datastore == Datastore.candidate) {
return transactionProvider.getOrCreateTransaction();
} else if (datastore == Datastore.running) {
* 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.mdsal.connector.ops.get;
import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataReadWriteTransaction;
+import java.util.concurrent.ExecutionException;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeReadWriteTransaction;
import org.opendaylight.netconf.api.DocumentedException;
import org.opendaylight.netconf.api.DocumentedException.ErrorSeverity;
import org.opendaylight.netconf.api.DocumentedException.ErrorTag;
// Proper exception should be thrown
Preconditions.checkState(getConfigExecution.getDatastore().isPresent(), "Source element missing from request");
- final DOMDataReadWriteTransaction rwTx = getTransaction(getConfigExecution.getDatastore().get());
+ final DOMDataTreeReadWriteTransaction rwTx = getTransaction(getConfigExecution.getDatastore().get());
try {
- final Optional<NormalizedNode<?, ?>> normalizedNodeOptional = rwTx.read(
- LogicalDatastoreType.CONFIGURATION, dataRoot).checkedGet();
+ final java.util.Optional<NormalizedNode<?, ?>> normalizedNodeOptional = rwTx.read(
+ LogicalDatastoreType.CONFIGURATION, dataRoot).get();
if (getConfigExecution.getDatastore().get() == Datastore.running) {
transactionProvider.abortRunningTransaction(rwTx);
}
}
return serializeNodeWithParentStructure(document, dataRoot, normalizedNodeOptional.get());
- } catch (final ReadFailedException e) {
+ } catch (final InterruptedException | ExecutionException e) {
LOG.warn("Unable to read data: {}", dataRoot, e);
throw new IllegalStateException("Unable to read data " + dataRoot, e);
}
}
- private DOMDataReadWriteTransaction getTransaction(final Datastore datastore) throws DocumentedException {
+ private DOMDataTreeReadWriteTransaction getTransaction(final Datastore datastore) throws DocumentedException {
if (datastore == Datastore.candidate) {
return transactionProvider.getOrCreateTransaction();
} else if (datastore == Datastore.running) {
xmlns:odl="http://opendaylight.org/xmlns/blueprint/v1.0.0"
odl:use-default-for-reference-types="true">
- <reference id="domDataBroker" interface="org.opendaylight.controller.md.sal.dom.api.DOMDataBroker"/>
- <reference id="domRpcService" interface="org.opendaylight.controller.md.sal.dom.api.DOMRpcService"/>
+ <reference id="domDataBroker" interface="org.opendaylight.mdsal.dom.api.DOMDataBroker"/>
+ <reference id="domRpcService" interface="org.opendaylight.mdsal.dom.api.DOMRpcService"/>
<reference id="schemaService"
interface="org.opendaylight.mdsal.dom.api.DOMSchemaService"/>
<reference id="netconfOperationServiceFactoryListener"
* 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.mdsal.connector.ops;
import static org.junit.Assert.assertEquals;
import org.custommonkey.xmlunit.XMLUnit;
import org.junit.Before;
import org.mockito.MockitoAnnotations;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.dom.broker.impl.SerializedDOMDataBroker;
-import org.opendaylight.controller.md.sal.dom.store.impl.InMemoryDOMDataStoreFactory;
-import org.opendaylight.controller.sal.core.spi.data.DOMStore;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.mdsal.dom.api.DOMSchemaService;
+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.netconf.api.xml.XmlUtil;
import org.opendaylight.netconf.mapping.api.NetconfOperation;
import org.opendaylight.netconf.mapping.api.NetconfOperationChainedExecution;
* 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.mdsal.connector.ops;
import static org.junit.Assert.assertTrue;
import static org.mockito.Mockito.doNothing;
import static org.mockito.Mockito.doReturn;
import static org.mockito.MockitoAnnotations.initMocks;
+import static org.opendaylight.yangtools.util.concurrent.FluentFutures.immediateFailedFluentFuture;
+import static org.opendaylight.yangtools.util.concurrent.FluentFutures.immediateFluentFuture;
import com.google.common.base.Preconditions;
import com.google.common.io.ByteSource;
-import com.google.common.util.concurrent.CheckedFuture;
-import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.FluentFuture;
import java.net.URI;
import java.util.Collection;
import java.util.Collections;
-import javax.annotation.Nonnull;
-import javax.annotation.Nullable;
import org.custommonkey.xmlunit.DetailedDiff;
import org.custommonkey.xmlunit.Diff;
import org.custommonkey.xmlunit.XMLUnit;
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mock;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcAvailabilityListener;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcException;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcResult;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcService;
-import org.opendaylight.controller.md.sal.dom.spi.DefaultDOMRpcResult;
+import org.opendaylight.mdsal.dom.api.DOMRpcAvailabilityListener;
+import org.opendaylight.mdsal.dom.api.DOMRpcException;
+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.spi.DefaultDOMRpcResult;
import org.opendaylight.netconf.api.DocumentedException;
import org.opendaylight.netconf.api.DocumentedException.ErrorSeverity;
import org.opendaylight.netconf.api.DocumentedException.ErrorTag;
import org.opendaylight.netconf.mdsal.connector.CurrentSchemaContext;
import org.opendaylight.netconf.util.test.XmlFileLoader;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
+import org.opendaylight.yangtools.concepts.NoOpListenerRegistration;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
}
private static final DOMRpcService RPC_SERVICE_VOID_INVOKER = new DOMRpcService() {
- @Nonnull
@Override
- public CheckedFuture<DOMRpcResult, DOMRpcException> invokeRpc(
- @Nonnull final SchemaPath type, @Nullable final NormalizedNode<?, ?> input) {
- return Futures.immediateCheckedFuture(new DefaultDOMRpcResult(null, Collections.emptyList()));
+ public FluentFuture<DOMRpcResult> invokeRpc(final SchemaPath type, final NormalizedNode<?, ?> input) {
+ return immediateFluentFuture(new DefaultDOMRpcResult(null, Collections.emptyList()));
}
- @Nonnull
@Override
- public <T extends DOMRpcAvailabilityListener> ListenerRegistration<T> registerRpcListener(
- @Nonnull final T listener) {
- return null;
+ public <T extends DOMRpcAvailabilityListener> ListenerRegistration<T> registerRpcListener(final T listener) {
+ return NoOpListenerRegistration.of(listener);
}
};
private static final DOMRpcService RPC_SERVICE_FAILED_INVOCATION = new DOMRpcService() {
- @Nonnull
@Override
- public CheckedFuture<DOMRpcResult, DOMRpcException> invokeRpc(
- @Nonnull final SchemaPath type, @Nullable final NormalizedNode<?, ?> input) {
- return Futures.immediateFailedCheckedFuture(new DOMRpcException("rpc invocation not implemented yet") {
+ public FluentFuture<DOMRpcResult> invokeRpc(final SchemaPath type, final NormalizedNode<?, ?> input) {
+ return immediateFailedFluentFuture(new DOMRpcException("rpc invocation not implemented yet") {
private static final long serialVersionUID = 1L;
});
}
- @Nonnull
@Override
- public <T extends DOMRpcAvailabilityListener> ListenerRegistration<T> registerRpcListener(
- @Nonnull final T listener) {
- return null;
+ public <T extends DOMRpcAvailabilityListener> ListenerRegistration<T> registerRpcListener(final T listener) {
+ return NoOpListenerRegistration.of(listener);
}
};
private final DOMRpcService rpcServiceSuccessfulInvocation = new DOMRpcService() {
- @Nonnull
@Override
- public CheckedFuture<DOMRpcResult, DOMRpcException> invokeRpc(
- @Nonnull final SchemaPath type, @Nullable final NormalizedNode<?, ?> input) {
+ public FluentFuture<DOMRpcResult> invokeRpc(final SchemaPath type, final NormalizedNode<?, ?> input) {
final Collection<DataContainerChild<? extends PathArgument, ?>> children =
(Collection<DataContainerChild<? extends PathArgument, ?>>) input.getValue();
final Module module = schemaContext.findModules(type.getLastComponent().getNamespace()).stream()
.withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(outputSchemaNode.getQName()))
.withValue(children).build();
- return Futures.immediateCheckedFuture(new DefaultDOMRpcResult(node));
+ return immediateFluentFuture(new DefaultDOMRpcResult(node));
}
- @Nonnull
@Override
- public <T extends DOMRpcAvailabilityListener> ListenerRegistration<T> registerRpcListener(
- @Nonnull final T lsnr) {
- return null;
+ public <T extends DOMRpcAvailabilityListener> ListenerRegistration<T> registerRpcListener(final T lsnr) {
+ return NoOpListenerRegistration.of(lsnr);
}
};
final SourceIdentifier sId = (SourceIdentifier) invocationOnMock.getArguments()[0];
final YangTextSchemaSource yangTextSchemaSource =
YangTextSchemaSource.delegateForByteSource(sId, ByteSource.wrap("module test".getBytes()));
- return Futures.immediateCheckedFuture(yangTextSchemaSource);
-
+ return immediateFluentFuture(yangTextSchemaSource);
}).when(sourceProvider).getSource(any(SourceIdentifier.class));
this.schemaContext = YangParserTestUtils.parseYangResource("/yang/mdsal-netconf-rpc-test.yang");
* 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.mdsal.connector.ops;
import static org.junit.Assert.assertEquals;
import static org.opendaylight.netconf.mdsal.connector.ops.AbstractNetconfOperationTest.executeOperation;
import static org.opendaylight.netconf.mdsal.connector.ops.AbstractNetconfOperationTest.verifyResponse;
+import com.google.common.collect.ImmutableClassToInstanceMap;
import com.google.common.util.concurrent.Futures;
-import java.util.Collections;
import org.custommonkey.xmlunit.XMLUnit;
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mock;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataBroker;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataReadWriteTransaction;
+import org.opendaylight.mdsal.dom.api.DOMDataBroker;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeReadWriteTransaction;
import org.opendaylight.netconf.api.DocumentedException;
import org.opendaylight.netconf.mdsal.connector.DOMDataTransactionValidator;
import org.opendaylight.netconf.mdsal.connector.DOMDataTransactionValidator.ValidationFailedException;
@Mock
private DOMDataTransactionValidator failingValidator;
@Mock
- private DOMDataReadWriteTransaction readWriteTx;
+ private DOMDataTreeReadWriteTransaction readWriteTx;
@Mock
private DOMDataBroker dataBroker;
}
private void whenValidatorIsNotDefined() {
- doReturn(Collections.emptyMap()).when(dataBroker).getSupportedExtensions();
+ doReturn(ImmutableClassToInstanceMap.of()).when(dataBroker).getExtensions();
}
private void whenUsingValidator(final DOMDataTransactionValidator validator) {
- doReturn(Collections.singletonMap(DOMDataTransactionValidator.class, validator))
- .when(dataBroker).getSupportedExtensions();
+ doReturn(ImmutableClassToInstanceMap.of(DOMDataTransactionValidator.class, validator))
+ .when(dataBroker).getExtensions();
}
private TransactionProvider initCandidateTransaction() {
return transactionProvider;
}
- private Document validate(final String resource,
- final TransactionProvider transactionProvider) throws Exception {
+ private Document validate(final String resource, final TransactionProvider transactionProvider) throws Exception {
final Validate validate = new Validate(SESSION_ID_FOR_REPORTING, transactionProvider);
return executeOperation(validate, resource);
}
<artifactId>netconf-util</artifactId>
</dependency>
<dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>sal-binding-api</artifactId>
+ <groupId>org.opendaylight.mdsal</groupId>
+ <artifactId>mdsal-binding-api</artifactId>
</dependency>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>sal-common-util</artifactId>
- </dependency>
+ </dependency>
<dependency>
<groupId>com.google.guava</groupId>
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.controller.config.yang.netconf.mdsal.monitoring;
import com.google.common.base.Preconditions;
import com.google.common.util.concurrent.MoreExecutors;
import java.util.Collection;
import java.util.function.Consumer;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
import org.opendaylight.mdsal.common.api.CommitInfo;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netconf.api.monitoring.NetconfMonitoringService;
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.Capabilities;
odl:use-default-for-reference-types="true">
<reference id="dataBroker"
- interface="org.opendaylight.controller.md.sal.binding.api.DataBroker"
+ interface="org.opendaylight.mdsal.binding.api.DataBroker"
odl:type="default"/>
<reference id="netconfMonitoringService"
interface="org.opendaylight.netconf.api.monitoring.NetconfMonitoringService"
import org.mockito.InOrder;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netconf.api.monitoring.NetconfMonitoringService;
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.Capabilities;
<artifactId>netconf-notifications-api</artifactId>
</dependency>
<dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>sal-binding-api</artifactId>
+ <groupId>org.opendaylight.mdsal</groupId>
+ <artifactId>mdsal-binding-api</artifactId>
</dependency>
<dependency>
<groupId>org.opendaylight.controller</groupId>
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.controller.config.yang.netconf.mdsal.notification;
import com.google.common.collect.ImmutableList;
import java.util.Collections;
import java.util.Set;
import javax.annotation.Nonnull;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
+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.notifications.BaseNotificationPublisherRegistration;
import org.opendaylight.netconf.notifications.NetconfNotificationCollector;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Uri;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-
/**
* Listens on capabilities changes in data store and publishes them to base
* netconf notification stream listener.
}
@Override
- public void onDataTreeChanged(@Nonnull Collection<DataTreeModification<Capabilities>> changes) {
+ public void onDataTreeChanged(@Nonnull final Collection<DataTreeModification<Capabilities>> changes) {
for (DataTreeModification<Capabilities> change : changes) {
final DataObjectModification<Capabilities> rootNode = change.getRootNode();
final DataObjectModification.ModificationType modificationType = rootNode.getModificationType();
}
- private void publishNotification(Set<Uri> added, Set<Uri> removed) {
+ private void publishNotification(final Set<Uri> added, final Set<Uri> removed) {
final NetconfCapabilityChangeBuilder netconfCapabilityChangeBuilder = new NetconfCapabilityChangeBuilder();
netconfCapabilityChangeBuilder.setChangedBy(new ChangedByBuilder().setServerOrUser(new ServerBuilder()
.setServer(true).build()).build());
/**
* Invoked by blueprint.
*/
+ @Override
public void close() {
if (baseNotificationPublisherRegistration != null) {
baseNotificationPublisherRegistration.close();
* 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.controller.config.yang.netconf.mdsal.notification;
import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.MoreExecutors;
import java.util.concurrent.ExecutionException;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
import org.opendaylight.mdsal.common.api.CommitInfo;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netconf.notifications.NetconfNotificationCollector;
import org.opendaylight.netconf.notifications.NotificationRegistration;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.netconf.notification._1._0.rev080714.StreamNameType;
*/
package org.opendaylight.controller.config.yang.netconf.mdsal.notification;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeChangeListener;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataTreeChangeListener;
+import org.opendaylight.mdsal.binding.api.DataTreeIdentifier;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
*
* @param instanceIdentifier instance identifier of subtree, on which this instance should listen on changes.
*/
- OperationalDatastoreListener(InstanceIdentifier<T> instanceIdentifier) {
+ OperationalDatastoreListener(final InstanceIdentifier<T> instanceIdentifier) {
this.instanceIdentifier = instanceIdentifier;
}
* @param dataBroker data broker
* @return listener registration
*/
- ListenerRegistration<OperationalDatastoreListener<T>> registerOnChanges(DataBroker dataBroker) {
- DataTreeIdentifier<T> id = new DataTreeIdentifier<>(LogicalDatastoreType.OPERATIONAL, instanceIdentifier);
+ ListenerRegistration<OperationalDatastoreListener<T>> registerOnChanges(final DataBroker dataBroker) {
+ DataTreeIdentifier<T> id = DataTreeIdentifier.create(LogicalDatastoreType.OPERATIONAL, instanceIdentifier);
return dataBroker.registerDataTreeChangeListener(id, this);
}
import com.google.common.base.Preconditions;
import java.util.Collection;
import javax.annotation.Nonnull;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
+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.notifications.BaseNotificationPublisherRegistration;
import org.opendaylight.netconf.notifications.NetconfNotificationCollector;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.netconf.base._1._0.rev110601.SessionIdOrZeroType;
@SuppressWarnings("checkstyle:MissingSwitchDefault")
@Override
- public void onDataTreeChanged(@Nonnull Collection<DataTreeModification<Session>> changes) {
+ public void onDataTreeChanged(@Nonnull final Collection<DataTreeModification<Session>> changes) {
for (DataTreeModification<Session> change : changes) {
final DataObjectModification<Session> rootNode = change.getRootNode();
final DataObjectModification.ModificationType modificationType = rootNode.getModificationType();
}
}
- private void publishStartedSession(DataObject dataObject) {
+ private void publishStartedSession(final DataObject dataObject) {
Preconditions.checkArgument(dataObject instanceof Session);
Session session = (Session) dataObject;
final NetconfSessionStart sessionStart = new NetconfSessionStartBuilder()
baseNotificationPublisherRegistration.onSessionStarted(sessionStart);
}
- private void publishEndedSession(DataObject dataObject) {
+ private void publishEndedSession(final DataObject dataObject) {
Preconditions.checkArgument(dataObject instanceof Session);
Session session = (Session) dataObject;
final NetconfSessionEnd sessionEnd = new NetconfSessionEndBuilder()
odl:restart-dependents-on-updates="true">
<reference id="dataBroker"
- interface="org.opendaylight.controller.md.sal.binding.api.DataBroker"
+ interface="org.opendaylight.mdsal.binding.api.DataBroker"
odl:type="default"/>
<reference id="netconfOperationServiceFactoryListener"
interface="org.opendaylight.netconf.mapping.api.NetconfOperationServiceFactoryListener"
* 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.controller.config.yang.netconf.mdsal.notification;
import static org.mockito.ArgumentMatchers.any;
import org.junit.Test;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeChangeListener;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
+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.netconf.notifications.BaseNotificationPublisherRegistration;
import org.opendaylight.netconf.notifications.NetconfNotificationCollector;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Uri;
verify(baseNotificationPublisherRegistration).onCapabilityChanged(expectedChange);
}
- private NetconfCapabilityChange changedCapabilitesFrom(final List<Uri> added, final List<Uri> deleted) {
+ private static NetconfCapabilityChange changedCapabilitesFrom(final List<Uri> added, final List<Uri> deleted) {
NetconfCapabilityChangeBuilder netconfCapabilityChangeBuilder = new NetconfCapabilityChangeBuilder();
netconfCapabilityChangeBuilder.setChangedBy(new ChangedByBuilder().setServerOrUser(
new ServerBuilder().setServer(true).build()).build());
import org.junit.Test;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netconf.notifications.NetconfNotificationCollector;
import org.opendaylight.netconf.notifications.NotificationRegistration;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.netconf.notification._1._0.rev080714.StreamNameType;
import org.mockito.ArgumentCaptor;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataTreeIdentifier;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
public void testDataStoreListener() {
final InstanceIdentifier<DataObject> instanceIdentifier = InstanceIdentifier.create(DataObject.class);
final DataTreeIdentifier<DataObject> testId =
- new DataTreeIdentifier<>(LogicalDatastoreType.OPERATIONAL, instanceIdentifier);
+ DataTreeIdentifier.create(LogicalDatastoreType.OPERATIONAL, instanceIdentifier);
final OperationalDatastoreListener<DataObject> op =
new OperationalDatastoreListener<DataObject>(instanceIdentifier) {
@Override
- public void onDataTreeChanged(@Nonnull Collection collection) {
+ public void onDataTreeChanged(@Nonnull final Collection collection) {
}
};
doReturn(null).when(dataBroker).registerDataTreeChangeListener(any(), any());
import org.mockito.ArgumentCaptor;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
-import org.opendaylight.controller.md.sal.binding.api.DataObjectModification.ModificationType;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeChangeListener;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
+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;
import org.opendaylight.netconf.notifications.BaseNotificationPublisherRegistration;
import org.opendaylight.netconf.notifications.NetconfNotificationCollector;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.HostBuilder;
Assert.assertEquals(session.getUsername(), value.getUsername());
}
- private static Session createSession(long id) {
+ private static Session createSession(final long id) {
return createSessionWithInRpcCount(id, 0);
}
- private static Session createSessionWithInRpcCount(long id, long inRpc) {
+ private static Session createSessionWithInRpcCount(final long id, final long inRpc) {
return new SessionBuilder()
.setSessionId(id)
.setSourceHost(HostBuilder.getDefaultInstance("0.0.0.0"))
}
@SuppressWarnings("unchecked")
- private static DataTreeModification<Session> getTreeModification(Session session, ModificationType type) {
+ private static DataTreeModification<Session> getTreeModification(final Session session,
+ final ModificationType type) {
final DataTreeModification<Session> treeChange = mock(DataTreeModification.class);
final DataObjectModification<Session> changeObject = mock(DataObjectModification.class);
switch (type) {
<dependencies>
<dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>sal-core-api</artifactId>
+ <groupId>org.opendaylight.mdsal</groupId>
+ <artifactId>mdsal-dom-api</artifactId>
</dependency>
<dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>sal-binding-api</artifactId>
+ <groupId>org.opendaylight.mdsal</groupId>
+ <artifactId>mdsal-binding-api</artifactId>
</dependency>
<dependency>
<groupId>org.opendaylight.mdsal.binding.model.ietf</groupId>
import java.util.Set;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.stream.Collectors;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+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.DOMSchemaService;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Uri;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.library.rev160621.ModulesState;
odl:use-default-for-reference-types="true">
<reference id="dataBroker"
- interface="org.opendaylight.controller.md.sal.binding.api.DataBroker"
+ interface="org.opendaylight.mdsal.binding.api.DataBroker"
odl:type="default"/>
<reference id="schemaService"
interface="org.opendaylight.mdsal.dom.api.DOMSchemaService" />
import org.junit.Test;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.mdsal.dom.api.DOMSchemaService;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Uri;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.library.rev160621.ModulesState;
import java.util.List;
import java.util.Set;
import javax.xml.transform.dom.DOMSource;
-import org.opendaylight.controller.md.sal.dom.api.DOMNotification;
-import org.opendaylight.controller.md.sal.dom.api.DOMNotificationListener;
+import org.opendaylight.mdsal.dom.api.DOMNotification;
+import org.opendaylight.mdsal.dom.api.DOMNotificationListener;
import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.messagebus.eventaggregator.rev141202.TopicId;
import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.messagebus.eventsource.rev141202.EventSourceStatus;
import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.messagebus.eventsource.rev141202.EventSourceStatusNotification;
import com.google.common.collect.Multimaps;
import com.google.common.util.concurrent.ListenableFuture;
import java.io.IOException;
+import java.time.Instant;
import java.util.ArrayList;
import java.util.Collection;
-import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
+import java.util.concurrent.ExecutionException;
import java.util.regex.Pattern;
import javax.xml.stream.XMLStreamException;
import javax.xml.transform.dom.DOMResult;
import javax.xml.transform.dom.DOMSource;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
-import org.opendaylight.controller.md.sal.dom.api.DOMEvent;
-import org.opendaylight.controller.md.sal.dom.api.DOMNotification;
-import org.opendaylight.controller.md.sal.dom.api.DOMNotificationListener;
-import org.opendaylight.controller.md.sal.dom.api.DOMNotificationPublishService;
import org.opendaylight.controller.messagebus.app.util.TopicDOMNotification;
import org.opendaylight.controller.messagebus.app.util.Util;
import org.opendaylight.controller.messagebus.spi.EventSource;
+import org.opendaylight.mdsal.dom.api.DOMEvent;
+import org.opendaylight.mdsal.dom.api.DOMNotification;
+import org.opendaylight.mdsal.dom.api.DOMNotificationListener;
+import org.opendaylight.mdsal.dom.api.DOMNotificationPublishService;
import org.opendaylight.netconf.api.xml.XmlUtil;
import org.opendaylight.netconf.util.NetconfUtil;
import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.messagebus.eventaggregator.rev141202.NotificationPattern;
try {
availableStreams = mount.getAvailableStreams();
streamMap = Maps.uniqueIndex(availableStreams, input -> input.getName().getValue());
- } catch (ReadFailedException e) {
- LOG.warn("Can not read streams for node {}", mount.getNodeId());
+ } catch (InterruptedException | ExecutionException e) {
+ LOG.warn("Can not read streams for node {}", mount.getNodeId(), e);
}
return streamMap;
}
@Override
public void onNotification(final DOMNotification notification) {
SchemaPath notificationPath = notification.getType();
- Date notificationEventTime = null;
+ Instant notificationEventTime = null;
if (notification instanceof DOMEvent) {
- notificationEventTime = ((DOMEvent) notification).getEventTime();
+ notificationEventTime = ((DOMEvent) notification).getEventInstant();
}
final String namespace = notification.getType().getLastComponent().getNamespace().toString();
for (NotificationTopicRegistration notifReg : notificationTopicRegistrations.get(namespace)) {
* 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.messagebus.eventsources.netconf;
import com.google.common.base.Preconditions;
import java.util.Collection;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeChangeListener;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.dom.api.DOMMountPointService;
-import org.opendaylight.controller.md.sal.dom.api.DOMNotificationPublishService;
import org.opendaylight.controller.messagebus.spi.EventSourceRegistry;
+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;
+import org.opendaylight.mdsal.dom.api.DOMMountPointService;
+import org.opendaylight.mdsal.dom.api.DOMNotificationPublishService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.node.topology.rev150114.NetconfNode;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.node.topology.rev150114.network.topology.topology.topology.types.TopologyNetconf;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NetworkTopology;
*/
public void initialize() {
Preconditions.checkNotNull(dataBroker);
- listenerRegistration = dataBroker.registerDataTreeChangeListener(new DataTreeIdentifier<>(
+ listenerRegistration = dataBroker.registerDataTreeChangeListener(DataTreeIdentifier.create(
LogicalDatastoreType.OPERATIONAL, NETCONF_DEVICE_PATH), this);
LOG.info("NetconfEventSourceManager initialized.");
}
*/
package org.opendaylight.netconf.messagebus.eventsources.netconf;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
-import com.google.common.util.concurrent.CheckedFuture;
+import com.google.common.util.concurrent.FluentFuture;
+import java.time.Instant;
import java.time.ZoneId;
import java.time.ZonedDateTime;
import java.time.format.DateTimeFormatter;
import java.util.Collections;
-import java.util.Date;
import java.util.List;
+import java.util.Optional;
+import java.util.concurrent.ExecutionException;
import javassist.ClassPool;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataBroker;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataReadOnlyTransaction;
-import org.opendaylight.controller.md.sal.dom.api.DOMMountPoint;
-import org.opendaylight.controller.md.sal.dom.api.DOMNotificationListener;
-import org.opendaylight.controller.md.sal.dom.api.DOMNotificationService;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcException;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcResult;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcService;
-import org.opendaylight.controller.md.sal.dom.api.DOMService;
import org.opendaylight.mdsal.binding.dom.codec.gen.impl.StreamWriterGenerator;
import org.opendaylight.mdsal.binding.dom.codec.impl.BindingNormalizedNodeCodecRegistry;
import org.opendaylight.mdsal.binding.generator.impl.ModuleInfoBackedContext;
import org.opendaylight.mdsal.binding.generator.util.BindingRuntimeContext;
import org.opendaylight.mdsal.binding.generator.util.JavassistUtils;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.dom.api.DOMDataBroker;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeReadTransaction;
+import org.opendaylight.mdsal.dom.api.DOMMountPoint;
+import org.opendaylight.mdsal.dom.api.DOMNotificationListener;
+import org.opendaylight.mdsal.dom.api.DOMNotificationService;
+import org.opendaylight.mdsal.dom.api.DOMRpcResult;
+import org.opendaylight.mdsal.dom.api.DOMRpcService;
+import org.opendaylight.mdsal.dom.api.DOMService;
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.netmod.notification.rev080714.Netconf;
* @param lastEventTime last event time
* @return rpc result
*/
- CheckedFuture<DOMRpcResult, DOMRpcException> invokeCreateSubscription(final Stream stream,
- final Optional<Date> lastEventTime) {
+ FluentFuture<DOMRpcResult> invokeCreateSubscription(final Stream stream, final Optional<Instant> lastEventTime) {
final CreateSubscriptionInputBuilder inputBuilder = new CreateSubscriptionInputBuilder()
.setStream(stream.getName());
if (lastEventTime.isPresent() && stream.isReplaySupport()) {
- final ZonedDateTime dateTime = lastEventTime.get().toInstant().atZone(ZoneId.systemDefault());
+ final ZonedDateTime dateTime = lastEventTime.get().atZone(ZoneId.systemDefault());
final String formattedDate = DateTimeFormatter.ISO_OFFSET_DATE_TIME.format(dateTime);
inputBuilder.setStartTime(new DateAndTime(formattedDate));
}
* @param stream stream
* @return rpc result
*/
- CheckedFuture<DOMRpcResult, DOMRpcException> invokeCreateSubscription(final Stream stream) {
- return invokeCreateSubscription(stream, Optional.absent());
+ FluentFuture<DOMRpcResult> invokeCreateSubscription(final Stream stream) {
+ return invokeCreateSubscription(stream, Optional.empty());
}
/**
- * Returns list of streams avaliable on device.
+ * Returns list of streams available on device.
*
* @return list of streams
- * @throws ReadFailedException if data read fails
+ * @throws ExecutionException if data read fails
+ * @throws InterruptedException if data read fails
*/
- List<Stream> getAvailableStreams() throws ReadFailedException {
- DOMDataReadOnlyTransaction tx = dataBroker.newReadOnlyTransaction();
- CheckedFuture<Optional<NormalizedNode<?, ?>>, ReadFailedException> checkFeature = tx
- .read(LogicalDatastoreType.OPERATIONAL, STREAMS_PATH);
- Optional<NormalizedNode<?, ?>> streams = checkFeature.checkedGet();
+ List<Stream> getAvailableStreams() throws InterruptedException, ExecutionException {
+ DOMDataTreeReadTransaction tx = dataBroker.newReadOnlyTransaction();
+ FluentFuture<Optional<NormalizedNode<?, ?>>> checkFeature = tx.read(LogicalDatastoreType.OPERATIONAL,
+ STREAMS_PATH);
+ Optional<NormalizedNode<?, ?>> streams = checkFeature.get();
if (streams.isPresent()) {
Streams streams1 = (Streams) CODEC_REGISTRY.fromNormalizedNode(STREAMS_PATH, streams.get()).getValue();
return streams1.getStream();
*/
package org.opendaylight.netconf.messagebus.eventsources.netconf;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import java.util.List;
-import org.opendaylight.controller.md.sal.dom.api.DOMMountPoint;
+import java.util.Optional;
import org.opendaylight.controller.messagebus.spi.EventSourceRegistration;
+import org.opendaylight.mdsal.dom.api.DOMMountPoint;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.node.topology.rev150114.NetconfNode;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.node.topology.rev150114.NetconfNodeConnectionStatus.ConnectionStatus;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.node.topology.rev150114.netconf.node.connection.status.available.capabilities.AvailableCapability;
}
Optional<EventSourceRegistration<NetconfEventSource>> getEventSourceRegistration() {
- return Optional.fromNullable(eventSourceRegistration);
+ return Optional.ofNullable(eventSourceRegistration);
}
NetconfNode getNetconfNode() {
*/
package org.opendaylight.netconf.messagebus.eventsources.netconf;
-import com.google.common.base.Optional;
import com.google.common.collect.Sets;
-import java.util.Date;
+import java.time.Instant;
+import java.util.Optional;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.messagebus.eventaggregator.rev141202.TopicId;
private final String sourceName;
private final String notificationUrnPrefix;
private boolean replaySupported;
- private Date lastEventTime;
+ private Instant lastEventTime;
protected final ConcurrentHashMap<SchemaPath, Set<TopicId>> notificationTopicMap = new ConcurrentHashMap<>();
protected NotificationTopicRegistration(final NotificationSourceType notificationSourceType,
return nameSpace.startsWith(getNotificationUrnPrefix());
}
- Optional<Date> getLastEventTime() {
- return Optional.fromNullable(lastEventTime);
+ Optional<Instant> getLastEventTime() {
+ return Optional.ofNullable(lastEventTime);
}
- void setLastEventTime(final Date lastEventTime) {
+ void setLastEventTime(final Instant lastEventTime) {
this.lastEventTime = lastEventTime;
}
*/
package org.opendaylight.netconf.messagebus.eventsources.netconf;
-import com.google.common.util.concurrent.CheckedFuture;
+import com.google.common.util.concurrent.FluentFuture;
import java.util.ArrayList;
import java.util.List;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
-import org.opendaylight.controller.md.sal.dom.api.DOMNotificationListener;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcException;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcResult;
+import java.util.concurrent.ExecutionException;
+import org.opendaylight.mdsal.dom.api.DOMNotificationListener;
+import org.opendaylight.mdsal.dom.api.DOMRpcResult;
import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.messagebus.eventaggregator.rev141202.TopicId;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.netmod.notification.rev080714.netconf.streams.Stream;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
* @param netconfEventSource event source
*/
StreamNotificationTopicRegistration(final Stream stream, final String notificationPrefix,
- NetconfEventSource netconfEventSource) {
+ final NetconfEventSource netconfEventSource) {
super(NotificationSourceType.NetconfDeviceStream, stream.getName().getValue(), notificationPrefix);
this.netconfEventSource = netconfEventSource;
this.mountPoint = netconfEventSource.getMount();
/**
* Subscribes to notification stream associated with this registration.
*/
+ @Override
void activateNotificationSource() {
if (!isActive()) {
LOG.info("Stream {} is not active on node {}. Will subscribe.", this.getStreamName(), this.nodeId);
- final CheckedFuture<DOMRpcResult, DOMRpcException> result = mountPoint.invokeCreateSubscription(stream);
+ final FluentFuture<DOMRpcResult> result = mountPoint.invokeCreateSubscription(stream);
try {
- result.checkedGet();
+ result.get();
setActive(true);
- } catch (DOMRpcException e) {
- LOG.warn("Can not subscribe stream {} on node {}", this.getSourceName(), this.nodeId);
+ } catch (InterruptedException | ExecutionException e) {
+ LOG.warn("Can not subscribe stream {} on node {}", this.getSourceName(), this.nodeId, e);
setActive(false);
}
} else {
* from last
* received event time will be requested.
*/
+ @Override
void reActivateNotificationSource() {
if (isActive()) {
LOG.info("Stream {} is reactivating on node {}.", this.getStreamName(), this.nodeId);
- final CheckedFuture<DOMRpcResult, DOMRpcException> result;
- result = mountPoint.invokeCreateSubscription(stream, getLastEventTime());
+ final FluentFuture<DOMRpcResult> result = mountPoint.invokeCreateSubscription(stream, getLastEventTime());
try {
- result.checkedGet();
+ result.get();
setActive(true);
- } catch (DOMRpcException e) {
- LOG.warn("Can not resubscribe stream {} on node {}", this.getSourceName(), this.nodeId);
+ } catch (InterruptedException | ExecutionException e) {
+ LOG.warn("Can not resubscribe stream {} on node {}", this.getSourceName(), this.nodeId, e);
setActive(false);
}
}
}
@Override
- boolean registerNotificationTopic(SchemaPath notificationPath, TopicId topicId) {
+ boolean registerNotificationTopic(final SchemaPath notificationPath, final TopicId topicId) {
if (!checkNotificationPath(notificationPath)) {
LOG.debug("Bad SchemaPath for notification try to register");
return false;
}
@Override
- synchronized void unRegisterNotificationTopic(TopicId topicId) {
+ synchronized void unRegisterNotificationTopic(final TopicId topicId) {
List<SchemaPath> notificationPathToRemove = new ArrayList<>();
for (SchemaPath notifKey : notificationTopicMap.keySet()) {
Set<TopicId> topicList = notificationTopicMap.get(notifKey);
odl:use-default-for-reference-types="true">
<reference id="dataBroker"
- interface="org.opendaylight.controller.md.sal.binding.api.DataBroker"
+ interface="org.opendaylight.mdsal.binding.api.DataBroker"
odl:type="default"/>
<reference id="domMountPointService"
- interface="org.opendaylight.controller.md.sal.dom.api.DOMMountPointService" />
+ interface="org.opendaylight.mdsal.dom.api.DOMMountPointService" />
<reference id="domNotificationPublishService"
- interface="org.opendaylight.controller.md.sal.dom.api.DOMNotificationPublishService" />
+ interface="org.opendaylight.mdsal.dom.api.DOMNotificationPublishService" />
<reference id="eventSourceRegistry"
interface="org.opendaylight.controller.messagebus.spi.EventSourceRegistry" />
import org.mockito.ArgumentCaptor;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
-import org.opendaylight.controller.md.sal.dom.api.DOMNotification;
-import org.opendaylight.controller.md.sal.dom.api.DOMNotificationListener;
+import org.opendaylight.mdsal.dom.api.DOMNotification;
+import org.opendaylight.mdsal.dom.api.DOMNotificationListener;
import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.messagebus.eventaggregator.rev141202.TopicId;
import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.messagebus.eventsource.rev141202.EventSourceStatus;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
Assert.assertFalse(afterUnregister.contains(topic3));
}
- private TopicId registerTopic(String value) {
+ private TopicId registerTopic(final String value) {
final TopicId topic = TopicId.getDefaultInstance(value);
registration.registerNotificationTopic(ConnectionNotificationTopicRegistration.EVENT_SOURCE_STATUS_PATH, topic);
return topic;
* @param listener listener
* @param status expected value
*/
- private static void checkStatus(DOMNotificationListener listener, EventSourceStatus status) {
+ private static void checkStatus(final DOMNotificationListener listener, final EventSourceStatus status) {
ArgumentCaptor<DOMNotification> notificationCaptor = ArgumentCaptor.forClass(DOMNotification.class);
verify(listener).onNotification(notificationCaptor.capture());
final DOMNotification value = notificationCaptor.getValue();
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
-import com.google.common.base.Optional;
import com.google.common.util.concurrent.CheckedFuture;
import com.google.common.util.concurrent.Futures;
import java.util.Collections;
import java.util.HashMap;
+import java.util.Optional;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
-import org.opendaylight.controller.md.sal.binding.api.MountPointService;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataBroker;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataReadOnlyTransaction;
-import org.opendaylight.controller.md.sal.dom.api.DOMMountPoint;
-import org.opendaylight.controller.md.sal.dom.api.DOMMountPointService;
-import org.opendaylight.controller.md.sal.dom.api.DOMNotificationPublishService;
-import org.opendaylight.controller.md.sal.dom.api.DOMNotificationService;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcService;
import org.opendaylight.controller.messagebus.spi.EventSource;
import org.opendaylight.controller.messagebus.spi.EventSourceRegistry;
-import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
+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.MountPointService;
+import org.opendaylight.mdsal.binding.api.RpcProviderService;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.ReadFailedException;
+import org.opendaylight.mdsal.dom.api.DOMDataBroker;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeReadTransaction;
+import org.opendaylight.mdsal.dom.api.DOMMountPoint;
+import org.opendaylight.mdsal.dom.api.DOMMountPointService;
+import org.opendaylight.mdsal.dom.api.DOMNotificationPublishService;
+import org.opendaylight.mdsal.dom.api.DOMNotificationService;
+import org.opendaylight.mdsal.dom.api.DOMRpcService;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.netmod.notification.rev080714.Netconf;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.netmod.notification.rev080714.netconf.Streams;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.node.topology.rev150114.NetconfNodeConnectionStatus.ConnectionStatus;
MountPointService mountPointServiceMock;
EventSourceRegistry eventSourceTopologyMock;
DataTreeModification<Node> dataTreeModificationMock;
- RpcProviderRegistry rpcProviderRegistryMock;
+ RpcProviderService rpcProviderRegistryMock;
EventSourceRegistry eventSourceRegistry;
@BeforeClass
mock(DOMNotificationPublishService.class);
domMountPointServiceMock = mock(DOMMountPointService.class);
eventSourceTopologyMock = mock(EventSourceRegistry.class);
- rpcProviderRegistryMock = mock(RpcProviderRegistry.class);
+ rpcProviderRegistryMock = mock(RpcProviderService.class);
eventSourceRegistry = mock(EventSourceRegistry.class);
listenerRegistrationMock = mock(ListenerRegistration.class);
doReturn(Optional.of(mock(DOMNotificationService.class))).when(domMountPointMock)
.getService(DOMNotificationService.class);
- DOMDataReadOnlyTransaction rtx = mock(DOMDataReadOnlyTransaction.class);
+ DOMDataTreeReadTransaction rtx = mock(DOMDataTreeReadTransaction.class);
doReturn(rtx).when(mpDataBroker).newReadOnlyTransaction();
CheckedFuture<Optional<NormalizedNode<?, ?>>, ReadFailedException> checkFeature = Futures
.immediateCheckedFuture(Optional.of(NetconfTestUtils.getStreamsNode("stream-1")));
}
@SuppressWarnings("unchecked")
- private void onDataChangedTestHelper(boolean create, boolean update, boolean isNetconf, String
- notificationCapabilityPrefix) throws Exception {
+ private void onDataChangedTestHelper(final boolean create, final boolean update, final boolean isNetconf,
+ final String notificationCapabilityPrefix) throws Exception {
dataTreeModificationMock = mock(DataTreeModification.class);
DataObjectModification<Node> mockModification = mock(DataObjectModification.class);
doReturn(create ? DataObjectModification.ModificationType.WRITE :
doReturn(node01).when(mockModification).getDataAfter();
- doReturn(new DataTreeIdentifier<>(LogicalDatastoreType.OPERATIONAL,
+ doReturn(DataTreeIdentifier.create(LogicalDatastoreType.OPERATIONAL,
NetconfTestUtils.getInstanceIdentifier(node01))).when(dataTreeModificationMock).getRootPath();
}
* 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.messagebus.eventsources.netconf;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.verify;
import com.google.common.base.Function;
-import com.google.common.base.Optional;
import com.google.common.collect.Lists;
import com.google.common.util.concurrent.Futures;
+import java.time.Instant;
import java.time.ZoneId;
import java.time.format.DateTimeFormatter;
-import java.util.Date;
import java.util.List;
+import java.util.Optional;
import javax.annotation.Nullable;
import org.junit.Assert;
import org.junit.Before;
import org.mockito.ArgumentCaptor;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataBroker;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataReadOnlyTransaction;
-import org.opendaylight.controller.md.sal.dom.api.DOMMountPoint;
-import org.opendaylight.controller.md.sal.dom.api.DOMNotificationService;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcService;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.dom.api.DOMDataBroker;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeReadTransaction;
+import org.opendaylight.mdsal.dom.api.DOMMountPoint;
+import org.opendaylight.mdsal.dom.api.DOMNotificationService;
+import org.opendaylight.mdsal.dom.api.DOMRpcService;
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.StreamNameType;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.netmod.notification.rev080714.Netconf;
@Mock
DOMRpcService rpcService;
@Mock
- private DOMDataReadOnlyTransaction tx;
+ private DOMDataTreeReadTransaction tx;
private NetconfEventSourceMount mount;
@Before
Stream stream = new StreamBuilder()
.setName(new StreamNameType(STREAM_1))
.build();
- mount.invokeCreateSubscription(stream, Optional.absent());
+ mount.invokeCreateSubscription(stream, Optional.empty());
final SchemaPath type = SchemaPath.create(true, QName.create(CreateSubscriptionInput.QNAME,
"create-subscription"));
ArgumentCaptor<ContainerNode> captor = ArgumentCaptor.forClass(ContainerNode.class);
.setName(new StreamNameType(STREAM_1))
.setReplaySupport(true)
.build();
- final Date date = new Date();
+ final Instant date = Instant.now();
mount.invokeCreateSubscription(stream, Optional.of(date));
final SchemaPath type = SchemaPath.create(true, QName.create(CreateSubscriptionInput.QNAME,
"create-subscription"));
ArgumentCaptor<ContainerNode> captor = ArgumentCaptor.forClass(ContainerNode.class);
verify(rpcService).invokeRpc(eq(type), captor.capture());
Assert.assertEquals(STREAM_1, getStreamName(captor.getValue()));
- final String expDate = DateTimeFormatter.ISO_OFFSET_DATE_TIME.format(date.toInstant().atZone(ZoneId
- .systemDefault()));
+ final String expDate = DateTimeFormatter.ISO_OFFSET_DATE_TIME.format(date.atZone(ZoneId.systemDefault()));
final Optional<LeafNode> actual = (Optional<LeafNode>) getDate(captor.getValue());
Assert.assertTrue(actual.isPresent());
String actualDate = (String) actual.get().getValue();
.setName(new StreamNameType(STREAM_1))
.setReplaySupport(true)
.build();
- mount.invokeCreateSubscription(stream, Optional.absent());
+ mount.invokeCreateSubscription(stream, Optional.empty());
final SchemaPath type = SchemaPath.create(true, QName.create(CreateSubscriptionInput.QNAME,
"create-subscription"));
ArgumentCaptor<ContainerNode> captor = ArgumentCaptor.forClass(ContainerNode.class);
private static Optional<?> getDate(final ContainerNode value) {
YangInstanceIdentifier.NodeIdentifier startTime =
new YangInstanceIdentifier.NodeIdentifier(QName.create(CreateSubscriptionInput.QNAME, "startTime"));
- return Optional.fromJavaUtil(value.getChild(startTime));
+ return value.getChild(startTime);
}
}
\ No newline at end of file
import org.mockito.ArgumentCaptor;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
-import org.opendaylight.controller.md.sal.dom.api.DOMNotification;
-import org.opendaylight.controller.md.sal.dom.api.DOMNotificationPublishService;
import org.opendaylight.controller.messagebus.app.util.TopicDOMNotification;
+import org.opendaylight.mdsal.dom.api.DOMNotification;
+import org.opendaylight.mdsal.dom.api.DOMNotificationPublishService;
import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.messagebus.eventaggregator.rev141202.NotificationPattern;
import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.messagebus.eventaggregator.rev141202.TopicId;
import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.messagebus.eventaggregator.rev141202.TopicNotification;
* 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.messagebus.eventsources.netconf;
import static org.hamcrest.CoreMatchers.hasItems;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
+import static org.opendaylight.yangtools.util.concurrent.FluentFutures.immediateNullFluentFuture;
-import com.google.common.base.Optional;
-import com.google.common.util.concurrent.Futures;
-import java.util.Date;
+import java.time.Instant;
+import java.util.Optional;
import java.util.Set;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
-import org.opendaylight.controller.md.sal.dom.api.DOMNotificationListener;
-import org.opendaylight.controller.md.sal.dom.api.DOMNotificationService;
+import org.opendaylight.mdsal.dom.api.DOMNotificationListener;
+import org.opendaylight.mdsal.dom.api.DOMNotificationService;
import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.messagebus.eventaggregator.rev141202.TopicId;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.netconf.notification._1._0.rev080714.StreamNameType;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.netmod.notification.rev080714.netconf.streams.Stream;
when(mount.registerNotificationListener(source, ConnectionNotificationTopicRegistration
.EVENT_SOURCE_STATUS_PATH))
.thenReturn(listenerRegistration);
- when(mount.invokeCreateSubscription(any(), any())).thenReturn(Futures.immediateCheckedFuture(null));
- when(mount.invokeCreateSubscription(any())).thenReturn(Futures.immediateCheckedFuture(null));
+ when(mount.invokeCreateSubscription(any(), any())).thenReturn(immediateNullFluentFuture());
+ when(mount.invokeCreateSubscription(any())).thenReturn(immediateNullFluentFuture());
when(source.getMount()).thenReturn(mount);
stream = new StreamBuilder().setName(StreamNameType.getDefaultInstance(STREAM_NAME)).setReplaySupport(true)
registration.reActivateNotificationSource();
Assert.assertTrue(registration.isActive());
- verify(mount).invokeCreateSubscription(stream, Optional.absent());
+ verify(mount).invokeCreateSubscription(stream, Optional.empty());
}
@Test
public void testReActivateNotificationSourceWithReplay() throws Exception {
- final Date lastEventTime = new Date();
+ final Instant lastEventTime = Instant.now();
registration.setActive(true);
registration.setLastEventTime(lastEventTime);
registration.reActivateNotificationSource();
Assert.assertFalse(afterUnregister.contains(topic3));
}
- private TopicId registerTopic(String value) {
+ private TopicId registerTopic(final String value) {
final TopicId topic = TopicId.getDefaultInstance(value);
registration.registerNotificationTopic(ConnectionNotificationTopicRegistration.EVENT_SOURCE_STATUS_PATH, topic);
return topic;
<artifactId>yang-test-util</artifactId>
</dependency>
<dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>sal-binding-broker-impl</artifactId>
+ <groupId>org.opendaylight.mdsal</groupId>
+ <artifactId>mdsal-binding-dom-adapter</artifactId>
<scope>test</scope>
</dependency>
<dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>sal-binding-broker-impl</artifactId>
+ <groupId>org.opendaylight.mdsal</groupId>
+ <artifactId>mdsal-binding-dom-adapter</artifactId>
<scope>test</scope>
<type>test-jar</type>
</dependency>
* 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.console.impl;
import com.google.common.base.Strings;
import java.util.UUID;
import java.util.concurrent.ExecutionException;
import java.util.stream.Collectors;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
import org.opendaylight.mdsal.common.api.CommitInfo;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netconf.console.api.NetconfCommands;
import org.opendaylight.netconf.console.utils.NetconfConsoleConstants;
import org.opendaylight.netconf.console.utils.NetconfConsoleUtils;
* 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.console.utils;
-import com.google.common.base.Optional;
import com.google.common.util.concurrent.ListenableFuture;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
+import java.util.Optional;
import java.util.concurrent.ExecutionException;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.ReadTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.node.topology.rev150114.NetconfNode;
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;
public static <D extends org.opendaylight.yangtools.yang.binding.DataObject> D read(
final LogicalDatastoreType store, final InstanceIdentifier<D> path, final DataBroker db) {
final ListenableFuture<Optional<D>> future;
- try (ReadOnlyTransaction transaction = db.newReadOnlyTransaction()) {
+ try (ReadTransaction transaction = db.newReadOnlyTransaction()) {
future = transaction.read(store, path);
}
odl:use-default-for-reference-types="true">
<reference id="dataBroker"
- interface="org.opendaylight.controller.md.sal.binding.api.DataBroker"
+ interface="org.opendaylight.mdsal.binding.api.DataBroker"
odl:type="default"/>
<bean id="netconfCommandsImpl" class="org.opendaylight.netconf.console.impl.NetconfCommandsImpl">
* 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.console.impl;
import static junit.framework.TestCase.assertFalse;
import org.awaitility.Awaitility;
import org.junit.Before;
import org.junit.Test;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
-import org.opendaylight.controller.md.sal.binding.test.ConcurrentDataBrokerTestCustomizer;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
+import org.opendaylight.mdsal.binding.dom.adapter.test.ConcurrentDataBrokerTestCustomizer;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netconf.console.utils.NetconfConsoleConstants;
import org.opendaylight.netconf.console.utils.NetconfConsoleUtils;
import org.opendaylight.netconf.console.utils.NetconfIidFactory;
interface="io.netty.util.concurrent.EventExecutor"
odl:type="global-event-executor"/>
<reference id="dataBroker"
- interface="org.opendaylight.controller.md.sal.binding.api.DataBroker"/>
+ interface="org.opendaylight.mdsal.binding.api.DataBroker"/>
<reference id="mountPointService"
- interface="org.opendaylight.controller.md.sal.dom.api.DOMMountPointService"
+ interface="org.opendaylight.mdsal.dom.api.DOMMountPointService"
odl:type="default"/>
<reference id="encryptionService"
interface="org.opendaylight.aaa.encrypt.AAAEncryptionService" />
<scope>test</scope>
</dependency>
<dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>sal-binding-broker-impl</artifactId>
+ <groupId>org.opendaylight.mdsal</groupId>
+ <artifactId>mdsal-binding-dom-adapter</artifactId>
<scope>test</scope>
</dependency>
<dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>sal-binding-broker-impl</artifactId>
+ <groupId>org.opendaylight.mdsal</groupId>
+ <artifactId>mdsal-binding-dom-adapter</artifactId>
<scope>test</scope>
<type>test-jar</type>
</dependency>
* 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.impl;
import akka.actor.ActorRef;
import com.google.common.base.Preconditions;
import java.util.List;
import java.util.stream.Collectors;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.dom.api.DOMActionService;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataBroker;
-import org.opendaylight.controller.md.sal.dom.api.DOMMountPointService;
-import org.opendaylight.controller.md.sal.dom.api.DOMNotification;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcService;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.dom.api.DOMActionService;
+import org.opendaylight.mdsal.dom.api.DOMDataBroker;
+import org.opendaylight.mdsal.dom.api.DOMMountPointService;
+import org.opendaylight.mdsal.dom.api.DOMNotification;
+import org.opendaylight.mdsal.dom.api.DOMRpcService;
import org.opendaylight.netconf.sal.connect.api.RemoteDeviceHandler;
import org.opendaylight.netconf.sal.connect.netconf.listener.NetconfDeviceCapabilities;
import org.opendaylight.netconf.sal.connect.netconf.listener.NetconfSessionPreferences;
* 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.impl;
import akka.actor.ActorRef;
import java.util.Collection;
import javax.annotation.Nonnull;
import javax.annotation.concurrent.GuardedBy;
-import org.opendaylight.controller.md.sal.binding.api.ClusteredDataTreeChangeListener;
-import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.dom.api.DOMMountPointService;
+import org.opendaylight.mdsal.binding.api.ClusteredDataTreeChangeListener;
+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.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.dom.api.DOMMountPointService;
import org.opendaylight.netconf.sal.connect.util.RemoteDeviceId;
import org.opendaylight.netconf.topology.singleton.api.NetconfTopologySingletonService;
import org.opendaylight.netconf.topology.singleton.impl.actors.NetconfNodeActor;
final InstanceIdentifier<Node> path = NetconfTopologyUtils.createTopologyNodeListPath(key, topologyId);
LOG.debug("{}: Registering data tree change listener on path {}", id, path);
dataChangeListenerRegistration = setup.getDataBroker().registerDataTreeChangeListener(
- new DataTreeIdentifier<>(LogicalDatastoreType.OPERATIONAL, path), this);
+ DataTreeIdentifier.create(LogicalDatastoreType.OPERATIONAL, path), this);
}
private synchronized void handleSlaveMountPoint(final DataObjectModification<Node> rootNode) {
* 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.impl;
import static org.opendaylight.netconf.topology.singleton.impl.utils.NetconfTopologyUtils.DEFAULT_SCHEMA_REPOSITORY;
import com.google.common.util.concurrent.ListenableFuture;
import java.util.concurrent.atomic.AtomicBoolean;
import javax.annotation.Nonnull;
-import org.opendaylight.controller.md.sal.dom.api.DOMMountPointService;
+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.netconf.sal.connect.util.RemoteDeviceId;
import org.opendaylight.controller.cluster.ActorSystemProvider;
import org.opendaylight.controller.config.threadpool.ScheduledThreadPool;
import org.opendaylight.controller.config.threadpool.ThreadPool;
-import org.opendaylight.controller.md.sal.binding.api.ClusteredDataTreeChangeListener;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.dom.api.DOMMountPointService;
-import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
+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.DataTreeIdentifier;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
+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.DOMMountPointService;
+import org.opendaylight.mdsal.dom.api.DOMRpcProviderService;
import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceProvider;
import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceRegistration;
import org.opendaylight.mdsal.singleton.common.api.ServiceGroupIdentifier;
clusterRegistrations = new ConcurrentHashMap<>();
private final DataBroker dataBroker;
- private final RpcProviderRegistry rpcProviderRegistry;
+ private final DOMRpcProviderService rpcProviderRegistry;
private final ClusterSingletonServiceProvider clusterSingletonServiceProvider;
private final ScheduledExecutorService keepaliveExecutor;
private final ListeningExecutorService processingExecutor;
private String privateKeyPath;
private String privateKeyPassphrase;
- public NetconfTopologyManager(final DataBroker dataBroker, final RpcProviderRegistry rpcProviderRegistry,
+ public NetconfTopologyManager(final DataBroker dataBroker, final DOMRpcProviderService rpcProviderRegistry,
final ClusterSingletonServiceProvider clusterSingletonServiceProvider,
final ScheduledThreadPool keepaliveExecutor, final ThreadPool processingExecutor,
final ActorSystemProvider actorSystemProvider,
}, MoreExecutors.directExecutor());
LOG.debug("Registering datastore listener");
- return dataBroker.registerDataTreeChangeListener(
- new DataTreeIdentifier<>(LogicalDatastoreType.CONFIGURATION,
- NetconfTopologyUtils.createTopologyListPath(topologyId).child(Node.class)), this);
+ return dataBroker.registerDataTreeChangeListener(DataTreeIdentifier.create(LogicalDatastoreType.CONFIGURATION,
+ NetconfTopologyUtils.createTopologyListPath(topologyId).child(Node.class)), this);
}
private void initTopology(final WriteTransaction wtx, final LogicalDatastoreType datastoreType) {
* 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.impl;
import akka.actor.ActorRef;
import akka.pattern.Patterns;
import akka.util.Timeout;
-import java.util.Collections;
-import java.util.Map;
-import javax.annotation.Nonnull;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionChainListener;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataBroker;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataBrokerExtension;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataReadOnlyTransaction;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataReadWriteTransaction;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataWriteTransaction;
-import org.opendaylight.controller.md.sal.dom.api.DOMTransactionChain;
+import com.google.common.collect.ClassToInstanceMap;
+import com.google.common.collect.ImmutableClassToInstanceMap;
+import org.opendaylight.mdsal.dom.api.DOMDataBroker;
+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.netconf.sal.connect.util.RemoteDeviceId;
import org.opendaylight.netconf.topology.singleton.impl.tx.ProxyReadTransaction;
import org.opendaylight.netconf.topology.singleton.impl.tx.ProxyReadWriteTransaction;
@SuppressWarnings("checkstyle:IllegalCatch")
@Override
- public DOMDataReadOnlyTransaction newReadOnlyTransaction() {
+ public DOMDataTreeReadTransaction newReadOnlyTransaction() {
final Future<Object> txActorFuture = Patterns.ask(masterNode, new NewReadTransactionRequest(), askTimeout);
return new ProxyReadTransaction(id, txActorFuture, executionContext, askTimeout);
}
@SuppressWarnings("checkstyle:IllegalCatch")
@Override
- public DOMDataReadWriteTransaction newReadWriteTransaction() {
+ public DOMDataTreeReadWriteTransaction newReadWriteTransaction() {
final Future<Object> txActorFuture = Patterns.ask(masterNode, new NewReadWriteTransactionRequest(), askTimeout);
return new ProxyReadWriteTransaction(id, txActorFuture, executionContext, askTimeout);
}
@SuppressWarnings("checkstyle:IllegalCatch")
@Override
- public DOMDataWriteTransaction newWriteOnlyTransaction() {
+ public DOMDataTreeWriteTransaction newWriteOnlyTransaction() {
final Future<Object> txActorFuture = Patterns.ask(masterNode, new NewWriteTransactionRequest(), askTimeout);
return new ProxyReadWriteTransaction(id, txActorFuture, executionContext, askTimeout);
}
@Override
- public DOMTransactionChain createTransactionChain(final TransactionChainListener listener) {
+ public DOMTransactionChain createTransactionChain(final DOMTransactionChainListener listener) {
throw new UnsupportedOperationException(id + ": Transaction chains not supported for netconf mount point");
}
- @Nonnull
@Override
- public Map<Class<? extends DOMDataBrokerExtension>, DOMDataBrokerExtension> getSupportedExtensions() {
- return Collections.emptyMap();
+ public ClassToInstanceMap<DOMDataBrokerExtension> getExtensions() {
+ return ImmutableClassToInstanceMap.of();
}
}
* 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.impl;
import akka.actor.ActorRef;
import akka.pattern.Patterns;
import akka.util.Timeout;
import com.google.common.collect.ImmutableList;
-import com.google.common.util.concurrent.CheckedFuture;
-import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.FluentFuture;
import com.google.common.util.concurrent.SettableFuture;
import java.util.Collection;
import javax.annotation.Nonnull;
-import javax.annotation.Nullable;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcAvailabilityListener;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcException;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcResult;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcService;
-import org.opendaylight.controller.md.sal.dom.spi.DefaultDOMRpcResult;
+import org.opendaylight.mdsal.dom.api.DOMRpcAvailabilityListener;
+import org.opendaylight.mdsal.dom.api.DOMRpcResult;
+import org.opendaylight.mdsal.dom.api.DOMRpcService;
+import org.opendaylight.mdsal.dom.spi.DefaultDOMRpcResult;
import org.opendaylight.netconf.sal.connect.util.RemoteDeviceId;
import org.opendaylight.netconf.topology.singleton.impl.utils.ClusteringRpcException;
import org.opendaylight.netconf.topology.singleton.messages.NormalizedNodeMessage;
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.util.concurrent.ExceptionMapper;
import org.opendaylight.yangtools.yang.common.RpcError;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import scala.concurrent.Future;
public class ProxyDOMRpcService implements DOMRpcService {
-
private static final Logger LOG = LoggerFactory.getLogger(ProxyDOMRpcService.class);
- private final ExceptionMapper<DOMRpcException> domRpcExceptionMapper =
- new ExceptionMapper<DOMRpcException>("invokeRpc", DOMRpcException.class) {
- @Override
- protected DOMRpcException newWithCause(final String message, final Throwable cause) {
- return new ClusteringRpcException(id + ": Exception during remote rpc invocation.", cause);
- }
- };
-
private final ActorRef masterActorRef;
private final ActorSystem actorSystem;
private final RemoteDeviceId id;
this.actorResponseWaitTime = actorResponseWaitTime;
}
- @Nonnull
@Override
- public CheckedFuture<DOMRpcResult, DOMRpcException> invokeRpc(@Nonnull final SchemaPath type,
- @Nullable final NormalizedNode<?, ?> input) {
+ public FluentFuture<DOMRpcResult> invokeRpc(final SchemaPath type, final NormalizedNode<?, ?> input) {
LOG.trace("{}: Rpc operation invoked with schema type: {} and node: {}.", id, type, input);
final NormalizedNodeMessage normalizedNodeMessage = input != null
@Override
public void onComplete(final Throwable failure, final Object response) {
if (failure != null) {
- settableFuture.setException(failure);
+ if (failure instanceof ClusteringRpcException) {
+ settableFuture.setException(failure);
+ } else {
+ settableFuture.setException(
+ new ClusteringRpcException(id + ": Exception during remote rpc invocation.", failure));
+ }
return;
}
}
}, actorSystem.dispatcher());
- return Futures.makeChecked(settableFuture, domRpcExceptionMapper);
+ return settableFuture;
}
@Nonnull
* 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.impl;
import akka.actor.ActorRef;
import akka.actor.ActorSystem;
import akka.util.Timeout;
import java.util.concurrent.atomic.AtomicBoolean;
-import org.opendaylight.controller.md.sal.dom.api.DOMMountPointService;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcService;
+import org.opendaylight.mdsal.dom.api.DOMMountPointService;
+import org.opendaylight.mdsal.dom.api.DOMRpcService;
import org.opendaylight.netconf.sal.connect.netconf.sal.NetconfDeviceNotificationService;
import org.opendaylight.netconf.sal.connect.netconf.sal.NetconfDeviceSalProvider;
import org.opendaylight.netconf.sal.connect.util.RemoteDeviceId;
import org.opendaylight.controller.cluster.schema.provider.RemoteYangTextSourceProvider;
import org.opendaylight.controller.cluster.schema.provider.impl.RemoteSchemaProvider;
import org.opendaylight.controller.cluster.schema.provider.impl.YangTextSchemaSourceSerializationProxy;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataBroker;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataReadOnlyTransaction;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataReadWriteTransaction;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataWriteTransaction;
-import org.opendaylight.controller.md.sal.dom.api.DOMMountPointService;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcResult;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcService;
+import org.opendaylight.mdsal.dom.api.DOMDataBroker;
+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.DOMMountPointService;
+import org.opendaylight.mdsal.dom.api.DOMRpcResult;
+import org.opendaylight.mdsal.dom.api.DOMRpcService;
import org.opendaylight.netconf.sal.connect.util.RemoteDeviceId;
import org.opendaylight.netconf.topology.singleton.impl.ProxyDOMRpcService;
import org.opendaylight.netconf.topology.singleton.impl.ProxyYangTextSourceProvider;
final CreateInitialMasterActorData masterActorData = (CreateInitialMasterActorData) message;
sourceIdentifiers = masterActorData.getSourceIndentifiers();
this.deviceDataBroker = masterActorData.getDeviceDataBroker();
- final DOMDataReadOnlyTransaction tx = deviceDataBroker.newReadOnlyTransaction();
+ final DOMDataTreeReadTransaction tx = deviceDataBroker.newReadOnlyTransaction();
readTxActor = context().actorOf(ReadTransactionActor.props(tx));
this.deviceRpc = masterActorData.getDeviceRpc();
sender().tell(new Success(readTxActor), self());
} else if (message instanceof NewWriteTransactionRequest) { // master
try {
- final DOMDataWriteTransaction tx = deviceDataBroker.newWriteOnlyTransaction();
+ final DOMDataTreeWriteTransaction tx = deviceDataBroker.newWriteOnlyTransaction();
final ActorRef txActor = context().actorOf(WriteTransactionActor.props(tx, writeTxIdleTimeout));
sender().tell(new Success(txActor), self());
} catch (final Exception t) {
} else if (message instanceof NewReadWriteTransactionRequest) {
try {
- final DOMDataReadWriteTransaction tx = deviceDataBroker.newReadWriteTransaction();
+ final DOMDataTreeReadWriteTransaction tx = deviceDataBroker.newReadWriteTransaction();
final ActorRef txActor = context().actorOf(ReadWriteTransactionActor.props(tx, writeTxIdleTimeout));
sender().tell(new Success(txActor), self());
} catch (final Exception t) {
}
private void resolveSchemaContext(final SchemaContextFactory schemaContextFactory,
- final SlaveSalFacade localSlaveSalManager, final ActorRef masterReference, int tries) {
+ final SlaveSalFacade localSlaveSalManager, final ActorRef masterReference, final int tries) {
final ListenableFuture<SchemaContext> schemaContextFuture =
schemaContextFactory.createSchemaContext(sourceIdentifiers);
Futures.addCallback(schemaContextFuture, new FutureCallback<SchemaContext>() {
import akka.actor.ActorRef;
import akka.actor.Status.Failure;
-import com.google.common.base.Optional;
import com.google.common.util.concurrent.FutureCallback;
-import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.MoreExecutors;
+import java.util.Optional;
import javax.annotation.Nonnull;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataReadTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeReadTransaction;
import org.opendaylight.netconf.topology.singleton.messages.NormalizedNodeMessage;
import org.opendaylight.netconf.topology.singleton.messages.transactions.EmptyReadResponse;
import org.opendaylight.netconf.topology.singleton.messages.transactions.ExistsRequest;
class ReadAdapter {
- private final DOMDataReadTransaction tx;
+ private final DOMDataTreeReadTransaction tx;
- ReadAdapter(final DOMDataReadTransaction tx) {
+ ReadAdapter(final DOMDataTreeReadTransaction tx) {
this.tx = tx;
}
private void read(final YangInstanceIdentifier path, final LogicalDatastoreType store, final ActorRef sender,
final ActorRef self) {
- Futures.addCallback(tx.read(store, path), new FutureCallback<Optional<NormalizedNode<?, ?>>>() {
-
+ tx.read(store, path).addCallback(new FutureCallback<Optional<NormalizedNode<?, ?>>>() {
@Override
- public void onSuccess(@Nonnull final Optional<NormalizedNode<?, ?>> result) {
+ public void onSuccess(final Optional<NormalizedNode<?, ?>> result) {
if (!result.isPresent()) {
sender.tell(new EmptyReadResponse(), self);
return;
private void exists(final YangInstanceIdentifier path, final LogicalDatastoreType store, final ActorRef sender,
final ActorRef self) {
- Futures.addCallback(tx.exists(store, path), new FutureCallback<Boolean>() {
+ tx.exists(store, path).addCallback(new FutureCallback<Boolean>() {
@Override
public void onSuccess(final Boolean result) {
if (result == null) {
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.netconf.topology.singleton.impl.actors;
import akka.actor.Props;
import akka.actor.UntypedAbstractActor;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataReadOnlyTransaction;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeReadTransaction;
import org.opendaylight.netconf.topology.singleton.messages.transactions.ReadActorMessage;
/**
- * ReadTransactionActor is an interface to device's {@link DOMDataReadOnlyTransaction} for cluster nodes.
+ * ReadTransactionActor is an interface to device's {@link DOMDataTreeReadTransaction} for cluster nodes.
*/
public final class ReadTransactionActor extends UntypedAbstractActor {
private final ReadAdapter readAdapter;
- private ReadTransactionActor(final DOMDataReadOnlyTransaction tx) {
+ private ReadTransactionActor(final DOMDataTreeReadTransaction tx) {
readAdapter = new ReadAdapter(tx);
}
* @param tx delegate device read transaction
* @return props
*/
- static Props props(final DOMDataReadOnlyTransaction tx) {
+ static Props props(final DOMDataTreeReadTransaction tx) {
return Props.create(ReadTransactionActor.class, () -> new ReadTransactionActor(tx));
}
* 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.impl.actors;
import akka.actor.Props;
import akka.actor.ReceiveTimeout;
import akka.actor.UntypedAbstractActor;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataReadWriteTransaction;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeReadWriteTransaction;
import org.opendaylight.netconf.topology.singleton.messages.transactions.ReadActorMessage;
import org.opendaylight.netconf.topology.singleton.messages.transactions.WriteActorMessage;
import org.slf4j.Logger;
private static final Logger LOG = LoggerFactory.getLogger(ReadWriteTransactionActor.class);
- private final DOMDataReadWriteTransaction tx;
+ private final DOMDataTreeReadWriteTransaction tx;
private final long idleTimeout;
private final ReadAdapter readAdapter;
private final WriteAdapter writeAdapter;
- private ReadWriteTransactionActor(final DOMDataReadWriteTransaction tx, final Duration idleTimeout) {
+ private ReadWriteTransactionActor(final DOMDataTreeReadWriteTransaction tx, final Duration idleTimeout) {
this.tx = tx;
this.idleTimeout = idleTimeout.toSeconds();
if (this.idleTimeout > 0) {
* @param idleTimeout idle time in seconds, after which transaction is closed automatically
* @return props
*/
- static Props props(final DOMDataReadWriteTransaction tx, final Duration idleTimeout) {
+ static Props props(final DOMDataTreeReadWriteTransaction tx, final Duration idleTimeout) {
return Props.create(ReadWriteTransactionActor.class, () -> new ReadWriteTransactionActor(tx, idleTimeout));
}
import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.MoreExecutors;
import javax.annotation.Nonnull;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataWriteTransaction;
import org.opendaylight.mdsal.common.api.CommitInfo;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteTransaction;
import org.opendaylight.netconf.topology.singleton.messages.NormalizedNodeMessage;
import org.opendaylight.netconf.topology.singleton.messages.transactions.CancelRequest;
import org.opendaylight.netconf.topology.singleton.messages.transactions.DeleteRequest;
private static final Logger LOG = LoggerFactory.getLogger(WriteAdapter.class);
- private final DOMDataWriteTransaction tx;
+ private final DOMDataTreeWriteTransaction tx;
- WriteAdapter(final DOMDataWriteTransaction tx) {
+ WriteAdapter(final DOMDataTreeWriteTransaction tx) {
this.tx = tx;
}
* 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.impl.actors;
import akka.actor.Props;
import akka.actor.ReceiveTimeout;
import akka.actor.UntypedAbstractActor;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataReadOnlyTransaction;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataWriteTransaction;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteTransaction;
import org.opendaylight.netconf.topology.singleton.messages.transactions.WriteActorMessage;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import scala.concurrent.duration.Duration;
/**
- * WriteTransactionActor is an interface to device's {@link DOMDataReadOnlyTransaction} for cluster nodes.
+ * WriteTransactionActor is an interface to device's {@link DOMDataTreeWriteTransaction} for cluster nodes.
*/
public final class WriteTransactionActor extends UntypedAbstractActor {
private static final Logger LOG = LoggerFactory.getLogger(WriteTransactionActor.class);
- private final DOMDataWriteTransaction tx;
+ private final DOMDataTreeWriteTransaction tx;
private final long idleTimeout;
private final WriteAdapter writeAdapter;
- private WriteTransactionActor(final DOMDataWriteTransaction tx, final Duration idleTimeout) {
+ private WriteTransactionActor(final DOMDataTreeWriteTransaction tx, final Duration idleTimeout) {
this.tx = tx;
this.idleTimeout = idleTimeout.toSeconds();
if (this.idleTimeout > 0) {
* @param idleTimeout idle time in seconds, after which transaction is closed automatically
* @return props
*/
- static Props props(final DOMDataWriteTransaction tx, final Duration idleTimeout) {
+ static Props props(final DOMDataTreeWriteTransaction tx, final Duration idleTimeout) {
return Props.create(WriteTransactionActor.class, () -> new WriteTransactionActor(tx, idleTimeout));
}
unhandled(message);
}
}
-
-
}
import akka.pattern.AskTimeoutException;
import akka.pattern.Patterns;
import akka.util.Timeout;
-import com.google.common.base.Optional;
-import com.google.common.util.concurrent.CheckedFuture;
import com.google.common.util.concurrent.FluentFuture;
import com.google.common.util.concurrent.SettableFuture;
import java.util.Objects;
-import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.controller.md.sal.common.api.MappingCheckedFuture;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
+import java.util.Optional;
import org.opendaylight.mdsal.common.api.CommitInfo;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.ReadFailedException;
+import org.opendaylight.mdsal.common.api.TransactionCommitFailedException;
import org.opendaylight.netconf.sal.connect.util.RemoteDeviceId;
import org.opendaylight.netconf.topology.singleton.impl.utils.NetconfTopologyUtils;
import org.opendaylight.netconf.topology.singleton.messages.NormalizedNodeMessage;
private final ExecutionContext executionContext;
private final Timeout askTimeout;
- ActorProxyTransactionFacade(ActorRef masterTxActor, RemoteDeviceId id, ExecutionContext executionContext,
- Timeout askTimeout) {
+ ActorProxyTransactionFacade(final ActorRef masterTxActor, final RemoteDeviceId id,
+ final ExecutionContext executionContext, final Timeout askTimeout) {
this.masterTxActor = Objects.requireNonNull(masterTxActor);
this.id = Objects.requireNonNull(id);
this.executionContext = Objects.requireNonNull(executionContext);
}
@Override
- public CheckedFuture<Optional<NormalizedNode<?, ?>>, ReadFailedException> read(LogicalDatastoreType store,
- YangInstanceIdentifier path) {
+ public void close() {
+ cancel();
+ }
+
+ @Override
+ public FluentFuture<Optional<NormalizedNode<?, ?>>> read(final LogicalDatastoreType store,
+ final YangInstanceIdentifier path) {
LOG.debug("{}: Read {} {} via actor {}", id, store, path, masterTxActor);
final Future<Object> future = Patterns.ask(masterTxActor, new ReadRequest(store, path), askTimeout);
public void onComplete(final Throwable failure, final Object response) {
if (failure != null) {
LOG.debug("{}: Read {} {} failed", id, store, path, failure);
- settableFuture.setException(processFailure(failure));
+
+ final Throwable processedFailure = processFailure(failure);
+ if (processedFailure instanceof ReadFailedException) {
+ settableFuture.setException(processedFailure);
+ } else {
+ settableFuture.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.absent());
+ settableFuture.set(Optional.empty());
return;
}
}
}, executionContext);
- return MappingCheckedFuture.create(settableFuture, ReadFailedException.MAPPER);
+ return settableFuture;
}
@Override
- public CheckedFuture<Boolean, ReadFailedException> exists(LogicalDatastoreType store, YangInstanceIdentifier path) {
+ 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);
public void onComplete(final Throwable failure, final Object response) {
if (failure != null) {
LOG.debug("{}: Exists {} {} failed", id, store, path, failure);
- settableFuture.setException(processFailure(failure));
+
+ final Throwable processedFailure = processFailure(failure);
+ if (processedFailure instanceof ReadFailedException) {
+ settableFuture.setException(processedFailure);
+ } else {
+ settableFuture.setException(new ReadFailedException("Exists of store " + store + " path " + path
+ + " failed", processedFailure));
+ }
return;
}
}
}, executionContext);
- return MappingCheckedFuture.create(settableFuture, ReadFailedException.MAPPER);
+ return settableFuture;
}
@Override
- public void delete(LogicalDatastoreType store, YangInstanceIdentifier path) {
+ public void delete(final LogicalDatastoreType store, final YangInstanceIdentifier path) {
LOG.debug("{}: Delete {} {} via actor {}", id, store, path, masterTxActor);
masterTxActor.tell(new DeleteRequest(store, path), ActorRef.noSender());
}
@Override
- public void put(LogicalDatastoreType store, YangInstanceIdentifier path, NormalizedNode<?, ?> data) {
+ public void put(final LogicalDatastoreType store, final YangInstanceIdentifier path,
+ final NormalizedNode<?, ?> data) {
LOG.debug("{}: Put {} {} via actor {}", id, store, path, masterTxActor);
masterTxActor.tell(new PutRequest(store, new NormalizedNodeMessage(path, data)), ActorRef.noSender());
}
@Override
- public void merge(LogicalDatastoreType store, YangInstanceIdentifier path, NormalizedNode<?, ?> data) {
+ public void merge(final LogicalDatastoreType store, final YangInstanceIdentifier path,
+ final NormalizedNode<?, ?> data) {
LOG.debug("{}: Merge {} {} via actor {}", id, store, path, masterTxActor);
masterTxActor.tell(new MergeRequest(store, new NormalizedNodeMessage(path, data)), ActorRef.noSender());
}
@Override
- public @NonNull FluentFuture<? extends @NonNull CommitInfo> commit() {
+ public FluentFuture<? extends CommitInfo> commit() {
LOG.debug("{}: Commit via actor {}", id, masterTxActor);
final Future<Object> future = Patterns.ask(masterTxActor, new SubmitRequest(), askTimeout);
failure);
}
- private Throwable processFailure(Throwable failure) {
+ private Throwable processFailure(final Throwable failure) {
if (failure instanceof AskTimeoutException) {
return NetconfTopologyUtils.createMasterIsDownException(id, (Exception)failure);
}
*/
package org.opendaylight.netconf.topology.singleton.impl.tx;
-import com.google.common.base.Optional;
-import com.google.common.util.concurrent.CheckedFuture;
import com.google.common.util.concurrent.FluentFuture;
-import com.google.common.util.concurrent.Futures;
import java.util.Objects;
+import java.util.Optional;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.controller.md.sal.common.api.data.AsyncWriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
import org.opendaylight.mdsal.common.api.CommitInfo;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.ReadFailedException;
+import org.opendaylight.mdsal.common.api.TransactionCommitFailedException;
import org.opendaylight.netconf.sal.connect.util.RemoteDeviceId;
+import org.opendaylight.yangtools.util.concurrent.FluentFutures;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.slf4j.Logger;
}
@Override
- public CheckedFuture<Optional<NormalizedNode<?, ?>>, ReadFailedException> read(final LogicalDatastoreType store,
+ public void close() {
+ // No-op
+ }
+
+ @Override
+ public FluentFuture<Optional<NormalizedNode<?, ?>>> read(final LogicalDatastoreType store,
final YangInstanceIdentifier path) {
LOG.debug("{}: Read {} {} - failure", id, store, path, failure);
- return Futures.immediateFailedCheckedFuture(ReadFailedException.MAPPER.apply(
+ return FluentFutures.immediateFailedFluentFuture(ReadFailedException.MAPPER.apply(
failure instanceof Exception ? (Exception)failure : new ReadFailedException("read", failure)));
}
@Override
- public CheckedFuture<Boolean, ReadFailedException> exists(final LogicalDatastoreType store,
+ public FluentFuture<Boolean> exists(final LogicalDatastoreType store,
final YangInstanceIdentifier path) {
LOG.debug("{}: Exists {} {} - failure", id, store, path, failure);
- return Futures.immediateFailedCheckedFuture(ReadFailedException.MAPPER.apply(
+ return FluentFutures.immediateFailedFluentFuture(ReadFailedException.MAPPER.apply(
failure instanceof Exception ? (Exception)failure : new ReadFailedException("read", failure)));
}
@Override
public @NonNull FluentFuture<? extends @NonNull CommitInfo> commit() {
LOG.debug("{}: Commit - failure", id, failure);
- return FluentFuture.from(Futures.immediateFailedFuture(failure instanceof Exception
- ? AsyncWriteTransaction.SUBMIT_EXCEPTION_MAPPER.apply((Exception)failure)
- : new TransactionCommitFailedException("commit", failure)));
+ final TransactionCommitFailedException txCommitEx;
+ if (failure instanceof TransactionCommitFailedException) {
+ txCommitEx = (TransactionCommitFailedException) failure;
+ } else {
+ txCommitEx = new TransactionCommitFailedException("commit", failure);
+ }
+ return FluentFutures.immediateFailedFluentFuture(txCommitEx);
}
}
* 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.impl.tx;
import akka.actor.ActorRef;
import akka.util.Timeout;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataReadOnlyTransaction;
import org.opendaylight.netconf.sal.connect.util.RemoteDeviceId;
import scala.concurrent.ExecutionContext;
import scala.concurrent.Future;
* ProxyReadTransaction uses provided {@link ActorRef} to delegate method calls to master
* {@link org.opendaylight.netconf.topology.singleton.impl.actors.ReadTransactionActor}.
*/
-public class ProxyReadTransaction extends ProxyReadWriteTransaction implements DOMDataReadOnlyTransaction {
+public class ProxyReadTransaction extends ProxyReadWriteTransaction {
public ProxyReadTransaction(final RemoteDeviceId id, final Future<Object> masterTxActorFuture,
final ExecutionContext executionContext, final Timeout askTimeout) {
super(id, masterTxActorFuture, executionContext, askTimeout);
}
-
- @Override
- public void close() {
- // noop
- }
}
import akka.actor.ActorRef;
import akka.dispatch.OnComplete;
import akka.util.Timeout;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
-import com.google.common.util.concurrent.CheckedFuture;
import com.google.common.util.concurrent.FluentFuture;
import com.google.common.util.concurrent.SettableFuture;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
+import java.util.Optional;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.function.Consumer;
import javax.annotation.concurrent.GuardedBy;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.controller.md.sal.common.api.MappingCheckedFuture;
-import org.opendaylight.controller.md.sal.common.api.data.AsyncWriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataReadWriteTransaction;
import org.opendaylight.mdsal.common.api.CommitInfo;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeReadWriteTransaction;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteTransaction;
import org.opendaylight.netconf.sal.connect.util.RemoteDeviceId;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
* ProxyReadWriteTransaction uses provided {@link ActorRef} to delegate method calls to master
* {@link org.opendaylight.netconf.topology.singleton.impl.actors.ReadWriteTransactionActor}.
*/
-public class ProxyReadWriteTransaction implements DOMDataReadWriteTransaction {
+public class ProxyReadWriteTransaction implements DOMDataTreeReadWriteTransaction {
private static final Logger LOG = LoggerFactory.getLogger(ProxyReadWriteTransaction.class);
private final RemoteDeviceId id;
return false;
}
- processTransactionOperation(AsyncWriteTransaction::cancel);
+ processTransactionOperation(DOMDataTreeWriteTransaction::cancel);
return true;
}
@Override
- public CheckedFuture<Optional<NormalizedNode<?, ?>>, ReadFailedException> read(final LogicalDatastoreType store,
+ public void close() {
+ cancel();
+ }
+
+ @Override
+ public FluentFuture<Optional<NormalizedNode<?, ?>>> read(final LogicalDatastoreType store,
final YangInstanceIdentifier path) {
LOG.debug("{}: Read {} {}", id, store, path);
final SettableFuture<Optional<NormalizedNode<?, ?>>> returnFuture = SettableFuture.create();
processTransactionOperation(facade -> returnFuture.setFuture(facade.read(store, path)));
- return MappingCheckedFuture.create(returnFuture, ReadFailedException.MAPPER);
+ return returnFuture;
}
@Override
- public CheckedFuture<Boolean, ReadFailedException> exists(final LogicalDatastoreType store,
+ public FluentFuture<Boolean> exists(final LogicalDatastoreType store,
final YangInstanceIdentifier path) {
LOG.debug("{}: Exists {} {}", id, store, path);
final SettableFuture<Boolean> returnFuture = SettableFuture.create();
processTransactionOperation(facade -> returnFuture.setFuture(facade.exists(store, path)));
- return MappingCheckedFuture.create(returnFuture, ReadFailedException.MAPPER);
+ return returnFuture;
}
@Override
*/
package org.opendaylight.netconf.topology.singleton.impl.tx;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataReadWriteTransaction;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeReadWriteTransaction;
/**
* Interfaces with a transaction back-end.
*
* @author Thomas Pantelis
*/
-interface ProxyTransactionFacade extends DOMDataReadWriteTransaction {
+interface ProxyTransactionFacade extends DOMDataTreeReadWriteTransaction {
}
* 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.impl.utils;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcException;
+import org.opendaylight.mdsal.dom.api.DOMRpcException;
public class ClusteringRpcException extends DOMRpcException {
private static final long serialVersionUID = 1L;
- public ClusteringRpcException(String message) {
+ public ClusteringRpcException(final String message) {
super(message);
}
- public ClusteringRpcException(String message, Throwable cause) {
+ public ClusteringRpcException(final String message, final Throwable cause) {
super(message, cause);
}
}
import io.netty.util.concurrent.EventExecutor;
import java.util.concurrent.ScheduledExecutorService;
import org.opendaylight.aaa.encrypt.AAAEncryptionService;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.dom.api.DOMRpcProviderService;
import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceProvider;
import org.opendaylight.netconf.client.NetconfClientDispatcher;
import org.opendaylight.netconf.sal.connect.netconf.NetconfDevice;
public class NetconfTopologySetup {
private final ClusterSingletonServiceProvider clusterSingletonServiceProvider;
- private final RpcProviderRegistry rpcProviderRegistry;
+ private final DOMRpcProviderService rpcProviderRegistry;
private final DataBroker dataBroker;
private final InstanceIdentifier<Node> instanceIdentifier;
private final Node node;
return clusterSingletonServiceProvider;
}
- public RpcProviderRegistry getRpcProviderRegistry() {
+ public DOMRpcProviderService getRpcProviderRegistry() {
return rpcProviderRegistry;
}
public static class NetconfTopologySetupBuilder {
private ClusterSingletonServiceProvider clusterSingletonServiceProvider;
- private RpcProviderRegistry rpcProviderRegistry;
+ private DOMRpcProviderService rpcProviderRegistry;
private DataBroker dataBroker;
private InstanceIdentifier<Node> instanceIdentifier;
private Node node;
return this;
}
- private RpcProviderRegistry getRpcProviderRegistry() {
+ private DOMRpcProviderService getRpcProviderRegistry() {
return rpcProviderRegistry;
}
- public NetconfTopologySetupBuilder setRpcProviderRegistry(final RpcProviderRegistry rpcProviderRegistry) {
+ public NetconfTopologySetupBuilder setRpcProviderRegistry(final DOMRpcProviderService rpcProviderRegistry) {
this.rpcProviderRegistry = rpcProviderRegistry;
return this;
}
* 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.util.List;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataBroker;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcService;
+import org.opendaylight.mdsal.dom.api.DOMDataBroker;
+import org.opendaylight.mdsal.dom.api.DOMRpcService;
import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
/**
* 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.transactions;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
public class DeleteRequest implements WriteActorMessage {
* 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.transactions;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
public class ExistsRequest implements ReadActorMessage {
package org.opendaylight.netconf.topology.singleton.messages.transactions;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netconf.topology.singleton.messages.NormalizedNodeMessage;
public class MergeRequest implements WriteActorMessage {
* 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.transactions;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netconf.topology.singleton.messages.NormalizedNodeMessage;
public class PutRequest implements WriteActorMessage {
* 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.transactions;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
public class ReadRequest implements ReadActorMessage {
odl:use-default-for-reference-types="true">
<reference id="dataBroker"
- interface="org.opendaylight.controller.md.sal.binding.api.DataBroker"/>
+ interface="org.opendaylight.mdsal.binding.api.DataBroker"/>
<reference id="rpcRegistry"
- interface="org.opendaylight.controller.sal.binding.api.RpcProviderRegistry"/>
+ interface="org.opendaylight.mdsal.dom.api.DOMRpcProviderService"/>
<reference id="clusterSingletonService"
interface="org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceProvider"/>
<reference id="keepAliveExecutor"
interface="org.opendaylight.netconf.client.NetconfClientDispatcher"
odl:type="netconf-client-dispatcher"/>
<reference id="mountPointService"
- interface="org.opendaylight.controller.md.sal.dom.api.DOMMountPointService"
+ interface="org.opendaylight.mdsal.dom.api.DOMMountPointService"
odl:type="default"/>
<odl:clustered-app-config
id="singletonConfig"
import akka.actor.ActorSystem;
import akka.testkit.javadsl.TestKit;
import akka.util.Timeout;
-import com.google.common.base.Optional;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableSet;
-import com.google.common.util.concurrent.CheckedFuture;
+import com.google.common.util.concurrent.FluentFuture;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.MoreExecutors;
import java.util.Collections;
import java.util.Iterator;
import java.util.Map.Entry;
+import java.util.Optional;
import java.util.Set;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import org.opendaylight.controller.cluster.ActorSystemProvider;
import org.opendaylight.controller.config.threadpool.ScheduledThreadPool;
import org.opendaylight.controller.config.threadpool.ThreadPool;
-import org.opendaylight.controller.md.sal.binding.api.BindingTransactionChain;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
-import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
-import org.opendaylight.controller.md.sal.binding.test.AbstractConcurrentDataBrokerTest;
-import org.opendaylight.controller.md.sal.common.api.data.AsyncTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionChain;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionChainListener;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataBroker;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataReadTransaction;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataReadWriteTransaction;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataWriteTransaction;
-import org.opendaylight.controller.md.sal.dom.api.DOMMountPoint;
-import org.opendaylight.controller.md.sal.dom.api.DOMMountPointService;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcException;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcIdentifier;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcImplementation;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcResult;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcService;
-import org.opendaylight.controller.md.sal.dom.api.DOMService;
-import org.opendaylight.controller.md.sal.dom.broker.impl.DOMRpcRouter;
-import org.opendaylight.controller.md.sal.dom.broker.impl.mount.DOMMountPointServiceImpl;
-import org.opendaylight.controller.md.sal.dom.spi.DefaultDOMRpcResult;
-import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
+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.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.binding.generator.impl.ModuleInfoBackedContext;
import org.opendaylight.mdsal.binding.spec.reflect.BindingReflections;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.dom.api.DOMDataBroker;
+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.DOMMountPoint;
import org.opendaylight.mdsal.dom.api.DOMMountPointListener;
+import org.opendaylight.mdsal.dom.api.DOMMountPointService;
+import org.opendaylight.mdsal.dom.api.DOMRpcIdentifier;
+import org.opendaylight.mdsal.dom.api.DOMRpcImplementation;
+import org.opendaylight.mdsal.dom.api.DOMRpcProviderService;
+import org.opendaylight.mdsal.dom.api.DOMRpcResult;
+import org.opendaylight.mdsal.dom.api.DOMRpcService;
+import org.opendaylight.mdsal.dom.api.DOMService;
+import org.opendaylight.mdsal.dom.broker.DOMMountPointServiceImpl;
+import org.opendaylight.mdsal.dom.broker.DOMRpcRouter;
+import org.opendaylight.mdsal.dom.spi.DefaultDOMRpcResult;
import org.opendaylight.mdsal.eos.dom.simple.SimpleDOMEntityOwnershipService;
import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceProvider;
import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceRegistration;
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.util.concurrent.FluentFutures;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.binding.YangModuleInfo;
import org.opendaylight.yangtools.yang.common.QName;
* @author Thomas Pantelis
*/
public class MountPointEndToEndTest {
- private static Logger LOG = LoggerFactory.getLogger(MountPointEndToEndTest.class);
+ private static final Logger LOG = LoggerFactory.getLogger(MountPointEndToEndTest.class);
private static final String TOP_MODULE_NAME = "opendaylight-mdsal-list-test";
private static final String ACTOR_SYSTEM_NAME = "test";
private static final InstanceIdentifier<Node> NODE_INSTANCE_ID = NetconfTopologyUtils.createTopologyNodeListPath(
new NodeKey(NODE_ID), TOPOLOGY_ID);
- @Mock private RpcProviderRegistry mockRpcProviderRegistry;
+ @Mock private DOMRpcProviderService mockRpcProviderRegistry;
@Mock private NetconfClientDispatcher mockClientDispatcher;
@Mock private AAAEncryptionService mockEncryptionService;
@Mock private ThreadPool mockThreadPool;
private ActorSystem slaveSystem;
private NetconfTopologyManager slaveNetconfTopologyManager;
private final SettableFuture<NetconfTopologyContext> slaveNetconfTopologyContextFuture = SettableFuture.create();
- private BindingTransactionChain slaveTxChain;
+ private TransactionChain slaveTxChain;
private final EventExecutor eventExecutor = GlobalEventExecutor.INSTANCE;
private final Config config = new ConfigBuilder().setWriteTransactionIdleTimeout(0).build();
putTopRpcSchemaPath = findRpcDefinition("put-top").getPath();
getTopRpcSchemaPath = findRpcDefinition("get-top").getPath();
- deviceRpcService.registerRpcImplementation(topRpcImplementation,
+ deviceRpcService.getRpcProviderService().registerRpcImplementation(topRpcImplementation,
DOMRpcIdentifier.create(putTopRpcSchemaPath), DOMRpcIdentifier.create(getTopRpcSchemaPath));
setupMaster();
slaveTxChain = slaveDataBroker.createTransactionChain(new TransactionChainListener() {
@Override
- public void onTransactionChainSuccessful(final TransactionChain<?, ?> chain) {
+ public void onTransactionChainSuccessful(final TransactionChain chain) {
}
@Override
- public void onTransactionChainFailed(final TransactionChain<?, ?> chain,
- final AsyncTransaction<?, ?> transaction, final Throwable cause) {
+ public void onTransactionChainFailed(final TransactionChain chain, final Transaction transaction,
+ final Throwable cause) {
LOG.error("Slave transaction chain failed", cause);
}
});
final MasterSalFacade masterSalFacade = masterSalFacadeFuture.get(5, TimeUnit.SECONDS);
masterSalFacade.onDeviceConnected(deviceSchemaContext,
- NetconfSessionPreferences.fromStrings(Collections.emptyList()), deviceRpcService);
+ NetconfSessionPreferences.fromStrings(Collections.emptyList()), deviceRpcService.getRpcService());
DOMMountPoint masterMountPoint = awaitMountPoint(masterMountPointService);
// This is essentially what happens in a clustered environment but we'll use a DTCL here.
masterDataBroker.registerDataTreeChangeListener(
- new DataTreeIdentifier<>(LogicalDatastoreType.OPERATIONAL, NODE_INSTANCE_ID), changes -> {
+ DataTreeIdentifier.create(LogicalDatastoreType.OPERATIONAL, NODE_INSTANCE_ID), changes -> {
final WriteTransaction slaveTx = slaveTxChain.newWriteOnlyTransaction();
for (DataTreeModification<Node> dataTreeModification : changes) {
DataObjectModification<Node> rootNode = dataTreeModification.getRootNode();
MasterSalFacade masterSalFacade = masterSalFacadeFuture.get(5, TimeUnit.SECONDS);
masterSalFacade.onDeviceConnected(deviceSchemaContext,
- NetconfSessionPreferences.fromStrings(Collections.emptyList()), deviceRpcService);
+ NetconfSessionPreferences.fromStrings(Collections.emptyList()), deviceRpcService.getRpcService());
verify(masterMountPointListener, timeout(5000)).onMountPointCreated(yangNodeInstanceId);
awaitMountPointNotPresent(masterMountPointService);
await().atMost(5, TimeUnit.SECONDS).until(() -> {
- try (ReadOnlyTransaction readTx = masterDataBroker.newReadOnlyTransaction()) {
+ try (ReadTransaction readTx = masterDataBroker.newReadOnlyTransaction()) {
Optional<Node> node = readTx.read(LogicalDatastoreType.OPERATIONAL,
NODE_INSTANCE_ID).get(5, TimeUnit.SECONDS);
assertTrue(node.isPresent());
private void testRpc(final DOMRpcService domRpcService, final SchemaPath schemaPath,
final NormalizedNode<?, ?> input, final DOMRpcResult result) throws InterruptedException,
ExecutionException, TimeoutException {
- final DOMRpcResult actual = invokeRpc(domRpcService, schemaPath, input, Futures.immediateCheckedFuture(result));
+ final FluentFuture<DOMRpcResult> future = result == null ? FluentFutures.immediateNullFluentFuture()
+ : FluentFutures.immediateFluentFuture(result);
+ final DOMRpcResult actual = invokeRpc(domRpcService, schemaPath, input, future);
if (result == null) {
assertNull(actual);
return;
private void testFailedRpc(final DOMRpcService domRpcService, final SchemaPath schemaPath,
final NormalizedNode<?, ?> input) throws InterruptedException, TimeoutException {
try {
- invokeRpc(domRpcService, schemaPath, input, Futures.immediateFailedCheckedFuture(
+ invokeRpc(domRpcService, schemaPath, input, FluentFutures.immediateFailedFluentFuture(
new ClusteringRpcException("mock")));
fail("Expected exception");
} catch (ExecutionException e) {
}
private DOMRpcResult invokeRpc(final DOMRpcService domRpcService, final SchemaPath schemaPath,
- final NormalizedNode<?, ?> input, final CheckedFuture<DOMRpcResult, DOMRpcException> returnFuture)
+ final NormalizedNode<?, ?> input, final FluentFuture<DOMRpcResult> returnFuture)
throws InterruptedException, ExecutionException, TimeoutException {
topRpcImplementation.init(returnFuture);
final ListenableFuture<DOMRpcResult> resultFuture = domRpcService.invokeRpc(schemaPath, input);
private static void testDOMDataBrokerOperations(final DOMDataBroker dataBroker)
throws InterruptedException, ExecutionException, TimeoutException {
- DOMDataWriteTransaction writeTx = dataBroker.newWriteOnlyTransaction();
+ DOMDataTreeWriteTransaction writeTx = dataBroker.newWriteOnlyTransaction();
final ContainerNode topNode = Builders.containerBuilder()
.withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(Top.QNAME)).build();
writeTx.delete(LogicalDatastoreType.CONFIGURATION, topPath);
writeTx.commit().get(5, TimeUnit.SECONDS);
- DOMDataReadWriteTransaction readTx = dataBroker.newReadWriteTransaction();
+ DOMDataTreeReadWriteTransaction readTx = dataBroker.newReadWriteTransaction();
assertFalse(readTx.exists(LogicalDatastoreType.CONFIGURATION, topPath).get(5, TimeUnit.SECONDS));
assertTrue(readTx.cancel());
}
writeTx.commit().get(5, TimeUnit.SECONDS);
}
- private static void verifyDataInStore(final DOMDataReadTransaction readTx, final YangInstanceIdentifier path,
+ private static void verifyDataInStore(final DOMDataTreeReadTransaction readTx, final YangInstanceIdentifier path,
final NormalizedNode<?, ?> expNode) throws InterruptedException, ExecutionException, TimeoutException {
final Optional<NormalizedNode<?, ?>> read = readTx.read(LogicalDatastoreType.CONFIGURATION, path)
.get(5, TimeUnit.SECONDS);
private static void verifyTopologyNodesCreated(final DataBroker dataBroker) {
await().atMost(5, TimeUnit.SECONDS).until(() -> {
- try (ReadOnlyTransaction readTx = dataBroker.newReadOnlyTransaction()) {
+ try (ReadTransaction readTx = dataBroker.newReadOnlyTransaction()) {
Optional<Topology> configTopology = readTx.read(LogicalDatastoreType.CONFIGURATION,
NetconfTopologyUtils.createTopologyListPath(TOPOLOGY_ID)).get(3, TimeUnit.SECONDS);
Optional<Topology> operTopology = readTx.read(LogicalDatastoreType.OPERATIONAL,
private static class TopDOMRpcImplementation implements DOMRpcImplementation {
private volatile SettableFuture<Entry<DOMRpcIdentifier, NormalizedNode<?, ?>>> rpcInvokedFuture;
- private volatile CheckedFuture<DOMRpcResult, DOMRpcException> returnFuture;
+ private volatile FluentFuture<DOMRpcResult> returnFuture;
@Override
- public CheckedFuture<DOMRpcResult, DOMRpcException> invokeRpc(final DOMRpcIdentifier rpc,
+ public FluentFuture<DOMRpcResult> invokeRpc(final DOMRpcIdentifier rpc,
final NormalizedNode<?, ?> input) {
rpcInvokedFuture.set(new SimpleEntry<>(rpc, input));
return returnFuture;
}
- void init(final CheckedFuture<DOMRpcResult, DOMRpcException> retFuture) {
+ void init(final FluentFuture<DOMRpcResult> retFuture) {
this.returnFuture = retFuture;
rpcInvokedFuture = SettableFuture.create();
}
* 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.impl;
import static java.nio.charset.StandardCharsets.UTF_8;
import org.mockito.ArgumentCaptor;
import org.mockito.Mock;
import org.opendaylight.controller.cluster.schema.provider.impl.YangTextSchemaSourceSerializationProxy;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataBroker;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataReadOnlyTransaction;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataReadWriteTransaction;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataWriteTransaction;
-import org.opendaylight.controller.md.sal.dom.api.DOMMountPoint;
-import org.opendaylight.controller.md.sal.dom.api.DOMMountPointService;
-import org.opendaylight.controller.md.sal.dom.api.DOMNotificationService;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcException;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcResult;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcService;
-import org.opendaylight.controller.md.sal.dom.spi.DefaultDOMRpcResult;
+import org.opendaylight.mdsal.dom.api.DOMDataBroker;
+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.DOMMountPoint;
+import org.opendaylight.mdsal.dom.api.DOMMountPointService;
+import org.opendaylight.mdsal.dom.api.DOMNotificationService;
+import org.opendaylight.mdsal.dom.api.DOMRpcException;
+import org.opendaylight.mdsal.dom.api.DOMRpcResult;
+import org.opendaylight.mdsal.dom.api.DOMRpcService;
+import org.opendaylight.mdsal.dom.spi.DefaultDOMRpcResult;
import org.opendaylight.netconf.sal.connect.util.RemoteDeviceId;
import org.opendaylight.netconf.topology.singleton.impl.actors.NetconfNodeActor;
import org.opendaylight.netconf.topology.singleton.impl.utils.ClusteringRpcException;
@Test
public void testSlaveNewTransactionRequests() {
- doReturn(mock(DOMDataReadOnlyTransaction.class)).when(mockDOMDataBroker).newReadOnlyTransaction();
- doReturn(mock(DOMDataReadWriteTransaction.class)).when(mockDOMDataBroker).newReadWriteTransaction();
- doReturn(mock(DOMDataWriteTransaction.class)).when(mockDOMDataBroker).newWriteOnlyTransaction();
+ doReturn(mock(DOMDataTreeReadTransaction.class)).when(mockDOMDataBroker).newReadOnlyTransaction();
+ doReturn(mock(DOMDataTreeReadWriteTransaction.class)).when(mockDOMDataBroker).newReadWriteTransaction();
+ doReturn(mock(DOMDataTreeWriteTransaction.class)).when(mockDOMDataBroker).newWriteOnlyTransaction();
initializeMaster(Collections.emptyList());
registerSlaveMountPoint();
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.verifyNoMoreInteractions;
import static org.mockito.MockitoAnnotations.initMocks;
-import static org.opendaylight.controller.md.sal.binding.api.DataObjectModification.ModificationType.DELETE;
-import static org.opendaylight.controller.md.sal.binding.api.DataObjectModification.ModificationType.SUBTREE_MODIFIED;
-import static org.opendaylight.controller.md.sal.binding.api.DataObjectModification.ModificationType.WRITE;
+import static org.opendaylight.mdsal.binding.api.DataObjectModification.ModificationType.DELETE;
+import static org.opendaylight.mdsal.binding.api.DataObjectModification.ModificationType.SUBTREE_MODIFIED;
+import static org.opendaylight.mdsal.binding.api.DataObjectModification.ModificationType.WRITE;
import akka.actor.ActorSystem;
import akka.actor.Props;
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mock;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataBroker;
-import org.opendaylight.controller.md.sal.dom.api.DOMMountPoint;
-import org.opendaylight.controller.md.sal.dom.api.DOMMountPointService;
-import org.opendaylight.controller.md.sal.dom.api.DOMNotificationService;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcService;
+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.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.dom.api.DOMDataBroker;
+import org.opendaylight.mdsal.dom.api.DOMMountPoint;
+import org.opendaylight.mdsal.dom.api.DOMMountPointService;
+import org.opendaylight.mdsal.dom.api.DOMNotificationService;
+import org.opendaylight.mdsal.dom.api.DOMRpcService;
import org.opendaylight.netconf.sal.connect.api.NetconfDeviceSchemasResolver;
import org.opendaylight.netconf.sal.connect.netconf.NetconfDevice;
import org.opendaylight.netconf.sal.connect.util.RemoteDeviceId;
doReturn(node).when(mockDataObjModification).getDataAfter();
netconfNodeManager.onDataTreeChanged(Collections.singletonList(
- new NetconfTopologyManagerTest.CustomTreeModification(new DataTreeIdentifier<>(
+ new NetconfTopologyManagerTest.CustomTreeModification(DataTreeIdentifier.create(
LogicalDatastoreType.OPERATIONAL, nodeListPath), mockDataObjModification)));
verify(mockMountPointBuilder, timeout(5000)).register();
doReturn(null).when(mockDataObjModification).getDataAfter();
netconfNodeManager.onDataTreeChanged(Collections.singletonList(
- new NetconfTopologyManagerTest.CustomTreeModification(new DataTreeIdentifier<>(
+ new NetconfTopologyManagerTest.CustomTreeModification(DataTreeIdentifier.create(
LogicalDatastoreType.OPERATIONAL, nodeListPath), mockDataObjModification)));
verify(mockMountPointReg, timeout(5000)).close();
doReturn(node).when(mockDataObjModification).getDataAfter();
netconfNodeManager.onDataTreeChanged(Collections.singletonList(
- new NetconfTopologyManagerTest.CustomTreeModification(new DataTreeIdentifier<>(
+ new NetconfTopologyManagerTest.CustomTreeModification(DataTreeIdentifier.create(
LogicalDatastoreType.OPERATIONAL, nodeListPath), mockDataObjModification)));
verify(mockMountPointBuilder, timeout(5000)).register();
doReturn(node).when(mockDataObjModification).getDataBefore();
netconfNodeManager.onDataTreeChanged(Collections.singletonList(
- new NetconfTopologyManagerTest.CustomTreeModification(new DataTreeIdentifier<>(
+ new NetconfTopologyManagerTest.CustomTreeModification(DataTreeIdentifier.create(
LogicalDatastoreType.OPERATIONAL, nodeListPath), mockDataObjModification)));
verify(mockMountPointReg, timeout(5000)).close();
doReturn(updatedNode).when(mockDataObjModification).getDataAfter();
netconfNodeManager.onDataTreeChanged(Collections.singletonList(
- new NetconfTopologyManagerTest.CustomTreeModification(new DataTreeIdentifier<>(
+ new NetconfTopologyManagerTest.CustomTreeModification(DataTreeIdentifier.create(
LogicalDatastoreType.OPERATIONAL, nodeListPath), mockDataObjModification)));
verify(mockMountPointReg, timeout(5000)).close();
// First try the registration where the perceived master hasn't been initialized as the master.
netconfNodeManager.onDataTreeChanged(Collections.singletonList(
- new NetconfTopologyManagerTest.CustomTreeModification(new DataTreeIdentifier<>(
+ new NetconfTopologyManagerTest.CustomTreeModification(DataTreeIdentifier.create(
LogicalDatastoreType.OPERATIONAL, nodeListPath), mockDataObjModification)));
verify(mockMountPointBuilder, after(1000).never()).register();
yangTextSchemaSourceRequestFuture);
netconfNodeManager.onDataTreeChanged(Collections.singletonList(
- new NetconfTopologyManagerTest.CustomTreeModification(new DataTreeIdentifier<>(
+ new NetconfTopologyManagerTest.CustomTreeModification(DataTreeIdentifier.create(
LogicalDatastoreType.OPERATIONAL, nodeListPath), mockDataObjModification)));
yangTextSchemaSourceRequestFuture.get(5, TimeUnit.SECONDS);
askForMasterMountPointFuture);
netconfNodeManager.onDataTreeChanged(Collections.singletonList(
- new NetconfTopologyManagerTest.CustomTreeModification(new DataTreeIdentifier<>(
+ new NetconfTopologyManagerTest.CustomTreeModification(DataTreeIdentifier.create(
LogicalDatastoreType.OPERATIONAL, nodeListPath), mockDataObjModification)));
askForMasterMountPointFuture.get(5, TimeUnit.SECONDS);
private static class TestMasterActor extends NetconfNodeActor {
final Map<Class<?>, CompletableFuture<? extends Object>> messagesToDrop = new ConcurrentHashMap<>();
- TestMasterActor(NetconfTopologySetup setup, RemoteDeviceId deviceId, Timeout actorResponseWaitTime,
- DOMMountPointService mountPointService) {
+ TestMasterActor(final NetconfTopologySetup setup, final RemoteDeviceId deviceId,
+ final Timeout actorResponseWaitTime, final DOMMountPointService mountPointService) {
super(setup, deviceId, setup.getSchemaResourcesDTO().getSchemaRegistry(),
setup.getSchemaResourcesDTO().getSchemaRepository(), actorResponseWaitTime, mountPointService);
}
@SuppressWarnings({ "rawtypes", "unchecked" })
@Override
- public void handleReceive(Object message) {
+ public void handleReceive(final Object message) {
CompletableFuture dropFuture = messagesToDrop.remove(message.getClass());
if (dropFuture != null) {
dropFuture.complete(message);
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.verifyNoMoreInteractions;
import static org.mockito.MockitoAnnotations.initMocks;
-import static org.opendaylight.controller.md.sal.binding.api.DataObjectModification.ModificationType.DELETE;
-import static org.opendaylight.controller.md.sal.binding.api.DataObjectModification.ModificationType.SUBTREE_MODIFIED;
-import static org.opendaylight.controller.md.sal.binding.api.DataObjectModification.ModificationType.WRITE;
+import static org.opendaylight.mdsal.binding.api.DataObjectModification.ModificationType.DELETE;
+import static org.opendaylight.mdsal.binding.api.DataObjectModification.ModificationType.SUBTREE_MODIFIED;
+import static org.opendaylight.mdsal.binding.api.DataObjectModification.ModificationType.WRITE;
import akka.util.Timeout;
-import com.google.common.base.Optional;
import com.google.common.collect.ImmutableSet;
import io.netty.util.concurrent.EventExecutor;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
import java.util.Objects;
+import java.util.Optional;
import java.util.Set;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.TimeUnit;
import java.util.function.Function;
-import javax.annotation.Nonnull;
import org.junit.Before;
import org.junit.Test;
import org.mockito.ArgumentCaptor;
import org.opendaylight.controller.cluster.ActorSystemProvider;
import org.opendaylight.controller.config.threadpool.ScheduledThreadPool;
import org.opendaylight.controller.config.threadpool.ThreadPool;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
-import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
-import org.opendaylight.controller.md.sal.binding.test.ConstantSchemaAbstractDataBrokerTest;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.dom.api.DOMMountPointService;
-import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
+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.dom.adapter.test.AbstractDataBrokerTest;
import org.opendaylight.mdsal.binding.spec.reflect.BindingReflections;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.dom.api.DOMMountPointService;
+import org.opendaylight.mdsal.dom.api.DOMRpcProviderService;
import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceProvider;
import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceRegistration;
import org.opendaylight.mdsal.singleton.common.api.ServiceGroupIdentifier;
public void setUp() throws Exception {
initMocks(this);
- ConstantSchemaAbstractDataBrokerTest dataBrokerTest = new ConstantSchemaAbstractDataBrokerTest(false) {
+ AbstractDataBrokerTest dataBrokerTest = new AbstractDataBrokerTest() {
@Override
protected Set<YangModuleInfo> getModuleInfos() throws Exception {
return ImmutableSet.of(BindingReflections.getModuleInfo(NetworkTopology.class),
dataBrokerTest.setup();
dataBroker = spy(dataBrokerTest.getDataBroker());
- final RpcProviderRegistry rpcProviderRegistry = mock(RpcProviderRegistry.class);
+ final DOMRpcProviderService rpcProviderRegistry = mock(DOMRpcProviderService.class);
final ScheduledThreadPool keepaliveExecutor = mock(ScheduledThreadPool.class);
final ThreadPool processingThreadPool = mock(ThreadPool.class);
final ExecutorService processingService = mock(ExecutorService.class);
netconfTopologyManager.init();
await().atMost(5, TimeUnit.SECONDS).until(() -> {
- ReadOnlyTransaction readTx = dataBroker.newReadOnlyTransaction();
+ ReadTransaction readTx = dataBroker.newReadOnlyTransaction();
Optional<Topology> config = readTx.read(LogicalDatastoreType.CONFIGURATION,
NetconfTopologyUtils.createTopologyListPath(TOPOLOGY_ID)).get(3, TimeUnit.SECONDS);
Optional<Topology> oper = readTx.read(LogicalDatastoreType.OPERATIONAL,
// verify registration is called with right parameters
verify(dataBroker).registerDataTreeChangeListener(
- new DataTreeIdentifier<>(LogicalDatastoreType.CONFIGURATION, NetconfTopologyUtils
+ DataTreeIdentifier.create(LogicalDatastoreType.CONFIGURATION, NetconfTopologyUtils
.createTopologyListPath(TOPOLOGY_ID).child(Node.class)), netconfTopologyManager);
netconfTopologyManager.close();
.registerClusterSingletonService(mockContext2);
netconfTopologyManager.onDataTreeChanged(Arrays.asList(
- new CustomTreeModification(new DataTreeIdentifier<>(LogicalDatastoreType.CONFIGURATION,
+ new CustomTreeModification(DataTreeIdentifier.create(LogicalDatastoreType.CONFIGURATION,
nodeInstanceId1), dataObjectModification1),
- new CustomTreeModification(new DataTreeIdentifier<>(LogicalDatastoreType.CONFIGURATION,
+ new CustomTreeModification(DataTreeIdentifier.create(LogicalDatastoreType.CONFIGURATION,
nodeInstanceId2), dataObjectModification2)));
verify(clusterSingletonServiceProvider).registerClusterSingletonService(mockContext1);
doNothing().when(mockContext2).refresh(any());
netconfTopologyManager.onDataTreeChanged(Arrays.asList(
- new CustomTreeModification(new DataTreeIdentifier<>(LogicalDatastoreType.CONFIGURATION,
+ new CustomTreeModification(DataTreeIdentifier.create(LogicalDatastoreType.CONFIGURATION,
nodeInstanceId1), dataObjectModification1),
- new CustomTreeModification(new DataTreeIdentifier<>(LogicalDatastoreType.CONFIGURATION,
+ new CustomTreeModification(DataTreeIdentifier.create(LogicalDatastoreType.CONFIGURATION,
nodeInstanceId2), dataObjectModification2)));
ArgumentCaptor<NetconfTopologySetup> mockContext1Setup = ArgumentCaptor.forClass(NetconfTopologySetup.class);
doReturn(null).when(dataObjectModification1).getDataAfter();
netconfTopologyManager.onDataTreeChanged(Arrays.asList(
- new CustomTreeModification(new DataTreeIdentifier<>(LogicalDatastoreType.CONFIGURATION,
+ new CustomTreeModification(DataTreeIdentifier.create(LogicalDatastoreType.CONFIGURATION,
nodeInstanceId1), dataObjectModification1)));
verify(mockClusterRegistration1).close();
});
netconfTopologyManager.onDataTreeChanged(Arrays.asList(
- new CustomTreeModification(new DataTreeIdentifier<>(LogicalDatastoreType.CONFIGURATION,
+ new CustomTreeModification(DataTreeIdentifier.create(LogicalDatastoreType.CONFIGURATION,
nodeInstanceId1), dataObjectModification1)));
verify(clusterSingletonServiceProvider, times(2)).registerClusterSingletonService(newMockContext1);
netconfTopologyManager.init();
netconfTopologyManager.onDataTreeChanged(Arrays.asList(
- new CustomTreeModification(new DataTreeIdentifier<>(LogicalDatastoreType.CONFIGURATION,
+ new CustomTreeModification(DataTreeIdentifier.create(LogicalDatastoreType.CONFIGURATION,
nodeInstanceId), dataObjectModification)));
verify(clusterSingletonServiceProvider, times(3)).registerClusterSingletonService(mockContext);
this.rootNode = rootNode;
}
- @Nonnull
@Override
public DataTreeIdentifier<Node> getRootPath() {
return rootPath;
}
- @Nonnull
@Override
public DataObjectModification<Node> getRootNode() {
return rootNode;
import java.util.concurrent.TimeUnit;
import org.junit.AfterClass;
import org.junit.Test;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataReadOnlyTransaction;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataReadWriteTransaction;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataWriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeReadTransaction;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeReadWriteTransaction;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteTransaction;
import org.opendaylight.netconf.sal.connect.util.RemoteDeviceId;
import org.opendaylight.netconf.topology.singleton.messages.transactions.DeleteRequest;
import org.opendaylight.netconf.topology.singleton.messages.transactions.NewReadTransactionRequest;
@Test
public void testNewReadOnlyTransaction() {
- final DOMDataReadOnlyTransaction tx = proxy.newReadOnlyTransaction();
+ final DOMDataTreeReadTransaction tx = proxy.newReadOnlyTransaction();
masterActor.expectMsgClass(NewReadTransactionRequest.class);
masterActor.reply(new Success(masterActor.ref()));
@Test
public void testNewWriteOnlyTransaction() {
- final DOMDataWriteTransaction tx = proxy.newWriteOnlyTransaction();
+ final DOMDataTreeWriteTransaction tx = proxy.newWriteOnlyTransaction();
masterActor.expectMsgClass(NewWriteTransactionRequest.class);
masterActor.reply(new Success(masterActor.ref()));
@Test
public void testNewReadWriteTransaction() {
- final DOMDataReadWriteTransaction tx = proxy.newReadWriteTransaction();
+ final DOMDataTreeReadWriteTransaction tx = proxy.newReadWriteTransaction();
masterActor.expectMsgClass(NewReadWriteTransactionRequest.class);
masterActor.reply(new Success(masterActor.ref()));
@Test
public void testGetSupportedExtensions() {
- assertTrue(proxy.getSupportedExtensions().isEmpty());
+ assertTrue(proxy.getExtensions().isEmpty());
}
}
* 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.impl;
import static org.junit.Assert.assertEquals;
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mock;
-import org.opendaylight.controller.md.sal.binding.api.BindingTransactionChain;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionChainListener;
-import org.opendaylight.controller.md.sal.dom.api.DOMMountPointService;
-import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
+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.LogicalDatastoreType;
+import org.opendaylight.mdsal.dom.api.DOMMountPointService;
+import org.opendaylight.mdsal.dom.api.DOMRpcProviderService;
import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceProvider;
import org.opendaylight.netconf.client.NetconfClientDispatcher;
import org.opendaylight.netconf.client.NetconfClientSessionListener;
private DataBroker dataBroker;
@Mock
- private RpcProviderRegistry rpcProviderRegistry;
+ private DOMRpcProviderService rpcProviderRegistry;
@Mock
private ClusterSingletonServiceProvider clusterSingletonServiceProvider;
private DOMMountPointService mountPointService;
@Mock
- private BindingTransactionChain txChain;
+ private TransactionChain txChain;
@Mock
private WriteTransaction writeTx;
import org.junit.Before;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataReadOnlyTransaction;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeReadTransaction;
public class ReadTransactionActorTest extends ReadTransactionActorTestAdapter {
private static ActorSystem system = ActorSystem.apply();
@Mock
- private DOMDataReadOnlyTransaction mockReadTx;
+ private DOMDataTreeReadTransaction mockReadTx;
@Before
public void setUp() {
package org.opendaylight.netconf.topology.singleton.impl.actors;
import static org.junit.Assert.assertEquals;
+import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.when;
+import static org.opendaylight.yangtools.util.concurrent.FluentFutures.immediateFailedFluentFuture;
+import static org.opendaylight.yangtools.util.concurrent.FluentFutures.immediateFluentFuture;
+import static org.opendaylight.yangtools.util.concurrent.FluentFutures.immediateTrueFluentFuture;
import akka.actor.ActorRef;
import akka.actor.ActorSystem;
import akka.actor.Status.Failure;
import akka.testkit.TestProbe;
import akka.util.Timeout;
-import com.google.common.base.Optional;
-import com.google.common.util.concurrent.Futures;
+import java.util.Optional;
import java.util.concurrent.TimeUnit;
import org.junit.Test;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataReadTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.ReadFailedException;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeReadTransaction;
import org.opendaylight.netconf.topology.singleton.messages.NormalizedNodeMessage;
import org.opendaylight.netconf.topology.singleton.messages.transactions.EmptyReadResponse;
import org.opendaylight.netconf.topology.singleton.messages.transactions.ExistsRequest;
static final NormalizedNode<?, ?> NODE = Builders.containerBuilder()
.withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(QName.create("", "cont"))).build();
- private DOMDataReadTransaction mockReadTx;
+ private DOMDataTreeReadTransaction mockReadTx;
private TestProbe probe;
private ActorRef actorRef;
- public void init(DOMDataReadTransaction inMockReadTx, ActorSystem system, ActorRef inActorRef) {
+ public void init(final DOMDataTreeReadTransaction inMockReadTx, final ActorSystem system,
+ final ActorRef inActorRef) {
this.mockReadTx = inMockReadTx;
this.probe = TestProbe.apply(system);
this.actorRef = inActorRef;
@Test
public void testRead() {
- when(mockReadTx.read(STORE, PATH)).thenReturn(Futures.immediateCheckedFuture(Optional.of(NODE)));
+ doReturn(immediateFluentFuture(Optional.of(NODE))).when(mockReadTx).read(STORE, PATH);
actorRef.tell(new ReadRequest(STORE, PATH), probe.ref());
verify(mockReadTx).read(STORE, PATH);
@Test
public void testReadEmpty() {
- when(mockReadTx.read(STORE, PATH)).thenReturn(Futures.immediateCheckedFuture(Optional.absent()));
+ doReturn(immediateFluentFuture(Optional.empty())).when(mockReadTx).read(STORE, PATH);
actorRef.tell(new ReadRequest(STORE, PATH), probe.ref());
verify(mockReadTx).read(STORE, PATH);
@Test
public void testReadFailure() {
final ReadFailedException cause = new ReadFailedException("fail");
- when(mockReadTx.read(STORE, PATH)).thenReturn(Futures.immediateFailedCheckedFuture(cause));
+ doReturn(immediateFailedFluentFuture(cause)).when(mockReadTx).read(STORE, PATH);
actorRef.tell(new ReadRequest(STORE, PATH), probe.ref());
verify(mockReadTx).read(STORE, PATH);
@Test
public void testExists() {
- when(mockReadTx.exists(STORE, PATH)).thenReturn(Futures.immediateCheckedFuture(Boolean.TRUE));
+ doReturn(immediateTrueFluentFuture()).when(mockReadTx).exists(STORE, PATH);
actorRef.tell(new ExistsRequest(STORE, PATH), probe.ref());
verify(mockReadTx).exists(STORE, PATH);
@Test
public void testExistsFailure() {
final ReadFailedException cause = new ReadFailedException("fail");
- when(mockReadTx.exists(STORE, PATH)).thenReturn(Futures.immediateFailedCheckedFuture(cause));
+ doReturn(immediateFailedFluentFuture(cause)).when(mockReadTx).exists(STORE, PATH);
actorRef.tell(new ExistsRequest(STORE, PATH), probe.ref());
verify(mockReadTx).exists(STORE, PATH);
* 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.impl.actors;
import akka.actor.ActorSystem;
import org.junit.Test;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataReadWriteTransaction;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeReadWriteTransaction;
import scala.concurrent.duration.Duration;
public class ReadWriteTransactionActorTest {
private static ActorSystem system = ActorSystem.apply();
@Mock
- private DOMDataReadWriteTransaction mockReadWriteTx;
+ private DOMDataTreeReadWriteTransaction mockReadWriteTx;
private final ReadTransactionActorTestAdapter readTestAdapter = new ReadTransactionActorTestAdapter() {};
private final WriteTransactionActorTestAdapter writeTestAdapter = new WriteTransactionActorTestAdapter() {};
* 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.impl.actors;
import akka.actor.ActorSystem;
import org.junit.Before;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataWriteTransaction;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteTransaction;
import scala.concurrent.duration.Duration;
public class WriteTransactionActorTest extends WriteTransactionActorTestAdapter {
private static ActorSystem system = ActorSystem.apply();
@Mock
- private DOMDataWriteTransaction mockWriteTx;
+ private DOMDataTreeWriteTransaction mockWriteTx;
@Before
public void setUp() {
import akka.actor.Status.Success;
import akka.testkit.TestProbe;
import org.junit.Test;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataWriteTransaction;
+import org.opendaylight.mdsal.common.api.TransactionCommitFailedException;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteTransaction;
import org.opendaylight.netconf.topology.singleton.messages.NormalizedNodeMessage;
import org.opendaylight.netconf.topology.singleton.messages.transactions.CancelRequest;
import org.opendaylight.netconf.topology.singleton.messages.transactions.DeleteRequest;
* @author Thomas Pantelis
*/
public abstract class WriteTransactionActorTestAdapter {
- private DOMDataWriteTransaction mockWriteTx;
+ private DOMDataTreeWriteTransaction mockWriteTx;
private TestProbe probe;
private ActorRef actorRef;
private ActorSystem system;
- public void init(DOMDataWriteTransaction inMockWriteTx, ActorSystem inSystem, ActorRef inActorRef) {
+ public void init(final DOMDataTreeWriteTransaction inMockWriteTx, final ActorSystem inSystem,
+ final ActorRef inActorRef) {
this.mockWriteTx = inMockWriteTx;
this.probe = TestProbe.apply(inSystem);
this.actorRef = inActorRef;
* 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.impl.tx;
import static org.junit.Assert.assertEquals;
import akka.testkit.TestProbe;
import akka.testkit.javadsl.TestKit;
import akka.util.Timeout;
-import com.google.common.base.Optional;
import com.google.common.util.concurrent.ListenableFuture;
import java.net.InetSocketAddress;
+import java.util.Optional;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.Test;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.ReadFailedException;
+import org.opendaylight.mdsal.common.api.TransactionCommitFailedException;
import org.opendaylight.netconf.api.DocumentedException;
import org.opendaylight.netconf.sal.connect.util.RemoteDeviceId;
import org.opendaylight.netconf.topology.singleton.messages.NormalizedNodeMessage;
return newSuccessfulProxyTx(Timeout.apply(5, TimeUnit.SECONDS));
}
- private ProxyReadWriteTransaction newSuccessfulProxyTx(Timeout timeout) {
+ private ProxyReadWriteTransaction newSuccessfulProxyTx(final Timeout timeout) {
return new ProxyReadWriteTransaction(DEVICE_ID, Futures.successful(masterActor.ref()),
system.dispatcher(), timeout);
}
}
}
- private void commit(ProxyReadWriteTransaction tx)
+ private void commit(final ProxyReadWriteTransaction tx)
throws InterruptedException, ExecutionException, TimeoutException {
final ListenableFuture<?> submit = tx.commit();
masterActor.expectMsgClass(SubmitRequest.class);
}
}
- private static void verifyDocumentedException(Throwable cause) {
+ private static void verifyDocumentedException(final Throwable cause) {
assertTrue("Unexpected cause " + cause, cause instanceof DocumentedException);
final DocumentedException de = (DocumentedException) cause;
assertEquals(DocumentedException.ErrorSeverity.WARNING, de.getErrorSeverity());
<dependencies>
<dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>sal-binding-api</artifactId>
+ <groupId>org.opendaylight.mdsal</groupId>
+ <artifactId>mdsal-binding-api</artifactId>
</dependency>
<dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>sal-core-api</artifactId>
+ <groupId>org.opendaylight.mdsal</groupId>
+ <artifactId>mdsal-dom-api</artifactId>
</dependency>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>sal-netconf-connector</artifactId>
</dependency>
<dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>sal-common-api</artifactId>
- </dependency>
- <dependency>
- <groupId>org.mockito</groupId>
- <artifactId>mockito-core</artifactId>
- <scope>test</scope>
+ <groupId>org.opendaylight.mdsal</groupId>
+ <artifactId>mdsal-common-api</artifactId>
</dependency>
<dependency>
<groupId>org.opendaylight.yangtools</groupId>
import org.opendaylight.aaa.encrypt.AAAEncryptionService;
import org.opendaylight.controller.config.threadpool.ScheduledThreadPool;
import org.opendaylight.controller.config.threadpool.ThreadPool;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.dom.api.DOMMountPointService;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.dom.api.DOMMountPointService;
import org.opendaylight.netconf.api.NetconfMessage;
import org.opendaylight.netconf.client.NetconfClientDispatcher;
import org.opendaylight.netconf.client.NetconfClientSessionListener;
*/
package org.opendaylight.netconf.topology.api;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.node.topology.rev150114.NetconfNode;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.MoreExecutors;
import javax.annotation.Nullable;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
import org.opendaylight.mdsal.common.api.CommitInfo;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netconf.topology.api.NetconfConnectorFactory;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Host;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.HostBuilder;
import org.opendaylight.aaa.encrypt.AAAEncryptionService;
import org.opendaylight.controller.config.threadpool.ScheduledThreadPool;
import org.opendaylight.controller.config.threadpool.ThreadPool;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeChangeListener;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.dom.api.DOMMountPointService;
+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.WriteTransaction;
import org.opendaylight.mdsal.common.api.CommitInfo;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.dom.api.DOMMountPointService;
import org.opendaylight.netconf.client.NetconfClientDispatcher;
import org.opendaylight.netconf.sal.connect.api.DeviceActionFactory;
import org.opendaylight.netconf.sal.connect.api.RemoteDeviceHandler;
}, MoreExecutors.directExecutor());
LOG.debug("Registering datastore listener");
- datastoreListenerRegistration =
- dataBroker.registerDataTreeChangeListener(
- new DataTreeIdentifier<>(LogicalDatastoreType.CONFIGURATION,
- TopologyUtil.createTopologyListPath(topologyId).child(Node.class)), this);
+ datastoreListenerRegistration = dataBroker.registerDataTreeChangeListener(DataTreeIdentifier.create(
+ LogicalDatastoreType.CONFIGURATION, TopologyUtil.createTopologyListPath(topologyId).child(Node.class)),
+ this);
}
@Override
import org.opendaylight.aaa.encrypt.AAAEncryptionService;
import org.opendaylight.controller.config.threadpool.ScheduledThreadPool;
import org.opendaylight.controller.config.threadpool.ThreadPool;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.dom.api.DOMMountPointService;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataObjectModification;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.dom.api.DOMMountPointService;
import org.opendaylight.netconf.client.NetconfClientDispatcher;
import org.opendaylight.netconf.client.NetconfClientSessionListener;
import org.opendaylight.netconf.client.conf.NetconfClientConfiguration;
<artifactId>netconf-notifications-api</artifactId>
</dependency>
<dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>sal-binding-api</artifactId>
+ <groupId>org.opendaylight.mdsal</groupId>
+ <artifactId>mdsal-binding-api</artifactId>
</dependency>
<dependency>
<groupId>org.opendaylight.mdsal</groupId>
<scope>test</scope>
</dependency>
<dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>sal-binding-broker-impl</artifactId>
+ <groupId>org.opendaylight.mdsal</groupId>
+ <artifactId>mdsal-binding-dom-adapter</artifactId>
<scope>test</scope>
</dependency>
<dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>sal-binding-broker-impl</artifactId>
+ <groupId>org.opendaylight.mdsal</groupId>
+ <artifactId>mdsal-binding-dom-adapter</artifactId>
<type>test-jar</type>
<scope>test</scope>
</dependency>
- <dependency>
- <groupId>org.mockito</groupId>
- <artifactId>mockito-core</artifactId>
- <scope>test</scope>
- </dependency>
<dependency>
<groupId>org.hamcrest</groupId>
<artifactId>hamcrest-core</artifactId>
*/
package org.opendaylight.netconf.sal.connect.api;
-import org.opendaylight.controller.md.sal.dom.api.DOMActionService;
+import org.opendaylight.mdsal.dom.api.DOMActionService;
import org.opendaylight.netconf.api.NetconfMessage;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
* @param schemaContext - schema context of device
* @return {@link DOMActionService} of specific device
*/
- default DOMActionService createDeviceAction(MessageTransformer<NetconfMessage> messageTransformer,
- RemoteDeviceCommunicator<NetconfMessage> listener, SchemaContext schemaContext) {
+ default DOMActionService createDeviceAction(final MessageTransformer<NetconfMessage> messageTransformer,
+ final RemoteDeviceCommunicator<NetconfMessage> listener, final SchemaContext schemaContext) {
return null;
}
}
*/
package org.opendaylight.netconf.sal.connect.api;
-import org.opendaylight.controller.md.sal.dom.api.DOMNotification;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcResult;
import org.opendaylight.mdsal.dom.api.DOMActionResult;
import org.opendaylight.mdsal.dom.api.DOMDataTreeIdentifier;
+import org.opendaylight.mdsal.dom.api.DOMNotification;
+import org.opendaylight.mdsal.dom.api.DOMRpcResult;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
* @param payload - input of action
* @return message
*/
- default M toActionRequest(SchemaPath action, DOMDataTreeIdentifier domDataTreeIdentifier, NormalizedNode<?,
- ?> payload) {
+ default M toActionRequest(final SchemaPath action, final DOMDataTreeIdentifier domDataTreeIdentifier,
+ final NormalizedNode<?, ?> payload) {
throw new UnsupportedOperationException();
}
* @param message - message to parsing
* @return {@link DOMActionResult}
*/
- default DOMActionResult toActionResult(SchemaPath action, M message) {
+ default DOMActionResult toActionResult(final SchemaPath action, final M message) {
throw new UnsupportedOperationException();
}
}
*/
package org.opendaylight.netconf.sal.connect.api;
-import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.FluentFuture;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.RpcResult;
public interface RemoteDeviceCommunicator<M> extends AutoCloseable {
- ListenableFuture<RpcResult<M>> sendRequest(M message, QName rpc);
+ FluentFuture<RpcResult<M>> sendRequest(M message, QName rpc);
+ @Override
void close();
}
*/
package org.opendaylight.netconf.sal.connect.api;
-import org.opendaylight.controller.md.sal.dom.api.DOMActionService;
-import org.opendaylight.controller.md.sal.dom.api.DOMNotification;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcService;
+import org.opendaylight.mdsal.dom.api.DOMActionService;
+import org.opendaylight.mdsal.dom.api.DOMNotification;
+import org.opendaylight.mdsal.dom.api.DOMRpcService;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
public interface RemoteDeviceHandler<PREF> extends AutoCloseable {
* @param netconfSessionPreferences - session of device
* @param deviceRpc - {@link DOMRpcService} of device
*/
- default void onDeviceConnected(SchemaContext remoteSchemaContext, PREF netconfSessionPreferences,
- DOMRpcService deviceRpc) {
+ default void onDeviceConnected(final SchemaContext remoteSchemaContext, final PREF netconfSessionPreferences,
+ final DOMRpcService deviceRpc) {
// DO NOTHING
}
* @param deviceRpc - {@link DOMRpcService} of device
* @param deviceAction - {@link DOMActionService} of device
*/
- default void onDeviceConnected(SchemaContext remoteSchemaContext, PREF netconfSessionPreferences,
- DOMRpcService deviceRpc, DOMActionService deviceAction) {
+ default void onDeviceConnected(final SchemaContext remoteSchemaContext, final PREF netconfSessionPreferences,
+ final DOMRpcService deviceRpc, final DOMActionService deviceAction) {
// DO NOTHING
}
void onNotification(DOMNotification domNotification);
+ @Override
void close();
}
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.stream.XMLStreamException;
import javax.xml.transform.dom.DOMSource;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcResult;
import org.opendaylight.mdsal.binding.generator.impl.ModuleInfoBackedContext;
+import org.opendaylight.mdsal.dom.api.DOMRpcResult;
import org.opendaylight.netconf.sal.connect.api.NetconfDeviceSchemas;
import org.opendaylight.netconf.sal.connect.netconf.sal.NetconfDeviceRpc;
import org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil;
import static java.util.Objects.requireNonNull;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import com.google.common.base.Predicates;
import com.google.common.collect.Collections2;
import com.google.common.collect.Lists;
import com.google.common.collect.Sets;
-import com.google.common.util.concurrent.CheckedFuture;
+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 java.util.Collections;
import java.util.LinkedList;
import java.util.List;
+import java.util.Optional;
import java.util.Set;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.stream.Collectors;
import javax.annotation.Nonnull;
import javax.annotation.concurrent.GuardedBy;
-import org.opendaylight.controller.md.sal.dom.api.DOMNotification;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcException;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcResult;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcService;
+import org.opendaylight.mdsal.dom.api.DOMNotification;
+import org.opendaylight.mdsal.dom.api.DOMRpcResult;
+import org.opendaylight.mdsal.dom.api.DOMRpcService;
import org.opendaylight.netconf.api.NetconfMessage;
import org.opendaylight.netconf.sal.connect.api.DeviceActionFactory;
import org.opendaylight.netconf.sal.connect.api.MessageTransformer;
// TODO check whether the model describing create subscription is present in schema
// Perhaps add a default schema context to support create-subscription if the model was not provided
// (same as what we do for base netconf operations in transformer)
- final CheckedFuture<DOMRpcResult, DOMRpcException> rpcResultListenableFuture = deviceRpc.invokeRpc(
+ final FluentFuture<DOMRpcResult> rpcResultListenableFuture = deviceRpc.invokeRpc(
NetconfMessageTransformUtil.toPath(NetconfMessageTransformUtil.CREATE_SUBSCRIPTION_RPC_QNAME),
NetconfMessageTransformUtil.CREATE_SUBSCRIPTION_RPC_CONTENT);
// Only disconnect is enough,
// the reconnecting nature of the connector will take care of reconnecting
listener.disconnect();
- return Optional.absent();
+ return Optional.empty();
}
return Optional.of(notification);
}
import java.util.Optional;
import java.util.Set;
import java.util.concurrent.ExecutionException;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcResult;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcService;
+import org.opendaylight.mdsal.dom.api.DOMRpcResult;
+import org.opendaylight.mdsal.dom.api.DOMRpcService;
import org.opendaylight.netconf.sal.connect.api.NetconfDeviceSchemas;
import org.opendaylight.netconf.sal.connect.netconf.listener.NetconfSessionPreferences;
import org.opendaylight.netconf.sal.connect.netconf.schema.mapping.BaseSchema;
* 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.sal.connect.netconf;
import org.opendaylight.netconf.sal.connect.api.NetconfDeviceSchemas;
*/
package org.opendaylight.netconf.sal.connect.netconf;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import java.util.LinkedList;
import java.util.List;
-import org.opendaylight.controller.md.sal.dom.api.DOMNotification;
+import java.util.Optional;
+import org.opendaylight.mdsal.dom.api.DOMNotification;
import org.opendaylight.netconf.api.NetconfMessage;
import org.opendaylight.netconf.api.xml.XmlUtil;
import org.opendaylight.netconf.sal.connect.api.MessageTransformer;
import com.google.common.base.Optional;
import com.google.common.base.Strings;
import com.google.common.collect.Lists;
-import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.FluentFuture;
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.SettableFuture;
import io.netty.util.concurrent.Future;
import org.opendaylight.netconf.sal.connect.api.RemoteDeviceCommunicator;
import org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil;
import org.opendaylight.netconf.sal.connect.util.RemoteDeviceId;
+import org.opendaylight.yangtools.util.concurrent.FluentFutures;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.RpcError;
import org.opendaylight.yangtools.yang.common.RpcResult;
}
@Override
- public ListenableFuture<RpcResult<NetconfMessage>> sendRequest(final NetconfMessage message, final QName rpc) {
+ public FluentFuture<RpcResult<NetconfMessage>> sendRequest(final NetconfMessage message, final QName rpc) {
sessionLock.lock();
try {
if (semaphore != null && !semaphore.tryAcquire()) {
LOG.warn("Limit of concurrent rpc messages was reached (limit: {}). Rpc reply message is needed. "
+ "Discarding request of Netconf device with id {}", concurentRpcMsgs, id.getName());
- return Futures.immediateFailedFuture(new NetconfDocumentedException(
+ return FluentFutures.immediateFailedFluentFuture(new NetconfDocumentedException(
"Limit of rpc messages was reached (Limit :" + concurentRpcMsgs
+ ") waiting for emptying the queue of Netconf device with id" + id.getName()));
}
}
}
- private ListenableFuture<RpcResult<NetconfMessage>> sendRequestWithLock(final NetconfMessage message,
+ private FluentFuture<RpcResult<NetconfMessage>> sendRequestWithLock(final NetconfMessage message,
final QName rpc) {
if (LOG.isTraceEnabled()) {
LOG.trace("{}: Sending message {}", id, msgToS(message));
if (currentSession == null) {
LOG.warn("{}: Session is disconnected, failing RPC request {}",
id, message);
- return Futures.immediateFuture(createSessionDownRpcResult());
+ return FluentFutures.immediateFluentFuture(createSessionDownRpcResult());
}
final Request req = new Request(new UncancellableFuture<>(true), message);
import static org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil.NETCONF_RUNNING_QNAME;
import com.google.common.base.Preconditions;
-import com.google.common.util.concurrent.CheckedFuture;
+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.MoreExecutors;
import java.util.concurrent.atomic.AtomicBoolean;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
-import org.opendaylight.controller.md.sal.dom.api.DOMActionService;
-import org.opendaylight.controller.md.sal.dom.api.DOMNotification;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcAvailabilityListener;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcException;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcResult;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcService;
+import org.eclipse.jdt.annotation.NonNull;
+import org.opendaylight.mdsal.dom.api.DOMActionService;
+import org.opendaylight.mdsal.dom.api.DOMNotification;
+import org.opendaylight.mdsal.dom.api.DOMRpcAvailabilityListener;
+import org.opendaylight.mdsal.dom.api.DOMRpcResult;
+import org.opendaylight.mdsal.dom.api.DOMRpcService;
import org.opendaylight.netconf.sal.connect.api.RemoteDeviceHandler;
import org.opendaylight.netconf.sal.connect.netconf.listener.NetconfDeviceCommunicator;
import org.opendaylight.netconf.sal.connect.netconf.listener.NetconfSessionPreferences;
*/
private static final class RequestTimeoutTask implements Runnable {
- private final CheckedFuture<DOMRpcResult, DOMRpcException> rpcResultFuture;
+ private final FluentFuture<DOMRpcResult> rpcResultFuture;
- RequestTimeoutTask(final CheckedFuture<DOMRpcResult, DOMRpcException> rpcResultFuture) {
+ RequestTimeoutTask(final FluentFuture<DOMRpcResult> rpcResultFuture) {
this.rpcResultFuture = rpcResultFuture;
}
@Nonnull
@Override
- public CheckedFuture<DOMRpcResult, DOMRpcException> invokeRpc(@Nonnull final SchemaPath type,
+ public @NonNull FluentFuture<DOMRpcResult> invokeRpc(@Nonnull final SchemaPath type,
final NormalizedNode<?, ?> input) {
- final CheckedFuture<DOMRpcResult, DOMRpcException> domRpcResultDOMRpcExceptionCheckedFuture =
+ final FluentFuture<DOMRpcResult> domRpcResultDOMRpcExceptionCheckedFuture =
deviceRpc.invokeRpc(type, input);
Futures.addCallback(domRpcResultDOMRpcExceptionCheckedFuture, resetKeepaliveTask,
MoreExecutors.directExecutor());
* 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.sal.connect.netconf.sal;
import com.google.common.base.Preconditions;
-import java.util.Collections;
-import java.util.Map;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionChainListener;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataBroker;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataBrokerExtension;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataReadOnlyTransaction;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataReadWriteTransaction;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataWriteTransaction;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcService;
-import org.opendaylight.controller.md.sal.dom.api.DOMTransactionChain;
+import com.google.common.collect.ClassToInstanceMap;
+import com.google.common.collect.ImmutableClassToInstanceMap;
+import org.opendaylight.mdsal.dom.api.DOMDataBroker;
+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.DOMRpcService;
+import org.opendaylight.mdsal.dom.api.DOMTransactionChain;
+import org.opendaylight.mdsal.dom.api.DOMTransactionChainListener;
import org.opendaylight.netconf.sal.connect.netconf.listener.NetconfSessionPreferences;
import org.opendaylight.netconf.sal.connect.netconf.sal.tx.ReadOnlyTx;
import org.opendaylight.netconf.sal.connect.netconf.sal.tx.ReadWriteTx;
}
@Override
- public DOMDataReadOnlyTransaction newReadOnlyTransaction() {
+ public DOMDataTreeReadTransaction newReadOnlyTransaction() {
return new ReadOnlyTx(netconfOps, id);
}
@Override
- public DOMDataReadWriteTransaction newReadWriteTransaction() {
+ public DOMDataTreeReadWriteTransaction newReadWriteTransaction() {
return new ReadWriteTx(newReadOnlyTransaction(), newWriteOnlyTransaction());
}
@Override
- public DOMDataWriteTransaction newWriteOnlyTransaction() {
+ public DOMDataTreeWriteTransaction newWriteOnlyTransaction() {
if (candidateSupported) {
if (runningWritable) {
return new WriteCandidateRunningTx(id, netconfOps, rollbackSupport);
}
@Override
- public DOMTransactionChain createTransactionChain(final TransactionChainListener listener) {
+ public DOMTransactionChain createTransactionChain(final DOMTransactionChainListener listener) {
return new TxChain(this, listener);
}
@Override
- public Map<Class<? extends DOMDataBrokerExtension>, DOMDataBrokerExtension> getSupportedExtensions() {
- return Collections.emptyMap();
+ public ClassToInstanceMap<DOMDataBrokerExtension> getExtensions() {
+ return ImmutableClassToInstanceMap.of();
}
-
}
* 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.sal.connect.netconf.sal;
import com.google.common.collect.HashMultimap;
import com.google.common.collect.Multimap;
import java.util.Collection;
import javax.annotation.Nonnull;
-import org.opendaylight.controller.md.sal.dom.api.DOMNotification;
-import org.opendaylight.controller.md.sal.dom.api.DOMNotificationListener;
-import org.opendaylight.controller.md.sal.dom.api.DOMNotificationService;
+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.ListenerRegistration;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import static java.util.Objects.requireNonNull;
import com.google.common.collect.Collections2;
-import com.google.common.util.concurrent.CheckedFuture;
-import com.google.common.util.concurrent.Futures;
-import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.FluentFuture;
+import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.MoreExecutors;
+import com.google.common.util.concurrent.SettableFuture;
import javax.annotation.Nonnull;
-import javax.annotation.Nullable;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcAvailabilityListener;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcException;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcIdentifier;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcImplementationNotAvailableException;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcResult;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcService;
-import org.opendaylight.controller.md.sal.dom.spi.DefaultDOMRpcResult;
+import org.opendaylight.mdsal.dom.api.DOMRpcAvailabilityListener;
+import org.opendaylight.mdsal.dom.api.DOMRpcIdentifier;
+import org.opendaylight.mdsal.dom.api.DOMRpcImplementationNotAvailableException;
+import org.opendaylight.mdsal.dom.api.DOMRpcResult;
+import org.opendaylight.mdsal.dom.api.DOMRpcService;
+import org.opendaylight.mdsal.dom.spi.DefaultDOMRpcResult;
import org.opendaylight.netconf.api.NetconfMessage;
import org.opendaylight.netconf.sal.connect.api.MessageTransformer;
import org.opendaylight.netconf.sal.connect.api.RemoteDeviceCommunicator;
this.schemaContext = requireNonNull(schemaContext);
}
- @Nonnull
@Override
- public CheckedFuture<DOMRpcResult, DOMRpcException> invokeRpc(@Nonnull final SchemaPath type,
- @Nullable final NormalizedNode<?, ?> input) {
- final NetconfMessage message = transformer.toRpcRequest(type, input);
- final ListenableFuture<RpcResult<NetconfMessage>> delegateFutureWithPureResult =
- communicator.sendRequest(message, type.getLastComponent());
+ public FluentFuture<DOMRpcResult> invokeRpc(final SchemaPath type, final NormalizedNode<?, ?> input) {
+ final FluentFuture<RpcResult<NetconfMessage>> delegateFuture = communicator.sendRequest(
+ transformer.toRpcRequest(type, input), type.getLastComponent());
+
+ final SettableFuture<DOMRpcResult> ret = SettableFuture.create();
+ delegateFuture.addCallback(new FutureCallback<RpcResult<NetconfMessage>>() {
+ @Override
+ public void onSuccess(RpcResult<NetconfMessage> result) {
+ ret.set(result.isSuccessful() ? transformer.toRpcResult(result.getResult(), type)
+ : new DefaultDOMRpcResult(result.getErrors()));
+ }
- final ListenableFuture<DOMRpcResult> transformed =
- Futures.transform(delegateFutureWithPureResult, input1 -> {
- if (input1.isSuccessful()) {
- return transformer.toRpcResult(input1.getResult(), type);
- } else {
- return new DefaultDOMRpcResult(input1.getErrors());
- }
- }, MoreExecutors.directExecutor());
+ @Override
+ public void onFailure(Throwable cause) {
+ ret.setException(new DOMRpcImplementationNotAvailableException(cause, "Unable to invoke rpc %s", type));
+ }
- return Futures.makeChecked(transformed, exception ->
- new DOMRpcImplementationNotAvailableException(exception, "Unable to invoke rpc %s", type));
+ }, MoreExecutors.directExecutor());
+ return ret;
}
@Nonnull
import com.google.common.annotations.VisibleForTesting;
import com.google.common.collect.Lists;
import java.util.List;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.dom.api.DOMActionService;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataBroker;
-import org.opendaylight.controller.md.sal.dom.api.DOMMountPointService;
-import org.opendaylight.controller.md.sal.dom.api.DOMNotification;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcService;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.dom.api.DOMActionService;
+import org.opendaylight.mdsal.dom.api.DOMDataBroker;
+import org.opendaylight.mdsal.dom.api.DOMMountPointService;
+import org.opendaylight.mdsal.dom.api.DOMNotification;
+import org.opendaylight.mdsal.dom.api.DOMRpcService;
import org.opendaylight.netconf.sal.connect.api.RemoteDeviceHandler;
import org.opendaylight.netconf.sal.connect.netconf.listener.NetconfDeviceCapabilities;
import org.opendaylight.netconf.sal.connect.netconf.listener.NetconfSessionPreferences;
@Override
public synchronized void onDeviceConnected(final SchemaContext schemaContext,
final NetconfSessionPreferences netconfSessionPreferences,
- final DOMRpcService deviceRpc, DOMActionService deviceAction) {
+ final DOMRpcService deviceRpc, final DOMActionService deviceAction) {
final DOMDataBroker domBroker =
new NetconfDeviceDataBroker(id, schemaContext, deviceRpc, netconfSessionPreferences);
package org.opendaylight.netconf.sal.connect.netconf.sal;
import com.google.common.base.Preconditions;
-import org.opendaylight.controller.md.sal.binding.api.BindingTransactionChain;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.AsyncTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionChain;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionChainListener;
-import org.opendaylight.controller.md.sal.dom.api.DOMActionService;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataBroker;
-import org.opendaylight.controller.md.sal.dom.api.DOMMountPoint;
-import org.opendaylight.controller.md.sal.dom.api.DOMMountPointService;
-import org.opendaylight.controller.md.sal.dom.api.DOMNotification;
-import org.opendaylight.controller.md.sal.dom.api.DOMNotificationService;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcService;
+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.dom.api.DOMActionService;
+import org.opendaylight.mdsal.dom.api.DOMDataBroker;
+import org.opendaylight.mdsal.dom.api.DOMMountPoint;
+import org.opendaylight.mdsal.dom.api.DOMMountPointService;
+import org.opendaylight.mdsal.dom.api.DOMNotification;
+import org.opendaylight.mdsal.dom.api.DOMNotificationService;
+import org.opendaylight.mdsal.dom.api.DOMRpcService;
import org.opendaylight.netconf.sal.connect.util.RemoteDeviceId;
import org.opendaylight.yangtools.concepts.ObjectRegistration;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
private volatile NetconfDeviceTopologyAdapter topologyDatastoreAdapter;
- private BindingTransactionChain txChain;
+ private TransactionChain txChain;
private final TransactionChainListener transactionChainListener = new TransactionChainListener() {
@Override
- public void onTransactionChainFailed(final TransactionChain<?, ?> chain,
- final AsyncTransaction<?, ?> transaction, final Throwable cause) {
+ public void onTransactionChainFailed(final TransactionChain chain, final Transaction transaction,
+ final Throwable cause) {
LOG.error("{}: TransactionChain({}) {} FAILED!", id, chain, transaction.getIdentifier(), cause);
chain.close();
resetTransactionChainForAdapaters();
}
@Override
- public void onTransactionChainSuccessful(final TransactionChain<?, ?> chain) {
+ public void onTransactionChainSuccessful(final TransactionChain chain) {
LOG.trace("{}: TransactionChain({}) SUCCESSFUL", id, chain);
}
};
* 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.sal.connect.netconf.sal;
import com.google.common.base.Preconditions;
import java.util.Map;
import java.util.concurrent.ExecutionException;
import java.util.stream.Collectors;
-import org.opendaylight.controller.md.sal.binding.api.BindingTransactionChain;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.TransactionChain;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
import org.opendaylight.mdsal.common.api.CommitInfo;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netconf.sal.connect.netconf.listener.NetconfDeviceCapabilities;
import org.opendaylight.netconf.sal.connect.util.RemoteDeviceId;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.PortNumber;
private static final Logger LOG = LoggerFactory.getLogger(NetconfDeviceTopologyAdapter.class);
private final RemoteDeviceId id;
- private BindingTransactionChain txChain;
+ private TransactionChain txChain;
private final InstanceIdentifier<NetworkTopology> networkTopologyPath;
private final KeyedInstanceIdentifier<Topology, TopologyKey> topologyListPath;
private static final String UNKNOWN_REASON = "Unknown reason";
- NetconfDeviceTopologyAdapter(final RemoteDeviceId id, final BindingTransactionChain txChain) {
+ NetconfDeviceTopologyAdapter(final RemoteDeviceId id, final TransactionChain txChain) {
this.id = id;
this.txChain = Preconditions.checkNotNull(txChain);
removeDeviceConfiguration();
}
- public void setTxChain(final BindingTransactionChain txChain) {
+ public void setTxChain(final TransactionChain txChain) {
this.txChain = Preconditions.checkNotNull(txChain);
}
}
* 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.sal.connect.netconf.sal;
import java.io.ByteArrayInputStream;
import java.util.Map;
import java.util.Optional;
import javax.annotation.Nonnull;
-import org.opendaylight.controller.md.sal.binding.api.ClusteredDataTreeChangeListener;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+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.DataTreeIdentifier;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.keystore.rev171017.Keystore;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.keystore.rev171017._private.keys.PrivateKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.keystore.rev171017.keystore.entry.KeyCredential;
public NetconfKeystoreAdapter(final DataBroker dataBroker) {
this.dataBroker = dataBroker;
- dataBroker.registerDataTreeChangeListener(
- new DataTreeIdentifier<>(LogicalDatastoreType.CONFIGURATION, keystoreIid), this);
+ dataBroker.registerDataTreeChangeListener(DataTreeIdentifier.create(LogicalDatastoreType.CONFIGURATION,
+ keystoreIid), this);
}
public Optional<KeyCredential> getKeypairFromId(final String keyId) {
*/
package org.opendaylight.netconf.sal.connect.netconf.sal;
-import com.google.common.util.concurrent.CheckedFuture;
-import com.google.common.util.concurrent.Futures;
-import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.FluentFuture;
+import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.MoreExecutors;
+import com.google.common.util.concurrent.SettableFuture;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcAvailabilityListener;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcException;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcImplementationNotAvailableException;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcResult;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcService;
-import org.opendaylight.controller.md.sal.dom.spi.DefaultDOMRpcResult;
+import org.opendaylight.mdsal.dom.api.DOMRpcAvailabilityListener;
+import org.opendaylight.mdsal.dom.api.DOMRpcImplementationNotAvailableException;
+import org.opendaylight.mdsal.dom.api.DOMRpcResult;
+import org.opendaylight.mdsal.dom.api.DOMRpcService;
+import org.opendaylight.mdsal.dom.spi.DefaultDOMRpcResult;
import org.opendaylight.netconf.api.NetconfMessage;
import org.opendaylight.netconf.sal.connect.api.MessageTransformer;
import org.opendaylight.netconf.sal.connect.api.RemoteDeviceCommunicator;
import org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil;
import org.opendaylight.netconf.sal.connect.util.RemoteDeviceId;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
+import org.opendaylight.yangtools.util.concurrent.FluentFutures;
import org.opendaylight.yangtools.yang.common.RpcResult;
import org.opendaylight.yangtools.yang.data.api.schema.AnyXmlNode;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
this.schemalessTransformer = messageTransformer;
}
- @Nonnull
@Override
- public CheckedFuture<DOMRpcResult, DOMRpcException> invokeRpc(@Nonnull final SchemaPath type,
- @Nullable final NormalizedNode<?, ?> input) {
+ public FluentFuture<DOMRpcResult> invokeRpc(final SchemaPath type, final NormalizedNode<?, ?> input) {
final MessageTransformer<NetconfMessage> transformer;
if (input instanceof AnyXmlNode) {
transformer = schemalessTransformer;
} else if (isBaseRpc(type)) {
transformer = baseRpcTransformer;
} else {
- return Futures.immediateFailedCheckedFuture(
- new DOMRpcImplementationNotAvailableException("Unable to invoke rpc %s", type));
+ return FluentFutures.immediateFailedFluentFuture(new DOMRpcImplementationNotAvailableException(
+ "Unable to invoke rpc %s", type));
}
return handleRpc(type, input, transformer);
}
- private CheckedFuture<DOMRpcResult, DOMRpcException> handleRpc(
+ private FluentFuture<DOMRpcResult> handleRpc(
@Nonnull final SchemaPath type, @Nullable final NormalizedNode<?, ?> input,
final MessageTransformer<NetconfMessage> transformer) {
- final NetconfMessage netconfMessage = transformer.toRpcRequest(type, input);
- final ListenableFuture<RpcResult<NetconfMessage>> rpcResultListenableFuture =
- listener.sendRequest(netconfMessage, type.getLastComponent());
+ final FluentFuture<RpcResult<NetconfMessage>> delegateFuture = listener.sendRequest(
+ transformer.toRpcRequest(type, input), type.getLastComponent());
- final ListenableFuture<DOMRpcResult> transformed =
- Futures.transform(rpcResultListenableFuture, input1 -> {
- if (input1.isSuccessful()) {
- return transformer.toRpcResult(input1.getResult(), type);
- }
+ final SettableFuture<DOMRpcResult> ret = SettableFuture.create();
+ delegateFuture.addCallback(new FutureCallback<RpcResult<NetconfMessage>>() {
+ @Override
+ public void onSuccess(RpcResult<NetconfMessage> result) {
+ ret.set(result.isSuccessful() ? transformer.toRpcResult(result.getResult(), type)
+ : new DefaultDOMRpcResult(result.getErrors()));
+ }
- return new DefaultDOMRpcResult(input1.getErrors());
- }, MoreExecutors.directExecutor());
+ @Override
+ public void onFailure(Throwable cause) {
+ ret.setException(new DOMRpcImplementationNotAvailableException(cause,
+ "Unable to invoke rpc %s on device %s", type, deviceId));
+ }
- return Futures.makeChecked(transformed, e -> new DOMRpcImplementationNotAvailableException(e,
- "Unable to invoke rpc %s on device %s", type, deviceId));
+ }, MoreExecutors.directExecutor());
+ return ret;
}
private static boolean isBaseRpc(final SchemaPath type) {
package org.opendaylight.netconf.sal.connect.netconf.sal.tx;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import com.google.common.collect.Lists;
import com.google.common.util.concurrent.FluentFuture;
import com.google.common.util.concurrent.SettableFuture;
import java.util.Collection;
import java.util.List;
+import java.util.Optional;
import java.util.concurrent.CopyOnWriteArrayList;
import javax.annotation.Nonnull;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataWriteTransaction;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcResult;
import org.opendaylight.mdsal.common.api.CommitInfo;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.TransactionCommitFailedException;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteTransaction;
+import org.opendaylight.mdsal.dom.api.DOMRpcResult;
import org.opendaylight.netconf.api.DocumentedException;
import org.opendaylight.netconf.api.NetconfDocumentedException;
import org.opendaylight.netconf.sal.connect.netconf.util.NetconfBaseOps;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-public abstract class AbstractWriteTx implements DOMDataWriteTransaction {
+public abstract class AbstractWriteTx implements DOMDataTreeWriteTransaction {
private static final Logger LOG = LoggerFactory.getLogger(AbstractWriteTx.class);
return;
}
- final DataContainerChild<?, ?> editStructure =
- netOps.createEditConfigStrcture(Optional.fromNullable(data),
+ final DataContainerChild<?, ?> editStructure = netOps.createEditConfigStrcture(Optional.ofNullable(data),
Optional.of(ModifyAction.REPLACE), path);
- editConfig(path, Optional.fromNullable(data), editStructure, Optional.absent(), "put");
+ editConfig(path, Optional.ofNullable(data), editStructure, Optional.empty(), "put");
}
@Override
return;
}
- final DataContainerChild<?, ?> editStructure =
- netOps.createEditConfigStrcture(Optional.fromNullable(data),
- Optional.absent(), path);
- editConfig(path, Optional.fromNullable(data), editStructure, Optional.absent(), "merge");
+ final DataContainerChild<?, ?> editStructure = netOps.createEditConfigStrcture(Optional.ofNullable(data),
+ Optional.empty(), path);
+ editConfig(path, Optional.ofNullable(data), editStructure, Optional.empty(), "merge");
}
/**
@Override
public synchronized void delete(final LogicalDatastoreType store, final YangInstanceIdentifier path) {
checkEditable(store);
- final DataContainerChild<?, ?> editStructure =
- netOps.createEditConfigStrcture(Optional.absent(),
+ final DataContainerChild<?, ?> editStructure = netOps.createEditConfigStrcture(Optional.empty(),
Optional.of(ModifyAction.DELETE), path);
- editConfig(path, Optional.absent(),
- editStructure, Optional.of(ModifyAction.NONE), "delete");
+ editConfig(path, Optional.empty(), editStructure, Optional.of(ModifyAction.NONE), "delete");
}
@Override
final SettableFuture<CommitInfo> resultFuture = SettableFuture.create();
Futures.addCallback(commitConfiguration(), new FutureCallback<RpcResult<Void>>() {
@Override
- public void onSuccess(RpcResult<Void> result) {
+ public void onSuccess(final RpcResult<Void> result) {
if (!result.isSuccessful()) {
final Collection<RpcError> errors = result.getErrors();
resultFuture.setException(new TransactionCommitFailedException(
}
@Override
- public void onFailure(Throwable failure) {
+ public void onFailure(final Throwable failure) {
resultFuture.setException(new TransactionCommitFailedException(
String.format("Commit of transaction %s failed", getIdentifier()), failure));
}
*/
package org.opendaylight.netconf.sal.connect.netconf.sal.tx;
-import com.google.common.base.Optional;
-import com.google.common.util.concurrent.CheckedFuture;
-import com.google.common.util.concurrent.Futures;
-import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.FluentFuture;
+import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.MoreExecutors;
-import org.opendaylight.controller.md.sal.common.api.MappingCheckedFuture;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataReadOnlyTransaction;
+import com.google.common.util.concurrent.SettableFuture;
+import java.util.Optional;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.ReadFailedException;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeReadTransaction;
import org.opendaylight.netconf.sal.connect.netconf.util.NetconfBaseOps;
import org.opendaylight.netconf.sal.connect.netconf.util.NetconfRpcFutureCallback;
import org.opendaylight.netconf.sal.connect.util.RemoteDeviceId;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-public final class ReadOnlyTx implements DOMDataReadOnlyTransaction {
+public final class ReadOnlyTx implements DOMDataTreeReadTransaction {
private static final Logger LOG = LoggerFactory.getLogger(ReadOnlyTx.class);
this.id = id;
}
- private CheckedFuture<Optional<NormalizedNode<?, ?>>, ReadFailedException> readConfigurationData(
+ private FluentFuture<Optional<NormalizedNode<?, ?>>> readConfigurationData(
final YangInstanceIdentifier path) {
- final ListenableFuture<Optional<NormalizedNode<?, ?>>> configRunning = netconfOps.getConfigRunningData(
- new NetconfRpcFutureCallback("Data read", id), Optional.fromNullable(path));
-
- return MappingCheckedFuture.create(configRunning, ReadFailedException.MAPPER);
+ return remapException(netconfOps.getConfigRunningData(
+ new NetconfRpcFutureCallback("Data read", id), Optional.ofNullable(path)));
}
- private CheckedFuture<Optional<NormalizedNode<?, ?>>, ReadFailedException> readOperationalData(
+ private FluentFuture<Optional<NormalizedNode<?, ?>>> readOperationalData(
final YangInstanceIdentifier path) {
- final ListenableFuture<Optional<NormalizedNode<?, ?>>> configCandidate = netconfOps.getData(
- new NetconfRpcFutureCallback("Data read", id), Optional.fromNullable(path));
+ return remapException(netconfOps.getData(
+ new NetconfRpcFutureCallback("Data read", id), Optional.ofNullable(path)));
+ }
+
+ private static <T> FluentFuture<T> remapException(FluentFuture<T> input) {
+ final SettableFuture<T> ret = SettableFuture.create();
+ input.addCallback(new FutureCallback<T>() {
- return MappingCheckedFuture.create(configCandidate, ReadFailedException.MAPPER);
+ @Override
+ public void onSuccess(T result) {
+ ret.set(result);
+ }
+
+ @Override
+ public void onFailure(Throwable cause) {
+ ret.setException(cause instanceof ReadFailedException ? cause
+ : new ReadFailedException("NETCONF operation failed", cause));
+ }
+ }, MoreExecutors.directExecutor());
+ return ret;
}
@Override
}
@Override
- public CheckedFuture<Optional<NormalizedNode<?, ?>>, ReadFailedException> read(
- final LogicalDatastoreType store, final YangInstanceIdentifier path) {
+ public FluentFuture<Optional<NormalizedNode<?, ?>>> read(final LogicalDatastoreType store,
+ final YangInstanceIdentifier path) {
switch (store) {
case CONFIGURATION:
return readConfigurationData(path);
throw new IllegalArgumentException(String.format(
"%s, Cannot read data %s for %s datastore, unknown datastore type", id, path, store));
}
-
}
@Override
- public CheckedFuture<Boolean, ReadFailedException> exists(final LogicalDatastoreType store,
- final YangInstanceIdentifier path) {
- final ListenableFuture<Boolean> result = Futures.transform(read(store, path),
- optionalNode -> optionalNode != null && optionalNode.isPresent(), MoreExecutors.directExecutor());
- return MappingCheckedFuture.create(result, ReadFailedException.MAPPER);
+ public FluentFuture<Boolean> exists(final LogicalDatastoreType store, final YangInstanceIdentifier path) {
+ return read(store, path).transform(optionalNode -> optionalNode != null && optionalNode.isPresent(),
+ MoreExecutors.directExecutor());
}
@Override
package org.opendaylight.netconf.sal.connect.netconf.sal.tx;
-import com.google.common.base.Optional;
-import com.google.common.util.concurrent.CheckedFuture;
import com.google.common.util.concurrent.FluentFuture;
+import java.util.Optional;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataReadTransaction;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataReadWriteTransaction;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataWriteTransaction;
import org.opendaylight.mdsal.common.api.CommitInfo;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeReadTransaction;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeReadWriteTransaction;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteTransaction;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
-public class ReadWriteTx implements DOMDataReadWriteTransaction {
+public class ReadWriteTx implements DOMDataTreeReadWriteTransaction {
- private final DOMDataReadTransaction delegateReadTx;
- private final DOMDataWriteTransaction delegateWriteTx;
+ private final DOMDataTreeReadTransaction delegateReadTx;
+ private final DOMDataTreeWriteTransaction delegateWriteTx;
- public ReadWriteTx(final DOMDataReadTransaction delegateReadTx, final DOMDataWriteTransaction delegateWriteTx) {
+ public ReadWriteTx(final DOMDataTreeReadTransaction delegateReadTx,
+ final DOMDataTreeWriteTransaction delegateWriteTx) {
this.delegateReadTx = delegateReadTx;
this.delegateWriteTx = delegateWriteTx;
}
return delegateWriteTx.cancel();
}
+ @Override
+ public void close() {
+ cancel();
+ }
+
@Override
public void put(final LogicalDatastoreType store, final YangInstanceIdentifier path,
final NormalizedNode<?, ?> data) {
}
@Override
- public @NonNull FluentFuture<? extends @NonNull CommitInfo> commit() {
+ public FluentFuture<? extends @NonNull CommitInfo> commit() {
return delegateWriteTx.commit();
}
@Override
- public CheckedFuture<Optional<NormalizedNode<?, ?>>, ReadFailedException> read(
- final LogicalDatastoreType store, final YangInstanceIdentifier path) {
+ public FluentFuture<Optional<NormalizedNode<?, ?>>> read(final LogicalDatastoreType store,
+ final YangInstanceIdentifier path) {
return delegateReadTx.read(store, path);
}
- @Override public CheckedFuture<Boolean, ReadFailedException> exists(
- final LogicalDatastoreType store,
- final YangInstanceIdentifier path) {
+ @Override
+ public FluentFuture<Boolean> exists(final LogicalDatastoreType store, final YangInstanceIdentifier path) {
return delegateReadTx.exists(store, path);
}
* 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.sal.connect.netconf.sal.tx;
import com.google.common.base.Preconditions;
import java.util.HashMap;
import java.util.Map;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionChainClosedException;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionChainListener;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataBroker;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataReadOnlyTransaction;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataReadWriteTransaction;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataWriteTransaction;
-import org.opendaylight.controller.md.sal.dom.api.DOMTransactionChain;
+import org.opendaylight.mdsal.dom.api.DOMDataBroker;
+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.DOMTransactionChainClosedException;
+import org.opendaylight.mdsal.dom.api.DOMTransactionChainListener;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
private static final Logger LOG = LoggerFactory.getLogger(TxChain.class);
private final DOMDataBroker dataBroker;
- private final TransactionChainListener listener;
+ private final DOMTransactionChainListener listener;
/**
* Submitted transactions that haven't completed yet.
*/
- private final Map<DOMDataWriteTransaction, AutoCloseable> pendingTransactions = new HashMap<>();
+ private final Map<DOMDataTreeWriteTransaction, AutoCloseable> pendingTransactions = new HashMap<>();
/**
* Transaction created by this chain that hasn't been submitted or cancelled yet.
private boolean closed = false;
private boolean successful = true;
- public TxChain(final DOMDataBroker dataBroker, final TransactionChainListener listener) {
+ public TxChain(final DOMDataBroker dataBroker, final DOMTransactionChainListener listener) {
this.dataBroker = dataBroker;
this.listener = listener;
}
@Override
- public synchronized DOMDataReadOnlyTransaction newReadOnlyTransaction() {
+ public synchronized DOMDataTreeReadTransaction newReadOnlyTransaction() {
checkOperationPermitted();
return dataBroker.newReadOnlyTransaction();
}
@Override
public synchronized AbstractWriteTx newWriteOnlyTransaction() {
checkOperationPermitted();
- final DOMDataWriteTransaction writeTransaction = dataBroker.newWriteOnlyTransaction();
+ final DOMDataTreeWriteTransaction writeTransaction = dataBroker.newWriteOnlyTransaction();
Preconditions.checkState(writeTransaction instanceof AbstractWriteTx);
final AbstractWriteTx pendingWriteTx = (AbstractWriteTx) writeTransaction;
pendingTransactions.put(pendingWriteTx, pendingWriteTx.addListener(this));
}
@Override
- public synchronized DOMDataReadWriteTransaction newReadWriteTransaction() {
+ public synchronized DOMDataTreeReadWriteTransaction newReadWriteTransaction() {
return new ReadWriteTx(dataBroker.newReadOnlyTransaction(), newWriteOnlyTransaction());
}
*/
private void checkOperationPermitted() {
if (closed) {
- throw new TransactionChainClosedException("Transaction chain was closed");
+ throw new DOMTransactionChainClosedException("Transaction chain was closed");
}
Preconditions.checkState(currentTransaction == null, "Last write transaction has not finished yet");
}
package org.opendaylight.netconf.sal.connect.netconf.sal.tx;
-import com.google.common.base.Optional;
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 java.util.Optional;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcResult;
+import org.opendaylight.mdsal.dom.api.DOMRpcResult;
import org.opendaylight.netconf.sal.connect.netconf.util.NetconfBaseOps;
import org.opendaylight.netconf.sal.connect.netconf.util.NetconfRpcFutureCallback;
import org.opendaylight.netconf.sal.connect.util.RemoteDeviceId;
* 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.sal.connect.netconf.sal.tx;
-import com.google.common.base.Optional;
import com.google.common.util.concurrent.ListenableFuture;
import java.util.ArrayList;
import java.util.List;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcResult;
+import java.util.Optional;
+import org.opendaylight.mdsal.dom.api.DOMRpcResult;
import org.opendaylight.netconf.sal.connect.netconf.util.NetconfBaseOps;
import org.opendaylight.netconf.sal.connect.netconf.util.NetconfRpcFutureCallback;
import org.opendaylight.netconf.sal.connect.util.RemoteDeviceId;
import java.nio.charset.StandardCharsets;
import java.util.Optional;
import javax.xml.transform.dom.DOMSource;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcService;
+import org.opendaylight.mdsal.dom.api.DOMRpcService;
import org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil;
import org.opendaylight.netconf.sal.connect.util.RemoteDeviceId;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.monitoring.rev101004.Yang;
import javax.xml.stream.XMLStreamException;
import javax.xml.transform.dom.DOMResult;
import javax.xml.transform.dom.DOMSource;
-import org.opendaylight.controller.md.sal.dom.api.DOMNotification;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcResult;
-import org.opendaylight.controller.md.sal.dom.spi.DefaultDOMRpcResult;
+import org.opendaylight.mdsal.dom.api.DOMNotification;
+import org.opendaylight.mdsal.dom.api.DOMRpcResult;
+import org.opendaylight.mdsal.dom.spi.DefaultDOMRpcResult;
import org.opendaylight.netconf.api.NetconfMessage;
import org.opendaylight.netconf.api.xml.XmlElement;
import org.opendaylight.netconf.api.xml.XmlUtil;
import com.google.common.collect.Multimaps;
import java.io.IOException;
import java.net.URISyntaxException;
+import java.time.Instant;
import java.util.Collection;
import java.util.Collections;
-import java.util.Date;
import java.util.Map;
import java.util.Set;
-import javax.annotation.Nonnull;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.stream.XMLStreamException;
import javax.xml.transform.dom.DOMResult;
import javax.xml.transform.dom.DOMSource;
-import org.opendaylight.controller.md.sal.dom.api.DOMEvent;
-import org.opendaylight.controller.md.sal.dom.api.DOMNotification;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcResult;
-import org.opendaylight.controller.md.sal.dom.spi.DefaultDOMRpcResult;
import org.opendaylight.mdsal.dom.api.DOMActionResult;
import org.opendaylight.mdsal.dom.api.DOMDataTreeIdentifier;
+import org.opendaylight.mdsal.dom.api.DOMEvent;
+import org.opendaylight.mdsal.dom.api.DOMNotification;
+import org.opendaylight.mdsal.dom.api.DOMRpcResult;
+import org.opendaylight.mdsal.dom.spi.DefaultDOMRpcResult;
import org.opendaylight.mdsal.dom.spi.SimpleDOMActionResult;
import org.opendaylight.netconf.api.NetconfMessage;
import org.opendaylight.netconf.api.xml.MissingNameSpaceException;
return builder.build();
}
- private void findAction(
DataSchemaNode dataSchemaNode, Builder<ActionDefinition> builder) {
+ private void findAction(
final DataSchemaNode dataSchemaNode, final Builder<ActionDefinition> builder) {
if (dataSchemaNode instanceof ActionNodeContainer) {
final ActionNodeContainer containerSchemaNode = (ActionNodeContainer) dataSchemaNode;
for (ActionDefinition actionDefinition : containerSchemaNode.getActions()) {
@Override
public synchronized DOMNotification toNotification(final NetconfMessage message) {
- final Map.Entry<Date, XmlElement> stripped = NetconfMessageTransformUtil.stripNotification(message);
+ final Map.Entry<Instant, XmlElement> stripped = NetconfMessageTransformUtil.stripNotification(message);
final QName notificationNoRev;
try {
notificationNoRev = QName.create(
}
@Override
- public NetconfMessage toActionRequest(SchemaPath action, DOMDataTreeIdentifier domDataTreeIdentifier,
+ public NetconfMessage toActionRequest(SchemaPath action, final DOMDataTreeIdentifier domDataTreeIdentifier,
final NormalizedNode<?, ?> payload) {
ActionDefinition actionDefinition = null;
SchemaPath schemaPath = action;
}
@Override
- public DOMActionResult toActionResult(SchemaPath action, NetconfMessage message) {
+ public DOMActionResult toActionResult(final SchemaPath action, final NetconfMessage message) {
ActionDefinition actionDefinition = null;
for (ActionDefinition actionDef : actions) {
if (actionDef.getPath().getLastComponent().equals(action.getLastComponent())) {
static class NetconfDeviceNotification implements DOMNotification, DOMEvent {
private final ContainerNode content;
private final SchemaPath schemaPath;
- private final Date eventTime;
+ private final Instant eventTime;
- NetconfDeviceNotification(final ContainerNode content, final Date eventTime) {
+ NetconfDeviceNotification(final ContainerNode content, final Instant eventTime) {
this.content = content;
this.eventTime = eventTime;
this.schemaPath = toPath(content.getNodeType());
}
- @Nonnull
@Override
public SchemaPath getType() {
return schemaPath;
-
}
- @Nonnull
@Override
public ContainerNode getBody() {
return content;
}
@Override
- public Date getEventTime() {
+ public Instant getEventInstant() {
return eventTime;
}
}
*/
package org.opendaylight.netconf.sal.connect.netconf.schema.mapping;
-import java.util.Date;
+import java.time.Instant;
import java.util.Map;
import javax.xml.transform.dom.DOMSource;
-import org.opendaylight.controller.md.sal.dom.api.DOMNotification;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcResult;
-import org.opendaylight.controller.md.sal.dom.spi.DefaultDOMRpcResult;
+import org.opendaylight.mdsal.dom.api.DOMNotification;
+import org.opendaylight.mdsal.dom.api.DOMRpcResult;
+import org.opendaylight.mdsal.dom.spi.DefaultDOMRpcResult;
import org.opendaylight.netconf.api.NetconfMessage;
import org.opendaylight.netconf.api.xml.MissingNameSpaceException;
import org.opendaylight.netconf.api.xml.XmlElement;
@Override
public DOMNotification toNotification(final NetconfMessage message) {
- final Map.Entry<Date, XmlElement> stripped = NetconfMessageTransformUtil.stripNotification(message);
+ final Map.Entry<Instant, XmlElement> stripped = NetconfMessageTransformUtil.stripNotification(message);
final QName notificationNoRev;
try {
notificationNoRev =
* 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.sal.connect.netconf.util;
import static org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil.EDIT_CONTENT_NODEID;
import static org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil.toFilterStructure;
import static org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil.toId;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
+import com.google.common.util.concurrent.FluentFuture;
import com.google.common.util.concurrent.FutureCallback;
-import com.google.common.util.concurrent.Futures;
-import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.MoreExecutors;
import java.util.Locale;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcResult;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcService;
+import java.util.Optional;
+import org.opendaylight.mdsal.dom.api.DOMRpcResult;
+import org.opendaylight.mdsal.dom.api.DOMRpcService;
import org.opendaylight.netconf.sal.connect.netconf.sal.KeepaliveSalFacade.KeepaliveDOMRpcService;
import org.opendaylight.netconf.sal.connect.netconf.sal.SchemalessNetconfDeviceRpc;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.netconf.base._1._0.rev110601.copy.config.input.target.ConfigTarget;
}
}
- public ListenableFuture<DOMRpcResult> lock(final FutureCallback<DOMRpcResult> callback, final QName datastore) {
+ public FluentFuture<DOMRpcResult> lock(final FutureCallback<DOMRpcResult> callback, final QName datastore) {
Preconditions.checkNotNull(callback);
Preconditions.checkNotNull(datastore);
- final ListenableFuture<DOMRpcResult> future = rpc.invokeRpc(NETCONF_LOCK_PATH, getLockContent(datastore));
- Futures.addCallback(future, callback, MoreExecutors.directExecutor());
+ final FluentFuture<DOMRpcResult> future = rpc.invokeRpc(NETCONF_LOCK_PATH, getLockContent(datastore));
+ future.addCallback(callback, MoreExecutors.directExecutor());
return future;
}
- public ListenableFuture<DOMRpcResult> lockCandidate(final FutureCallback<DOMRpcResult> callback) {
- final ListenableFuture<DOMRpcResult> future = rpc.invokeRpc(NETCONF_LOCK_PATH,
+ public FluentFuture<DOMRpcResult> lockCandidate(final FutureCallback<DOMRpcResult> callback) {
+ final FluentFuture<DOMRpcResult> future = rpc.invokeRpc(NETCONF_LOCK_PATH,
getLockContent(NETCONF_CANDIDATE_QNAME));
- Futures.addCallback(future, callback, MoreExecutors.directExecutor());
+ future.addCallback(callback, MoreExecutors.directExecutor());
return future;
}
- public ListenableFuture<DOMRpcResult> lockRunning(final FutureCallback<DOMRpcResult> callback) {
- final ListenableFuture<DOMRpcResult> future = rpc.invokeRpc(NETCONF_LOCK_PATH,
+ public FluentFuture<DOMRpcResult> lockRunning(final FutureCallback<DOMRpcResult> callback) {
+ final FluentFuture<DOMRpcResult> future = rpc.invokeRpc(NETCONF_LOCK_PATH,
getLockContent(NETCONF_RUNNING_QNAME));
- Futures.addCallback(future, callback, MoreExecutors.directExecutor());
+ future.addCallback(callback, MoreExecutors.directExecutor());
return future;
}
- public ListenableFuture<DOMRpcResult> unlock(final FutureCallback<DOMRpcResult> callback, final QName datastore) {
+ public FluentFuture<DOMRpcResult> unlock(final FutureCallback<DOMRpcResult> callback, final QName datastore) {
Preconditions.checkNotNull(callback);
Preconditions.checkNotNull(datastore);
- final ListenableFuture<DOMRpcResult> future = rpc.invokeRpc(NETCONF_UNLOCK_PATH, getUnLockContent(datastore));
- Futures.addCallback(future, callback, MoreExecutors.directExecutor());
+ final FluentFuture<DOMRpcResult> future = rpc.invokeRpc(NETCONF_UNLOCK_PATH, getUnLockContent(datastore));
+ future.addCallback(callback, MoreExecutors.directExecutor());
return future;
}
- public ListenableFuture<DOMRpcResult> unlockRunning(final FutureCallback<DOMRpcResult> callback) {
- final ListenableFuture<DOMRpcResult> future = rpc.invokeRpc(NETCONF_UNLOCK_PATH,
+ public FluentFuture<DOMRpcResult> unlockRunning(final FutureCallback<DOMRpcResult> callback) {
+ final FluentFuture<DOMRpcResult> future = rpc.invokeRpc(NETCONF_UNLOCK_PATH,
getUnLockContent(NETCONF_RUNNING_QNAME));
- Futures.addCallback(future, callback, MoreExecutors.directExecutor());
+ future.addCallback(callback, MoreExecutors.directExecutor());
return future;
}
- public ListenableFuture<DOMRpcResult> unlockCandidate(final FutureCallback<DOMRpcResult> callback) {
- final ListenableFuture<DOMRpcResult> future = rpc.invokeRpc(NETCONF_UNLOCK_PATH,
+ public FluentFuture<DOMRpcResult> unlockCandidate(final FutureCallback<DOMRpcResult> callback) {
+ final FluentFuture<DOMRpcResult> future = rpc.invokeRpc(NETCONF_UNLOCK_PATH,
getUnLockContent(NETCONF_CANDIDATE_QNAME));
- Futures.addCallback(future, callback, MoreExecutors.directExecutor());
+ future.addCallback(callback, MoreExecutors.directExecutor());
return future;
}
- public ListenableFuture<DOMRpcResult> discardChanges(final FutureCallback<DOMRpcResult> callback) {
+ public FluentFuture<DOMRpcResult> discardChanges(final FutureCallback<DOMRpcResult> callback) {
Preconditions.checkNotNull(callback);
- final ListenableFuture<DOMRpcResult> future = rpc.invokeRpc(NETCONF_DISCARD_CHANGES_PATH, null);
- Futures.addCallback(future, callback, MoreExecutors.directExecutor());
+ final FluentFuture<DOMRpcResult> future = rpc.invokeRpc(NETCONF_DISCARD_CHANGES_PATH, null);
+ future.addCallback(callback, MoreExecutors.directExecutor());
return future;
}
- public ListenableFuture<DOMRpcResult> commit(final FutureCallback<DOMRpcResult> callback) {
+ public FluentFuture<DOMRpcResult> commit(final FutureCallback<DOMRpcResult> callback) {
Preconditions.checkNotNull(callback);
- final ListenableFuture<DOMRpcResult> future = rpc.invokeRpc(
- NetconfMessageTransformUtil.NETCONF_COMMIT_PATH, NetconfMessageTransformUtil.COMMIT_RPC_CONTENT);
- Futures.addCallback(future, callback, MoreExecutors.directExecutor());
+ final FluentFuture<DOMRpcResult> future = rpc.invokeRpc(NetconfMessageTransformUtil.NETCONF_COMMIT_PATH,
+ NetconfMessageTransformUtil.COMMIT_RPC_CONTENT);
+ future.addCallback(callback, MoreExecutors.directExecutor());
return future;
}
- public ListenableFuture<DOMRpcResult> validate(final FutureCallback<DOMRpcResult> callback, final QName datastore) {
+ public FluentFuture<DOMRpcResult> validate(final FutureCallback<DOMRpcResult> callback, final QName datastore) {
Preconditions.checkNotNull(callback);
Preconditions.checkNotNull(datastore);
- final ListenableFuture<DOMRpcResult> future = rpc.invokeRpc(
- NetconfMessageTransformUtil.NETCONF_VALIDATE_PATH, getValidateContent(datastore));
- Futures.addCallback(future, callback, MoreExecutors.directExecutor());
+ final FluentFuture<DOMRpcResult> future = rpc.invokeRpc(NetconfMessageTransformUtil.NETCONF_VALIDATE_PATH,
+ getValidateContent(datastore));
+ future.addCallback(callback, MoreExecutors.directExecutor());
return future;
}
- public ListenableFuture<DOMRpcResult> validateCandidate(final FutureCallback<DOMRpcResult> callback) {
+ public FluentFuture<DOMRpcResult> validateCandidate(final FutureCallback<DOMRpcResult> callback) {
return validate(callback, NETCONF_CANDIDATE_QNAME);
}
- public ListenableFuture<DOMRpcResult> validateRunning(final FutureCallback<DOMRpcResult> callback) {
+ public FluentFuture<DOMRpcResult> validateRunning(final FutureCallback<DOMRpcResult> callback) {
return validate(callback, NETCONF_RUNNING_QNAME);
}
- public ListenableFuture<DOMRpcResult> copyConfig(final FutureCallback<DOMRpcResult> callback,
+ public FluentFuture<DOMRpcResult> copyConfig(final FutureCallback<DOMRpcResult> callback,
final QName source, final QName target) {
Preconditions.checkNotNull(callback);
Preconditions.checkNotNull(source);
Preconditions.checkNotNull(target);
- final ListenableFuture<DOMRpcResult> future = rpc.invokeRpc(NETCONF_COPY_CONFIG_PATH,
+ final FluentFuture<DOMRpcResult> future = rpc.invokeRpc(NETCONF_COPY_CONFIG_PATH,
getCopyConfigContent(source, target));
- Futures.addCallback(future, callback, MoreExecutors.directExecutor());
+ future.addCallback(callback, MoreExecutors.directExecutor());
return future;
}
- public ListenableFuture<DOMRpcResult> copyRunningToCandidate(final FutureCallback<DOMRpcResult> callback) {
+ public FluentFuture<DOMRpcResult> copyRunningToCandidate(final FutureCallback<DOMRpcResult> callback) {
return copyConfig(callback, NETCONF_RUNNING_QNAME, NETCONF_CANDIDATE_QNAME);
}
- public ListenableFuture<DOMRpcResult> getConfig(final FutureCallback<DOMRpcResult> callback, final QName datastore,
+ public FluentFuture<DOMRpcResult> getConfig(final FutureCallback<DOMRpcResult> callback, final QName datastore,
final Optional<YangInstanceIdentifier> filterPath) {
Preconditions.checkNotNull(callback);
Preconditions.checkNotNull(datastore);
- final ListenableFuture<DOMRpcResult> future;
+ final FluentFuture<DOMRpcResult> future;
if (isFilterPresent(filterPath)) {
final DataContainerChild<?, ?> node = transformer.toFilterStructure(filterPath.get());
future = rpc.invokeRpc(NETCONF_GET_CONFIG_PATH,
NetconfMessageTransformUtil.wrap(NETCONF_GET_CONFIG_NODEID, getSourceNode(datastore)));
}
- Futures.addCallback(future, callback, MoreExecutors.directExecutor());
+ future.addCallback(callback, MoreExecutors.directExecutor());
return future;
}
- public ListenableFuture<Optional<NormalizedNode<?, ?>>> getConfigRunningData(
+ public FluentFuture<Optional<NormalizedNode<?, ?>>> getConfigRunningData(
final FutureCallback<DOMRpcResult> callback, final Optional<YangInstanceIdentifier> filterPath) {
- final ListenableFuture<DOMRpcResult> configRunning = getConfigRunning(callback, filterPath);
+ final FluentFuture<DOMRpcResult> configRunning = getConfigRunning(callback, filterPath);
return extractData(filterPath, configRunning);
}
- public ListenableFuture<Optional<NormalizedNode<?, ?>>> getData(final FutureCallback<DOMRpcResult> callback,
+ public FluentFuture<Optional<NormalizedNode<?, ?>>> getData(final FutureCallback<DOMRpcResult> callback,
final Optional<YangInstanceIdentifier> filterPath) {
- final ListenableFuture<DOMRpcResult> configRunning = get(callback, filterPath);
+ final FluentFuture<DOMRpcResult> configRunning = get(callback, filterPath);
return extractData(filterPath, configRunning);
}
- private ListenableFuture<Optional<NormalizedNode<?, ?>>> extractData(
- final Optional<YangInstanceIdentifier> path, final ListenableFuture<DOMRpcResult> configRunning) {
- return Futures.transform(configRunning, result -> {
- Preconditions.checkArgument(
- result.getErrors().isEmpty(), "Unable to read data: %s, errors: %s", path, result.getErrors());
+ private FluentFuture<Optional<NormalizedNode<?, ?>>> extractData(
+ final Optional<YangInstanceIdentifier> path, final FluentFuture<DOMRpcResult> configRunning) {
+ return configRunning.transform(result -> {
+ Preconditions.checkArgument(result.getErrors().isEmpty(), "Unable to read data: %s, errors: %s", path,
+ result.getErrors());
final DataContainerChild<? extends YangInstanceIdentifier.PathArgument, ?> dataNode =
((ContainerNode) result.getResult()).getChild(NetconfMessageTransformUtil.NETCONF_DATA_NODEID)
.get();
}, MoreExecutors.directExecutor());
}
- public ListenableFuture<DOMRpcResult> getConfigRunning(final FutureCallback<DOMRpcResult> callback,
+ public FluentFuture<DOMRpcResult> getConfigRunning(final FutureCallback<DOMRpcResult> callback,
final Optional<YangInstanceIdentifier> filterPath) {
return getConfig(callback, NETCONF_RUNNING_QNAME, filterPath);
}
- public ListenableFuture<DOMRpcResult> getConfigCandidate(final FutureCallback<DOMRpcResult> callback,
+ public FluentFuture<DOMRpcResult> getConfigCandidate(final FutureCallback<DOMRpcResult> callback,
final Optional<YangInstanceIdentifier> filterPath) {
return getConfig(callback, NETCONF_CANDIDATE_QNAME, filterPath);
}
- public ListenableFuture<DOMRpcResult> get(final FutureCallback<DOMRpcResult> callback,
+ public FluentFuture<DOMRpcResult> get(final FutureCallback<DOMRpcResult> callback,
final Optional<YangInstanceIdentifier> filterPath) {
Preconditions.checkNotNull(callback);
- final ListenableFuture<DOMRpcResult> future = rpc.invokeRpc(NETCONF_GET_PATH, isFilterPresent(filterPath)
+ final FluentFuture<DOMRpcResult> future = rpc.invokeRpc(NETCONF_GET_PATH, isFilterPresent(filterPath)
? NetconfMessageTransformUtil.wrap(NETCONF_GET_NODEID, toFilterStructure(filterPath.get(), schemaContext))
: NetconfMessageTransformUtil.GET_RPC_CONTENT);
- Futures.addCallback(future, callback, MoreExecutors.directExecutor());
+ future.addCallback(callback, MoreExecutors.directExecutor());
return future;
}
return filterPath.isPresent() && !filterPath.get().isEmpty();
}
- public ListenableFuture<DOMRpcResult> editConfigCandidate(final FutureCallback<? super DOMRpcResult> callback,
+ public FluentFuture<DOMRpcResult> editConfigCandidate(final FutureCallback<? super DOMRpcResult> callback,
final DataContainerChild<?, ?> editStructure,
final ModifyAction modifyAction, final boolean rollback) {
return editConfig(callback, NETCONF_CANDIDATE_QNAME, editStructure, Optional.of(modifyAction), rollback);
}
- public ListenableFuture<DOMRpcResult> editConfigCandidate(final FutureCallback<? super DOMRpcResult> callback,
+ public FluentFuture<DOMRpcResult> editConfigCandidate(final FutureCallback<? super DOMRpcResult> callback,
final DataContainerChild<?, ?> editStructure,
final boolean rollback) {
- return editConfig(callback, NETCONF_CANDIDATE_QNAME, editStructure, Optional.absent(), rollback);
+ return editConfig(callback, NETCONF_CANDIDATE_QNAME, editStructure, Optional.empty(), rollback);
}
- public ListenableFuture<DOMRpcResult> editConfigRunning(final FutureCallback<? super DOMRpcResult> callback,
+ public FluentFuture<DOMRpcResult> editConfigRunning(final FutureCallback<? super DOMRpcResult> callback,
final DataContainerChild<?, ?> editStructure,
final ModifyAction modifyAction, final boolean rollback) {
return editConfig(callback, NETCONF_RUNNING_QNAME, editStructure, Optional.of(modifyAction), rollback);
}
- public ListenableFuture<DOMRpcResult> editConfigRunning(final FutureCallback<? super DOMRpcResult> callback,
+ public FluentFuture<DOMRpcResult> editConfigRunning(final FutureCallback<? super DOMRpcResult> callback,
final DataContainerChild<?, ?> editStructure,
final boolean rollback) {
- return editConfig(callback, NETCONF_RUNNING_QNAME, editStructure, Optional.absent(), rollback);
+ return editConfig(callback, NETCONF_RUNNING_QNAME, editStructure, Optional.empty(), rollback);
}
- public ListenableFuture<DOMRpcResult> editConfig(
+ public FluentFuture<DOMRpcResult> editConfig(
final FutureCallback<? super DOMRpcResult> callback, final QName datastore,
final DataContainerChild<?, ?> editStructure, final Optional<ModifyAction> modifyAction,
final boolean rollback) {
Preconditions.checkNotNull(callback);
Preconditions.checkNotNull(datastore);
- final ListenableFuture<DOMRpcResult> future = rpc.invokeRpc(NETCONF_EDIT_CONFIG_PATH,
+ final FluentFuture<DOMRpcResult> future = rpc.invokeRpc(NETCONF_EDIT_CONFIG_PATH,
getEditConfigContent(datastore, editStructure, modifyAction, rollback));
- Futures.addCallback(future, callback, MoreExecutors.directExecutor());
+ future.addCallback(callback, MoreExecutors.directExecutor());
return future;
}
import com.google.common.collect.ImmutableMap;
import java.io.IOException;
import java.net.URI;
+import java.time.Instant;
import java.time.format.DateTimeParseException;
import java.util.AbstractMap;
+import java.util.AbstractMap.SimpleEntry;
import java.util.Collection;
-import java.util.Date;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
}
public static AnyXmlNode createEditConfigAnyxml(
- final SchemaContext ctx, final YangInstanceIdentifier dataPath, final Optional<ModifyAction> operation,
- final Optional<NormalizedNode<?, ?>> lastChildOverride) {
+ final SchemaContext ctx, final YangInstanceIdentifier dataPath,
+ final java.util.Optional<ModifyAction> operation,
+ final java.util.Optional<NormalizedNode<?, ?>> lastChildOverride) {
final NormalizedNode<?, ?> configContent;
if (dataPath.isEmpty()) {
} else {
final Entry<QName, ModifyAction> modifyOperation = operation.isPresent()
? new AbstractMap.SimpleEntry<>(NETCONF_OPERATION_QNAME, operation.get()) : null;
- configContent = ImmutableNodes.fromInstanceId(ctx, dataPath, lastChildOverride.toJavaUtil(),
+ configContent = ImmutableNodes.fromInstanceId(ctx, dataPath, lastChildOverride,
java.util.Optional.ofNullable(modifyOperation));
}
.build();
}
- public static DataContainerChild<?, ?> createEditConfigStructure(
- final SchemaContext ctx, final YangInstanceIdentifier dataPath, final Optional<ModifyAction> operation,
- final Optional<NormalizedNode<?, ?>> lastChildOverride) {
+ public static DataContainerChild<?, ?> createEditConfigStructure(final SchemaContext ctx,
+ final YangInstanceIdentifier dataPath, final java.util.Optional<ModifyAction> operation,
+ final java.util.Optional<NormalizedNode<?, ?>> lastChildOverride) {
return Builders.choiceBuilder().withNodeIdentifier(EDIT_CONTENT_NODEID)
.withChild(createEditConfigAnyxml(ctx, dataPath, operation, lastChildOverride)).build();
}
return SchemaPath.ROOT.createChild(rpc);
}
- public static Map.Entry<Date, XmlElement> stripNotification(final NetconfMessage message) {
+ public static Map.Entry<Instant, XmlElement> stripNotification(final NetconfMessage message) {
final XmlElement xmlElement = XmlElement.fromDomDocument(message.getDocument());
final List<XmlElement> childElements = xmlElement.getChildElements();
Preconditions.checkArgument(childElements.size() == 2, "Unable to parse notification %s, unexpected format."
}
try {
- return new AbstractMap.SimpleEntry<>(
- NetconfNotification.RFC3339_DATE_PARSER.apply(eventTimeElement.getTextContent()),
+ return new SimpleEntry<>(
+ NetconfNotification.RFC3339_DATE_PARSER.apply(eventTimeElement.getTextContent()).toInstant(),
notificationElement);
} catch (final DocumentedException e) {
throw new IllegalArgumentException("Notification payload does not contain " + EVENT_TIME + " " + message,
} catch (final DateTimeParseException e) {
LOG.warn("Unable to parse event time from {}. Setting time to {}", eventTimeElement,
NetconfNotification.UNKNOWN_EVENT_TIME, e);
- return new AbstractMap.SimpleEntry<>(NetconfNotification.UNKNOWN_EVENT_TIME, notificationElement);
+ return new SimpleEntry<>(NetconfNotification.UNKNOWN_EVENT_TIME.toInstant(),
+ notificationElement);
}
}
* 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.sal.connect.netconf.util;
import com.google.common.util.concurrent.FutureCallback;
import javax.annotation.Nonnull;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcResult;
+import org.opendaylight.mdsal.dom.api.DOMRpcResult;
import org.opendaylight.netconf.sal.connect.util.RemoteDeviceId;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
*/
package org.opendaylight.netconf.sal.connect.netconf.util;
-import com.google.common.base.Optional;
+import java.util.Optional;
import org.opendaylight.yangtools.yang.data.api.ModifyAction;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.AnyXmlNode;
public Optional<NormalizedNode<?, ?>> selectFromDataStructure(
final DataContainerChild<? extends YangInstanceIdentifier.PathArgument, ?> data,
final YangInstanceIdentifier path) {
- return Optional.fromJavaUtil(NormalizedNodes.findNode(data, path.getPathArguments()));
+ return NormalizedNodes.findNode(data, path.getPathArguments());
}
@Override
*/
package org.opendaylight.netconf.sal.connect.netconf.util;
-import com.google.common.base.Optional;
+import java.util.Optional;
import org.opendaylight.yangtools.yang.data.api.ModifyAction;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.AnyXmlNode;
import static org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil.NETCONF_DATA_NODEID;
import static org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil.NETCONF_DATA_QNAME;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import java.util.Collections;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Map.Entry;
+import java.util.Optional;
import javax.xml.transform.dom.DOMSource;
import org.opendaylight.netconf.api.DocumentedException;
import org.opendaylight.netconf.api.xml.XmlElement;
* 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.sal.connect.util;
import com.google.common.util.concurrent.FutureCallback;
import java.util.concurrent.ExecutionException;
import java.util.stream.Collectors;
import org.opendaylight.aaa.encrypt.AAAEncryptionService;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
import org.opendaylight.mdsal.common.api.CommitInfo;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.keystore.rev171017.AddKeystoreEntryInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.keystore.rev171017.AddKeystoreEntryOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.keystore.rev171017.AddKeystoreEntryOutputBuilder;
import com.google.common.util.concurrent.MoreExecutors;
import com.google.common.util.concurrent.SettableFuture;
import org.opendaylight.aaa.encrypt.AAAEncryptionService;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
import org.opendaylight.mdsal.common.api.CommitInfo;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.node.topology.rev150114.CreateDeviceInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.node.topology.rev150114.CreateDeviceOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.node.topology.rev150114.CreateDeviceOutputBuilder;
import org.junit.Test;
import org.mockito.ArgumentCaptor;
import org.mockito.Mockito;
-import org.opendaylight.controller.md.sal.dom.api.DOMActionService;
-import org.opendaylight.controller.md.sal.dom.api.DOMNotification;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcResult;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcService;
-import org.opendaylight.controller.md.sal.dom.spi.DefaultDOMRpcResult;
+import org.opendaylight.mdsal.dom.api.DOMActionService;
+import org.opendaylight.mdsal.dom.api.DOMNotification;
+import org.opendaylight.mdsal.dom.api.DOMRpcResult;
+import org.opendaylight.mdsal.dom.api.DOMRpcService;
+import org.opendaylight.mdsal.dom.spi.DefaultDOMRpcResult;
import org.opendaylight.netconf.api.NetconfMessage;
import org.opendaylight.netconf.api.xml.XmlNetconfConstants;
import org.opendaylight.netconf.api.xml.XmlUtil;
* 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.sal.connect.netconf;
import static org.hamcrest.CoreMatchers.hasItem;
import static org.mockito.Mockito.when;
import static org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil.NETCONF_GET_QNAME;
import static org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil.toPath;
+import static org.opendaylight.yangtools.util.concurrent.FluentFutures.immediateFailedFluentFuture;
+import static org.opendaylight.yangtools.util.concurrent.FluentFutures.immediateFluentFuture;
-import com.google.common.util.concurrent.CheckedFuture;
-import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.FluentFuture;
import com.google.common.util.concurrent.ListenableFuture;
import java.net.InetSocketAddress;
import java.util.Collections;
import org.junit.Test;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcException;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcImplementationNotAvailableException;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcResult;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcService;
-import org.opendaylight.controller.md.sal.dom.spi.DefaultDOMRpcResult;
+import org.opendaylight.mdsal.dom.api.DOMRpcImplementationNotAvailableException;
+import org.opendaylight.mdsal.dom.api.DOMRpcResult;
+import org.opendaylight.mdsal.dom.api.DOMRpcService;
+import org.opendaylight.mdsal.dom.spi.DefaultDOMRpcResult;
import org.opendaylight.netconf.sal.connect.netconf.listener.NetconfSessionPreferences;
import org.opendaylight.netconf.sal.connect.netconf.schema.mapping.BaseSchema;
import org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil;
.withChild(data)
.build();
when(rpc.invokeRpc(eq(toPath(NETCONF_GET_QNAME)), any()))
- .thenReturn(Futures.immediateCheckedFuture(new DefaultDOMRpcResult(rpcReply)));
+ .thenReturn(immediateFluentFuture(new DefaultDOMRpcResult(rpcReply)));
final NetconfStateSchemas stateSchemas = NetconfStateSchemas.create(rpc, CAPS, deviceId);
final Set<QName> availableYangSchemasQNames = stateSchemas.getAvailableYangSchemasQNames();
assertEquals(numberOfLegalSchemas, availableYangSchemasQNames.size());
@Test
public void testCreateFail() throws Exception {
- final CheckedFuture<DOMRpcResult, DOMRpcException> resultFuture =
- Futures.immediateFailedCheckedFuture(new DOMRpcImplementationNotAvailableException("not available"));
- when(rpc.invokeRpc(eq(toPath(NETCONF_GET_QNAME)), any())).thenReturn(resultFuture);
+ when(rpc.invokeRpc(eq(toPath(NETCONF_GET_QNAME)), any())).thenReturn(
+ immediateFailedFluentFuture(new DOMRpcImplementationNotAvailableException("not available")));
final NetconfStateSchemas stateSchemas = NetconfStateSchemas.create(rpc, CAPS, deviceId);
final Set<QName> availableYangSchemasQNames = stateSchemas.getAvailableYangSchemasQNames();
Assert.assertTrue(availableYangSchemasQNames.isEmpty());
public void testCreateRpcError() throws Exception {
final RpcError rpcError = RpcResultBuilder.newError(RpcError.ErrorType.RPC, "fail", "fail");
when(rpc.invokeRpc(eq(toPath(NETCONF_GET_QNAME)), any()))
- .thenReturn(Futures.immediateCheckedFuture(new DefaultDOMRpcResult(rpcError)));
+ .thenReturn(immediateFluentFuture(new DefaultDOMRpcResult(rpcError)));
final NetconfStateSchemas stateSchemas = NetconfStateSchemas.create(rpc, CAPS, deviceId);
final Set<QName> availableYangSchemasQNames = stateSchemas.getAvailableYangSchemasQNames();
Assert.assertTrue(availableYangSchemasQNames.isEmpty());
public void testCreateInterrupted() throws Throwable {
//NetconfStateSchemas.create calls Thread.currentThread().interrupt(), so it must run in its own thread
final Future<?> testFuture = Executors.newSingleThreadExecutor().submit(() -> {
- final ListenableFuture interruptedFuture = mock(ListenableFuture.class);
+ final ListenableFuture<DOMRpcResult> interruptedFuture = mock(ListenableFuture.class);
try {
when(interruptedFuture.get()).thenThrow(new InterruptedException("interrupted"));
- final CheckedFuture checkedFuture = Futures.makeChecked(interruptedFuture, ReadFailedException.MAPPER);
- when(rpc.invokeRpc(eq(toPath(NETCONF_GET_QNAME)), any())).thenReturn(checkedFuture);
+ when(rpc.invokeRpc(eq(toPath(NETCONF_GET_QNAME)), any())).thenReturn(
+ FluentFuture.from(interruptedFuture));
NetconfStateSchemas.create(rpc, CAPS, deviceId);
} catch (final InterruptedException | ExecutionException e) {
LOG.info("Operation failed.", e);
* 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.sal.connect.netconf;
import static org.junit.Assert.assertEquals;
import java.util.Set;
import org.junit.Before;
import org.junit.Test;
-import org.opendaylight.controller.md.sal.dom.api.DOMEvent;
-import org.opendaylight.controller.md.sal.dom.api.DOMNotification;
+import org.opendaylight.mdsal.dom.api.DOMEvent;
+import org.opendaylight.mdsal.dom.api.DOMNotification;
import org.opendaylight.netconf.api.NetconfMessage;
import org.opendaylight.netconf.api.xml.XmlUtil;
import org.opendaylight.netconf.notifications.NetconfNotification;
assertNotNull(root);
assertEquals(6, Iterables.size(root.getValue()));
assertEquals("user-visited-page", root.getNodeType().getLocalName());
- assertEquals(NetconfNotification.RFC3339_DATE_PARSER.apply("2015-10-23T09:42:27.67175+00:00"),
- ((DOMEvent) domNotification).getEventTime());
+ assertEquals(NetconfNotification.RFC3339_DATE_PARSER.apply("2015-10-23T09:42:27.67175+00:00").toInstant(),
+ ((DOMEvent) domNotification).getEventInstant());
}
}
* 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.sal.connect.netconf;
import static org.mockito.ArgumentMatchers.any;
import java.util.Collection;
import org.junit.Test;
import org.mockito.Mockito;
-import org.opendaylight.controller.md.sal.dom.api.DOMNotification;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcService;
+import org.opendaylight.mdsal.dom.api.DOMNotification;
+import org.opendaylight.mdsal.dom.api.DOMRpcService;
import org.opendaylight.netconf.api.NetconfMessage;
import org.opendaylight.netconf.api.xml.XmlNetconfConstants;
import org.opendaylight.netconf.sal.connect.api.RemoteDeviceHandler;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcResult;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcService;
-import org.opendaylight.controller.md.sal.dom.spi.DefaultDOMRpcResult;
+import org.opendaylight.mdsal.dom.api.DOMRpcResult;
+import org.opendaylight.mdsal.dom.api.DOMRpcService;
+import org.opendaylight.mdsal.dom.spi.DefaultDOMRpcResult;
import org.opendaylight.netconf.sal.connect.api.RemoteDeviceHandler;
import org.opendaylight.netconf.sal.connect.netconf.listener.NetconfDeviceCommunicator;
import org.opendaylight.netconf.sal.connect.netconf.listener.NetconfSessionPreferences;
import org.junit.Test;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataBroker;
-import org.opendaylight.controller.md.sal.dom.api.DOMMountPoint;
-import org.opendaylight.controller.md.sal.dom.api.DOMMountPointService;
-import org.opendaylight.controller.md.sal.dom.api.DOMNotification;
-import org.opendaylight.controller.md.sal.dom.api.DOMNotificationService;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcService;
import org.opendaylight.mdsal.binding.generator.impl.ModuleInfoBackedContext;
+import org.opendaylight.mdsal.dom.api.DOMDataBroker;
+import org.opendaylight.mdsal.dom.api.DOMMountPoint;
+import org.opendaylight.mdsal.dom.api.DOMMountPointService;
+import org.opendaylight.mdsal.dom.api.DOMNotification;
+import org.opendaylight.mdsal.dom.api.DOMNotificationService;
+import org.opendaylight.mdsal.dom.api.DOMRpcService;
import org.opendaylight.netconf.sal.connect.util.RemoteDeviceId;
import org.opendaylight.yangtools.concepts.ObjectRegistration;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import static org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil.toPath;
import com.google.common.collect.Lists;
-import com.google.common.util.concurrent.Futures;
import java.net.InetSocketAddress;
import java.util.Arrays;
import org.junit.Assert;
import org.junit.Test;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataReadOnlyTransaction;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataReadWriteTransaction;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcResult;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcService;
-import org.opendaylight.controller.md.sal.dom.spi.DefaultDOMRpcResult;
import org.opendaylight.mdsal.binding.generator.impl.ModuleInfoBackedContext;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeReadTransaction;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeReadWriteTransaction;
+import org.opendaylight.mdsal.dom.api.DOMRpcResult;
+import org.opendaylight.mdsal.dom.api.DOMRpcService;
+import org.opendaylight.mdsal.dom.spi.DefaultDOMRpcResult;
import org.opendaylight.netconf.sal.connect.netconf.listener.NetconfSessionPreferences;
import org.opendaylight.netconf.sal.connect.netconf.sal.tx.AbstractWriteTx;
import org.opendaylight.netconf.sal.connect.netconf.sal.tx.WriteCandidateRunningTx;
import org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil;
import org.opendaylight.netconf.sal.connect.util.RemoteDeviceId;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.monitoring.extension.rev131210.$YangModuleInfoImpl;
+import org.opendaylight.yangtools.util.concurrent.FluentFutures;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
schemaContext = moduleInfoBackedContext.tryToCreateSchemaContext().get();
DOMRpcResult result = new DefaultDOMRpcResult();
when(rpcService.invokeRpc(any(SchemaPath.class), any(NormalizedNode.class)))
- .thenReturn(Futures.immediateCheckedFuture(result));
+ .thenReturn(FluentFutures.immediateFluentFuture(result));
dataBroker = getDataBroker(NetconfMessageTransformUtil.NETCONF_CANDIDATE_URI.toString());
}
@Test
public void testNewReadOnlyTransaction() throws Exception {
- final DOMDataReadOnlyTransaction tx = dataBroker.newReadOnlyTransaction();
+ final DOMDataTreeReadTransaction tx = dataBroker.newReadOnlyTransaction();
tx.read(LogicalDatastoreType.OPERATIONAL, null);
verify(rpcService).invokeRpc(eq(toPath(NETCONF_GET_QNAME)), any(ContainerNode.class));
}
@Test
public void testNewReadWriteTransaction() throws Exception {
- final DOMDataReadWriteTransaction tx = dataBroker.newReadWriteTransaction();
+ final DOMDataTreeReadWriteTransaction tx = dataBroker.newReadWriteTransaction();
tx.read(LogicalDatastoreType.OPERATIONAL, null);
verify(rpcService).invokeRpc(eq(toPath(NETCONF_GET_QNAME)), any(ContainerNode.class));
}
testWriteTransaction(WriteRunningTx.class, NetconfMessageTransformUtil.NETCONF_RUNNING_WRITABLE_URI.toString());
}
- private void testWriteTransaction(Class<? extends AbstractWriteTx> transaction, String... capabilities) {
+ private void testWriteTransaction(final Class<? extends AbstractWriteTx> transaction,
+ final String... capabilities) {
NetconfDeviceDataBroker db = getDataBroker(capabilities);
Assert.assertEquals(transaction, db.newWriteOnlyTransaction().getClass());
}
- private NetconfDeviceDataBroker getDataBroker(String... caps) {
+ private NetconfDeviceDataBroker getDataBroker(final String... caps) {
NetconfSessionPreferences prefs = NetconfSessionPreferences.fromStrings(Arrays.asList(caps));
final RemoteDeviceId id =
new RemoteDeviceId("device-1", InetSocketAddress.createUnresolved("localhost", 17830));
* 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.sal.connect.netconf.sal;
import static org.mockito.Mockito.doReturn;
import org.junit.Test;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
-import org.opendaylight.controller.md.sal.dom.api.DOMNotification;
-import org.opendaylight.controller.md.sal.dom.api.DOMNotificationListener;
+import org.opendaylight.mdsal.dom.api.DOMNotification;
+import org.opendaylight.mdsal.dom.api.DOMNotificationListener;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.verify;
-import com.google.common.util.concurrent.CheckedFuture;
+import com.google.common.util.concurrent.FluentFuture;
import com.google.common.util.concurrent.Futures;
import java.util.Collection;
import java.util.Collections;
import org.mockito.ArgumentCaptor;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcAvailabilityListener;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcException;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcIdentifier;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcResult;
import org.opendaylight.mdsal.binding.generator.impl.ModuleInfoBackedContext;
+import org.opendaylight.mdsal.dom.api.DOMRpcAvailabilityListener;
+import org.opendaylight.mdsal.dom.api.DOMRpcIdentifier;
+import org.opendaylight.mdsal.dom.api.DOMRpcResult;
import org.opendaylight.netconf.api.NetconfMessage;
import org.opendaylight.netconf.api.xml.XmlUtil;
import org.opendaylight.netconf.sal.connect.api.RemoteDeviceCommunicator;
@Test
public void testInvokeRpc() throws Exception {
NormalizedNode<?, ?> input = createNode("urn:ietf:params:xml:ns:netconf:base:1.0", "2011-06-01", "filter");
- final CheckedFuture<DOMRpcResult, DOMRpcException> future = rpc.invokeRpc(path, input);
- final DOMRpcResult result = future.checkedGet();
+ final FluentFuture<DOMRpcResult> future = rpc.invokeRpc(path, input);
+ final DOMRpcResult result = future.get();
Assert.assertEquals(expectedReply, result);
}
}
}
- private static ContainerNode createNode(String namespace, String date, String localName) {
+ private static ContainerNode createNode(final String namespace, final String date, final String localName) {
return Builders.containerBuilder().withNodeIdentifier(
new YangInstanceIdentifier.NodeIdentifier(QName.create(namespace, date, localName))).build();
}
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mock;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataBroker;
-import org.opendaylight.controller.md.sal.dom.api.DOMNotification;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcService;
+import org.opendaylight.mdsal.dom.api.DOMDataBroker;
+import org.opendaylight.mdsal.dom.api.DOMNotification;
+import org.opendaylight.mdsal.dom.api.DOMRpcService;
import org.opendaylight.netconf.sal.connect.netconf.listener.NetconfDeviceCapabilities;
import org.opendaylight.netconf.sal.connect.netconf.listener.NetconfSessionPreferences;
import org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil;
import org.mockito.ArgumentCaptor;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
-import org.opendaylight.controller.md.sal.binding.api.BindingTransactionChain;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionChainListener;
-import org.opendaylight.controller.md.sal.dom.api.DOMMountPointService;
+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.LogicalDatastoreType;
+import org.opendaylight.mdsal.dom.api.DOMMountPointService;
import org.opendaylight.netconf.sal.connect.util.RemoteDeviceId;
public class NetconfDeviceSalProviderTest {
@Mock
private DataBroker dataBroker;
@Mock
- private BindingTransactionChain chain;
+ private TransactionChain chain;
@Mock
private DOMMountPointService mountPointService;
@Mock
import static org.mockito.Mockito.verify;
import static org.opendaylight.mdsal.common.api.CommitInfo.emptyFluentFuture;
-import com.google.common.base.Optional;
import java.net.InetSocketAddress;
+import java.util.Optional;
import java.util.concurrent.TimeUnit;
import org.awaitility.Awaitility;
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
-import org.opendaylight.controller.md.sal.binding.api.BindingTransactionChain;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
-import org.opendaylight.controller.md.sal.binding.test.ConcurrentDataBrokerTestCustomizer;
-import org.opendaylight.controller.md.sal.common.api.data.AsyncTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionChain;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionChainListener;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataBroker;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataWriteTransaction;
+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.binding.dom.adapter.test.ConcurrentDataBrokerTestCustomizer;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.dom.api.DOMDataBroker;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteTransaction;
import org.opendaylight.netconf.sal.connect.netconf.listener.NetconfDeviceCapabilities;
import org.opendaylight.netconf.sal.connect.util.RemoteDeviceId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.node.topology.rev150114.NetconfNode;
@Mock
private WriteTransaction writeTx;
@Mock
- private BindingTransactionChain txChain;
+ private TransactionChain txChain;
@Mock
private NetconfNode data;
private SchemaContext schemaContext = null;
private final String sessionIdForReporting = "netconf-test-session1";
- private BindingTransactionChain transactionChain;
+ private TransactionChain transactionChain;
private DataBroker dataBroker;
transactionChain = dataBroker.createTransactionChain(new TransactionChainListener() {
@Override
- public void onTransactionChainFailed(final TransactionChain<?, ?> chain,
- final AsyncTransaction<?, ?> transaction, final Throwable cause) {
+ public void onTransactionChainFailed(final TransactionChain chain, final Transaction transaction,
+ final Throwable cause) {
}
@Override
- public void onTransactionChainSuccessful(final TransactionChain<?, ?> chain) {
+ public void onTransactionChainSuccessful(final TransactionChain chain) {
}
});
Awaitility.await().atMost(5, TimeUnit.SECONDS).until(() -> {
Optional<NetconfNode> netconfNode = dataBroker.newReadWriteTransaction()
.read(LogicalDatastoreType.OPERATIONAL, id.getTopologyBindingPath().augmentation(NetconfNode.class))
- .checkedGet(5, TimeUnit.SECONDS);
+ .get(5, TimeUnit.SECONDS);
return netconfNode.isPresent() && netconfNode.get().getConnectionStatus()
== NetconfNodeConnectionStatus.ConnectionStatus.UnableToConnect;
});
NormalizedNode<?, ?> augmentNode = ImmutableLeafNodeBuilder.create().withValue(dataTestId)
.withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(netconfTestLeafQname)).build();
- DOMDataWriteTransaction wtx = domDataBroker.newWriteOnlyTransaction();
+ DOMDataTreeWriteTransaction wtx = domDataBroker.newWriteOnlyTransaction();
wtx.put(LogicalDatastoreType.OPERATIONAL, pathToAugmentedLeaf, augmentNode);
wtx.commit().get(5, TimeUnit.SECONDS);
import org.junit.Test;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
+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.netconf.api.xml.XmlUtil;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.keystore.rev171017.Keystore;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.keystore.rev171017._private.keys.PrivateKey;
* 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.sal.connect.netconf.sal.tx;
import static org.junit.Assert.fail;
import org.mockito.InOrder;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcService;
-import org.opendaylight.controller.md.sal.dom.spi.DefaultDOMRpcResult;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.dom.api.DOMRpcService;
+import org.opendaylight.mdsal.dom.spi.DefaultDOMRpcResult;
import org.opendaylight.netconf.sal.connect.netconf.schema.mapping.BaseSchema;
import org.opendaylight.netconf.sal.connect.netconf.util.NetconfBaseOps;
import org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil;
* 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.sal.connect.netconf.sal.tx;
import static org.mockito.ArgumentMatchers.any;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.controller.md.sal.common.impl.util.compat.DataNormalizationException;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcService;
-import org.opendaylight.controller.md.sal.dom.spi.DefaultDOMRpcResult;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.dom.api.DOMRpcService;
+import org.opendaylight.mdsal.dom.spi.DefaultDOMRpcResult;
import org.opendaylight.netconf.sal.connect.netconf.util.NetconfBaseOps;
import org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil;
import org.opendaylight.netconf.sal.connect.util.RemoteDeviceId;
* 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.sal.connect.netconf.sal.tx;
+import static org.junit.Assert.assertNotEquals;
+import static org.junit.Assert.assertTrue;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
-import com.google.common.util.concurrent.CheckedFuture;
-import com.google.common.util.concurrent.Futures;
-import org.junit.Assert;
+import com.google.common.util.concurrent.FluentFuture;
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataReadTransaction;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataWriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeReadTransaction;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteTransaction;
+import org.opendaylight.yangtools.util.concurrent.FluentFutures;
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.LeafNode;
public class ReadWriteTxTest {
@Mock
- private DOMDataReadTransaction delegateReadTx;
+ private DOMDataTreeReadTransaction delegateReadTx;
@Mock
- private DOMDataWriteTransaction delegateWriteTx;
+ private DOMDataTreeWriteTransaction delegateWriteTx;
private ReadWriteTx tx;
@Before
@Test
public void exists() throws Exception {
final YangInstanceIdentifier id = TxTestUtils.getContainerId();
- final CheckedFuture<Boolean, ReadFailedException> resultFuture =
- Futures.immediateCheckedFuture(true);
- when(delegateReadTx.exists(LogicalDatastoreType.CONFIGURATION, id)).thenReturn(resultFuture);
- final CheckedFuture<Boolean, ReadFailedException> exists = tx.exists(LogicalDatastoreType.CONFIGURATION, id);
- Assert.assertTrue(exists.get());
+ when(delegateReadTx.exists(LogicalDatastoreType.CONFIGURATION, id)).thenReturn(
+ FluentFutures.immediateTrueFluentFuture());
+ final FluentFuture<Boolean> exists = tx.exists(LogicalDatastoreType.CONFIGURATION, id);
+ assertTrue(exists.get());
}
@Test
public void getIdentifier() throws Exception {
final ReadWriteTx tx2 = new ReadWriteTx(null, null);
- Assert.assertNotEquals(tx.getIdentifier(), tx2.getIdentifier());
+ assertNotEquals(tx.getIdentifier(), tx2.getIdentifier());
}
-
}
import org.mockito.ArgumentCaptor;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionChainClosedException;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionChainListener;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataBroker;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataReadOnlyTransaction;
+import org.opendaylight.mdsal.common.api.TransactionCommitFailedException;
+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;
public class TxChainTest {
@Mock
private DOMDataBroker broker;
@Mock
- private TransactionChainListener listener;
+ private DOMTransactionChainListener listener;
@Mock
- private DOMDataReadOnlyTransaction readOnlyTx;
+ private DOMDataTreeReadTransaction readOnlyTx;
@Mock
private AbstractWriteTx writeOnlyTx1;
@Mock
chain.newWriteOnlyTransaction();
}
- @Test(expected = TransactionChainClosedException.class)
+ @Test(expected = DOMTransactionChainClosedException.class)
public void testCloseAfterFinished() throws Exception {
chain.close();
verify(listener).onTransactionChainSuccessful(chain);
* 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.sal.connect.netconf.sal.tx;
import static org.mockito.ArgumentMatchers.any;
import org.junit.Test;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcService;
-import org.opendaylight.controller.md.sal.dom.spi.DefaultDOMRpcResult;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.dom.api.DOMRpcService;
+import org.opendaylight.mdsal.dom.spi.DefaultDOMRpcResult;
import org.opendaylight.netconf.sal.connect.netconf.util.NetconfBaseOps;
import org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil;
import org.opendaylight.netconf.sal.connect.util.RemoteDeviceId;
* 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.sal.connect.netconf.sal.tx;
import static org.mockito.ArgumentMatchers.any;
import org.junit.Test;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcService;
-import org.opendaylight.controller.md.sal.dom.spi.DefaultDOMRpcResult;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.dom.api.DOMRpcService;
+import org.opendaylight.mdsal.dom.spi.DefaultDOMRpcResult;
import org.opendaylight.netconf.sal.connect.netconf.util.NetconfBaseOps;
import org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil;
import org.opendaylight.netconf.sal.connect.util.RemoteDeviceId;
* 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.sal.connect.netconf.sal.tx;
import static org.mockito.ArgumentMatchers.any;
import org.junit.Test;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcService;
-import org.opendaylight.controller.md.sal.dom.spi.DefaultDOMRpcResult;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.dom.api.DOMRpcService;
+import org.opendaylight.mdsal.dom.spi.DefaultDOMRpcResult;
import org.opendaylight.netconf.sal.connect.netconf.util.NetconfBaseOps;
import org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil;
import org.opendaylight.netconf.sal.connect.util.RemoteDeviceId;
import org.junit.Test;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcException;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcResult;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcService;
-import org.opendaylight.controller.md.sal.dom.spi.DefaultDOMRpcResult;
+import org.opendaylight.mdsal.dom.api.DOMRpcException;
+import org.opendaylight.mdsal.dom.api.DOMRpcResult;
+import org.opendaylight.mdsal.dom.api.DOMRpcService;
+import org.opendaylight.mdsal.dom.spi.DefaultDOMRpcResult;
import org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil;
import org.opendaylight.netconf.sal.connect.util.RemoteDeviceId;
import org.opendaylight.yangtools.util.xml.UntrustedXML;
* 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.sal.connect.netconf.schema.mapping;
import java.io.InputStream;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcResult;
+import org.opendaylight.mdsal.dom.api.DOMRpcResult;
import org.opendaylight.netconf.api.NetconfMessage;
import org.opendaylight.netconf.api.xml.XmlUtil;
import org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil;
import org.hamcrest.CoreMatchers;
import org.junit.Before;
import org.junit.Test;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcResult;
import org.opendaylight.mdsal.binding.generator.impl.ModuleInfoBackedContext;
import org.opendaylight.mdsal.dom.api.DOMActionResult;
import org.opendaylight.mdsal.dom.api.DOMDataTreeIdentifier;
+import org.opendaylight.mdsal.dom.api.DOMRpcResult;
import org.opendaylight.netconf.api.NetconfMessage;
import org.opendaylight.netconf.api.xml.XmlUtil;
import org.opendaylight.netconf.sal.connect.netconf.schema.NetconfRemoteSchemaYangSourceProvider;
.nodeWithKey(Schema.QNAME, keys).build();
final DataContainerChild<?, ?> editConfigStructure =
createEditConfigStructure(BaseSchema.BASE_NETCONF_CTX_WITH_NOTIFICATIONS.getSchemaContext(), id,
- com.google.common.base.Optional.absent(), com.google.common.base.Optional.fromNullable(schemaNode));
+ Optional.empty(), Optional.ofNullable(schemaNode));
final DataContainerChild<?, ?> target = NetconfBaseOps.getTargetNode(NETCONF_CANDIDATE_QNAME);
* 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.sal.connect.netconf.schema.mapping;
import javax.xml.transform.dom.DOMSource;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
-import org.opendaylight.controller.md.sal.dom.api.DOMNotification;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcResult;
+import org.opendaylight.mdsal.dom.api.DOMNotification;
+import org.opendaylight.mdsal.dom.api.DOMRpcResult;
import org.opendaylight.netconf.api.NetconfMessage;
import org.opendaylight.netconf.api.xml.XmlUtil;
import org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil;
* 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.sal.connect.netconf.util;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
-import com.google.common.base.Optional;
+import com.google.common.util.concurrent.FluentFuture;
import java.io.IOException;
import java.io.InputStream;
import java.net.InetSocketAddress;
import java.util.ArrayList;
import java.util.List;
+import java.util.Optional;
import org.custommonkey.xmlunit.Diff;
import org.custommonkey.xmlunit.XMLUnit;
import org.junit.Assert;
import org.mockito.ArgumentMatcher;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcService;
+import org.opendaylight.mdsal.dom.api.DOMRpcService;
import org.opendaylight.netconf.api.NetconfMessage;
import org.opendaylight.netconf.api.xml.XmlUtil;
import org.opendaylight.netconf.sal.connect.api.MessageTransformer;
final NetconfMessage ok = new NetconfMessage(XmlUtil.readXmlToDocument(okStream));
final NetconfMessage data = new NetconfMessage(XmlUtil.readXmlToDocument(dataStream));
when(listener.sendRequest(any(), eq(NetconfMessageTransformUtil.NETCONF_GET_CONFIG_QNAME)))
- .thenReturn(RpcResultBuilder.success(data).buildFuture());
+ .thenReturn(FluentFuture.from(RpcResultBuilder.success(data).buildFuture()));
when(listener.sendRequest(any(), eq(NetconfMessageTransformUtil.NETCONF_GET_QNAME)))
- .thenReturn(RpcResultBuilder.success(data).buildFuture());
+ .thenReturn(FluentFuture.from(RpcResultBuilder.success(data).buildFuture()));
when(listener.sendRequest(any(), eq(NetconfMessageTransformUtil.NETCONF_EDIT_CONFIG_QNAME)))
- .thenReturn(RpcResultBuilder.success(ok).buildFuture());
+ .thenReturn(FluentFuture.from(RpcResultBuilder.success(ok).buildFuture()));
when(listener.sendRequest(any(), eq(NetconfMessageTransformUtil.NETCONF_COPY_CONFIG_QNAME)))
- .thenReturn(RpcResultBuilder.success(ok).buildFuture());
+ .thenReturn(FluentFuture.from(RpcResultBuilder.success(ok).buildFuture()));
when(listener.sendRequest(any(), eq(NetconfMessageTransformUtil.NETCONF_DISCARD_CHANGES_QNAME)))
- .thenReturn(RpcResultBuilder.success(ok).buildFuture());
+ .thenReturn(FluentFuture.from(RpcResultBuilder.success(ok).buildFuture()));
when(listener.sendRequest(any(), eq(NetconfMessageTransformUtil.NETCONF_VALIDATE_QNAME)))
- .thenReturn(RpcResultBuilder.success(ok).buildFuture());
+ .thenReturn(FluentFuture.from(RpcResultBuilder.success(ok).buildFuture()));
when(listener.sendRequest(any(), eq(NetconfMessageTransformUtil.NETCONF_LOCK_QNAME)))
- .thenReturn(RpcResultBuilder.success(ok).buildFuture());
+ .thenReturn(FluentFuture.from(RpcResultBuilder.success(ok).buildFuture()));
when(listener.sendRequest(any(), eq(NetconfMessageTransformUtil.NETCONF_UNLOCK_QNAME)))
- .thenReturn(RpcResultBuilder.success(ok).buildFuture());
+ .thenReturn(FluentFuture.from(RpcResultBuilder.success(ok).buildFuture()));
when(listener.sendRequest(any(), eq(NetconfMessageTransformUtil.NETCONF_COMMIT_QNAME)))
- .thenReturn(RpcResultBuilder.success(ok).buildFuture());
+ .thenReturn(FluentFuture.from(RpcResultBuilder.success(ok).buildFuture()));
final SchemaContext schemaContext =
YangParserTestUtils.parseYangResource("/schemas/test-module.yang");
final MessageTransformer<NetconfMessage> transformer = new NetconfMessageTransformer(schemaContext, true);
@Test
public void testGetConfigRunning() throws Exception {
- baseOps.getConfigRunning(callback, Optional.absent());
+ baseOps.getConfigRunning(callback, Optional.empty());
verifyMessageSent("getConfig", NetconfMessageTransformUtil.NETCONF_GET_CONFIG_QNAME);
}
@Test
public void testGetConfigCandidate() throws Exception {
- baseOps.getConfigCandidate(callback, Optional.absent());
+ baseOps.getConfigCandidate(callback, Optional.empty());
verifyMessageSent("getConfig_candidate", NetconfMessageTransformUtil.NETCONF_GET_CONFIG_QNAME);
}
@Test
public void testGet() throws Exception {
- baseOps.get(callback, Optional.absent());
+ baseOps.get(callback, Optional.empty());
verifyMessageSent("get", NetconfMessageTransformUtil.NETCONF_GET_QNAME);
}
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import org.opendaylight.aaa.encrypt.AAAEncryptionService;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netconf.api.xml.XmlUtil;
import org.opendaylight.netconf.sal.connect.util.NetconfSalKeystoreService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.keystore.rev171017.AddPrivateKeyInput;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import org.opendaylight.aaa.encrypt.AAAEncryptionService;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.netconf.sal.connect.util.NetconfTopologyRPCProvider;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Host;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
*/
package org.opendaylight.netconf.sal.connect.netconf.util;
-import com.google.common.base.Optional;
import com.google.common.collect.ImmutableMap;
import java.io.IOException;
import java.net.URISyntaxException;
import java.util.Arrays;
import java.util.Collection;
import java.util.Map;
+import java.util.Optional;
import javax.xml.transform.dom.DOMSource;
import org.custommonkey.xmlunit.Diff;
import org.custommonkey.xmlunit.XMLUnit;
private final String testDataset;
public SchemalessRpcStructureTransformerTest(
- YangInstanceIdentifier path, String testDataset,
- Class<? extends Exception> expectedException) throws IOException, SAXException, URISyntaxException {
+ final YangInstanceIdentifier path, final String testDataset,
+ final Class<? extends Exception> expectedException) throws IOException, SAXException, URISyntaxException {
this.path = path;
this.testDataset = testDataset;
this.expectedException = expectedException;
Assert.assertTrue(String.format("Input %s: %s", testDataset, diff.toString()), diff.similar());
}
- private static YangInstanceIdentifier.NodeIdentifier createNodeId(String name) {
+ private static YangInstanceIdentifier.NodeIdentifier createNodeId(final String name) {
return new YangInstanceIdentifier.NodeIdentifier(QName.create(NAMESPACE, name));
}
private static YangInstanceIdentifier.NodeIdentifierWithPredicates createListNodeId(
- String nodeName, String keyName, String id) {
+ final String nodeName, final String keyName, final String id) {
return new YangInstanceIdentifier
.NodeIdentifierWithPredicates(QName.create(NAMESPACE, nodeName), QName.create(NAMESPACE, keyName), id);
}
private static YangInstanceIdentifier.NodeIdentifierWithPredicates createListNodeId(
- String nodeName, Map<QName, Object> keys) {
+ final String nodeName, final Map<QName, Object> keys) {
return new YangInstanceIdentifier.NodeIdentifierWithPredicates(QName.create(NAMESPACE, nodeName), keys);
}
}
<artifactId>netconf-ssh</artifactId>
</dependency>
<dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>sal-inmemory-datastore</artifactId>
+ <groupId>org.opendaylight.mdsal</groupId>
+ <artifactId>mdsal-dom-inmemory-datastore</artifactId>
</dependency>
<dependency>
<groupId>org.opendaylight.netconf</groupId>
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.netconf.test.tool;
import com.google.common.collect.ClassToInstanceMap;
import java.util.Set;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataBroker;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataWriteTransaction;
-import org.opendaylight.controller.md.sal.dom.broker.impl.SerializedDOMDataBroker;
-import org.opendaylight.controller.md.sal.dom.store.impl.InMemoryDOMDataStoreFactory;
-import org.opendaylight.controller.sal.core.spi.data.DOMStore;
+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.DOMSchemaServiceExtension;
+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.netconf.api.capability.Capability;
import org.opendaylight.netconf.api.monitoring.CapabilityListener;
import org.opendaylight.netconf.impl.SessionIdProvider;
YangInstanceIdentifier yangInstanceIdentifier = YangInstanceIdentifier.builder().node(NetconfState.QNAME)
.build();
- final DOMDataWriteTransaction tx = dataBroker.newWriteOnlyTransaction();
+ final DOMDataTreeWriteTransaction tx = dataBroker.newWriteOnlyTransaction();
tx.put(LogicalDatastoreType.OPERATIONAL, yangInstanceIdentifier, netconf);
try {
private static DOMDataBroker createDataStore(final DOMSchemaService schemaService, final long sessionId) {
LOG.debug("Session {}: Creating data stores for simulated device", sessionId);
- final DOMStore operStore = InMemoryDOMDataStoreFactory
- .create("DOM-OPER", schemaService);
- final DOMStore configStore = InMemoryDOMDataStoreFactory
- .create("DOM-CFG", schemaService);
+ final DOMStore operStore = InMemoryDOMDataStoreFactory.create("DOM-OPER", schemaService);
+ final DOMStore configStore = InMemoryDOMDataStoreFactory.create("DOM-CFG", schemaService);
ExecutorService listenableFutureExecutor = SpecialExecutors.newBlockingBoundedCachedThreadPool(
16, 16, "CommitFutures", MdsalOperationProvider.class);
<dependencies>
<dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>sal-binding-api</artifactId>
+ <groupId>org.opendaylight.mdsal</groupId>
+ <artifactId>mdsal-binding-api</artifactId>
</dependency>
<dependency>
<groupId>com.google.guava</groupId>
import java.util.ArrayList;
import java.util.List;
import javax.annotation.Nullable;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
import org.opendaylight.mdsal.common.api.CommitInfo;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Uri;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.library.rev160621.ModulesState;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.library.rev160621.ModulesStateBuilder;
<odl:clustered-app-config id="yanglibConfig"
binding-class="org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.yanglib.impl.rev141210.YanglibConfig"/>
- <reference id="dataBroker" interface="org.opendaylight.controller.md.sal.binding.api.DataBroker"/>
+ <reference id="dataBroker" interface="org.opendaylight.mdsal.binding.api.DataBroker"/>
<reference id="webServer" interface="org.opendaylight.aaa.web.WebServer"/>
<reference id="webContextSecurer" interface="org.opendaylight.aaa.web.WebContextSecurer"/>
<reference id="servletSupport" interface="org.opendaylight.aaa.web.servlet.ServletSupport" />
import org.mockito.ArgumentCaptor;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Uri;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.library.rev160621.ModulesState;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.library.rev160621.ModulesStateBuilder;
Code Review / netconf.git / commitdiff