package org.opendaylight.netvirt.aclservice.stats;
import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
import java.util.List;
-import java.util.concurrent.Future;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
}
@Override
- public Future<RpcResult<GetAclPortStatisticsOutput>> getAclPortStatistics(GetAclPortStatisticsInput input) {
+ public ListenableFuture<RpcResult<GetAclPortStatisticsOutput>> getAclPortStatistics(
+ GetAclPortStatisticsInput input) {
LOG.trace("Get ACL port statistics for input: {}", input);
RpcResultBuilder<GetAclPortStatisticsOutput> rpcResultBuilder;
rpcResultBuilder = RpcResultBuilder.failed();
rpcResultBuilder.withError(ErrorType.APPLICATION, "operation-not-supported",
"Operation not supported for ACL " + this.securityGroupMode + " mode");
- return Futures.immediateFuture(rpcResultBuilder.build());
+ return rpcResultBuilder.buildFuture();
}
// Default direction is Both
Direction direction = input.getDirection() == null ? Direction.Both : input.getDirection();
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.DeleteIdPoolInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.DeleteIdPoolInputBuilder;
+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.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.rpcs.rev160406.GetDpidFromInterfaceInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.GetDpidFromInterfaceInputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.GetDpidFromInterfaceOutput;
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();
+ RpcResult<ReleaseIdOutput> rpcResult = idManager.releaseId(idInput).get();
if (!rpcResult.isSuccessful()) {
LOG.error("RPC Call to release Id with Key {} from pool {} returned with Errors {}",
idKey, poolName, rpcResult.getErrors());
.setPoolName(poolName).setLow(AclConstants.ACL_TAG_POOL_START)
.setHigh(AclConstants.ACL_TAG_POOL_END).build();
try {
- Future<RpcResult<Void>> result = this.idManager.createIdPool(createPool);
+ Future<RpcResult<CreateIdPoolOutput>> result = this.idManager.createIdPool(createPool);
if (result != null && result.get().isSuccessful()) {
LOG.debug("Created IdPool for {}", poolName);
}
public void deleteIdPool(String poolName) {
DeleteIdPoolInput deletePool = new DeleteIdPoolInputBuilder().setPoolName(poolName).build();
try {
- Future<RpcResult<Void>> result = this.idManager.deleteIdPool(deletePool);
+ Future<RpcResult<DeleteIdPoolOutput>> result = this.idManager.deleteIdPool(deletePool);
if (result != null && result.get().isSuccessful()) {
LOG.debug("Deleted IdPool for {}", poolName);
}
package org.opendaylight.netvirt.aclservice.stats;
-import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.List;
-import java.util.concurrent.Future;
import org.opendaylight.genius.mdsalutil.NwConstants;
import org.opendaylight.netvirt.aclservice.utils.AclConstants;
import org.opendaylight.netvirt.aclservice.utils.AclServiceUtils;
protected FlowCookie aclDropFlowCookieMask = new FlowCookie(AclLiveStatisticsHelper.COOKIE_ACL_DROP_FLOW_MASK);
@Override
- public Future<RpcResult<GetNodeConnectorStatisticsOutput>> getNodeConnectorStatistics(
+ public ListenableFuture<RpcResult<GetNodeConnectorStatisticsOutput>> getNodeConnectorStatistics(
GetNodeConnectorStatisticsInput input) {
- return Futures.immediateFuture(RpcResultBuilder.<GetNodeConnectorStatisticsOutput>success().build());
+ return RpcResultBuilder.<GetNodeConnectorStatisticsOutput>success().buildFuture();
}
@Override
- public Future<RpcResult<GetQueueStatisticsOutput>> getQueueStatistics(GetQueueStatisticsInput input) {
- return Futures.immediateFuture(RpcResultBuilder.<GetQueueStatisticsOutput>success().build());
+ public ListenableFuture<RpcResult<GetQueueStatisticsOutput>> getQueueStatistics(GetQueueStatisticsInput input) {
+ return RpcResultBuilder.<GetQueueStatisticsOutput>success().buildFuture();
}
@Override
- public Future<RpcResult<GetGroupStatisticsOutput>> getGroupStatistics(GetGroupStatisticsInput input) {
- return Futures.immediateFuture(RpcResultBuilder.<GetGroupStatisticsOutput>success().build());
+ public ListenableFuture<RpcResult<GetGroupStatisticsOutput>> getGroupStatistics(GetGroupStatisticsInput input) {
+ return RpcResultBuilder.<GetGroupStatisticsOutput>success().buildFuture();
}
@Override
- public Future<RpcResult<GetFlowStatisticsOutput>> getFlowStatistics(GetFlowStatisticsInput input) {
+ public ListenableFuture<RpcResult<GetFlowStatisticsOutput>> getFlowStatistics(GetFlowStatisticsInput input) {
LOG.info("getFlowStatistics rpc input = {}", input);
List<FlowAndStatisticsMapList> flowStatsList = new ArrayList<>();
RpcResultBuilder<GetFlowStatisticsOutput> rpcResultBuilder = RpcResultBuilder.success();
rpcResultBuilder.withResult(output);
- return Futures.immediateFuture(rpcResultBuilder.build());
+ return rpcResultBuilder.buildFuture();
}
private FlowAndStatisticsMapList buildFlowStats(short tableId, Integer priority, Integer lportTag, long byteCount,
}
@Override
- public Future<RpcResult<GetMeterStatisticsOutput>> getMeterStatistics(GetMeterStatisticsInput input) {
- return Futures.immediateFuture(RpcResultBuilder.<GetMeterStatisticsOutput>success().build());
+ public ListenableFuture<RpcResult<GetMeterStatisticsOutput>> getMeterStatistics(GetMeterStatisticsInput input) {
+ return RpcResultBuilder.<GetMeterStatisticsOutput>success().buildFuture();
}
}
import static org.opendaylight.yangtools.testutils.mockito.MoreAnswers.realOrException;
import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
import com.google.inject.AbstractModule;
-import java.util.concurrent.Future;
import org.mockito.Mockito;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.test.DataBrokerTestModule;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.AllocateIdOutput;
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.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.DeleteIdPoolOutputBuilder;
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.idmanager.rev160406.ReleaseIdOutputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.aclservice.config.rev160806.AclserviceConfig;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.aclservice.config.rev160806.AclserviceConfig.SecurityGroupMode;
import org.opendaylight.yangtools.yang.common.RpcResult;
private abstract static class TestIdManagerService implements IdManagerService {
@Override
- public Future<RpcResult<Void>> createIdPool(CreateIdPoolInput input) {
- return Futures.immediateFuture(RpcResultBuilder.<Void>success().build());
+ public ListenableFuture<RpcResult<CreateIdPoolOutput>> createIdPool(CreateIdPoolInput input) {
+ return RpcResultBuilder.success(new CreateIdPoolOutputBuilder().build()).buildFuture();
}
@Override
- public Future<RpcResult<AllocateIdOutput>> allocateId(AllocateIdInput input) {
+ public
ListenableFuture<RpcResult<AllocateIdOutput>> allocateId(AllocateIdInput input) {
String key = input.getIdKey();
long id = IdHelper.getId(key) == null ? AclConstants.PROTO_MATCH_PRIORITY
: IdHelper.getId(key);
}
@Override
- public Future<RpcResult<Void>> releaseId(ReleaseIdInput input) {
- return Futures.immediateFuture(RpcResultBuilder.<Void>success().build());
+ public ListenableFuture<RpcResult<ReleaseIdOutput>> releaseId(ReleaseIdInput input) {
+ return RpcResultBuilder.success(new ReleaseIdOutputBuilder().build()).buildFuture();
}
@Override
- public Future<RpcResult<java.lang.Void>> deleteIdPool(DeleteIdPoolInput poolName) {
- return Futures.immediateFuture(RpcResultBuilder.<Void>success().build());
+ public ListenableFuture<RpcResult<DeleteIdPoolOutput>> deleteIdPool(DeleteIdPoolInput poolName) {
+ return RpcResultBuilder.success(new DeleteIdPoolOutputBuilder().build()).buildFuture();
}
}
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.DeleteIdPoolInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.DeleteIdPoolInputBuilder;
+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.ReleaseIdInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.ReleaseIdInputBuilder;
CreateIdPoolInput createPool = new CreateIdPoolInputBuilder().setPoolName(poolName).setLow(low).setHigh(high)
.build();
try {
- Future<RpcResult<Void>> result = idManager.createIdPool(createPool);
+ Future<RpcResult<CreateIdPoolOutput>> result = idManager.createIdPool(createPool);
if (result != null && result.get().isSuccessful()) {
LOG.info("DHCP Allocation Pool Service : Created IdPool name {}", poolName);
} else {
String poolName = getPoolKeyIdByAllocationPool(networkId, pool);
DeleteIdPoolInput deletePool = new DeleteIdPoolInputBuilder().setPoolName(poolName).build();
try {
- Future<RpcResult<Void>> result = idManager.deleteIdPool(deletePool);
+ Future<RpcResult<DeleteIdPoolOutput>> result = idManager.deleteIdPool(deletePool);
if (result != null && result.get().isSuccessful()) {
LOG.info("DHCP Allocation Pool Service : Deleted IdPool name {}", poolName);
} else {
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.rev160406.IfL2vlan;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.etree.rev160614.EtreeInstance;
private void createIdPool() throws Exception {
CreateIdPoolInput createPool = new CreateIdPoolInputBuilder().setPoolName(ElanConstants.ELAN_ID_POOL_NAME)
.setLow(ElanConstants.ELAN_ID_LOW_VALUE).setHigh(ElanConstants.ELAN_ID_HIGH_VALUE).build();
- Future<RpcResult<Void>> result = idManager.createIdPool(createPool);
+ Future<RpcResult<CreateIdPoolOutput>> result = idManager.createIdPool(createPool);
if (result != null && result.get().isSuccessful()) {
LOG.debug("ELAN Id Pool is created successfully");
}
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.TransportZones;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.transport.zone.subnets.DeviceVteps;
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.ItmRpcService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.config.rev150710.ElanConfig;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.ElanInstances;
builder.setIpAddress(tunnelIp);
try {
deleteStaleTunnelsOfHwvtepInITM(dataBroker, itmRpcService, hwvtepId, psName, tunnelIp);
- Future<RpcResult<Void>> result = itmRpcService.addL2GwDevice(builder.build());
- RpcResult<Void> rpcResult = result.get();
+ RpcResult<AddL2GwDeviceOutput> rpcResult = itmRpcService.addL2GwDevice(builder.build()).get();
if (rpcResult.isSuccessful()) {
LOG.info("Created ITM tunnels for {}", hwvtepId);
} else {
package org.opendaylight.netvirt.elan.l2gw.utils;
import java.util.concurrent.ExecutionException;
-import java.util.concurrent.Future;
import org.opendaylight.genius.utils.hwvtep.HwvtepSouthboundConstants;
import org.opendaylight.genius.utils.hwvtep.HwvtepSouthboundUtils;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
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.ItmRpcService;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;
import org.opendaylight.yangtools.yang.common.RpcResult;
builder.setNodeId(HwvtepSouthboundUtils.createManagedNodeId(new NodeId(hwvtepId), psName).getValue());
builder.setIpAddress(tunnelIp);
try {
- Future<RpcResult<Void>> result = itmRpcService.deleteL2GwDevice(builder.build());
- RpcResult<Void> rpcResult = result.get();
+ RpcResult<DeleteL2GwDeviceOutput> rpcResult = itmRpcService.deleteL2GwDevice(builder.build()).get();
if (rpcResult.isSuccessful()) {
LOG.info("Deleted ITM tunnels for {}", hwvtepId);
} else {
import com.google.common.base.Optional;
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.genius.interfacemanager.globals.InterfaceInfo;
}
@Override
- public Future<RpcResult<GetElanInterfaceStatisticsOutput>> getElanInterfaceStatistics(
+ public ListenableFuture<RpcResult<GetElanInterfaceStatisticsOutput>> getElanInterfaceStatistics(
GetElanInterfaceStatisticsInput input) {
String interfaceName = input.getInterfaceName();
LOG.debug("getElanInterfaceStatistics is called for elan interface {}", interfaceName);
if (!interfaceInfo.isOperational()) {
LOG.debug("interface {} is down and returning with no statistics", interfaceName);
rpcResultBuilder = RpcResultBuilder.success();
- return Futures
- .immediateFuture(rpcResultBuilder.withResult(new GetElanInterfaceStatisticsOutputBuilder()
+ return rpcResultBuilder.withResult(new GetElanInterfaceStatisticsOutputBuilder()
.setStatResult(
new StatResultBuilder().setStatResultCode(ResultCode.NotFound).setByteRxCount(0L)
.setByteTxCount(0L).setPacketRxCount(0L).setPacketTxCount(0L).build())
- .build()).build());
+ .build()).buildFuture();
}
rpcResultBuilder = RpcResultBuilder.success();
return Futures.immediateFuture(rpcResultBuilder
return null;
}
- private Future<RpcResult<GetElanInterfaceStatisticsOutput>> getFutureWithAppErrorMessage(
+ private ListenableFuture<RpcResult<GetElanInterfaceStatisticsOutput>> getFutureWithAppErrorMessage(
RpcResultBuilder<GetElanInterfaceStatisticsOutput> rpcResultBuilder, String message) {
rpcResultBuilder.withError(ErrorType.APPLICATION, message);
- return Futures.immediateFuture(rpcResultBuilder.build());
+ return rpcResultBuilder.buildFuture();
}
}
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.RemoveTerminatingServiceActionsInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.RemoveTerminatingServiceActionsInputBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.RemoveTerminatingServiceActionsOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
public void removeTerminatingServiceAction(BigInteger destDpId, int serviceId) {
RemoveTerminatingServiceActionsInput input = new RemoveTerminatingServiceActionsInputBuilder()
.setDpnId(destDpId).setServiceId(serviceId).build();
- Future<RpcResult<Void>> futureObject = itmRpcService.removeTerminatingServiceActions(input);
+ Future<RpcResult<RemoveTerminatingServiceActionsOutput>> futureObject =
+ itmRpcService.removeTerminatingServiceActions(input);
try {
- RpcResult<Void> result = futureObject.get();
+ RpcResult<RemoveTerminatingServiceActionsOutput> result = futureObject.get();
if (result.isSuccessful()) {
LOG.debug("Successfully completed removeTerminatingServiceActions for ELAN with serviceId {} on "
+ "dpn {}", serviceId, destDpId);
import static org.opendaylight.yangtools.testutils.mockito.MoreAnswers.realOrException;
+import com.google.common.util.concurrent.ListenableFuture;
import java.util.List;
-import java.util.concurrent.Future;
-
import org.mockito.Mockito;
import org.opendaylight.genius.interfacemanager.IfmUtil;
import org.opendaylight.genius.interfacemanager.commons.InterfaceManagerCommonUtils;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.GetEgressActionsForInterfaceOutputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.OdlInterfaceRpcService;
import org.opendaylight.yangtools.yang.common.RpcResult;
-
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
}
@Override
- public Future<RpcResult<GetEgressActionsForInterfaceOutput>> getEgressActionsForInterface(
+ public ListenableFuture<RpcResult<GetEgressActionsForInterfaceOutput>> getEgressActionsForInterface(
GetEgressActionsForInterfaceInput input) {
return FutureRpcResults.fromBuilder(LOG, input, () -> {
List<Action> actionsList = IfmUtil.getEgressActionsForInterface(input.getIntfName(), input.getTunnelKey(),
}
@Override
- public Future<RpcResult<GetDpidFromInterfaceOutput>> getDpidFromInterface(
+ public ListenableFuture<RpcResult<GetDpidFromInterfaceOutput>> getDpidFromInterface(
GetDpidFromInterfaceInput input) {
return FutureRpcResults.fromBuilder(LOG, input, () -> {
return new GetDpidFromInterfaceOutputBuilder().setDpid(
import static org.opendaylight.netvirt.elanmanager.tests.ElanServiceTestBase.ELAN1;
-import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
import java.util.HashMap;
import java.util.Map;
-import java.util.concurrent.Future;
-
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.AllocateIdInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.AllocateIdOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.AllocateIdOutputBuilder;
}
@Override
- public Future<RpcResult<AllocateIdOutput>> allocateId(AllocateIdInput allocateIdInput) {
+ public
ListenableFuture<RpcResult<AllocateIdOutput>> allocateId(AllocateIdInput allocateIdInput) {
Long id = ids.get(allocateIdInput.getIdKey());
- return Futures.immediateFuture(RpcResultBuilder.success(
- new AllocateIdOutputBuilder().setIdValue(id).build()).build());
+ return RpcResultBuilder.success(new AllocateIdOutputBuilder().setIdValue(id).build()).buildFuture();
}
}
import static org.opendaylight.netvirt.fibmanager.FibConstants.DEFAULT_FIB_FLOW_PRIORITY;
import static org.opendaylight.netvirt.fibmanager.FibConstants.FLOWID_PREFIX;
-import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
import java.math.BigInteger;
import java.net.InetAddress;
import java.net.UnknownHostException;
import java.util.ArrayList;
import java.util.List;
-import java.util.concurrent.Future;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.apache.commons.lang3.tuple.ImmutablePair;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.Flow;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list.Instruction;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fib.rpc.rev160121.CleanupDpnForVpnInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fib.rpc.rev160121.CleanupDpnForVpnOutput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fib.rpc.rev160121.CleanupDpnForVpnOutputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fib.rpc.rev160121.CreateFibEntryInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fib.rpc.rev160121.CreateFibEntryOutput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fib.rpc.rev160121.CreateFibEntryOutputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fib.rpc.rev160121.FibRpcService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fib.rpc.rev160121.PopulateFibOnDpnInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fib.rpc.rev160121.PopulateFibOnDpnOutput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fib.rpc.rev160121.PopulateFibOnDpnOutputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fib.rpc.rev160121.RemoveFibEntryInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fib.rpc.rev160121.RemoveFibEntryOutput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fib.rpc.rev160121.RemoveFibEntryOutputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.VpnInstanceOpData;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.VpnInstanceToVpnId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data.VpnInstanceOpDataEntry;
* To install FIB routes on specified dpn with given instructions.
*/
@Override
- public Future<RpcResult<Void>> createFibEntry(CreateFibEntryInput input) {
+ public ListenableFuture<RpcResult<CreateFibEntryOutput>> createFibEntry(CreateFibEntryInput input) {
BigInteger dpnId = input.getSourceDpid();
String vpnName = input.getVpnName();
vpnFootprintService.updateVpnToDpnMapping(dpnId, vpnName, vpnRd, null /* interfaceName*/,
new ImmutablePair<>(ipAddressSource, ipAddress), true /*add*/);
LOG.info("ADD: Added Custom Fib Entry rd {} prefix {} label {}", vpnRd, ipAddress, input.getServiceId());
- return Futures.immediateFuture(RpcResultBuilder.<Void>success().build());
+ return RpcResultBuilder.success(new CreateFibEntryOutputBuilder().build()).buildFuture();
}
/**
* To remove FIB/LFIB/TST routes from specified dpn.
*/
@Override
- public Future<RpcResult<Void>> removeFibEntry(RemoveFibEntryInput input) {
+ public ListenableFuture<RpcResult<RemoveFibEntryOutput>> removeFibEntry(RemoveFibEntryInput input) {
BigInteger dpnId = input.getSourceDpid();
String vpnName = input.getVpnName();
long vpnId = getVpnId(dataBroker, vpnName);
vpnFootprintService.updateVpnToDpnMapping(dpnId, vpnName, vpnRd, null /* interfaceName*/,
new ImmutablePair<>(ipAddressSource, ipAddress), false /*add*/);
LOG.info("REMOVE: Removed Custom Fib Entry rd {} prefix {} label {}", vpnRd, ipAddress, input.getServiceId());
- return Futures.immediateFuture(RpcResultBuilder.<Void>success().build());
+ return RpcResultBuilder.success(new RemoveFibEntryOutputBuilder().build()).buildFuture();
}
@Override
- public Future<RpcResult<Void>> populateFibOnDpn(PopulateFibOnDpnInput input) {
+ public ListenableFuture<RpcResult<PopulateFibOnDpnOutput>> populateFibOnDpn(PopulateFibOnDpnInput input) {
fibManager.populateFibOnNewDpn(input.getDpid(), input.getVpnId(), input.getRd(), null);
- return Futures.immediateFuture(RpcResultBuilder.<Void>success().build());
+ return RpcResultBuilder.success(new PopulateFibOnDpnOutputBuilder().build()).buildFuture();
}
@Override
- public Future<RpcResult<Void>> cleanupDpnForVpn(CleanupDpnForVpnInput input) {
+ public ListenableFuture<RpcResult<CleanupDpnForVpnOutput>> cleanupDpnForVpn(CleanupDpnForVpnInput input) {
fibManager.cleanUpDpnForVpn(input.getDpid(), input.getVpnId(), input.getRd(), null);
- return Futures.immediateFuture(RpcResultBuilder.<Void>success().build());
+ return RpcResultBuilder.success(new CleanupDpnForVpnOutputBuilder().build()).buildFuture();
}
private void removeLocalFibEntry(BigInteger dpnId, long vpnId, String ipPrefix) {
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.itm.op.rev160406.DpnEndpoints;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.dpn.endpoints.DPNTEPsInfo;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.dpn.endpoints.DPNTEPsInfoKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.lockmanager.rev160413.TimeUnits;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.lockmanager.rev160413.TryLockInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.lockmanager.rev160413.TryLockInputBuilder;
+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.UnlockInputBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.lockmanager.rev160413.UnlockOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.BucketId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.GroupId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.group.Buckets;
void releaseId(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();
+ RpcResult<ReleaseIdOutput> rpcResult = idManager.releaseId(idInput).get();
if (!rpcResult.isSuccessful()) {
LOG.error("RPC Call to Get Unique Id for key {} returned with Errors {}", idKey, rpcResult.getErrors());
}
public static boolean lockCluster(LockManagerService lockManager, String lockName, long tryLockPeriod) {
TryLockInput input = new TryLockInputBuilder().setLockName(lockName).setTime(tryLockPeriod)
.setTimeUnit(TimeUnits.Milliseconds).build();
- Future<RpcResult<Void>> result = lockManager.tryLock(input);
+ Future<RpcResult<TryLockOutput>> result = lockManager.tryLock(input);
boolean lockAcquired;
try {
- if ((result != null) && (result.get().isSuccessful())) {
+ if (result != null && result.get().isSuccessful()) {
LOG.debug("lockCluster: Acquired lock for {}", lockName);
lockAcquired = true;
} else {
public static void unlockCluster(LockManagerService lockManager, String lockName) {
UnlockInput input = new UnlockInputBuilder().setLockName(lockName).build();
- Future<RpcResult<Void>> result = lockManager.unlock(input);
+ Future<RpcResult<UnlockOutput>> result = lockManager.unlock(input);
try {
- if ((result != null) && (result.get().isSuccessful())) {
+ if (result != null && result.get().isSuccessful()) {
LOG.debug("unlockCluster: Unlocked {}", lockName);
} else {
LOG.error("unlockCluster: Unable to release lock for {}", lockName);
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.genius.interfacemanager.rev160406.TunnelTypeBase;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.TunnelTypeGre;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.TunnelTypeMplsOverGre;
private final ItmRpcService itmManager;
private final IdManagerService idManager;
private final IElanService elanService;
- private LockManagerService lockManager;
+ private final LockManagerService lockManager;
private final SalGroupService salGroupService;
private final JobCoordinator jobCoordinator;
private final FibUtil fibUtil;
.setHigh(175000L)
.build();
try {
- Future<RpcResult<Void>> result = idManager.createIdPool(createPool);
+ Future<RpcResult<CreateIdPoolOutput>> result = idManager.createIdPool(createPool);
if (result != null && result.get().isSuccessful()) {
LOG.info("Created IdPool for NextHopPointerPool");
}
.setPoolName(NEXTHOP_ID_POOL_NAME)
.setIdKey(nexthopKey).build();
try {
- Future<RpcResult<Void>> result = idManager.releaseId(idInput);
- RpcResult<Void> rpcResult = result.get();
+ RpcResult<ReleaseIdOutput> rpcResult = idManager.releaseId(idInput).get();
if (!rpcResult.isSuccessful()) {
LOG.error("RPC Call to Get Unique Id for nexthopKey {} returned with Errors {}",
nexthopKey, rpcResult.getErrors());
import static com.google.common.base.Preconditions.checkArgument;
import static com.google.common.base.Preconditions.checkNotNull;
-import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
import java.math.BigInteger;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorRef;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.ipv6service.ipv6util.rev170210.Ipv6NdutilService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.ipv6service.ipv6util.rev170210.SendNeighborSolicitationInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.ipv6service.ipv6util.rev170210.SendNeighborSolicitationOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.ipv6service.ipv6util.rev170210.interfaces.InterfaceAddress;
import org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service.rev130709.PacketProcessingService;
import org.opendaylight.yangtools.yang.common.RpcError;
}
@Override
- public Future<RpcResult<Void>> sendNeighborSolicitation(SendNeighborSolicitationInput ndInput) {
- RpcResultBuilder<Void> failureBuilder = RpcResultBuilder.failed();
- RpcResultBuilder<Void> successBuilder = RpcResultBuilder.success();
+ public ListenableFuture<RpcResult<SendNeighborSolicitationOutput>> sendNeighborSolicitation(
+ SendNeighborSolicitationInput ndInput) {
+ RpcResultBuilder<SendNeighborSolicitationOutput> failureBuilder = RpcResultBuilder.failed();
+ RpcResultBuilder<SendNeighborSolicitationOutput> successBuilder = RpcResultBuilder.success();
Ipv6Address targetIpv6Address = null;
Ipv6Address srcIpv6Address;
String interfaceName = null;
}
if (localErrorCount == ndInput.getInterfaceAddress().size()) {
// Failed to send IPv6 Neighbor Solicitation on all the interfaces, return failure.
- return Futures.immediateFuture(failureBuilder.build());
+ return failureBuilder.buildFuture();
}
- return Futures.immediateFuture(successBuilder.build());
+ return successBuilder.buildFuture();
}
private GetPortFromInterfaceOutput getPortFromInterface(String interfaceName) {
import com.google.common.base.Optional;
import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.Futures;
-import com.google.common.util.concurrent.JdkFutureAdapters;
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.MoreExecutors;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
-import java.util.concurrent.Future;
import javax.annotation.Nonnull;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.IdManagerService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fib.rpc.rev160121.CreateFibEntryInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fib.rpc.rev160121.CreateFibEntryInputBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fib.rpc.rev160121.CreateFibEntryOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fib.rpc.rev160121.FibRpcService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fib.rpc.rev160121.RemoveFibEntryInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fib.rpc.rev160121.RemoveFibEntryInputBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fib.rpc.rev160121.RemoveFibEntryOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.Adjacencies;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.AdjacenciesOp;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.AdjacenciesOpBuilder;
.setServiceId(l3Vni).setIpAddressSource(CreateFibEntryInput.IpAddressSource.FloatingIP)
.setInstruction(instructionsFib).build();
- Future<RpcResult<Void>> future1 = fibService.createFibEntry(input);
- ListenableFuture<RpcResult<Void>> futureVxlan = JdkFutureAdapters.listenInPoolThread(future1);
+ ListenableFuture<RpcResult<CreateFibEntryOutput>> futureVxlan = fibService.createFibEntry(input);
LOG.debug("onAddFloatingIp : Add Floating Ip {} , found associated to fixed port {}",
externalIp, interfaceName);
if (floatingIpPortMacAddress != null) {
writeTx.submit();
}
final long finalL3Vni = l3Vni;
- Futures.addCallback(futureVxlan, new FutureCallback<RpcResult<Void>>() {
+ Futures.addCallback(futureVxlan, new FutureCallback<RpcResult<CreateFibEntryOutput>>() {
@Override
public void onFailure(@Nonnull Throwable error) {
}
@Override
- public void onSuccess(@Nonnull RpcResult<Void> result) {
+ public void onSuccess(@Nonnull RpcResult<CreateFibEntryOutput> result) {
if (result.isSuccessful()) {
LOG.info("onAddFloatingIp : Successfully installed custom FIB routes for Floating "
+ "IP Prefix {} on DPN {}", externalIp, dpnId);
RemoveFibEntryInput input = new RemoveFibEntryInputBuilder().setVpnName(vpnName)
.setSourceDpid(dpnId).setIpAddress(fibExternalIp).setServiceId(l3Vni)
.setIpAddressSource(RemoveFibEntryInput.IpAddressSource.FloatingIP).build();
- Future<RpcResult<Void>> future = fibService.removeFibEntry(input);
- ListenableFuture<RpcResult<Void>> futureVxlan = JdkFutureAdapters.listenInPoolThread(future);
+ ListenableFuture<RpcResult<RemoveFibEntryOutput>> futureVxlan = fibService.removeFibEntry(input);
final long finalL3Vni = l3Vni;
- Futures.addCallback(futureVxlan, new FutureCallback<RpcResult<Void>>() {
+ Futures.addCallback(futureVxlan, new FutureCallback<RpcResult<RemoveFibEntryOutput>>() {
@Override
public void onFailure(@Nonnull Throwable error) {
}
@Override
- public void onSuccess(@Nonnull RpcResult<Void> result) {
+ public void onSuccess(@Nonnull RpcResult<RemoveFibEntryOutput> result) {
if (result.isSuccessful()) {
LOG.info("onRemoveFloatingIp : Successfully removed custom FIB routes for Floating "
+ "IP Prefix {} on DPN {}", externalIp, dpnId);
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 com.google.common.util.concurrent.MoreExecutors;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.List;
-import java.util.concurrent.Future;
import javax.annotation.Nonnull;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.IdManagerService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fib.rpc.rev160121.CreateFibEntryInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fib.rpc.rev160121.CreateFibEntryInputBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fib.rpc.rev160121.CreateFibEntryOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fib.rpc.rev160121.FibRpcService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fib.rpc.rev160121.RemoveFibEntryInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fib.rpc.rev160121.RemoveFibEntryInputBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fib.rpc.rev160121.RemoveFibEntryOutput;
import org.opendaylight.yangtools.yang.common.RpcResult;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
+ "NAPT Switch {} with l3Vni {}, ExternalFixedIp {}, ExternalVpnName {} for RouterId {}",
NwConstants.L3_FIB_TABLE, tableId, dpnId, l3Vni, externalIp, vpnName, routerId);
- Future<RpcResult<Void>> future1 = fibService.createFibEntry(input);
- ListenableFuture<RpcResult<Void>> futureVxlan = JdkFutureAdapters.listenInPoolThread(future1);
+ ListenableFuture<RpcResult<CreateFibEntryOutput>> futureVxlan = fibService.createFibEntry(input);
final long finalL3Vni = l3Vni;
- Futures.addCallback(futureVxlan, new FutureCallback<RpcResult<Void>>() {
+ Futures.addCallback(futureVxlan, new FutureCallback<RpcResult<CreateFibEntryOutput>>() {
@Override
public void onFailure(@Nonnull Throwable error) {
LOG.error("evpnAdvToBgpAndInstallFibAndTsFlows : Error in custom fib routes install process for "
}
@Override
- public void onSuccess(@Nonnull RpcResult<Void> result) {
+ public void onSuccess(@Nonnull RpcResult<CreateFibEntryOutput> result) {
if (result.isSuccessful()) {
LOG.info("evpnAdvToBgpAndInstallFibAndTsFlows : Successfully installed custom FIB routes for "
+ "External Fixed IP {} on DPN {} with l3Vni {}, ExternalVpnName {} for RouterId {}",
+ "NAPT Switch {} with l3Vni {}, ExternalFixedIp {}, ExternalVpnName {} for RouterId {}",
NwConstants.L3_FIB_TABLE, NwConstants.INBOUND_NAPT_TABLE, dpnId, l3Vni, externalIp, vpnName, routerId);
- Future<RpcResult<Void>> future = fibService.removeFibEntry(input);
- ListenableFuture<RpcResult<Void>> futureVxlan = JdkFutureAdapters.listenInPoolThread(future);
+ ListenableFuture<RpcResult<RemoveFibEntryOutput>> futureVxlan = fibService.removeFibEntry(input);
final long finalL3Vni = l3Vni;
- Futures.addCallback(futureVxlan, new FutureCallback<RpcResult<Void>>() {
+ Futures.addCallback(futureVxlan, new FutureCallback<RpcResult<RemoveFibEntryOutput>>() {
@Override
public void onFailure(@Nonnull Throwable error) {
LOG.error("evpnDelFibTsAndReverseTraffic : Error in custom fib routes remove process for "
}
@Override
- public void onSuccess(@Nonnull RpcResult<Void> result) {
+ public void onSuccess(@Nonnull RpcResult<RemoveFibEntryOutput> result) {
if (result.isSuccessful()) {
LOG.info("evpnDelFibTsAndReverseTraffic : Successfully removed custom FIB routes for "
+ "External Fixed IP {} on DPN {} with l3Vni {}, ExternalVpnName {} for "
import com.google.common.util.concurrent.AsyncFunction;
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 com.google.common.util.concurrent.MoreExecutors;
import java.math.BigInteger;
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.interfacemanager.rev160406.TunnelTypeBase;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.TunnelTypeGre;
import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.GroupTypes;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fib.rpc.rev160121.CreateFibEntryInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fib.rpc.rev160121.CreateFibEntryInputBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fib.rpc.rev160121.CreateFibEntryOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fib.rpc.rev160121.FibRpcService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fib.rpc.rev160121.RemoveFibEntryInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fib.rpc.rev160121.RemoveFibEntryInputBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fib.rpc.rev160121.RemoveFibEntryOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.config.rev170206.NatserviceConfig;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.config.rev170206.NatserviceConfig.NatMode;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.ExtRouters;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.vpn.rpc.rev160201.GenerateVpnLabelOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.vpn.rpc.rev160201.RemoveVpnLabelInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.vpn.rpc.rev160201.RemoveVpnLabelInputBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.vpn.rpc.rev160201.RemoveVpnLabelOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.vpn.rpc.rev160201.VpnRpcService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.ports.attributes.ports.Port;
import org.opendaylight.yangtools.yang.binding.DataObject;
.setHigh(NatConstants.SNAT_ID_HIGH_VALUE)
.build();
try {
- Future<RpcResult<Void>> result = idManager.createIdPool(createPool);
+ Future<RpcResult<CreateIdPoolOutput>> result = idManager.createIdPool(createPool);
if (result != null && result.get().isSuccessful()) {
LOG.debug("createGroupIdPool : GroupIdPool created successfully");
} else {
//Generate VPN label for the external IP
GenerateVpnLabelInput labelInput = new GenerateVpnLabelInputBuilder().setVpnName(vpnName)
.setIpPrefix(externalIp).build();
- Future<RpcResult<GenerateVpnLabelOutput>> labelFuture = vpnService.generateVpnLabel(labelInput);
+ ListenableFuture<RpcResult<GenerateVpnLabelOutput>> labelFuture = vpnService.generateVpnLabel(labelInput);
//On successful generation of the VPN label, advertise the route to the BGP and install the FIB routes.
- ListenableFuture<RpcResult<Void>> future =
- Futures.transformAsync(JdkFutureAdapters.listenInPoolThread(labelFuture),
- (AsyncFunction<RpcResult<GenerateVpnLabelOutput>, RpcResult<Void>>) result -> {
+ ListenableFuture<RpcResult<CreateFibEntryOutput>> future =
+ Futures.transformAsync(labelFuture,
+ (AsyncFunction<RpcResult<GenerateVpnLabelOutput>, RpcResult<CreateFibEntryOutput>>) result -> {
if (result.isSuccessful()) {
LOG.debug("advToBgpAndInstallFibAndTsFlows : inside apply with result success");
GenerateVpnLabelOutput output = result.getResult();
.setSourceDpid(dpnId).setIpAddress(fibExternalIp).setServiceId(label)
.setIpAddressSource(CreateFibEntryInput.IpAddressSource.ExternalFixedIP)
.setInstruction(fibTableCustomInstructions).build();
- Future<RpcResult<Void>> future1 = fibService.createFibEntry(input);
- return JdkFutureAdapters.listenInPoolThread(future1);
+ return fibService.createFibEntry(input);
} else {
LOG.error("advToBgpAndInstallFibAndTsFlows : inside apply with result failed");
String errMsg = String.format("Could not retrieve the label for prefix %s in VPN %s, %s",
}
}, MoreExecutors.directExecutor());
- Futures.addCallback(future, new FutureCallback<RpcResult<Void>>() {
+ Futures.addCallback(future, new FutureCallback<RpcResult<CreateFibEntryOutput>>() {
@Override
public void onFailure(@Nonnull Throwable error) {
}
@Override
- public void onSuccess(@Nonnull RpcResult<Void> result) {
+ public void onSuccess(@Nonnull RpcResult<CreateFibEntryOutput> result) {
if (result.isSuccessful()) {
LOG.info("advToBgpAndInstallFibAndTsFlows : Successfully installed custom FIB routes for prefix {}",
externalIp);
RemoveFibEntryInput input = new RemoveFibEntryInputBuilder().setVpnName(vpnName)
.setSourceDpid(dpnId).setIpAddress(externalIp).setServiceId(label)
.setIpAddressSource(RemoveFibEntryInput.IpAddressSource.ExternalFixedIP).build();
- Future<RpcResult<Void>> future = fibService.removeFibEntry(input);
+ ListenableFuture<RpcResult<RemoveFibEntryOutput>> future = fibService.removeFibEntry(input);
removeTunnelTableEntry(dpnId, label, removeFlowInvTx);
removeLFibTableEntry(dpnId, label, removeFlowInvTx);
NatUtil.removePreDnatToSnatTableEntry(mdsalManager, dpnId, removeFlowInvTx);
}
if (!switchOver) {
- ListenableFuture<RpcResult<Void>> labelFuture =
- Futures.transformAsync(JdkFutureAdapters.listenInPoolThread(future),
- (AsyncFunction<RpcResult<Void>, RpcResult<Void>>) result -> {
+ ListenableFuture<RpcResult<RemoveVpnLabelOutput>> labelFuture =
+ Futures.transformAsync(future, result -> {
//Release label
- if (result.isSuccessful()) {
- NatUtil.removePreDnatToSnatTableEntry(mdsalManager, dpnId, removeFlowInvTx);
- RemoveVpnLabelInput labelInput = new RemoveVpnLabelInputBuilder()
- .setVpnName(vpnName).setIpPrefix(externalIp).build();
- Future<RpcResult<Void>> labelFuture1 = vpnService.removeVpnLabel(labelInput);
- return JdkFutureAdapters.listenInPoolThread(labelFuture1);
- } else {
- String errMsg =
- String.format("RPC call to remove custom FIB entries on dpn %s for "
- + "prefix %s Failed - %s", dpnId, externalIp, result.getErrors());
- LOG.error(errMsg);
- return Futures.immediateFailedFuture(new RuntimeException(errMsg));
- }
- });
+ if (result.isSuccessful()) {
+ NatUtil.removePreDnatToSnatTableEntry(mdsalManager, dpnId, removeFlowInvTx);
+ RemoveVpnLabelInput labelInput = new RemoveVpnLabelInputBuilder()
+ .setVpnName(vpnName).setIpPrefix(externalIp).build();
+ return vpnService.removeVpnLabel(labelInput);
+ } else {
+ String errMsg =
+ String.format("RPC call to remove custom FIB entries on dpn %s for "
+ + "prefix %s Failed - %s", dpnId, externalIp, result.getErrors());
+ LOG.error(errMsg);
+ return Futures.immediateFailedFuture(new RuntimeException(errMsg));
+ }
+ }, MoreExecutors.directExecutor());
- Futures.addCallback(labelFuture, new FutureCallback<RpcResult<Void>>() {
+ Futures.addCallback(labelFuture, new FutureCallback<RpcResult<RemoveVpnLabelOutput>>() {
@Override
public void onFailure(@Nonnull Throwable error) {
}
@Override
- public void onSuccess(@Nonnull RpcResult<Void> result) {
+ public void onSuccess(@Nonnull RpcResult<RemoveVpnLabelOutput> result) {
if (result.isSuccessful()) {
LOG.debug("delFibTsAndReverseTraffic : Successfully removed the label for the prefix {} "
+ "from VPN {}", externalIp, vpnName);
RemoveFibEntryInput input = new RemoveFibEntryInputBuilder()
.setVpnName(vpnName).setSourceDpid(dpnId).setIpAddress(externalIp)
.setIpAddressSource(RemoveFibEntryInput.IpAddressSource.ExternalFixedIP).setServiceId(label).build();
- Future<RpcResult<Void>> future = fibService.removeFibEntry(input);
+ ListenableFuture<RpcResult<RemoveFibEntryOutput>> future = fibService.removeFibEntry(input);
removeTunnelTableEntry(dpnId, label, removeFlowInvTx);
removeLFibTableEntry(dpnId, label, removeFlowInvTx);
NatUtil.removePreDnatToSnatTableEntry(mdsalManager, dpnId, removeFlowInvTx);
}
if (!switchOver) {
- ListenableFuture<RpcResult<Void>> labelFuture =
- Futures.transformAsync(JdkFutureAdapters.listenInPoolThread(future),
- (AsyncFunction<RpcResult<Void>, RpcResult<Void>>) result -> {
- //Release label
- if (result.isSuccessful()) {
- RemoveVpnLabelInput labelInput = new RemoveVpnLabelInputBuilder()
- .setVpnName(vpnName).setIpPrefix(externalIp).build();
- Future<RpcResult<Void>> labelFuture1 = vpnService.removeVpnLabel(labelInput);
- return JdkFutureAdapters.listenInPoolThread(labelFuture1);
- } else {
- String errMsg =
- String.format("RPC call to remove custom FIB entries on dpn %s for "
- + "prefix %s Failed - %s",
- dpnId, externalIp, result.getErrors());
- LOG.error(errMsg);
- return Futures.immediateFailedFuture(new RuntimeException(errMsg));
- }
- });
+ ListenableFuture<RpcResult<RemoveVpnLabelOutput>> labelFuture =
+ Futures.transformAsync(future, result -> {
+ //Release label
+ if (result.isSuccessful()) {
+ RemoveVpnLabelInput labelInput = new RemoveVpnLabelInputBuilder()
+ .setVpnName(vpnName).setIpPrefix(externalIp).build();
+ return vpnService.removeVpnLabel(labelInput);
+ } else {
+ String errMsg =
+ String.format("RPC call to remove custom FIB entries on dpn %s for "
+ + "prefix %s Failed - %s",
+ dpnId, externalIp, result.getErrors());
+ LOG.error(errMsg);
+ return Futures.immediateFailedFuture(new RuntimeException(errMsg));
+ }
+ }, MoreExecutors.directExecutor());
- Futures.addCallback(labelFuture, new FutureCallback<RpcResult<Void>>() {
+ Futures.addCallback(labelFuture, new FutureCallback<RpcResult<RemoveVpnLabelOutput>>() {
@Override
public void onFailure(@Nonnull Throwable error) {
}
@Override
- public void onSuccess(@Nonnull RpcResult<Void> result) {
+ public void onSuccess(@Nonnull RpcResult<RemoveVpnLabelOutput> result) {
if (result.isSuccessful()) {
LOG.debug("delFibTsAndReverseTraffic : Successfully removed the label for the prefix {} "
+ "from VPN {}", externalIp, vpnName);
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.DeleteIdPoolInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.DeleteIdPoolInputBuilder;
+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.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.netvirt.natservice.rev160111.ExternalIpsCounter;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.IntextIpMap;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.IntextIpPortMap;
.setHigh(HIGH_PORT)
.build();
try {
- Future<RpcResult<Void>> result = idManager.createIdPool(createPool);
+ Future<RpcResult<CreateIdPoolOutput>> result = idManager.createIdPool(createPool);
if (result != null && result.get().isSuccessful()) {
LOG.debug("createNaptPortPool : Created PortPool :{}", poolName);
} else {
DeleteIdPoolInput deleteIdPoolInput = new DeleteIdPoolInputBuilder().setPoolName(poolName).build();
LOG.debug("removeNaptPortPool : Remove Napt port pool requested for : {}", poolName);
try {
- Future<RpcResult<Void>> result = idManager.deleteIdPool(deleteIdPoolInput);
+ Future<RpcResult<DeleteIdPoolOutput>> result = idManager.deleteIdPool(deleteIdPoolInput);
if (result != null && result.get().isSuccessful()) {
LOG.debug("removeNaptPortPool : Deleted PortPool {}", poolName);
} else {
.setPoolName(externalIp)
.setIdKey(internalIpPort).build();
try {
- Future<RpcResult<Void>> result = idManager.releaseId(idInput);
- RpcResult<Void> rpcResult = result.get();
+ RpcResult<ReleaseIdOutput> rpcResult = idManager.releaseId(idInput).get();
if (!rpcResult.isSuccessful()) {
LOG.error("removePortFromPool : idmanager failed to remove port from pool {}", rpcResult.getErrors());
}
import java.util.List;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
-
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.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.netvirt.fibmanager.rev150330.vrfentries.VrfEntry;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.prefix.to._interface.vpn.ids.Prefixes;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data.VpnInstanceOpDataEntry;
.setPoolName(IfmConstants.IFM_IDPOOL_NAME).setIdKey(routerName)
.build();
try {
- Future<RpcResult<Void>> result = idManager.releaseId(getIdInput);
- RpcResult<Void> rpcResult = result.get();
+ RpcResult<ReleaseIdOutput> rpcResult = idManager.releaseId(getIdInput).get();
if (!rpcResult.isSuccessful()) {
LOG.error("releaseLPortTagForRouter:ID manager failed while releasing allocated lport_tag "
+ "for router {}. Exception {} ", routerName, rpcResult.getErrors());
}
private static boolean isL3VpnOverVxLan(Long l3Vni) {
- return (l3Vni != null && l3Vni != 0);
+ return l3Vni != null && l3Vni != 0;
}
static ProviderTypes getExtNwProvTypeFromRouterName(DataBroker dataBroker, String routerName,
Collections.singletonList(nextHopIp), VrfEntry.EncapType.Vxlan, NatConstants.DEFAULT_LABEL_VALUE,
l3Vni, gwMacAddress, null /* parent-vpn-rd */, origin, writeTx);
/* Publish to Bgp only if its an INTERNET VPN */
- if ((rd != null) && (!rd.equalsIgnoreCase(vpnName))) {
+ if (rd != null && !rd.equalsIgnoreCase(vpnName)) {
bgpManager.advertisePrefix(rd, null /*macAddress*/, prefix, Collections.singletonList(nextHopIp),
VrfEntry.EncapType.Vxlan, NatConstants.DEFAULT_LABEL_VALUE, l3Vni, 0 /*l2vni*/,
gwMacAddress);
package org.opendaylight.netvirt.natservice.internal;
import com.google.common.base.Optional;
-
import java.math.BigInteger;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
-
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
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.DeleteIdPoolInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.DeleteIdPoolInputBuilder;
+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.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.yangtools.yang.binding.InstanceIdentifier;
ReleaseIdInput releaseIdInput = new ReleaseIdInputBuilder().setPoolName(NatConstants.ODL_VNI_POOL_NAME)
.setIdKey(vniKey).build();
try {
- Future<RpcResult<Void>> result = idManager.releaseId(releaseIdInput);
- RpcResult<Void> rpcResult = result.get();
+ RpcResult<ReleaseIdOutput> rpcResult = idManager.releaseId(releaseIdInput).get();
if (!rpcResult.isSuccessful()) {
LOG.warn("releaseVNI : Unable to release ID {} from OpenDaylight VXLAN VNI range pool. Error {}",
vniKey, rpcResult.getErrors());
CreateIdPoolInput createPool = null;
createPool = new CreateIdPoolInputBuilder().setPoolName(poolName).setLow(lowLimit).setHigh(highLimit).build();
try {
- Future<RpcResult<Void>> result = idManager.createIdPool(createPool);
+ Future<RpcResult<CreateIdPoolOutput>> result = idManager.createIdPool(createPool);
if (result != null && result.get().isSuccessful()) {
LOG.debug("createOpenDaylightVniRangesPool : Created OpenDaylight VXLAN VNI range pool {} "
+ "with range {}-{}", poolName, lowLimit, highLimit);
public static void deleteOpenDaylightVniRangesPool(IdManagerService idManager, String poolName) {
DeleteIdPoolInput deletePool = new DeleteIdPoolInputBuilder().setPoolName(poolName).build();
- Future<RpcResult<Void>> result = idManager.deleteIdPool(deletePool);
+ Future<RpcResult<DeleteIdPoolOutput>> result = idManager.deleteIdPool(deletePool);
try {
if (result != null && result.get().isSuccessful()) {
LOG.debug("deleteOpenDaylightVniRangesPool : Deleted OpenDaylight VXLAN VNI range pool {} successfully",
import com.google.common.base.Strings;
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 com.google.common.util.concurrent.MoreExecutors;
import java.math.BigInteger;
import java.util.Collections;
import java.util.List;
import java.util.Map;
-import java.util.concurrent.Future;
import javax.annotation.Nonnull;
import javax.annotation.PostConstruct;
import javax.inject.Inject;
import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.GroupTypes;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fib.rpc.rev160121.CreateFibEntryInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fib.rpc.rev160121.CreateFibEntryInputBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fib.rpc.rev160121.CreateFibEntryOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fib.rpc.rev160121.FibRpcService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fib.rpc.rev160121.RemoveFibEntryInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fib.rpc.rev160121.RemoveFibEntryInputBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fib.rpc.rev160121.RemoveFibEntryOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.dpn.routers.DpnRoutersList;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.dpn.routers.dpn.routers.list.RoutersList;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.config.rev170206.NatserviceConfig;
new CreateFibEntryInputBuilder().setVpnName(externalVpnName).setSourceDpid(srcDpnId)
.setInstruction(customInstructions).setIpAddress(fibExternalIp)
.setServiceId(serviceId).setInstruction(customInstructions).build();
- Future<RpcResult<Void>> future = fibRpcService.createFibEntry(input);
- ListenableFuture<RpcResult<Void>> listenableFuture = JdkFutureAdapters.listenInPoolThread(future);
+ ListenableFuture<RpcResult<CreateFibEntryOutput>> listenableFuture = fibRpcService.createFibEntry(input);
- Futures.addCallback(listenableFuture, new FutureCallback<RpcResult<Void>>() {
+ Futures.addCallback(listenableFuture, new FutureCallback<RpcResult<CreateFibEntryOutput>>() {
@Override
public void onFailure(@Nonnull Throwable error) {
}
@Override
- public void onSuccess(@Nonnull RpcResult<Void> result) {
+ public void onSuccess(@Nonnull RpcResult<CreateFibEntryOutput> result) {
if (result.isSuccessful()) {
LOG.info("hndlTepAddOnNaptSwitch : SNAT -> Successfully installed custom FIB routes "
+ "for prefix {}", externalIp);
.setSourceDpid(fipCfgdDpnId).setInstruction(customInstructions)
.setIpAddress(fibExternalIp).setServiceId(serviceId).setInstruction(customInstructions)
.build();
- Future<RpcResult<Void>> future = fibRpcService.createFibEntry(input);
- ListenableFuture<RpcResult<Void>> listenableFuture = JdkFutureAdapters.listenInPoolThread(future);
+ ListenableFuture<RpcResult<CreateFibEntryOutput>> listenableFuture =
+ fibRpcService.createFibEntry(input);
- Futures.addCallback(listenableFuture, new FutureCallback<RpcResult<Void>>() {
+ Futures.addCallback(listenableFuture, new FutureCallback<RpcResult<CreateFibEntryOutput>>() {
@Override
public void onFailure(@Nonnull Throwable error) {
}
@Override
- public void onSuccess(@Nonnull RpcResult<Void> result) {
+ public void onSuccess(@Nonnull RpcResult<CreateFibEntryOutput> result) {
if (result.isSuccessful()) {
LOG.info("hndlTepAddForDnatInEachRtr : DNAT -> Successfully installed custom FIB routes "
+ "for prefix {}", externalIp);
RemoveFibEntryInput input = new RemoveFibEntryInputBuilder().setVpnName(vpnName)
.setSourceDpid(fipCfgdDpnId).setIpAddress(externalIp).setServiceId(serviceId)
.setIpAddressSource(RemoveFibEntryInput.IpAddressSource.FloatingIP).build();
- Future<RpcResult<Void>> future = fibRpcService.removeFibEntry(input);
- ListenableFuture<RpcResult<Void>> listenableFuture = JdkFutureAdapters.listenInPoolThread(future);
+ ListenableFuture<RpcResult<RemoveFibEntryOutput>> listenableFuture =
+ fibRpcService.removeFibEntry(input);
- Futures.addCallback(listenableFuture, new FutureCallback<RpcResult<Void>>() {
+ Futures.addCallback(listenableFuture, new FutureCallback<RpcResult<RemoveFibEntryOutput>>() {
@Override
public void onFailure(@Nonnull Throwable error) {
}
@Override
- public void onSuccess(@Nonnull RpcResult<Void> result) {
+ public void onSuccess(@Nonnull RpcResult<RemoveFibEntryOutput> result) {
if (result.isSuccessful()) {
LOG.info("hndlTepDelForDnatInEachRtr : DNAT -> Successfully removed the entry pushing the "
+ "MPLS label to the tunnel");
import static org.opendaylight.netvirt.natservice.internal.NatUtil.buildfloatingIpIdToPortMappingIdentifier;
import com.google.common.base.Optional;
-import com.google.common.util.concurrent.AsyncFunction;
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 com.google.common.util.concurrent.MoreExecutors;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
-import java.util.concurrent.Future;
import javax.annotation.Nonnull;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.IdManagerService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fib.rpc.rev160121.CreateFibEntryInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fib.rpc.rev160121.CreateFibEntryInputBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fib.rpc.rev160121.CreateFibEntryOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fib.rpc.rev160121.FibRpcService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fib.rpc.rev160121.RemoveFibEntryInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fib.rpc.rev160121.RemoveFibEntryInputBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fib.rpc.rev160121.RemoveFibEntryOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.ProviderTypes;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.external.subnets.Subnets;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.floating.ip.info.router.ports.ports.InternalToExternalPortMap;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.vpn.rpc.rev160201.GenerateVpnLabelOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.vpn.rpc.rev160201.RemoveVpnLabelInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.vpn.rpc.rev160201.RemoveVpnLabelInputBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.vpn.rpc.rev160201.RemoveVpnLabelOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.vpn.rpc.rev160201.VpnRpcService;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.common.RpcResult;
*/
GenerateVpnLabelInput labelInput = new GenerateVpnLabelInputBuilder().setVpnName(vpnName)
.setIpPrefix(externalIp).build();
- Future<RpcResult<GenerateVpnLabelOutput>> labelFuture = vpnService.generateVpnLabel(labelInput);
-
- ListenableFuture<RpcResult<Void>> future = Futures.transformAsync(
- JdkFutureAdapters.listenInPoolThread(labelFuture),
- (AsyncFunction<RpcResult<GenerateVpnLabelOutput>, RpcResult<Void>>) result -> {
- if (result.isSuccessful()) {
- GenerateVpnLabelOutput output = result.getResult();
- long label = output.getLabel();
- LOG.debug("onAddFloatingIp : Generated label {} for prefix {}", label, externalIp);
- FloatingIPListener.updateOperationalDS(dataBroker, routerUuid, interfaceName, label,
+ ListenableFuture<RpcResult<GenerateVpnLabelOutput>> labelFuture = vpnService.generateVpnLabel(labelInput);
+
+ ListenableFuture<RpcResult<CreateFibEntryOutput>> future = Futures.transformAsync(labelFuture, result -> {
+ if (result.isSuccessful()) {
+ GenerateVpnLabelOutput output = result.getResult();
+ long label = output.getLabel();
+ LOG.debug("onAddFloatingIp : Generated label {} for prefix {}", label, externalIp);
+ FloatingIPListener.updateOperationalDS(dataBroker, routerUuid, interfaceName, label,
internalIp, externalIp);
- /*
- * For external network of type VXLAN all packets going from VMs within the DC, towards the
- * external gateway device via the External VXLAN Tunnel,we are setting the VXLAN Tunnel ID to
- * the L3VNI value of VPNInstance to which the VM belongs to.
- */
- long l3vni = 0;
- if (NatUtil.isOpenStackVniSemanticsEnforcedForGreAndVxlan(elanService, provType)) {
- l3vni = NatOverVxlanUtil.getInternetVpnVni(idManager, vpnName, l3vni).longValue();
- }
- String fibExternalIp = NatUtil.validateAndAddNetworkMask(externalIp);
- //Inform BGP
- NatUtil.addPrefixToBGP(dataBroker, bgpManager, fibManager, vpnName, rd, subnetId,
- fibExternalIp, nextHopIp, networkId.getValue(), floatingIpPortMacAddress,
- label, l3vni, RouteOrigin.STATIC, dpnId);
-
- List<Instruction> instructions = new ArrayList<>();
-
List<ActionInfo> actionsInfos = new ArrayList<>();
- actionsInfos.add(new ActionNxResubmit(NwConstants.PDNAT_TABLE));
- instructions.add(new InstructionApplyActions(actionsInfos).buildInstruction(0));
- makeTunnelTableEntry(vpnName, dpnId, label, instructions, writeFlowInvTx, provType);
-
- //Install custom FIB routes
-
List<ActionInfo> actionInfoFib = new ArrayList<>();
- List<Instruction> customInstructions = new ArrayList<>();
- actionInfoFib.add(new ActionSetFieldEthernetDestination(new MacAddress(floatingIpPortMacAddress)));
- customInstructions.add(new InstructionApplyActions(actionInfoFib).buildInstruction(0));
- customInstructions.add(new InstructionGotoTable(NwConstants.PDNAT_TABLE).buildInstruction(1));
-
- makeLFibTableEntry(dpnId, label, floatingIpPortMacAddress, NwConstants.PDNAT_TABLE, writeFlowInvTx);
- CreateFibEntryInput input = new CreateFibEntryInputBuilder().setVpnName(vpnName)
+ /*
+ * For external network of type VXLAN all packets going from VMs within the DC, towards the
+ * external gateway device via the External VXLAN Tunnel,we are setting the VXLAN Tunnel ID to
+ * the L3VNI value of VPNInstance to which the VM belongs to.
+ */
+ long l3vni = 0;
+ if (NatUtil.isOpenStackVniSemanticsEnforcedForGreAndVxlan(elanService, provType)) {
+ l3vni = NatOverVxlanUtil.getInternetVpnVni(idManager, vpnName, l3vni).longValue();
+ }
+ String fibExternalIp = NatUtil.validateAndAddNetworkMask(externalIp);
+ //Inform BGP
+ NatUtil.addPrefixToBGP(dataBroker, bgpManager, fibManager, vpnName, rd, subnetId,
+ fibExternalIp, nextHopIp, networkId.getValue(), floatingIpPortMacAddress,
+ label, l3vni, RouteOrigin.STATIC, dpnId);
+
+ List<Instruction> instructions = new ArrayList<>();
+ List<ActionInfo> actionsInfos = new ArrayList<>();
+ actionsInfos.add(new ActionNxResubmit(NwConstants.PDNAT_TABLE));
+ instructions.add(new InstructionApplyActions(actionsInfos).buildInstruction(0));
+ makeTunnelTableEntry(vpnName, dpnId, label, instructions, writeFlowInvTx, provType);
+
+ //Install custom FIB routes
+ List<ActionInfo> actionInfoFib = new ArrayList<>();
+ List<Instruction> customInstructions = new ArrayList<>();
+ actionInfoFib.add(new ActionSetFieldEthernetDestination(new MacAddress(floatingIpPortMacAddress)));
+ customInstructions.add(new InstructionApplyActions(actionInfoFib).buildInstruction(0));
+ customInstructions.add(new InstructionGotoTable(NwConstants.PDNAT_TABLE).buildInstruction(1));
+
+ makeLFibTableEntry(dpnId, label, floatingIpPortMacAddress, NwConstants.PDNAT_TABLE, writeFlowInvTx);
+ CreateFibEntryInput input = new CreateFibEntryInputBuilder().setVpnName(vpnName)
.setSourceDpid(dpnId).setInstruction(customInstructions)
.setIpAddress(fibExternalIp).setServiceId(label)
.setIpAddressSource(CreateFibEntryInput.IpAddressSource.FloatingIP)
.setInstruction(customInstructions).build();
- //Future<RpcResult<java.lang.Void>> createFibEntry(CreateFibEntryInput input);
- Future<RpcResult<Void>> future1 = fibService.createFibEntry(input);
- LOG.debug("onAddFloatingIp : Add Floating Ip {} , found associated to fixed port {}",
- externalIp, interfaceName);
- String networkVpnName = NatUtil.getAssociatedVPN(dataBroker, networkId);
- txRunner.callWithNewWriteOnlyTransactionAndSubmit(tx -> {
- vpnManager.addSubnetMacIntoVpnInstance(networkVpnName, subnetVpnName,
- floatingIpPortMacAddress, dpnId, tx);
- vpnManager.addArpResponderFlowsToExternalNetworkIps(routerUuid,
- Collections.singleton(externalIp),
- floatingIpPortMacAddress, dpnId, networkId, tx);
- });
- return JdkFutureAdapters.listenInPoolThread(future1);
- } else {
- String errMsg = String.format("onAddFloatingIp : Could not retrieve the label for prefix %s "
- + "in VPN %s, %s", externalIp, vpnName, result.getErrors());
- LOG.error(errMsg);
- return Futures.immediateFailedFuture(new RuntimeException(errMsg));
- }
- }, MoreExecutors.directExecutor());
+ //Future<RpcResult<java.lang.Void>> createFibEntry(CreateFibEntryInput input);
+ ListenableFuture<RpcResult<CreateFibEntryOutput>> future1 = fibService.createFibEntry(input);
+ LOG.debug("onAddFloatingIp : Add Floating Ip {} , found associated to fixed port {}",
+ externalIp, interfaceName);
+ String networkVpnName = NatUtil.getAssociatedVPN(dataBroker, networkId);
+ txRunner.callWithNewWriteOnlyTransactionAndSubmit(tx -> {
+ vpnManager.addSubnetMacIntoVpnInstance(networkVpnName, subnetVpnName,
+ floatingIpPortMacAddress, dpnId, tx);
+ vpnManager.addArpResponderFlowsToExternalNetworkIps(routerUuid,
+ Collections.singleton(externalIp),
+ floatingIpPortMacAddress, dpnId, networkId, tx);
+ });
+ return future1;
+ } else {
+ String errMsg = String.format("onAddFloatingIp : Could not retrieve the label for prefix %s "
+ + "in VPN %s, %s", externalIp, vpnName, result.getErrors());
+ LOG.error(errMsg);
+ return Futures.immediateFailedFuture(new RuntimeException(errMsg));
+ }
+ }, MoreExecutors.directExecutor());
- Futures.addCallback(future, new FutureCallback<RpcResult<Void>>() {
+ Futures.addCallback(future, new FutureCallback<RpcResult<CreateFibEntryOutput>>() {
@Override
public void onFailure(@Nonnull Throwable error) {
}
@Override
- public void onSuccess(@Nonnull RpcResult<Void> result) {
+ public void onSuccess(@Nonnull RpcResult<CreateFibEntryOutput> result) {
if (result.isSuccessful()) {
LOG.info("onAddFloatingIp : Successfully installed custom FIB routes for prefix {}", externalIp);
} else {
RemoveFibEntryInput input = new RemoveFibEntryInputBuilder().setVpnName(vpnName)
.setSourceDpid(dpnId).setIpAddress(fibExternalIp).setServiceId(label)
.setIpAddressSource(RemoveFibEntryInput.IpAddressSource.FloatingIP).build();
- Future<RpcResult<Void>> future = fibService.removeFibEntry(input);
+ ListenableFuture<RpcResult<RemoveFibEntryOutput>> future = fibService.removeFibEntry(input);
- ListenableFuture<RpcResult<Void>> labelFuture = Futures.transformAsync(
- JdkFutureAdapters.listenInPoolThread(future),
- (AsyncFunction<RpcResult<Void>, RpcResult<Void>>) result -> {
- //Release label
- if (result.isSuccessful()) {
+ ListenableFuture<RpcResult<RemoveVpnLabelOutput>> labelFuture = Futures.transformAsync(future, result -> {
+ //Release label
+ if (result.isSuccessful()) {
/* check if any floating IP information is available in vpn-to-dpn-list for given dpn id. If exist any
* floating IP then do not remove INTERNAL_TUNNEL_TABLE (table=36) -> PDNAT_TABLE (table=25) flow entry
*/
- Boolean removeTunnelFlow = Boolean.TRUE;
- if (NatUtil.isOpenStackVniSemanticsEnforcedForGreAndVxlan(elanService, provType)) {
- if (NatUtil.isFloatingIpPresentForDpn(dataBroker, dpnId, rd, vpnName, externalIp, false)) {
- removeTunnelFlow = Boolean.FALSE;
- }
- }
- if (removeTunnelFlow) {
- removeTunnelTableEntry(dpnId, label, removeFlowInvTx);
+ Boolean removeTunnelFlow = Boolean.TRUE;
+ if (NatUtil.isOpenStackVniSemanticsEnforcedForGreAndVxlan(elanService, provType)) {
+ if (NatUtil.isFloatingIpPresentForDpn(dataBroker, dpnId, rd, vpnName, externalIp, false)) {
+ removeTunnelFlow = Boolean.FALSE;
}
- removeLFibTableEntry(dpnId, label, removeFlowInvTx);
- RemoveVpnLabelInput labelInput = new RemoveVpnLabelInputBuilder()
- .setVpnName(vpnName).setIpPrefix(externalIp).build();
- Future<RpcResult<Void>> labelFuture1 = vpnService.removeVpnLabel(labelInput);
- return JdkFutureAdapters.listenInPoolThread(labelFuture1);
- } else {
- String errMsg = String.format("onRemoveFloatingIp :RPC call to remove custom FIB entries "
- + "on dpn %s for prefix %s Failed - %s", dpnId, externalIp, result.getErrors());
- LOG.error(errMsg);
- return Futures.immediateFailedFuture(new RuntimeException(errMsg));
}
- }, MoreExecutors.directExecutor());
+ if (removeTunnelFlow) {
+ removeTunnelTableEntry(dpnId, label, removeFlowInvTx);
+ }
+ removeLFibTableEntry(dpnId, label, removeFlowInvTx);
+ RemoveVpnLabelInput labelInput = new RemoveVpnLabelInputBuilder()
+ .setVpnName(vpnName).setIpPrefix(externalIp).build();
+ return vpnService.removeVpnLabel(labelInput);
+ } else {
+ String errMsg = String.format("onRemoveFloatingIp :RPC call to remove custom FIB entries "
+ + "on dpn %s for prefix %s Failed - %s", dpnId, externalIp, result.getErrors());
+ LOG.error(errMsg);
+ return Futures.immediateFailedFuture(new RuntimeException(errMsg));
+ }
+ }, MoreExecutors.directExecutor());
- Futures.addCallback(labelFuture, new FutureCallback<RpcResult<Void>>() {
+ Futures.addCallback(labelFuture, new FutureCallback<RpcResult<RemoveVpnLabelOutput>>() {
@Override
public void onFailure(@Nonnull Throwable error) {
}
@Override
- public void onSuccess(@Nonnull RpcResult<Void> result) {
+ public void onSuccess(@Nonnull RpcResult<RemoveVpnLabelOutput> result) {
if (result.isSuccessful()) {
LOG.debug("onRemoveFloatingIp : Successfully removed the label for the prefix {} from VPN {}",
externalIp, vpnName);
package org.opendaylight.netvirt.natservice.rpcservice;
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 javax.inject.Inject;
import javax.inject.Singleton;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.yangtools.yang.common.RpcError;
import org.opendaylight.yangtools.yang.common.RpcResult;
import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
-
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
}
@Override
- public Future<RpcResult<GetNatTranslationsOnVpnOutput>> getNatTranslationsOnVpn(
+ public ListenableFuture<RpcResult<GetNatTranslationsOnVpnOutput>> getNatTranslationsOnVpn(
GetNatTranslationsOnVpnInput input) {
RpcResultBuilder<GetNatTranslationsOnVpnOutput> rpcResultBuilder = null;
input.getVpnUuid().getValue());
rpcResultBuilder = RpcResultBuilder.<GetNatTranslationsOnVpnOutput>failed()
.withError(RpcError.ErrorType.APPLICATION, errMsg);
- return Futures.immediateFuture(rpcResultBuilder.build());
+ return rpcResultBuilder.buildFuture();
}
List<RouterNat> natRouterList = new ArrayList<>();
for (Uuid routerUuid : routerUuidList) {
}
@Override
- public Future<RpcResult<GetNatTranslationsOnRouterOutput>> getNatTranslationsOnRouter(
+ public ListenableFuture<RpcResult<GetNatTranslationsOnRouterOutput>> getNatTranslationsOnRouter(
GetNatTranslationsOnRouterInput input) {
RpcResultBuilder<GetNatTranslationsOnRouterOutput> rpcResultBuilder = null;
long routerId = NatUtil.getVpnId(dataBroker, input.getRouterUuid().getValue());
input.getRouterUuid().getValue());
rpcResultBuilder = RpcResultBuilder.<GetNatTranslationsOnRouterOutput>failed()
.withError(RpcError.ErrorType.APPLICATION, errMsg);
- return Futures.immediateFuture(rpcResultBuilder.build());
+ return rpcResultBuilder.buildFuture();
}
List<RouterNat> routerNatList = constructNatInformation(input.getRouterUuid(), routerId);
.setRouterNat(routerNatList);
rpcResultBuilder = RpcResultBuilder.success();
rpcResultBuilder.withResult(output.build());
- return Futures.immediateFuture(rpcResultBuilder.build());
+ return rpcResultBuilder.buildFuture();
}
- public Future<RpcResult<GetNatTranslationsForNetworkAndIpaddressOutput>> getNatTranslationsForNetworkAndIpaddress(
- GetNatTranslationsForNetworkAndIpaddressInput input) {
+ @Override
+ public ListenableFuture<RpcResult<GetNatTranslationsForNetworkAndIpaddressOutput>>
+ getNatTranslationsForNetworkAndIpaddress(GetNatTranslationsForNetworkAndIpaddressInput input) {
String ipAddress = String.valueOf(input.getIpAddress().getValue());
RpcResultBuilder<GetNatTranslationsForNetworkAndIpaddressOutput> rpcResultBuilder = null;
input.getNetworkUuid().getValue());
rpcResultBuilder = RpcResultBuilder.<GetNatTranslationsForNetworkAndIpaddressOutput>failed()
.withError(RpcError.ErrorType.APPLICATION, errMsg);
- return Futures.immediateFuture(rpcResultBuilder.build());
+ return rpcResultBuilder.buildFuture();
}
Subnet subNet = null;
Boolean isIpInSubnet = Boolean.FALSE;
+ " of Network {%s}", ipAddress, input.getNetworkUuid().getValue());
rpcResultBuilder = RpcResultBuilder.<GetNatTranslationsForNetworkAndIpaddressOutput>failed()
.withError(RpcError.ErrorType.APPLICATION, errMsg);
- return Futures.immediateFuture(rpcResultBuilder.build());
+ return rpcResultBuilder.buildFuture();
}
Subnetmap subnetMap = NatUtil.getSubnetMap(dataBroker, subNet.getUuid());
.setNatTranslation("DNAT");
rpcResultBuilder = RpcResultBuilder.success();
rpcResultBuilder.withResult(output.build());
- return Futures.immediateFuture(rpcResultBuilder.build());
+ return rpcResultBuilder.buildFuture();
}
}
}
.setProtocol(protocolType.getProtocol().getName());
rpcResultBuilder = RpcResultBuilder.success();
rpcResultBuilder.withResult(output.build());
- return Futures.immediateFuture(rpcResultBuilder.build());
+ return rpcResultBuilder.buildFuture();
}
}
}
String errMsg = String.format("404 Not Found - No NAT Translation found for IP {%s}", ipAddress);
rpcResultBuilder = RpcResultBuilder.<GetNatTranslationsForNetworkAndIpaddressOutput>failed()
.withError(RpcError.ErrorType.APPLICATION, errMsg);
- return Futures.immediateFuture(rpcResultBuilder.build());
+ return rpcResultBuilder.buildFuture();
}
private List<RouterNat> constructNatInformation(Uuid routerUuid, long routerId) {
natRouterList.add(natRouterBuilder.build());
return natRouterList;
}
-}
\ No newline at end of file
+}
import org.opendaylight.netvirt.natservice.internal.IPAddress;
import org.opendaylight.netvirt.natservice.internal.NaptManager;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.CreateIdPoolInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.CreateIdPoolOutputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.IdManagerService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.IntextIpMap;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.intext.ip.map.IpMapping;
public void init() {
MockitoAnnotations.initMocks(this);
naptManager = new NaptManager(dataBroker, idMgr);
- when(idMgr.createIdPool(any(CreateIdPoolInput.class)))
- .thenReturn(Futures.immediateFuture(RpcResultBuilder.<Void>success().build()));
+ when(idMgr.createIdPool(any(CreateIdPoolInput.class))).thenReturn(
+ Futures.immediateFuture(RpcResultBuilder.success(new CreateIdPoolOutputBuilder().build()).build()));
PowerMockito.mockStatic(MDSALUtil.class);
}
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
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.netvirt.neutronvpn.rev150602.vpnmaps.VpnMap;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.bgpvpns.rev150903.BgpvpnTypeBase;
.setLow(NeutronConstants.RD_IDPOOL_START)
.setHigh(new BigInteger(NeutronConstants.RD_IDPOOL_SIZE).longValue()).build();
try {
- Future<RpcResult<Void>> result = idManager.createIdPool(createPool);
+ Future<RpcResult<CreateIdPoolOutput>> result = idManager.createIdPool(createPool);
if (result != null && result.get().isSuccessful()) {
LOG.info("Created IdPool for Bgpvpn RD");
} else {
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.MoreExecutors;
import com.google.common.util.concurrent.SettableFuture;
-
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.AssociateNetworksOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.AssociateNetworksOutputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.AssociateRouterInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.AssociateRouterOutput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.AssociateRouterOutputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.CreateEVPNInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.CreateEVPNOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.CreateL3VPNInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.DissociateNetworksOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.DissociateNetworksOutputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.DissociateRouterInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.DissociateRouterOutput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.DissociateRouterOutputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.GetEVPNInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.GetEVPNOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.GetFixedIPsForNeutronPortInput;
@Override
// TODO Clean up the exception handling
@SuppressWarnings("checkstyle:IllegalCatch")
- public Future<RpcResult<CreateL3VPNOutput>> createL3VPN(CreateL3VPNInput input) {
+ public ListenableFuture<RpcResult<CreateL3VPNOutput>> createL3VPN(CreateL3VPNInput input) {
CreateL3VPNOutputBuilder opBuilder = new CreateL3VPNOutputBuilder();
SettableFuture<RpcResult<CreateL3VPNOutput>> result = SettableFuture.create();
* It handles the invocations to the neutronvpn:getL3VPN RPC method.
*/
@Override
- public Future<RpcResult<GetL3VPNOutput>> getL3VPN(GetL3VPNInput input) {
+ public ListenableFuture<RpcResult<GetL3VPNOutput>> getL3VPN(GetL3VPNInput input) {
GetL3VPNOutputBuilder opBuilder = new GetL3VPNOutputBuilder();
SettableFuture<RpcResult<GetL3VPNOutput>> result = SettableFuture.create();
* It handles the invocations to the neutronvpn:deleteL3VPN RPC method.
*/
@Override
- public Future<RpcResult<DeleteL3VPNOutput>> deleteL3VPN(DeleteL3VPNInput input) {
+ public ListenableFuture<RpcResult<DeleteL3VPNOutput>> deleteL3VPN(DeleteL3VPNInput input) {
DeleteL3VPNOutputBuilder opBuilder = new DeleteL3VPNOutputBuilder();
SettableFuture<RpcResult<DeleteL3VPNOutput>> result = SettableFuture.create();
}
LOG.info("associateNetworksToVpn: update VPN {} with networks list: {}", vpnId.getValue(),
passedNwList.toString());
- updateVpnMaps(vpnId, null, null, null, new ArrayList<Uuid>(passedNwList));
+ updateVpnMaps(vpnId, null, null, null, new ArrayList<>(passedNwList));
return failedNwList;
}
continue;
}
updateVpnInternetForSubnet(sm, vpnId, true);
- if (!(vpnOpDataEntry.isIpv6Configured())
- && (NeutronvpnUtils.getIpVersionFromString(sm.getSubnetIp()) == IpVersionChoice.IPV6)) {
+ if (!vpnOpDataEntry.isIpv6Configured()
+ && NeutronvpnUtils.getIpVersionFromString(sm.getSubnetIp()) == IpVersionChoice.IPV6) {
LOG.info("associateExtNetworkToVpn: add IPv6 Internet default route in VPN {}", vpnId.getValue());
neutronvpnUtils.updateVpnInstanceWithFallback(vpnId.getValue(), true);
}
}
LOG.info("dissociateNetworksFromVpn: Withdraw networks list {} from VPN {}", networks.toString(),
vpnId.getValue());
- clearFromVpnMaps(vpnId, null, new ArrayList<Uuid>(passedNwList));
+ clearFromVpnMaps(vpnId, null, new ArrayList<>(passedNwList));
return failedNwList;
}
@Override
// TODO Clean up the exception handling
@SuppressWarnings("checkstyle:IllegalCatch")
- public Future<RpcResult<AssociateNetworksOutput>> associateNetworks(AssociateNetworksInput input) {
+ public
ListenableFuture<RpcResult<AssociateNetworksOutput>> associateNetworks(AssociateNetworksInput input) {
AssociateNetworksOutputBuilder opBuilder = new AssociateNetworksOutputBuilder();
SettableFuture<RpcResult<AssociateNetworksOutput>> result = SettableFuture.create();
@Override
// TODO Clean up the exception handling
@SuppressWarnings("checkstyle:IllegalCatch")
- public Future<RpcResult<Void>> associateRouter(AssociateRouterInput input) {
+ public ListenableFuture<RpcResult<AssociateRouterOutput>> associateRouter(AssociateRouterInput input) {
- SettableFuture<RpcResult<Void>> result = SettableFuture.create();
+ SettableFuture<RpcResult<AssociateRouterOutput>> result = SettableFuture.create();
LOG.debug("associateRouter {}", input);
StringBuilder returnMsg = new StringBuilder();
Uuid vpnId = input.getVpnId();
returnMsg.append("VPN not found : ").append(vpnId.getValue());
}
if (returnMsg.length() != 0) {
- result.set(RpcResultBuilder.<Void>failed().withWarning(ErrorType.PROTOCOL, "invalid-value",
- formatAndLog(LOG::error, "associate router to vpn {} failed due to {}", routerId.getValue(),
- returnMsg)).build());
+ result.set(RpcResultBuilder.<AssociateRouterOutput>failed().withWarning(ErrorType.PROTOCOL,
+ "invalid-value", formatAndLog(LOG::error,
+ "associate router to vpn {} failed due to {}", routerId.getValue(),returnMsg)).build());
} else {
- result.set(RpcResultBuilder.<Void>success().build());
+ result.set(RpcResultBuilder.success(new AssociateRouterOutputBuilder().build()).build());
}
} catch (Exception ex) {
- result.set(RpcResultBuilder.<Void>failed().withError(ErrorType.APPLICATION,
+ result.set(RpcResultBuilder.<AssociateRouterOutput>failed().withError(ErrorType.APPLICATION,
formatAndLog(LOG::error, "associate router {} to vpn {} failed due to {}", routerId.getValue(),
vpnId.getValue(), ex.getMessage(), ex)).build());
}
@Override
// TODO Clean up the exception handling
@SuppressWarnings("checkstyle:IllegalCatch")
- public Future<RpcResult<GetFixedIPsForNeutronPortOutput>> getFixedIPsForNeutronPort(
+ public ListenableFuture<RpcResult<GetFixedIPsForNeutronPortOutput>> getFixedIPsForNeutronPort(
GetFixedIPsForNeutronPortInput input) {
GetFixedIPsForNeutronPortOutputBuilder opBuilder = new GetFixedIPsForNeutronPortOutputBuilder();
SettableFuture<RpcResult<GetFixedIPsForNeutronPortOutput>> result = SettableFuture.create();
@Override
// TODO Clean up the exception handling
@SuppressWarnings("checkstyle:IllegalCatch")
- public Future<RpcResult<DissociateNetworksOutput>> dissociateNetworks(DissociateNetworksInput input) {
+ public ListenableFuture<RpcResult<DissociateNetworksOutput>> dissociateNetworks(DissociateNetworksInput input) {
DissociateNetworksOutputBuilder opBuilder = new DissociateNetworksOutputBuilder();
SettableFuture<RpcResult<DissociateNetworksOutput>> result = SettableFuture.create();
@Override
// TODO Clean up the exception handling
@SuppressWarnings("checkstyle:IllegalCatch")
- public Future<RpcResult<Void>> dissociateRouter(DissociateRouterInput input) {
+ public ListenableFuture<RpcResult<DissociateRouterOutput>> dissociateRouter(DissociateRouterInput input) {
- SettableFuture<RpcResult<Void>> result = SettableFuture.create();
+ SettableFuture<RpcResult<DissociateRouterOutput>> result = SettableFuture.create();
LOG.debug("dissociateRouter {}", input);
StringBuilder returnMsg = new StringBuilder();
returnMsg.append("VPN not found : ").append(vpnId.getValue());
}
if (returnMsg.length() != 0) {
- result.set(RpcResultBuilder.<Void>failed().withWarning(ErrorType.PROTOCOL, "invalid-value",
- formatAndLog(LOG::error, "dissociate router {} to vpn {} failed due to {}", routerId.getValue(),
- vpnId.getValue(), returnMsg)).build());
+ result.set(RpcResultBuilder.<DissociateRouterOutput>failed().withWarning(ErrorType.PROTOCOL,
+ "invalid-value", formatAndLog(LOG::error, "dissociate router {} to vpn {} failed due to {}",
+ routerId.getValue(), vpnId.getValue(), returnMsg)).build());
} else {
- result.set(RpcResultBuilder.<Void>success().build());
+ result.set(RpcResultBuilder.success(new DissociateRouterOutputBuilder().build()).build());
}
} catch (Exception ex) {
- result.set(RpcResultBuilder.<Void>failed().withError(ErrorType.APPLICATION,
+ result.set(RpcResultBuilder.<DissociateRouterOutput>failed().withError(ErrorType.APPLICATION,
formatAndLog(LOG::error, "disssociate router {} to vpn {} failed due to {}", routerId.getValue(),
vpnId.getValue(), ex.getMessage(), ex)).build());
}
}
@Override
- public Future<RpcResult<CreateEVPNOutput>> createEVPN(CreateEVPNInput input) {
+ public ListenableFuture<RpcResult<CreateEVPNOutput>> createEVPN(CreateEVPNInput input) {
return neutronEvpnManager.createEVPN(input);
}
@Override
- public Future<RpcResult<GetEVPNOutput>> getEVPN(GetEVPNInput input) {
+ public ListenableFuture<RpcResult<GetEVPNOutput>> getEVPN(GetEVPNInput input) {
return neutronEvpnManager.getEVPN(input);
}
@Override
- public Future<RpcResult<DeleteEVPNOutput>> deleteEVPN(DeleteEVPNInput input) {
+ public ListenableFuture<RpcResult<DeleteEVPNOutput>> deleteEVPN(DeleteEVPNInput input) {
return neutronEvpnManager.deleteEVPN(input);
}
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.netvirt.aclservice.rev160608.Dhcpv6Base;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.aclservice.rev160608.InterfaceAclBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.aclservice.rev160608.IpPrefixOrAddress;
private final ManagedNewTransactionRunner txRunner;
private final IdManagerService idManager;
private final JobCoordinator jobCoordinator;
- private IPV6InternetDefaultRouteProgrammer ipV6InternetDefRt;
+ private final IPV6InternetDefaultRouteProgrammer ipV6InternetDefRt;
@Inject
public NeutronvpnUtils(final DataBroker dataBroker, final IdManagerService idManager,
protected void releaseRDId(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();
+ RpcResult<ReleaseIdOutput> rpcResult = idManager.releaseId(idInput).get();
if (!rpcResult.isSuccessful()) {
LOG.error("RPC Call to Get Unique Id returned with errors for poolname {} and ID Key {}: {}",
poolName, idKey, rpcResult.getErrors());
InstanceIdentifier<VpnInstance> id = InstanceIdentifier.builder(VpnInstances.class).child(VpnInstance.class,
new VpnInstanceKey(vpnId.getValue())).build();
Optional<VpnInstance> vpnInstance = read(LogicalDatastoreType.CONFIGURATION, id);
- return (vpnInstance.isPresent()) ? vpnInstance.get() : null;
+ return vpnInstance.isPresent() ? vpnInstance.get() : null;
}
/**
package org.opendaylight.netvirt.neutronvpn.evpn.manager;
import com.google.common.base.Optional;
+import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.SettableFuture;
import java.util.ArrayList;
import java.util.List;
-import java.util.concurrent.Future;
import java.util.function.Consumer;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
}
@SuppressWarnings("checkstyle:IllegalCatch")
- public Future<RpcResult<CreateEVPNOutput>> createEVPN(CreateEVPNInput input) {
+ public ListenableFuture<RpcResult<CreateEVPNOutput>> createEVPN(CreateEVPNInput input) {
CreateEVPNOutputBuilder opBuilder = new CreateEVPNOutputBuilder();
SettableFuture<RpcResult<CreateEVPNOutput>> result = SettableFuture.create();
List<RpcError> errorList = new ArrayList<>();
errorResponseList.add("EVPN creation successful with no errors");
}
opBuilder.setResponse(errorResponseList);
- result.set(RpcResultBuilder.<CreateEVPNOutput>success().withResult(opBuilder.build()).build());
+ result.set(RpcResultBuilder.success(opBuilder.build()).build());
}
return result;
}
- public Future<RpcResult<GetEVPNOutput>> getEVPN(GetEVPNInput input) {
+ public ListenableFuture<RpcResult<GetEVPNOutput>> getEVPN(GetEVPNInput input) {
GetEVPNOutputBuilder opBuilder = new GetEVPNOutputBuilder();
SettableFuture<RpcResult<GetEVPNOutput>> result = SettableFuture.create();
Uuid inputVpnId = input.getId();
}
} else {
// No VPN present
- result.set(RpcResultBuilder.<GetEVPNOutput>success().withResult(opBuilder.build()).build());
+ result.set(RpcResultBuilder.success(opBuilder.build()).build());
return result;
}
} else {
}
opBuilder.setEvpnInstances(evpnList);
- result.set(RpcResultBuilder.<GetEVPNOutput>success().withResult(opBuilder.build()).build());
+ result.set(RpcResultBuilder.success(opBuilder.build()).build());
return result;
}
- public Future<RpcResult<DeleteEVPNOutput>> deleteEVPN(DeleteEVPNInput input) {
+ public ListenableFuture<RpcResult<DeleteEVPNOutput>> deleteEVPN(DeleteEVPNInput input) {
DeleteEVPNOutputBuilder opBuilder = new DeleteEVPNOutputBuilder();
SettableFuture<RpcResult<DeleteEVPNOutput>> result = SettableFuture.create();
List<RpcError> errorList = new ArrayList<>();
errorResponseList.add("Deletion of EVPN operation successful");
}
opBuilder.setResponse(errorResponseList);
- result.set(RpcResultBuilder.<DeleteEVPNOutput>success().withResult(opBuilder.build()).build());
+ result.set(RpcResultBuilder.success(opBuilder.build()).build());
}
return result;
}
package org.opendaylight.netvirt.neutronvpn.l2gw;
import java.util.concurrent.ExecutionException;
-import java.util.concurrent.Future;
import org.opendaylight.genius.utils.hwvtep.HwvtepSouthboundConstants;
import org.opendaylight.genius.utils.hwvtep.HwvtepSouthboundUtils;
import org.opendaylight.netvirt.neutronvpn.api.l2gw.L2GatewayDevice;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
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.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.ItmRpcService;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;
import org.opendaylight.yangtools.yang.common.RpcResult;
private L2GatewayUtils() { }
protected static boolean isGatewayAssociatedToL2Device(L2GatewayDevice l2GwDevice) {
- return (l2GwDevice.getL2GatewayIds().size() > 0);
+ return l2GwDevice.getL2GatewayIds().size() > 0;
}
protected static boolean isLastL2GatewayBeingDeleted(L2GatewayDevice l2GwDevice) {
- return (l2GwDevice.getL2GatewayIds().size() == 1);
+ return l2GwDevice.getL2GatewayIds().size() == 1;
}
protected static boolean isItmTunnelsCreatedForL2Device(L2GatewayDevice l2GwDevice) {
- return (l2GwDevice.getHwvtepNodeId() != null && l2GwDevice.getL2GatewayIds().size() > 0);
+ return l2GwDevice.getHwvtepNodeId() != null && l2GwDevice.getL2GatewayIds().size() > 0;
}
protected static void createItmTunnels(ItmRpcService itmRpcService, String hwvtepId, String psName,
builder.setNodeId(HwvtepSouthboundUtils.createManagedNodeId(new NodeId(hwvtepId), psName).getValue());
builder.setIpAddress(tunnelIp);
try {
- Future<RpcResult<Void>> result = itmRpcService.addL2GwDevice(builder.build());
- RpcResult<Void> rpcResult = result.get();
+ RpcResult<AddL2GwDeviceOutput> rpcResult = itmRpcService.addL2GwDevice(builder.build()).get();
if (rpcResult.isSuccessful()) {
LOG.info("Created ITM tunnels for {}", hwvtepId);
} else {
builder.setNodeId(HwvtepSouthboundUtils.createManagedNodeId(new NodeId(hwvtepId), psName).getValue());
builder.setIpAddress(tunnelIp);
try {
- Future<RpcResult<Void>> result = itmRpcService.deleteL2GwDevice(builder.build());
- RpcResult<Void> rpcResult = result.get();
+ RpcResult<DeleteL2GwDeviceOutput> rpcResult = itmRpcService.deleteL2GwDevice(builder.build()).get();
if (rpcResult.isSuccessful()) {
LOG.info("Deleted ITM tunnels for {}", hwvtepId);
} else {
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.math.BigInteger;
import java.util.ArrayList;
import java.util.List;
-import java.util.concurrent.Future;
import org.mockito.Mockito;
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.Ipv4Address;
}
@Override
- public Future<RpcResult<GetEndpointIpForDpnOutput>> getEndpointIpForDpn(GetEndpointIpForDpnInput input) {
+ public ListenableFuture<RpcResult<GetEndpointIpForDpnOutput>> getEndpointIpForDpn(GetEndpointIpForDpnInput input) {
BigInteger dpnId = input.getDpid();
// if the dpnId is DPN_ID_NO_EXIST, then an empty response will be returned
localIpList.add(new IpAddress(new Ipv4Address(GeniusProviderTestParams.IPV4_ADDRESS_STR)));
builder.setLocalIps(localIpList);
} else if (dpnId == GeniusProviderTestParams.DPN_ID_INVALID) {
- return Futures.immediateFuture(RpcResultBuilder.<GetEndpointIpForDpnOutput>failed()
- .withError(ErrorType.APPLICATION, "Invalid data.").build());
+ return RpcResultBuilder.<GetEndpointIpForDpnOutput>failed()
+ .withError(ErrorType.APPLICATION, "Invalid data.").buildFuture();
}
- return Futures.immediateFuture(RpcResultBuilder
- .<GetEndpointIpForDpnOutput>success(builder.build()).build());
+ return RpcResultBuilder.success(builder.build()).buildFuture();
}
@Override
- public Future<RpcResult<GetDpidFromInterfaceOutput>> getDpidFromInterface(GetDpidFromInterfaceInput input) {
+ public ListenableFuture<RpcResult<GetDpidFromInterfaceOutput>> getDpidFromInterface(
+ GetDpidFromInterfaceInput input) {
String ifName = input.getIntfName();
// if the ifName is INTERFACE_NAME_NO_EXIST, then an empty response will be returned
if (ifName == GeniusProviderTestParams.INTERFACE_NAME) {
builder.setDpid(GeniusProviderTestParams.DPN_ID);
} else if (ifName == GeniusProviderTestParams.INTERFACE_NAME_INVALID) {
- return Futures.immediateFuture(RpcResultBuilder.<GetDpidFromInterfaceOutput>failed()
- .withError(ErrorType.APPLICATION, "Invalid data.").build());
+ return RpcResultBuilder.<GetDpidFromInterfaceOutput>failed()
+ .withError(ErrorType.APPLICATION, "Invalid data.").buildFuture();
}
- return Futures.immediateFuture(RpcResultBuilder
- .<GetDpidFromInterfaceOutput>success(builder.build()).build());
+ return RpcResultBuilder.success(builder.build()).buildFuture();
}
@Override
- public Future<RpcResult<GetNodeconnectorIdFromInterfaceOutput>>
+ public ListenableFuture<RpcResult<GetNodeconnectorIdFromInterfaceOutput>>
getNodeconnectorIdFromInterface(GetNodeconnectorIdFromInterfaceInput input) {
String ifName = input.getIntfName();
GeniusProviderTestParams.NODE_CONNECTOR_ID_PREFIX
+ GeniusProviderTestParams.INTERFACE_NAME));
} else if (ifName == GeniusProviderTestParams.INTERFACE_NAME_INVALID) {
- return Futures.immediateFuture(RpcResultBuilder.<GetNodeconnectorIdFromInterfaceOutput>failed()
- .withError(ErrorType.APPLICATION, "Invalid data.").build());
+ return RpcResultBuilder.<GetNodeconnectorIdFromInterfaceOutput>failed()
+ .withError(ErrorType.APPLICATION, "Invalid data.").buildFuture();
}
- return Futures.immediateFuture(RpcResultBuilder
- .<GetNodeconnectorIdFromInterfaceOutput>success(builder.build()).build());
+ return RpcResultBuilder.success(builder.build()).buildFuture();
}
}
import com.google.common.util.concurrent.CheckedFuture;
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 com.google.common.util.concurrent.MoreExecutors;
import com.google.common.util.concurrent.SettableFuture;
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import javax.annotation.Nonnull;
-
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
import org.opendaylight.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.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.inventory.rev130819.NodeConnectorId;
@Override
@SuppressWarnings("checkstyle:illegalCatch")
- public Future<RpcResult<GetNodeCountersOutput>> getNodeCounters(GetNodeCountersInput input) {
+ public ListenableFuture<RpcResult<GetNodeCountersOutput>> getNodeCounters(GetNodeCountersInput input) {
BigInteger dpId = input.getNodeId();
LOG.trace("getting node counters for node {}", dpId);
GetNodeCountersOutputBuilder gncob = new GetNodeCountersOutputBuilder();
@Override
@SuppressWarnings("checkstyle:illegalCatch")
- public Future<RpcResult<GetNodeAggregatedCountersOutput>> getNodeAggregatedCounters(
+ public ListenableFuture<RpcResult<GetNodeAggregatedCountersOutput>> getNodeAggregatedCounters(
GetNodeAggregatedCountersInput input) {
BigInteger dpId = input.getNodeId();
LOG.trace("getting aggregated node counters for node {}", dpId);
@Override
@SuppressWarnings("checkstyle:illegalCatch")
- public Future<RpcResult<GetNodeConnectorCountersOutput>> getNodeConnectorCounters(
+ public ListenableFuture<RpcResult<GetNodeConnectorCountersOutput>> getNodeConnectorCounters(
GetNodeConnectorCountersInput input) {
String portId = input.getPortId();
LOG.trace("getting port counters of port {}", portId);
}
@Override
- public Future<RpcResult<AcquireElementCountersRequestHandlerOutput>> acquireElementCountersRequestHandler(
+ public
ListenableFuture<RpcResult<AcquireElementCountersRequestHandlerOutput>> acquireElementCountersRequestHandler(
AcquireElementCountersRequestHandlerInput input) {
AcquireElementCountersRequestHandlerOutputBuilder aecrhob =
new AcquireElementCountersRequestHandlerOutputBuilder();
}
@Override
- public Future<RpcResult<ReleaseElementCountersRequestHandlerOutput>> releaseElementCountersRequestHandler(
+ public ListenableFuture<RpcResult<ReleaseElementCountersRequestHandlerOutput>> releaseElementCountersRequestHandler(
ReleaseElementCountersRequestHandlerInput input) {
InstanceIdentifier<CounterRequests> ingressPath =
InstanceIdentifier.builder(IngressElementCountersRequestConfig.class)
}
@Override
- public Future<RpcResult<GetElementCountersByHandlerOutput>> getElementCountersByHandler(
+ public ListenableFuture<RpcResult<GetElementCountersByHandlerOutput>> getElementCountersByHandler(
GetElementCountersByHandlerInput input) {
InstanceIdentifier<CounterRequests> ingressPath =
InstanceIdentifier.builder(IngressElementCountersRequestConfig.class)
}
@Override
- public Future<RpcResult<CleanAllElementCounterRequestsOutput>> cleanAllElementCounterRequests(
+ public ListenableFuture<RpcResult<CleanAllElementCounterRequestsOutput>> cleanAllElementCounterRequests(
CleanAllElementCounterRequestsInput input) {
ReadOnlyTransaction tx = db.newReadOnlyTransaction();
CheckedFuture<Optional<IngressElementCountersRequestConfig>, ReadFailedException> iecrc =
CreateIdPoolInput createPool = new CreateIdPoolInputBuilder()
.setPoolName(CountersServiceUtils.COUNTERS_PULL_NAME).setLow(CountersServiceUtils.COUNTERS_PULL_START)
.setHigh(CountersServiceUtils.COUNTERS_PULL_START + CountersServiceUtils.COUNTERS_PULL_END).build();
- Future<RpcResult<Void>> result = idManagerService.createIdPool(createPool);
- Futures.addCallback(JdkFutureAdapters.listenInPoolThread(result), new FutureCallback<RpcResult<Void>>() {
+ ListenableFuture<RpcResult<CreateIdPoolOutput>> result = idManagerService.createIdPool(createPool);
+ Futures.addCallback(result, new FutureCallback<RpcResult<CreateIdPoolOutput>>() {
@Override
public void onFailure(Throwable error) {
}
@Override
- public void onSuccess(@Nonnull RpcResult<Void> rpcResult) {
+ public void onSuccess(@Nonnull RpcResult<CreateIdPoolOutput> rpcResult) {
if (rpcResult.isSuccessful()) {
LOG.debug("Created IdPool for tap");
} else {
ReleaseIdInput idInput = new ReleaseIdInputBuilder().setPoolName(CountersServiceUtils.COUNTERS_PULL_NAME)
.setIdKey(idKey).build();
try {
- Future<RpcResult<Void>> result = idManagerService.releaseId(idInput);
- RpcResult<Void> rpcResult = result.get();
+ RpcResult<ReleaseIdOutput> rpcResult = idManagerService.releaseId(idInput).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.opendaylight.flow.types.rev131026.instruction.list.Instruction;
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.rpcs.rev160406.OdlInterfaceRpcService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.ItmRpcService;
.setHigh(VpnConstants.VPN_IDPOOL_HIGH)
.build();
try {
- Future<RpcResult<Void>> result = idManager.createIdPool(createPool);
+ Future<RpcResult<CreateIdPoolOutput>> result = idManager.createIdPool(createPool);
if (result != null && result.get().isSuccessful()) {
LOG.info("Created IdPool for VPN Service");
}
.setHigh(VpnConstants.UPPER_PSEUDO_LPORT_TAG)
.build();
try {
- Future<RpcResult<Void>> result = idManager.createIdPool(createPseudoLporTagPool);
+ Future<RpcResult<CreateIdPoolOutput>> result = idManager.createIdPool(createPseudoLporTagPool);
if (result.get().isSuccessful()) {
LOG.debug("Created IdPool for Pseudo Port tags");
} else {
ListenableFutures.addErrorLogging(listenableFuture, LOG,
"Error while configuring arp responder for ext. interface");
- return DataTreeEventCallbackRegistrar.NextAction.UNREGISTER; });
+ return DataTreeEventCallbackRegistrar.NextAction.UNREGISTER;
+ });
}
package org.opendaylight.netvirt.vpnmanager;
import com.google.common.base.Optional;
+import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.SettableFuture;
import java.util.ArrayList;
import java.util.Collection;
-import java.util.concurrent.Future;
import java.util.function.Consumer;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.vpn.rpc.rev160201.GenerateVpnLabelOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.vpn.rpc.rev160201.GenerateVpnLabelOutputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.vpn.rpc.rev160201.RemoveStaticRouteInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.vpn.rpc.rev160201.RemoveStaticRouteOutput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.vpn.rpc.rev160201.RemoveStaticRouteOutputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.vpn.rpc.rev160201.RemoveVpnLabelInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.vpn.rpc.rev160201.RemoveVpnLabelOutput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.vpn.rpc.rev160201.RemoveVpnLabelOutputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.vpn.rpc.rev160201.VpnRpcService;
import org.opendaylight.yangtools.yang.common.RpcError;
import org.opendaylight.yangtools.yang.common.RpcError.ErrorType;
* Generate label for the given ip prefix from the associated VPN.
*/
@Override
- public Future<RpcResult<GenerateVpnLabelOutput>> generateVpnLabel(GenerateVpnLabelInput input) {
+ public ListenableFuture<RpcResult<GenerateVpnLabelOutput>> generateVpnLabel(GenerateVpnLabelInput input) {
String vpnName = input.getVpnName();
String ipPrefix = input.getIpPrefix();
SettableFuture<RpcResult<GenerateVpnLabelOutput>> futureResult = SettableFuture.create();
* Remove label for the given ip prefix from the associated VPN.
*/
@Override
- public Future<RpcResult<Void>> removeVpnLabel(RemoveVpnLabelInput input) {
+ public ListenableFuture<RpcResult<RemoveVpnLabelOutput>> removeVpnLabel(RemoveVpnLabelInput input) {
String vpnName = input.getVpnName();
String ipPrefix = input.getIpPrefix();
String rd = VpnUtil.getVpnRd(dataBroker, vpnName);
- SettableFuture<RpcResult<Void>> futureResult = SettableFuture.create();
VpnUtil.releaseId(idManager, VpnConstants.VPN_IDPOOL_NAME,
VpnUtil.getNextHopLabelKey(rd != null ? rd : vpnName, ipPrefix));
- futureResult.set(RpcResultBuilder.<Void>success().build());
- return futureResult;
+ return RpcResultBuilder.success(new RemoveVpnLabelOutputBuilder().build()).buildFuture();
}
private Collection<RpcError> validateAddStaticRouteInput(AddStaticRouteInput input) {
// TODO Clean up the exception handling
@SuppressWarnings("checkstyle:IllegalCatch")
@Override
- public Future<RpcResult<AddStaticRouteOutput>> addStaticRoute(AddStaticRouteInput input) {
+ public
ListenableFuture<RpcResult<AddStaticRouteOutput>> addStaticRoute(AddStaticRouteInput input) {
SettableFuture<RpcResult<AddStaticRouteOutput>> result = SettableFuture.create();
String destination = input.getDestination();
}
@Override
- public Future<RpcResult<Void>> removeStaticRoute(RemoveStaticRouteInput input) {
+ public ListenableFuture<RpcResult<RemoveStaticRouteOutput>> removeStaticRoute(RemoveStaticRouteInput input) {
- SettableFuture<RpcResult<Void>> result = SettableFuture.create();
+ SettableFuture<RpcResult<RemoveStaticRouteOutput>> result = SettableFuture.create();
String destination = input.getDestination();
String vpnInstanceName = input.getVpnInstanceName();
destination, nexthop, vpnInstanceName);
Collection<RpcError> rpcErrors = validateRemoveStaticRouteInput(input);
if (!rpcErrors.isEmpty()) {
- result.set(RpcResultBuilder.<Void>failed().withRpcErrors(rpcErrors).build());
+ result.set(RpcResultBuilder.<RemoveStaticRouteOutput>failed().withRpcErrors(rpcErrors).build());
return result;
}
String vpnRd = VpnUtil.getVpnRd(dataBroker, input.getVpnInstanceName());
if (vpnRd == null) {
String message = "Could not find Route-Distinguisher for VpnName " + vpnInstanceName;
- result.set(RpcResultBuilder.<Void>failed().withError(RpcError.ErrorType.APPLICATION, message).build());
+ result.set(RpcResultBuilder.<RemoveStaticRouteOutput>failed()
+ .withError(RpcError.ErrorType.APPLICATION, message).build());
return result;
}
vpnManager.delExtraRoute(vpnInstanceName, destination,
nexthop, vpnRd, null /* routerId */, null /* intfName */, null);
}
- result.set(RpcResultBuilder.<Void>success().build());
+ result.set(RpcResultBuilder.success(new RemoveStaticRouteOutputBuilder().build()).build());
return result;
}
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.meta.rev160406.IfIndexesInterfaceMap;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.lockmanager.rev160413.TimeUnits;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.lockmanager.rev160413.TryLockInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.lockmanager.rev160413.TryLockInputBuilder;
+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.UnlockInputBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.lockmanager.rev160413.UnlockOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.ElanDpnInterfaces;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.ElanInterfaces;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.ElanTagNameMap;
public String get() {
long microSeconds = (System.nanoTime() - this.startNanoseconds) / 1000 ;
- long date = this.startDate + (microSeconds / 1000) ;
+ long date = this.startDate + microSeconds / 1000 ;
return this.dateFormat.format(date) + String.format("%03d", microSeconds % 1000) ;
}
}
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();
+ RpcResult<ReleaseIdOutput> rpcResult = idManager.releaseId(idInput).get();
if (!rpcResult.isSuccessful()) {
LOG.error("releaseId: RPC Call to release Id for key {} from pool {} returned with Errors {}",
idKey, poolName, rpcResult.getErrors());
public static void lockSubnet(LockManagerService lockManager, String subnetId) {
TryLockInput input =
new TryLockInputBuilder().setLockName(subnetId).setTime(3000L).setTimeUnit(TimeUnits.Milliseconds).build();
- Future<RpcResult<Void>> result = lockManager.tryLock(input);
+ Future<RpcResult<TryLockOutput>> result = lockManager.tryLock(input);
try {
if (result != null && result.get().isSuccessful()) {
LOG.debug("lockSubnet: Acquired lock for {}", subnetId);
@SuppressWarnings("checkstyle:AvoidHidingCauseException")
public static void unlockSubnet(LockManagerService lockManager, String subnetId) {
UnlockInput input = new UnlockInputBuilder().setLockName(subnetId).build();
- Future<RpcResult<Void>> result = lockManager.unlock(input);
+ Future<RpcResult<UnlockOutput>> result = lockManager.unlock(input);
try {
if (result != null && result.get().isSuccessful()) {
LOG.debug("unlockSubnet: Unlocked {}", subnetId);
}
public static Set<BigInteger> getDpnInElan(DataBroker dataBroker, Map<String,String> elanInstanceRouterPortMap) {
- Set<BigInteger> dpnIdSet = new HashSet<BigInteger>();
+ Set<BigInteger> dpnIdSet = new HashSet<>();
for (String elanInstanceName : elanInstanceRouterPortMap.keySet()) {
InstanceIdentifier<ElanDpnInterfacesList> elanDpnInterfaceId = getElanDpnOperationalDataPath(
elanInstanceName);
}
public static Map<String, String> getElanInstanceRouterPortMap(DataBroker dataBroker, String vpnName) {
- Map<String, String> elanInstanceRouterPortMap = new HashMap<String, String>();
+ Map<String, String> elanInstanceRouterPortMap = new HashMap<>();
Optional<Subnetmaps> subnetMapsData =
read(dataBroker, LogicalDatastoreType.CONFIGURATION, buildSubnetMapsWildCardPath());
if (subnetMapsData.isPresent()) {
Code Review / netvirt.git / commitdiff