*/
package org.opendaylight.transportpce.common;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService;
-import org.opendaylight.controller.md.sal.binding.api.NotificationService;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataBroker;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.NotificationPublishService;
+import org.opendaylight.mdsal.binding.api.NotificationService;
import org.opendaylight.mdsal.binding.dom.codec.impl.BindingNormalizedNodeCodecRegistry;
+import org.opendaylight.mdsal.dom.api.DOMDataBroker;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
public interface DataStoreContext {
import java.util.concurrent.Executors;
import javassist.ClassPool;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService;
-import org.opendaylight.controller.md.sal.binding.api.NotificationService;
-import org.opendaylight.controller.md.sal.binding.impl.BindingDOMDataBrokerAdapter;
-import org.opendaylight.controller.md.sal.binding.impl.BindingDOMNotificationPublishServiceAdapter;
-import org.opendaylight.controller.md.sal.binding.impl.BindingDOMNotificationServiceAdapter;
-import org.opendaylight.controller.md.sal.binding.impl.BindingToNormalizedNodeCodec;
-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.broker.impl.DOMNotificationRouter;
-import org.opendaylight.controller.md.sal.dom.broker.impl.SerializedDOMDataBroker;
-import org.opendaylight.controller.md.sal.dom.store.impl.InMemoryDOMDataStore;
-import org.opendaylight.controller.sal.core.spi.data.DOMStore;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.NotificationPublishService;
+import org.opendaylight.mdsal.binding.api.NotificationService;
+import org.opendaylight.mdsal.binding.dom.adapter.BindingDOMDataBrokerAdapter;
+import org.opendaylight.mdsal.binding.dom.adapter.BindingDOMNotificationPublishServiceAdapter;
+import org.opendaylight.mdsal.binding.dom.adapter.BindingDOMNotificationServiceAdapter;
+import org.opendaylight.mdsal.binding.dom.adapter.BindingToNormalizedNodeCodec;
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.GeneratedClassLoadingStrategy;
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.DOMSchemaService;
import org.opendaylight.mdsal.dom.api.DOMSchemaServiceExtension;
+import org.opendaylight.mdsal.dom.broker.DOMNotificationRouter;
+import org.opendaylight.mdsal.dom.broker.SerializedDOMDataBroker;
+import org.opendaylight.mdsal.dom.spi.store.DOMStore;
+import org.opendaylight.mdsal.dom.store.inmemory.InMemoryDOMDataStore;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.util.ListenerRegistry;
import org.opendaylight.yangtools.yang.binding.YangModelBindingProvider;
@Override
public NotificationService createNotificationService() {
- return new BindingDOMNotificationServiceAdapter(this.mockedSchemaContext.bindingStreamCodecs,
- this.domNotificationRouter);
+ return new BindingDOMNotificationServiceAdapter(this.domNotificationRouter,
+ this.mockedSchemaContext.bindingStreamCodecs);
}
@Override
public NotificationPublishService createNotificationPublishService() {
- return new BindingDOMNotificationPublishServiceAdapter(this.mockedSchemaContext.bindingToNormalized,
- this.domNotificationRouter);
+ return new BindingDOMNotificationPublishServiceAdapter(this.domNotificationRouter,
+ this.mockedSchemaContext.bindingToNormalized);
}
@Override
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.controller.md.sal.binding.api.MountPoint;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.sal.binding.api.RpcConsumerRegistry;
+import org.opendaylight.mdsal.binding.api.MountPoint;
+import org.opendaylight.mdsal.binding.api.RpcConsumerRegistry;
import org.opendaylight.mdsal.common.api.CommitInfo;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.transportpce.common.Timeouts;
import org.opendaylight.transportpce.common.device.DeviceTransaction;
import org.opendaylight.transportpce.common.device.DeviceTransactionManager;
LOG.error("Failed to obtain mount point for device {}!", nodeId);
return Collections.emptyList();
}
- final Optional<RpcConsumerRegistry> service = mountPoint.getService(RpcConsumerRegistry.class).toJavaUtil();
+ final Optional<RpcConsumerRegistry> service = mountPoint.getService(RpcConsumerRegistry.class);
if (!service.isPresent()) {
LOG.error("Failed to get RpcService for node {}", nodeId);
}
import java.util.concurrent.Future;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.controller.md.sal.binding.api.MountPoint;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.sal.binding.api.RpcConsumerRegistry;
+import org.opendaylight.mdsal.binding.api.MountPoint;
+import org.opendaylight.mdsal.binding.api.RpcConsumerRegistry;
import org.opendaylight.mdsal.common.api.CommitInfo;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.transportpce.common.Timeouts;
import org.opendaylight.transportpce.common.device.DeviceTransaction;
import org.opendaylight.transportpce.common.device.DeviceTransactionManager;
LOG.error("Failed to obtain mount point for device {}!", nodeId);
return Collections.emptyList();
}
- final Optional<RpcConsumerRegistry> service = mountPoint.getService(RpcConsumerRegistry.class).toJavaUtil();
+ final Optional<RpcConsumerRegistry> service = mountPoint.getService(RpcConsumerRegistry.class);
if (!service.isPresent()) {
LOG.error("Failed to get RpcService for node {}", nodeId);
}
package org.opendaylight.transportpce.common.device;
-import com.google.common.base.Optional;
import com.google.common.util.concurrent.FluentFuture;
import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.ListenableFuture;
+import java.util.Optional;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.atomic.AtomicBoolean;
import javax.annotation.Nullable;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
import org.opendaylight.mdsal.common.api.CommitInfo;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yangtools.util.concurrent.FluentFutures;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
-import org.opendaylight.controller.md.sal.binding.api.MountPoint;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.MountPoint;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.MountPoint;
-import org.opendaylight.controller.md.sal.binding.api.MountPointService;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.MountPoint;
+import org.opendaylight.mdsal.binding.api.MountPointService;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.transportpce.common.InstanceIdentifiers;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
private Optional<DataBroker> getDeviceDataBroker(String deviceId) {
Optional<MountPoint> netconfNode = getDeviceMountPoint(deviceId);
if (netconfNode.isPresent()) {
- return netconfNode.get().getService(DataBroker.class).toJavaUtil();
+ return netconfNode.get().getService(DataBroker.class);
} else {
LOG.error("Device mount point not found for : {}", deviceId);
return Optional.empty();
public Optional<MountPoint> getDeviceMountPoint(String deviceId) {
InstanceIdentifier<Node> netconfNodeIID = InstanceIdentifiers.NETCONF_TOPOLOGY_II.child(Node.class,
new NodeKey(new NodeId(deviceId)));
- return mountPointService.getMountPoint(netconfNodeIID).toJavaUtil();
+ return mountPointService.getMountPoint(netconfNodeIID);
}
@Override
if (deviceTxOpt.isPresent()) {
DeviceTransaction deviceTx = deviceTxOpt.get();
try {
- return deviceTx.read(logicalDatastoreType, path).get(timeout, timeUnit).toJavaUtil();
+ return deviceTx.read(logicalDatastoreType, path).get(timeout, timeUnit);
} catch (InterruptedException | ExecutionException | TimeoutException e) {
LOG.error("Exception thrown while reading data from device {}! IID: {}", deviceId, path, e);
} finally {
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.transportpce.common.StringConstants;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev190702.Network;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev190702.network.Nodes;
*/
InstanceIdentifier<NodeInfo> nodeInfoIID = InstanceIdentifier.builder(Network.class).child(Nodes.class,
new NodesKey(nodeId)).child(NodeInfo.class).build();
- try (ReadOnlyTransaction readTx = dataBroker.newReadOnlyTransaction()) {
+ try (ReadTransaction readTx = dataBroker.newReadOnlyTransaction()) {
Optional<NodeInfo> nodeInfoObj =
- readTx.read(LogicalDatastoreType.CONFIGURATION, nodeInfoIID).get().toJavaUtil();
+ readTx.read(LogicalDatastoreType.CONFIGURATION, nodeInfoIID).get();
if (nodeInfoObj.isPresent()) {
NodeInfo nodInfo = nodeInfoObj.get();
switch (nodInfo.getOpenroadmVersion()) {
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
-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.ReadTransaction;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev190702.Network;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev190702.network.Nodes;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev190702.network.NodesKey;
*/
InstanceIdentifier<Mapping> portMappingIID = InstanceIdentifier.builder(Network.class).child(Nodes.class,
new NodesKey(nodeId)).child(Mapping.class, new MappingKey(logicalConnPoint)).build();
- try (ReadOnlyTransaction readTx = this.dataBroker.newReadOnlyTransaction()) {
- Optional<Mapping> mapObject = readTx.read(LogicalDatastoreType.CONFIGURATION, portMappingIID).get()
- .toJavaUtil();
+ try (ReadTransaction readTx = this.dataBroker.newReadOnlyTransaction()) {
+ Optional<Mapping> mapObject = readTx.read(LogicalDatastoreType.CONFIGURATION, portMappingIID).get();
if (mapObject.isPresent()) {
Mapping mapping = mapObject.get();
LOG.info("Found mapping for {} - {}. Mapping: {}", nodeId, logicalConnPoint, mapping.toString());
public Nodes getNode(String nodeId) {
InstanceIdentifier<Nodes> nodePortMappingIID = InstanceIdentifier.builder(Network.class).child(Nodes.class,
new NodesKey(nodeId)).build();
- try (ReadOnlyTransaction readTx = this.dataBroker.newReadOnlyTransaction()) {
- Optional<Nodes> nodePortMapObject = readTx.read(LogicalDatastoreType.CONFIGURATION, nodePortMappingIID)
- .get().toJavaUtil();
+ try (ReadTransaction readTx = this.dataBroker.newReadOnlyTransaction()) {
+ Optional<Nodes> nodePortMapObject =
+ readTx.read(LogicalDatastoreType.CONFIGURATION, nodePortMappingIID).get();
if (nodePortMapObject.isPresent()) {
Nodes node = nodePortMapObject.get();
LOG.info("Found node {} in portmapping.", nodeId);
import java.util.stream.Collectors;
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.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.transportpce.common.StringConstants;
import org.opendaylight.transportpce.common.Timeouts;
import org.opendaylight.transportpce.common.device.DeviceTransactionManager;
import java.util.concurrent.ExecutionException;
import java.util.stream.Collectors;
import org.eclipse.jdt.annotation.NonNull;
-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.transportpce.common.StringConstants;
import org.opendaylight.transportpce.common.Timeouts;
import org.opendaylight.transportpce.common.device.DeviceTransactionManager;
import com.google.common.util.concurrent.FluentFuture;
import com.google.common.util.concurrent.ListenableFuture;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.mdsal.common.api.CommitInfo;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
}
- public <T extends DataObject> ListenableFuture<com.google.common.base.Optional<T>>
+ public <T extends DataObject> ListenableFuture<java.util.Optional<T>>
read(LogicalDatastoreType store, InstanceIdentifier<T> path) {
return requestProcessor.read(store, path);
}
package org.opendaylight.transportpce.common.network;
-import com.google.common.base.Optional;
import com.google.common.util.concurrent.FluentFuture;
import com.google.common.util.concurrent.ListenableFuture;
+import java.util.Optional;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.mdsal.common.api.CommitInfo;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
*/
package org.opendaylight.transportpce.common.network;
-import com.google.common.base.Optional;
import com.google.common.util.concurrent.FluentFuture;
import com.google.common.util.concurrent.ListenableFuture;
+import java.util.Optional;
import java.util.concurrent.locks.ReentrantReadWriteLock;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
-import org.opendaylight.controller.md.sal.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.ReadTransaction;
+import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
import org.opendaylight.mdsal.common.api.CommitInfo;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.Logger;
private final DataBroker dataBroker;
private ReadWriteTransaction rwTx;
- private ReadOnlyTransaction readTx;
+ private ReadTransaction readTx;
private ReentrantReadWriteLock lock;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.mdsal.common.api.CommitInfo;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.transportpce.common.StringConstants;
import org.opendaylight.transportpce.common.Timeouts;
import org.opendaylight.transportpce.common.device.DeviceTransaction;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.mdsal.common.api.CommitInfo;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.transportpce.common.StringConstants;
import org.opendaylight.transportpce.common.Timeouts;
import org.opendaylight.transportpce.common.device.DeviceTransaction;
xmlns:odl="http://opendaylight.org/xmlns/blueprint/v1.0.0"
odl:use-default-for-reference-types="true">
- <reference id="mountPointService" interface="org.opendaylight.controller.md.sal.binding.api.MountPointService" />
- <reference id="dataBroker" interface="org.opendaylight.controller.md.sal.binding.api.DataBroker" odl:type="default" />
+ <reference id="mountPointService" interface="org.opendaylight.mdsal.binding.api.MountPointService" />
+ <reference id="dataBroker" interface="org.opendaylight.mdsal.binding.api.DataBroker" odl:type="default" />
<bean id="deviceTransactionManager" class="org.opendaylight.transportpce.common.device.DeviceTransactionManagerImpl"
destroy-method="preDestroy" >
<service ref="FixedFlexImpl" interface="org.opendaylight.transportpce.common.fixedflex.FixedFlexInterface"/>
-</blueprint>
\ No newline at end of file
+</blueprint>
import static org.mockito.Matchers.any;
-import com.google.common.base.Optional;
import com.google.common.util.concurrent.FluentFuture;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListeningExecutorService;
import com.google.common.util.concurrent.MoreExecutors;
import java.util.LinkedList;
import java.util.List;
+import java.util.Optional;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.runners.MockitoJUnitRunner;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.MountPoint;
-import org.opendaylight.controller.md.sal.binding.api.MountPointService;
-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.MountPoint;
+import org.opendaylight.mdsal.binding.api.MountPointService;
+import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
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.network.rev180226.networks.Network;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.networks.NetworkBuilder;
import org.opendaylight.yangtools.util.concurrent.FluentFutures;
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.DataObjectModification.ModificationType;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeChangeListener;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
-import org.opendaylight.controller.md.sal.binding.api.MountPoint;
-import org.opendaylight.controller.md.sal.binding.api.NotificationService;
-import org.opendaylight.controller.sal.binding.api.RpcConsumerRegistry;
+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.DataTreeModification;
+import org.opendaylight.mdsal.binding.api.MountPoint;
+import org.opendaylight.mdsal.binding.api.NotificationService;
+import org.opendaylight.mdsal.binding.api.RpcConsumerRegistry;
import org.opendaylight.transportpce.common.StringConstants;
import org.opendaylight.transportpce.common.device.DeviceTransactionManager;
import org.opendaylight.transportpce.networkmodel.dto.NodeRegistration;
}
final Optional<NotificationService> notificationService =
- mountPoint.getService(NotificationService.class).toJavaUtil();
+ mountPoint.getService(NotificationService.class);
if (!notificationService.isPresent()) {
LOG.error("Failed to get RpcService for node {}", nodeId);
return;
streamName = "OPENROADM";
}
- final Optional<RpcConsumerRegistry> service = mountPoint.getService(RpcConsumerRegistry.class)
- .toJavaUtil();
+ final Optional<RpcConsumerRegistry> service = mountPoint.getService(RpcConsumerRegistry.class);
if (service.isPresent()) {
final NotificationsService rpcService = service.get().getRpcService(NotificationsService.class);
if (rpcService == null) {
if (streamName == null) {
streamName = "OPENROADM";
}
- final Optional<RpcConsumerRegistry> service = mountPoint.getService(RpcConsumerRegistry.class).toJavaUtil();
+ final Optional<RpcConsumerRegistry> service = mountPoint.getService(RpcConsumerRegistry.class);
if (service.isPresent()) {
final NotificationsService rpcService = service.get().getRpcService(NotificationsService.class);
if (rpcService == null) {
*/
package org.opendaylight.transportpce.networkmodel;
-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.controller.sal.binding.api.BindingAwareBroker;
-import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataTreeIdentifier;
+import org.opendaylight.mdsal.binding.api.RpcProviderService;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.transportpce.common.InstanceIdentifiers;
import org.opendaylight.transportpce.common.network.NetworkTransactionService;
import org.opendaylight.transportpce.networkmodel.util.ClliNetwork;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.networkutils.rev170818.TransportpceNetworkutilsService;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
+import org.opendaylight.yangtools.concepts.ObjectRegistration;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
private NetworkTransactionService networkTransactionService;
private final DataBroker dataBroker;
- private final RpcProviderRegistry rpcProviderRegistry;
+ private final RpcProviderService rpcProviderService;
private final TransportpceNetworkutilsService networkutilsService;
private final NetConfTopologyListener topologyListener;
private final OpenRoadmFactory openRoadmFactory;
private ListenerRegistration<NetConfTopologyListener> dataTreeChangeListenerRegistration;
- private BindingAwareBroker.RpcRegistration<TransportpceNetworkutilsService> networkutilsServiceRpcRegistration;
+ private ObjectRegistration<TransportpceNetworkutilsService> networkutilsServiceRpcRegistration;
public NetworkModelProvider(NetworkTransactionService networkTransactionService,
- final DataBroker dataBroker, final RpcProviderRegistry rpcProviderRegistry,
+ final DataBroker dataBroker, final RpcProviderService rpcProviderService,
final TransportpceNetworkutilsService networkutilsService, final NetConfTopologyListener topologyListener,
OpenRoadmFactory openRoadmFactory) {
this.networkTransactionService = networkTransactionService;
this.dataBroker = dataBroker;
- this.rpcProviderRegistry = rpcProviderRegistry;
+ this.rpcProviderService = rpcProviderService;
this.networkutilsService = networkutilsService;
this.topologyListener = topologyListener;
this.openRoadmFactory = openRoadmFactory;
OpenRoadmNetwork.createOpenRoadmNetworkLayer(dataBroker);
openRoadmFactory.createTopoLayerVersionControl(networkTransactionService);
dataTreeChangeListenerRegistration =
- dataBroker.registerDataTreeChangeListener(new DataTreeIdentifier<>(LogicalDatastoreType.OPERATIONAL,
+ dataBroker.registerDataTreeChangeListener(DataTreeIdentifier.create(LogicalDatastoreType.OPERATIONAL,
InstanceIdentifiers.NETCONF_TOPOLOGY_II.child(Node.class)), topologyListener);
networkutilsServiceRpcRegistration =
- rpcProviderRegistry.addRpcImplementation(TransportpceNetworkutilsService.class, networkutilsService);
+ rpcProviderService.registerRpcImplementation(TransportpceNetworkutilsService.class, networkutilsService);
}
*/
package org.opendaylight.transportpce.networkmodel;
-import com.google.common.base.Optional;
import com.google.common.util.concurrent.ListenableFuture;
-
+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.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.ReadTransaction;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.transportpce.common.NetworkUtils;
import org.opendaylight.transportpce.networkmodel.util.OpenRoadmFactory;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.networkutils.rev170818.DeleteLinkInput;
//Check if link exists
try {
- ReadOnlyTransaction readOnlyTransaction = dataBroker.newReadOnlyTransaction();
+ ReadTransaction readOnlyTransaction = dataBroker.newReadOnlyTransaction();
Optional<Link> linkOptional = readOnlyTransaction.read(LogicalDatastoreType.CONFIGURATION, linkIID.build())
.get();
if (!linkOptional.isPresent()) {
package org.opendaylight.transportpce.networkmodel;
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.LogicalDatastoreType;
import org.opendaylight.transportpce.common.NetworkUtils;
import org.opendaylight.transportpce.networkmodel.util.LinkIdUtil;
import org.opendaylight.transportpce.networkmodel.util.OpenRoadmFactory;
import java.util.stream.Stream;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.MountPoint;
-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.MountPoint;
+import org.opendaylight.mdsal.binding.api.ReadTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.transportpce.common.Timeouts;
import org.opendaylight.transportpce.common.device.DeviceTransactionManager;
import org.opendaylight.transportpce.common.network.NetworkTransactionService;
public Direction getDegreeDirection(Integer degreeCounter, NodeId nodeId) {
InstanceIdentifier<Nodes> nodesIID = InstanceIdentifier.builder(Network.class)
.child(Nodes.class, new NodesKey(nodeId.getValue())).build();
- try (ReadOnlyTransaction readTx = this.dataBroker.newReadOnlyTransaction()) {
- Optional<Nodes> nodesObject = readTx.read(LogicalDatastoreType.CONFIGURATION, nodesIID)
- .get().toJavaUtil();
+ try (ReadTransaction readTx = this.dataBroker.newReadOnlyTransaction()) {
+ Optional<Nodes> nodesObject = readTx.read(LogicalDatastoreType.CONFIGURATION, nodesIID).get();
if (nodesObject.isPresent() && (nodesObject.get().getMapping() != null)) {
List<Mapping> mappingList = nodesObject.get().getMapping();
mappingList = mappingList.stream().filter(mp -> mp.getLogicalConnectionPoint().contains("DEG"
private Integer getDegFromInterface(NodeId nodeId, String interfaceName) {
InstanceIdentifier<Nodes> nodesIID = InstanceIdentifier.builder(Network.class)
.child(Nodes.class, new NodesKey(nodeId.getValue())).build();
- try (ReadOnlyTransaction readTx = this.dataBroker.newReadOnlyTransaction()) {
- Optional<Nodes> nodesObject = readTx.read(LogicalDatastoreType.CONFIGURATION, nodesIID)
- .get().toJavaUtil();
+ try (ReadTransaction readTx = this.dataBroker.newReadOnlyTransaction()) {
+ Optional<Nodes> nodesObject = readTx.read(LogicalDatastoreType.CONFIGURATION, nodesIID).get();
if (nodesObject.isPresent() && (nodesObject.get().getCpToDegree() != null)) {
List<CpToDegree> cpToDeg = nodesObject.get().getCpToDegree();
Stream cpToDegStream = cpToDeg.stream().filter(cp -> cp.getInterfaceName() != null)
import com.google.common.util.concurrent.FluentFuture;
import java.util.concurrent.ExecutionException;
import org.eclipse.jdt.annotation.NonNull;
-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.transportpce.common.NetworkUtils;
import org.opendaylight.transportpce.networkmodel.util.LinkIdUtil;
import org.opendaylight.transportpce.networkmodel.util.OpenRoadmFactory;
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.http.org.opendaylight.transportpce.alarmsuppression.rev171102.ServiceNodelist;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.alarmsuppression.rev171102.service.nodelist.Nodelist;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.alarmsuppression.rev171102.service.nodelist.nodelist.Nodes;
List<Nodes> allNodeList = new ArrayList<>();
InstanceIdentifier<ServiceNodelist> serviceNodeListIID = InstanceIdentifier.create(ServiceNodelist.class);
try {
- ReadOnlyTransaction rtx = dataBroker.newReadOnlyTransaction();
- com.google.common.base.Optional<ServiceNodelist> serviceListObject =
+ ReadTransaction rtx = dataBroker.newReadOnlyTransaction();
+ Optional<ServiceNodelist> serviceListObject =
rtx.read(LogicalDatastoreType.OPERATIONAL, serviceNodeListIID).get();
if (serviceListObject.isPresent()) {
for (Nodelist nodelist : serviceListObject.get().getNodelist()) {
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.http.org.opendaylight.transportpce.alarmsuppression.rev171102.ServiceNodelist;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.alarmsuppression.rev171102.service.nodelist.Nodelist;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.alarmsuppression.rev171102.service.nodelist.nodelist.Nodes;
List<Nodes> allNodeList = new ArrayList<>();
InstanceIdentifier<ServiceNodelist> serviceNodeListIID = InstanceIdentifier.create(ServiceNodelist.class);
try {
- ReadOnlyTransaction rtx = dataBroker.newReadOnlyTransaction();
- com.google.common.base.Optional<ServiceNodelist> serviceListObject =
+ ReadTransaction rtx = dataBroker.newReadOnlyTransaction();
+ Optional<ServiceNodelist> serviceListObject =
rtx.read(LogicalDatastoreType.OPERATIONAL, serviceNodeListIID).get();
if (serviceListObject.isPresent()) {
for (Nodelist nodelist : serviceListObject.get().getNodelist()) {
import java.util.concurrent.TimeoutException;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.transportpce.common.NetworkUtils;
import org.opendaylight.transportpce.common.device.DeviceTransactionManager;
import org.opendaylight.transportpce.common.mapping.PortMapping;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
-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.transportpce.common.NetworkUtils;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev190702.network.nodes.NodeInfo;
import org.opendaylight.yang.gen.v1.http.org.openroadm.clli.network.rev181130.NetworkTypes1;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
-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.transportpce.common.NetworkUtils;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev190702.network.nodes.NodeInfo;
import org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev181130.NetworkTypes1;
import java.util.concurrent.TimeoutException;
import java.util.stream.Collectors;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.transportpce.common.NetworkUtils;
import org.opendaylight.transportpce.common.device.DeviceTransactionManager;
import org.opendaylight.transportpce.common.network.NetworkTransactionService;
InstanceIdentifierBuilder<Link> linkIID = InstanceIdentifier.builder(Networks.class).child(Network.class,
new NetworkKey(new NetworkId(NetworkUtils.OVERLAY_NETWORK_ID))).augmentation(Network1.class)
.child(Link.class, new LinkKey(linkId));
- com.google.common.base.Optional<Link> link =
+ java.util.Optional<Link> link =
networkTransactionService.read(LogicalDatastoreType.CONFIGURATION,linkIID.build()).get();
if (link.isPresent()) {
LinkBuilder linkBuilder = new LinkBuilder(link.get());
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.transportpce.common.NetworkUtils;
import org.opendaylight.transportpce.common.network.NetworkTransactionService;
import org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev181130.Link1;
InstanceIdentifier.InstanceIdentifierBuilder<Link> linkIID = InstanceIdentifier.builder(Networks.class)
.child(Network.class, new NetworkKey(new NetworkId(NetworkUtils.OVERLAY_NETWORK_ID)))
.augmentation(Network1.class).child(Link.class, new LinkKey(linkId));
- com.google.common.base.Optional<Link> link =
+ java.util.Optional<Link> link =
networkTransactionService.read(LogicalDatastoreType.CONFIGURATION,linkIID.build()).get();
if (link.isPresent()) {
LinkBuilder linkBuilder = new LinkBuilder(link.get());
<blueprint xmlns="http://www.osgi.org/xmlns/blueprint/v1.0.0" xmlns:odl="http://opendaylight.org/xmlns/blueprint/v1.0.0"
odl:use-default-for-reference-types="true">
- <reference id="dataBroker" interface="org.opendaylight.controller.md.sal.binding.api.DataBroker"
- odl:type="default" />
- <reference id="rpcProviderRegistry" interface="org.opendaylight.controller.sal.binding.api.RpcProviderRegistry" />
+ <reference id="dataBroker" interface="org.opendaylight.mdsal.binding.api.DataBroker" odl:type="default" />
+ <reference id="rpcProviderService" interface="org.opendaylight.mdsal.binding.api.RpcProviderService" />
<reference id="deviceTransactionManager" interface="org.opendaylight.transportpce.common.device.DeviceTransactionManager" />
<reference id="portMapping" interface="org.opendaylight.transportpce.common.mapping.PortMapping" />
<reference id="networkTransactionImpl" interface="org.opendaylight.transportpce.common.network.NetworkTransactionService" />
init-method="init" destroy-method="close">
<argument ref="networkTransactionImpl" />
<argument ref="dataBroker" />
- <argument ref="rpcProviderRegistry" />
+ <argument ref="rpcProviderService" />
<argument ref="networkutilsServiceImpl" />
<argument ref="netconfTopologyListener" />
<argument ref="openRoadmFactory" />
package org.opendaylight.transportpce.olm;
-import org.opendaylight.controller.sal.binding.api.BindingAwareBroker.RpcRegistration;
-import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
+import org.opendaylight.mdsal.binding.api.RpcProviderService;
import org.opendaylight.transportpce.olm.service.OlmPowerService;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.TransportpceOlmService;
+import org.opendaylight.yangtools.concepts.ObjectRegistration;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
*/
public class OlmProvider {
private static final Logger LOG = LoggerFactory.getLogger(OlmProvider.class);
- private final RpcProviderRegistry rpcProviderRegistry;
+ private final RpcProviderService rpcProviderService;
private final OlmPowerService olmPowerService;
- private RpcRegistration<TransportpceOlmService> olmRPCRegistration;
+ private ObjectRegistration<TransportpceOlmService> olmRPCRegistration;
/**
* Instantiates a new olm provider.
* @param olmPowerService
* implementation of OlmService
- * @param rpcProviderRegistry
- * the rpc provider registry
+ * @param rpcProviderService
+ * the rpc provider service
*/
- public OlmProvider(final RpcProviderRegistry rpcProviderRegistry, final OlmPowerService olmPowerService) {
- this.rpcProviderRegistry = rpcProviderRegistry;
+ public OlmProvider(final RpcProviderService rpcProviderService, final OlmPowerService olmPowerService) {
+ this.rpcProviderService = rpcProviderService;
this.olmPowerService = olmPowerService;
}
public void init() {
LOG.info("OlmProvider Session Initiated");
// Initializing Notification module
- olmRPCRegistration = rpcProviderRegistry.addRpcImplementation(TransportpceOlmService.class,
+ olmRPCRegistration = rpcProviderService.registerRpcImplementation(TransportpceOlmService.class,
new OlmPowerServiceRpcImpl(this.olmPowerService));
}
import java.util.Map;
import java.util.Optional;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.transportpce.common.crossconnect.CrossConnect;
import org.opendaylight.transportpce.common.device.DeviceTransactionManager;
import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfaceException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.mdsal.common.api.CommitInfo;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.transportpce.common.Timeouts;
import org.opendaylight.transportpce.common.crossconnect.CrossConnect;
import org.opendaylight.transportpce.common.device.DeviceTransaction;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.mdsal.common.api.CommitInfo;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.transportpce.common.Timeouts;
import org.opendaylight.transportpce.common.crossconnect.CrossConnect;
import org.opendaylight.transportpce.common.device.DeviceTransaction;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import java.util.stream.Collectors;
-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.transportpce.common.InstanceIdentifiers;
import org.opendaylight.transportpce.common.NetworkUtils;
import org.opendaylight.transportpce.common.ResponseCodes;
.augmentation(Network1.class)
.build();
Optional<Network1> networkOptional;
- try (ReadOnlyTransaction rtx = this.dataBroker.newReadOnlyTransaction()) {
+ try (ReadTransaction rtx = this.dataBroker.newReadOnlyTransaction()) {
//TODO change to constant from Timeouts class when it will be merged.
networkOptional = rtx.read(LogicalDatastoreType.CONFIGURATION, networkIID).get(Timeouts.DATASTORE_READ,
- TimeUnit.MILLISECONDS).toJavaUtil();
+ TimeUnit.MILLISECONDS);
} catch (InterruptedException | ExecutionException | TimeoutException e) {
LOG.warn("Read of {} topology failed", NetworkUtils.OVERLAY_NETWORK_ID);
private String getRealNodeId(String mappedNodeId) {
KeyedInstanceIdentifier<Node, NodeKey> mappedNodeII =
InstanceIdentifiers.OVERLAY_NETWORK_II.child(Node.class, new NodeKey(new NodeId(mappedNodeId)));
- com.google.common.base.Optional<Node> realNode;
- try (ReadOnlyTransaction readOnlyTransaction = this.dataBroker.newReadOnlyTransaction()) {
+ Optional<Node> realNode;
+ try (ReadTransaction readOnlyTransaction = this.dataBroker.newReadOnlyTransaction()) {
realNode = readOnlyTransaction.read(LogicalDatastoreType.CONFIGURATION, mappedNodeII).get();
} catch (InterruptedException | ExecutionException e) {
LOG.error(e.getMessage(), e);
.augmentation(Network1.class).child(Link.class, new LinkKey(linkId))
.build();
Optional<Link> linkOptional;
- try (ReadOnlyTransaction rtx = dataBroker.newReadOnlyTransaction()) {
+ try (ReadTransaction rtx = dataBroker.newReadOnlyTransaction()) {
//TODO change to constant from Timeouts class when it will be merged.
linkOptional = rtx.read(LogicalDatastoreType.CONFIGURATION, linkIID).get(Timeouts.DATASTORE_READ,
- TimeUnit.MILLISECONDS).toJavaUtil();
+ TimeUnit.MILLISECONDS);
return linkOptional.get();
} catch (InterruptedException | ExecutionException | TimeoutException e) {
LOG.warn("Read of {} topology failed", NetworkUtils.OVERLAY_NETWORK_ID);
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
-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.transportpce.common.device.DeviceTransactionManager;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.GetPmInput;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.GetPmOutputBuilder;
public static Optional<Nodes> getNode(String nodeId, DataBroker db) {
InstanceIdentifier<Nodes> nodesIID = InstanceIdentifier.create(Network.class)
.child(Nodes.class, new NodesKey(nodeId));
- try (ReadOnlyTransaction readTransaction = db.newReadOnlyTransaction()) {
+ try (ReadTransaction readTransaction = db.newReadOnlyTransaction()) {
return readTransaction.read(LogicalDatastoreType.CONFIGURATION, nodesIID)
- .get(DATABROKER_READ_TIMEOUT_SECONDS, TimeUnit.SECONDS).toJavaUtil();
+ .get(DATABROKER_READ_TIMEOUT_SECONDS, TimeUnit.SECONDS);
} catch (InterruptedException | ExecutionException | TimeoutException ex) {
LOG.error("Unable to read Portmapping for nodeId {}", nodeId, ex);
return Optional.empty();
import java.util.stream.Collectors;
import java.util.stream.Stream;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.transportpce.common.Timeouts;
import org.opendaylight.transportpce.common.device.DeviceTransactionManager;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.GetPmInput;
import java.util.stream.Stream;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.transportpce.common.Timeouts;
import org.opendaylight.transportpce.common.device.DeviceTransactionManager;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.GetPmInput;
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="rpcProviderRegistry"
- interface="org.opendaylight.controller.sal.binding.api.RpcProviderRegistry" />
+ <reference id="rpcProviderService"
+ interface="org.opendaylight.mdsal.binding.api.RpcProviderService" />
<reference id="openRoadmInterfaces"
interface="org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfaces" />
<reference id="crossConnect"
<bean id="provider"
class="org.opendaylight.transportpce.olm.OlmProvider"
init-method="init" destroy-method="close">
- <argument ref="rpcProviderRegistry" />
+ <argument ref="rpcProviderService" />
<argument ref="olmPowerServiceImpl" />
</bean>
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mockito;
-import org.opendaylight.controller.md.sal.binding.api.MountPoint;
-import org.opendaylight.controller.md.sal.binding.api.MountPointService;
+import org.opendaylight.mdsal.binding.api.MountPoint;
+import org.opendaylight.mdsal.binding.api.MountPointService;
import org.opendaylight.transportpce.common.StringConstants;
import org.opendaylight.transportpce.common.crossconnect.CrossConnect;
import org.opendaylight.transportpce.common.crossconnect.CrossConnectImpl;
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mockito;
-import org.opendaylight.controller.md.sal.binding.api.MountPoint;
-import org.opendaylight.controller.md.sal.binding.api.MountPointService;
+import org.opendaylight.mdsal.binding.api.MountPoint;
+import org.opendaylight.mdsal.binding.api.MountPointService;
import org.opendaylight.transportpce.common.StringConstants;
import org.opendaylight.transportpce.common.crossconnect.CrossConnect;
import org.opendaylight.transportpce.common.crossconnect.CrossConnectImpl;
import org.mockito.InjectMocks;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
-import org.opendaylight.controller.md.sal.binding.api.MountPoint;
-import org.opendaylight.controller.md.sal.binding.api.MountPointService;
+import org.opendaylight.mdsal.binding.api.MountPoint;
+import org.opendaylight.mdsal.binding.api.MountPointService;
import org.opendaylight.transportpce.common.NetworkUtils;
import org.opendaylight.transportpce.common.StringConstants;
import org.opendaylight.transportpce.common.crossconnect.CrossConnect;
package org.opendaylight.transportpce.olm.stub;
-import com.google.common.base.Optional;
-import org.opendaylight.controller.md.sal.binding.api.MountPoint;
-import org.opendaylight.controller.md.sal.binding.api.MountPointService;
+import java.util.Optional;
+import org.opendaylight.mdsal.binding.api.MountPoint;
+import org.opendaylight.mdsal.binding.api.MountPointService;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
@Override
public Optional<MountPoint> getMountPoint(InstanceIdentifier<?> mountPoint) {
if (returnedMountPoint == null) {
- return Optional.absent();
+ return Optional.empty();
}
return Optional.of(returnedMountPoint);
}
package org.opendaylight.transportpce.olm.stub;
-import com.google.common.base.Optional;
+import java.util.Optional;
import javax.annotation.Nonnull;
-import org.opendaylight.controller.md.sal.binding.api.BindingService;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.MountPoint;
-import org.opendaylight.controller.sal.binding.api.RpcConsumerRegistry;
+import org.opendaylight.mdsal.binding.api.BindingService;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.MountPoint;
+import org.opendaylight.mdsal.binding.api.RpcConsumerRegistry;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
public class MountPointStub implements MountPoint {
@Override
public <T extends BindingService> Optional<T> getService(Class<T> service) {
if (service.isInstance(dataBroker)) {
- return Optional.fromNullable((T)dataBroker);
+ return Optional.ofNullable((T)dataBroker);
}
if (service.isInstance(rpcConsumerRegistry)) {
- return Optional.fromNullable((T)rpcConsumerRegistry);
+ return Optional.ofNullable((T)rpcConsumerRegistry);
}
- return Optional.absent();
+ return Optional.empty();
}
@Nonnull
import java.util.Map;
import java.util.Optional;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-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.ReadWriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.transportpce.common.NetworkUtils;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev170228.Network;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev170228.network.Nodes;
*/
package org.opendaylight.transportpce.pce.constraints;
-import com.google.common.base.Optional;
-
import java.util.ArrayList;
import java.util.List;
+import java.util.Optional;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import java.util.stream.Collectors;
-
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.transportpce.common.Timeouts;
import org.opendaylight.transportpce.common.network.NetworkTransactionService;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.pce.rev190624.PathComputationRequestInput;
}
private Optional<PathDescription> getPathDescriptionFromDatastore(String serviceName) {
- Optional<PathDescription> result = Optional.absent();
+ Optional<PathDescription> result = Optional.empty();
InstanceIdentifier<ServicePaths> pathDescriptionIID = InstanceIdentifier.create(ServicePathList.class)
.child(ServicePaths.class, new ServicePathsKey(serviceName));
try {
import java.util.stream.IntStream;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.transportpce.common.NetworkUtils;
import org.opendaylight.transportpce.common.network.NetworkTransactionService;
import org.opendaylight.yang.gen.v1.gnpy.gnpy.network.topology.rev181214.Coordinate;
// read the configuration part of the data broker that concerns
// the openRoadm topology and get all the nodes
java.util.Optional<Network> openRoadmTopo = this.networkTransactionService
- .read(LogicalDatastoreType.CONFIGURATION, insIdOpenRoadmTopo).get().toJavaUtil();
+ .read(LogicalDatastoreType.CONFIGURATION, insIdOpenRoadmTopo).get();
java.util.Optional<Network> openRoadmNet = this.networkTransactionService
- .read(LogicalDatastoreType.CONFIGURATION, insIdrOpenRoadmNet).get().toJavaUtil();
+ .read(LogicalDatastoreType.CONFIGURATION, insIdrOpenRoadmNet).get();
if (openRoadmNet.isPresent()) {
List<Node> openRoadmNetNodeList = openRoadmNet.get().getNode();
if (openRoadmTopo.isPresent()) {
*/
package org.opendaylight.transportpce.pce.impl;
-import org.opendaylight.controller.sal.binding.api.BindingAwareBroker;
-import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
+import org.opendaylight.mdsal.binding.api.RpcProviderService;
import org.opendaylight.transportpce.pce.service.PathComputationService;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.pce.rev190624.TransportpcePceService;
+import org.opendaylight.yangtools.concepts.ObjectRegistration;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
private static final Logger LOG = LoggerFactory.getLogger(PceProvider.class);
- private final RpcProviderRegistry rpcRegistry;
+ private final RpcProviderService rpcService;
private final PathComputationService pathComputationService;
- private BindingAwareBroker.RpcRegistration<TransportpcePceService> rpcRegistration;
+ private ObjectRegistration<PceServiceRPCImpl> rpcRegistration;
- public PceProvider(RpcProviderRegistry rpcProviderRegistry, PathComputationService pathComputationService) {
- this.rpcRegistry = rpcProviderRegistry;
+ public PceProvider(RpcProviderService rpcProviderService, PathComputationService pathComputationService) {
+ this.rpcService = rpcProviderService;
this.pathComputationService = pathComputationService;
}
public void init() {
LOG.info("PceProvider Session Initiated");
final PceServiceRPCImpl consumer = new PceServiceRPCImpl(pathComputationService);
- rpcRegistration = rpcRegistry.addRpcImplementation(TransportpcePceService.class, consumer);
+ rpcRegistration = rpcService.registerRpcImplementation(TransportpcePceService.class, consumer);
}
/*
package org.opendaylight.transportpce.pce.networkanalyzer;
-import com.google.common.base.Optional;
-
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
+import java.util.Optional;
import java.util.Set;
import java.util.concurrent.ExecutionException;
-
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.transportpce.common.NetworkUtils;
import org.opendaylight.transportpce.common.ResponseCodes;
import org.opendaylight.transportpce.common.network.NetworkTransactionService;
import java.util.concurrent.Callable;
import java.util.concurrent.Executors;
-import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService;
+import org.opendaylight.mdsal.binding.api.NotificationPublishService;
import org.opendaylight.transportpce.common.network.NetworkTransactionService;
import org.opendaylight.transportpce.pce.PceComplianceCheck;
import org.opendaylight.transportpce.pce.PceComplianceCheckResult;
<reference id="networkTransactionImpl" interface="org.opendaylight.transportpce.common.network.NetworkTransactionService" />
<reference id="dataBroker"
- interface="org.opendaylight.controller.md.sal.binding.api.DataBroker"
+ interface="org.opendaylight.mdsal.binding.api.DataBroker"
odl:type="default"/>
- <reference id="rpcRegistry"
- interface="org.opendaylight.controller.sal.binding.api.RpcProviderRegistry"/>
+ <reference id="rpcService"
+ interface="org.opendaylight.mdsal.binding.api.RpcProviderService"/>
<reference id="notificationPublishService"
- interface="org.opendaylight.controller.md.sal.binding.api.NotificationPublishService"
+ interface="org.opendaylight.mdsal.binding.api.NotificationPublishService"
odl:type="default" />
<bean id="pceServiceImpl"
<bean id="provider"
class="org.opendaylight.transportpce.pce.impl.PceProvider"
init-method="init" destroy-method="close">
- <argument ref="rpcRegistry" />
+ <argument ref="rpcService" />
<argument ref="pceServiceImpl" />
</bean>
import java.util.concurrent.TimeUnit;
-import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService;
+import org.opendaylight.mdsal.binding.api.NotificationPublishService;
import org.opendaylight.yangtools.yang.binding.Notification;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.concurrent.ExecutionException;
import java.util.stream.Collectors;
import org.junit.Assert;
-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.transportpce.common.DataStoreContext;
import org.opendaylight.transportpce.common.NetworkUtils;
import org.opendaylight.transportpce.common.converter.XMLDataObjectConverter;
*/
package org.opendaylight.transportpce.renderer;
-import com.google.common.base.Optional;
-
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.List;
+import java.util.Optional;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import java.util.stream.Collectors;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
-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.ReadTransaction;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.transportpce.common.NetworkUtils;
import org.opendaylight.transportpce.common.Timeouts;
import org.opendaylight.transportpce.common.fixedflex.FixedFlexImpl;
InstanceIdentifier<Node1>
nodeIID = createNode1IID(nodeId);
Optional<Node1> nodeOpt;
- try (ReadOnlyTransaction nodeReadTx = this.dataBroker.newReadOnlyTransaction()) {
+ try (ReadTransaction nodeReadTx = this.dataBroker.newReadOnlyTransaction()) {
nodeOpt = nodeReadTx.read(LogicalDatastoreType.CONFIGURATION, nodeIID)
.get(Timeouts.DATASTORE_READ, TimeUnit.MILLISECONDS);
} catch (InterruptedException | ExecutionException | TimeoutException e) {
LOG.warn("Exception while getting node from {} topology!", NetworkUtils.OVERLAY_NETWORK_ID, e);
- nodeOpt = Optional.absent();
+ nodeOpt = Optional.empty();
}
return nodeOpt;
}
private Optional<TerminationPoint1> getTerminationPoint1FromDatastore(String nodeId, String tpId) {
InstanceIdentifier<TerminationPoint1> tpIID = createTerminationPoint1IIDBuilder(nodeId, tpId).build();
Optional<TerminationPoint1> tpOpt;
- try (ReadOnlyTransaction readTx = this.dataBroker.newReadOnlyTransaction()) {
+ try (ReadTransaction readTx = this.dataBroker.newReadOnlyTransaction()) {
tpOpt = readTx.read(LogicalDatastoreType.CONFIGURATION, tpIID)
.get(Timeouts.DATASTORE_READ, TimeUnit.MILLISECONDS);
} catch (InterruptedException | ExecutionException | TimeoutException e) {
LOG.warn("Exception while getting termination point from {} topology!", NetworkUtils.OVERLAY_NETWORK_ID,
e);
- tpOpt = Optional.absent();
+ tpOpt = Optional.empty();
}
return tpOpt;
}
*/
package org.opendaylight.transportpce.renderer;
-import org.opendaylight.controller.sal.binding.api.BindingAwareBroker.RpcRegistration;
-import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
+import org.opendaylight.mdsal.binding.api.RpcProviderService;
import org.opendaylight.transportpce.renderer.provisiondevice.RendererServiceOperations;
import org.opendaylight.transportpce.renderer.rpcs.DeviceRendererRPCImpl;
import org.opendaylight.transportpce.renderer.rpcs.TransportPCEServicePathRPCImpl;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.renderer.device.rev170228.TransportpceDeviceRendererService;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.renderer.rev171017.TransportpceRendererService;
+import org.opendaylight.yangtools.concepts.ObjectRegistration;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class RendererProvider {
private static final Logger LOG = LoggerFactory.getLogger(RendererProvider.class);
- private final RpcProviderRegistry rpcProviderRegistry;
+ private final RpcProviderService rpcProviderService;
private DeviceRendererRPCImpl deviceRendererRPCImpl;
- private RpcRegistration<TransportpceDeviceRendererService> deviceRendererRegistration;
- private RpcRegistration<TransportpceRendererService> tpceServiceRegistry;
+ private ObjectRegistration<DeviceRendererRPCImpl> deviceRendererRegistration;
+ private ObjectRegistration<TransportpceRendererService> tpceServiceRegistry;
private RendererServiceOperations rendererServiceOperations;
- public RendererProvider(RpcProviderRegistry rpcProviderRegistry, DeviceRendererRPCImpl deviceRendererRPCImpl,
+ public RendererProvider(RpcProviderService rpcProviderService, DeviceRendererRPCImpl deviceRendererRPCImpl,
RendererServiceOperations rendererServiceOperations) {
- this.rpcProviderRegistry = rpcProviderRegistry;
+ this.rpcProviderService = rpcProviderService;
this.deviceRendererRPCImpl = deviceRendererRPCImpl;
this.rendererServiceOperations = rendererServiceOperations;
}
LOG.info("RendererProvider Session Initiated");
TransportPCEServicePathRPCImpl transportPCEServicePathRPCImpl =
new TransportPCEServicePathRPCImpl(this.rendererServiceOperations);
- this.deviceRendererRegistration = this.rpcProviderRegistry
- .addRpcImplementation(TransportpceDeviceRendererService.class, deviceRendererRPCImpl);
- this.tpceServiceRegistry = this.rpcProviderRegistry
- .addRpcImplementation(TransportpceRendererService.class, transportPCEServicePathRPCImpl);
+ this.deviceRendererRegistration = this.rpcProviderService
+ .registerRpcImplementation(TransportpceDeviceRendererService.class, deviceRendererRPCImpl);
+ this.tpceServiceRegistry = this.rpcProviderService
+ .registerRpcImplementation(TransportpceRendererService.class, transportPCEServicePathRPCImpl);
}
/**
import java.util.List;
import java.util.Optional;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.transportpce.common.StringConstants;
import org.opendaylight.transportpce.common.Timeouts;
import org.opendaylight.transportpce.common.device.DeviceTransactionManager;
import java.util.List;
import java.util.Optional;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.transportpce.common.StringConstants;
import org.opendaylight.transportpce.common.Timeouts;
import org.opendaylight.transportpce.common.device.DeviceTransactionManager;
import com.google.common.collect.Sets;
import com.google.common.util.concurrent.FluentFuture;
-
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import java.util.concurrent.atomic.AtomicBoolean;
-
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
-import org.opendaylight.controller.md.sal.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.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.transportpce.common.StringConstants;
import org.opendaylight.transportpce.common.Timeouts;
import org.opendaylight.transportpce.common.crossconnect.CrossConnect;
InstanceIdentifier<Services> iid =
InstanceIdentifier.create(ServiceList.class).child(Services.class, serviceKey);
Optional<Services> services;
- try (ReadOnlyTransaction readTx = this.dataBroker.newReadOnlyTransaction()) {
- Future<com.google.common.base.Optional<Services>> future =
+ try (ReadTransaction readTx = this.dataBroker.newReadOnlyTransaction()) {
+ Future<java.util.Optional<Services>> future =
readTx.read(LogicalDatastoreType.OPERATIONAL, iid);
- services = future.get(Timeouts.DATASTORE_READ, TimeUnit.MILLISECONDS).toJavaUtil();
+ services = future.get(Timeouts.DATASTORE_READ, TimeUnit.MILLISECONDS);
} catch (InterruptedException | ExecutionException | TimeoutException e) {
throw e;
}
*/
package org.opendaylight.transportpce.renderer.provisiondevice;
-import com.google.common.base.Optional;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.ListeningExecutorService;
import com.google.common.util.concurrent.MoreExecutors;
-
import java.util.ArrayList;
import java.util.List;
+import java.util.Optional;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
-
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService;
-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.NotificationPublishService;
+import org.opendaylight.mdsal.binding.api.ReadTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.transportpce.common.OperationResult;
import org.opendaylight.transportpce.common.ResponseCodes;
import org.opendaylight.transportpce.common.StringConstants;
private Optional<PathDescription> getPathDescriptionFromDatastore(String serviceName) {
InstanceIdentifier<PathDescription> pathDescriptionIID = InstanceIdentifier.create(ServicePathList.class)
.child(ServicePaths.class, new ServicePathsKey(serviceName)).child(PathDescription.class);
- ReadOnlyTransaction pathDescReadTx = this.dataBroker.newReadOnlyTransaction();
+ ReadTransaction pathDescReadTx = this.dataBroker.newReadOnlyTransaction();
try {
LOG.debug("Getting path description for service {}", serviceName);
return pathDescReadTx.read(LogicalDatastoreType.OPERATIONAL, pathDescriptionIID)
} catch (InterruptedException | ExecutionException | TimeoutException e) {
LOG.warn("Exception while getting path description from datastore {} for service {}!", pathDescriptionIID,
serviceName, e);
- return Optional.absent();
+ return Optional.empty();
}
}
xmlns:odl="http://opendaylight.org/xmlns/blueprint/v1.0.0"
odl:use-default-for-reference-types="true">
- <reference id="dataBroker" interface="org.opendaylight.controller.md.sal.binding.api.DataBroker"
+ <reference id="dataBroker" interface="org.opendaylight.mdsal.binding.api.DataBroker"
odl:type="default" />
<reference id="notificationPublishService"
- interface="org.opendaylight.controller.md.sal.binding.api.NotificationPublishService"
+ interface="org.opendaylight.mdsal.binding.api.NotificationPublishService"
odl:type="default" />
- <reference id="rpcProviderRegistry" interface="org.opendaylight.controller.sal.binding.api.RpcProviderRegistry" />
+ <reference id="rpcProviderService" interface="org.opendaylight.mdsal.binding.api.RpcProviderService" />
<reference id="deviceTransactionManager" interface="org.opendaylight.transportpce.common.device.DeviceTransactionManager" />
<reference id="openRoadmInterfaces" interface="org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfaces" />
<reference id="portMapping" interface="org.opendaylight.transportpce.common.mapping.PortMapping" />
<bean id="rendererProvider" class="org.opendaylight.transportpce.renderer.RendererProvider"
init-method="init" destroy-method="close">
- <argument ref="rpcProviderRegistry" />
+ <argument ref="rpcProviderService" />
<argument ref="deviceRendererRPCImpl" />
<argument ref="rendererServiceOperations" />
</bean>
import org.junit.Test;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
-import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
+import org.opendaylight.mdsal.binding.api.RpcProviderService;
import org.opendaylight.transportpce.renderer.provisiondevice.RendererServiceOperations;
import org.opendaylight.transportpce.renderer.rpcs.DeviceRendererRPCImpl;
import org.opendaylight.transportpce.renderer.rpcs.TransportPCEServicePathRPCImpl;
@Mock
- RpcProviderRegistry rpcProviderRegistry;
+ RpcProviderService rpcProviderService;
@Mock
private RendererServiceOperations rendererServiceOperations;
}
@Test
- public void testInitMethodRegistersRendererToRpcRegistry() {
- RendererProvider provider = new RendererProvider(rpcProviderRegistry,
- deviceRendererRPC, rendererServiceOperations);
+ public void testInitMethodRegistersRendererToRpcService() {
+ RendererProvider provider =
+ new RendererProvider(rpcProviderService, deviceRendererRPC, rendererServiceOperations);
provider.init();
- verify(rpcProviderRegistry, times(1))
- .addRpcImplementation(any(), any(TransportPCEServicePathRPCImpl.class));
+ verify(rpcProviderService, times(1))
+ .registerRpcImplementation(any(), any(TransportPCEServicePathRPCImpl.class));
- verify(rpcProviderRegistry, times(1))
- .addRpcImplementation(any(), any(DeviceRendererRPCImpl.class));
+ verify(rpcProviderService, times(1))
+ .registerRpcImplementation(any(), any(DeviceRendererRPCImpl.class));
}
import org.junit.Assert;
import org.junit.Test;
import org.mockito.Mockito;
-import org.opendaylight.controller.md.sal.binding.api.MountPoint;
-import org.opendaylight.controller.md.sal.binding.api.MountPointService;
+import org.opendaylight.mdsal.binding.api.MountPoint;
+import org.opendaylight.mdsal.binding.api.MountPointService;
import org.opendaylight.transportpce.common.StringConstants;
import org.opendaylight.transportpce.common.crossconnect.CrossConnect;
import org.opendaylight.transportpce.common.crossconnect.CrossConnectImpl;
);
}
-}
\ No newline at end of file
+}
import org.junit.Assert;
import org.junit.Test;
import org.mockito.Mockito;
-import org.opendaylight.controller.md.sal.binding.api.MountPoint;
-import org.opendaylight.controller.md.sal.binding.api.MountPointService;
-//import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.MountPoint;
+import org.opendaylight.mdsal.binding.api.MountPointService;
import org.opendaylight.transportpce.common.StringConstants;
import org.opendaylight.transportpce.common.crossconnect.CrossConnect;
import org.opendaylight.transportpce.common.crossconnect.CrossConnectImpl;
import org.junit.Assert;
import org.junit.Test;
import org.mockito.Mockito;
-import org.opendaylight.controller.md.sal.binding.api.MountPoint;
-import org.opendaylight.controller.md.sal.binding.api.MountPointService;
+import org.opendaylight.mdsal.binding.api.MountPoint;
+import org.opendaylight.mdsal.binding.api.MountPointService;
import org.opendaylight.transportpce.common.StringConstants;
import org.opendaylight.transportpce.common.crossconnect.CrossConnect;
import org.opendaylight.transportpce.common.crossconnect.CrossConnectImpl;
import org.junit.Assert;
import org.junit.Test;
import org.mockito.Mockito;
-import org.opendaylight.controller.md.sal.binding.api.MountPoint;
-import org.opendaylight.controller.md.sal.binding.api.MountPointService;
+import org.opendaylight.mdsal.binding.api.MountPoint;
+import org.opendaylight.mdsal.binding.api.MountPointService;
import org.opendaylight.transportpce.common.StringConstants;
import org.opendaylight.transportpce.common.crossconnect.CrossConnect;
import org.opendaylight.transportpce.common.crossconnect.CrossConnectImpl;
Assert.assertEquals(nodeId, servicePathOutput.getNodeInterface().get(0).getNodeId());
}
}
-}
\ No newline at end of file
+}
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mockito;
-import org.opendaylight.controller.md.sal.binding.api.MountPoint;
-import org.opendaylight.controller.md.sal.binding.api.MountPointService;
-import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.MountPoint;
+import org.opendaylight.mdsal.binding.api.MountPointService;
+import org.opendaylight.mdsal.binding.api.NotificationPublishService;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.transportpce.common.ResponseCodes;
import org.opendaylight.transportpce.common.StringConstants;
import org.opendaylight.transportpce.common.crossconnect.CrossConnect;
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mockito;
-import org.opendaylight.controller.md.sal.binding.api.MountPoint;
-import org.opendaylight.controller.md.sal.binding.api.MountPointService;
-import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService;
+import org.opendaylight.mdsal.binding.api.MountPoint;
+import org.opendaylight.mdsal.binding.api.MountPointService;
+import org.opendaylight.mdsal.binding.api.NotificationPublishService;
import org.opendaylight.transportpce.common.ResponseCodes;
import org.opendaylight.transportpce.common.StringConstants;
import org.opendaylight.transportpce.common.crossconnect.CrossConnect;
package org.opendaylight.transportpce.renderer.stub;
-import com.google.common.base.Optional;
-import org.opendaylight.controller.md.sal.binding.api.MountPoint;
-import org.opendaylight.controller.md.sal.binding.api.MountPointService;
+import java.util.Optional;
+import org.opendaylight.mdsal.binding.api.MountPoint;
+import org.opendaylight.mdsal.binding.api.MountPointService;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
@Override
public Optional<MountPoint> getMountPoint(InstanceIdentifier<?> mountPoint) {
if (returnedMountPoint == null) {
- return Optional.absent();
+ return Optional.empty();
}
return Optional.of(returnedMountPoint);
}
package org.opendaylight.transportpce.renderer.stub;
-import com.google.common.base.Optional;
+import java.util.Optional;
import javax.annotation.Nonnull;
-import org.opendaylight.controller.md.sal.binding.api.BindingService;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.MountPoint;
-import org.opendaylight.controller.sal.binding.api.RpcConsumerRegistry;
+import org.opendaylight.mdsal.binding.api.BindingService;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.MountPoint;
+import org.opendaylight.mdsal.binding.api.RpcConsumerRegistry;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
public class MountPointStub implements MountPoint {
@Override
public <T extends BindingService> Optional<T> getService(Class<T> service) {
if (service.isInstance(dataBroker)) {
- return Optional.fromNullable((T)dataBroker);
+ return Optional.ofNullable((T)dataBroker);
}
if (service.isInstance(rpcConsumerRegistry)) {
- return Optional.fromNullable((T)rpcConsumerRegistry);
+ return Optional.ofNullable((T)rpcConsumerRegistry);
}
- return Optional.absent();
+ return Optional.empty();
}
@Nonnull
import java.util.List;
import java.util.concurrent.ExecutionException;
import org.mockito.Mockito;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.sal.binding.api.RpcConsumerRegistry;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.RpcConsumerRegistry;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.transportpce.common.device.DeviceTransactionManager;
import org.opendaylight.transportpce.renderer.stub.MountPointStub;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev190702.Network;
import java.util.concurrent.TimeUnit;
-import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService;
+import org.opendaylight.mdsal.binding.api.NotificationPublishService;
import org.opendaylight.yangtools.yang.binding.Notification;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.Optional;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.transportpce.common.Timeouts;
import org.opendaylight.transportpce.common.device.DeviceTransaction;
import org.opendaylight.transportpce.common.device.DeviceTransactionManager;
return null;
}
DeviceTransaction deviceTx = deviceTxFuture.get().get();
- com.google.common.base.Optional<? extends DataObject> readOpt
+ Optional<? extends DataObject> readOpt
= deviceTx.read(logicalDatastoreType, instanceIdentifier).get();
if (!readOpt.isPresent()) {
return null;
package org.opendaylight.transportpce.renderer.utils;
import java.util.concurrent.ExecutionException;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.transportpce.common.NetworkUtils;
import org.opendaylight.transportpce.common.device.DeviceTransactionManager;
import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev181130.Node1;
import java.time.format.DateTimeFormatter;
import java.util.Optional;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.NotificationPublishService;
import org.opendaylight.transportpce.common.OperationResult;
import org.opendaylight.transportpce.common.ResponseCodes;
import org.opendaylight.transportpce.pce.service.PathComputationService;
package org.opendaylight.transportpce.servicehandler.impl;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService;
-import org.opendaylight.controller.md.sal.binding.api.NotificationService;
-import org.opendaylight.controller.sal.binding.api.BindingAwareBroker.RpcRegistration;
-import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.NotificationPublishService;
+import org.opendaylight.mdsal.binding.api.NotificationService;
+import org.opendaylight.mdsal.binding.api.RpcProviderService;
import org.opendaylight.transportpce.pce.service.PathComputationService;
import org.opendaylight.transportpce.renderer.NetworkModelWavelengthService;
import org.opendaylight.transportpce.renderer.provisiondevice.RendererServiceOperations;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.renderer.rev171017.TransportpceRendererListener;
import org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev161014.OrgOpenroadmServiceService;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
+import org.opendaylight.yangtools.concepts.ObjectRegistration;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
private static final Logger LOG = LoggerFactory.getLogger(ServicehandlerProvider.class);
private final DataBroker dataBroker;
- private final RpcProviderRegistry rpcRegistry;
+ private final RpcProviderService rpcService;
private final NotificationService notificationService;
private final NetworkModelWavelengthService networkModelWavelengthService;
private final NotificationPublishService notificationPublishService;
private ListenerRegistration<TransportpcePceListener> pcelistenerRegistration;
private ListenerRegistration<TransportpceRendererListener> rendererlistenerRegistration;
- private RpcRegistration<OrgOpenroadmServiceService> rpcRegistration;
+ private ObjectRegistration<OrgOpenroadmServiceService> rpcRegistration;
private PathComputationService pathComputationService;
private RendererServiceOperations rendererServiceOperations;
- public ServicehandlerProvider(final DataBroker dataBroker, RpcProviderRegistry rpcProviderRegistry,
+ public ServicehandlerProvider(final DataBroker dataBroker, RpcProviderService rpcProviderService,
NotificationService notificationService, PathComputationService pathComputationService,
RendererServiceOperations rendererServiceOperations,
NetworkModelWavelengthService networkModelWavelengthService,
NotificationPublishService notificationPublishService) {
this.dataBroker = dataBroker;
- this.rpcRegistry = rpcProviderRegistry;
+ this.rpcService = rpcProviderService;
this.notificationService = notificationService;
this.pathComputationService = pathComputationService;
this.rendererServiceOperations = rendererServiceOperations;
final ServicehandlerImpl servicehandler = new ServicehandlerImpl(dataBroker, pathComputationService,
rendererServiceOperations, notificationPublishService, pceListenerImpl, rendererListenerImpl,
networkModelWavelengthService);
- rpcRegistration = rpcRegistry.addRpcImplementation(OrgOpenroadmServiceService.class, servicehandler);
+ rpcRegistration =
+ rpcService.registerRpcImplementation(OrgOpenroadmServiceService.class, servicehandler);
}
/**
*/
package org.opendaylight.transportpce.servicehandler.listeners;
-import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService;
+import org.opendaylight.mdsal.binding.api.NotificationPublishService;
import org.opendaylight.transportpce.common.OperationResult;
import org.opendaylight.transportpce.pce.service.PathComputationService;
import org.opendaylight.transportpce.renderer.provisiondevice.RendererServiceOperations;
*/
package org.opendaylight.transportpce.servicehandler.listeners;
-import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService;
+import org.opendaylight.mdsal.binding.api.NotificationPublishService;
import org.opendaylight.transportpce.common.OperationResult;
import org.opendaylight.transportpce.pce.service.PathComputationService;
import org.opendaylight.transportpce.servicehandler.ServiceInput;
import java.util.concurrent.Executors;
-import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService;
+import org.opendaylight.mdsal.binding.api.NotificationPublishService;
import org.opendaylight.transportpce.common.ResponseCodes;
import org.opendaylight.transportpce.pce.service.PathComputationService;
import org.opendaylight.transportpce.servicehandler.MappingConstraints;
import java.util.concurrent.Executors;
-import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService;
+import org.opendaylight.mdsal.binding.api.NotificationPublishService;
import org.opendaylight.transportpce.common.ResponseCodes;
import org.opendaylight.transportpce.renderer.provisiondevice.RendererServiceOperations;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.renderer.rev171017.ServiceDeleteInput;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
-import org.opendaylight.controller.md.sal.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.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.transportpce.common.OperationResult;
import org.opendaylight.transportpce.common.Timeouts;
import org.opendaylight.transportpce.servicehandler.ModelMappingUtils;
@Override
public Optional<Services> getService(String serviceName) {
try {
- ReadOnlyTransaction readTx = this.dataBroker.newReadOnlyTransaction();
+ ReadTransaction readTx = this.dataBroker.newReadOnlyTransaction();
InstanceIdentifier<Services> iid =
InstanceIdentifier.create(ServiceList.class).child(Services.class, new ServicesKey(serviceName));
- Future<com.google.common.base.Optional<Services>> future =
+ Future<java.util.Optional<Services>> future =
readTx.read(LogicalDatastoreType.OPERATIONAL, iid);
- return future.get(Timeouts.DATASTORE_READ, TimeUnit.MILLISECONDS).toJavaUtil();
+ return future.get(Timeouts.DATASTORE_READ, TimeUnit.MILLISECONDS);
} catch (InterruptedException | ExecutionException | TimeoutException e) {
LOG.warn("Reading service {} failed:", serviceName, e);
}
public Optional<org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev161014.temp.service.list
.Services> getTempService(String serviceName) {
try {
- ReadOnlyTransaction readTx = this.dataBroker.newReadOnlyTransaction();
+ ReadTransaction readTx = this.dataBroker.newReadOnlyTransaction();
InstanceIdentifier<org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev161014.temp.service.list
.Services> iid = InstanceIdentifier.create(TempServiceList.class).child(org.opendaylight.yang.gen.v1
.http.org.openroadm.service.rev161014.temp.service.list.Services.class,
new org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev161014.temp.service.list
.ServicesKey(serviceName));
- Future<com.google.common.base.Optional<org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev161014
+ Future<java.util.Optional<org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev161014
.temp.service.list.Services>> future = readTx.read(LogicalDatastoreType.OPERATIONAL, iid);
- return future.get(Timeouts.DATASTORE_READ, TimeUnit.MILLISECONDS).toJavaUtil();
+ return future.get(Timeouts.DATASTORE_READ, TimeUnit.MILLISECONDS);
} catch (InterruptedException | ExecutionException | TimeoutException e) {
LOG.warn("Reading service {} failed:", serviceName, e);
}
break;
}
try {
- writeTx.submit().get(Timeouts.DATASTORE_WRITE, TimeUnit.MILLISECONDS);
+ writeTx.commit().get(Timeouts.DATASTORE_WRITE, TimeUnit.MILLISECONDS);
} catch (InterruptedException | ExecutionException | TimeoutException e) {
LOG.error("Failed to {} service from Service List", action, e);
result = "Failed to " + action + " service from Service List";
Services service = ModelMappingUtils.mappingServices(input, null);
writeTx.put(LogicalDatastoreType.OPERATIONAL, iid, service);
try {
- writeTx.submit().get(Timeouts.DATASTORE_WRITE, TimeUnit.MILLISECONDS);
+ writeTx.commit().get(Timeouts.DATASTORE_WRITE, TimeUnit.MILLISECONDS);
result = null;
} catch (InterruptedException | TimeoutException | ExecutionException e) {
LOG.error("Failed to createService service to Service List", e);
import java.util.concurrent.Callable;
import java.util.concurrent.Executors;
-import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService;
+import org.opendaylight.mdsal.binding.api.NotificationPublishService;
import org.opendaylight.transportpce.common.ResponseCodes;
import org.opendaylight.transportpce.pce.service.PathComputationService;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.pce.rev190624.CancelResourceReserveInput;
*/
package org.opendaylight.transportpce.servicehandler.stub;
-import com.google.common.base.Optional;
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.ListeningExecutorService;
import com.google.common.util.concurrent.MoreExecutors;
-
+import java.util.Optional;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
-
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService;
-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.NotificationPublishService;
+import org.opendaylight.mdsal.binding.api.ReadTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.transportpce.common.OperationResult;
import org.opendaylight.transportpce.common.ResponseCodes;
import org.opendaylight.transportpce.common.Timeouts;
private Optional<PathDescription> getPathDescriptionFromDatastore(String serviceName) {
InstanceIdentifier<PathDescription> pathDescriptionIID = InstanceIdentifier.create(ServicePathList.class)
.child(ServicePaths.class, new ServicePathsKey(serviceName)).child(PathDescription.class);
- ReadOnlyTransaction pathDescReadTx = this.dataBroker.newReadOnlyTransaction();
+ ReadTransaction pathDescReadTx = this.dataBroker.newReadOnlyTransaction();
try {
LOG.debug("Getting path description for service {}", serviceName);
return pathDescReadTx.read(LogicalDatastoreType.OPERATIONAL, pathDescriptionIID)
} catch (InterruptedException | ExecutionException | TimeoutException e) {
LOG.warn("Exception while getting path description from datastore {} for service {}!", pathDescriptionIID,
serviceName, e);
- return Optional.absent();
+ return Optional.empty();
}
}
xmlns:odl="http://opendaylight.org/xmlns/blueprint/v1.0.0"
odl:use-default-for-reference-types="true">
- <reference id="rpcRegistry"
- interface="org.opendaylight.controller.sal.binding.api.RpcProviderRegistry"/>
+ <reference id="rpcService"
+ interface="org.opendaylight.mdsal.binding.api.RpcProviderService"/>
<reference id="dataBroker"
- interface="org.opendaylight.controller.md.sal.binding.api.DataBroker"
+ interface="org.opendaylight.mdsal.binding.api.DataBroker"
odl:type="default" />
<reference id="notificationService"
- interface="org.opendaylight.controller.md.sal.binding.api.NotificationService"
+ interface="org.opendaylight.mdsal.binding.api.NotificationService"
odl:type="default" />
<reference id="notificationPublishService"
- interface="org.opendaylight.controller.md.sal.binding.api.NotificationPublishService"
+ interface="org.opendaylight.mdsal.binding.api.NotificationPublishService"
odl:type="default" />
<reference id="pathComputationService"
<bean id="provider"
class="org.opendaylight.transportpce.servicehandler.impl.ServicehandlerProvider"
init-method="init" destroy-method="close">
- <argument ref="rpcRegistry" />
+ <argument ref="rpcService" />
<argument ref="dataBroker" />
<argument ref="notificationService" />
<argument ref="notificationPublishService" />
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.NotificationPublishService;
import org.opendaylight.transportpce.common.ResponseCodes;
import org.opendaylight.transportpce.pce.service.PathComputationService;
import org.opendaylight.transportpce.renderer.provisiondevice.RendererServiceOperations;
import org.junit.Test;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
-import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService;
-import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
+import org.opendaylight.mdsal.binding.api.NotificationPublishService;
+import org.opendaylight.mdsal.binding.api.RpcProviderService;
import org.opendaylight.transportpce.pce.service.PathComputationService;
import org.opendaylight.transportpce.renderer.NetworkModelWavelengthService;
import org.opendaylight.transportpce.renderer.provisiondevice.RendererServiceOperations;
private NotificationPublishService notificationPublishService;
@Mock
- RpcProviderRegistry rpcProviderRegistry;
+ RpcProviderService rpcProviderRegistry;
@Mock
NetworkModelWavelengthService networkModelWavelengthService;
provider.init();
verify(rpcProviderRegistry, times(1))
- .addRpcImplementation(any(), any(ServicehandlerImpl.class));
+ .registerRpcImplementation(any(), any(ServicehandlerImpl.class));
}
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
-import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService;
+import org.opendaylight.mdsal.binding.api.NotificationPublishService;
import org.opendaylight.transportpce.common.OperationResult;
import org.opendaylight.transportpce.pce.service.PathComputationService;
import org.opendaylight.transportpce.servicehandler.ServiceInput;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
-import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService;
+import org.opendaylight.mdsal.binding.api.NotificationPublishService;
import org.opendaylight.transportpce.common.ResponseCodes;
import org.opendaylight.transportpce.pce.service.PathComputationService;
import org.opendaylight.transportpce.servicehandler.utils.ServiceDataUtils;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
-import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService;
+import org.opendaylight.mdsal.binding.api.NotificationPublishService;
import org.opendaylight.transportpce.common.ResponseCodes;
import org.opendaylight.transportpce.renderer.provisiondevice.RendererServiceOperations;
import org.opendaylight.transportpce.servicehandler.ModelMappingUtils;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.transportpce.common.OperationResult;
import org.opendaylight.transportpce.common.ResponseCodes;
import org.opendaylight.transportpce.servicehandler.ServiceInput;
import static org.mockito.Mockito.doAnswer;
import static org.mockito.Mockito.mock;
-import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService;
+import org.opendaylight.mdsal.binding.api.NotificationPublishService;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.renderer.rev171017.ServiceRpcResultSp;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.renderer.rev171017.ServiceRpcResultSpBuilder;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.renderer.rev171017.service.rpc.result.sp.PathTopologyBuilder;
public void setRendererFailed() {
this.rendererFailed = true;
}
-}
\ No newline at end of file
+}
*/
package org.opendaylight.transportpce.test;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService;
-import org.opendaylight.controller.md.sal.binding.api.NotificationService;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataBroker;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.NotificationPublishService;
+import org.opendaylight.mdsal.binding.api.NotificationService;
+import org.opendaylight.mdsal.dom.api.DOMDataBroker;
import org.opendaylight.transportpce.common.DataStoreContext;
import org.opendaylight.transportpce.common.DataStoreContextImpl;
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.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.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.dom.api.DOMDataBroker;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteTransaction;
import org.opendaylight.transportpce.common.DataStoreContext;
import org.opendaylight.transportpce.common.DataStoreContextImpl;
import org.opendaylight.transportpce.common.converter.XMLDataObjectConverter;
NormalizedNodes.findNode(initialDataNormalizedNodes.get(), initialDataIi);
Preconditions.checkArgument(dataNormalizedNodes.isPresent());
LOG.info("Initial data was successfully stored into ds");
- DOMDataWriteTransaction writeOnlyTransaction = domDataBroker.newWriteOnlyTransaction();
+ DOMDataTreeWriteTransaction writeOnlyTransaction = domDataBroker.newWriteOnlyTransaction();
writeOnlyTransaction.put(LogicalDatastoreType.OPERATIONAL, initialDataIi, dataNormalizedNodes.get());
try {
writeOnlyTransaction.commit().get();