*/
package org.opendaylight.transportpce.common.crossconnect;
-import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.FluentFuture;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Optional;
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.common.api.CommitInfo;
import org.opendaylight.transportpce.common.Timeouts;
import org.opendaylight.transportpce.common.device.DeviceTransaction;
import org.opendaylight.transportpce.common.device.DeviceTransactionManager;
// post the cross connect on the device
deviceTx.put(LogicalDatastoreType.CONFIGURATION, rdmConnectionIID, rdmConnBldr.build());
- ListenableFuture<Void> submit =
- deviceTx.submit(Timeouts.DEVICE_WRITE_TIMEOUT, Timeouts.DEVICE_WRITE_TIMEOUT_UNIT);
+ FluentFuture<? extends @NonNull CommitInfo> commit =
+ deviceTx.commit(Timeouts.DEVICE_WRITE_TIMEOUT, Timeouts.DEVICE_WRITE_TIMEOUT_UNIT);
try {
- submit.get();
+ commit.get();
LOG.info("Roadm-connection successfully created: {}-{}-{}", srcTp, destTp, waveNumber);
return Optional.of(connectionNumber);
} catch (InterruptedException | ExecutionException e) {
// post the cross connect on the device
deviceTx.delete(LogicalDatastoreType.CONFIGURATION, generateRdmConnectionIID(connectionNumber));
- ListenableFuture<Void> submit =
- deviceTx.submit(Timeouts.DEVICE_WRITE_TIMEOUT, Timeouts.DEVICE_WRITE_TIMEOUT_UNIT);
+ FluentFuture<? extends @NonNull CommitInfo> commit =
+ deviceTx.commit(Timeouts.DEVICE_WRITE_TIMEOUT, Timeouts.DEVICE_WRITE_TIMEOUT_UNIT);
try {
- submit.get();
+ commit.get();
LOG.info("Roadm connection successfully deleted ");
return interfList;
} catch (InterruptedException | ExecutionException e) {
InstanceIdentifier<RoadmConnections> roadmConnIID = InstanceIdentifier.create(OrgOpenroadmDevice.class)
.child(RoadmConnections.class, new RoadmConnectionsKey(connectionNumber));
deviceTx.put(LogicalDatastoreType.CONFIGURATION, roadmConnIID, newRdmConn);
- ListenableFuture<Void> submit = deviceTx.submit(Timeouts.DEVICE_WRITE_TIMEOUT,
- Timeouts.DEVICE_WRITE_TIMEOUT_UNIT);
+ FluentFuture<? extends @NonNull CommitInfo> commit =
+ deviceTx.commit(Timeouts.DEVICE_WRITE_TIMEOUT, Timeouts.DEVICE_WRITE_TIMEOUT_UNIT);
try {
- submit.get();
+ commit.get();
LOG.info("Roadm connection power level successfully set ");
return true;
} catch (InterruptedException | ExecutionException ex) {
*/
package org.opendaylight.transportpce.common.crossconnect;
-import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.FluentFuture;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Collections;
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.common.api.CommitInfo;
import org.opendaylight.transportpce.common.Timeouts;
import org.opendaylight.transportpce.common.device.DeviceTransaction;
import org.opendaylight.transportpce.common.device.DeviceTransactionManager;
// post the cross connect on the device
deviceTx.put(LogicalDatastoreType.CONFIGURATION, rdmConnectionIID, rdmConnBldr.build());
- ListenableFuture<Void> submit =
- deviceTx.submit(Timeouts.DEVICE_WRITE_TIMEOUT, Timeouts.DEVICE_WRITE_TIMEOUT_UNIT);
+ FluentFuture<? extends @NonNull CommitInfo> commit =
+ deviceTx.commit(Timeouts.DEVICE_WRITE_TIMEOUT, Timeouts.DEVICE_WRITE_TIMEOUT_UNIT);
try {
- submit.get();
+ commit.get();
LOG.info("Roadm-connection successfully created: {}-{}-{}", srcTp, destTp, waveNumber);
return Optional.of(connectionNumber);
} catch (InterruptedException | ExecutionException e) {
// post the cross connect on the device
deviceTx.delete(LogicalDatastoreType.CONFIGURATION, generateRdmConnectionIID(connectionName));
- ListenableFuture<Void> submit =
- deviceTx.submit(Timeouts.DEVICE_WRITE_TIMEOUT, Timeouts.DEVICE_WRITE_TIMEOUT_UNIT);
+ FluentFuture<? extends @NonNull CommitInfo> commit =
+ deviceTx.commit(Timeouts.DEVICE_WRITE_TIMEOUT, Timeouts.DEVICE_WRITE_TIMEOUT_UNIT);
try {
- submit.get();
+ commit.get();
LOG.info("Roadm connection {} successfully deleted on {}", connectionName, deviceId);
return interfList;
} catch (InterruptedException | ExecutionException e) {
InstanceIdentifier<RoadmConnections> roadmConnIID = InstanceIdentifier.create(OrgOpenroadmDevice.class)
.child(RoadmConnections.class, new RoadmConnectionsKey(connectionName));
deviceTx.put(LogicalDatastoreType.CONFIGURATION, roadmConnIID, newRdmConn);
- ListenableFuture<Void> submit = deviceTx.submit(Timeouts.DEVICE_WRITE_TIMEOUT,
- Timeouts.DEVICE_WRITE_TIMEOUT_UNIT);
+ FluentFuture<? extends @NonNull CommitInfo> commit =
+ deviceTx.commit(Timeouts.DEVICE_WRITE_TIMEOUT, Timeouts.DEVICE_WRITE_TIMEOUT_UNIT);
try {
- submit.get();
+ commit.get();
LOG.info("Roadm connection power level successfully set ");
return true;
} catch (InterruptedException | ExecutionException ex) {
} catch (InterruptedException | ExecutionException | TimeoutException e) {
LOG.error("Exception thrown while reading data from device {}! IID: {}", deviceId, path, e);
} finally {
- deviceTx.submit(GET_DATA_SUBMIT_TIMEOUT, GET_DATA_SUBMIT_TIME_UNIT);
+ deviceTx.commit(GET_DATA_SUBMIT_TIMEOUT, GET_DATA_SUBMIT_TIME_UNIT);
}
} else {
LOG.error("Could not obtain transaction for device {}!", deviceId);
package org.opendaylight.transportpce.common.openroadminterfaces;
-import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.FluentFuture;
import java.util.Optional;
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.transportpce.common.StringConstants;
import org.opendaylight.transportpce.common.Timeouts;
import org.opendaylight.transportpce.common.device.DeviceTransaction;
InstanceIdentifier<Interface> interfacesIID = InstanceIdentifier.create(OrgOpenroadmDevice.class).child(
Interface.class, new InterfaceKey(ifBuilder.getName()));
deviceTx.put(LogicalDatastoreType.CONFIGURATION, interfacesIID, ifBuilder.build());
- ListenableFuture<Void> txSubmitFuture = deviceTx.submit(Timeouts.DEVICE_WRITE_TIMEOUT,
- Timeouts.DEVICE_WRITE_TIMEOUT_UNIT);
+ FluentFuture<? extends @NonNull CommitInfo> txSubmitFuture =
+ deviceTx.commit(Timeouts.DEVICE_WRITE_TIMEOUT, Timeouts.DEVICE_WRITE_TIMEOUT_UNIT);
try {
txSubmitFuture.get();
LOG.info("Successfully posted interface {} on node {}", ifBuilder.getName(), nodeId);
}
deviceTx.delete(LogicalDatastoreType.CONFIGURATION, interfacesIID);
- ListenableFuture<Void> submit = deviceTx.submit(Timeouts.DEVICE_WRITE_TIMEOUT,
- Timeouts.DEVICE_WRITE_TIMEOUT_UNIT);
+ FluentFuture<? extends @NonNull CommitInfo> commit =
+ deviceTx.commit(Timeouts.DEVICE_WRITE_TIMEOUT, Timeouts.DEVICE_WRITE_TIMEOUT_UNIT);
try {
- submit.get();
+ commit.get();
LOG.info("Successfully deleted {} on node {}", interfaceName, nodeId);
} catch (InterruptedException | ExecutionException e) {
throw new OpenRoadmInterfaceException(String.format("Failed to delete interface %s on " + "node %s",
nodeId), e);
}
deviceTx.put(LogicalDatastoreType.CONFIGURATION, circuitPackIID, cpBldr.build());
- ListenableFuture<Void> txSubmitFuture = deviceTx.submit(Timeouts.DEVICE_WRITE_TIMEOUT,
- Timeouts.DEVICE_WRITE_TIMEOUT_UNIT);
+ FluentFuture<? extends @NonNull CommitInfo> txSubmitFuture =
+ deviceTx.commit(Timeouts.DEVICE_WRITE_TIMEOUT, Timeouts.DEVICE_WRITE_TIMEOUT_UNIT);
try {
txSubmitFuture.get();
LOG.info("Successfully posted equipment state change on node {}", nodeId);
package org.opendaylight.transportpce.common.openroadminterfaces;
-import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.FluentFuture;
import java.util.Optional;
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.transportpce.common.StringConstants;
import org.opendaylight.transportpce.common.Timeouts;
import org.opendaylight.transportpce.common.device.DeviceTransaction;
LOG.info("POST INTERF for {} : InterfaceBuilder : name = {} \t type = {}", nodeId, ifBuilder.getName(),
ifBuilder.getType().toString());
deviceTx.put(LogicalDatastoreType.CONFIGURATION, interfacesIID, ifBuilder.build());
- ListenableFuture<Void> txSubmitFuture = deviceTx.submit(Timeouts.DEVICE_WRITE_TIMEOUT,
- Timeouts.DEVICE_WRITE_TIMEOUT_UNIT);
+ FluentFuture<? extends @NonNull CommitInfo> txSubmitFuture =
+ deviceTx.commit(Timeouts.DEVICE_WRITE_TIMEOUT, Timeouts.DEVICE_WRITE_TIMEOUT_UNIT);
try {
txSubmitFuture.get();
LOG.info("Successfully posted interface {} on node {}", ifBuilder.getName(), nodeId);
}
deviceTx.delete(LogicalDatastoreType.CONFIGURATION, interfacesIID);
- ListenableFuture<Void> submit = deviceTx.submit(Timeouts.DEVICE_WRITE_TIMEOUT,
- Timeouts.DEVICE_WRITE_TIMEOUT_UNIT);
+ FluentFuture<? extends @NonNull CommitInfo> commit =
+ deviceTx.commit(Timeouts.DEVICE_WRITE_TIMEOUT, Timeouts.DEVICE_WRITE_TIMEOUT_UNIT);
try {
- submit.get();
+ commit.get();
LOG.info("Successfully deleted {} on node {}", interfaceName, nodeId);
} catch (InterruptedException | ExecutionException e) {
throw new OpenRoadmInterfaceException(String.format("Failed to delete interface %s on " + "node %s",
nodeId), e);
}
deviceTx.put(LogicalDatastoreType.CONFIGURATION, circuitPackIID, cpBldr.build());
- ListenableFuture<Void> txSubmitFuture = deviceTx.submit(Timeouts.DEVICE_WRITE_TIMEOUT,
- Timeouts.DEVICE_WRITE_TIMEOUT_UNIT);
+ FluentFuture<? extends @NonNull CommitInfo> txSubmitFuture =
+ deviceTx.commit(Timeouts.DEVICE_WRITE_TIMEOUT, Timeouts.DEVICE_WRITE_TIMEOUT_UNIT);
try {
txSubmitFuture.get();
LOG.info("Successfully posted equipment state change on node {}", nodeId);
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.ListenableFuture;
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.concurrent.ExecutionException;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
-
+import org.eclipse.jdt.annotation.NonNull;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
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.common.api.CommitInfo;
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;
Future<java.util.Optional<DeviceTransaction>> anotherDeviceTxFuture =
transactionManager.getDeviceTransaction("another-id");
Assert.assertTrue(anotherDeviceTxFuture.isDone());
- anotherDeviceTxFuture.get().get().submit(defaultTimeout, defaultTimeUnit);
+ anotherDeviceTxFuture.get().get().commit(defaultTimeout, defaultTimeUnit);
- firstDeviceTx.submit(defaultTimeout, defaultTimeUnit);
+ firstDeviceTx.commit(defaultTimeout, defaultTimeUnit);
Thread.sleep(200);
Assert.assertTrue(secondDeviceTxFuture.isDone());
Assert.assertFalse(thirdDeviceTxFuture.isDone());
secondDeviceTx.put(defaultDatastore, defaultIid, defaultData);
Assert.assertFalse(thirdDeviceTxFuture.isDone());
- secondDeviceTx.submit(defaultTimeout, defaultTimeUnit);
+ secondDeviceTx.commit(defaultTimeout, defaultTimeUnit);
Thread.sleep(200);
Assert.assertTrue(thirdDeviceTxFuture.isDone());
DeviceTransaction thirdDeviceTx = thirdDeviceTxFuture.get().get();
thirdDeviceTx.put(defaultDatastore, defaultIid, defaultData);
- thirdDeviceTx.submit(defaultTimeout, defaultTimeUnit);
+ thirdDeviceTx.commit(defaultTimeout, defaultTimeUnit);
Mockito.verify(rwTransactionMock, Mockito.times(3)).put(defaultDatastore, defaultIid, defaultData);
Mockito.verify(rwTransactionMock, Mockito.times(4)).commit();
try {
for (Future<java.util.Optional<DeviceTransaction>> futureTx : deviceTransactionFutures) {
DeviceTransaction deviceTx = futureTx.get().get();
- deviceTx.submit(defaultTimeout, defaultTimeUnit);
+ deviceTx.commit(defaultTimeout, defaultTimeUnit);
deviceTransactions.add(deviceTx);
}
} catch (InterruptedException | ExecutionException e) {
}
deviceTransactions.parallelStream()
- .forEach(deviceTransaction -> deviceTransaction.submit(defaultTimeout, defaultTimeUnit));
+ .forEach(deviceTransaction -> deviceTransaction.commit(defaultTimeout, defaultTimeUnit));
deviceTransactions.parallelStream()
.forEach(deviceTransaction -> Assert.assertTrue(deviceTransaction.wasSubmittedOrCancelled().get()));
Exception throwedException = null;
- ListenableFuture<Void> submitFuture = deviceTx.submit(200, defaultTimeUnit);
+ FluentFuture<? extends @NonNull CommitInfo> submitFuture = deviceTx.commit(200, defaultTimeUnit);
try {
submitFuture.get();
} catch (InterruptedException e) {
Future<java.util.Optional<DeviceTransaction>> deviceTxFuture = deviceTxManager.getDeviceTransaction(deviceId);
DeviceTransaction deviceTx = deviceTxFuture.get().get();
deviceTx.put(store, path, data);
- deviceTx.submit(defaultTimeout, defaultTimeUnit);
+ deviceTx.commit(defaultTimeout, defaultTimeUnit);
}
}
package org.opendaylight.transportpce.olm.power;
-import com.google.common.util.concurrent.ListenableFuture;
-
+import com.google.common.util.concurrent.FluentFuture;
import java.math.BigDecimal;
import java.util.HashMap;
import java.util.Map;
import java.util.Optional;
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.transportpce.common.Timeouts;
import org.opendaylight.transportpce.common.crossconnect.CrossConnect;
import org.opendaylight.transportpce.common.device.DeviceTransaction;
InstanceIdentifier<Interface> interfacesIID = InstanceIdentifier.create(OrgOpenroadmDevice.class)
.child(Interface.class, new InterfaceKey(interfaceName));
deviceTx.put(LogicalDatastoreType.CONFIGURATION, interfacesIID, ochInterfaceBuilder.build());
- ListenableFuture<Void> submit = deviceTx.submit(Timeouts.DEVICE_WRITE_TIMEOUT,
- Timeouts.DEVICE_WRITE_TIMEOUT_UNIT);
+ FluentFuture<? extends @NonNull CommitInfo> commit =
+ deviceTx.commit(Timeouts.DEVICE_WRITE_TIMEOUT, Timeouts.DEVICE_WRITE_TIMEOUT_UNIT);
try {
- submit.get();
- LOG.info("Transponder Power update is submitted");
+ commit.get();
+ LOG.info("Transponder Power update is committed");
return true;
} catch (InterruptedException | ExecutionException e) {
LOG.error("Setting transponder power failed {}", e);
InstanceIdentifier<RoadmConnections> roadmConnIID = InstanceIdentifier.create(OrgOpenroadmDevice.class)
.child(RoadmConnections.class, new RoadmConnectionsKey(connectionNumber));
deviceTx.put(LogicalDatastoreType.CONFIGURATION, roadmConnIID, newRdmConn);
- ListenableFuture<Void> submit = deviceTx.submit(Timeouts.DEVICE_WRITE_TIMEOUT,
- Timeouts.DEVICE_WRITE_TIMEOUT_UNIT);
+ FluentFuture<? extends @NonNull CommitInfo> commit =
+ deviceTx.commit(Timeouts.DEVICE_WRITE_TIMEOUT, Timeouts.DEVICE_WRITE_TIMEOUT_UNIT);
try {
- submit.get();
+ commit.get();
LOG.info("Roadm connection power level successfully set ");
return true;
} catch (InterruptedException | ExecutionException ex) {
package org.opendaylight.transportpce.olm.power;
-import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.FluentFuture;
import java.math.BigDecimal;
import java.util.HashMap;
import java.util.Map;
import java.util.Optional;
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.transportpce.common.Timeouts;
import org.opendaylight.transportpce.common.crossconnect.CrossConnect;
import org.opendaylight.transportpce.common.device.DeviceTransaction;
InstanceIdentifier<Interface> interfacesIID = InstanceIdentifier.create(OrgOpenroadmDevice.class)
.child(Interface.class, new InterfaceKey(interfaceName));
deviceTx.put(LogicalDatastoreType.CONFIGURATION, interfacesIID, ochInterfaceBuilder.build());
- ListenableFuture<Void> submit = deviceTx.submit(Timeouts.DEVICE_WRITE_TIMEOUT,
- Timeouts.DEVICE_WRITE_TIMEOUT_UNIT);
+ FluentFuture<? extends @NonNull CommitInfo> commit =
+ deviceTx.commit(Timeouts.DEVICE_WRITE_TIMEOUT, Timeouts.DEVICE_WRITE_TIMEOUT_UNIT);
try {
- submit.get();
- LOG.info("Transponder Power update is submitted");
+ commit.get();
+ LOG.info("Transponder Power update is committed");
return true;
} catch (InterruptedException | ExecutionException e) {
LOG.error("Setting transponder power failed {}", e);
InstanceIdentifier<RoadmConnections> roadmConnIID = InstanceIdentifier.create(OrgOpenroadmDevice.class)
.child(RoadmConnections.class, new RoadmConnectionsKey(connectionNumber));
deviceTx.put(LogicalDatastoreType.CONFIGURATION, roadmConnIID, newRdmConn);
- ListenableFuture<Void> submit = deviceTx.submit(Timeouts.DEVICE_WRITE_TIMEOUT,
- Timeouts.DEVICE_WRITE_TIMEOUT_UNIT);
+ FluentFuture<? extends @NonNull CommitInfo> commit =
+ deviceTx.commit(Timeouts.DEVICE_WRITE_TIMEOUT, Timeouts.DEVICE_WRITE_TIMEOUT_UNIT);
try {
- submit.get();
+ commit.get();
LOG.info("Roadm connection power level successfully set ");
return true;
} catch (InterruptedException | ExecutionException ex) {
}
DeviceTransaction deviceTx = deviceTxFuture.get().get();
deviceTx.put(logicalDatastoreType, instanceIdentifier, object, true);
- deviceTx.submit(Timeouts.DEVICE_WRITE_TIMEOUT, Timeouts.DEVICE_WRITE_TIMEOUT_UNIT).get();
+ deviceTx.commit(Timeouts.DEVICE_WRITE_TIMEOUT, Timeouts.DEVICE_WRITE_TIMEOUT_UNIT).get();
return true;
}