import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.JdkFutureAdapters;
+import com.google.common.util.concurrent.ListenableFuture;
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.math.BigInteger;
import java.util.Collection;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.arputil.rev160406.OdlArputilService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.arputil.rev160406.SendArpRequestInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.arputil.rev160406.SendArpRequestInputBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.arputil.rev160406.SendArpRequestOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.arputil.rev160406.interfaces.InterfaceAddress;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.arputil.rev160406.interfaces.InterfaceAddressBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.GetInterfaceFromIfIndexInput;
List<InterfaceAddress> addresses = Collections.singletonList(interfaceAddressBuilder.build());
SendArpRequestInput input = new SendArpRequestInputBuilder().setInterfaceAddress(addresses)
.setIpaddress(IpAddressBuilder.getDefaultInstance(targetIp)).build();
- Future<RpcResult<Void>> future = arpService.sendArpRequest(input);
+ ListenableFuture<RpcResult<SendArpRequestOutput>> future = arpService.sendArpRequest(input);
final String msgFormat = String.format("Send ARP Request on interface %s to destination %s",
sourceInterface, targetIp);
- Futures.addCallback(JdkFutureAdapters.listenInPoolThread(future), new FutureCallback<RpcResult<Void>>() {
- @Override
- public void onFailure(Throwable error) {
- LOG.error("Error - {}", msgFormat, error);
- }
-
- @Override
- public void onSuccess(RpcResult<Void> result) {
- if (result != null && !result.isSuccessful()) {
- LOG.warn("Rpc call to {} failed {}", msgFormat, getErrorText(result.getErrors()));
- } else {
- LOG.debug("Successful RPC Result - {}", msgFormat);
- }
- }
- });
+ Futures.addCallback(JdkFutureAdapters.listenInPoolThread(future),
+ new FutureCallback<RpcResult<SendArpRequestOutput>>() {
+ @Override
+ public void onFailure(Throwable error) {
+ LOG.error("Error - {}", msgFormat, error);
+ }
+
+ @Override
+ public void onSuccess(RpcResult<SendArpRequestOutput> result) {
+ if (result != null && !result.isSuccessful()) {
+ LOG.warn("Rpc call to {} failed {}", msgFormat, getErrorText(result.getErrors()));
+ } else {
+ LOG.debug("Successful RPC Result - {}", msgFormat);
+ }
+ }
+ });
}
}
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.MonitorProfileCreateOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.MonitorProfileDeleteInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.MonitorProfileDeleteInputBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.MonitorProfileDeleteOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.MonitorStartInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.MonitorStartInputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.MonitorStartOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.MonitorStatus;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.MonitorStopInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.MonitorStopInputBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.MonitorStopOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.MonitorUnpauseInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.MonitorUnpauseInputBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.MonitorUnpauseOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.MonitoringMode;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411._interface.monitor.map.InterfaceMonitorEntry;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411._interface.monitor.map.InterfaceMonitorEntryBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.AllocateIdInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.AllocateIdOutputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.CreateIdPoolInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.CreateIdPoolOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.IdManagerService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.ReleaseIdInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.ReleaseIdOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.OdlInterfaceRpcService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service.rev130709.PacketProcessingService;
import org.opendaylight.yangtools.yang.binding.DataObject;
MockitoAnnotations.initMocks(this);
when(idManager.createIdPool(any(CreateIdPoolInput.class)))
.thenReturn(Futures.immediateFuture(
- RpcResultBuilder.<Void>success().build()));
+ RpcResultBuilder.<CreateIdPoolOutput>success().build()));
AlivenessProtocolHandlerRegistry alivenessProtocolHandlerRegistry = new AlivenessProtocolHandlerRegistryImpl();
alivenessMonitor = new AlivenessMonitor(dataBroker, idManager,
.setIdValue(mockId++).build())
.build()));
when(idManager.releaseId(any(ReleaseIdInput.class))).thenReturn(Futures
- .immediateFuture(RpcResultBuilder.<Void>success().build()));
+ .immediateFuture(RpcResultBuilder.<ReleaseIdOutput>success().build()));
doReturn(readTx).when(dataBroker).newReadOnlyTransaction();
doReturn(writeTx).when(dataBroker).newWriteOnlyTransaction();
doReturn(readWriteTx).when(dataBroker).newReadWriteTransaction();
when(readTx.read(eq(LogicalDatastoreType.OPERATIONAL),
argThat(isType(MonitoridKeyEntry.class))))
.thenReturn(Futures.immediateCheckedFuture(optMap));
- RpcResult<Void> result = alivenessMonitor.monitorUnpause(input).get();
+ RpcResult<MonitorUnpauseOutput> result = alivenessMonitor.monitorUnpause(input).get();
verify(readWriteTx).merge(eq(LogicalDatastoreType.OPERATIONAL),
argThat(isType(MonitoringState.class)), stateCaptor.capture());
assertEquals(MonitorStatus.Started, stateCaptor.getValue().getStatus());
when(readWriteTx.read(eq(LogicalDatastoreType.OPERATIONAL),
argThat(isType(InterfaceMonitorEntry.class))))
.thenReturn(Futures.immediateCheckedFuture(optEntry));
- RpcResult<Void> result = alivenessMonitor.monitorStop(input).get();
+ RpcResult<MonitorStopOutput> result = alivenessMonitor.monitorStop(input).get();
verify(idManager).releaseId(any(ReleaseIdInput.class));
verify(writeTx, times(2)).delete(eq(LogicalDatastoreType.OPERATIONAL),
any(InstanceIdentifier.class));
when(readWriteTx.read(eq(LogicalDatastoreType.OPERATIONAL),
argThat(isType(MonitorProfile.class))))
.thenReturn(Futures.immediateCheckedFuture(optProfile));
- RpcResult<Void> result = alivenessMonitor.monitorProfileDelete(input)
+ RpcResult<MonitorProfileDeleteOutput> result = alivenessMonitor.monitorProfileDelete(input)
.get();
verify(idManager).releaseId(any(ReleaseIdInput.class));
verify(readWriteTx).delete(eq(LogicalDatastoreType.OPERATIONAL),
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.MonitorEvent;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.MonitorEventBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.MonitorPauseInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.MonitorPauseOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.MonitorProfileCreateInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.MonitorProfileCreateOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.MonitorProfileCreateOutputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.MonitorProfileDeleteInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.MonitorProfileDeleteOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.MonitorProfileGetInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.MonitorProfileGetOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.MonitorProfileGetOutputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.MonitorStartOutputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.MonitorStatus;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.MonitorStopInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.MonitorStopOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.MonitorUnpauseInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.MonitorUnpauseOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.MonitoringMode;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.MonitoringStates;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411._interface.monitor.map.InterfaceMonitorEntry;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.AllocateIdOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.CreateIdPoolInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.CreateIdPoolInputBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.CreateIdPoolOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.IdManagerService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.ReleaseIdInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.ReleaseIdInputBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.ReleaseIdOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service.rev130709.PacketInReason;
import org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service.rev130709.PacketProcessingListener;
import org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service.rev130709.PacketReceived;
.setPoolName(AlivenessMonitorConstants.MONITOR_IDPOOL_NAME)
.setLow(AlivenessMonitorConstants.MONITOR_IDPOOL_START)
.setHigh(AlivenessMonitorConstants.MONITOR_IDPOOL_SIZE).build();
- Future<RpcResult<Void>> resultFuture = idManager.createIdPool(createPool);
- Futures.addCallback(JdkFutureAdapters.listenInPoolThread(resultFuture), new FutureCallback<RpcResult<Void>>() {
-
- @Override
- public void onFailure(Throwable error) {
- LOG.error("Failed to create idPool for Aliveness Monitor Service", error);
- }
+ ListenableFuture<RpcResult<CreateIdPoolOutput>> resultFuture = idManager.createIdPool(createPool);
+ Futures.addCallback(JdkFutureAdapters.listenInPoolThread(resultFuture),
+ new FutureCallback<RpcResult<CreateIdPoolOutput>>() {
+ @Override
+ public void onFailure(Throwable error) {
+ LOG.error("Failed to create idPool for Aliveness Monitor Service", error);
+ }
- @Override
- public void onSuccess(@Nonnull RpcResult<Void> result) {
- if (result.isSuccessful()) {
- LOG.debug("Created IdPool for Aliveness Monitor Service");
- } else {
- LOG.error("RPC to create Idpool failed {}", result.getErrors());
- }
- }
- }, callbackExecutorService);
+ @Override
+ public void onSuccess(@Nonnull RpcResult<CreateIdPoolOutput> result) {
+ if (result.isSuccessful()) {
+ LOG.debug("Created IdPool for Aliveness Monitor Service");
+ } else {
+ LOG.error("RPC to create Idpool failed {}", result.getErrors());
+ }
+ }
+ }, callbackExecutorService);
}
private int getUniqueId(final String idKey) {
ReleaseIdInput idInput = new ReleaseIdInputBuilder().setPoolName(AlivenessMonitorConstants.MONITOR_IDPOOL_NAME)
.setIdKey(idKey).build();
try {
- Future<RpcResult<Void>> result = idManager.releaseId(idInput);
- RpcResult<Void> rpcResult = result.get();
+ ListenableFuture<RpcResult<ReleaseIdOutput>> result = idManager.releaseId(idInput);
+ RpcResult<ReleaseIdOutput> rpcResult = result.get();
if (!rpcResult.isSuccessful()) {
LOG.warn("RPC Call to release Id {} returned with Errors {}", idKey, rpcResult.getErrors());
}
}
@Override
- public Future<RpcResult<MonitorStartOutput>> monitorStart(MonitorStartInput input) {
+ public ListenableFuture<RpcResult<MonitorStartOutput>> monitorStart(MonitorStartInput input) {
RpcResultBuilder<MonitorStartOutput> rpcResultBuilder;
final Config in = input.getConfig();
Long profileId = in.getProfileId();
LOG.warn("Monitoring for the interface {} with this configuration is already registered.",
interfaceName);
MonitorStartOutput output = new MonitorStartOutputBuilder().setMonitorId(monitorId).build();
- rpcResultBuilder = RpcResultBuilder.success(output).withWarning(ErrorType.APPLICATION, "config-exists",
- message);
+ rpcResultBuilder = RpcResultBuilder.success(output).withWarning(ErrorType.APPLICATION,
+ "config-exists", message);
return Futures.immediateFuture(rpcResultBuilder.build());
} else {
// Construct the monitor key
}
@Override
- public Future<RpcResult<Void>> monitorPause(MonitorPauseInput input) {
+ public ListenableFuture<RpcResult<MonitorPauseOutput>> monitorPause(MonitorPauseInput input) {
LOG.debug("Monitor Pause operation invoked for monitor id: {}", input.getMonitorId());
- SettableFuture<RpcResult<Void>> result = SettableFuture.create();
+ SettableFuture<RpcResult<MonitorPauseOutput>> result = SettableFuture.create();
final Long monitorId = input.getMonitorId();
// Set the monitoring status to Paused
updateMonitorStatusTo(monitorId, MonitorStatus.Paused, currentStatus -> currentStatus == MonitorStatus.Started);
if (stopMonitoringTask(monitorId)) {
- result.set(RpcResultBuilder.<Void>success().build());
+ result.set(RpcResultBuilder.<MonitorPauseOutput>success().build());
} else {
String errorMsg = String.format("No Monitoring Task availble to pause for the given monitor id : %d",
monitorId);
LOG.error("Monitor Pause operation failed- {}", errorMsg);
- result.set(RpcResultBuilder.<Void>failed().withError(ErrorType.APPLICATION, errorMsg).build());
+ result.set(RpcResultBuilder.<MonitorPauseOutput>failed()
+ .withError(ErrorType.APPLICATION, errorMsg).build());
}
return result;
}
@Override
- public Future<RpcResult<Void>> monitorUnpause(MonitorUnpauseInput input) {
+ public ListenableFuture<RpcResult<MonitorUnpauseOutput>> monitorUnpause(MonitorUnpauseInput input) {
LOG.debug("Monitor Unpause operation invoked for monitor id: {}", input.getMonitorId());
- final SettableFuture<RpcResult<Void>> result = SettableFuture.create();
+ final SettableFuture<RpcResult<MonitorUnpauseOutput>> result = SettableFuture.create();
final Long monitorId = input.getMonitorId();
final ReadOnlyTransaction tx = dataBroker.newReadOnlyTransaction();
tx.close();
String msg = String.format("Unable to read monitoring info associated with monitor id %d", monitorId);
LOG.error("Monitor unpause Failed. {}", msg, error);
- result.set(RpcResultBuilder.<Void>failed().withError(ErrorType.APPLICATION, msg, error).build());
+ result.set(RpcResultBuilder.<MonitorUnpauseOutput>failed()
+ .withError(ErrorType.APPLICATION, msg, error).build());
}
@Override
String msg = String.format("Unable to read Monitoring profile associated with id %d",
info.getProfileId());
LOG.warn("Monitor unpause Failed. {}", msg, error);
- result.set(RpcResultBuilder.<Void>failed().withError(ErrorType.APPLICATION, msg, error)
- .build());
+ result.set(RpcResultBuilder.<MonitorUnpauseOutput>failed()
+ .withError(ErrorType.APPLICATION, msg, error).build());
}
@Override
} else {
scheduleMonitoringTask(info, profile.getMonitorInterval());
}
- result.set(RpcResultBuilder.<Void>success().build());
+ result.set(RpcResultBuilder.<MonitorUnpauseOutput>success().build());
} else {
String msg = String.format("Monitoring profile associated with id %d is not present",
info.getProfileId());
LOG.warn("Monitor unpause Failed. {}", msg);
result.set(
- RpcResultBuilder.<Void>failed().withError(ErrorType.APPLICATION, msg).build());
+ RpcResultBuilder.<MonitorUnpauseOutput>failed()
+ .withError(ErrorType.APPLICATION, msg).build());
}
}
}, callbackExecutorService);
tx.close();
String msg = String.format("Monitoring info associated with id %d is not present", monitorId);
LOG.warn("Monitor unpause Failed. {}", msg);
- result.set(RpcResultBuilder.<Void>failed().withError(ErrorType.APPLICATION, msg).build());
+ result.set(RpcResultBuilder.<MonitorUnpauseOutput>failed()
+ .withError(ErrorType.APPLICATION, msg).build());
}
}
}, callbackExecutorService);
}
@Override
- public Future<RpcResult<MonitorProfileCreateOutput>> monitorProfileCreate(final MonitorProfileCreateInput input) {
+ public ListenableFuture<RpcResult<MonitorProfileCreateOutput>> monitorProfileCreate(
+ final MonitorProfileCreateInput input) {
LOG.debug("Monitor Profile Create operation - {}", input.getProfile());
final SettableFuture<RpcResult<MonitorProfileCreateOutput>> returnFuture = SettableFuture.create();
Profile profile = input.getProfile();
}
@Override
- public Future<RpcResult<MonitorProfileGetOutput>> monitorProfileGet(MonitorProfileGetInput input) {
+ public ListenableFuture<RpcResult<MonitorProfileGetOutput>> monitorProfileGet(MonitorProfileGetInput input) {
LOG.debug("Monitor Profile Get operation for input profile- {}", input.getProfile());
RpcResultBuilder<MonitorProfileGetOutput> rpcResultBuilder;
final Long profileId = getExistingProfileId(input);
}
@Override
- public Future<RpcResult<Void>> monitorProfileDelete(final MonitorProfileDeleteInput input) {
+ public ListenableFuture<RpcResult<MonitorProfileDeleteOutput>> monitorProfileDelete(
+ final MonitorProfileDeleteInput input) {
LOG.debug("Monitor Profile delete for Id: {}", input.getProfileId());
- final SettableFuture<RpcResult<Void>> result = SettableFuture.create();
+ final SettableFuture<RpcResult<MonitorProfileDeleteOutput>> result = SettableFuture.create();
final Long profileId = input.getProfileId();
final ReadWriteTransaction tx = dataBroker.newReadWriteTransaction();
ListenableFuture<Optional<MonitorProfile>> readFuture = tx.read(LogicalDatastoreType.OPERATIONAL,
getMonitorProfileId(profileId));
- ListenableFuture<RpcResult<Void>> writeFuture = Futures.transformAsync(readFuture, optProfile -> {
- if (optProfile.isPresent()) {
- tx.delete(LogicalDatastoreType.OPERATIONAL, getMonitorProfileId(profileId));
- Futures.addCallback(tx.submit(), new FutureCallback<Void>() {
- @Override
- public void onFailure(Throwable error) {
- String msg = String.format("Error when removing monitor profile %d from datastore",
- profileId);
- LOG.error("Error when removing monitor profile {} from datastore", profileId, error);
- result.set(RpcResultBuilder.<Void>failed().withError(ErrorType.APPLICATION, msg, error)
- .build());
- }
+ ListenableFuture<RpcResult<MonitorProfileDeleteOutput>> writeFuture =
+ Futures.transformAsync(readFuture, optProfile -> {
+ if (optProfile.isPresent()) {
+ tx.delete(LogicalDatastoreType.OPERATIONAL, getMonitorProfileId(profileId));
+ Futures.addCallback(tx.submit(), new FutureCallback<Void>() {
+ @Override
+ public void onFailure(Throwable error) {
+ String msg = String.format("Error when removing monitor profile %d from datastore",
+ profileId);
+ LOG.error("Error when removing monitor profile {} from datastore", profileId, error);
+ result.set(RpcResultBuilder.<MonitorProfileDeleteOutput>failed()
+ .withError(ErrorType.APPLICATION, msg, error)
+ .build());
+ }
- @Override
- public void onSuccess(Void noarg) {
- MonitorProfile profile = optProfile.get();
- String id = getUniqueProfileKey(profile.getFailureThreshold(),
- profile.getMonitorInterval(), profile.getMonitorWindow(),
- profile.getProtocolType());
- releaseId(id);
- result.set(RpcResultBuilder.<Void>success().build());
- }
- }, callbackExecutorService);
- } else {
- String msg = String.format("Monitor profile with Id: %d does not exist", profileId);
- LOG.info(msg);
- result.set(RpcResultBuilder.<Void>success()
- .withWarning(ErrorType.PROTOCOL, "invalid-value", msg).build());
- }
- return result;
- }, callbackExecutorService);
+ @Override
+ public void onSuccess(Void noarg) {
+ MonitorProfile profile = optProfile.get();
+ String id = getUniqueProfileKey(profile.getFailureThreshold(),
+ profile.getMonitorInterval(), profile.getMonitorWindow(),
+ profile.getProtocolType());
+ releaseId(id);
+ result.set(RpcResultBuilder.<MonitorProfileDeleteOutput>success().build());
+ }
+ }, callbackExecutorService);
+ } else {
+ String msg = String.format("Monitor profile with Id: %d does not exist", profileId);
+ LOG.info(msg);
+ result.set(RpcResultBuilder.<MonitorProfileDeleteOutput>success()
+ .withWarning(ErrorType.PROTOCOL, "invalid-value", msg).build());
+ }
+ return result;
+ }, callbackExecutorService);
- Futures.addCallback(writeFuture, new FutureCallback<RpcResult<Void>>() {
+ Futures.addCallback(writeFuture, new FutureCallback<RpcResult<MonitorProfileDeleteOutput>>() {
@Override
public void onFailure(Throwable error) {
String msg = String.format("Error when removing monitor profile %d from datastore", profileId);
LOG.error("Error when removing monitor profile {} from datastore", profileId, error);
- result.set(RpcResultBuilder.<Void>failed().withError(ErrorType.APPLICATION, msg, error).build());
+ result.set(RpcResultBuilder.<MonitorProfileDeleteOutput>failed()
+ .withError(ErrorType.APPLICATION, msg, error).build());
}
@Override
- public void onSuccess(RpcResult<Void> noarg) {
+ public void onSuccess(RpcResult<MonitorProfileDeleteOutput> noarg) {
LOG.debug("Successfully removed Monitor Profile {}", profileId);
}
}, callbackExecutorService);
}
@Override
- public Future<RpcResult<Void>> monitorStop(MonitorStopInput input) {
+ public ListenableFuture<RpcResult<MonitorStopOutput>> monitorStop(MonitorStopInput input) {
LOG.debug("Monitor Stop operation for monitor id - {}", input.getMonitorId());
- SettableFuture<RpcResult<Void>> result = SettableFuture.create();
+ SettableFuture<RpcResult<MonitorStopOutput>> result = SettableFuture.create();
final Long monitorId = input.getMonitorId();
Optional<MonitoringInfo> optInfo =
lockMap.remove(monitorKey);
}
- result.set(RpcResultBuilder.<Void>success().build());
+ result.set(RpcResultBuilder.<MonitorStopOutput>success().build());
} else {
String errorMsg = String.format("Do not have monitoring information associated with key %d", monitorId);
LOG.error("Delete monitoring operation Failed - {}", errorMsg);
- result.set(RpcResultBuilder.<Void>failed().withError(ErrorType.APPLICATION, errorMsg).build());
+ result.set(RpcResultBuilder.<MonitorStopOutput>failed().withError(ErrorType.APPLICATION, errorMsg).build());
}
return result;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.arputil.rev160406.OdlArputilService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.arputil.rev160406.SendArpRequestInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.arputil.rev160406.SendArpRequestInputBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.arputil.rev160406.SendArpRequestOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.arputil.rev160406.SendArpResponseInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.arputil.rev160406.SendArpResponseOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.arputil.rev160406.interfaces.InterfaceAddress;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.GetEgressActionsForInterfaceInputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.GetEgressActionsForInterfaceOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service.rev130709.SendToController;
import org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service.rev130709.TransmitPacketInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service.rev130709.TransmitPacketInputBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service.rev130709.TransmitPacketOutput;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.common.RpcError.ErrorType;
}
@Override
- public Future<RpcResult<GetMacOutput>> getMac(GetMacInput input) {
+ public ListenableFuture<RpcResult<GetMacOutput>> getMac(GetMacInput input) {
try {
final String dstIpAddress = getIpAddressInString(input.getIpaddress());
LOG.trace("getMac rpc invoked for ip {}", dstIpAddress);
}
SendArpRequestInputBuilder builder = new SendArpRequestInputBuilder()
.setInterfaceAddress(input.getInterfaceAddress()).setIpaddress(input.getIpaddress());
- Future<RpcResult<Void>> arpReqFt = sendArpRequest(builder.build());
+ ListenableFuture<RpcResult<SendArpRequestOutput>> arpReqFt = sendArpRequest(builder.build());
final SettableFuture<RpcResult<GetMacOutput>> ft = SettableFuture.create();
Futures.addCallback(JdkFutureAdapters.listenInPoolThread(arpReqFt, threadPool),
- new FutureCallback<RpcResult<Void>>() {
+ new FutureCallback<RpcResult<SendArpRequestOutput>>() {
@Override
public void onFailure(Throwable ex) {
RpcResultBuilder<GetMacOutput> resultBuilder = RpcResultBuilder.<GetMacOutput>failed()
}
@Override
- public void onSuccess(RpcResult<Void> result) {
+ public void onSuccess(RpcResult<SendArpRequestOutput> result) {
LOG.trace("Successfully sent the arp pkt out for ip {}", dstIpAddress);
}
}, MoreExecutors.directExecutor());
}
@Override
- public Future<RpcResult<Void>> sendArpRequest(SendArpRequestInput arpReqInput) {
+ public ListenableFuture<RpcResult<SendArpRequestOutput>> sendArpRequest(SendArpRequestInput arpReqInput) {
LOG.trace("rpc sendArpRequest invoked for ip {}", arpReqInput.getIpaddress());
BigInteger dpnId;
byte[] payload;
byte[] dstIpBytes;
byte[] srcMac;
- RpcResultBuilder<Void> failureBuilder = RpcResultBuilder.failed();
- RpcResultBuilder<Void> successBuilder = RpcResultBuilder.success();
+ RpcResultBuilder<SendArpRequestOutput> failureBuilder = RpcResultBuilder.failed();
+ RpcResultBuilder<SendArpRequestOutput> successBuilder = RpcResultBuilder.success();
try {
dstIpBytes = getIpAddressBytes(arpReqInput.getIpaddress());
return Futures.immediateFuture(successBuilder.build());
}
- public Future<RpcResult<Void>> sendPacketOut(BigInteger dpnId, byte[] payload, NodeConnectorRef ref) {
+ public ListenableFuture<RpcResult<TransmitPacketOutput>> sendPacketOut(
+ BigInteger dpnId, byte[] payload, NodeConnectorRef ref) {
NodeConnectorRef nodeConnectorRef = MDSALUtil.getNodeConnRef(dpnId, "0xfffffffd");
return packetProcessingService.transmitPacket(new TransmitPacketInputBuilder().setPayload(payload)
.setNode(new NodeRef(InstanceIdentifier.builder(Nodes.class)
.setIngress(nodeConnectorRef).setEgress(ref).build());
}
- private Future<RpcResult<Void>> sendPacketOutWithActions(BigInteger dpnId, byte[] payload, NodeConnectorRef ref,
-
List<Action> actions) {
+ private Future<RpcResult<TransmitPacketOutput>> sendPacketOutWithActions(
+
BigInteger dpnId, byte[] payload, NodeConnectorRef ref, List<Action> actions) {
NodeConnectorRef nodeConnectorRef = MDSALUtil.getNodeConnRef(dpnId, "0xfffffffd");
TransmitPacketInput transmitPacketInput = new TransmitPacketInputBuilder().setPayload(payload)
.setNode(new NodeRef(InstanceIdentifier.builder(Nodes.class)
}
@Override
- public Future<RpcResult<Void>> sendArpResponse(SendArpResponseInput input) {
+ public ListenableFuture<RpcResult<SendArpResponseOutput>> sendArpResponse(SendArpResponseInput input) {
LOG.trace("sendArpResponse rpc invoked");
BigInteger dpnId;
byte[] payload;
} catch (UnknownHostException | PacketException | InterruptedException | UnsupportedEncodingException
| ExecutionException e) {
LOG.error("failed to send arp response for {}: ", input.getSrcIpaddress(), e);
- return RpcResultBuilder.<Void>failed().withError(ErrorType.APPLICATION, e.getMessage(), e).buildFuture();
+ return RpcResultBuilder.<SendArpResponseOutput>failed()
+ .withError(ErrorType.APPLICATION, e.getMessage(), e).buildFuture();
}
- RpcResultBuilder<Void> rpcResultBuilder = RpcResultBuilder.success();
+ RpcResultBuilder<SendArpResponseOutput> rpcResultBuilder = RpcResultBuilder.success();
return Futures.immediateFuture(rpcResultBuilder.build());
}
import static org.opendaylight.yangtools.testutils.mockito.MoreAnswers.realOrException;
import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
import java.util.ArrayList;
import java.util.List;
-import java.util.concurrent.Future;
+
import org.mockito.Mockito;
import org.opendaylight.genius.mdsalutil.ActionInfo;
import org.opendaylight.genius.mdsalutil.actions.ActionOutput;
}
@Override
- public Future<RpcResult<GetPortFromInterfaceOutput>> getPortFromInterface(GetPortFromInterfaceInput input) {
+ public ListenableFuture<RpcResult<GetPortFromInterfaceOutput>> getPortFromInterface(
+ GetPortFromInterfaceInput input) {
RpcResultBuilder<GetPortFromInterfaceOutput> rpcResultBuilder;
GetPortFromInterfaceOutputBuilder output = new GetPortFromInterfaceOutputBuilder().setDpid(DPN_ID)
.setPortname(INTERFACE_NAME).setPortno(PORT_NUMBER).setPhyAddress("1F:1F:1F:1F:1F:1F");
}
@Override
- public Future<RpcResult<GetEgressActionsForInterfaceOutput>>
+ public ListenableFuture<RpcResult<GetEgressActionsForInterfaceOutput>>
getEgressActionsForInterface(GetEgressActionsForInterfaceInput input) {
RpcResultBuilder<GetEgressActionsForInterfaceOutput> rpcResultBuilder;
}
@Override
- public Future<RpcResult<GetInterfaceFromIfIndexOutput>>
+ public ListenableFuture<RpcResult<GetInterfaceFromIfIndexOutput>>
getInterfaceFromIfIndex(GetInterfaceFromIfIndexInput input) {
RpcResultBuilder<GetInterfaceFromIfIndexOutput> rpcResultBuilder;
GetInterfaceFromIfIndexOutputBuilder output = new GetInterfaceFromIfIndexOutputBuilder()
import static org.opendaylight.yangtools.testutils.mockito.MoreAnswers.realOrException;
import com.google.common.util.concurrent.Futures;
-import java.util.concurrent.Future;
+import com.google.common.util.concurrent.ListenableFuture;
+
import org.mockito.Mockito;
import org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service.rev130709.PacketProcessingService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service.rev130709.TransmitPacketInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service.rev130709.TransmitPacketOutput;
import org.opendaylight.yangtools.yang.common.RpcResult;
import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
}
@Override
- public Future<RpcResult<Void>> transmitPacket(TransmitPacketInput input) {
- RpcResultBuilder<Void> rpcResultBuilder = RpcResultBuilder.success();
+ public ListenableFuture<RpcResult<TransmitPacketOutput>> transmitPacket(TransmitPacketInput input) {
+ RpcResultBuilder<TransmitPacketOutput> rpcResultBuilder = RpcResultBuilder.success();
return Futures.immediateFuture(rpcResultBuilder.build());
}
}
package org.opendaylight.genius.testutils.itm;
import com.google.common.collect.Lists;
+import com.google.common.util.concurrent.ListenableFuture;
import java.math.BigInteger;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.Future;
+
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddressBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.AddExternalTunnelEndpointInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.AddExternalTunnelEndpointOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.AddL2GwDeviceInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.AddL2GwDeviceOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.AddL2GwMlagDeviceInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.AddL2GwMlagDeviceOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.BuildExternalTunnelFromDpnsInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.BuildExternalTunnelFromDpnsOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.CreateTerminatingServiceActionsInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.CreateTerminatingServiceActionsOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.DeleteL2GwDeviceInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.DeleteL2GwDeviceOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.DeleteL2GwMlagDeviceInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.DeleteL2GwMlagDeviceOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.GetDpnEndpointIpsInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.GetDpnEndpointIpsOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.GetDpnEndpointIpsOutputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.IsTunnelInternalOrExternalOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.ItmRpcService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.RemoveExternalTunnelEndpointInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.RemoveExternalTunnelEndpointOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.RemoveExternalTunnelFromDpnsInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.RemoveExternalTunnelFromDpnsOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.RemoveTerminatingServiceActionsInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.RemoveTerminatingServiceActionsOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.SetBfdEnableOnTunnelInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.SetBfdEnableOnTunnelOutput;
import org.opendaylight.yangtools.yang.common.RpcResult;
import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
}
@Override
- public synchronized Future<RpcResult<Void>> buildExternalTunnelFromDpns(BuildExternalTunnelFromDpnsInput input) {
- return RpcResultBuilder.<Void>success().buildFuture();
+ public synchronized ListenableFuture<RpcResult<BuildExternalTunnelFromDpnsOutput>> buildExternalTunnelFromDpns(
+ BuildExternalTunnelFromDpnsInput input) {
+ return RpcResultBuilder.<BuildExternalTunnelFromDpnsOutput>success().buildFuture();
}
@Override
- public synchronized Future<RpcResult<Void>> removeExternalTunnelEndpoint(RemoveExternalTunnelEndpointInput input) {
- return RpcResultBuilder.<Void>success().buildFuture();
+ public synchronized ListenableFuture<RpcResult<RemoveExternalTunnelEndpointOutput>> removeExternalTunnelEndpoint(
+ RemoveExternalTunnelEndpointInput input) {
+ return RpcResultBuilder.<RemoveExternalTunnelEndpointOutput>success().buildFuture();
}
@Override
- public Future<RpcResult<GetDpnInfoOutput>> getDpnInfo(GetDpnInfoInput input) {
+ public ListenableFuture<RpcResult<GetDpnInfoOutput>> getDpnInfo(GetDpnInfoInput input) {
throw new UnsupportedOperationException("getDpnInfo");
}
@Override
- public synchronized Future<RpcResult<Void>> addL2GwMlagDevice(AddL2GwMlagDeviceInput input) {
- return RpcResultBuilder.<Void>success().buildFuture();
+ public synchronized ListenableFuture<RpcResult<AddL2GwMlagDeviceOutput>> addL2GwMlagDevice(
+ AddL2GwMlagDeviceInput input) {
+ return RpcResultBuilder.<AddL2GwMlagDeviceOutput>success().buildFuture();
}
@Override
- public synchronized Future<RpcResult<Void>> removeExternalTunnelFromDpns(RemoveExternalTunnelFromDpnsInput input) {
- return RpcResultBuilder.<Void>success().buildFuture();
+ public synchronized ListenableFuture<RpcResult<RemoveExternalTunnelFromDpnsOutput>> removeExternalTunnelFromDpns(
+ RemoveExternalTunnelFromDpnsInput input) {
+ return RpcResultBuilder.<RemoveExternalTunnelFromDpnsOutput>success().buildFuture();
}
@Override
- public synchronized Future<RpcResult<Void>> deleteL2GwDevice(DeleteL2GwDeviceInput input) {
- return RpcResultBuilder.<Void>success().buildFuture();
+ public synchronized ListenableFuture<RpcResult<DeleteL2GwDeviceOutput>> deleteL2GwDevice(
+ DeleteL2GwDeviceInput input) {
+ return RpcResultBuilder.<DeleteL2GwDeviceOutput>success().buildFuture();
}
@Override
- public synchronized Future<RpcResult<Void>> addL2GwDevice(AddL2GwDeviceInput input) {
- return RpcResultBuilder.<Void>success().buildFuture();
+ public synchronized ListenableFuture<RpcResult<AddL2GwDeviceOutput>> addL2GwDevice(AddL2GwDeviceInput input) {
+ return RpcResultBuilder.<AddL2GwDeviceOutput>success().buildFuture();
}
@Override
- public synchronized Future<RpcResult<IsTunnelInternalOrExternalOutput>> isTunnelInternalOrExternal(
+ public synchronized ListenableFuture<RpcResult<IsTunnelInternalOrExternalOutput>> isTunnelInternalOrExternal(
IsTunnelInternalOrExternalInput input) {
throw new UnsupportedOperationException("TODO");
}
@Override
- public synchronized Future<RpcResult<GetTunnelInterfaceNameOutput>> getTunnelInterfaceName(
+ public synchronized ListenableFuture<RpcResult<GetTunnelInterfaceNameOutput>> getTunnelInterfaceName(
GetTunnelInterfaceNameInput input) {
String interfaceName = interfaceNames.get(input.getSourceDpid())
.get(new String(tepIps.get(input.getDestinationDpid()).getValue()));
}
@Override
- public synchronized Future<RpcResult<IsDcgwPresentOutput>> isDcgwPresent(IsDcgwPresentInput input) {
+ public synchronized ListenableFuture<RpcResult<IsDcgwPresentOutput>> isDcgwPresent(IsDcgwPresentInput input) {
IsDcgwPresentOutput output = new IsDcgwPresentOutputBuilder().setRetVal(0L).build();
return RpcResultBuilder.success(output).buildFuture();
}
@Override
- public synchronized Future<RpcResult<GetExternalTunnelInterfaceNameOutput>> getExternalTunnelInterfaceName(
- GetExternalTunnelInterfaceNameInput input) {
+ public synchronized ListenableFuture<RpcResult<GetExternalTunnelInterfaceNameOutput>>
+ getExternalTunnelInterfaceName(GetExternalTunnelInterfaceNameInput input) {
String interfaceName = externalInterfaceNames.get(new BigInteger(input.getSourceNode(), 10))
.get(input.getDestinationNode());
GetExternalTunnelInterfaceNameOutput output = new GetExternalTunnelInterfaceNameOutputBuilder()
}
@Override
- public synchronized Future<RpcResult<Void>> createTerminatingServiceActions(
- CreateTerminatingServiceActionsInput input) {
- return RpcResultBuilder.<Void>success().buildFuture();
+ public synchronized ListenableFuture<RpcResult<CreateTerminatingServiceActionsOutput>>
+ createTerminatingServiceActions(CreateTerminatingServiceActionsInput input) {
+ return RpcResultBuilder.<CreateTerminatingServiceActionsOutput>success().buildFuture();
}
@Override
- public synchronized Future<RpcResult<GetDpnEndpointIpsOutput>> getDpnEndpointIps(GetDpnEndpointIpsInput input) {
+ public synchronized ListenableFuture<RpcResult<GetDpnEndpointIpsOutput>> getDpnEndpointIps(
+ GetDpnEndpointIpsInput input) {
GetDpnEndpointIpsOutput output = new GetDpnEndpointIpsOutputBuilder()
.setNexthopipList(Lists.newArrayList(tepIps.get(input.getSourceDpid()))).build();
return RpcResultBuilder.success(output).buildFuture();
}
@Override
- public synchronized Future<RpcResult<Void>> deleteL2GwMlagDevice(DeleteL2GwMlagDeviceInput input) {
- return RpcResultBuilder.<Void>success().buildFuture();
+ public synchronized ListenableFuture<RpcResult<DeleteL2GwMlagDeviceOutput>> deleteL2GwMlagDevice(
+ DeleteL2GwMlagDeviceInput input) {
+ return RpcResultBuilder.<DeleteL2GwMlagDeviceOutput>success().buildFuture();
}
@Override
- public synchronized Future<RpcResult<GetInternalOrExternalInterfaceNameOutput>> getInternalOrExternalInterfaceName(
- GetInternalOrExternalInterfaceNameInput input) {
+ public synchronized ListenableFuture<RpcResult<GetInternalOrExternalInterfaceNameOutput>>
+ getInternalOrExternalInterfaceName(GetInternalOrExternalInterfaceNameInput input) {
throw new UnsupportedOperationException("TODO");
}
@Override
- public synchronized Future<RpcResult<Void>> removeTerminatingServiceActions(
- RemoveTerminatingServiceActionsInput input) {
- return RpcResultBuilder.<Void>success().buildFuture();
+ public synchronized ListenableFuture<RpcResult<RemoveTerminatingServiceActionsOutput>>
+ removeTerminatingServiceActions(RemoveTerminatingServiceActionsInput input) {
+ return RpcResultBuilder.<RemoveTerminatingServiceActionsOutput>success().buildFuture();
}
@Override
- public synchronized Future<RpcResult<Void>> addExternalTunnelEndpoint(AddExternalTunnelEndpointInput input) {
- return RpcResultBuilder.<Void>success().buildFuture();
+ public synchronized ListenableFuture<RpcResult<AddExternalTunnelEndpointOutput>> addExternalTunnelEndpoint(
+ AddExternalTunnelEndpointInput input) {
+ return RpcResultBuilder.<AddExternalTunnelEndpointOutput>success().buildFuture();
}
@Override
- public synchronized Future<RpcResult<Void>> setBfdEnableOnTunnel(SetBfdEnableOnTunnelInput input) {
+ public synchronized ListenableFuture<RpcResult<SetBfdEnableOnTunnelOutput>> setBfdEnableOnTunnel(
+ SetBfdEnableOnTunnelInput input) {
throw new UnsupportedOperationException("TODO");
}
@Override
- public synchronized Future<RpcResult<GetEgressActionsForTunnelOutput>>
+ public synchronized ListenableFuture<RpcResult<GetEgressActionsForTunnelOutput>>
getEgressActionsForTunnel(GetEgressActionsForTunnelInput input) {
throw new UnsupportedOperationException("TODO");
}
@Override
- public synchronized Future<RpcResult<GetTunnelTypeOutput>> getTunnelType(GetTunnelTypeInput input) {
+ public synchronized ListenableFuture<RpcResult<GetTunnelTypeOutput>> getTunnelType(GetTunnelTypeInput input) {
throw new UnsupportedOperationException("TODO");
}
}
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.MoreExecutors;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutionException;
-import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
+
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.ReadFailedException;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.AllocateIdRangeOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.AllocateIdRangeOutputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.CreateIdPoolInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.CreateIdPoolOutput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.CreateIdPoolOutputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.DeleteIdPoolInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.DeleteIdPoolOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.IdManagerService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.IdPools;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.ReleaseIdInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.ReleaseIdOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.id.pools.IdPool;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.id.pools.IdPoolBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.id.pools.IdPoolKey;
}
@Override
- public Future<RpcResult<Void>> createIdPool(CreateIdPoolInput input) {
+ public ListenableFuture<RpcResult<CreateIdPoolOutput>> createIdPool(CreateIdPoolInput input) {
LOG.info("createIdPool called with input {}", input);
long low = input.getLow();
long high = input.getHigh();
String poolName = input.getPoolName().intern();
try {
idUtils.lock(lockManager, poolName);
- return txRunner.callWithNewWriteOnlyTransactionAndSubmit(tx -> {
+ return Futures.transform(txRunner.callWithNewWriteOnlyTransactionAndSubmit(tx -> {
IdPool idPool = createGlobalPool(tx, poolName, low, high, blockSize);
String localPoolName = idUtils.getLocalPoolName(poolName);
IdLocalPool idLocalPool = localPool.get(poolName);
createLocalPool(tx, localPoolName, idPool);
idUtils.updateChildPool(tx, idPool.getPoolName(), localPoolName);
}
- });
+ }), unused -> new CreateIdPoolOutputBuilder().build(), MoreExecutors.directExecutor());
} finally {
idUtils.unlock(lockManager, poolName);
}
}
@Override
- public Future<RpcResult<AllocateIdOutput>> allocateId(AllocateIdInput input) {
+ public
ListenableFuture<RpcResult<AllocateIdOutput>> allocateId(AllocateIdInput input) {
String idKey = input.getIdKey();
String poolName = input.getPoolName();
return FutureRpcResults.fromBuilder(LOG, "allocateId", input, () -> {
}
@Override
- public Future<RpcResult<AllocateIdRangeOutput>> allocateIdRange(AllocateIdRangeInput input) {
+ public
ListenableFuture<RpcResult<AllocateIdRangeOutput>> allocateIdRange(AllocateIdRangeInput input) {
String idKey = input.getIdKey();
String poolName = input.getPoolName();
long size = input.getSize();
}
@Override
- public Future<RpcResult<Void>> deleteIdPool(DeleteIdPoolInput input) {
+ public ListenableFuture<RpcResult<DeleteIdPoolOutput>> deleteIdPool(DeleteIdPoolInput input) {
return FutureRpcResults.fromListenableFuture(LOG, "deleteIdPool", input, () -> {
String poolName = input.getPoolName().intern();
InstanceIdentifier<IdPool> idPoolToBeDeleted = idUtils.getIdPoolInstance(poolName);
singleTxDB.syncDelete(CONFIGURATION, idPoolToBeDeleted);
}
// TODO return the Future from a TBD asyncDelete instead.. BUT check that all callers @CheckReturnValue
- return Futures.immediateFuture((Void) null);
+ return Futures.immediateFuture((DeleteIdPoolOutput) null);
}).build();
}
@Override
- public Future<RpcResult<Void>> releaseId(ReleaseIdInput input) {
+ public ListenableFuture<RpcResult<ReleaseIdOutput>> releaseId(ReleaseIdInput input) {
String poolName = input.getPoolName();
String idKey = input.getIdKey();
String uniqueKey = idUtils.getUniqueKey(poolName, idKey);
idUtils.lock(lockManager, uniqueKey);
releaseIdFromLocalPool(poolName, idUtils.getLocalPoolName(poolName), idKey);
// TODO return the Future from releaseIdFromLocalPool() instead.. check all callers @CheckReturnValue
- return Futures.immediateFuture((Void) null);
+ return Futures.immediateFuture((ReleaseIdOutput) null);
}).onFailureLogLevel(org.opendaylight.genius.tools.mdsal.rpc.FutureRpcResults.LogLevel.NONE).onFailure(e -> {
if (e instanceof IdDoesNotExistException) {
// Do not log full stack trace in case ID does not exist
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.lockmanager.rev160413.LockInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.lockmanager.rev160413.LockInputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.lockmanager.rev160413.LockManagerService;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.lockmanager.rev160413.LockOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.lockmanager.rev160413.UnlockInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.lockmanager.rev160413.UnlockInputBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.lockmanager.rev160413.UnlockOutput;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.common.RpcResult;
import org.slf4j.Logger;
public void lock(LockManagerService lockManager, String poolName) throws IdManagerException {
LockInput input = new LockInputBuilder().setLockName(poolName).build();
- Future<RpcResult<Void>> result = lockManager.lock(input);
+ Future<RpcResult<LockOutput>> result = lockManager.lock(input);
try {
if (result != null && result.get().isSuccessful()) {
if (LOG.isDebugEnabled()) {
public void unlock(LockManagerService lockManager, String poolName) {
UnlockInput input = new UnlockInputBuilder().setLockName(poolName).build();
- Future<RpcResult<Void>> result = lockManager.unlock(input);
+ Future<RpcResult<UnlockOutput>> result = lockManager.unlock(input);
try {
if (result != null && result.get().isSuccessful()) {
if (LOG.isDebugEnabled()) {
import com.google.common.base.Optional;
import com.google.common.collect.ImmutableMap;
+import com.google.common.util.concurrent.ListenableFuture;
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.math.BigInteger;
import java.util.ArrayList;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.IdPools;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.ReleaseIdInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.ReleaseIdInputBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.ReleaseIdOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.id.pools.IdPool;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.id.pools.IdPoolKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.IfL2vlan;
public static void releaseId(IdManagerService idManager, String poolName, String idKey) {
ReleaseIdInput idInput = new ReleaseIdInputBuilder().setPoolName(poolName).setIdKey(idKey).build();
try {
- Future<RpcResult<Void>> result = idManager.releaseId(idInput);
- RpcResult<Void> rpcResult = result.get();
+ ListenableFuture<RpcResult<ReleaseIdOutput>> result = idManager.releaseId(idInput);
+ RpcResult<ReleaseIdOutput> rpcResult = result.get();
if (!rpcResult.isSuccessful()) {
LOG.warn("RPC Call to release Id with Key {} returned with Errors {}", idKey, rpcResult.getErrors());
}
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.PhysAddress;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.CreateIdPoolInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.CreateIdPoolInputBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.CreateIdPoolOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.IdManagerService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.config.rev160406.IfmConfig;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406._interface.child.info.InterfaceParentEntry;
CreateIdPoolInput createPool = new CreateIdPoolInputBuilder().setPoolName(IfmConstants.IFM_IDPOOL_NAME)
.setLow(IfmConstants.IFM_ID_POOL_START).setHigh(IfmConstants.IFM_ID_POOL_END).build();
// TODO: Error handling
- Future<RpcResult<Void>> result = idManager.createIdPool(createPool);
+ ListenableFuture<RpcResult<CreateIdPoolOutput>> result = idManager.createIdPool(createPool);
try {
if (result != null && result.get().isSuccessful()) {
LOG.debug("Created IdPool for InterfaceMgr");
import com.google.common.base.Optional;
import com.google.common.util.concurrent.JdkFutureAdapters;
+import com.google.common.util.concurrent.ListenableFuture;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import javax.inject.Inject;
import javax.inject.Singleton;
+
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.ReadTransaction;
import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.MonitorProfileCreateOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.MonitorProfileDeleteInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.MonitorProfileDeleteInputBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.MonitorProfileDeleteOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.MonitorProfileGetInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.MonitorProfileGetInputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.MonitorProfileGetOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.MonitorStartOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.MonitorStopInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.MonitorStopInputBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.MonitorStopOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.MonitoringMode;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.monitor.params.SourceBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.monitor.profile.create.input.Profile;
if (interfaceName != null) {
MonitorStopInput input = new MonitorStopInputBuilder().setMonitorId(monitorId).build();
- Future<RpcResult<Void>> future = alivenessMonitorService.monitorStop(input);
+ ListenableFuture<RpcResult<MonitorStopOutput>> future = alivenessMonitorService.monitorStop(input);
ListenableFutures.addErrorLogging(JdkFutureAdapters.listenInPoolThread(future),
LOG, "Stop LLDP monitoring for {}", trunkInterface);
MonitorProfileDeleteInput profileDeleteInput = new MonitorProfileDeleteInputBuilder()
.setProfileId(profileId).build();
- Future<RpcResult<Void>> future = alivenessMonitorService.monitorProfileDelete(profileDeleteInput);
+ ListenableFuture<RpcResult<MonitorProfileDeleteOutput>> future =
+ alivenessMonitorService.monitorProfileDelete(profileDeleteInput);
ListenableFutures.addErrorLogging(JdkFutureAdapters.listenInPoolThread(future),
LOG, "Delete monitor profile {}", interfaceName);
}
import static org.opendaylight.genius.tools.mdsal.rpc.FutureRpcResults.LogLevel.NONE;
import static org.opendaylight.genius.tools.mdsal.rpc.FutureRpcResults.fromListenableFuture;
-import java.util.concurrent.Future;
+import com.google.common.util.concurrent.ListenableFuture;
import javax.inject.Inject;
import javax.inject.Singleton;
+
import org.opendaylight.genius.interfacemanager.interfaces.InterfaceManagerService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.GetDpidFromInterfaceInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.GetDpidFromInterfaceOutput;
}
@Override
- public Future<RpcResult<GetEndpointIpForDpnOutput>> getEndpointIpForDpn(GetEndpointIpForDpnInput input) {
+ public ListenableFuture<RpcResult<GetEndpointIpForDpnOutput>> getEndpointIpForDpn(GetEndpointIpForDpnInput input) {
return fromListenableFuture(LOG, input, () -> interfaceManagerService.getEndpointIpForDpn(input)).build();
}
@Override
- public Future<RpcResult<GetInterfaceTypeOutput>> getInterfaceType(GetInterfaceTypeInput input) {
+ public ListenableFuture<RpcResult<GetInterfaceTypeOutput>> getInterfaceType(GetInterfaceTypeInput input) {
return fromListenableFuture(LOG, input, () -> interfaceManagerService.getInterfaceType(input)).build();
}
@Override
- public Future<RpcResult<GetTunnelTypeOutput>> getTunnelType(GetTunnelTypeInput input) {
+ public ListenableFuture<RpcResult<GetTunnelTypeOutput>> getTunnelType(GetTunnelTypeInput input) {
return fromListenableFuture(LOG, input, () -> interfaceManagerService.getTunnelType(input)).build();
}
@Override
- public Future<RpcResult<GetPortFromInterfaceOutput>> getPortFromInterface(GetPortFromInterfaceInput input) {
+ public ListenableFuture<RpcResult<GetPortFromInterfaceOutput>> getPortFromInterface(
+ GetPortFromInterfaceInput input) {
return fromListenableFuture(LOG, input, () -> interfaceManagerService.getPortFromInterface(input)).build();
}
@Override
- public Future<RpcResult<GetNodeconnectorIdFromInterfaceOutput>> getNodeconnectorIdFromInterface(
+ public ListenableFuture<RpcResult<GetNodeconnectorIdFromInterfaceOutput>> getNodeconnectorIdFromInterface(
GetNodeconnectorIdFromInterfaceInput input) {
return fromListenableFuture(LOG, input, () -> interfaceManagerService.getNodeconnectorIdFromInterface(input))
.build();
}
@Override
- public Future<RpcResult<GetInterfaceFromIfIndexOutput>> getInterfaceFromIfIndex(
+ public ListenableFuture<RpcResult<GetInterfaceFromIfIndexOutput>> getInterfaceFromIfIndex(
GetInterfaceFromIfIndexInput input) {
return fromListenableFuture(LOG, input, () -> interfaceManagerService.getInterfaceFromIfIndex(input)).build();
}
@Override
- public Future<RpcResult<GetDpnInterfaceListOutput>> getDpnInterfaceList(GetDpnInterfaceListInput input) {
+ public ListenableFuture<RpcResult<GetDpnInterfaceListOutput>> getDpnInterfaceList(GetDpnInterfaceListInput input) {
return fromListenableFuture(LOG, input, () -> interfaceManagerService.getDpnInterfaceList(input)).build();
}
@Override
- public Future<RpcResult<GetEgressInstructionsForInterfaceOutput>> getEgressInstructionsForInterface(
+ public ListenableFuture<RpcResult<GetEgressInstructionsForInterfaceOutput>> getEgressInstructionsForInterface(
GetEgressInstructionsForInterfaceInput input) {
return fromListenableFuture(LOG, input, () -> interfaceManagerService.getEgressInstructionsForInterface(input))
.onFailureLogLevel(DEBUG).build();
}
@Override
- public Future<RpcResult<GetEgressActionsForInterfaceOutput>> getEgressActionsForInterface(
+ public ListenableFuture<RpcResult<GetEgressActionsForInterfaceOutput>> getEgressActionsForInterface(
GetEgressActionsForInterfaceInput input) {
return fromListenableFuture(LOG, input, () -> interfaceManagerService.getEgressActionsForInterface(input))
.onFailureLogLevel(DEBUG).build();
}
@Override
- public Future<RpcResult<GetDpidFromInterfaceOutput>> getDpidFromInterface(GetDpidFromInterfaceInput input) {
+ public ListenableFuture<RpcResult<GetDpidFromInterfaceOutput>> getDpidFromInterface(
+ GetDpidFromInterfaceInput input) {
String interfaceName = input.getIntfName();
return fromListenableFuture(LOG, input, () -> interfaceManagerService.getDpidFromInterface(input))
.withRpcErrorMessage(e -> getDpidFromInterfaceErrorMessage(interfaceName, e.getMessage()))
package org.opendaylight.genius.itm.impl;
import com.google.common.base.Preconditions;
+import com.google.common.util.concurrent.ListenableFuture;
import java.math.BigInteger;
import java.util.Collection;
import java.util.List;
import java.util.concurrent.ExecutionException;
-import java.util.concurrent.Future;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
+
import org.apache.felix.service.command.CommandSession;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.CreateIdPoolInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.CreateIdPoolInputBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.CreateIdPoolOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.IdManagerService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.TunnelTypeBase;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.config.rev160406.VtepConfigSchemas;
.setHigh(new BigInteger(ITMConstants.ITM_IDPOOL_SIZE).longValue())
.build();
try {
- Future<RpcResult<Void>> result = idManager.createIdPool(createPool);
+ ListenableFuture<RpcResult<CreateIdPoolOutput>> result = idManager.createIdPool(createPool);
if (result != null && result.get().isSuccessful()) {
LOG.debug("Created IdPool for ITM Service");
}
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableMap.Builder;
+import com.google.common.util.concurrent.ListenableFuture;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.concurrent.ExecutionException;
-import java.util.concurrent.Future;
import java.util.function.Predicate;
import java.util.regex.Pattern;
import javax.inject.Inject;
import javax.inject.Singleton;
+
import org.opendaylight.genius.interfacemanager.globals.IfmConstants;
import org.opendaylight.genius.itm.globals.ITMConstants;
import org.opendaylight.genius.itm.impl.ITMBatchingUtils;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.IdManagerService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.ReleaseIdInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.ReleaseIdInputBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.ReleaseIdOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.IfL2vlan;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.IfTunnel;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.TunnelMonitoringTypeBfd;
private void releaseId(String poolName, String idKey) throws InterruptedException, ExecutionException,
OperationFailedException {
ReleaseIdInput idInput = new ReleaseIdInputBuilder().setPoolName(poolName).setIdKey(idKey).build();
- Future<RpcResult<Void>> result = idManagerService.releaseId(idInput);
- RpcResult<Void> rpcResult = result.get();
+ ListenableFuture<RpcResult<ReleaseIdOutput>> result = idManagerService.releaseId(idInput);
+ RpcResult<ReleaseIdOutput> rpcResult = result.get();
if (!rpcResult.isSuccessful()) {
LOG.error("RPC Call to release Id with Key {} returned with Errors {}", idKey, rpcResult.getErrors());
Optional<RpcError> rpcError = rpcResult.getErrors().stream().findFirst();
import java.util.HashMap;
import java.util.List;
import java.util.Map;
-import java.util.concurrent.Future;
import java.util.stream.Collectors;
import javax.annotation.Nonnull;
import javax.annotation.PostConstruct;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.transport.zone.subnets.DeviceVtepsKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.transport.zone.subnets.Vteps;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.AddExternalTunnelEndpointInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.AddExternalTunnelEndpointOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.AddL2GwDeviceInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.AddL2GwDeviceOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.AddL2GwMlagDeviceInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.AddL2GwMlagDeviceOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.BuildExternalTunnelFromDpnsInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.BuildExternalTunnelFromDpnsOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.CreateTerminatingServiceActionsInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.CreateTerminatingServiceActionsOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.DeleteL2GwDeviceInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.DeleteL2GwDeviceOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.DeleteL2GwMlagDeviceInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.DeleteL2GwMlagDeviceOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.GetDpnEndpointIpsInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.GetDpnEndpointIpsOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.GetDpnEndpointIpsOutputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.IsTunnelInternalOrExternalOutputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.ItmRpcService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.RemoveExternalTunnelEndpointInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.RemoveExternalTunnelEndpointOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.RemoveExternalTunnelFromDpnsInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.RemoveExternalTunnelFromDpnsOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.RemoveTerminatingServiceActionsInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.RemoveTerminatingServiceActionsOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.SetBfdEnableOnTunnelInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.SetBfdEnableOnTunnelOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.get.dpn.info.output.Computes;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.get.dpn.info.output.ComputesBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
}
@Override
- public Future<RpcResult<GetTunnelInterfaceNameOutput>> getTunnelInterfaceName(GetTunnelInterfaceNameInput input) {
+ public ListenableFuture<RpcResult<GetTunnelInterfaceNameOutput>> getTunnelInterfaceName(
+ GetTunnelInterfaceNameInput input) {
RpcResultBuilder<GetTunnelInterfaceNameOutput> resultBld = null;
BigInteger sourceDpn = input.getSourceDpid();
BigInteger destinationDpn = input.getDestinationDpid();
}
@Override
- public Future<RpcResult<GetEgressActionsForTunnelOutput>>
+ public ListenableFuture<RpcResult<GetEgressActionsForTunnelOutput>>
getEgressActionsForTunnel(GetEgressActionsForTunnelInput input) {
String tunnelName = input.getIntfName();
if (tunnelName == null) {
}
@Override
- public Future<RpcResult<GetTunnelTypeOutput>> getTunnelType(GetTunnelTypeInput input) {
+ public ListenableFuture<RpcResult<GetTunnelTypeOutput>> getTunnelType(GetTunnelTypeInput input) {
String tunnelName = input.getIntfName();
if (tunnelName == null) {
return Futures.immediateFuture(RpcResultBuilder.<GetTunnelTypeOutput>failed()
}
@Override
- public Future<RpcResult<Void>> setBfdEnableOnTunnel(SetBfdEnableOnTunnelInput input) {
+ public ListenableFuture<RpcResult<SetBfdEnableOnTunnelOutput>> setBfdEnableOnTunnel(
+ SetBfdEnableOnTunnelInput input) {
//TODO
return null;
}
@Override
- public Future<RpcResult<Void>> removeExternalTunnelEndpoint(
+ public ListenableFuture<RpcResult<RemoveExternalTunnelEndpointOutput>> removeExternalTunnelEndpoint(
RemoveExternalTunnelEndpointInput input) {
//Ignore the Futures for now
- final SettableFuture<RpcResult<Void>> result = SettableFuture.create();
+ final SettableFuture<RpcResult<RemoveExternalTunnelEndpointOutput>> result = SettableFuture.create();
Collection<DPNTEPsInfo> meshedDpnList = dpnTEPsInfoCache.getAllPresent();
ItmExternalTunnelDeleteWorker.deleteTunnels(dataBroker, meshedDpnList,
input.getDestinationIp(), input.getTunnelType());
Futures.addCallback(futureCheck, new FutureCallback<Void>() {
@Override public void onSuccess(Void voidInstance) {
- result.set(RpcResultBuilder.<Void>success().build());
+ result.set(RpcResultBuilder.<RemoveExternalTunnelEndpointOutput>success().build());
}
@Override public void onFailure(Throwable error) {
+ " in datastore and tunnel type " + input.getTunnelType();
LOG.error("Unable to delete DcGatewayIp {} in datastore and tunnel type {}", input.getDestinationIp(),
input.getTunnelType());
- result.set(RpcResultBuilder.<Void>failed()
+ result.set(RpcResultBuilder.<RemoveExternalTunnelEndpointOutput>failed()
.withError(RpcError.ErrorType.APPLICATION, msg, error).build());
}
});
}
@Override
- public Future<RpcResult<Void>> removeExternalTunnelFromDpns(
+ public ListenableFuture<RpcResult<RemoveExternalTunnelFromDpnsOutput>> removeExternalTunnelFromDpns(
RemoveExternalTunnelFromDpnsInput input) {
//Ignore the Futures for now
- final SettableFuture<RpcResult<Void>> result = SettableFuture.create();
+ final SettableFuture<RpcResult<RemoveExternalTunnelFromDpnsOutput>> result = SettableFuture.create();
List<DPNTEPsInfo> cfgDpnList = ItmUtils.getDpnTepListFromDpnId(dpnTEPsInfoCache, input.getDpnId()) ;
ItmExternalTunnelDeleteWorker.deleteTunnels(dataBroker, cfgDpnList,
input.getDestinationIp(), input.getTunnelType());
- result.set(RpcResultBuilder.<Void>success().build());
+ result.set(RpcResultBuilder.<RemoveExternalTunnelFromDpnsOutput>success().build());
return result;
}
@Override
- public Future<RpcResult<Void>> buildExternalTunnelFromDpns(
+ public ListenableFuture<RpcResult<BuildExternalTunnelFromDpnsOutput>> buildExternalTunnelFromDpns(
BuildExternalTunnelFromDpnsInput input) {
//Ignore the Futures for now
- final SettableFuture<RpcResult<Void>> result = SettableFuture.create();
+ final SettableFuture<RpcResult<BuildExternalTunnelFromDpnsOutput>> result = SettableFuture.create();
List<ListenableFuture<Void>> extTunnelResultList = externalTunnelAddWorker
.buildTunnelsFromDpnToExternalEndPoint(input.getDpnId(), input.getDestinationIp(),input.getTunnelType());
for (ListenableFuture<Void> extTunnelResult : extTunnelResultList) {
@Override
public void onSuccess(Void voidInstance) {
- result.set(RpcResultBuilder.<Void>success().build());
+ result.set(RpcResultBuilder.<BuildExternalTunnelFromDpnsOutput>success().build());
}
@Override
public void onFailure(Throwable error) {
String msg = "Unable to create ext tunnel";
LOG.error("create ext tunnel failed. {}.", msg, error);
- result.set(RpcResultBuilder.<Void>failed()
+ result.set(RpcResultBuilder.<BuildExternalTunnelFromDpnsOutput>failed()
.withError(RpcError.ErrorType.APPLICATION, msg, error).build());
}
});
}
@Override
- public Future<RpcResult<Void>> addExternalTunnelEndpoint(
+ public ListenableFuture<RpcResult<AddExternalTunnelEndpointOutput>> addExternalTunnelEndpoint(
AddExternalTunnelEndpointInput input) {
// TODO Auto-generated method stub
//Ignore the Futures for now
- final SettableFuture<RpcResult<Void>> result = SettableFuture.create();
+ final SettableFuture<RpcResult<AddExternalTunnelEndpointOutput>> result = SettableFuture.create();
Collection<DPNTEPsInfo> meshedDpnList = dpnTEPsInfoCache.getAllPresent();
externalTunnelAddWorker.buildTunnelsToExternalEndPoint(meshedDpnList,
input.getDestinationIp(), input.getTunnelType());
Futures.addCallback(futureCheck, new FutureCallback<Void>() {
@Override public void onSuccess(Void voidInstance) {
- result.set(RpcResultBuilder.<Void>success().build());
+ result.set(RpcResultBuilder.<AddExternalTunnelEndpointOutput>success().build());
}
@Override public void onFailure(Throwable error) {
LOG.error("Unable to create DcGatewayIp in datastore for ip {} and tunnel type {}",
input.getDestinationIp() , input.getTunnelType());
- result.set(RpcResultBuilder.<Void>failed()
+ result.set(RpcResultBuilder.<AddExternalTunnelEndpointOutput>failed()
.withError(RpcError.ErrorType.APPLICATION, msg, error).build());
}
});
}
@Override
- public Future<RpcResult<GetExternalTunnelInterfaceNameOutput>> getExternalTunnelInterfaceName(
+ public ListenableFuture<RpcResult<GetExternalTunnelInterfaceNameOutput>> getExternalTunnelInterfaceName(
GetExternalTunnelInterfaceNameInput input) {
SettableFuture.create();
RpcResultBuilder<GetExternalTunnelInterfaceNameOutput> resultBld;
}
@Override
- public Future<RpcResult<java.lang.Void>>
+ public ListenableFuture<RpcResult<CreateTerminatingServiceActionsOutput>>
createTerminatingServiceActions(final CreateTerminatingServiceActionsInput input) {
LOG.info("create terminatingServiceAction on DpnId = {} for service id {} and instructions {}",
input.getDpnId() , input.getServiceId(), input.getInstruction());
- final SettableFuture<RpcResult<Void>> result = SettableFuture.create();
+ final SettableFuture<RpcResult<CreateTerminatingServiceActionsOutput>> result = SettableFuture.create();
int serviceId = input.getServiceId() ;
final List<MatchInfo> mkMatches = getTunnelMatchesForServiceId(serviceId);
@Override
public void onSuccess(Void voidInstance) {
- result.set(RpcResultBuilder.<Void>success().build());
+ result.set(RpcResultBuilder.<CreateTerminatingServiceActionsOutput>success().build());
}
@Override
public void onFailure(Throwable error) {
String msg = String.format("Unable to install terminating service flow for %s", input.getDpnId());
LOG.error("create terminating service actions failed. {}", msg, error);
- result.set(RpcResultBuilder.<Void>failed().withError(RpcError.ErrorType.APPLICATION, msg, error)
+ result.set(RpcResultBuilder.<CreateTerminatingServiceActionsOutput>failed()
+ .withError(RpcError.ErrorType.APPLICATION, msg, error)
.build());
}
}, MoreExecutors.directExecutor());
}
@Override
- public Future<RpcResult<java.lang.Void>>
+ public ListenableFuture<RpcResult<RemoveTerminatingServiceActionsOutput>>
removeTerminatingServiceActions(final RemoveTerminatingServiceActionsInput input) {
LOG.info("remove terminatingServiceActions called with DpnId = {} and serviceId = {}",
input.getDpnId(), input.getServiceId());
- final SettableFuture<RpcResult<Void>> result = SettableFuture.create();
+ final SettableFuture<RpcResult<RemoveTerminatingServiceActionsOutput>> result = SettableFuture.create();
Flow terminatingServiceTableFlow = MDSALUtil.buildFlowNew(NwConstants.INTERNAL_TUNNEL_TABLE,
getFlowRef(NwConstants.INTERNAL_TUNNEL_TABLE,input.getServiceId()), 5,
String.format("%s:%d","ITM Flow Entry ",input.getServiceId()), 0, 0,
@Override
public void onSuccess(Void voidInstance) {
- result.set(RpcResultBuilder.<Void>success().build());
+ result.set(RpcResultBuilder.<RemoveTerminatingServiceActionsOutput>success().build());
}
@Override
public void onFailure(Throwable error) {
String msg = String.format("Unable to remove terminating service flow for %s", input.getDpnId());
LOG.error("remove terminating service actions failed. {}", msg, error);
- result.set(RpcResultBuilder.<Void>failed().withError(RpcError.ErrorType.APPLICATION, msg, error)
+ result.set(RpcResultBuilder.<RemoveTerminatingServiceActionsOutput>failed()
+ .withError(RpcError.ErrorType.APPLICATION, msg, error)
.build());
}
}, MoreExecutors.directExecutor());
}
@Override
- public Future<RpcResult<GetInternalOrExternalInterfaceNameOutput>> getInternalOrExternalInterfaceName(
+ public ListenableFuture<RpcResult<GetInternalOrExternalInterfaceNameOutput>> getInternalOrExternalInterfaceName(
GetInternalOrExternalInterfaceNameInput input) {
RpcResultBuilder<GetInternalOrExternalInterfaceNameOutput> resultBld = failed();
BigInteger srcDpn = input.getSourceDpid() ;
@SuppressWarnings("checkstyle:IllegalCatch")
@Override
- public Future<RpcResult<java.lang.Void>> deleteL2GwDevice(DeleteL2GwDeviceInput input) {
- final SettableFuture<RpcResult<Void>> result = SettableFuture.create();
+ public ListenableFuture<RpcResult<DeleteL2GwDeviceOutput>> deleteL2GwDevice(DeleteL2GwDeviceInput input) {
+ final SettableFuture<RpcResult<DeleteL2GwDeviceOutput>> result = SettableFuture.create();
boolean foundVxlanTzone = false;
try {
final IpAddress hwIp = input.getIpAddress();
TransportZones transportZones = transportZonesOptional.get();
if (transportZones.getTransportZone() == null || transportZones.getTransportZone().isEmpty()) {
LOG.error("No teps configured");
- result.set(RpcResultBuilder.<Void>failed()
+ result.set(RpcResultBuilder.<DeleteL2GwDeviceOutput>failed()
.withError(RpcError.ErrorType.APPLICATION, "No teps Configured").build());
return result;
}
foundVxlanTzone = true;
String transportZone = tzone.getZoneName();
if (tzone.getSubnets() == null || tzone.getSubnets().isEmpty()) {
- result.set(RpcResultBuilder.<Void>failed()
+ result.set(RpcResultBuilder.<DeleteL2GwDeviceOutput>failed()
.withError(RpcError.ErrorType.APPLICATION, "No subnets Configured").build());
return result;
}
Futures.addCallback(futureCheck, new FutureCallback<Void>() {
@Override public void onSuccess(Void voidInstance) {
- result.set(RpcResultBuilder.<Void>success().build());
+ result.set(RpcResultBuilder.<DeleteL2GwDeviceOutput>success().build());
}
@Override public void onFailure(Throwable error) {
String msg = String.format("Unable to delete HwVtep %s from datastore", nodeId);
LOG.error("Unable to delete HwVtep {}, {} from datastore", nodeId, hwIp);
- result.set(RpcResultBuilder.<Void>failed()
+ result.set(RpcResultBuilder.<DeleteL2GwDeviceOutput>failed()
.withError(RpcError.ErrorType.APPLICATION, msg, error).build());
}
});
}
} else {
- result.set(RpcResultBuilder.<Void>failed()
+ result.set(RpcResultBuilder.<DeleteL2GwDeviceOutput>failed()
.withError(RpcError.ErrorType.APPLICATION, "No TransportZones configured").build());
return result;
}
if (!foundVxlanTzone) {
- result.set(RpcResultBuilder.<Void>failed()
+ result.set(RpcResultBuilder.<DeleteL2GwDeviceOutput>failed()
.withError(RpcError.ErrorType.APPLICATION, "No VxLan TransportZones configured")
.build());
}
return result;
} catch (Exception e) {
- RpcResultBuilder<java.lang.Void> resultBuilder = RpcResultBuilder.<Void>failed()
+ RpcResultBuilder<DeleteL2GwDeviceOutput> resultBuilder = RpcResultBuilder.<DeleteL2GwDeviceOutput>failed()
.withError(RpcError.ErrorType.APPLICATION, "Deleting l2 Gateway to DS Failed", e);
return Futures.immediateFuture(resultBuilder.build());
}
@SuppressWarnings("checkstyle:IllegalCatch")
@Override
- public Future<RpcResult<java.lang.Void>> addL2GwDevice(AddL2GwDeviceInput input) {
+ public ListenableFuture<RpcResult<AddL2GwDeviceOutput>> addL2GwDevice(AddL2GwDeviceInput input) {
- final SettableFuture<RpcResult<Void>> result = SettableFuture.create();
+ final SettableFuture<RpcResult<AddL2GwDeviceOutput>> result = SettableFuture.create();
boolean foundVxlanTzone = false;
try {
final IpAddress hwIp = input.getIpAddress();
TransportZones transportZones = transportZonesOptional.get();
if (transportZones.getTransportZone() == null || transportZones.getTransportZone().isEmpty()) {
LOG.error("No transportZone configured");
- result.set(RpcResultBuilder.<Void>failed()
+ result.set(RpcResultBuilder.<AddL2GwDeviceOutput>failed()
.withError(RpcError.ErrorType.APPLICATION, "No transportZone Configured").build());
return result;
}
Futures.addCallback(futureCheck, new FutureCallback<Void>() {
@Override public void onSuccess(Void voidInstance) {
- result.set(RpcResultBuilder.<Void>success().build());
+ result.set(RpcResultBuilder.<AddL2GwDeviceOutput>success().build());
}
@Override public void onFailure(Throwable error) {
String msg = String.format("Unable to write HwVtep %s to datastore", nodeId);
LOG.error("Unable to write HwVtep {}, {} to datastore", nodeId, hwIp);
- result.set(RpcResultBuilder.<Void>failed()
+ result.set(RpcResultBuilder.<AddL2GwDeviceOutput>failed()
.withError(RpcError.ErrorType.APPLICATION, msg, error).build());
}
});
}
} else {
- result.set(RpcResultBuilder.<Void>failed()
+ result.set(RpcResultBuilder.<AddL2GwDeviceOutput>failed()
.withError(RpcError.ErrorType.APPLICATION, "No TransportZones configured").build());
return result;
}
if (!foundVxlanTzone) {
- result.set(RpcResultBuilder.<Void>failed()
+ result.set(RpcResultBuilder.<AddL2GwDeviceOutput>failed()
.withError(RpcError.ErrorType.APPLICATION, "No VxLan TransportZones configured")
.build());
}
return result;
} catch (Exception e) {
- RpcResultBuilder<java.lang.Void> resultBuilder = RpcResultBuilder.<Void>failed()
+ RpcResultBuilder<AddL2GwDeviceOutput> resultBuilder = RpcResultBuilder.<AddL2GwDeviceOutput>failed()
.withError(RpcError.ErrorType.APPLICATION, "Adding l2 Gateway to DS Failed", e);
return Futures.immediateFuture(resultBuilder.build());
}
@SuppressWarnings("checkstyle:IllegalCatch")
@Override
- public Future<RpcResult<java.lang.Void>> addL2GwMlagDevice(AddL2GwMlagDeviceInput input) {
+ public ListenableFuture<RpcResult<AddL2GwMlagDeviceOutput>> addL2GwMlagDevice(AddL2GwMlagDeviceInput input) {
- final SettableFuture<RpcResult<Void>> result = SettableFuture.create();
+ final SettableFuture<RpcResult<AddL2GwMlagDeviceOutput>> result = SettableFuture.create();
try {
final IpAddress hwIp = input.getIpAddress();
final List<String> nodeId = input.getNodeId();
TransportZones transportZones = transportZonesOptional.get();
if (transportZones.getTransportZone() == null || transportZones.getTransportZone().isEmpty()) {
LOG.error("No teps configured");
- result.set(RpcResultBuilder.<Void>failed()
+ result.set(RpcResultBuilder.<AddL2GwMlagDeviceOutput>failed()
.withError(RpcError.ErrorType.APPLICATION, "No teps Configured").build());
return result;
}
String transportZone = transportZones.getTransportZone().get(0).getZoneName();
if (transportZones.getTransportZone().get(0).getSubnets() == null
|| transportZones.getTransportZone().get(0).getSubnets().isEmpty()) {
- result.set(RpcResultBuilder.<Void>failed()
+ result.set(RpcResultBuilder.<AddL2GwMlagDeviceOutput>failed()
.withError(RpcError.ErrorType.APPLICATION, "No subnets Configured").build());
return result;
}
@Override
public void onSuccess(Void voidInstance) {
- result.set(RpcResultBuilder.<Void>success().build());
+ result.set(RpcResultBuilder.<AddL2GwMlagDeviceOutput>success().build());
}
@Override
public void onFailure(Throwable error) {
String msg = String.format("Unable to write HwVtep %s to datastore", nodeId);
LOG.error("Unable to write HwVtep {}, {} to datastore", nodeId , hwIp);
- result.set(RpcResultBuilder.<Void>failed().withError(RpcError.ErrorType.APPLICATION, msg, error)
+ result.set(RpcResultBuilder.<AddL2GwMlagDeviceOutput>failed()
+ .withError(RpcError.ErrorType.APPLICATION, msg, error)
.build());
}
}, MoreExecutors.directExecutor());
}
return result;
} catch (RuntimeException e) {
- RpcResultBuilder<java.lang.Void> resultBuilder = RpcResultBuilder.<Void>failed()
+ RpcResultBuilder<AddL2GwMlagDeviceOutput> resultBuilder = RpcResultBuilder.<AddL2GwMlagDeviceOutput>failed()
.withError(RpcError.ErrorType.APPLICATION, "Adding l2 Gateway to DS Failed", e);
return Futures.immediateFuture(resultBuilder.build());
}
@SuppressWarnings("checkstyle:IllegalCatch")
@Override
- public Future<RpcResult<Void>> deleteL2GwMlagDevice(DeleteL2GwMlagDeviceInput input) {
-
- final SettableFuture<RpcResult<Void>> result = SettableFuture.create();
+ public ListenableFuture<RpcResult<DeleteL2GwMlagDeviceOutput>> deleteL2GwMlagDevice(
+ DeleteL2GwMlagDeviceInput input) {
+ final SettableFuture<RpcResult<DeleteL2GwMlagDeviceOutput>> result = SettableFuture.create();
try {
final IpAddress hwIp = input.getIpAddress();
final List<String> nodeId = input.getNodeId();
TransportZones tzones = transportZonesOptional.get();
if (tzones.getTransportZone() == null || tzones.getTransportZone().isEmpty()) {
LOG.error("No teps configured");
- result.set(RpcResultBuilder.<Void>failed()
+ result.set(RpcResultBuilder.<DeleteL2GwMlagDeviceOutput>failed()
.withError(RpcError.ErrorType.APPLICATION, "No teps Configured").build());
return result;
}
String transportZone = tzones.getTransportZone().get(0).getZoneName();
if (tzones.getTransportZone().get(0).getSubnets() == null || tzones.getTransportZone()
.get(0).getSubnets().isEmpty()) {
- result.set(RpcResultBuilder.<Void>failed()
+ result.set(RpcResultBuilder.<DeleteL2GwMlagDeviceOutput>failed()
.withError(RpcError.ErrorType.APPLICATION, "No subnets Configured").build());
return result;
}
@Override
public void onSuccess(Void voidInstance) {
- result.set(RpcResultBuilder.<Void>success().build());
+ result.set(RpcResultBuilder.<DeleteL2GwMlagDeviceOutput>success().build());
}
@Override
public void onFailure(Throwable error) {
String msg = String.format("Unable to write HwVtep %s to datastore", nodeId);
LOG.error("Unable to write HwVtep {}, {} to datastore", nodeId , hwIp);
- result.set(RpcResultBuilder.<Void>failed().withError(RpcError.ErrorType.APPLICATION, msg, error)
+ result.set(RpcResultBuilder.<DeleteL2GwMlagDeviceOutput>failed()
+ .withError(RpcError.ErrorType.APPLICATION, msg, error)
.build());
}
});
}
return result;
} catch (Exception e) {
- RpcResultBuilder<java.lang.Void> resultBuilder = RpcResultBuilder.<Void>failed()
- .withError(RpcError.ErrorType.APPLICATION, "Deleting l2 Gateway to DS Failed", e);
+ RpcResultBuilder<DeleteL2GwMlagDeviceOutput> resultBuilder =
+ RpcResultBuilder.<DeleteL2GwMlagDeviceOutput>failed().withError(RpcError.ErrorType.APPLICATION,
+ "Deleting l2 Gateway to DS Failed", e);
return Futures.immediateFuture(resultBuilder.build());
}
}
@Override
- public Future<RpcResult<IsTunnelInternalOrExternalOutput>> isTunnelInternalOrExternal(
+ public ListenableFuture<RpcResult<IsTunnelInternalOrExternalOutput>> isTunnelInternalOrExternal(
IsTunnelInternalOrExternalInput input) {
RpcResultBuilder<IsTunnelInternalOrExternalOutput> resultBld;
String tunIfName = input.getTunnelInterfaceName();
}
@Override
- public Future<RpcResult<IsDcgwPresentOutput>> isDcgwPresent(IsDcgwPresentInput input) {
+ public ListenableFuture<RpcResult<IsDcgwPresentOutput>> isDcgwPresent(IsDcgwPresentInput input) {
RpcResultBuilder<IsDcgwPresentOutput> resultBld = RpcResultBuilder.success();
List<DcGatewayIp> dcGatewayIpList = ItmUtils.getDcGatewayIpList(dataBroker);
}
@Override
- public Future<RpcResult<GetDpnEndpointIpsOutput>> getDpnEndpointIps(GetDpnEndpointIpsInput input) {
+ public ListenableFuture<RpcResult<GetDpnEndpointIpsOutput>> getDpnEndpointIps(GetDpnEndpointIpsInput input) {
BigInteger srcDpn = input.getSourceDpid() ;
RpcResultBuilder<GetDpnEndpointIpsOutput> resultBld = failed();
InstanceIdentifier<DPNTEPsInfo> tunnelInfoId =
}
@Override
- public Future<RpcResult<GetDpnInfoOutput>> getDpnInfo(GetDpnInfoInput input) {
+ public ListenableFuture<RpcResult<GetDpnInfoOutput>> getDpnInfo(GetDpnInfoInput input) {
return FutureRpcResults.fromListenableFuture(LOG, "getDpnInfo", input,
() -> Futures.immediateFuture(getDpnInfoInternal(input))).build();
}
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.AllocateIdOutputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.IdManagerService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.ReleaseIdInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.ReleaseIdOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.TunnelTypeBase;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.TunnelTypeVxlan;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.ExternalTunnelList;
setupMocks();
when(idManagerService.releaseId(any(ReleaseIdInput.class))).thenReturn(Futures.immediateFuture(RpcResultBuilder
- .<Void>success().build()));
+ .<ReleaseIdOutput>success().build()));
}
@After
import static org.opendaylight.mdsal.binding.testutils.AssertDataObjects.assertEqualBeans;
import com.google.common.base.Optional;
+import com.google.common.util.concurrent.ListenableFuture;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.Future;
import javax.inject.Inject;
+
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.transport.zone.subnets.DeviceVtepsKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.AddExternalTunnelEndpointInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.AddExternalTunnelEndpointInputBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.AddExternalTunnelEndpointOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.AddL2GwDeviceInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.AddL2GwDeviceInputBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.AddL2GwDeviceOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.AddL2GwMlagDeviceInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.AddL2GwMlagDeviceInputBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.AddL2GwMlagDeviceOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.BuildExternalTunnelFromDpnsInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.BuildExternalTunnelFromDpnsInputBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.BuildExternalTunnelFromDpnsOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.DeleteL2GwDeviceInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.DeleteL2GwDeviceInputBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.DeleteL2GwDeviceOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.DeleteL2GwMlagDeviceInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.DeleteL2GwMlagDeviceInputBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.DeleteL2GwMlagDeviceOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.GetExternalTunnelInterfaceNameInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.GetExternalTunnelInterfaceNameInputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.GetExternalTunnelInterfaceNameOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.GetTunnelInterfaceNameOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.RemoveExternalTunnelEndpointInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.RemoveExternalTunnelEndpointInputBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.RemoveExternalTunnelEndpointOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.RemoveExternalTunnelFromDpnsInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.RemoveExternalTunnelFromDpnsInputBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.RemoveExternalTunnelFromDpnsOutput;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.common.RpcResult;
@Test
public void testAddExternalTunnelEndpoint() throws Exception {
- Future<RpcResult<Void>> rpcRes = itmManagerRpcService.addExternalTunnelEndpoint(addExternalTunnelEndpointInput);
+ ListenableFuture<RpcResult<AddExternalTunnelEndpointOutput>> rpcRes =
+ itmManagerRpcService.addExternalTunnelEndpoint(addExternalTunnelEndpointInput);
// check RPC response is SUCCESS
assertThat(rpcRes.get().isSuccessful()).isTrue();
@Test
public void testAddL2GwDevice() throws Exception {
- Future<RpcResult<java.lang.Void>> rpcRes = itmManagerRpcService.addL2GwDevice(addL2GwDeviceInput);
+ ListenableFuture<RpcResult<AddL2GwDeviceOutput>> rpcRes =
+ itmManagerRpcService.addL2GwDevice(addL2GwDeviceInput);
// check RPC response is SUCCESS
assertThat(rpcRes.get().isSuccessful()).isTrue();
@Test
public void testAddL2GwMlagDevice() throws Exception {
- Future<RpcResult<java.lang.Void>> rpcRes = itmManagerRpcService.addL2GwMlagDevice(addL2GwMlagDeviceInput);
+ ListenableFuture<RpcResult<AddL2GwMlagDeviceOutput>> rpcRes =
+ itmManagerRpcService.addL2GwMlagDevice(addL2GwMlagDeviceInput);
// check RPC response is SUCCESS
assertThat(rpcRes.get().isSuccessful()).isTrue();
@Test
public void testDeleteL2GwDevice() throws Exception {
- Future<RpcResult<java.lang.Void>> rpcRes = itmManagerRpcService.deleteL2GwDevice(deleteL2GwDeviceInput);
+ ListenableFuture<RpcResult<DeleteL2GwDeviceOutput>> rpcRes =
+ itmManagerRpcService.deleteL2GwDevice(deleteL2GwDeviceInput);
// check RPC response is SUCCESS
assertThat(rpcRes.get().isSuccessful()).isTrue();
@Test
public void testDeleteL2GwMlagDevice() throws Exception {
- Future<RpcResult<java.lang.Void>> rpcRes =
+ ListenableFuture<RpcResult<DeleteL2GwMlagDeviceOutput>> rpcRes =
itmManagerRpcService.deleteL2GwMlagDevice(deleteL2GwMlagDeviceInput);
// check RPC response is SUCCESS
@Test
public void testBuildExternalTunnelFromDpns() throws Exception {
- Future<RpcResult<Void>> rpcRes =
+ ListenableFuture<RpcResult<BuildExternalTunnelFromDpnsOutput>> rpcRes =
itmManagerRpcService.buildExternalTunnelFromDpns(buildExternalTunnelFromDpnsInput);
// check RPC response is SUCCESS
@Test
public void testRemoveExternalTunnelFromDpns() throws Exception {
- Future<RpcResult<Void>> rpcRes =
+ ListenableFuture<RpcResult<RemoveExternalTunnelFromDpnsOutput>> rpcRes =
itmManagerRpcService.removeExternalTunnelFromDpns(removeExternalTunnelFromDpnsInput);
// check RPC response is SUCCESS
@Test
public void testRemoveExternalTunnelEndpoint() throws Exception {
// call RPC to add ExternalTunnelEndpoint as pre-requisite
- Future<RpcResult<Void>> rpcRes =
+ ListenableFuture<RpcResult<AddExternalTunnelEndpointOutput>> rpcRes =
itmManagerRpcService.addExternalTunnelEndpoint(addExternalTunnelEndpointInput);
// check RPC response is SUCCESS
assertThat(rpcRes.get().isSuccessful()).isTrue();
- rpcRes = itmManagerRpcService.removeExternalTunnelEndpoint(removeExternalTunnelEndpointInput);
+ ListenableFuture<RpcResult<RemoveExternalTunnelEndpointOutput>> removeExternalTunnelEndpoint =
+ itmManagerRpcService.removeExternalTunnelEndpoint(removeExternalTunnelEndpointInput);
// check RPC response is SUCCESS
- assertThat(rpcRes.get().isSuccessful()).isTrue();
+ assertThat(removeExternalTunnelEndpoint.get().isSuccessful()).isTrue();
// check ExternalTunnelEndpoint is deleted from config DS
assertThat(Optional.absent()).isEqualTo(dataBroker.newReadOnlyTransaction()
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.MoreExecutors;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ExecutionException;
-import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import javax.inject.Inject;
import javax.inject.Singleton;
+
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.genius.tools.mdsal.rpc.FutureRpcResults;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.lockmanager.rev160413.LockInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.lockmanager.rev160413.LockManagerService;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.lockmanager.rev160413.LockOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.lockmanager.rev160413.TryLockInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.lockmanager.rev160413.TryLockOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.lockmanager.rev160413.UnlockInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.lockmanager.rev160413.UnlockOutput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.lockmanager.rev160413.UnlockOutputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.lockmanager.rev160413.locks.Lock;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.common.RpcResult;
}
@Override
- public Future<RpcResult<Void>> lock(LockInput input) {
+ public ListenableFuture<RpcResult<LockOutput>> lock(LockInput input) {
String lockName = input.getLockName();
String owner = lockManagerUtils.getUniqueID();
return FutureRpcResults.fromListenableFuture(LOG, input, () -> {
}
@Override
- public Future<RpcResult<Void>> tryLock(TryLockInput input) {
+ public ListenableFuture<RpcResult<TryLockOutput>> tryLock(TryLockInput input) {
String lockName = input.getLockName();
String owner = lockManagerUtils.getUniqueID();
LOG.debug("Locking {}, owner {}" , lockName, owner);
InstanceIdentifier<Lock> lockInstanceIdentifier = lockManagerUtils.getLockInstanceIdentifier(lockName);
Lock lockData = lockManagerUtils.buildLock(lockName, owner);
- RpcResultBuilder<Void> lockRpcBuilder;
+ RpcResultBuilder<TryLockOutput> lockRpcBuilder;
try {
if (getLock(lockInstanceIdentifier, lockData, retryCount)) {
lockRpcBuilder = RpcResultBuilder.success();
}
@Override
- public Future<RpcResult<Void>> unlock(UnlockInput input) {
+ public ListenableFuture<RpcResult<UnlockOutput>> unlock(UnlockInput input) {
String lockName = input.getLockName();
LOG.debug("Unlocking {}", lockName);
InstanceIdentifier<Lock> lockInstanceIdentifier = lockManagerUtils.getLockInstanceIdentifier(lockName);
return FutureRpcResults.fromListenableFuture(LOG, input,
- () -> txRunner.callWithNewReadWriteTransactionAndSubmit(tx -> {
+ () -> Futures.transform(txRunner.callWithNewReadWriteTransactionAndSubmit(tx -> {
Optional<Lock> result = tx.read(LogicalDatastoreType.OPERATIONAL, lockInstanceIdentifier).get();
if (!result.isPresent()) {
LOG.debug("unlock ignored, as unnecessary; lock is already unlocked: {}", lockName);
} else {
tx.delete(LogicalDatastoreType.OPERATIONAL, lockInstanceIdentifier);
}
- })).build();
+ }), unused -> new UnlockOutputBuilder().build(), MoreExecutors.directExecutor())).build();
}
public CompletableFuture<Void> getSynchronizerForLock(String lockName) {
/**
* Try to acquire lock indefinitely until it is successful.
*/
- private ListenableFuture<Void> getLock(final InstanceIdentifier<Lock> lockInstanceIdentifier, final Lock lockData)
+ private ListenableFuture<LockOutput> getLock(final InstanceIdentifier<Lock> lockInstanceIdentifier,
+ final Lock lockData)
throws InterruptedException {
// Count from 1 to provide human-comprehensible messages
String lockName = lockData.getLockName();
import static org.opendaylight.genius.tools.mdsal.testutils.TestFutureRpcResults.assertRpcErrorCause;
import static org.opendaylight.genius.tools.mdsal.testutils.TestFutureRpcResults.assertRpcErrorWithoutCausesOrMessages;
-import static org.opendaylight.genius.tools.mdsal.testutils.TestFutureRpcResults.assertVoidRpcSuccess;
+import static org.opendaylight.genius.tools.mdsal.testutils.TestFutureRpcResults.assertRpcSuccess;
import java.util.Timer;
import java.util.TimerTask;
@Test
public void testLockAndUnLock() throws InterruptedException, ExecutionException, TimeoutException {
LockInput lockInput = new LockInputBuilder().setLockName("testLock").build();
- assertVoidRpcSuccess(lockManager.lock(lockInput));
+ assertRpcSuccess(lockManager.lock(lockInput));
UnlockInput unlockInput = new UnlockInputBuilder().setLockName("testLock").build();
- assertVoidRpcSuccess(lockManager.unlock(unlockInput));
+ assertRpcSuccess(lockManager.unlock(unlockInput));
}
@Test
public void testUnLockOfUnknownShouldNotFail() throws InterruptedException, ExecutionException, TimeoutException {
UnlockInput unlockInput = new UnlockInputBuilder().setLockName("unknownLock").build();
- assertVoidRpcSuccess(lockManager.unlock(unlockInput));
+ assertRpcSuccess(lockManager.unlock(unlockInput));
}
@Test
// lock() RPC will infinitely retry, and it will only come out when the key is unlocked
public void testLockAndReLockSameAgain() throws InterruptedException, ExecutionException, TimeoutException {
LockInput lockInput = new LockInputBuilder().setLockName("testLock").build();
- assertVoidRpcSuccess(lockManager.lock(lockInput));
+ assertRpcSuccess(lockManager.lock(lockInput));
runUnlockTimerTask("testLock", 3000);
// This will retry infinitely since the other lock is not released!
// After 5 seconds, the parallel thread will unlock the key, and the below TC will pass
- assertVoidRpcSuccess(lockManager.lock(lockInput));
+ assertRpcSuccess(lockManager.lock(lockInput));
}
@Test
TryLockInput lockInput = new TryLockInputBuilder().setLockName("testTryLock").setTime(3L)
.setTimeUnit(TimeUnits.Seconds).build();
- assertVoidRpcSuccess(lockManager.tryLock(lockInput));
+ assertRpcSuccess(lockManager.tryLock(lockInput));
// The second acquireLock request will retry for 3 seconds
// and since the first lock is not unlocked, the request will fail.
lockInput = new TryLockInputBuilder().setLockName("testTryLock").setTime(4000000L)
.setTimeUnit(TimeUnits.Microseconds).build();
- assertVoidRpcSuccess(lockManager.tryLock(lockInput));
+ assertRpcSuccess(lockManager.tryLock(lockInput));
}
@Test
dbFailureSimulator.failSubmits(new OptimisticLockFailedException("bada boum bam!"));
LockInput lockInput = new LockInputBuilder().setLockName("testLock").build();
runUnfailSubmitsTimerTask(3000); // see other tests above
- assertVoidRpcSuccess(lockManager.lock(lockInput));
+ assertRpcSuccess(lockManager.lock(lockInput));
}
@Test
public void run() {
UnlockInput unlockInput = new UnlockInputBuilder().setLockName(lockKey).build();
try {
- assertVoidRpcSuccess(lockManager.unlock(unlockInput));
+ assertRpcSuccess(lockManager.unlock(unlockInput));
} catch (InterruptedException | ExecutionException | TimeoutException e) {
LOG.error("runUnlockTimerTask() failed", e);
// throw new RuntimeException(e) is useless here, as this in a BG Thread, and it would go nowhere
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
-import java.util.concurrent.Future;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service.rev130709.PacketProcessingService;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service.rev130709.TransmitPacketOutput;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.InstanceIdentifierBuilder;
import org.opendaylight.yangtools.yang.common.RpcResult;
}
public void sendPacketOutWithActionsInternal(BigInteger dpnId, byte[] payload, List<ActionInfo> actionInfos) {
- Future<RpcResult<Void>> future = packetProcessingService.transmitPacket(
- MDSALUtil.getPacketOut(actionInfos, payload, dpnId, getNodeConnRef("openflow:" + dpnId, "0xfffffffd")));
+ ListenableFuture<RpcResult<TransmitPacketOutput>> future = packetProcessingService.transmitPacket(
+ MDSALUtil.getPacketOut(actionInfos, payload, dpnId,
+ getNodeConnRef("openflow:" + dpnId, "0xfffffffd")));
JdkFutures.addErrorLogging(future, LOG, "Transmit packet");
}
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.MoreExecutors;
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.CreateIdPoolInputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.IdManagerService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.ReleaseIdInputBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.ReleaseIdOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.id.pools.IdPool;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.id.pools.id.pool.AvailableIdsHolder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.id.pools.id.pool.ReleasedIdsHolder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.resourcemanager.rev160622.GetResourcePoolOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.resourcemanager.rev160622.GetResourcePoolOutputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.resourcemanager.rev160622.ReleaseResourceInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.resourcemanager.rev160622.ReleaseResourceOutput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.resourcemanager.rev160622.ReleaseResourceOutputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.resourcemanager.rev160622.ResourceManagerService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.resourcemanager.rev160622.ResourceTypeBase;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.resourcemanager.rev160622.ResourceTypeGroupIds;
}
@Override
- public Future<RpcResult<AllocateResourceOutput>> allocateResource(AllocateResourceInput input) {
+ public
ListenableFuture<RpcResult<AllocateResourceOutput>> allocateResource(AllocateResourceInput input) {
Objects.requireNonNull(input.getResourceType(), RESOURCE_TYPE_CANNOT_BE_NULL);
Objects.requireNonNull(input.getIdKey(), RESOURCE_ID_CANNOT_BE_NULL);
Objects.requireNonNull(input.getSize(), RESOURCE_SIZE_CANNOT_BE_NULL);
}
@Override
- public Future<RpcResult<GetResourcePoolOutput>> getResourcePool(GetResourcePoolInput input) {
+ public ListenableFuture<RpcResult<GetResourcePoolOutput>> getResourcePool(GetResourcePoolInput input) {
Objects.requireNonNull(input.getResourceType(), RESOURCE_TYPE_CANNOT_BE_NULL);
Objects.requireNonNull(resourcesCache.get(input.getResourceType()), RESOURCE_TYPE_CANNOT_BE_NULL);
}
@Override
- public Future<RpcResult<GetAvailableResourcesOutput>> getAvailableResources(GetAvailableResourcesInput input) {
+ public ListenableFuture<RpcResult<GetAvailableResourcesOutput>> getAvailableResources(
+ GetAvailableResourcesInput input) {
Objects.requireNonNull(input.getResourceType(), RESOURCE_TYPE_CANNOT_BE_NULL);
Objects.requireNonNull(resourcesCache.get(input.getResourceType()), RESOURCE_TYPE_NOT_FOUND);
}
@Override
- public Future<RpcResult<Void>> releaseResource(ReleaseResourceInput input) {
+ public ListenableFuture<RpcResult<ReleaseResourceOutput>> releaseResource(ReleaseResourceInput input) {
Objects.requireNonNull(input.getIdKey(), RESOURCE_ID_CANNOT_BE_NULL);
Objects.requireNonNull(input.getResourceType(), RESOURCE_TYPE_CANNOT_BE_NULL);
ReleaseIdInputBuilder releaseIdInputBuilder = new ReleaseIdInputBuilder();
releaseIdInputBuilder.setIdKey(input.getIdKey()).setPoolName(resourcesCache.get(input.getResourceType()));
- return idManager.releaseId(releaseIdInputBuilder.build());
+ return transform(idManager.releaseId(releaseIdInputBuilder.build()));
+ }
+
+ private ListenableFuture<RpcResult<ReleaseResourceOutput>> transform(
+ final ListenableFuture<RpcResult<ReleaseIdOutput>> rpcResultListenableFuture) {
+ return Futures.transform(rpcResultListenableFuture, input -> {
+ final RpcResult<ReleaseResourceOutput> rpcOutput;
+ if (input.isSuccessful()) {
+ final ReleaseResourceOutput sendEchoOutput = new ReleaseResourceOutputBuilder().build();
+ rpcOutput = RpcResultBuilder.success(sendEchoOutput).build();
+ } else {
+ rpcOutput = RpcResultBuilder.<ReleaseResourceOutput>failed()
+ .withRpcErrors(input.getErrors())
+ .build();
+ }
+ return rpcOutput;
+ }, MoreExecutors.directExecutor());
}
private void createIdPool(String poolNameProperty, String lowIdProperty, String highIdProperty,
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
+import com.google.common.util.concurrent.ListenableFuture;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ExecutionException;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.resourcemanager.rev160622.GetResourcePoolOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.resourcemanager.rev160622.ReleaseResourceInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.resourcemanager.rev160622.ReleaseResourceInputBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.resourcemanager.rev160622.ReleaseResourceOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.resourcemanager.rev160622.ResourceManagerService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.resourcemanager.rev160622.ResourceTypeBase;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.resourcemanager.rev160622.ResourceTypeGroupIds;
allocateResource(resourceType.getName(), resourceType, NUMBER_OF_RESOURCES);
// Release resources
- RpcResult<Void> result = releaseResource(resourceType.getName(), resourceType).get();
+ RpcResult<ReleaseResourceOutput> result = releaseResource(resourceType.getName(), resourceType).get();
assertSuccessfulFutureRpcResult(result);
}
}
releaseResource(null, ResourceTypeTableIds.class).get();
}
- private Future<RpcResult<Void>> releaseResource(String resourceKey,
+ private ListenableFuture<RpcResult<ReleaseResourceOutput>> releaseResource(String resourceKey,
Class<? extends ResourceTypeBase> resourceType) throws Exception {
final ReleaseResourceInput input = new ReleaseResourceInputBuilder().setResourceType(resourceType)
.setIdKey(resourceKey).build();
package org.opendaylight.genius.srm.impl;
import com.google.common.util.concurrent.Futures;
-import java.util.concurrent.Future;
+import com.google.common.util.concurrent.ListenableFuture;
import javax.inject.Inject;
import javax.inject.Singleton;
+
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.genius.tools.mdsal.rpc.FutureRpcResults;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.srm.rpcs.rev170711.RecoverInput;
}
@Override
- public Future<RpcResult<RecoverOutput>> recover(RecoverInput input) {
+ public ListenableFuture<RpcResult<RecoverOutput>> recover(RecoverInput input) {
return FutureRpcResults.fromListenableFuture(LOG, "recover", input,
() -> Futures.immediateFuture(SrmRpcUtils.callSrmOp(dataBroker, input))).build();
}
@Override
- public Future<RpcResult<ReinstallOutput>> reinstall(ReinstallInput input) {
+ public ListenableFuture<RpcResult<ReinstallOutput>> reinstall(ReinstallInput input) {
return FutureRpcResults.fromListenableFuture(LOG, "reinstall", input,
() -> Futures.immediateFuture(SrmRpcUtils.callSrmOp(dataBroker, input))).build();
}
@Override
@CheckReturnValue
@SuppressWarnings("checkstyle:IllegalCatch")
- public Future<RpcResult<O>> build() {
+ public ListenableFuture<RpcResult<O>> build() {
SettableFuture<RpcResult<O>> futureRpcResult = SettableFuture.create();
FutureCallback<O> callback = new FutureCallback<O>() {
@Override
import java.util.concurrent.Future;
import java.util.concurrent.TimeoutException;
import org.opendaylight.genius.tools.mdsal.rpc.FutureRpcResults;
+import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.common.RpcError;
import org.opendaylight.yangtools.yang.common.RpcError.ErrorType;
import org.opendaylight.yangtools.yang.common.RpcResult;
assertThat(rpcResult.getErrors()).isEmpty();
}
+ public static <O extends DataObject> void assertRpcSuccess(Future<RpcResult<O>> futureRpcResult)
+ throws InterruptedException, ExecutionException, TimeoutException {
+ RpcResult<O> rpcResult = futureRpcResult.get(1, MINUTES);
+ assertThat(rpcResult.isSuccessful()).isTrue();
+ assertThat(rpcResult.getErrors()).isEmpty();
+ }
+
public static <T> void assertRpcErrorWithoutCausesOrMessages(Future<RpcResult<T>> futureRpcResult)
throws InterruptedException, ExecutionException, TimeoutException {
RpcResult<T> rpcResult = futureRpcResult.get(1, MINUTES);
Code Review / genius.git / commitdiff