import java.util.HashMap;
import java.util.List;
import java.util.Map;
+import javax.annotation.PostConstruct;
+import javax.annotation.PreDestroy;
+import javax.inject.Inject;
+import javax.inject.Singleton;
import org.apache.commons.net.util.SubnetUtils;
import org.apache.felix.service.command.CommandSession;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.genius.interfacemanager.interfaces.IInterfaceManager;
import org.opendaylight.genius.itm.globals.ITMConstants;
import org.opendaylight.genius.itm.impl.ItmUtils;
import org.opendaylight.genius.mdsalutil.MDSALDataStoreUtils;
+import org.opendaylight.genius.utils.cache.DataStoreCache;
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.IpPrefix;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface.AdminStatus;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface.OperStatus;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.IfL2vlan;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.IfTunnel;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.TunnelMonitoringTypeBase;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.TunnelMonitoringTypeBfd;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.TunnelMonitoringTypeLldp;
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;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.TunnelTypeVxlan;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.config.rev160406.TunnelMonitorInterval;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.config.rev160406.TunnelMonitorIntervalBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.config.rev160406.TunnelMonitorParams;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.config.rev160406.TunnelMonitorParamsBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.TunnelList;
-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.TepTypeInternal;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.TunnelOperStatus;
+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.TransportZones;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.TransportZonesBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.TransportZone;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-//import org.opendaylight.genius.interfacemgr.util.OperationalIfmUtil;
-
-
+@Singleton
public class TepCommandHelper {
private static final Logger LOG = LoggerFactory.getLogger(TepCommandHelper.class);
- private DataBroker dataBroker;
+ private final DataBroker dataBroker;
static int check = 0;
static short flag = 0;
/*
private List<Subnets> subnetList = new ArrayList<>();
private List<TransportZone> tZoneList = new ArrayList<>();
private List<Vteps> vtepDelCommitList = new ArrayList<>();
- private IInterfaceManager interfaceManager;
// private List<InstanceIdentifier<? extends DataObject>> vtepPaths = new
// ArrayList<>();
-
- public TepCommandHelper(final DataBroker broker) {
- this.dataBroker = broker;
+ @Inject
+ public TepCommandHelper(final DataBroker dataBroker) {
+ this.dataBroker = dataBroker;
}
+ @PostConstruct
+ public void start() {
+ configureTunnelType(ITMConstants.DEFAULT_TRANSPORT_ZONE,ITMConstants.TUNNEL_TYPE_VXLAN);
+ LOG.info("TepCommandHelper Started");
+ }
- public void setInterfaceManager(IInterfaceManager interfaceManager) {
- this.interfaceManager = interfaceManager;
+ @PreDestroy
+ public void close() {
+ LOG.info("TepCommandHelper Closed");
}
public void createLocalCache(BigInteger dpnId, String portName, Integer vlanId, String ipAddress,
SubnetsKey subnetsKey = new SubnetsKey(subnetMaskObj);
SubnetObject subObCli = new SubnetObject(gatewayIpObj, subnetsKey, subnetMaskObj, vlanId);
if (tZones.containsKey(transportZone)) {
- Map<SubnetObject, List<Vteps>> subVtepMapTemp = (Map<SubnetObject, List<Vteps>>) tZones.get(transportZone);
+ Map<SubnetObject, List<Vteps>> subVtepMapTemp = tZones.get(transportZone);
if (subVtepMapTemp.containsKey(subObCli)) { // if Subnet exists
- List<Vteps> vtepListTemp = (List<Vteps>) subVtepMapTemp.get(subObCli);
+ List<Vteps> vtepListTemp = subVtepMapTemp.get(subObCli);
if (vtepListTemp.contains(vtepCli)) {
// do nothing
} else {
// Checking for duplicates in local cache
for (String tZ : tZones.keySet()) {
boolean isGreType = isGreTunnelType(tZ, tZoneMap);
- Map<SubnetObject, List<Vteps>> subVtepMapTemp = (Map<SubnetObject, List<Vteps>>) tZones.get(tZ);
+ Map<SubnetObject, List<Vteps>> subVtepMapTemp = tZones.get(tZ);
for (SubnetObject subOb : subVtepMapTemp.keySet()) {
List<Vteps> vtepList = subVtepMapTemp.get(subOb);
validateForDuplicateAndSingleGreTep(inputVtep, isConfiguredTepGreType, isGreType, vtepList);
if (isConfiguredTepGreType && isGreType) {
for (Vteps vtep : vtepList) {
if (vtep.getDpnId().equals(dpnId)) {
- String errMsg = new StringBuilder("DPN [").append(dpnId)
- .append("] already configured with GRE TEP. Mutiple GRE TEP's on a single DPN are not allowed.")
- .toString();
+ String errMsg = "DPN [" + dpnId +
+ "] already configured with GRE TEP. Mutiple GRE TEP's on a single DPN are not allowed.";
Preconditions.checkArgument(false, errMsg);
}
}
return true;
}
*/
- if( (tzone != null) && (tzone.getTunnelType()).equals(TunnelTypeGre.class) ) {
- return true;
- }
- return false;
+ return (tzone != null) && (tzone.getTunnelType()).equals(TunnelTypeGre.class);
}
/**
public TransportZone getTransportZone(String tzone) {
InstanceIdentifier<TransportZone> tzonePath = InstanceIdentifier.builder(TransportZones.class)
.child(TransportZone.class, new TransportZoneKey(tzone)).build();
- Optional<TransportZone> tZoneOptional = ItmUtils.read(LogicalDatastoreType.CONFIGURATION, tzonePath,
- dataBroker);
- if (tZoneOptional.isPresent()) {
- return tZoneOptional.get();
- }
- return null;
- }
-
- /**
- * Gets the transport zone from config ds.
- *
- * @param tzone
- * the tzone
- * @return the transport zone
- */
- public TransportZone getTransportZoneFromConfigDS(String tzone) {
- InstanceIdentifier<TransportZone> tzonePath = InstanceIdentifier.builder(TransportZones.class)
- .child(TransportZone.class, new TransportZoneKey(tzone)).build();
- Optional<TransportZone> tZoneOptional = ItmUtils.read(LogicalDatastoreType.CONFIGURATION, tzonePath,
- dataBroker);
- if (tZoneOptional.isPresent()) {
- return tZoneOptional.get();
- }
- return null;
+ return ItmUtils.read(LogicalDatastoreType.CONFIGURATION, tzonePath, dataBroker).orNull();
}
/**
*/
public TransportZones getAllTransportZones() {
InstanceIdentifier<TransportZones> path = InstanceIdentifier.builder(TransportZones.class).build();
- Optional<TransportZones> tZonesOptional = ItmUtils.read(LogicalDatastoreType.CONFIGURATION, path, dataBroker);
- if (tZonesOptional.isPresent()) {
- return tZonesOptional.get();
- }
- return null;
+ return ItmUtils.read(LogicalDatastoreType.CONFIGURATION, path, dataBroker).orNull();
}
public boolean checkExistingSubnet(Map<SubnetObject, List<Vteps>> subVtepMapTemp, SubnetObject subObCli) {
public boolean checkTepPerTzPerDpn(String tzone, BigInteger dpnId) {
// check in local cache
if (tZones.containsKey(tzone)) {
- Map<SubnetObject, List<Vteps>> subVtepMapTemp = (Map<SubnetObject, List<Vteps>>) tZones.get(tzone);
+ Map<SubnetObject, List<Vteps>> subVtepMapTemp = tZones.get(tzone);
for (SubnetObject subOb : subVtepMapTemp.keySet()) {
List<Vteps> vtepList = subVtepMapTemp.get(subOb);
for (Vteps vtep : vtepList)
for (String tZ : tZones.keySet()) {
LOG.debug("tZones" + tZ);
subnetList = new ArrayList<>();
- Map<SubnetObject, List<Vteps>> subVtepMapTemp = (Map<SubnetObject, List<Vteps>>) tZones.get(tZ);
+ Map<SubnetObject, List<Vteps>> subVtepMapTemp = tZones.get(tZ);
for (SubnetObject subOb : subVtepMapTemp.keySet()) {
LOG.debug("subnets" + subOb.get_prefix());
List<Vteps> vtepList = subVtepMapTemp.get(subOb);
result.add(String.format("%-16s %-16s %-16s %-12s %-12s %-12s %-16s %-12s", tZ.getZoneName(), strTunnelType, sub
.getPrefix().getIpv4Prefix().getValue(), sub.getGatewayIp().getIpv4Address()
.getValue(), sub.getVlanId().toString(), vtep.getDpnId().toString(), vtep
- .getIpAddress().getIpv4Address().getValue(), vtep.getPortname().toString()));
+ .getIpAddress().getIpv4Address().getValue(), vtep.getPortname()));
}
}
}
- if (flag == true) {
- for (String p : result) {
- if(session != null) {
- session.getConsole().println(p);
+ if (session != null) {
+ if (flag) {
+ for (String p : result) {
+ System.out.println(p);
}
+ } else {
+ System.out.println("No teps to display");
}
- } else if (session != null) {
- session.getConsole().println("No teps to display");
}
} else if(session != null){
- session.getConsole().println("No teps configured");
+ System.out.println("No teps configured");
}
}
+public void showCache(String cacheName) {
+
+ if( !DataStoreCache.isCacheValid(cacheName)) {
+ System.out.println( " " + cacheName + " is not a valid Cache Name ") ;
+ return ;
+ }
+ List<Object> keys = null ;
+ keys = DataStoreCache.getKeys(cacheName);
+ if( keys != null && !keys.isEmpty()) {
+ System.out.println( "Dumping the data in cache for " + cacheName ) ;
+ for( Object key : keys ) {
+ System.out.println( " KEY: " + key + " Value: " + DataStoreCache.get(cacheName, key) ) ;
+ System.out.println() ;
+ }
+
+ }else
+ System.out.println( "No data in cache for " + cacheName ) ;
+ }
public void deleteVtep(BigInteger dpnId, String portName, Integer vlanId, String ipAddress, String subnetMask,
String gatewayIp, String transportZone,CommandSession session) throws TepException {
vtepDelCommitList.add(vtepCli);
}
else if(session != null) {
- session.getConsole().println(String.format("vtep with this vlan or gateway doesnt exist"));
+ session.getConsole().println("vtep with this vlan or gateway doesnt exist");
}
}
}
else if(session != null) {
- session.getConsole().println(String.format("Vtep with this ipaddress doesnt exist"));
+ session.getConsole().println("Vtep with this ipaddress doesnt exist");
}
} else if(session != null) {
- session.getConsole().println(String.format("Vtep Doesnt exist"));
+ session.getConsole().println("Vtep Doesnt exist");
}
}
}
}
}
- public void showState(TunnelList tunnels, boolean tunnelMonitorEnabled, CommandSession session) throws TepException {
- IfTunnel tunnelInterface = null;
- IfL2vlan l2Vlan = null;
- List<InternalTunnel> tunnelLists = tunnels.getInternalTunnel();
+ public void showState(List<StateTunnelList> tunnelLists, boolean tunnelMonitorEnabled,CommandSession session) throws TepException{
if (tunnelLists == null || tunnelLists.isEmpty()) {
handleError("No Internal Tunnels Exist", session);
return;
session.getConsole().println("Tunnel Monitoring is Off");
}
}
- String displayFormat = "%-16s %-16s %-16s %-16s %-16s %-8s %-10s %-10s";
- if(session != null) {
- session.getConsole().println(String.format(displayFormat, "Tunnel Name", "Source-DPN",
- "Destination-DPN", "Source-IP", "Destination-IP", "Vlan Id", "Trunk-State", "Transport Type"));
- session.getConsole().println("-------------------------------------------------------------------------------------------------------------------------------------");
-
- }
- for (InternalTunnel tunnel : tunnelLists) {
- String tunnelInterfaceName = tunnel.getTunnelInterfaceName();
- LOG.trace("tunnelInterfaceName::: {}", tunnelInterfaceName);
-
- InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface> ifStateId =
- ItmUtils.buildStateInterfaceId(tunnelInterfaceName);
- Optional<org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface> ifStateOptional =
- ItmUtils.read(LogicalDatastoreType.OPERATIONAL, ifStateId, dataBroker);
- String tunnelState = "DOWN" ;
- if (ifStateOptional.isPresent()) {
- org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface iface = ifStateOptional.get() ;
- if(iface.getAdminStatus() == AdminStatus.Up && iface.getOperStatus() == OperStatus.Up)
- tunnelState = "UP" ;
- }
- InstanceIdentifier<Interface> trunkIdentifier = ItmUtils.buildId(tunnelInterfaceName);
- Optional<Interface> ifaceObj = ItmUtils.read(LogicalDatastoreType.CONFIGURATION, trunkIdentifier, dataBroker) ;
- if (ifaceObj.isPresent()) {
- l2Vlan = (IfL2vlan) ifaceObj.get().getAugmentation(IfL2vlan.class);
- tunnelInterface = (IfTunnel) ifaceObj.get().getAugmentation(IfTunnel.class);
-
- Class<? extends TunnelTypeBase> tunType = tunnelInterface.getTunnelInterfaceType();
+ String displayFormat = "%-16s %-16s %-16s %-16s %-16s %-10s %-10s";
+ System.out.println(String.format(displayFormat, "Tunnel Name", "Source-DPN",
+ "Destination-DPN", "Source-IP", "Destination-IP", "Trunk-State", "Transport Type"));
+ System.out.println("-------------------------------------------------------------------------------------------------------------------------------------");
+
+ for (StateTunnelList tunnelInst : tunnelLists) {
+ // Display only the internal tunnels
+ if( tunnelInst.getDstInfo().getTepDeviceType().equals(TepTypeInternal.class)) {
+ String tunnelInterfaceName = tunnelInst.getTunnelInterfaceName();
+ LOG.trace("tunnelInterfaceName::: {}", tunnelInterfaceName);
+ String tunnelState = ITMConstants.TUNNEL_STATE_UNKNOWN;
+ if (tunnelInst.getOperState() == TunnelOperStatus.Up)
+ tunnelState = ITMConstants.TUNNEL_STATE_UP;
+ else if (tunnelInst.getOperState() == TunnelOperStatus.Down )
+ tunnelState = ITMConstants.TUNNEL_STATE_DOWN;
+ Class<? extends TunnelTypeBase> tunType = tunnelInst.getTransportType();
String tunnelType = ITMConstants.TUNNEL_TYPE_VXLAN;
if( tunType.equals(TunnelTypeVxlan.class))
tunnelType = ITMConstants.TUNNEL_TYPE_VXLAN ;
else if( tunType.equals(TunnelTypeGre.class) )
tunnelType = ITMConstants.TUNNEL_TYPE_GRE ;
- int vlanId = 0;
- if( l2Vlan != null ) {
- vlanId = l2Vlan.getVlanId().getValue() ;
- }
- if(session != null) {
- session.getConsole().println(String.format(displayFormat, tunnel.getTunnelInterfaceName(), tunnel
- .getSourceDPN().toString(), tunnel.getDestinationDPN().toString(), tunnelInterface.getTunnelSource().getIpv4Address().getValue(), tunnelInterface.getTunnelDestination().getIpv4Address().getValue(), vlanId, tunnelState,
+ else if (tunType.equals(TunnelTypeMplsOverGre.class))
+ tunnelType = ITMConstants.TUNNEL_TYPE_MPLSoGRE;
+ System.out.println(String.format(displayFormat, tunnelInst.getTunnelInterfaceName(), tunnelInst.getSrcInfo().getTepDeviceId(),
+ tunnelInst.getDstInfo().getTepDeviceId(), tunnelInst.getSrcInfo().getTepIp().getIpv4Address().getValue(), tunnelInst.getDstInfo().getTepIp().getIpv4Address().getValue(), tunnelState,
tunnelType));
- }
}
}
}
SubnetObject subObCli = new SubnetObject(gatewayIpObj, subnetsKey, subnetMaskObj, vlanId);
if (tZones.containsKey(transportZone)) {
- Map<SubnetObject, List<Vteps>> subVtepMapTemp = (Map<SubnetObject, List<Vteps>>) tZones.get(transportZone);
+ Map<SubnetObject, List<Vteps>> subVtepMapTemp = tZones.get(transportZone);
if (subVtepMapTemp.containsKey(subObCli)) { // if Subnet exists
- List<Vteps> vtepListTemp = (List<Vteps>) subVtepMapTemp.get(subObCli);
+ List<Vteps> vtepListTemp = subVtepMapTemp.get(subObCli);
if (vtepListTemp.contains(vtepCli)) {
exists = true; // return true if tzones has vtep
vtepListTemp.remove(vtepCli);
public void configureTunnelType(String tZoneName, String tunnelType) {
LOG.debug("configureTunnelType {} for transportZone {}", tunnelType, tZoneName);
- TransportZone tZoneFromConfigDS = getTransportZoneFromConfigDS(tZoneName);
+ TransportZone tZoneFromConfigDS = ItmUtils.getTransportZoneFromConfigDS(tZoneName, dataBroker);
validateTunnelType(tZoneName, tunnelType,tZoneFromConfigDS);
if (tZoneFromConfigDS != null) {
// if (tZone != null) {
if (tZoneFromConfigDS != null) {
if( (!tZoneFromConfigDS.getTunnelType().equals(tunType)) && ItmUtils.isNotEmpty(tZoneFromConfigDS.getSubnets())) {
- String errorMsg = new StringBuilder("Changing the tunnel type from ").append(tZoneFromConfigDS.getTunnelType())
- .append(" to ").append(strTunnelType)
- .append(" is not allowed for already configured transport zone [").append(tZoneName)
- .append("].").toString();
+ String errorMsg = "Changing the tunnel type from " + tZoneFromConfigDS.getTunnelType() +
+ " to " + strTunnelType +
+ " is not allowed for already configured transport zone [" + tZoneName +
+ "].";
Preconditions.checkArgument(false, errorMsg);
}
}
Code Review / genius.git / blobdiff