@Override
public void updateInterfaceParentRef(String interfaceName, String parentInterface) {
- // This should generally be called by EOS Owner for IFACE_ENTITY - runOnlyInLeaderNode()
+ // This should generally be called by EOS Owner for INTERFACE_CONFIG_ENTITY - runOnlyInLeaderNode()
updateInterfaceParentRef(interfaceName, parentInterface, true);
}
@Override
public void updateInterfaceParentRef(String interfaceName, String parentInterface, boolean readInterfaceBeforeWrite) {
- // This should generally be called by EOS Owner for IFACE_ENTITY - runOnlyInLeaderNode()
+ // This should generally be called by EOS Owner for INTERFACE_CONFIG_ENTITY - runOnlyInLeaderNode()
if (interfaceName == null) {
return;
}
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.List;
-import java.util.Objects;
import java.util.concurrent.ConcurrentHashMap;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
MDSALUtil.syncUpdate(broker, LogicalDatastoreType.OPERATIONAL, interfaceId, interfaceData);
}
- public static void createInterfaceChildEntry(String parentInterface, String childInterface) {
+ public static void createInterfaceChildEntry(String parentInterface, String childInterface,
+ Optional<WriteTransaction> txOptional) {
InterfaceParentEntryKey interfaceParentEntryKey = new InterfaceParentEntryKey(parentInterface);
InterfaceChildEntryKey interfaceChildEntryKey = new InterfaceChildEntryKey(childInterface);
InstanceIdentifier<InterfaceChildEntry> intfId = InterfaceMetaUtils
.getInterfaceChildEntryIdentifier(interfaceParentEntryKey, interfaceChildEntryKey);
InterfaceChildEntryBuilder entryBuilder = new InterfaceChildEntryBuilder().setKey(interfaceChildEntryKey)
.setChildInterface(childInterface);
- BatchingUtils.write(intfId, entryBuilder.build(), BatchingUtils.EntityType.DEFAULT_CONFIG);
+ if(!txOptional.isPresent()) {
+ BatchingUtils.write(intfId, entryBuilder.build(), BatchingUtils.EntityType.DEFAULT_CONFIG);
+ } else {
+ txOptional.get().put(LogicalDatastoreType.CONFIGURATION, intfId, entryBuilder.build(), true);
+ }
}
public static void deleteInterfaceChildEntry(String parentInterface, String childInterface) {
LOG.info("Creating child interface {} of type {} bound on parent-interface {}",
childInterface, l2vlanMode, parentInterface);
- createInterfaceChildEntry(parentInterface, childInterface);
+ createInterfaceChildEntry(parentInterface, childInterface, Optional.of(tx) );
return true;
}
String synchronizationKey = isTunnelInterface ?
parentRefs.getDatapathNodeIdentifier().toString() : parentRefs.getParentInterface();
coordinator.enqueueJob(synchronizationKey, configWorker, IfmConstants.JOB_MAX_RETRIES);
- });
+ }, IfmClusterUtils.INTERFACE_CONFIG_ENTITY);
}
@Override
interfaceOld.getName() : parentRefs.getParentInterface();
coordinator.enqueueJob(synchronizationKey, configWorker, IfmConstants.JOB_MAX_RETRIES);
- });
+ }, IfmClusterUtils.INTERFACE_CONFIG_ENTITY);
}
@Override
String synchronizationKey = isTunnelInterface ?
interfaceNew.getName() : parentRefs.getParentInterface();
coordinator.enqueueJob(synchronizationKey, configWorker, IfmConstants.JOB_MAX_RETRIES);
- });
+ }, IfmClusterUtils.INTERFACE_CONFIG_ENTITY);
}
private class RendererConfigAddWorker implements Callable<List<ListenableFuture<Void>>> {
String portName = InterfaceManagerCommonUtils.getPortNameForInterface(nodeConnectorId, flowCapableNodeConnectorOld.getName());
remove(nodeConnectorId, null, flowCapableNodeConnectorOld, portName, true);
- });
+ }, IfmClusterUtils.INTERFACE_CONFIG_ENTITY);
}
@Override
InterfaceStateUpdateWorker portStateUpdateWorker = new InterfaceStateUpdateWorker(key, fcNodeConnectorOld,
fcNodeConnectorNew, portName);
coordinator.enqueueJob(portName, portStateUpdateWorker, IfmConstants.JOB_MAX_RETRIES);
- });
+ }, IfmClusterUtils.INTERFACE_CONFIG_ENTITY);
}
@Override
InterfaceStateAddWorker ifStateAddWorker = new InterfaceStateAddWorker(idManager, nodeConnectorId,
fcNodeConnectorNew, portName);
coordinator.enqueueJob(portName, ifStateAddWorker, IfmConstants.JOB_MAX_RETRIES);
- });
+ }, IfmClusterUtils.INTERFACE_CONFIG_ENTITY);
}
private void remove(NodeConnectorId nodeConnectorIdNew, NodeConnectorId nodeConnectorIdOld,
}
return futures;
});
- });
+ }, IfmClusterUtils.INTERFACE_CONFIG_ENTITY);
}
@Override
tpNew.getName(), newInterfaceName, parentRefName);
interfaceMgrProvider.updateInterfaceParentRef(newInterfaceName, parentRefName);
}
- });
+ }, IfmClusterUtils.INTERFACE_CONFIG_ENTITY);
}
@Override
*/
package org.opendaylight.genius.interfacemanager.renderer.ovs.confighelpers;
+import com.google.common.base.Optional;
import com.google.common.util.concurrent.ListenableFuture;
import java.math.BigInteger;
import java.util.ArrayList;
createTunnelPort = bridgeEntry == null || bridgeEntry.getBridgeInterfaceEntry() == null ?
true : bridgeEntry.getBridgeInterfaceEntry().isEmpty();
tunnelName = SouthboundUtils.generateOfTunnelName(dpId, ifTunnel);
- InterfaceManagerCommonUtils.createInterfaceChildEntry(tunnelName, interfaceNew.getName());
+ InterfaceManagerCommonUtils.createInterfaceChildEntry(tunnelName, interfaceNew.getName(), Optional.absent());
}
LOG.debug("creating bridge interfaceEntry in ConfigDS {}", dpId);
*/
package org.opendaylight.genius.interfacemanager.renderer.ovs.confighelpers;
+import com.google.common.base.Optional;
import com.google.common.util.concurrent.ListenableFuture;
import java.util.ArrayList;
import java.util.List;
+
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
import org.opendaylight.genius.interfacemanager.commons.InterfaceManagerCommonUtils;
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.InterfaceKey;
IdManagerService idManager) {
LOG.debug("add vlan member configuration {}",interfaceNew.getName());
List<ListenableFuture<Void>> futures = new ArrayList<>();
-
- InterfaceManagerCommonUtils.createInterfaceChildEntry(parentRefs.getParentInterface(), interfaceNew.getName());
+ WriteTransaction writeTransaction = dataBroker.newWriteOnlyTransaction();
+ InterfaceManagerCommonUtils.createInterfaceChildEntry(parentRefs.getParentInterface(),
+ interfaceNew.getName(), Optional.of(writeTransaction));
+ futures.add(writeTransaction.submit());
InterfaceKey interfaceKey = new InterfaceKey(parentRefs.getParentInterface());
Interface ifaceParent = InterfaceManagerCommonUtils.getInterfaceFromConfigDS(interfaceKey, dataBroker);
}
return futures;
});
- });
+ }, IfmClusterUtils.INTERFACE_CONFIG_ENTITY);
return null;
}
public class IfmClusterUtils {
private static final Logger LOG = LoggerFactory.getLogger(IfmClusterUtils.class);
- public static final String IFACE_ENTITY = "iface";
+ public static final String INTERFACE_CONFIG_ENTITY = "interface_config";
+ public static final String INTERFACE_SERVICE_BINDING_ENTITY = "interface_service_binding";
private static InterfacemgrProvider ifaceServiceProvider = null;
EntityOwnershipService entityOwnershipService) {
setIfaceServiceProvider(provider);
try {
- EntityOwnerUtils.registerEntityCandidateForOwnerShip(entityOwnershipService,
- IFACE_ENTITY, IFACE_ENTITY,
- null/*listener*/);
+ EntityOwnerUtils.registerEntityCandidateForOwnerShip(entityOwnershipService, INTERFACE_CONFIG_ENTITY,
+ INTERFACE_CONFIG_ENTITY, null/*listener*/);
+ EntityOwnerUtils.registerEntityCandidateForOwnerShip(entityOwnershipService, INTERFACE_SERVICE_BINDING_ENTITY,
+ INTERFACE_SERVICE_BINDING_ENTITY, null/*listener*/);
} catch (CandidateAlreadyRegisteredException e) {
- LOG.error("failed to register the entity, ",IFACE_ENTITY);
+ LOG.error("failed to register entity {} for entity-owenership-service", e.getEntity());
}
}
- public static void runOnlyInLeaderNode(final Runnable job) {
+ public static void runOnlyInLeaderNode(final Runnable job, String entity) {
ListenableFuture<Boolean> checkEntityOwnerFuture = ClusteringUtils.checkNodeEntityOwner(
- ifaceServiceProvider.getEntityOwnershipService(), IFACE_ENTITY, IFACE_ENTITY);
+ ifaceServiceProvider.getEntityOwnershipService(), entity, entity);
Futures.addCallback(checkEntityOwnerFuture, new FutureCallback<Boolean>() {
@Override
public void onSuccess(Boolean isOwner) {
if (isOwner) {
job.run();
} else {
- LOG.trace("job is not run as node is not owner for :{} ", IFACE_ENTITY);
+ LOG.trace("job is not run as node is not owner for :{} ", INTERFACE_CONFIG_ENTITY);
}
}
@Override
public void onFailure(Throwable error) {
- LOG.error("Failed to identify owner for entity {} due to {}", IFACE_ENTITY, error);
+ LOG.error("Failed to identify owner for entity {} due to {}", INTERFACE_CONFIG_ENTITY, error);
}
});
}
getIfBfdObj(BFD_PARAM_ENABLE, ifTunnel != null ? ifTunnel.isMonitorEnabled().toString() : "false"));
bfdParams.add(getIfBfdObj(BFD_PARAM_MIN_TX, ifTunnel != null && ifTunnel.getMonitorInterval() != null
? ifTunnel.getMonitorInterval().toString() : BFD_MIN_TX_VAL));
+ bfdParams.add(getIfBfdObj(BFD_FORWARDING_IF_RX_VAL, "true"));
return bfdParams;
}
import java.util.concurrent.Callable;
import javax.inject.Inject;
import javax.inject.Singleton;
+
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.genius.datastoreutils.AsyncDataTreeChangeListenerBase;
+import org.opendaylight.genius.datastoreutils.AsyncClusteredDataTreeChangeListenerBase;
import org.opendaylight.genius.datastoreutils.DataStoreJobCoordinator;
import org.opendaylight.genius.interfacemanager.IfmConstants;
import org.opendaylight.genius.interfacemanager.InterfacemgrProvider;
+import org.opendaylight.genius.interfacemanager.renderer.ovs.utilities.IfmClusterUtils;
import org.opendaylight.genius.interfacemanager.servicebindings.flowbased.config.factory.FlowBasedServicesConfigAddable;
import org.opendaylight.genius.interfacemanager.servicebindings.flowbased.config.factory.FlowBasedServicesConfigRemovable;
import org.opendaylight.genius.interfacemanager.servicebindings.flowbased.config.factory.FlowBasedServicesRendererFactory;
import org.opendaylight.genius.interfacemanager.servicebindings.flowbased.config.helpers.FlowBasedIngressServicesConfigBindHelper;
import org.opendaylight.genius.interfacemanager.servicebindings.flowbased.config.helpers.FlowBasedIngressServicesConfigUnbindHelper;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.servicebinding.rev160406.ServiceBindings;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.servicebinding.rev160406.ServiceModeBase;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.servicebinding.rev160406.service.bindings.ServicesInfo;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.servicebinding.rev160406.service.bindings.ServicesInfoKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.servicebinding.rev160406.service.bindings.services.info.BoundServices;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@Singleton
-public class FlowBasedServicesConfigListener extends AsyncDataTreeChangeListenerBase<BoundServices, FlowBasedServicesConfigListener> {
+public class FlowBasedServicesConfigListener extends AsyncClusteredDataTreeChangeListenerBase<BoundServices, FlowBasedServicesConfigListener> {
private static final Logger LOG = LoggerFactory.getLogger(FlowBasedServicesConfigListener.class);
@Inject
@Override
protected void remove(InstanceIdentifier<BoundServices> key, BoundServices boundServiceOld) {
- String interfaceName = InstanceIdentifier.keyOf(key.firstIdentifierOf(ServicesInfo.class)).getInterfaceName();
- LOG.info("Service Binding Entry removed for Interface: {}, Data: {}",
- interfaceName, boundServiceOld);
- Class<? extends ServiceModeBase> serviceMode = InstanceIdentifier
- .keyOf(key.firstIdentifierOf(ServicesInfo.class)).getServiceMode();
- FlowBasedServicesConfigRemovable flowBasedServicesConfigRemovable = FlowBasedServicesRendererFactory
- .getFlowBasedServicesRendererFactory(serviceMode). getFlowBasedServicesRemoveRenderer();
- DataStoreJobCoordinator coordinator = DataStoreJobCoordinator.getInstance();
- RendererConfigRemoveWorker configWorker = new RendererConfigRemoveWorker(flowBasedServicesConfigRemovable, key,
+ IfmClusterUtils.runOnlyInLeaderNode(() -> {
+ ServicesInfoKey serviceKey = InstanceIdentifier.keyOf(key.firstIdentifierOf(ServicesInfo.class));
+ LOG.info("Service Binding Entry removed for Interface: {}, Data: {}", serviceKey.getInterfaceName(),
boundServiceOld);
- coordinator.enqueueJob(interfaceName, configWorker, IfmConstants.JOB_MAX_RETRIES);
+ FlowBasedServicesConfigRemovable flowBasedServicesConfigRemovable =
+ FlowBasedServicesRendererFactory.getFlowBasedServicesRendererFactory(serviceKey.getServiceMode())
+ .getFlowBasedServicesRemoveRenderer();
+ DataStoreJobCoordinator coordinator = DataStoreJobCoordinator.getInstance();
+ RendererConfigRemoveWorker configWorker =
+ new RendererConfigRemoveWorker(flowBasedServicesConfigRemovable, key, boundServiceOld);
+ coordinator.enqueueJob(serviceKey.getInterfaceName(), configWorker, IfmConstants.JOB_MAX_RETRIES);
+ }, IfmClusterUtils.INTERFACE_SERVICE_BINDING_ENTITY);
}
@Override
@Override
protected void add(InstanceIdentifier<BoundServices> key, BoundServices boundServicesNew) {
- String interfaceName = InstanceIdentifier.keyOf(key.firstIdentifierOf(ServicesInfo.class)).getInterfaceName();
- LOG.info("Service Binding Entry created for Interface: {}, Data: {}",
- interfaceName, boundServicesNew);
- Class<? extends ServiceModeBase> serviceMode = InstanceIdentifier
- .keyOf(key.firstIdentifierOf(ServicesInfo.class)).getServiceMode();
-
- FlowBasedServicesConfigAddable flowBasedServicesAddable = FlowBasedServicesRendererFactory
- .getFlowBasedServicesRendererFactory(serviceMode).getFlowBasedServicesAddRenderer();
- DataStoreJobCoordinator coordinator = DataStoreJobCoordinator.getInstance();
- RendererConfigAddWorker configWorker = new RendererConfigAddWorker(flowBasedServicesAddable, key,
+ IfmClusterUtils.runOnlyInLeaderNode(() -> {
+ ServicesInfoKey serviceKey = InstanceIdentifier.keyOf(key.firstIdentifierOf(ServicesInfo.class));
+ LOG.info("Service Binding Entry created for Interface: {}, Data: {}", serviceKey.getInterfaceName(),
boundServicesNew);
- coordinator.enqueueJob(interfaceName, configWorker, IfmConstants.JOB_MAX_RETRIES);
+ FlowBasedServicesConfigAddable flowBasedServicesAddable =
+ FlowBasedServicesRendererFactory.getFlowBasedServicesRendererFactory(serviceKey.getServiceMode())
+ .getFlowBasedServicesAddRenderer();
+ DataStoreJobCoordinator coordinator = DataStoreJobCoordinator.getInstance();
+ RendererConfigAddWorker configWorker =
+ new RendererConfigAddWorker(flowBasedServicesAddable, key, boundServicesNew);
+ coordinator.enqueueJob(serviceKey.getInterfaceName(), configWorker, IfmConstants.JOB_MAX_RETRIES);
+ }, IfmClusterUtils.INTERFACE_SERVICE_BINDING_ENTITY);
}
@Override
import javax.inject.Singleton;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.genius.datastoreutils.AsyncDataTreeChangeListenerBase;
+import org.opendaylight.genius.datastoreutils.AsyncClusteredDataTreeChangeListenerBase;
import org.opendaylight.genius.datastoreutils.DataStoreJobCoordinator;
import org.opendaylight.genius.interfacemanager.IfmConstants;
import org.opendaylight.genius.interfacemanager.InterfacemgrProvider;
+import org.opendaylight.genius.interfacemanager.renderer.ovs.utilities.IfmClusterUtils;
import org.opendaylight.genius.interfacemanager.servicebindings.flowbased.state.factory.FlowBasedServicesStateAddable;
import org.opendaylight.genius.interfacemanager.servicebindings.flowbased.state.factory.FlowBasedServicesStateRemovable;
import org.opendaylight.genius.interfacemanager.servicebindings.flowbased.state.factory.FlowBasedServicesStateRendererFactory;
import org.slf4j.LoggerFactory;
@Singleton
-public class FlowBasedServicesInterfaceStateListener extends AsyncDataTreeChangeListenerBase<Interface, FlowBasedServicesInterfaceStateListener> {
+public class FlowBasedServicesInterfaceStateListener extends AsyncClusteredDataTreeChangeListenerBase<Interface, FlowBasedServicesInterfaceStateListener> {
private static final Logger LOG = LoggerFactory.getLogger(FlowBasedServicesInterfaceStateListener.class);
@Inject
@Override
protected void remove(InstanceIdentifier<Interface> key, Interface interfaceStateOld) {
- LOG.debug("Received interface state remove event for {}", interfaceStateOld.getName());
- DataStoreJobCoordinator coordinator = DataStoreJobCoordinator.getInstance();
- for(Object serviceMode : FlowBasedServicesUtils.SERVICE_MODE_MAP.values()) {
- FlowBasedServicesStateRemovable flowBasedServicesStateRemovable = FlowBasedServicesStateRendererFactory.
- getFlowBasedServicesStateRendererFactory((Class<? extends ServiceModeBase>) serviceMode).
- getFlowBasedServicesStateRemoveRenderer();
- RendererStateInterfaceUnbindWorker stateUnbindWorker =
- new RendererStateInterfaceUnbindWorker(flowBasedServicesStateRemovable, interfaceStateOld);
- coordinator.enqueueJob(interfaceStateOld.getName(), stateUnbindWorker, IfmConstants.JOB_MAX_RETRIES);
- }
+ IfmClusterUtils.runOnlyInLeaderNode(() -> {
+ LOG.debug("Received interface state remove event for {}", interfaceStateOld.getName());
+ DataStoreJobCoordinator coordinator = DataStoreJobCoordinator.getInstance();
+ FlowBasedServicesUtils.SERVICE_MODE_MAP.values().stream().forEach(serviceMode ->
+ coordinator.enqueueJob(interfaceStateOld.getName(), new RendererStateInterfaceUnbindWorker
+ (FlowBasedServicesStateRendererFactory.getFlowBasedServicesStateRendererFactory(serviceMode)
+ .getFlowBasedServicesStateRemoveRenderer(), interfaceStateOld), IfmConstants.JOB_MAX_RETRIES));
+ }, IfmClusterUtils.INTERFACE_SERVICE_BINDING_ENTITY);
}
@Override
@Override
protected void add(InstanceIdentifier<Interface> key, Interface interfaceStateNew) {
- if (interfaceStateNew.getOperStatus() == Interface.OperStatus.Down) {
- LOG.info("Interface: {} operstate is down when adding. Not Binding services", interfaceStateNew.getName());
- return;
- }
- LOG.debug("Received interface state add event for {}", interfaceStateNew.getName());
- DataStoreJobCoordinator coordinator = DataStoreJobCoordinator.getInstance();
- for(Object serviceMode : FlowBasedServicesUtils.SERVICE_MODE_MAP.values()) {
- FlowBasedServicesStateAddable flowBasedServicesStateAddable = FlowBasedServicesStateRendererFactory.
- getFlowBasedServicesStateRendererFactory((Class<? extends ServiceModeBase>) serviceMode).
- getFlowBasedServicesStateAddRenderer();
- RendererStateInterfaceBindWorker stateBindWorker = new RendererStateInterfaceBindWorker(flowBasedServicesStateAddable,
- interfaceStateNew);
- coordinator.enqueueJob(interfaceStateNew.getName(), stateBindWorker, IfmConstants.JOB_MAX_RETRIES);
- }
+ IfmClusterUtils.runOnlyInLeaderNode(() -> {
+ LOG.debug("Received interface state add event for {}", interfaceStateNew.getName());
+ DataStoreJobCoordinator coordinator = DataStoreJobCoordinator.getInstance();
+ FlowBasedServicesUtils.SERVICE_MODE_MAP.values().stream().forEach(serviceMode ->
+ coordinator.enqueueJob(interfaceStateNew.getName(), new RendererStateInterfaceBindWorker
+ (FlowBasedServicesStateRendererFactory.getFlowBasedServicesStateRendererFactory(serviceMode)
+ .getFlowBasedServicesStateAddRenderer(), interfaceStateNew), IfmConstants.JOB_MAX_RETRIES));
+ }, IfmClusterUtils.INTERFACE_SERVICE_BINDING_ENTITY);
}
@Override
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
+
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;
EGRESS
}
- public static final ImmutableBiMap SERVICE_MODE_MAP =
- new ImmutableBiMap.Builder<ServiceMode, Class<? extends ServiceModeBase>>()
- .put(ServiceMode.EGRESS, ServiceModeEgress.class)
- .put(ServiceMode.INGRESS, ServiceModeIngress.class)
- .build();
+ public static final ImmutableBiMap<ServiceMode, Class<? extends ServiceModeBase>> SERVICE_MODE_MAP =
+ new ImmutableBiMap.Builder<ServiceMode, Class<? extends ServiceModeBase>>()
+ .put(ServiceMode.EGRESS, ServiceModeEgress.class)
+ .put(ServiceMode.INGRESS, ServiceModeIngress.class)
+ .build();
public static ServicesInfo getServicesInfoForInterface(String interfaceName, Class<? extends ServiceModeBase> serviceMode,
DataBroker dataBroker) {