*/
package org.opendaylight.genius.itm.rpc;
+import static org.opendaylight.genius.tools.mdsal.rpc.FutureRpcResults.LogLevel.ERROR;
+import static org.opendaylight.genius.tools.mdsal.rpc.FutureRpcResults.fromListenableFuture;
+import static org.opendaylight.yangtools.yang.common.RpcResultBuilder.failed;
+
import com.google.common.base.Objects;
import com.google.common.base.Optional;
import com.google.common.util.concurrent.FutureCallback;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
-import java.util.concurrent.Future;
import java.util.stream.Collectors;
+import javax.annotation.Nonnull;
import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import javax.inject.Inject;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
-import org.opendaylight.genius.infra.FutureRpcResults;
+import org.opendaylight.genius.interfacemanager.interfaces.IInterfaceManager;
+import org.opendaylight.genius.interfacemanager.interfaces.InterfaceManagerService;
import org.opendaylight.genius.itm.cache.DPNTEPsInfoCache;
+import org.opendaylight.genius.itm.cache.DpnTepStateCache;
+import org.opendaylight.genius.itm.cache.TunnelStateCache;
import org.opendaylight.genius.itm.confighelpers.ItmExternalTunnelAddWorker;
import org.opendaylight.genius.itm.confighelpers.ItmExternalTunnelDeleteWorker;
import org.opendaylight.genius.itm.globals.ITMConstants;
import org.opendaylight.genius.itm.impl.ItmUtils;
+import org.opendaylight.genius.itm.utils.DpnTepInterfaceInfo;
+import org.opendaylight.genius.mdsalutil.ActionInfo;
import org.opendaylight.genius.mdsalutil.MDSALUtil;
import org.opendaylight.genius.mdsalutil.MatchInfo;
import org.opendaylight.genius.mdsalutil.NwConstants;
+import org.opendaylight.genius.mdsalutil.actions.ActionOutput;
+import org.opendaylight.genius.mdsalutil.actions.ActionSetFieldTunnelId;
import org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager;
import org.opendaylight.genius.mdsalutil.matches.MatchTunnelId;
+import org.opendaylight.genius.tools.mdsal.rpc.FutureRpcResults;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddressBuilder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Uri;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.Action;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNode;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.Flow;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406.BridgeRefInfo;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.external.tunnel.list.ExternalTunnel;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.external.tunnel.list.ExternalTunnelKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.tunnel.list.InternalTunnel;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.tunnels_state.StateTunnelList;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.DcGatewayIpList;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.TransportZones;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.dc.gateway.ip.list.DcGatewayIp;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.transport.zone.subnets.DeviceVtepsKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.transport.zone.subnets.Vteps;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.AddExternalTunnelEndpointInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.AddExternalTunnelEndpointOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.AddL2GwDeviceInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.AddL2GwDeviceOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.AddL2GwMlagDeviceInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.AddL2GwMlagDeviceOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.BuildExternalTunnelFromDpnsInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.BuildExternalTunnelFromDpnsOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.CreateTerminatingServiceActionsInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.CreateTerminatingServiceActionsOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.DeleteL2GwDeviceInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.DeleteL2GwDeviceOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.DeleteL2GwMlagDeviceInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.DeleteL2GwMlagDeviceOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.GetDpnEndpointIpsInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.GetDpnEndpointIpsOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.GetDpnEndpointIpsOutputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.GetDpnInfoOutputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.GetEgressActionsForTunnelInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.GetEgressActionsForTunnelOutput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.GetEgressActionsForTunnelOutputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.GetExternalTunnelInterfaceNameInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.GetExternalTunnelInterfaceNameOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.GetExternalTunnelInterfaceNameOutputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.GetTunnelInterfaceNameOutputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.GetTunnelTypeInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.GetTunnelTypeOutput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.GetTunnelTypeOutputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.IsDcgwPresentInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.IsDcgwPresentOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.IsDcgwPresentOutputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.IsTunnelInternalOrExternalOutputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.ItmRpcService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.RemoveExternalTunnelEndpointInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.RemoveExternalTunnelEndpointOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.RemoveExternalTunnelFromDpnsInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.RemoveExternalTunnelFromDpnsOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.RemoveTerminatingServiceActionsInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.RemoveTerminatingServiceActionsOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.SetBfdEnableOnTunnelInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.SetBfdEnableOnTunnelOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.get.dpn.info.output.Computes;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.get.dpn.info.output.ComputesBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
public class ItmManagerRpcService implements ItmRpcService {
private static final Logger LOG = LoggerFactory.getLogger(ItmManagerRpcService.class);
+
private final DataBroker dataBroker;
private final IMdsalApiManager mdsalManager;
private final DPNTEPsInfoCache dpnTEPsInfoCache;
private final ItmExternalTunnelAddWorker externalTunnelAddWorker;
- private final ItmConfig itmConfig;
private final SingleTransactionDataBroker singleTransactionDataBroker;
+ private final IInterfaceManager interfaceManager;
+ private final InterfaceManagerService interfaceManagerService;
+ private final DpnTepStateCache dpnTepStateCache;
+ private final TunnelStateCache tunnelStateCache;
@Inject
public ItmManagerRpcService(final DataBroker dataBroker, final IMdsalApiManager mdsalManager,
- final ItmConfig itmConfig, final DPNTEPsInfoCache dpnTEPsInfoCache) {
+ final ItmConfig itmConfig, final DPNTEPsInfoCache dpnTEPsInfoCache,
+ final IInterfaceManager interfaceManager, final DpnTepStateCache dpnTepStateCache,
+ final TunnelStateCache tunnelStateCache,
+ final InterfaceManagerService interfaceManagerService) {
this.dataBroker = dataBroker;
this.mdsalManager = mdsalManager;
this.dpnTEPsInfoCache = dpnTEPsInfoCache;
this.externalTunnelAddWorker = new ItmExternalTunnelAddWorker(dataBroker, itmConfig, dpnTEPsInfoCache);
- this.itmConfig = itmConfig;
this.singleTransactionDataBroker = new SingleTransactionDataBroker(dataBroker);
+ this.interfaceManager = interfaceManager;
+ this.interfaceManagerService = interfaceManagerService;
+ this.dpnTepStateCache = dpnTepStateCache;
+ this.tunnelStateCache = tunnelStateCache;
}
@PostConstruct
}
@Override
- public Future<RpcResult<GetTunnelInterfaceNameOutput>> getTunnelInterfaceName(GetTunnelInterfaceNameInput input) {
+ public ListenableFuture<RpcResult<GetTunnelInterfaceNameOutput>> getTunnelInterfaceName(
+ GetTunnelInterfaceNameInput input) {
RpcResultBuilder<GetTunnelInterfaceNameOutput> resultBld = null;
BigInteger sourceDpn = input.getSourceDpid();
BigInteger destinationDpn = input.getDestinationDpid();
resultBld = RpcResultBuilder.success();
resultBld.withResult(output.build());
} else {
- resultBld = RpcResultBuilder.failed();
+ resultBld = failed();
}
} else {
- resultBld = RpcResultBuilder.failed();
+ resultBld = failed();
}
return Futures.immediateFuture(resultBld.build());
}
@Override
- public Future<RpcResult<GetEgressActionsForTunnelOutput>> getEgressActionsForTunnel(
- GetEgressActionsForTunnelInput input) {
- //TODO
- return null;
+ public ListenableFuture<RpcResult<GetEgressActionsForTunnelOutput>>
+ getEgressActionsForTunnel(GetEgressActionsForTunnelInput input) {
+ String tunnelName = input.getIntfName();
+ if (tunnelName == null) {
+ return Futures.immediateFuture(RpcResultBuilder.<GetEgressActionsForTunnelOutput>failed()
+ .withError(RpcError.ErrorType.APPLICATION,
+ "tunnel name not set for GetEgressActionsForTunnel call").build());
+ }
+
+ if (!dpnTepStateCache.isInternal(tunnelName) && !interfaceManager.isItmDirectTunnelsEnabled()) {
+ // Re-direct the RPC to Interface Manager
+ // From the rpc input and get the output and copy to output
+ org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406
+ .GetEgressActionsForInterfaceInputBuilder inputIfmBuilder =
+ new org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406
+ .GetEgressActionsForInterfaceInputBuilder().setIntfName(input.getIntfName())
+ .setTunnelKey(input.getTunnelKey()).setActionKey(input.getActionKey());
+ SettableFuture<RpcResult<GetEgressActionsForTunnelOutput>> settableFuture = SettableFuture.create();
+ Futures.addCallback(interfaceManagerService.getEgressActionsForInterface(inputIfmBuilder.build()),
+ new FutureCallback<org.opendaylight.yang.gen.v1.urn.opendaylight.genius
+ .interfacemanager.rpcs.rev160406.GetEgressActionsForInterfaceOutput>() {
+ @Override
+ public void onSuccess(@Nonnull org.opendaylight.yang.gen.v1.urn.opendaylight.genius
+ .interfacemanager.rpcs.rev160406.GetEgressActionsForInterfaceOutput result) {
+ GetEgressActionsForTunnelOutputBuilder output =
+ new GetEgressActionsForTunnelOutputBuilder().setAction(result.getAction());
+ settableFuture.set(RpcResultBuilder.<GetEgressActionsForTunnelOutput>success()
+ .withResult(output.build()).build());
+ }
+
+ @Override
+ public void onFailure(Throwable throwable) {
+ LOG.debug("RPC Call to Get egress actions failed for interface {}", tunnelName);
+ String errMsg = String.format("RPC call to get egress actions failed for interface %s",
+ tunnelName);
+ settableFuture.set(RpcResultBuilder.<GetEgressActionsForTunnelOutput>failed()
+ .withError(RpcError.ErrorType.APPLICATION, errMsg, throwable).build());
+ }
+ });
+ return settableFuture;
+ } else {
+ return fromListenableFuture(LOG, input, () -> getEgressActionsForInterface(input.getIntfName(),
+ input.getTunnelKey(), input.getActionKey())).onFailureLogLevel(ERROR).build();
+ }
}
@Override
- public Future<RpcResult<GetTunnelTypeOutput>> getTunnelType(GetTunnelTypeInput input) {
- //TODO
- return null;
+ public ListenableFuture<RpcResult<GetTunnelTypeOutput>> getTunnelType(GetTunnelTypeInput input) {
+ String tunnelName = input.getIntfName();
+ if (tunnelName == null) {
+ return Futures.immediateFuture(RpcResultBuilder.<GetTunnelTypeOutput>failed()
+ .withError(RpcError.ErrorType.APPLICATION,
+ "tunnel name not set for getTunnelType call").build());
+ }
+
+ if (!dpnTepStateCache.isInternal(tunnelName) || !interfaceManager.isItmDirectTunnelsEnabled()) {
+ org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406
+ .GetTunnelTypeInputBuilder inputBuilder = new org.opendaylight.yang.gen.v1.urn.opendaylight
+ .genius.interfacemanager.rpcs.rev160406.GetTunnelTypeInputBuilder()
+ .setIntfName(input.getIntfName());
+ SettableFuture<RpcResult<GetTunnelTypeOutput>> settableFuture = SettableFuture.create();
+ Futures.addCallback(interfaceManagerService.getTunnelType(inputBuilder.build()),
+ new FutureCallback<org.opendaylight.yang.gen.v1.urn.opendaylight.genius
+ .interfacemanager.rpcs.rev160406.GetTunnelTypeOutput>() {
+ public void onSuccess(@Nonnull org.opendaylight.yang.gen.v1.urn.opendaylight.genius
+ .interfacemanager.rpcs.rev160406.GetTunnelTypeOutput result) {
+ GetTunnelTypeOutputBuilder output = new GetTunnelTypeOutputBuilder()
+ .setTunnelType(result.getTunnelType());
+ settableFuture.set(RpcResultBuilder.<GetTunnelTypeOutput>success()
+ .withResult(output.build()).build());
+ }
+
+ public void onFailure(Throwable throwable) {
+ LOG.debug("RPC Call to Get tunnel type failed for interface {}", tunnelName);
+ String errMsg = String.format("RPC to Get tunnel type failed for interface %s",
+ tunnelName);
+ settableFuture.set(RpcResultBuilder.<GetTunnelTypeOutput>failed()
+ .withError(RpcError.ErrorType.APPLICATION, errMsg, throwable).build());
+ }
+ });
+ return settableFuture;
+ } else {
+ LOG.debug("get tunnel type from ITM for interface name {}", input.getIntfName());
+ return FutureRpcResults.fromBuilder(LOG, input, () -> {
+ DpnTepInterfaceInfo ifInfo = dpnTepStateCache.getTunnelFromCache(input.getIntfName());
+ return new GetTunnelTypeOutputBuilder().setTunnelType(ifInfo.getTunnelType());
+ }).build();
+ }
}
@Override
- public Future<RpcResult<Void>> setBfdEnableOnTunnel(SetBfdEnableOnTunnelInput input) {
+ public ListenableFuture<RpcResult<SetBfdEnableOnTunnelOutput>> setBfdEnableOnTunnel(
+ SetBfdEnableOnTunnelInput input) {
//TODO
return null;
}
@Override
- public Future<RpcResult<Void>> removeExternalTunnelEndpoint(
+ public ListenableFuture<RpcResult<RemoveExternalTunnelEndpointOutput>> removeExternalTunnelEndpoint(
RemoveExternalTunnelEndpointInput input) {
//Ignore the Futures for now
- final SettableFuture<RpcResult<Void>> result = SettableFuture.create();
+ final SettableFuture<RpcResult<RemoveExternalTunnelEndpointOutput>> result = SettableFuture.create();
Collection<DPNTEPsInfo> meshedDpnList = dpnTEPsInfoCache.getAllPresent();
ItmExternalTunnelDeleteWorker.deleteTunnels(dataBroker, meshedDpnList,
input.getDestinationIp(), input.getTunnelType());
Futures.addCallback(futureCheck, new FutureCallback<Void>() {
@Override public void onSuccess(Void voidInstance) {
- result.set(RpcResultBuilder.<Void>success().build());
+ result.set(RpcResultBuilder.<RemoveExternalTunnelEndpointOutput>success().build());
}
@Override public void onFailure(Throwable error) {
String msg = "Unable to delete DcGatewayIp " + input.getDestinationIp()
+ " in datastore and tunnel type " + input.getTunnelType();
- LOG.error(msg);
- result.set(RpcResultBuilder.<Void>failed()
+ LOG.error("Unable to delete DcGatewayIp {} in datastore and tunnel type {}", input.getDestinationIp(),
+ input.getTunnelType());
+ result.set(RpcResultBuilder.<RemoveExternalTunnelEndpointOutput>failed()
.withError(RpcError.ErrorType.APPLICATION, msg, error).build());
}
});
}
@Override
- public Future<RpcResult<Void>> removeExternalTunnelFromDpns(
+ public ListenableFuture<RpcResult<RemoveExternalTunnelFromDpnsOutput>> removeExternalTunnelFromDpns(
RemoveExternalTunnelFromDpnsInput input) {
//Ignore the Futures for now
- final SettableFuture<RpcResult<Void>> result = SettableFuture.create();
+ final SettableFuture<RpcResult<RemoveExternalTunnelFromDpnsOutput>> result = SettableFuture.create();
List<DPNTEPsInfo> cfgDpnList = ItmUtils.getDpnTepListFromDpnId(dpnTEPsInfoCache, input.getDpnId()) ;
ItmExternalTunnelDeleteWorker.deleteTunnels(dataBroker, cfgDpnList,
input.getDestinationIp(), input.getTunnelType());
- result.set(RpcResultBuilder.<Void>success().build());
+ result.set(RpcResultBuilder.<RemoveExternalTunnelFromDpnsOutput>success().build());
return result;
}
@Override
- public Future<RpcResult<Void>> buildExternalTunnelFromDpns(
+ public ListenableFuture<RpcResult<BuildExternalTunnelFromDpnsOutput>> buildExternalTunnelFromDpns(
BuildExternalTunnelFromDpnsInput input) {
//Ignore the Futures for now
- final SettableFuture<RpcResult<Void>> result = SettableFuture.create();
+ final SettableFuture<RpcResult<BuildExternalTunnelFromDpnsOutput>> result = SettableFuture.create();
List<ListenableFuture<Void>> extTunnelResultList = externalTunnelAddWorker
.buildTunnelsFromDpnToExternalEndPoint(input.getDpnId(), input.getDestinationIp(),input.getTunnelType());
for (ListenableFuture<Void> extTunnelResult : extTunnelResultList) {
@Override
public void onSuccess(Void voidInstance) {
- result.set(RpcResultBuilder.<Void>success().build());
+ result.set(RpcResultBuilder.<BuildExternalTunnelFromDpnsOutput>success().build());
}
@Override
public void onFailure(Throwable error) {
String msg = "Unable to create ext tunnel";
- LOG.error("create ext tunnel failed. {}. {}", msg, error);
- result.set(RpcResultBuilder.<Void>failed()
+ LOG.error("create ext tunnel failed. {}.", msg, error);
+ result.set(RpcResultBuilder.<BuildExternalTunnelFromDpnsOutput>failed()
.withError(RpcError.ErrorType.APPLICATION, msg, error).build());
}
});
}
@Override
- public Future<RpcResult<Void>> addExternalTunnelEndpoint(
+ public ListenableFuture<RpcResult<AddExternalTunnelEndpointOutput>> addExternalTunnelEndpoint(
AddExternalTunnelEndpointInput input) {
// TODO Auto-generated method stub
//Ignore the Futures for now
- final SettableFuture<RpcResult<Void>> result = SettableFuture.create();
+ final SettableFuture<RpcResult<AddExternalTunnelEndpointOutput>> result = SettableFuture.create();
Collection<DPNTEPsInfo> meshedDpnList = dpnTEPsInfoCache.getAllPresent();
externalTunnelAddWorker.buildTunnelsToExternalEndPoint(meshedDpnList,
input.getDestinationIp(), input.getTunnelType());
Futures.addCallback(futureCheck, new FutureCallback<Void>() {
@Override public void onSuccess(Void voidInstance) {
- result.set(RpcResultBuilder.<Void>success().build());
+ result.set(RpcResultBuilder.<AddExternalTunnelEndpointOutput>success().build());
}
@Override public void onFailure(Throwable error) {
"Unable to create DcGatewayIp {} in datastore for ip " + input.getDestinationIp() + "and "
+ "tunnel type " + input.getTunnelType();
- LOG.error(msg);
- result.set(RpcResultBuilder.<Void>failed()
+ LOG.error("Unable to create DcGatewayIp in datastore for ip {} and tunnel type {}",
+ input.getDestinationIp() , input.getTunnelType());
+ result.set(RpcResultBuilder.<AddExternalTunnelEndpointOutput>failed()
.withError(RpcError.ErrorType.APPLICATION, msg, error).build());
}
});
}
@Override
- public Future<RpcResult<GetExternalTunnelInterfaceNameOutput>> getExternalTunnelInterfaceName(
+ public ListenableFuture<RpcResult<GetExternalTunnelInterfaceNameOutput>> getExternalTunnelInterfaceName(
GetExternalTunnelInterfaceNameInput input) {
SettableFuture.create();
RpcResultBuilder<GetExternalTunnelInterfaceNameOutput> resultBld;
resultBld = RpcResultBuilder.success();
resultBld.withResult(output.build());
} else {
- resultBld = RpcResultBuilder.failed();
+ resultBld = failed();
}
return Futures.immediateFuture(resultBld.build());
}
@Override
- public Future<RpcResult<java.lang.Void>>
+ public ListenableFuture<RpcResult<CreateTerminatingServiceActionsOutput>>
createTerminatingServiceActions(final CreateTerminatingServiceActionsInput input) {
LOG.info("create terminatingServiceAction on DpnId = {} for service id {} and instructions {}",
input.getDpnId() , input.getServiceId(), input.getInstruction());
- final SettableFuture<RpcResult<Void>> result = SettableFuture.create();
+ final SettableFuture<RpcResult<CreateTerminatingServiceActionsOutput>> result = SettableFuture.create();
int serviceId = input.getServiceId() ;
final List<MatchInfo> mkMatches = getTunnelMatchesForServiceId(serviceId);
@Override
public void onSuccess(Void voidInstance) {
- result.set(RpcResultBuilder.<Void>success().build());
+ result.set(RpcResultBuilder.<CreateTerminatingServiceActionsOutput>success().build());
}
@Override
public void onFailure(Throwable error) {
String msg = String.format("Unable to install terminating service flow for %s", input.getDpnId());
- LOG.error("create terminating service actions failed. {}. {}", msg, error);
- result.set(RpcResultBuilder.<Void>failed().withError(RpcError.ErrorType.APPLICATION, msg, error)
+ LOG.error("create terminating service actions failed. {}", msg, error);
+ result.set(RpcResultBuilder.<CreateTerminatingServiceActionsOutput>failed()
+ .withError(RpcError.ErrorType.APPLICATION, msg, error)
.build());
}
}, MoreExecutors.directExecutor());
}
@Override
- public Future<RpcResult<java.lang.Void>>
+ public ListenableFuture<RpcResult<RemoveTerminatingServiceActionsOutput>>
removeTerminatingServiceActions(final RemoveTerminatingServiceActionsInput input) {
LOG.info("remove terminatingServiceActions called with DpnId = {} and serviceId = {}",
input.getDpnId(), input.getServiceId());
- final SettableFuture<RpcResult<Void>> result = SettableFuture.create();
+ final SettableFuture<RpcResult<RemoveTerminatingServiceActionsOutput>> result = SettableFuture.create();
Flow terminatingServiceTableFlow = MDSALUtil.buildFlowNew(NwConstants.INTERNAL_TUNNEL_TABLE,
getFlowRef(NwConstants.INTERNAL_TUNNEL_TABLE,input.getServiceId()), 5,
String.format("%s:%d","ITM Flow Entry ",input.getServiceId()), 0, 0,
@Override
public void onSuccess(Void voidInstance) {
- result.set(RpcResultBuilder.<Void>success().build());
+ result.set(RpcResultBuilder.<RemoveTerminatingServiceActionsOutput>success().build());
}
@Override
public void onFailure(Throwable error) {
String msg = String.format("Unable to remove terminating service flow for %s", input.getDpnId());
- LOG.error("remove terminating service actions failed. {}. {}", msg, error);
- result.set(RpcResultBuilder.<Void>failed().withError(RpcError.ErrorType.APPLICATION, msg, error)
+ LOG.error("remove terminating service actions failed. {}", msg, error);
+ result.set(RpcResultBuilder.<RemoveTerminatingServiceActionsOutput>failed()
+ .withError(RpcError.ErrorType.APPLICATION, msg, error)
.build());
}
}, MoreExecutors.directExecutor());
}
@Override
- public Future<RpcResult<GetInternalOrExternalInterfaceNameOutput>> getInternalOrExternalInterfaceName(
+ public ListenableFuture<RpcResult<GetInternalOrExternalInterfaceNameOutput>> getInternalOrExternalInterfaceName(
GetInternalOrExternalInterfaceNameInput input) {
- RpcResultBuilder<GetInternalOrExternalInterfaceNameOutput> resultBld = RpcResultBuilder.failed();
+ RpcResultBuilder<GetInternalOrExternalInterfaceNameOutput> resultBld = failed();
BigInteger srcDpn = input.getSourceDpid() ;
IpAddress dstIp = input.getDestinationIp() ;
InstanceIdentifier<ExternalTunnel> path1 = InstanceIdentifier.create(ExternalTunnelList.class)
.child(ExternalTunnel.class,
- new ExternalTunnelKey(String.valueOf(dstIp), srcDpn.toString(), input.getTunnelType()));
+ new ExternalTunnelKey(String.valueOf(dstIp.getValue()),
+ srcDpn.toString(), input.getTunnelType()));
Optional<ExternalTunnel> optExtTunnel = ItmUtils.read(LogicalDatastoreType.CONFIGURATION, path1, dataBroker);
@SuppressWarnings("checkstyle:IllegalCatch")
@Override
- public Future<RpcResult<java.lang.Void>> deleteL2GwDevice(DeleteL2GwDeviceInput input) {
- final SettableFuture<RpcResult<Void>> result = SettableFuture.create();
+ public ListenableFuture<RpcResult<DeleteL2GwDeviceOutput>> deleteL2GwDevice(DeleteL2GwDeviceInput input) {
+ final SettableFuture<RpcResult<DeleteL2GwDeviceOutput>> result = SettableFuture.create();
boolean foundVxlanTzone = false;
try {
final IpAddress hwIp = input.getIpAddress();
TransportZones transportZones = transportZonesOptional.get();
if (transportZones.getTransportZone() == null || transportZones.getTransportZone().isEmpty()) {
LOG.error("No teps configured");
- result.set(RpcResultBuilder.<Void>failed()
+ result.set(RpcResultBuilder.<DeleteL2GwDeviceOutput>failed()
.withError(RpcError.ErrorType.APPLICATION, "No teps Configured").build());
return result;
}
foundVxlanTzone = true;
String transportZone = tzone.getZoneName();
if (tzone.getSubnets() == null || tzone.getSubnets().isEmpty()) {
- result.set(RpcResultBuilder.<Void>failed()
+ result.set(RpcResultBuilder.<DeleteL2GwDeviceOutput>failed()
.withError(RpcError.ErrorType.APPLICATION, "No subnets Configured").build());
return result;
}
Futures.addCallback(futureCheck, new FutureCallback<Void>() {
@Override public void onSuccess(Void voidInstance) {
- result.set(RpcResultBuilder.<Void>success().build());
+ result.set(RpcResultBuilder.<DeleteL2GwDeviceOutput>success().build());
}
@Override public void onFailure(Throwable error) {
String msg = String.format("Unable to delete HwVtep %s from datastore", nodeId);
LOG.error("Unable to delete HwVtep {}, {} from datastore", nodeId, hwIp);
- result.set(RpcResultBuilder.<Void>failed()
+ result.set(RpcResultBuilder.<DeleteL2GwDeviceOutput>failed()
.withError(RpcError.ErrorType.APPLICATION, msg, error).build());
}
});
}
} else {
- result.set(RpcResultBuilder.<Void>failed()
+ result.set(RpcResultBuilder.<DeleteL2GwDeviceOutput>failed()
.withError(RpcError.ErrorType.APPLICATION, "No TransportZones configured").build());
return result;
}
if (!foundVxlanTzone) {
- result.set(RpcResultBuilder.<Void>failed()
+ result.set(RpcResultBuilder.<DeleteL2GwDeviceOutput>failed()
.withError(RpcError.ErrorType.APPLICATION, "No VxLan TransportZones configured")
.build());
}
return result;
} catch (Exception e) {
- RpcResultBuilder<java.lang.Void> resultBuilder = RpcResultBuilder.<Void>failed()
+ RpcResultBuilder<DeleteL2GwDeviceOutput> resultBuilder = RpcResultBuilder.<DeleteL2GwDeviceOutput>failed()
.withError(RpcError.ErrorType.APPLICATION, "Deleting l2 Gateway to DS Failed", e);
return Futures.immediateFuture(resultBuilder.build());
}
@SuppressWarnings("checkstyle:IllegalCatch")
@Override
- public Future<RpcResult<java.lang.Void>> addL2GwDevice(AddL2GwDeviceInput input) {
+ public ListenableFuture<RpcResult<AddL2GwDeviceOutput>> addL2GwDevice(AddL2GwDeviceInput input) {
- final SettableFuture<RpcResult<Void>> result = SettableFuture.create();
+ final SettableFuture<RpcResult<AddL2GwDeviceOutput>> result = SettableFuture.create();
boolean foundVxlanTzone = false;
try {
final IpAddress hwIp = input.getIpAddress();
TransportZones transportZones = transportZonesOptional.get();
if (transportZones.getTransportZone() == null || transportZones.getTransportZone().isEmpty()) {
LOG.error("No transportZone configured");
- result.set(RpcResultBuilder.<Void>failed()
+ result.set(RpcResultBuilder.<AddL2GwDeviceOutput>failed()
.withError(RpcError.ErrorType.APPLICATION, "No transportZone Configured").build());
return result;
}
Futures.addCallback(futureCheck, new FutureCallback<Void>() {
@Override public void onSuccess(Void voidInstance) {
- result.set(RpcResultBuilder.<Void>success().build());
+ result.set(RpcResultBuilder.<AddL2GwDeviceOutput>success().build());
}
@Override public void onFailure(Throwable error) {
String msg = String.format("Unable to write HwVtep %s to datastore", nodeId);
LOG.error("Unable to write HwVtep {}, {} to datastore", nodeId, hwIp);
- result.set(RpcResultBuilder.<Void>failed()
+ result.set(RpcResultBuilder.<AddL2GwDeviceOutput>failed()
.withError(RpcError.ErrorType.APPLICATION, msg, error).build());
}
});
}
} else {
- result.set(RpcResultBuilder.<Void>failed()
+ result.set(RpcResultBuilder.<AddL2GwDeviceOutput>failed()
.withError(RpcError.ErrorType.APPLICATION, "No TransportZones configured").build());
return result;
}
if (!foundVxlanTzone) {
- result.set(RpcResultBuilder.<Void>failed()
+ result.set(RpcResultBuilder.<AddL2GwDeviceOutput>failed()
.withError(RpcError.ErrorType.APPLICATION, "No VxLan TransportZones configured")
.build());
}
return result;
} catch (Exception e) {
- RpcResultBuilder<java.lang.Void> resultBuilder = RpcResultBuilder.<Void>failed()
+ RpcResultBuilder<AddL2GwDeviceOutput> resultBuilder = RpcResultBuilder.<AddL2GwDeviceOutput>failed()
.withError(RpcError.ErrorType.APPLICATION, "Adding l2 Gateway to DS Failed", e);
return Futures.immediateFuture(resultBuilder.build());
}
@SuppressWarnings("checkstyle:IllegalCatch")
@Override
- public Future<RpcResult<java.lang.Void>> addL2GwMlagDevice(AddL2GwMlagDeviceInput input) {
+ public ListenableFuture<RpcResult<AddL2GwMlagDeviceOutput>> addL2GwMlagDevice(AddL2GwMlagDeviceInput input) {
- final SettableFuture<RpcResult<Void>> result = SettableFuture.create();
+ final SettableFuture<RpcResult<AddL2GwMlagDeviceOutput>> result = SettableFuture.create();
try {
final IpAddress hwIp = input.getIpAddress();
final List<String> nodeId = input.getNodeId();
TransportZones transportZones = transportZonesOptional.get();
if (transportZones.getTransportZone() == null || transportZones.getTransportZone().isEmpty()) {
LOG.error("No teps configured");
- result.set(RpcResultBuilder.<Void>failed()
+ result.set(RpcResultBuilder.<AddL2GwMlagDeviceOutput>failed()
.withError(RpcError.ErrorType.APPLICATION, "No teps Configured").build());
return result;
}
String transportZone = transportZones.getTransportZone().get(0).getZoneName();
if (transportZones.getTransportZone().get(0).getSubnets() == null
|| transportZones.getTransportZone().get(0).getSubnets().isEmpty()) {
- result.set(RpcResultBuilder.<Void>failed()
+ result.set(RpcResultBuilder.<AddL2GwMlagDeviceOutput>failed()
.withError(RpcError.ErrorType.APPLICATION, "No subnets Configured").build());
return result;
}
@Override
public void onSuccess(Void voidInstance) {
- result.set(RpcResultBuilder.<Void>success().build());
+ result.set(RpcResultBuilder.<AddL2GwMlagDeviceOutput>success().build());
}
@Override
public void onFailure(Throwable error) {
String msg = String.format("Unable to write HwVtep %s to datastore", nodeId);
LOG.error("Unable to write HwVtep {}, {} to datastore", nodeId , hwIp);
- result.set(RpcResultBuilder.<Void>failed().withError(RpcError.ErrorType.APPLICATION, msg, error)
+ result.set(RpcResultBuilder.<AddL2GwMlagDeviceOutput>failed()
+ .withError(RpcError.ErrorType.APPLICATION, msg, error)
.build());
}
}, MoreExecutors.directExecutor());
}
return result;
} catch (RuntimeException e) {
- RpcResultBuilder<java.lang.Void> resultBuilder = RpcResultBuilder.<Void>failed()
+ RpcResultBuilder<AddL2GwMlagDeviceOutput> resultBuilder = RpcResultBuilder.<AddL2GwMlagDeviceOutput>failed()
.withError(RpcError.ErrorType.APPLICATION, "Adding l2 Gateway to DS Failed", e);
return Futures.immediateFuture(resultBuilder.build());
}
@SuppressWarnings("checkstyle:IllegalCatch")
@Override
- public Future<RpcResult<Void>> deleteL2GwMlagDevice(DeleteL2GwMlagDeviceInput input) {
-
- final SettableFuture<RpcResult<Void>> result = SettableFuture.create();
+ public ListenableFuture<RpcResult<DeleteL2GwMlagDeviceOutput>> deleteL2GwMlagDevice(
+ DeleteL2GwMlagDeviceInput input) {
+ final SettableFuture<RpcResult<DeleteL2GwMlagDeviceOutput>> result = SettableFuture.create();
try {
final IpAddress hwIp = input.getIpAddress();
final List<String> nodeId = input.getNodeId();
TransportZones tzones = transportZonesOptional.get();
if (tzones.getTransportZone() == null || tzones.getTransportZone().isEmpty()) {
LOG.error("No teps configured");
- result.set(RpcResultBuilder.<Void>failed()
+ result.set(RpcResultBuilder.<DeleteL2GwMlagDeviceOutput>failed()
.withError(RpcError.ErrorType.APPLICATION, "No teps Configured").build());
return result;
}
String transportZone = tzones.getTransportZone().get(0).getZoneName();
if (tzones.getTransportZone().get(0).getSubnets() == null || tzones.getTransportZone()
.get(0).getSubnets().isEmpty()) {
- result.set(RpcResultBuilder.<Void>failed()
+ result.set(RpcResultBuilder.<DeleteL2GwMlagDeviceOutput>failed()
.withError(RpcError.ErrorType.APPLICATION, "No subnets Configured").build());
return result;
}
@Override
public void onSuccess(Void voidInstance) {
- result.set(RpcResultBuilder.<Void>success().build());
+ result.set(RpcResultBuilder.<DeleteL2GwMlagDeviceOutput>success().build());
}
@Override
public void onFailure(Throwable error) {
String msg = String.format("Unable to write HwVtep %s to datastore", nodeId);
LOG.error("Unable to write HwVtep {}, {} to datastore", nodeId , hwIp);
- result.set(RpcResultBuilder.<Void>failed().withError(RpcError.ErrorType.APPLICATION, msg, error)
+ result.set(RpcResultBuilder.<DeleteL2GwMlagDeviceOutput>failed()
+ .withError(RpcError.ErrorType.APPLICATION, msg, error)
.build());
}
});
}
return result;
} catch (Exception e) {
- RpcResultBuilder<java.lang.Void> resultBuilder = RpcResultBuilder.<Void>failed()
- .withError(RpcError.ErrorType.APPLICATION, "Deleting l2 Gateway to DS Failed", e);
+ RpcResultBuilder<DeleteL2GwMlagDeviceOutput> resultBuilder =
+ RpcResultBuilder.<DeleteL2GwMlagDeviceOutput>failed().withError(RpcError.ErrorType.APPLICATION,
+ "Deleting l2 Gateway to DS Failed", e);
return Futures.immediateFuture(resultBuilder.build());
}
}
@Override
- public Future<RpcResult<IsTunnelInternalOrExternalOutput>> isTunnelInternalOrExternal(
+ public ListenableFuture<RpcResult<IsTunnelInternalOrExternalOutput>> isTunnelInternalOrExternal(
IsTunnelInternalOrExternalInput input) {
RpcResultBuilder<IsTunnelInternalOrExternalOutput> resultBld;
String tunIfName = input.getTunnelInterfaceName();
}
@Override
- public Future<RpcResult<IsDcgwPresentOutput>> isDcgwPresent(IsDcgwPresentInput input) {
+ public ListenableFuture<RpcResult<IsDcgwPresentOutput>> isDcgwPresent(IsDcgwPresentInput input) {
RpcResultBuilder<IsDcgwPresentOutput> resultBld = RpcResultBuilder.success();
List<DcGatewayIp> dcGatewayIpList = ItmUtils.getDcGatewayIpList(dataBroker);
String dcgwIpStr = input.getDcgwIp();
- IpAddress dcgwIpAddr = new IpAddress(dcgwIpStr.toCharArray());
+ IpAddress dcgwIpAddr = IpAddressBuilder.getDefaultInstance(dcgwIpStr);
long retVal;
if (dcGatewayIpList != null && !dcGatewayIpList.isEmpty()
}
@Override
- public Future<RpcResult<GetDpnEndpointIpsOutput>> getDpnEndpointIps(GetDpnEndpointIpsInput input) {
+ public ListenableFuture<RpcResult<GetDpnEndpointIpsOutput>> getDpnEndpointIps(GetDpnEndpointIpsInput input) {
BigInteger srcDpn = input.getSourceDpid() ;
- RpcResultBuilder<GetDpnEndpointIpsOutput> resultBld = RpcResultBuilder.failed();
+ RpcResultBuilder<GetDpnEndpointIpsOutput> resultBld = failed();
InstanceIdentifier<DPNTEPsInfo> tunnelInfoId =
InstanceIdentifier.builder(DpnEndpoints.class).child(DPNTEPsInfo.class,
new DPNTEPsInfoKey(srcDpn)).build();
}
List<IpAddress> nexthopIpList = new ArrayList<>();
- tunnelEndPointList.forEach(tunnelEndPoint -> {
- nexthopIpList.add(tunnelEndPoint.getIpAddress());
- });
+ tunnelEndPointList.forEach(tunnelEndPoint -> nexthopIpList.add(tunnelEndPoint.getIpAddress()));
GetDpnEndpointIpsOutputBuilder output = new GetDpnEndpointIpsOutputBuilder().setNexthopipList(nexthopIpList);
resultBld = RpcResultBuilder.success();
}
@Override
- public Future<RpcResult<GetDpnInfoOutput>> getDpnInfo(GetDpnInfoInput input) {
- return FutureRpcResults.fromListenableFuture(LOG, "getDpnInfo", input, () -> {
- return Futures.immediateFuture(getDpnInfoInternal(input));
- }).build();
+ public ListenableFuture<RpcResult<GetDpnInfoOutput>> getDpnInfo(GetDpnInfoInput input) {
+ return FutureRpcResults.fromListenableFuture(LOG, "getDpnInfo", input,
+ () -> Futures.immediateFuture(getDpnInfoInternal(input))).build();
}
private GetDpnInfoOutput getDpnInfoInternal(GetDpnInfoInput input) throws ReadFailedException {
}
Map<String, BigInteger> result = new HashMap<>();
for (Node node : operInventoryNodes.getNode()) {
- String name = node.<FlowCapableNode>getAugmentation(FlowCapableNode.class).getDescription();
+ String name = node.getAugmentation(FlowCapableNode.class).getDescription();
if (nodeNames.contains(name)) {
String[] nodeId = node.getId().getValue().split(":");
result.put(name, new BigInteger(nodeId[1]));
.child(BridgeRefEntry.class, new BridgeRefEntryKey(dpnId)).build();
BridgeRefEntry bridgeRefEntry =
singleTransactionDataBroker.syncRead(LogicalDatastoreType.OPERATIONAL, path);
- return ((InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology
- .rev131021.network.topology.topology.Node>)bridgeRefEntry.getBridgeReference().getValue())
+ return bridgeRefEntry.getBridgeReference().getValue()
.firstKeyOf(org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021
.network.topology.topology.Node.class).getNodeId().getValue();
}
+
+ private ListenableFuture<GetEgressActionsForTunnelOutput> getEgressActionsForInterface(String interfaceName,
+ long tunnelKey, Integer actionKey) throws ReadFailedException {
+ int actionKeyStart = actionKey == null ? 0 : actionKey;
+ DpnTepInterfaceInfo interfaceInfo = dpnTepStateCache.getTunnelFromCache(interfaceName);
+ if (interfaceInfo == null) {
+ throw new IllegalStateException("Interface information not present in config DS for" + interfaceName);
+ }
+ Optional<StateTunnelList> ifState = tunnelStateCache
+ .get(tunnelStateCache.getStateTunnelListIdentifier(interfaceName));
+ if (ifState.isPresent()) {
+ String tunnelType = ItmUtils.convertTunnelTypetoString(interfaceInfo.getTunnelType());
+ List<Action> actions = getEgressActionInfosForInterface(tunnelType, ifState.get().getPortNumber(),
+ tunnelKey, actionKeyStart).stream().map(ActionInfo::buildAction).collect(Collectors.toList());
+ return Futures.immediateFuture(new GetEgressActionsForTunnelOutputBuilder().setAction(actions).build());
+ }
+ throw new IllegalStateException("Interface information not present in oper DS for" + interfaceName);
+ }
+
+ private static List<ActionInfo> getEgressActionInfosForInterface(String tunnelType, String portNo, Long tunnelKey,
+ int actionKeyStart) {
+ List<ActionInfo> result = new ArrayList<>();
+ switch (tunnelType) {
+ case ITMConstants.TUNNEL_TYPE_GRE:
+ case ITMConstants.TUNNEL_TYPE_MPLSoGRE:
+ // Invoke IFM RPC and pass it on to the caller.
+ LOG.warn("Interface Type {} not handled by ITM", tunnelType);
+ break;
+ case ITMConstants.TUNNEL_TYPE_VXLAN:
+ //TODO tunnel_id to encode GRE key, once it is supported
+ // Until then, tunnel_id should be "cleaned", otherwise it stores the value coming from a VXLAN tunnel
+ result.add(new ActionSetFieldTunnelId(actionKeyStart++,
+ BigInteger.valueOf(tunnelKey != null ? tunnelKey : 0L)));
+ result.add(new ActionOutput(actionKeyStart, new Uri(portNo)));
+ break;
+
+ default:
+ LOG.warn("Interface Type {} not handled yet", tunnelType);
+ break;
+ }
+ return result;
+ }
}
Code Review / genius.git / blobdiff