/*
- * Copyright (c) 2016 Ericsson India Global Services Pvt Ltd. and others. All rights reserved.
+ * Copyright (c) 2016, 2017 Ericsson India Global Services Pvt Ltd. and others. All rights reserved.
*
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
*/
package org.opendaylight.genius.itm.impl;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
+import com.google.common.util.concurrent.ListenableFuture;
import java.math.BigInteger;
+import java.util.Collection;
import java.util.List;
import java.util.concurrent.ExecutionException;
-import java.util.concurrent.Future;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
+import javax.annotation.PostConstruct;
+import javax.annotation.PreDestroy;
+import javax.inject.Inject;
+import javax.inject.Singleton;
import org.apache.felix.service.command.CommandSession;
-import java.util.regex.Matcher;
-import java.util.regex.Pattern;
-
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService;
-import org.opendaylight.controller.md.sal.binding.api.NotificationService;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.sal.binding.api.BindingAwareBroker;
-import org.opendaylight.controller.sal.binding.api.BindingAwareBroker.ProviderContext;
-import org.opendaylight.controller.sal.binding.api.BindingAwareProvider;
import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
-import org.opendaylight.genius.interfacemanager.interfaces.IInterfaceManager;
import org.opendaylight.genius.itm.api.IITMProvider;
+import org.opendaylight.genius.itm.cache.DpnTepStateCache;
import org.opendaylight.genius.itm.cli.TepCommandHelper;
-import org.opendaylight.genius.itm.listeners.cache.DpnTepsInfoListener;
import org.opendaylight.genius.itm.cli.TepException;
import org.opendaylight.genius.itm.globals.ITMConstants;
import org.opendaylight.genius.itm.listeners.InterfaceStateListener;
+import org.opendaylight.genius.itm.listeners.OvsdbNodeListener;
import org.opendaylight.genius.itm.listeners.TransportZoneListener;
-import org.opendaylight.genius.itm.listeners.cache.StateTunnelListListener;
import org.opendaylight.genius.itm.listeners.TunnelMonitorChangeListener;
import org.opendaylight.genius.itm.listeners.TunnelMonitorIntervalListener;
import org.opendaylight.genius.itm.listeners.VtepConfigSchemaListener;
-import org.opendaylight.genius.itm.listeners.cache.ItmMonitoringIntervalListener;
-import org.opendaylight.genius.itm.listeners.cache.ItmMonitoringListener;
import org.opendaylight.genius.itm.monitoring.ItmTunnelEventListener;
import org.opendaylight.genius.itm.rpc.ItmManagerRpcService;
-import org.opendaylight.genius.itm.snd.ITMStatusMonitor;
import org.opendaylight.genius.mdsalutil.MDSALUtil;
-import org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager;
-import org.opendaylight.genius.utils.cache.DataStoreCache;
+import org.opendaylight.infrautils.utils.concurrent.JdkFutures;
+import org.opendaylight.mdsal.eos.binding.api.Entity;
+import org.opendaylight.mdsal.eos.binding.api.EntityOwnershipCandidateRegistration;
+import org.opendaylight.mdsal.eos.binding.api.EntityOwnershipService;
+import org.opendaylight.mdsal.eos.common.api.CandidateAlreadyRegisteredException;
+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.interfaces.rev140508.interfaces.Interface;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.CreateIdPoolInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.CreateIdPoolInputBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.CreateIdPoolOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.IdManagerService;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
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.VtepConfigSchemas;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.config.rev160406.vtep.config.schemas.VtepConfigSchema;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.config.rev160406.vtep.config.schemas.VtepConfigSchemaBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.TunnelList;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.ItmRpcService;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.ExternalTunnelList;
-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.ExternalTunnelBuilder;
-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.tunnels_state.StateTunnelList;
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.RemoveExternalTunnelEndpointInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.AddExternalTunnelEndpointInputBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.RemoveExternalTunnelEndpointInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.RemoveExternalTunnelEndpointInputBuilder;
-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.rpcs.rev160406.*;
import org.opendaylight.yangtools.yang.common.RpcResult;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-public class ItmProvider implements BindingAwareProvider, AutoCloseable, IITMProvider /*,ItmStateService */{
+@Singleton
+public class ItmProvider implements AutoCloseable, IITMProvider /*,ItmStateService */ {
private static final Logger LOG = LoggerFactory.getLogger(ItmProvider.class);
- private IInterfaceManager interfaceManager;
- private ITMManager itmManager;
- private IMdsalApiManager mdsalManager;
- private DataBroker dataBroker;
- private NotificationPublishService notificationPublishService;
- private ItmManagerRpcService itmRpcService ;
- private IdManagerService idManager;
- private NotificationService notificationService;
- private TepCommandHelper tepCommandHelper;
- private TransportZoneListener tzChangeListener;
- private TunnelMonitorChangeListener tnlToggleListener;
- private TunnelMonitorIntervalListener tnlIntervalListener;
- private VtepConfigSchemaListener vtepConfigSchemaListener;
- private InterfaceStateListener ifStateListener;
+
+ private final DataBroker dataBroker;
+ private final ItmManagerRpcService itmRpcService ;
+ private final IdManagerService idManager;
+ private final TepCommandHelper tepCommandHelper;
+ private final TransportZoneListener tzChangeListener;
+ private final TunnelMonitorChangeListener tnlToggleListener;
+ private final TunnelMonitorIntervalListener tnlIntervalListener;
+ private final VtepConfigSchemaListener vtepConfigSchemaListener;
+ private final InterfaceStateListener ifStateListener;
+ private final EntityOwnershipService entityOwnershipService;
private RpcProviderRegistry rpcProviderRegistry;
- private static final ITMStatusMonitor itmStatusMonitor = ITMStatusMonitor.getInstance();
- private ItmTunnelEventListener itmStateListener;
- private ItmMonitoringListener itmMonitoringListener;
- private ItmMonitoringIntervalListener itmMonitoringIntervalListener;
+ private final ItmTunnelEventListener itmStateListener;
+ private final OvsdbNodeListener ovsdbChangeListener;
static short flag = 0;
- private StateTunnelListListener tunnelStateListener ;
- private DpnTepsInfoListener dpnTepsInfoListener ;
- public ItmProvider() {
+ private final TunnelMonitoringConfig tunnelMonitoringConfig;
+ private EntityOwnershipCandidateRegistration registryCandidate;
+ private final DpnTepStateCache dpnTepStateCache;
+
+ @Inject
+ public ItmProvider(DataBroker dataBroker,
+ IdManagerService idManagerService,
+ InterfaceStateListener interfaceStateListener,
+ ItmManagerRpcService itmManagerRpcService,
+ ItmTunnelEventListener itmTunnelEventListener,
+ TepCommandHelper tepCommandHelper,
+ TunnelMonitorChangeListener tunnelMonitorChangeListener,
+ TunnelMonitorIntervalListener tunnelMonitorIntervalListener,
+ TransportZoneListener transportZoneListener,
+ VtepConfigSchemaListener vtepConfigSchemaListener,
+ OvsdbNodeListener ovsdbNodeListener,
+ TunnelMonitoringConfig tunnelMonitoringConfig,
+ EntityOwnershipService entityOwnershipService,
+ DpnTepStateCache dpnTepStateCache) {
LOG.info("ItmProvider Before register MBean");
- itmStatusMonitor.registerMbean();
- }
-
- public void setRpcProviderRegistry(RpcProviderRegistry rpcProviderRegistry) {
- this.rpcProviderRegistry = rpcProviderRegistry;
+ this.dataBroker = dataBroker;
+ this.idManager = idManagerService;
+ this.ifStateListener = interfaceStateListener;
+ this.itmRpcService = itmManagerRpcService;
+ this.itmStateListener = itmTunnelEventListener;
+ this.tepCommandHelper = tepCommandHelper;
+ this.tnlToggleListener = tunnelMonitorChangeListener;
+ this.tnlIntervalListener = tunnelMonitorIntervalListener;
+ this.tzChangeListener = transportZoneListener;
+ this.vtepConfigSchemaListener = vtepConfigSchemaListener;
+ this.ovsdbChangeListener = ovsdbNodeListener;
+ this.tunnelMonitoringConfig = tunnelMonitoringConfig;
+ this.entityOwnershipService = entityOwnershipService;
+ this.dpnTepStateCache = dpnTepStateCache;
+ ITMBatchingUtils.registerWithBatchManager(this.dataBroker);
}
- public RpcProviderRegistry getRpcProviderRegistry() {
- return this.rpcProviderRegistry;
- }
-
- @Override
- public void onSessionInitiated(ProviderContext session) {
- LOG.info("ItmProvider Session Initiated");
- itmStatusMonitor.reportStatus("STARTING");
+ @PostConstruct
+ @SuppressWarnings("checkstyle:IllegalCatch")
+ public void start() {
try {
- dataBroker = session.getSALService(DataBroker.class);
- idManager = getRpcProviderRegistry().getRpcService(IdManagerService.class);
-
- itmManager = new ITMManager(dataBroker);
- tzChangeListener = new TransportZoneListener(dataBroker, idManager) ;
- itmRpcService = new ItmManagerRpcService(dataBroker, idManager);
- vtepConfigSchemaListener = new VtepConfigSchemaListener(dataBroker);
- this.ifStateListener = new InterfaceStateListener(dataBroker);
- tnlToggleListener = new TunnelMonitorChangeListener(dataBroker);
- tnlIntervalListener = new TunnelMonitorIntervalListener(dataBroker);
- tepCommandHelper = new TepCommandHelper(dataBroker);
- getRpcProviderRegistry().addRpcImplementation(ItmRpcService.class, itmRpcService);
- itmRpcService.setMdsalManager(mdsalManager);
- itmManager.setMdsalManager(mdsalManager);
- itmManager.setNotificationPublishService(notificationPublishService);
- itmManager.setMdsalManager(mdsalManager);
- tzChangeListener.setMdsalManager(mdsalManager);
- tzChangeListener.setItmManager(itmManager);
- tzChangeListener.registerListener(LogicalDatastoreType.CONFIGURATION, dataBroker);
- tnlIntervalListener.registerListener(LogicalDatastoreType.CONFIGURATION, dataBroker);
- tnlToggleListener.registerListener(LogicalDatastoreType.CONFIGURATION, dataBroker);
- tepCommandHelper = new TepCommandHelper(dataBroker);
- tepCommandHelper.setInterfaceManager(interfaceManager);
- tepCommandHelper.configureTunnelType(ITMConstants.DEFAULT_TRANSPORT_ZONE,ITMConstants.TUNNEL_TYPE_VXLAN);
- itmStateListener =new ItmTunnelEventListener(dataBroker);
createIdPool();
- itmStatusMonitor.reportStatus("OPERATIONAL");
- DataStoreCache.create(ITMConstants.ITM_MONIRORING_PARAMS_CACHE_NAME);
- itmMonitoringListener = new ItmMonitoringListener(dataBroker);
- itmMonitoringIntervalListener = new ItmMonitoringIntervalListener(dataBroker);
- DataStoreCache.create(ITMConstants.TUNNEL_STATE_CACHE_NAME) ;
- tunnelStateListener = new StateTunnelListListener(dataBroker);
- DataStoreCache.create(ITMConstants.DPN_TEPs_Info_CACHE_NAME) ;
- dpnTepsInfoListener = new DpnTepsInfoListener(dataBroker);
- } catch (Exception e) {
- LOG.error("Error initializing services", e);
- itmStatusMonitor.reportStatus("ERROR");
+ registerEntityForOwnership();
+ LOG.info("ItmProvider Started");
+ } catch (Exception ex) {
+ LOG.info("ItmProvider failed to start");
}
}
- public void setInterfaceManager(IInterfaceManager interfaceManager) {
- this.interfaceManager = interfaceManager;
- }
-
- public void setNotificationPublishService(NotificationPublishService notificationPublishService) {
- this.notificationPublishService = notificationPublishService;
- }
-
- public void setMdsalApiManager(IMdsalApiManager mdsalMgr) {
- this.mdsalManager = mdsalMgr;
- }
- public void setNotificationService(NotificationService notificationService) {
- this.notificationService = notificationService;
+ private void registerEntityForOwnership() {
+ try {
+ this.registryCandidate = entityOwnershipService
+ .registerCandidate(new Entity(ITMConstants.ITM_CONFIG_ENTITY, ITMConstants.ITM_CONFIG_ENTITY));
+ } catch (CandidateAlreadyRegisteredException e) {
+ LOG.error("failed to register entity {} for entity-ownership-service", e.getEntity());
+ }
}
@Override
- public void close() throws Exception {
- if (itmManager != null) {
- itmManager.close();
- }
+ @PreDestroy
+ public void close() {
if (tzChangeListener != null) {
tzChangeListener.close();
}
if (tnlIntervalListener != null) {
tnlIntervalListener.close();
}
- if(tnlToggleListener!= null){
+ if (tnlToggleListener != null) {
tnlToggleListener.close();
}
- if(tunnelStateListener!= null){
- tunnelStateListener.close();
+ if (ovsdbChangeListener != null) {
+ ovsdbChangeListener.close();
}
- if(dpnTepsInfoListener!= null){
- dpnTepsInfoListener.close();
+ if (registryCandidate != null) {
+ registryCandidate.close();
}
LOG.info("ItmProvider Closed");
}
.setHigh(new BigInteger(ITMConstants.ITM_IDPOOL_SIZE).longValue())
.build();
try {
- Future<RpcResult<Void>> result = idManager.createIdPool(createPool);
- if ((result != null) && (result.get().isSuccessful())) {
+ ListenableFuture<RpcResult<CreateIdPoolOutput>> result = idManager.createIdPool(createPool);
+ if (result != null && result.get().isSuccessful()) {
LOG.debug("Created IdPool for ITM Service");
}
} catch (InterruptedException | ExecutionException e) {
- LOG.error("Failed to create idPool for ITM Service",e);
+ LOG.error("Failed to create idPool for ITM Service ", e);
}
}
return dataBroker;
}
+ @Override
public void addExternalEndpoint(Class<? extends TunnelTypeBase> tunnelType, IpAddress dcgwIP) {
AddExternalTunnelEndpointInput addExternalTunnelEndpointInput =
new AddExternalTunnelEndpointInputBuilder().setTunnelType(tunnelType)
.setDestinationIp(dcgwIP).build();
- itmRpcService.addExternalTunnelEndpoint(addExternalTunnelEndpointInput);
+ JdkFutures.addErrorLogging(itmRpcService.addExternalTunnelEndpoint(addExternalTunnelEndpointInput),
+ LOG, "addExternalTunnelEndpoint");
}
+ @Override
public void remExternalEndpoint(Class<? extends TunnelTypeBase> tunnelType, IpAddress dcgwIP) {
RemoveExternalTunnelEndpointInput removeExternalTunnelEndpointInput =
new RemoveExternalTunnelEndpointInputBuilder().setTunnelType(tunnelType)
.setDestinationIp(dcgwIP).build();
- itmRpcService.removeExternalTunnelEndpoint(removeExternalTunnelEndpointInput);
+ JdkFutures.addErrorLogging(itmRpcService.removeExternalTunnelEndpoint(removeExternalTunnelEndpointInput),
+ LOG, "removeExternalTunnelEndpoint");
}
+
@Override
public void createLocalCache(BigInteger dpnId, String portName, Integer vlanId, String ipAddress, String subnetMask,
String gatewayIp, String transportZone, CommandSession session) {
if (tepCommandHelper != null) {
try {
- tepCommandHelper.createLocalCache(dpnId, portName, vlanId, ipAddress, subnetMask, gatewayIp, transportZone, session);
+ tepCommandHelper.createLocalCache(dpnId, portName, vlanId, ipAddress, subnetMask,
+ gatewayIp, transportZone, session);
} catch (TepException e) {
- LOG.error(e.getMessage());
+ LOG.error("Create Local Cache failed", e);
}
} else {
LOG.trace("tepCommandHelper doesnt exist");
@Override
public void commitTeps() {
- try {
- tepCommandHelper.deleteOnCommit();
- tepCommandHelper.buildTeps();
- } catch (Exception e) {
- LOG.debug("unable to configure teps" + e.toString());
- }
+ tepCommandHelper.deleteOnCommit();
+ tepCommandHelper.buildTeps();
}
@Override
public void showTeps(CommandSession session) {
try {
- tepCommandHelper.showTeps(itmManager.getTunnelMonitorEnabledFromConfigDS(), ItmUtils.determineMonitorInterval(this.dataBroker), session);
+ tepCommandHelper.showTeps(tunnelMonitoringConfig.isTunnelMonitoringEnabled(),
+ tunnelMonitoringConfig.getMonitorInterval(), session);
} catch (TepException e) {
- LOG.error(e.getMessage());
+ LOG.error("show teps failed", e);
}
}
- public void showState(List<StateTunnelList> tunnels,CommandSession session) {
+ @Override
+ public void showState(Collection<StateTunnelList> tunnels,CommandSession session) {
if (tunnels != null) {
try {
- tepCommandHelper.showState(tunnels, itmManager.getTunnelMonitorEnabledFromConfigDS(), session);
- }catch(TepException e) {
- LOG.error(e.getMessage());
+ tepCommandHelper.showState(tunnels, tunnelMonitoringConfig.isTunnelMonitoringEnabled(), session);
+ } catch (TepException e) {
+ LOG.error("show state failed", e);
}
- }else
+ } else {
LOG.debug("No tunnels available");
+ }
}
@Override
- public void showCache( String cacheName) {
+ public void showCache(String cacheName) {
tepCommandHelper.showCache(cacheName);
}
+ @Override
public void deleteVtep(BigInteger dpnId, String portName, Integer vlanId, String ipAddress, String subnetMask,
String gatewayIp, String transportZone, CommandSession session) {
try {
- tepCommandHelper.deleteVtep(dpnId, portName, vlanId, ipAddress, subnetMask, gatewayIp, transportZone, session);
- } catch (Exception e) {
- LOG.error(e.getMessage());
+ tepCommandHelper.deleteVtep(dpnId, portName, vlanId, ipAddress,
+ subnetMask, gatewayIp, transportZone, session);
+ } catch (TepException e) {
+ LOG.error("Delete Vteps Failed", e);
}
}
@Override
public VtepConfigSchema getVtepConfigSchema(String schemaName) {
- Optional<VtepConfigSchema> schema = ItmUtils.read(LogicalDatastoreType.CONFIGURATION,
- ItmUtils.getVtepConfigSchemaIdentifier(schemaName), this.dataBroker);
- if (schema.isPresent()) {
- return schema.get();
- }
- return null;
+ return ItmUtils.read(LogicalDatastoreType.CONFIGURATION, ItmUtils.getVtepConfigSchemaIdentifier(schemaName),
+ this.dataBroker).orNull();
}
@Override
public List<VtepConfigSchema> getAllVtepConfigSchemas() {
- Optional<VtepConfigSchemas> schemas = ItmUtils.read(LogicalDatastoreType.CONFIGURATION,
- ItmUtils.getVtepConfigSchemasIdentifier(), this.dataBroker);
- if (schemas.isPresent()) {
- return schemas.get().getVtepConfigSchema();
- }
- return null;
+ return ItmUtils.read(LogicalDatastoreType.CONFIGURATION, ItmUtils.getVtepConfigSchemasIdentifier(),
+ this.dataBroker).toJavaUtil().map(VtepConfigSchemas::getVtepConfigSchema).orElse(null);
}
@Override
/* if (ItmUtils.getDpnIdList(schema.getDpnIds()).isEmpty()) {
builder.setDpnIds(schema.getDpnIds());
} else {*/
- if (lstDpnsForAdd != null && !lstDpnsForAdd.isEmpty()) {
- List<BigInteger> originalDpnList = ItmUtils.getDpnIdList(schema.getDpnIds()) ;
- originalDpnList.addAll(lstDpnsForAdd) ;
- builder.setDpnIds(ItmUtils.getDpnIdsListFromBigInt(originalDpnList));
- }
- if (lstDpnsForDelete != null && !lstDpnsForDelete.isEmpty()) {
- List<BigInteger> originalDpnList = ItmUtils.getDpnIdList(schema.getDpnIds()) ;
- originalDpnList.removeAll(lstDpnsForDelete) ;
- builder.setDpnIds(ItmUtils.getDpnIdsListFromBigInt(originalDpnList)) ;
- // schema.setDpnIds(ItmUtils.getDpnIdsListFromBigInt(ItmUtils.getDpnIdList(schema.getDpnIds()).removeAll(lstDpnsForAdd)));
- }
- // }
+ if (lstDpnsForAdd != null && !lstDpnsForAdd.isEmpty()) {
+ List<BigInteger> originalDpnList = ItmUtils.getDpnIdList(schema.getDpnIds());
+ originalDpnList.addAll(lstDpnsForAdd) ;
+ builder.setDpnIds(ItmUtils.getDpnIdsListFromBigInt(originalDpnList));
+ }
+ if (lstDpnsForDelete != null && !lstDpnsForDelete.isEmpty()) {
+ List<BigInteger> originalDpnList = ItmUtils.getDpnIdList(schema.getDpnIds());
+ originalDpnList.removeAll(lstDpnsForDelete) ;
+ builder.setDpnIds(ItmUtils.getDpnIdsListFromBigInt(originalDpnList));
+ // schema.setDpnIds(ItmUtils.getDpnIdsListFromBigInt(ItmUtils.getDpnIdList(schema.getDpnIds())
+ // .removeAll(lstDpnsForAdd)));
+ }
+ // }
schema = builder.build();
MDSALUtil.syncWrite(this.dataBroker, LogicalDatastoreType.CONFIGURATION,
ItmUtils.getVtepConfigSchemaIdentifier(schemaName), schema);
- LOG.debug("Vtep config schema {} updated to config DS with DPN's {}", schemaName, ItmUtils.getDpnIdList(schema.getDpnIds()));
+ LOG.debug("Vtep config schema {} updated to config DS with DPN's {}",
+ schemaName, ItmUtils.getDpnIdList(schema.getDpnIds()));
}
@Override
LOG.debug("Deleted all Vtep schemas from config DS");
}
+ @Override
public void configureTunnelMonitorParams(boolean monitorEnabled, String monitorProtocol) {
tepCommandHelper.configureTunnelMonitorParams(monitorEnabled, monitorProtocol);
}
+ @Override
public void configureTunnelMonitorInterval(int interval) {
tepCommandHelper.configureTunnelMonitorInterval(interval);
}
-
- public boolean validateIP (final String ip){
- if (ip == null || ip.equals("")) {
+
+ @Override
+ public boolean validateIP(final String ip) {
+ if ((ip == null) || ip.isEmpty() || "null".equals(ip) || "0.0.0.0".equals(ip)) {
return false;
}
- final String PATTERN =
+ final String PTRN =
"^(([01]?\\d\\d?|2[0-4]\\d|25[0-5])\\.){3}([01]?\\d\\d?|2[0-4]\\d|25[0-5])$";
- Pattern pattern = Pattern.compile(PATTERN);
+ Pattern pattern = Pattern.compile(PTRN);
Matcher matcher = pattern.matcher(ip);
return matcher.matches();
}
+
+ @Override
+ public Interface getInterface(String tunnelName) {
+ return dpnTepStateCache.getInterfaceFromCache(tunnelName);
+ }
}
Code Review / genius.git / blobdiff