public class ElanForwardingEntriesHandler extends AbstractDataChangeListener<ElanInterface> implements AutoCloseable {
- private DataBroker broker;
- private ListenerRegistration<DataChangeListener> listenerRegistration;
-
- private IMdsalApiManager mdsalManager;
-
- private IITMProvider itmManager;
private static final Logger logger = LoggerFactory.getLogger(ElanForwardingEntriesHandler.class);
+ private DataBroker broker;
+ private ListenerRegistration<DataChangeListener> listenerRegistration;
-
- public ElanForwardingEntriesHandler(DataBroker db, IMdsalApiManager mdsalManager){
+ public ElanForwardingEntriesHandler(DataBroker db){
super(ElanInterface.class);
this.broker = db;
- this.mdsalManager = mdsalManager;
- }
-
- public void setIITMManager(IITMProvider itmManager) {
- this.itmManager = itmManager;
}
private InstanceIdentifier<?> getWildCardPath() {
package org.opendaylight.vpnservice.elan.internal;
import com.google.common.base.Optional;
-import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.DataChangeListener;
import org.opendaylight.vpnservice.interfacemgr.globals.InterfaceInfo;
import org.opendaylight.vpnservice.interfacemgr.globals.InterfaceInfo.InterfaceType;
import org.opendaylight.vpnservice.interfacemgr.interfaces.IInterfaceManager;
-import org.opendaylight.vpnservice.itm.api.IITMProvider;
+import org.opendaylight.vpnservice.itm.globals.ITMConstants;
+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.tables.table.Flow;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.group.buckets.Bucket;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.groups.Group;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.servicebinding.rev151015.service.bindings.services.info.BoundServices;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list.Instruction;
import org.opendaylight.vpnservice.mdsalutil.*;
import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.elan.rev150602.forwarding.entries.MacEntryBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.elan.rev150602.forwarding.entries.MacEntryKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.IdManagerService;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.rpcs.rev151003.GetEgressActionsForInterfaceInputBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.rpcs.rev151003.GetEgressActionsForInterfaceOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.rpcs.rev151003.OdlInterfaceRpcService;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
private IMdsalApiManager mdsalManager;
private IInterfaceManager interfaceManager;
private IdManagerService idManager;
- private IITMProvider itmManager;
+
private ElanForwardingEntriesHandler elanForwardingEntriesHandler;
private Map<String, ConcurrentLinkedQueue<ElanInterface>> unProcessedElanInterfaces =
new ConcurrentHashMap<String, ConcurrentLinkedQueue<ElanInterface>> ();
this.broker = broker;
}
- public void setIITMManager(IITMProvider itmManager) {
- this.itmManager = itmManager;
- }
-
@Override
public void close() throws Exception {
if (elanInterfaceListenerRegistration != null) {
}
}
}
-
/*
*This condition check is mainly to get DPN-ID in pre-provision deletion scenario after stopping CSS
*/
removeElanDpnInterfaceFromOperationalDataStore(elanName, dpId, interfaceName);
}
+ removeStaticELanFlows(elanInfo, interfaceInfo);
ElanUtils.delete(broker, LogicalDatastoreType.OPERATIONAL, elanInterfaceId);
List<String> elanInterfaces = elanState.getElanInterfaces();
elanInterfaces.remove(interfaceName);
- removeStaticELanFlows(elanInfo, interfaceInfo);
+
if(elanInterfaces.isEmpty()) {
ElanUtils.delete(broker, LogicalDatastoreType.OPERATIONAL, ElanUtils.getElanInstanceOperationalDataPath(elanName));
ElanUtils.delete(broker, LogicalDatastoreType.OPERATIONAL, ElanUtils.getElanDpnOperationDataPath(elanName));
if (isOperational(interfaceInfo)) {
// LocalBroadcast Group creation with elan-Interfaces
- setupLocalBroadcastGroups(elanInfo, interfaceInfo);
+ setupElanBroadcastGroups(elanInfo, interfaceInfo);
+ setupLocalBroadcastGroups(elanInfo, interfaceInfo);
//Terminating Service , UnknownDMAC Table.
setupTerminateServiceTable(elanInfo, interfaceInfo);
setupUnknownDMacTable(elanInfo, interfaceInfo);
bindService(elanInfo, interfaceInfo.getInterfaceName());
//update the remote-DPNs remoteBC group entry with Tunnels
- setRemoteBCGrouponOtherDpns(elanInfo, interfaceInfo);
+ setElanBCGrouponOtherDpns(elanInfo, interfaceInfo);
}
}
public void setupFilterEqualsTable(ElanInstance elanInfo, InterfaceInfo interfaceInfo) {
int ifTag = interfaceInfo.getInterfaceTag();
- FlowEntity flowEntity = MDSALUtil.buildFlowEntity(interfaceInfo.getDpId(), ElanConstants.ELAN_FILTER_EQUALS_TABLE, getFlowRef(ElanConstants.ELAN_FILTER_EQUALS_TABLE, ifTag),
- 9, elanInfo.getElanInstanceName(), 0, 0, ElanConstants.COOKIE_ELAN_FILTER_EQUALS.add(BigInteger.valueOf(ifTag)), getTunnelIdMatchForFilterEqualsLPortTag(ifTag),
- getInstructionsInPortForOutGroup(interfaceInfo.getInterfaceName()));
+ Flow flow = MDSALUtil.buildFlowNew(ElanConstants.ELAN_FILTER_EQUALS_TABLE, getFlowRef(ElanConstants.ELAN_FILTER_EQUALS_TABLE, ifTag),
+ 9, elanInfo.getElanInstanceName(), 0, 0, ElanConstants.COOKIE_ELAN_FILTER_EQUALS.add(BigInteger.valueOf(ifTag)), getTunnelIdMatchForFilterEqualsLPortTag(ifTag), ElanUtils.getInstructionsInPortForOutGroup(interfaceInfo.getInterfaceName()));
+
+ mdsalManager.installFlow(interfaceInfo.getDpId(), flow);
+
+ Flow flowEntry = MDSALUtil.buildFlowNew(ElanConstants.ELAN_FILTER_EQUALS_TABLE, getFlowRef(ElanConstants.ELAN_FILTER_EQUALS_TABLE, 1000+ifTag),
+ 10, elanInfo.getElanInstanceName(), 0, 0, ElanConstants.COOKIE_ELAN_FILTER_EQUALS.add(BigInteger.valueOf(ifTag)), getMatchesForFilterEqualsLPortTag(ifTag),
+ getInstructionsDrop());
+
+ mdsalManager.installFlow(interfaceInfo.getDpId(), flowEntry);
+ }
+
+ public void removeFilterEqualsTable(ElanInstance elanInfo, InterfaceInfo interfaceInfo) {
+ int ifTag = interfaceInfo.getInterfaceTag();
+ Flow flow = MDSALUtil.buildFlowNew(ElanConstants.ELAN_FILTER_EQUALS_TABLE, getFlowRef(ElanConstants.ELAN_FILTER_EQUALS_TABLE, ifTag),
+ 9, elanInfo.getElanInstanceName(), 0, 0, ElanConstants.COOKIE_ELAN_FILTER_EQUALS.add(BigInteger.valueOf(ifTag)), getTunnelIdMatchForFilterEqualsLPortTag(ifTag), ElanUtils.getInstructionsInPortForOutGroup(interfaceInfo.getInterfaceName()));
- mdsalManager.installFlow(flowEntity);
+ mdsalManager.removeFlow(interfaceInfo.getDpId(), flow);
- FlowEntity flowEntity1 = MDSALUtil.buildFlowEntity(interfaceInfo.getDpId(), ElanConstants.ELAN_FILTER_EQUALS_TABLE, getFlowRef(ElanConstants.ELAN_FILTER_EQUALS_TABLE, 1000+ifTag),
+ Flow flowEntity = MDSALUtil.buildFlowNew(ElanConstants.ELAN_FILTER_EQUALS_TABLE, getFlowRef(ElanConstants.ELAN_FILTER_EQUALS_TABLE, 1000+ifTag),
10, elanInfo.getElanInstanceName(), 0, 0, ElanConstants.COOKIE_ELAN_FILTER_EQUALS.add(BigInteger.valueOf(ifTag)), getMatchesForFilterEqualsLPortTag(ifTag),
getInstructionsDrop());
- mdsalManager.installFlow(flowEntity1);
+ mdsalManager.removeFlow(interfaceInfo.getDpId(), flowEntity);
}
- private List<BucketInfo> getRemoteBCGroupBucketInfos(ElanInstance elanInfo,
- InterfaceInfo interfaceInfo) {
+ private List<Bucket> getRemoteBCGroupBucketInfos(ElanInstance elanInfo,
+ int bucketKeyStart, InterfaceInfo interfaceInfo) {
BigInteger dpnId = interfaceInfo.getDpId();
int elanTag = elanInfo.getElanTag().intValue();
- List<BucketInfo> listBucketInfo = new ArrayList<BucketInfo>();
+ int bucketId = bucketKeyStart;
+ List<Bucket> listBuckets = new ArrayList<Bucket>();
ElanDpnInterfacesList elanDpns = ElanUtils.getElanDpnInterfacesList(elanInfo.getElanInstanceName());
if(elanDpns != null) {
List<DpnInterfaces> dpnInterfaceses = elanDpns.getDpnInterfaces();
for(DpnInterfaces dpnInterface : dpnInterfaceses) {
if(ElanUtils.isDpnPresent(dpnInterface.getDpId()) && dpnInterface.getDpId() != dpnId && dpnInterface.getInterfaces() != null && !dpnInterface.getInterfaces().isEmpty()) {
try {
- //FIXME [ELANBE] Removing ITM API for now, will need this for multi dpn.
- //List<ActionInfo> listActionInfo = itmManager.ITMIngressGetActions(dpnId, dpnInterface.getDpId(), (int) elanTag);
- //listBucketInfo.add(new BucketInfo(listActionInfo));
+ List<Action> listAction = ElanUtils.getItmEgressAction(dpnId, dpnInterface.getDpId(), (int) elanTag);
+ listBuckets.add(MDSALUtil.buildBucket(listAction, MDSALUtil.GROUP_WEIGHT, bucketId, MDSALUtil.WATCH_PORT, MDSALUtil.WATCH_GROUP));
+ bucketId++;
} catch (Exception ex) {
logger.error( "Logical Group Interface not found between source Dpn - {}, destination Dpn - {} " ,dpnId, dpnInterface.getDpId() );
}
}
}
}
- List<ActionInfo> listActionInfo = new ArrayList<ActionInfo>();
- listActionInfo.add(new ActionInfo(ActionType.group, new String[] {String.valueOf(ElanUtils.getElanLocalBCGID(elanInfo.getElanTag()))}));
- listBucketInfo.add(new BucketInfo(listActionInfo));
- return listBucketInfo;
+ return listBuckets;
}
- public ActionInfo getTunnelIdActionInfo(int interfaceTag) {
- return new ActionInfo(ActionType.set_field_tunnel_id, new BigInteger[]{BigInteger.valueOf(interfaceTag)});
+ private List<Bucket> getRemoteBCGroupBuckets(ElanInstance elanInfo,
+ InterfaceInfo interfaceInfo, int bucketId) {
+ BigInteger dpnId = interfaceInfo.getDpId();
+ int elanTag = elanInfo.getElanTag().intValue();
+ List<Bucket> listBucketInfo = new ArrayList<Bucket>();
+ ElanDpnInterfacesList elanDpns = ElanUtils.getElanDpnInterfacesList(elanInfo.getElanInstanceName());
+ if(elanDpns != null) {
+ List<DpnInterfaces> dpnInterfaceses = elanDpns.getDpnInterfaces();
+ for(DpnInterfaces dpnInterface : dpnInterfaceses) {
+ if(ElanUtils.isDpnPresent(dpnInterface.getDpId()) && dpnInterface.getDpId() != dpnId && dpnInterface.getInterfaces() != null && !dpnInterface.getInterfaces().isEmpty()) {
+ try {
+ List<Action> listActionInfo = ElanUtils.getItmEgressAction(dpnId, dpnInterface.getDpId(), (int) elanTag);
+ listBucketInfo.add(MDSALUtil.buildBucket(listActionInfo, 0, bucketId, 0xffffffffL, 0xffffffffL));
+ bucketId++;
+ } catch (Exception ex) {
+ logger.error( "Logical Group Interface not found between source Dpn - {}, destination Dpn - {} " ,dpnId, dpnInterface.getDpId() );
+ }
+ }
+ }
+ }
+ return listBucketInfo;
}
- private void setRemoteBCGrouponOtherDpns(ElanInstance elanInfo,
- InterfaceInfo interfaceInfo) {
+ private void setElanBCGrouponOtherDpns(ElanInstance elanInfo,
+ InterfaceInfo interfaceInfo) {
BigInteger dpnId = interfaceInfo.getDpId();
int elanTag = elanInfo.getElanTag().intValue();
long groupId = ElanUtils.getElanRemoteBCGID(elanTag);
+ List<Bucket> listBucket = new ArrayList<Bucket>();
+ int bucketId = 0;
ElanDpnInterfacesList elanDpns = ElanUtils.getElanDpnInterfacesList(elanInfo.getElanInstanceName());
if(elanDpns != null) {
List<DpnInterfaces> dpnInterfaceses = elanDpns.getDpnInterfaces();
for(DpnInterfaces dpnInterface : dpnInterfaceses) {
- List<BucketInfo> remoteListBucketInfo = new ArrayList<BucketInfo>();
+ List<Bucket> remoteListBucketInfo = new ArrayList<Bucket>();
if(ElanUtils.isDpnPresent(dpnInterface.getDpId()) && !dpnInterface.getDpId().equals(dpnId) && dpnInterface.getInterfaces() != null && !dpnInterface.getInterfaces().isEmpty()) {
+ for(String ifName : dpnInterface.getInterfaces()) {
+ // In case if there is a InterfacePort in the cache which is not in
+ // operational state, skip processing it
+ InterfaceInfo ifInfo = interfaceManager.getInterfaceInfoFromOperationalDataStore(ifName, interfaceInfo.getInterfaceType());
+ if (!isOperational(ifInfo)) {
+ continue;
+ }
+
+ listBucket.add(MDSALUtil.buildBucket(getInterfacePortActions(ifInfo), MDSALUtil.GROUP_WEIGHT, bucketId, MDSALUtil.WATCH_PORT, MDSALUtil.WATCH_GROUP));
+ bucketId++;
+ }
+ remoteListBucketInfo.addAll(listBucket);
for(DpnInterfaces otherFes : dpnInterfaceses) {
if (ElanUtils.isDpnPresent(otherFes.getDpId()) && otherFes.getDpId() != dpnInterface.getDpId()
&& otherFes.getInterfaces() != null && ! otherFes.getInterfaces().isEmpty()) {
try {
- //FIXME [ELANBE] Removing ITM API for now, will need this for multi dpn.
- //List<ActionInfo> remoteListActionInfo = itmManager.ITMIngressGetActions(dpnInterface.getDpId(), otherFes.getDpId(), (int) elanTag);
- //remoteListBucketInfo.add(new BucketInfo(remoteListActionInfo));
+ List<Action> remoteListActionInfo = ElanUtils.getItmEgressAction(dpnInterface.getDpId(), otherFes.getDpId(), (int) elanTag);
+ remoteListBucketInfo.add(MDSALUtil.buildBucket(remoteListActionInfo, MDSALUtil.GROUP_WEIGHT, bucketId, MDSALUtil.WATCH_PORT,MDSALUtil.WATCH_GROUP));
+ bucketId++;
} catch (Exception ex) {
logger.error( "Logical Group Interface not found between source Dpn - {}, destination Dpn - {} " ,dpnInterface.getDpId(), otherFes.getDpId() );
return;
}
}
}
- List<ActionInfo> remoteListActionInfo = new ArrayList<ActionInfo>();
- remoteListActionInfo.add(new ActionInfo(ActionType.group, new String[] {String.valueOf(ElanUtils.getElanLocalBCGID(elanTag))}));
- remoteListBucketInfo.add(new BucketInfo(remoteListActionInfo));
- GroupEntity groupEntity = MDSALUtil.buildGroupEntity(dpnInterface.getDpId(), groupId, elanInfo.getElanInstanceName(), GroupTypes.GroupAll, remoteListBucketInfo);
- mdsalManager.installGroup(groupEntity);
+ if(remoteListBucketInfo.size() == 0) {
+ logger.debug( "No ITM is present on Dpn - {} " ,dpnInterface.getDpId());
+ continue;
+ }
+ Group group = MDSALUtil.buildGroup(groupId, elanInfo.getElanInstanceName(), GroupTypes.GroupAll, MDSALUtil.buildBucketLists(remoteListBucketInfo));
+ mdsalManager.syncInstallGroup(dpnInterface.getDpId(), group, ElanConstants.DELAY_TIME_IN_MILLISECOND);
}
}
}
List<DpnInterfaces> elanDpns = ElanUtils.getInvolvedDpnsInElan(elanInfo.getElanInstanceName());
if(elanDpns != null) {
for(DpnInterfaces dpnInterface : elanDpns) {
- List<BucketInfo> remoteListBucketInfo = new ArrayList<BucketInfo>();
+ int bucketId = 0;
+ List<Bucket> remoteListBucket = new ArrayList<Bucket>();
if(ElanUtils.isDpnPresent(dstDpId) && dpnInterface.getDpId().equals(dstDpId) && dpnInterface.getInterfaces() != null && !dpnInterface.getInterfaces().isEmpty()) {
try {
- //FIXME [ELANBE] Removing ITM API for now, will need this for multi dpn.
- //List<ActionInfo> remoteListActionInfo = itmManager.ITMIngressGetActions(interfaceInfo.getDpId(), dstDpId, (int) elanTag);
- //remoteListBucketInfo.add(new BucketInfo(remoteListActionInfo));
+ List<Action> remoteListActionInfo = ElanUtils.getItmEgressAction(interfaceInfo.getDpId(), dstDpId, (int) elanTag);
+ remoteListBucket.add(MDSALUtil.buildBucket(remoteListActionInfo, MDSALUtil.GROUP_WEIGHT, bucketId, MDSALUtil.WATCH_PORT, MDSALUtil.WATCH_GROUP));
+ bucketId++;
} catch (Exception ex) {
logger.error( "Logical Group Interface not found between source Dpn - {}, destination Dpn - {} " ,dpnInterface.getDpId(), dstDpId);
return;
}
- List<ActionInfo> remoteListActionInfo = new ArrayList<ActionInfo>();
- remoteListActionInfo.add(new ActionInfo(ActionType.group, new String[] {String.valueOf(ElanUtils.getElanLocalBCGID(elanTag))}));
- remoteListBucketInfo.add(new BucketInfo(remoteListActionInfo));
- GroupEntity groupEntity = MDSALUtil.buildGroupEntity(interfaceInfo.getDpId(), groupId, elanInfo.getElanInstanceName(), GroupTypes.GroupAll, remoteListBucketInfo);
- mdsalManager.installGroup(groupEntity);
+ List<Action> remoteListActionInfo = new ArrayList<Action>();
+ remoteListActionInfo.add(new ActionInfo(ActionType.group, new String[] {String.valueOf(ElanUtils.getElanLocalBCGID(elanTag))}).buildAction());
+ remoteListBucket.add(MDSALUtil.buildBucket(remoteListActionInfo, MDSALUtil.GROUP_WEIGHT, bucketId, MDSALUtil.WATCH_PORT, MDSALUtil.WATCH_GROUP));
+ Group group = MDSALUtil.buildGroup(groupId, elanInfo.getElanInstanceName(), GroupTypes.GroupAll, MDSALUtil.buildBucketLists(remoteListBucket));
+ mdsalManager.syncInstallGroup(interfaceInfo.getDpId(), group, ElanConstants.DELAY_TIME_IN_MILLISECOND);
break;
}
}
/**
* Returns the bucket info with the given interface as the only bucket.
*/
- private List<BucketInfo> getLocalBCGroupBucketInfo(InterfaceInfo interfaceInfo) {
- return Lists.newArrayList(new BucketInfo(getInterfacePortActionInfos(interfaceInfo)));
+ private Bucket getLocalBCGroupBucketInfo(InterfaceInfo interfaceInfo, int bucketIdStart) {
+ return MDSALUtil.buildBucket(getInterfacePortActions(interfaceInfo), MDSALUtil.GROUP_WEIGHT, bucketIdStart, MDSALUtil.WATCH_PORT, MDSALUtil.WATCH_GROUP);
}
private List<MatchInfo> getMatchesForElanTag(Long elanTag) {
return mkMatches;
}
- private List<InstructionInfo> getInstructionsForOutGroup(
+ private List<Instruction> getInstructionsForOutGroup(
long groupId) {
- List<InstructionInfo> mkInstructions = new ArrayList<InstructionInfo>();
- List <ActionInfo> actionsInfos = new ArrayList <ActionInfo> ();
- actionsInfos.add(new ActionInfo(ActionType.group, new String[]{Long.toString(groupId)}));
- mkInstructions.add(new InstructionInfo(InstructionType.write_actions, actionsInfos));
+ List<Instruction> mkInstructions = new ArrayList<Instruction>();
+ List <Action> actions = new ArrayList <Action> ();
+ actions.add(new ActionInfo(ActionType.group, new String[]{Long.toString(groupId)}).buildAction());
+ mkInstructions.add(ElanUtils.getWriteActionInstruction(actions));
return mkInstructions;
}
}
}
+ public void setupElanBroadcastGroups(ElanInstance elanInfo, InterfaceInfo interfaceInfo) {
+ List<Bucket> listBucket = new ArrayList<Bucket>();
+ int bucketId = 0;
+ BigInteger dpnId = interfaceInfo.getDpId();
+ long groupId = ElanUtils.getElanRemoteBCGID(elanInfo.getElanTag());
+
+ DpnInterfaces dpnInterfaces = ElanUtils.getElanInterfaceInfoByElanDpn(elanInfo.getElanInstanceName(), dpnId);
+ for(String ifName : dpnInterfaces.getInterfaces()) {
+ // In case if there is a InterfacePort in the cache which is not in
+ // operational state, skip processing it
+ InterfaceInfo ifInfo = interfaceManager.getInterfaceInfoFromOperationalDataStore(ifName, interfaceInfo.getInterfaceType());
+ if (!isOperational(ifInfo)) {
+ continue;
+ }
+
+ listBucket.add(MDSALUtil.buildBucket(getInterfacePortActions(ifInfo), MDSALUtil.GROUP_WEIGHT, bucketId, MDSALUtil.WATCH_PORT, MDSALUtil.WATCH_GROUP));
+ bucketId++;
+ }
+ List<Bucket> listBucketInfoRemote = getRemoteBCGroupBuckets(elanInfo, interfaceInfo, bucketId);
+ listBucket.addAll(listBucketInfoRemote);
+
+ Group group = MDSALUtil.buildGroup(groupId, elanInfo.getElanInstanceName(), GroupTypes.GroupAll, MDSALUtil.buildBucketLists(listBucket));
+ logger.trace("installing the localBroadCast Group:{}", group);
+ mdsalManager.syncInstallGroup(dpnId, group, ElanConstants.DELAY_TIME_IN_MILLISECOND);
+ }
+
public void setupLocalBroadcastGroups(ElanInstance elanInfo, InterfaceInfo interfaceInfo) {
- List<BucketInfo> listBucketInfo = new ArrayList<BucketInfo>();
+ List<Bucket> listBucket = new ArrayList<Bucket>();
+ int bucketId = 0;
BigInteger dpnId = interfaceInfo.getDpId();
long groupId = ElanUtils.getElanLocalBCGID(elanInfo.getElanTag());
continue;
}
- listBucketInfo.add(new BucketInfo(getInterfacePortActionInfos(ifInfo)));
+ listBucket.add(MDSALUtil.buildBucket(getInterfacePortActions(ifInfo), MDSALUtil.GROUP_WEIGHT, bucketId, MDSALUtil.WATCH_PORT, MDSALUtil.WATCH_GROUP));
+ bucketId++;
}
- GroupEntity groupEntity = MDSALUtil.buildGroupEntity(dpnId, groupId, elanInfo.getElanInstanceName(), GroupTypes.GroupAll, listBucketInfo);
- logger.trace("installing the localBroadCast GroupEntity:{}", groupEntity);
- mdsalManager.syncInstallGroup(groupEntity, ElanConstants.DELAY_TIME_IN_MILLISECOND);
+
+ Group group = MDSALUtil.buildGroup(groupId, elanInfo.getElanInstanceName(), GroupTypes.GroupAll, MDSALUtil.buildBucketLists(listBucket));
+ logger.trace("installing the localBroadCast Group:{}", group);
+ mdsalManager.syncInstallGroup(dpnId, group, ElanConstants.DELAY_TIME_IN_MILLISECOND);
}
public void removeLocalBroadcastGroup(ElanInstance elanInfo, InterfaceInfo interfaceInfo) {
BigInteger dpnId = interfaceInfo.getDpId();
long groupId = ElanUtils.getElanLocalBCGID(elanInfo.getElanTag());
-
- GroupEntity groupEntity = MDSALUtil.buildGroupEntity(dpnId, groupId, elanInfo.getElanInstanceName(), GroupTypes.GroupAll, getLocalBCGroupBucketInfo(interfaceInfo));
- logger.trace("deleted the localBroadCast GroupEntity:{}", groupEntity);
- mdsalManager.syncRemoveGroup(groupEntity);
+ List<Bucket> listBuckets = new ArrayList<>();
+ int bucketId = 0;
+ listBuckets.add(getLocalBCGroupBucketInfo(interfaceInfo, bucketId));
+ //listBuckets.addAll(getRemoteBCGroupBucketInfos(elanInfo, 1, interfaceInfo));
+ Group group = MDSALUtil.buildGroup(groupId, elanInfo.getElanInstanceName(), GroupTypes.GroupAll, MDSALUtil.buildBucketLists(listBuckets));
+ logger.trace("deleted the localBroadCast Group:{}", group);
+ mdsalManager.syncRemoveGroup(dpnId, group);
}
- public void removeRemoteBroadcastGroup(ElanInstance elanInfo, InterfaceInfo interfaceInfo) {
- List<BucketInfo> listBucketInfo = getRemoteBCGroupBucketInfos(elanInfo, interfaceInfo);
+ public void removeElanBroadcastGroup(ElanInstance elanInfo, InterfaceInfo interfaceInfo) {
+ int bucketId = 0;
+ List<Bucket> listBuckets = new ArrayList<>();
+ listBuckets.add(getLocalBCGroupBucketInfo(interfaceInfo, bucketId));
+ bucketId++;
+ listBuckets.addAll(getRemoteBCGroupBucketInfos(elanInfo, bucketId, interfaceInfo));
BigInteger dpnId = interfaceInfo.getDpId();
long groupId = ElanUtils.getElanRemoteBCGID(elanInfo.getElanTag());
- GroupEntity groupEntity = MDSALUtil.buildGroupEntity(dpnId, groupId, elanInfo.getElanInstanceName(), GroupTypes.GroupAll, listBucketInfo);
- logger.trace("deleting the remoteBroadCast GroupEntity:{}", groupEntity);
- mdsalManager.syncRemoveGroup(groupEntity);
+ Group group = MDSALUtil.buildGroup(groupId, elanInfo.getElanInstanceName(), GroupTypes.GroupAll, MDSALUtil.buildBucketLists(listBuckets));
+ logger.trace("deleting the remoteBroadCast group:{}", group);
+ mdsalManager.syncRemoveGroup(dpnId, group);
}
public void setupTerminateServiceTable(ElanInstance elanInfo, InterfaceInfo interfaceInfo) {
long elanTag = elanInfo.getElanTag();
- //FIXME [ELANBE] Removing ITM API for now, will need this for multi dpn.
-// FlowEntity flowEntity = MDSALUtil.buildFlowEntity(interfaceInfo.getDpId(), ITMConstants.TERMINATING_SERVICE_TABLE, getFlowRef(ITMConstants.TERMINATING_SERVICE_TABLE, elanTag),
-// 5, elanInfo.getElanInstanceName(), 0, 0, ITMConstants.COOKIE_ITM.add(BigInteger.valueOf(elanTag)), itmManager.getTunnelMatchesForServiceId(elanTag),
-// getInstructionsForOutGroup(ElanUtils.getElanLocalBCGID(elanTag)));
-//
-// mdsalManager.installFlow(flowEntity);
+ Flow flowEntity = MDSALUtil.buildFlowNew(ITMConstants.TERMINATING_SERVICE_TABLE, getFlowRef(ITMConstants.TERMINATING_SERVICE_TABLE, elanTag),
+ 5, String.format("%s:%d","ITM Flow Entry ",elanTag), 0, 0, ITMConstants.COOKIE_ITM.add(BigInteger.valueOf(elanTag)), ElanUtils.getTunnelMatchesForServiceId((int)elanTag),
+ getInstructionsForOutGroup(ElanUtils.getElanRemoteBCGID(elanTag)));
+
+ mdsalManager.installFlow(interfaceInfo.getDpId(), flowEntity);
}
public void setupUnknownDMacTable(ElanInstance elanInfo, InterfaceInfo interfaceInfo) {
long elanTag = elanInfo.getElanTag();
- FlowEntity flowEntity = MDSALUtil.buildFlowEntity(interfaceInfo.getDpId(), ElanConstants.ELAN_UNKNOWN_DMAC_TABLE, getFlowRef(ElanConstants.ELAN_UNKNOWN_DMAC_TABLE, elanTag),
+ Flow flowEntity = MDSALUtil.buildFlowNew(ElanConstants.ELAN_UNKNOWN_DMAC_TABLE, getFlowRef(ElanConstants.ELAN_UNKNOWN_DMAC_TABLE, elanTag),
5, elanInfo.getElanInstanceName(), 0, 0, ElanConstants.COOKIE_ELAN_UNKNOWN_DMAC.add(BigInteger.valueOf(elanTag)), getMatchesForElanTag(elanTag),
- getInstructionsForOutGroup(ElanUtils.getElanLocalBCGID(elanTag)));
+ getInstructionsForOutGroup(ElanUtils.getElanRemoteBCGID(elanTag)));
- mdsalManager.installFlow(flowEntity);
+ mdsalManager.installFlow(interfaceInfo.getDpId(), flowEntity);
}
private void removeStaticELanFlows(final ElanInstance elanInfo, final InterfaceInfo interfaceInfo) {
logger.debug("deleting the elan: {} present on dpId: {}", elanInfo.getElanInstanceName(), dpId);
removeDefaultTermFlow(dpId, elanInfo.getElanTag());
removeUnknownDmacFlow(dpId, elanInfo);
- removeRemoteBroadcastGroup(elanInfo, interfaceInfo);
+ removeElanBroadcastGroup(elanInfo, interfaceInfo);
removeLocalBroadcastGroup(elanInfo, interfaceInfo);
+ removeFilterEqualsTable(elanInfo, interfaceInfo);
} else {
- setupLocalBroadcastGroups(elanInfo, interfaceInfo);
+ setupElanBroadcastGroups(elanInfo, interfaceInfo);
+ removeFilterEqualsTable(elanInfo, interfaceInfo);
}
}
private void removeUnknownDmacFlow(BigInteger dpId, ElanInstance elanInfo) {
- FlowEntity flowEntity = getUnknownDmacFlowEntity(dpId, elanInfo);
- mdsalManager.syncRemoveFlow(flowEntity, ElanConstants.DELAY_TIME_IN_MILLISECOND);
+ Flow flow = getUnknownDmacFlowEntity(dpId, elanInfo);
+ mdsalManager.removeFlow(dpId, flow);
}
private void removeDefaultTermFlow(BigInteger dpId, long elanTag) {
- //FIXME [ELANBE] Removing ITM API for now, will need this for multi dpn.
- //itmManager.removeTerminatingServiceAction(dpId, (int) elanTag);
+ ElanUtils.removeTerminatingServiceAction(dpId, (int) elanTag);
}
private void bindService(ElanInstance elanInfo, String interfaceName) {
ElanUtils.DEFAULT_CALLBACK);
}
- private FlowEntity getUnknownDmacFlowEntity(BigInteger dpId, ElanInstance elanInfo) {
+ private Flow getUnknownDmacFlowEntity(BigInteger dpId, ElanInstance elanInfo) {
long elanTag = elanInfo.getElanTag();
List<MatchInfo> mkMatches = new ArrayList<MatchInfo>();
// Matching metadata
ElanUtils.getElanMetadataLabel(elanTag),
MetaDataUtil.METADATA_MASK_SERVICE }));
- List<InstructionInfo> mkInstructions = new ArrayList<InstructionInfo>();
- List <ActionInfo> actionsInfos = new ArrayList <ActionInfo> ();
- actionsInfos.add(new ActionInfo(ActionType.group, new String[]{Long.toString(ElanUtils.getElanRemoteBCGID(elanTag))}));
- mkInstructions.add(new InstructionInfo(InstructionType.write_actions, actionsInfos));
+ List<Instruction> mkInstructions = new ArrayList<Instruction>();
+ List <Action> actionsInfos = new ArrayList <Action> ();
+ actionsInfos.add(new ActionInfo(ActionType.group, new String[]{Long.toString(ElanUtils.getElanRemoteBCGID(elanTag))}, 0).buildAction());
+ mkInstructions.add(ElanUtils.getWriteActionInstruction(actionsInfos));
- FlowEntity flowEntity = MDSALUtil.buildFlowEntity(dpId, ElanConstants.ELAN_UNKNOWN_DMAC_TABLE, getFlowRef(ElanConstants.ELAN_UNKNOWN_DMAC_TABLE, elanTag),
+ Flow flow = MDSALUtil.buildFlowNew(ElanConstants.ELAN_UNKNOWN_DMAC_TABLE, getFlowRef(ElanConstants.ELAN_UNKNOWN_DMAC_TABLE, elanTag),
5, elanInfo.getElanInstanceName(), 0, 0, ElanConstants.COOKIE_ELAN_UNKNOWN_DMAC.add(BigInteger.valueOf(elanTag)),
mkMatches, mkInstructions);
- return flowEntity;
+ return flow;
}
private String getFlowRef(long tableId, long elanTag) {
return new StringBuffer().append(tableId).append(elanTag).toString();
}
- private List<ActionInfo> getInterfacePortActionInfos(InterfaceInfo interfaceInfo) {
- List<ActionInfo> listActionInfo = new ArrayList<ActionInfo>();
- listActionInfo.add(getTunnelIdActionInfo(interfaceInfo.getInterfaceTag()));
- listActionInfo.add(new ActionInfo(ActionType.nx_resubmit, new String[]{}));
- return listActionInfo;
+ private List<Action> getInterfacePortActions(InterfaceInfo interfaceInfo) {
+ List<Action> listAction = new ArrayList<Action>();
+ int actionKey = 0;
+ listAction.add((new ActionInfo(ActionType.set_field_tunnel_id, new BigInteger[] {BigInteger.valueOf(interfaceInfo.getInterfaceTag())}, actionKey)).buildAction());
+ actionKey++;
+ listAction.add((new ActionInfo(ActionType.nx_resubmit, new BigInteger[] {BigInteger.valueOf(55)}, actionKey)).buildAction());
+ return listAction;
}
private void updateElanDpnInterfacesList(String elanInstanceName, BigInteger dpId, List<String> interfaceNames) {
- if(!interfaceNames.isEmpty()) {
- DpnInterfaces dpnInterface = new DpnInterfacesBuilder().setDpId(dpId)
- .setInterfaces(interfaceNames).setKey(new DpnInterfacesKey(dpId)).build();
- MDSALUtil.syncWrite(broker, LogicalDatastoreType.OPERATIONAL, ElanUtils.getElanDpnInterfaceOperationalDataPath(elanInstanceName, dpId),
- dpnInterface);
- } else {
- MDSALUtil.syncDelete(broker, LogicalDatastoreType.OPERATIONAL, ElanUtils.getElanDpnInterfaceOperationalDataPath(elanInstanceName, dpId));
- }
-
+ DpnInterfaces dpnInterface = new DpnInterfacesBuilder().setDpId(dpId)
+ .setInterfaces(interfaceNames).setKey(new DpnInterfacesKey(dpId)).build();
+ MDSALUtil.syncWrite(broker, LogicalDatastoreType.OPERATIONAL, ElanUtils.getElanDpnInterfaceOperationalDataPath(elanInstanceName, dpId),
+ dpnInterface);
}
private List<String> createElanInterfacesList(String elanInstanceName, String interfaceName, BigInteger dpId) {
}
- private List<InstructionInfo> getInstructionsInPortForOutGroup(
- String ifName) {
- List<InstructionInfo> mkInstructions = new ArrayList<InstructionInfo>();
- List <ActionInfo> actionsInfos = new ArrayList <ActionInfo> ();
- actionsInfos.addAll(ElanUtils.getEgressActionsForInterface(ifName));
- mkInstructions.add(new InstructionInfo(InstructionType.apply_actions, actionsInfos));
- return mkInstructions;
- }
-
-
-
- private List<InstructionInfo> getInstructionsDrop() {
- List<InstructionInfo> mkInstructions = new ArrayList<InstructionInfo>();
- List <ActionInfo> actionsInfos = new ArrayList <ActionInfo> ();
- actionsInfos.add(new ActionInfo(ActionType.drop_action, new String[]{}));
- mkInstructions.add(new InstructionInfo(InstructionType.write_actions, actionsInfos));
+ private List<Instruction> getInstructionsDrop() {
+ List<Instruction> mkInstructions = new ArrayList<Instruction>();
+ List <Action> actionsInfos = new ArrayList <Action> ();
+ actionsInfos.add(new ActionInfo(ActionType.drop_action, new String[]{}).buildAction());
+ mkInstructions.add(ElanUtils.getWriteActionInstruction(actionsInfos));
return mkInstructions;
}
import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.CreateIdPoolInputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.IdManagerService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.rpcs.rev151003.OdlInterfaceRpcService;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.itm.rpcs.rev151217.ItmRpcService;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.common.RpcResult;
import org.opendaylight.elanmanager.exceptions.MacNotFoundException;
//private ElanInterfaceEventListener elanInterfaceEventListener;
private ElanItmEventListener elanItmEventListener;
- private IITMProvider itmManager;
+
+ public void setItmRpcService(ItmRpcService itmRpcService) {
+ this.itmRpcService = itmRpcService;
+ }
+
+ public ItmRpcService getItmRpcService() {
+ return itmRpcService;
+ }
+
+ private ItmRpcService itmRpcService;
private DataBroker broker;
private static final Logger logger = LoggerFactory.getLogger(ElanServiceProvider.class);
createIdPool();
broker = session.getSALService(DataBroker.class);
- elanForwardingEntriesHandler = new ElanForwardingEntriesHandler(broker, mdsalManager);
- elanForwardingEntriesHandler.setIITMManager(itmManager);
+ elanForwardingEntriesHandler = new ElanForwardingEntriesHandler(broker);
elanInterfaceManager = ElanInterfaceManager.getElanInterfaceManager();
elanInterfaceManager.setInterfaceManager(interfaceManager);
elanInterfaceManager.setIdManager(idManager);
elanInterfaceManager.setMdSalApiManager(mdsalManager);
elanInterfaceManager.setDataBroker(broker);
- elanInterfaceManager.setIITMManager(itmManager);
elanInterfaceManager.registerListener();
elanInterfaceManager.setInterfaceManagerRpcService(interfaceManagerRpcService);
elanInterfaceManager.setElanForwardingEntriesHandler(elanForwardingEntriesHandler);
elanSmacFlowEventListener = new ElanSmacFlowEventListener(broker);
elanSmacFlowEventListener.setMdSalApiManager(mdsalManager);
elanSmacFlowEventListener.setInterfaceManager(interfaceManager);
- elanSmacFlowEventListener.setIITMManager(itmManager);
elanSmacFlowEventListener.setSalFlowService(session.getRpcService(SalFlowService.class));
notificationService.registerNotificationListener(elanSmacFlowEventListener);
return mdsalManager;
}
- public IITMProvider getItmManager() {
- return itmManager;
- }
-
- public DataBroker getBroker() {
+ public DataBroker getBroker() {
return broker;
}
return interfaceManagerRpcService;
}
- public void setItmManager(IITMProvider itmManager) {
- this.itmManager = itmManager;
- }
-
private void createIdPool() {
CreateIdPoolInput createPool = new CreateIdPoolInputBuilder()
.setPoolName(ElanConstants.ELAN_ID_POOL_NAME).setLow(ElanConstants.ELAN_ID_LOW_VALUE).setHigh(ElanConstants.ELAN_ID_HIGH_VALUE)
private final DataBroker broker;
private IMdsalApiManager mdsalManager;
private IInterfaceManager interfaceManager;
- private IITMProvider itmManager;
private static final Logger logger = LoggerFactory.getLogger(ElanSmacFlowEventListener.class);
public ElanSmacFlowEventListener(DataBroker dataBroker) {
}
- public void setIITMManager(IITMProvider itmManager) {
- this.itmManager = itmManager;
- }
public void setMdSalApiManager(IMdsalApiManager mdsalManager) {
this.mdsalManager = mdsalManager;
}
@Override
public void onFlowAdded(FlowAdded arg0) {
// TODO Auto-generated method stub
-
+
}
@Override
import org.opendaylight.vpnservice.elan.internal.ElanServiceProvider;
import org.opendaylight.vpnservice.interfacemgr.globals.InterfaceInfo;
import org.opendaylight.vpnservice.interfacemgr.globals.InterfaceServiceUtil;
-import org.opendaylight.vpnservice.itm.api.IITMProvider;
+import org.opendaylight.vpnservice.itm.globals.ITMConstants;
import org.opendaylight.vpnservice.mdsalutil.*;
import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
import org.opendaylight.vpnservice.mdsalutil.interfaces.IMdsalApiManager;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.OutputActionCase;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.PushVlanActionCase;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.SetFieldCase;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.SetFieldCaseBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.set.field._case.SetFieldBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.Action;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.ActionBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.ActionKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.Flow;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.instruction.ApplyActionsCaseBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.instruction.WriteActionsCaseBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.instruction.apply.actions._case.ApplyActionsBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.instruction.write.actions._case.WriteActionsBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list.Instruction;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list.InstructionBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list.InstructionKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.TunnelBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.elan.rev150602.*;
import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.elan.rev150602.elan._interface.forwarding.entries.ElanInterfaceMac;
import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.elan.rev150602.elan._interface.forwarding.entries.ElanInterfaceMacKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.elan.rev150602.forwarding.entries.MacEntry;
import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.elan.rev150602.forwarding.entries.MacEntryKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.*;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.rpcs.rev151003.GetEgressActionsForInterfaceInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.rpcs.rev151003.GetEgressActionsForInterfaceInputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.rpcs.rev151003.GetEgressActionsForInterfaceOutput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.rpcs.rev151003.GetEgressActionsInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.rpcs.rev151003.GetEgressActionsInputBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.rpcs.rev151003.GetEgressActionsOutput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.rpcs.rev151003.OdlInterfaceRpcService;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.itm.rpcs.rev151217.CreateTerminatingServiceActionsInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.itm.rpcs.rev151217.CreateTerminatingServiceActionsInputBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.itm.rpcs.rev151217.GetTunnelInterfaceNameInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.itm.rpcs.rev151217.GetTunnelInterfaceNameInputBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.itm.rpcs.rev151217.GetTunnelInterfaceNameOutput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.itm.rpcs.rev151217.ItmRpcService;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.itm.rpcs.rev151217.RemoveTerminatingServiceActionsInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.itm.rpcs.rev151217.RemoveTerminatingServiceActionsInputBuilder;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.common.RpcResult;
String macAddress) {
IMdsalApiManager mdsalApiManager = elanServiceProvider.getMdsalManager();
DataBroker broker = elanServiceProvider.getBroker();
- IITMProvider itmManager = elanServiceProvider.getItmManager();
+ ItmRpcService itmRpcService = elanServiceProvider.getItmRpcService();
synchronized (macAddress) {
logger.info("Acquired lock for mac : " + macAddress + "Proceeding with install operation.");
setupKnownSmacFlow(elanInfo, interfaceInfo, macTimeout, macAddress, mdsalApiManager);
- setupTermDmacFlows(interfaceInfo, itmManager);
+ setupTermDmacFlows(interfaceInfo, mdsalApiManager);
setupOrigDmacFlows(elanInfo, interfaceInfo, macAddress, mdsalApiManager, broker);
}
}
return flowEntity;
}
- private static void setupTermDmacFlows(InterfaceInfo interfaceInfo, IITMProvider itmManager) {
+ private static void setupTermDmacFlows(InterfaceInfo interfaceInfo, IMdsalApiManager mdsalApiManager) {
BigInteger dpId = interfaceInfo.getDpId();
- long lportGroupId = interfaceInfo.getGroupId();
int lportTag = interfaceInfo.getInterfaceTag();
- List <ActionInfo> actionsInfos = new ArrayList <ActionInfo> ();
- actionsInfos = getEgressActionsForInterface(interfaceInfo.getInterfaceName());
-
- //FIXME [ELANBE] ITM Service API to invoke Terminating Service
- //itmManager.createTerminatingServiceActions(dpId, lportTag, actionsInfos);
+ Flow flow = MDSALUtil.buildFlowNew(NwConstants.INTERNAL_TUNNEL_TABLE, getFlowRef(NwConstants.INTERNAL_TUNNEL_TABLE,lportTag), 5, String.format("%s:%d","ITM Flow Entry ",lportTag), 0, 0, ITMConstants.COOKIE_ITM.add(BigInteger.valueOf(lportTag)), getTunnelIdMatchForFilterEqualsLPortTag(lportTag),
+ getInstructionsInPortForOutGroup(interfaceInfo.getInterfaceName()));
+ mdsalApiManager.installFlow(dpId, flow);
if (logger.isDebugEnabled()) {
logger.debug("Terminating service table flow entry created on dpn:{} for logical Interface port:{}", dpId, interfaceInfo.getPortName());
}
}
- public static List<ActionInfo> getEgressActionsForInterface(String ifName) {
- List<ActionInfo> listActionInfo = new ArrayList<ActionInfo>();
+ private static String getFlowRef(short tableId, int elanTag) {
+ return new StringBuffer().append(tableId).append(elanTag).toString();
+ }
+
+ private static List<MatchInfo> getTunnelIdMatchForFilterEqualsLPortTag(int LportTag) {
+ List<MatchInfo> mkMatches = new ArrayList<MatchInfo>();
+ // Matching metadata
+ mkMatches.add(new MatchInfo(MatchFieldType.tunnel_id, new BigInteger[] {
+ BigInteger.valueOf(LportTag)}));
+ return mkMatches;
+
+
+ }
+
+ public static List<Instruction> getInstructionsInPortForOutGroup(
+ String ifName) {
+ List<Instruction> mkInstructions = new ArrayList<Instruction>();
+ List <Action> actionsInfos = new ArrayList <Action> ();
+ actionsInfos.addAll(ElanUtils.getEgressActionsForInterface(ifName));
+ mkInstructions.add(new InstructionBuilder().setInstruction(new ApplyActionsCaseBuilder().setApplyActions(new ApplyActionsBuilder().setAction(actionsInfos).build()).build())
+ .setKey(new InstructionKey(0)).build());
+ return mkInstructions;
+ }
+
+ public static Instruction getWriteActionInstruction(List<Action> actions) {
+ return new InstructionBuilder().setInstruction(new WriteActionsCaseBuilder().setWriteActions(new WriteActionsBuilder().setAction(actions).build()).build()).setKey(new InstructionKey(0)).build();
+ }
+
+ public static Instruction getApplyActionInstruction(List<Action> actions) {
+ return new InstructionBuilder().setInstruction(new ApplyActionsCaseBuilder().setApplyActions(new ApplyActionsBuilder().setAction(actions).build()).build()).setKey(new InstructionKey(0)).build();
+ }
+
+
+ public static List<Action> getEgressActionsForInterface(String ifName) {
+ List<Action> listAction = new ArrayList<Action>();
try {
Future<RpcResult<GetEgressActionsForInterfaceOutput>> result =
elanServiceProvider.getInterfaceManagerRpcService().getEgressActionsForInterface(
} else {
List<org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.Action> actions =
rpcResult.getResult().getAction();
- for (Action action : actions) {
- org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.Action actionClass = action.getAction();
- if (actionClass instanceof OutputActionCase) {
- listActionInfo.add(new ActionInfo(ActionType.output,
- new String[] {((OutputActionCase)actionClass).getOutputAction()
- .getOutputNodeConnector().getValue()}));
- } else if (actionClass instanceof PushVlanActionCase) {
- listActionInfo.add(new ActionInfo(ActionType.push_vlan, new String[] {}));
- } else if (actionClass instanceof SetFieldCase) {
- if (((SetFieldCase)actionClass).getSetField().getVlanMatch() != null) {
- int vlanVid = ((SetFieldCase)actionClass).getSetField().getVlanMatch().getVlanId().getVlanId().getValue();
- listActionInfo.add(new ActionInfo(ActionType.set_field_vlan_vid,
- new String[] { Long.toString(vlanVid) }));
- }
- }
- }
+ listAction = actions;
}
} catch (InterruptedException | ExecutionException e) {
logger.warn("Exception when egress actions for interface {}", ifName, e);
}
- return listActionInfo;
+ return listAction;
}
private static void setupOrigDmacFlows(ElanInstance elanInfo, InterfaceInfo interfaceInfo, String macAddress,
private static void setupLocalDmacFlow(long elanTag, BigInteger dpId, String ifName, String macAddress,
String displayName, IMdsalApiManager mdsalApiManager, long ifTag) {
- FlowEntity flowEntity = getLocalDmacFlowEntry(elanTag, dpId, ifName, macAddress, displayName, ifTag);
- mdsalApiManager.installFlow(flowEntity);
+ Flow flowEntity = getLocalDmacFlowEntry(elanTag, dpId, ifName, macAddress, displayName, ifTag);
+ mdsalApiManager.installFlow(dpId, flowEntity);
}
return new StringBuffer().append(tableId).append(elanTag).append(dpId).append(remoteDpId).append(macAddress).toString();
}
- public static FlowEntity getLocalDmacFlowEntry(long elanTag, BigInteger dpId, String ifName, String macAddress,
+ public static Flow getLocalDmacFlowEntry(long elanTag, BigInteger dpId, String ifName, String macAddress,
String displayName, long ifTag) {
List<MatchInfo> mkMatches = new ArrayList<MatchInfo>();
mkMatches.add(new MatchInfo(MatchFieldType.metadata, new BigInteger[] {
MetaDataUtil.METADATA_MASK_SERVICE }));
mkMatches.add(new MatchInfo(MatchFieldType.eth_dst, new String[] { macAddress }));
- List<InstructionInfo> mkInstructions = new ArrayList<InstructionInfo>();
- List <ActionInfo> actionsInfos = new ArrayList <ActionInfo> ();
+ List<Instruction> mkInstructions = new ArrayList<Instruction>();
+ List <Action> actionsInfos = new ArrayList <Action> ();
actionsInfos.addAll(getEgressActionsForInterface(ifName));
- mkInstructions.add(new InstructionInfo(InstructionType.write_actions, actionsInfos));
+ mkInstructions.add(new InstructionBuilder().setInstruction(new ApplyActionsCaseBuilder().setApplyActions(new ApplyActionsBuilder().setAction(actionsInfos).build()).build())
+ .setKey(new InstructionKey(0)).build());
+ Flow flow = MDSALUtil.buildFlowNew(ElanConstants.ELAN_DMAC_TABLE, getKnownDynamicmacFlowRef(ElanConstants.ELAN_DMAC_TABLE, dpId, ifTag, macAddress, elanTag),
+ 20, displayName, 0, 0, ElanConstants.COOKIE_ELAN_KNOWN_DMAC.add(BigInteger.valueOf(elanTag)), mkMatches, mkInstructions);
- FlowEntity flowEntity = MDSALUtil.buildFlowEntity(dpId, ElanConstants.ELAN_DMAC_TABLE,
- getKnownDynamicmacFlowRef(ElanConstants.ELAN_DMAC_TABLE, dpId, ifTag, macAddress, elanTag),
- 20, displayName, 0, 0, ElanConstants.COOKIE_ELAN_KNOWN_DMAC.add(BigInteger.valueOf(elanTag)),
- mkMatches, mkInstructions);
- return flowEntity;
+ return flow;
}
public static void setupRemoteDmacFlow(BigInteger srcDpId, BigInteger destDpId, int lportTag, long elanTag, String macAddress,
String displayName) {
IMdsalApiManager mdsalApiManager = elanServiceProvider.getMdsalManager();
- FlowEntity flowEntity = getRemoteDmacFlowEntry(srcDpId, destDpId, lportTag, elanTag, macAddress, displayName);
- mdsalApiManager.installFlow(flowEntity);
+ Flow flowEntity = getRemoteDmacFlowEntry(srcDpId, destDpId, lportTag, elanTag, macAddress, displayName);
+ mdsalApiManager.installFlow(srcDpId, flowEntity);
}
- public static FlowEntity getRemoteDmacFlowEntry(BigInteger srcDpId, BigInteger destDpId, int lportTag, long elanTag,
- String macAddress, String displayName) {
- IITMProvider itmManager = elanServiceProvider.getItmManager();
+ public static Flow getRemoteDmacFlowEntry(BigInteger srcDpId, BigInteger destDpId, int lportTag, long elanTag,
+ String macAddress, String displayName) {
+ ItmRpcService itmRpcService = elanServiceProvider.getItmRpcService();
List<MatchInfo> mkMatches = new ArrayList<MatchInfo>();
mkMatches.add(new MatchInfo(MatchFieldType.metadata, new BigInteger[]{
ElanUtils.getElanMetadataLabel(elanTag),
MetaDataUtil.METADATA_MASK_SERVICE }));
mkMatches.add(new MatchInfo(MatchFieldType.eth_dst, new String[] { macAddress }));
- List<InstructionInfo> mkInstructions = new ArrayList<InstructionInfo>();
+ List<Instruction> mkInstructions = new ArrayList<Instruction>();
+
//List of ActionInfo for the provided Source and Destination DPIDs
try {
- //FIXME [ELANBE] Removing ITM API for now, will need this for multi dpn.
- //List<ActionInfo> actionsInfos = itmManager.ITMIngressGetActions(srcDpId, destDpId, lportTag);
- //mkInstructions.add(new InstructionInfo(InstructionType.write_actions, actionsInfos));
+ List<Action> actionsInfos = getItmEgressAction(srcDpId, destDpId, lportTag);
+ Instruction instruction = new InstructionBuilder().setInstruction(new ApplyActionsCaseBuilder().setApplyActions(new ApplyActionsBuilder().setAction(actionsInfos).build()).build())
+ .setKey(new InstructionKey(0)).build();
+ mkInstructions.add(instruction);
} catch (Exception e) {
logger.error("Interface Not Found exception");
}
- FlowEntity flowEntity = MDSALUtil.buildFlowEntity(srcDpId, ElanConstants.ELAN_DMAC_TABLE,
- getKnownDynamicmacFlowRef(ElanConstants.ELAN_DMAC_TABLE, srcDpId, destDpId, macAddress, elanTag),
- 20, displayName, 0, 0, ElanConstants.COOKIE_ELAN_KNOWN_DMAC.add(BigInteger.valueOf(elanTag)),
- mkMatches, mkInstructions);
- return flowEntity;
+
+ Flow flow = MDSALUtil.buildFlowNew(ElanConstants.ELAN_DMAC_TABLE, getKnownDynamicmacFlowRef(ElanConstants.ELAN_DMAC_TABLE, srcDpId, destDpId, macAddress, elanTag), 20
+ , displayName, 0, 0, ElanConstants.COOKIE_ELAN_KNOWN_DMAC.add(BigInteger.valueOf(elanTag)), mkMatches, mkInstructions);
+
+ return flow;
+
}
public static void deleteMacFlows(ElanInstance elanInfo, InterfaceInfo interfaceInfo, MacEntry macEntry) {
long ifTag = interfaceInfo.getInterfaceTag();
List<DpnInterfaces> remoteFEs = getInvolvedDpnsInElan(elanInstanceName);
IMdsalApiManager mdsalApiManager = elanServiceProvider.getMdsalManager();
- IITMProvider itmManager = elanServiceProvider.getItmManager();
+ ItmRpcService itmRpcService = elanServiceProvider.getItmRpcService();
BigInteger srcdpId = interfaceInfo.getDpId();
String displayName = elanInstanceName;
long groupId = interfaceInfo.getGroupId();
if(deleteSmac) {
mdsalApiManager.removeFlow(getKnownSmacFlowEntity(elanInfo, interfaceInfo, 0, macAddress));
}
- mdsalApiManager.removeFlow(getLocalDmacFlowEntry(elanTag, dpnInterface.getDpId(), ifName, macAddress, displayName, ifTag));
-
- //FIXME [ELANBE] Removing ITM API for now, will need this for multi dpn.
- //itmManager.removeTerminatingServiceAction(dpnInterface.getDpId(), interfaceInfo.getInterfaceTag());
+ mdsalApiManager.removeFlow(dpnInterface.getDpId(), getLocalDmacFlowEntry(elanTag, dpnInterface.getDpId(), ifName, macAddress, displayName, ifTag));
+ RemoveTerminatingServiceActionsInput removeTerminatingServiceActionsInput = new RemoveTerminatingServiceActionsInputBuilder().setServiceId(interfaceInfo.getInterfaceTag()).setDpnId(dpnInterface.getDpId()).build();
+ itmRpcService.removeTerminatingServiceActions(removeTerminatingServiceActionsInput);
if (logger.isDebugEnabled()) {
logger.debug("All the required flows deleted for elan:{}, logical Interface port:{} and mac address:{} on dpn:{}", elanInstanceName, interfaceInfo.getPortName(), macAddress, dpnInterface.getDpId());
}
} else if (isDpnPresent(dpnInterface.getDpId())) {
- mdsalApiManager.removeFlow(
+ mdsalApiManager.removeFlow(dpnInterface.getDpId(),
getRemoteDmacFlowEntry(dpnInterface.getDpId(), srcdpId, interfaceInfo.getInterfaceTag(), elanTag, macAddress,
displayName));
if (logger.isDebugEnabled()) {
.child(BoundServices.class, new BoundServicesKey(serviceIndex)).build();
}
+
+ public static List<Action> getItmEgressAction(BigInteger sourceDpnId,
+ BigInteger destinationDpnId, int serviceTag) {
+ ItmRpcService itmManager = elanServiceProvider.getItmRpcService();
+ OdlInterfaceRpcService interfaceManagerRpcService = elanServiceProvider.getInterfaceManagerRpcService();
+ logger.debug("In getItmIngress Action source {}, destination {}, elanTag {}", sourceDpnId, destinationDpnId, serviceTag);
+ List<Action> actions = new ArrayList<>();
+ String tunnelInterfaceName;
+ GetTunnelInterfaceNameInput input = new GetTunnelInterfaceNameInputBuilder().setDestinationDpid(destinationDpnId).setSourceDpid(sourceDpnId).build();
+ Future<RpcResult<GetTunnelInterfaceNameOutput>> output = itmManager.getTunnelInterfaceName(input);
+ try {
+ GetTunnelInterfaceNameOutput tunnelInterfaceNameOutput = output.get().getResult();
+ tunnelInterfaceName = tunnelInterfaceNameOutput.getInterfaceName();
+ logger.debug("Received tunnelInterfaceName from getTunnelInterfaceName RPC {}", tunnelInterfaceName);
+ } catch (InterruptedException | ExecutionException e) {
+ logger.error("Error in RPC call getTunnelInterfaceName {}", e);
+ return actions;
+ }
+ if (tunnelInterfaceName != null && !tunnelInterfaceName.isEmpty()) {
+ GetEgressActionsInput getEgressActionsForInterfaceInput = new GetEgressActionsInputBuilder().setServiceTag(Long.valueOf(serviceTag)).setIntfName(tunnelInterfaceName).build();
+ Future<RpcResult<GetEgressActionsOutput>> egressActionsOutputFuture = interfaceManagerRpcService.getEgressActions(getEgressActionsForInterfaceInput);
+ try {
+ GetEgressActionsOutput egressActionsOutput = egressActionsOutputFuture.get().getResult();
+ List<Action> outputAction = egressActionsOutput.getAction();
+ return outputAction;
+ } catch (InterruptedException | ExecutionException e) {
+ logger.error("Error in RPC call getEgressActionsForInterface {}", e);
+ return actions;
+ }
+ }
+ return actions;
+ }
+
+ public static List<MatchInfo> getTunnelMatchesForServiceId(int elanTag) {
+ List<MatchInfo> mkMatches = new ArrayList<MatchInfo>();
+ // Matching metadata
+ mkMatches.add(new MatchInfo(MatchFieldType.tunnel_id, new BigInteger[]{
+ BigInteger.valueOf(elanTag)}));
+
+ return mkMatches;
+ }
+
+ public static void removeTerminatingServiceAction(BigInteger destDpId, int serviceId) {
+ ItmRpcService itmRpcService = elanServiceProvider.getItmRpcService();
+ RemoveTerminatingServiceActionsInput input = new RemoveTerminatingServiceActionsInputBuilder().setDpnId(destDpId).setServiceId(serviceId).build();
+ Future<RpcResult<Void>> futureObject = itmRpcService.removeTerminatingServiceActions(input);
+ try {
+ RpcResult<Void> result = futureObject.get();
+ if (result.isSuccessful()) {
+ logger.debug("Successfully completed removeTerminatingServiceActions");
+ } else {
+ logger.debug("Failure in removeTerminatingServiceAction RPC call");
+ }
+ } catch (InterruptedException | ExecutionException e) {
+ logger.error("Error in RPC call removeTerminatingServiceActions {}", e);
+ }
+ }
+
+ public static void createTerminatingServiceActions(BigInteger destDpId, int serviceId, List<Action> actions) {
+ ItmRpcService itmRpcService = elanServiceProvider.getItmRpcService();
+ List<Instruction> mkInstructions = new ArrayList<Instruction>();
+ mkInstructions.add(getApplyActionInstruction(actions));
+ CreateTerminatingServiceActionsInput input = new CreateTerminatingServiceActionsInputBuilder().setDpnId(destDpId).setServiceId(serviceId).setInstruction(mkInstructions).build();
+
+ itmRpcService.createTerminatingServiceActions(input);
+ }
}
import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.IdManagerService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.rpcs.rev151003.OdlInterfaceRpcService;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.itm.rpcs.rev151217.ItmRpcService;
public class ElanServiceImplModule extends org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.elanservice.impl.rev150216.AbstractElanServiceImplModule {
public ElanServiceImplModule(org.opendaylight.controller.config.api.ModuleIdentifier identifier, org.opendaylight.controller.config.api.DependencyResolver dependencyResolver) {
provider.setMdsalManager(getMdsalutilDependency());
provider.setInterfaceManager(getOdlinterfaceDependency());
provider.setInterfaceManagerRpcService(rpcregistryDependency.getRpcService(OdlInterfaceRpcService.class));
- provider.setItmManager(getItmmanagerDependency());
+ provider.setItmRpcService(rpcregistryDependency.getRpcService(ItmRpcService.class));
provider.setIdManager(idManager);
getBrokerDependency().registerProvider(provider);
return provider;
}
}
+ rpc get-egress-actions {
+ description "used to retrieve group actions to use from interface name";
+ input {
+ leaf intf-name {
+ type string;
+ }
+ leaf service-tag {
+ type uint32;
+ }
+ }
+ output {
+ uses action:action-list;
+ }
+ }
+
rpc get-egress-instructions-for-interface {
description "used to retrieve flow instructions to use from interface name";
input {
import org.opendaylight.vpnservice.interfacemgr.globals.InterfaceInfo;
import org.opendaylight.vpnservice.interfacemgr.globals.VlanInterfaceInfo;
import org.opendaylight.vpnservice.interfacemgr.servicebindings.flowbased.utilities.FlowBasedServicesUtils;
-import org.opendaylight.vpnservice.mdsalutil.MDSALUtil;
+import org.opendaylight.vpnservice.mdsalutil.ActionInfo;
+import org.opendaylight.vpnservice.mdsalutil.ActionType;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.iana._if.type.rev140508.L2vlan;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.iana._if.type.rev140508.Tunnel;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.InterfaceType;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.Interfaces;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.InterfacesState;
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;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.Action;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.instruction.WriteMetadataCase;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.instruction.write.metadata._case.WriteMetadata;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list.Instruction;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.overlay.rev150105.TunnelTypeBase;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.overlay.rev150105.TunnelTypeGre;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.overlay.rev150105.TunnelTypeVxlan;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.DatapathId;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.alivenessmonitor.rev150629.*;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.alivenessmonitor.rev150629.monitor.profile.create.input.ProfileBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.AllocateIdInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.AllocateIdInputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.AllocateIdOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.ReleaseIdInputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.id.pools.IdPool;
import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.id.pools.IdPoolKey;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.meta.rev151007.InterfaceMonitorIdMap;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.meta.rev151007.MonitorIdInterfaceMap;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.meta.rev151007._interface.monitor.id.map.InterfaceMonitorId;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.meta.rev151007._interface.monitor.id.map.InterfaceMonitorIdBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.meta.rev151007._interface.monitor.id.map.InterfaceMonitorIdKey;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.meta.rev151007.monitor.id._interface.map.MonitorIdInterface;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.meta.rev151007.monitor.id._interface.map.MonitorIdInterfaceBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.meta.rev151007.monitor.id._interface.map.MonitorIdInterfaceKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.rev150331.IfL2vlan.L2vlanMode;
import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.rev150331.IfTunnel;
import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.rev150331.IfL2vlan;
return result;
}
+ public static List<Action> getEgressActions(String interfaceName, long serviceTag, DataBroker dataBroker) {
+ List<ActionInfo> listActionInfo = new ArrayList<>();
+ List<ActionInfo> interfaceActionList = IfmUtil.getEgressActionInfosForInterface(interfaceName, serviceTag, dataBroker);
+ listActionInfo.addAll(interfaceActionList);
+ List<Action> actionsList = new ArrayList<>();
+ for (ActionInfo actionInfo : listActionInfo) {
+ actionsList.add(actionInfo.buildAction());
+ }
+ return actionsList;
+ }
+
+ public static List<Action> getEgressActionsForInterface(String interfaceName, DataBroker dataBroker) {
+ List<ActionInfo> listActionInfo = getEgressActionInfosForInterface(interfaceName, 0, dataBroker);
+ List<Action> actionsList = new ArrayList<>();
+ for (ActionInfo actionInfo : listActionInfo) {
+ actionsList.add(actionInfo.buildAction());
+ }
+ return actionsList;
+ }
+
+ public static List<ActionInfo> getEgressActionInfosForInterface(String interfaceName, int actionKeyStart, DataBroker dataBroker) {
+ Interface interfaceInfo = InterfaceManagerCommonUtils.getInterfaceFromConfigDS(new InterfaceKey(interfaceName),
+ dataBroker);
+ List<ActionInfo> listActionInfo = new ArrayList<ActionInfo>();
+ org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface ifState =
+ InterfaceManagerCommonUtils.getInterfaceStateFromOperDS(interfaceName, dataBroker);
+
+ String lowerLayerIf = ifState.getLowerLayerIf().get(0);
+ NodeConnectorId nodeConnectorId = new NodeConnectorId(lowerLayerIf);
+ String portNo = IfmUtil.getPortNoFromNodeConnectorId(nodeConnectorId);
+ Class<? extends InterfaceType> ifType = interfaceInfo.getType();
+ if(L2vlan.class.equals(ifType)){
+ IfL2vlan vlanIface = interfaceInfo.getAugmentation(IfL2vlan.class);
+ LOG.trace("L2Vlan: {}",vlanIface);
+ long vlanVid = (vlanIface == null) ? 0 : vlanIface.getVlanId().getValue();
+ if (vlanVid != 0) {
+ listActionInfo.add(new ActionInfo(ActionType.push_vlan, new String[] {}, actionKeyStart));
+ actionKeyStart++;
+ listActionInfo.add(new ActionInfo(ActionType.set_field_vlan_vid,
+ new String[] { Long.toString(vlanVid) }, actionKeyStart));
+ actionKeyStart++;
+ }
+ listActionInfo.add(new ActionInfo(ActionType.output, new String[] {portNo}, actionKeyStart));
+ }else if(Tunnel.class.equals(ifType)){
+ listActionInfo.add(new ActionInfo(ActionType.output, new String[] { portNo}, actionKeyStart));
+ }
+ return listActionInfo;
+ }
+
+ public static List<ActionInfo> getEgressActionInfosForInterface(String interfaceName, long serviceTag, DataBroker dataBroker) {
+ int actionKey = 0;
+ ActionInfo actionSetTunnel = new ActionInfo(ActionType.set_field_tunnel_id, new BigInteger[] {
+ BigInteger.valueOf(serviceTag)}, actionKey) ;
+ List<ActionInfo> listActionInfo = new ArrayList<ActionInfo>();
+ listActionInfo.add(actionSetTunnel);
+ actionKey++;
+ listActionInfo.addAll(getEgressActionInfosForInterface(interfaceName, actionKey, dataBroker));
+ return listActionInfo;
+ }
+
public static NodeId getNodeIdFromNodeConnectorId(NodeConnectorId ncId) {
return new NodeId(ncId.getValue().substring(0,ncId.getValue().lastIndexOf(":")));
}
import java.util.concurrent.Future;
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.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.InterfaceKey;
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.inventory.rev130819.NodeConnectorId;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.alivenessmonitor.rev150629.AlivenessMonitorListener;
import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.CreateIdPoolInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.CreateIdPoolInputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.IdManagerService;
@Override
public List<ActionInfo> getInterfaceEgressActions(String ifName) {
- return interfaceManagerRpcService.getEgressActionInfosForInterface(ifName);
+ return IfmUtil.getEgressActionInfosForInterface(ifName, 0, dataBroker);
}
@Override
import org.opendaylight.vpnservice.interfacemgr.IfmUtil;
import org.opendaylight.vpnservice.interfacemgr.commons.InterfaceManagerCommonUtils;
import org.opendaylight.vpnservice.interfacemgr.commons.InterfaceMetaUtils;
-import org.opendaylight.vpnservice.interfacemgr.servicebindings.flowbased.utilities.FlowBasedServicesUtils;
import org.opendaylight.vpnservice.mdsalutil.*;
import org.opendaylight.vpnservice.mdsalutil.interfaces.IMdsalApiManager;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.iana._if.type.rev140508.L2vlan;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.iana._if.type.rev140508.Tunnel;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.InterfaceType;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.rev150331.IfL2vlan;
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;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.Action;
import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.meta.rev151007.bridge._interface.info.BridgeEntry;
import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.meta.rev151007.bridge._interface.info.BridgeEntryKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.meta.rev151007.bridge._interface.info.bridge.entry.BridgeInterfaceEntry;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.rev150331.IfL2vlan;
import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.rev150331.IfTunnel;
import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.rev150331.ParentRefs;
import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.rev150331.TunnelTypeBase;
RpcResultBuilder<GetEgressInstructionsForInterfaceOutput> rpcResultBuilder;
try {
List<InstructionInfo> instructionInfo = new ArrayList<InstructionInfo>();
- List<ActionInfo> actionInfo = getEgressActionInfosForInterface(input.getIntfName());
+ List<ActionInfo> actionInfo = IfmUtil.getEgressActionInfosForInterface(input.getIntfName(), 0, dataBroker);
instructionInfo.add(new InstructionInfo(InstructionType.write_actions, actionInfo));
GetEgressInstructionsForInterfaceOutputBuilder output = new GetEgressInstructionsForInterfaceOutputBuilder().
setInstruction(buildInstructions(instructionInfo));
public Future<RpcResult<GetEgressActionsForInterfaceOutput>> getEgressActionsForInterface(GetEgressActionsForInterfaceInput input) {
RpcResultBuilder<GetEgressActionsForInterfaceOutput> rpcResultBuilder;
try {
- List<Action> actionsList = getEgressActionsForInterface(input.getIntfName());
+ List<Action> actionsList = IfmUtil.getEgressActionsForInterface(input.getIntfName(), dataBroker);
GetEgressActionsForInterfaceOutputBuilder output = new GetEgressActionsForInterfaceOutputBuilder().
setAction(actionsList);
rpcResultBuilder = RpcResultBuilder.success();
return Futures.immediateFuture(rpcResultBuilder.build());
}
+ @Override
+ public Future<RpcResult<GetEgressActionsOutput>> getEgressActions(GetEgressActionsInput input) {
+ RpcResultBuilder<GetEgressActionsOutput> rpcResultBuilder;
+ try {
+ List<Action> actionsList = IfmUtil.getEgressActions(input.getIntfName(), input.getServiceTag(), dataBroker);
+ GetEgressActionsOutputBuilder output = new GetEgressActionsOutputBuilder().
+ setAction(actionsList);
+ rpcResultBuilder = RpcResultBuilder.success();
+ rpcResultBuilder.withResult(output.build());
+ }catch(Exception e){
+ LOG.error("Retrieval of egress actions for the key {} failed due to {}" ,input.getIntfName(), e);
+ rpcResultBuilder = RpcResultBuilder.failed();
+ }
+ return Futures.immediateFuture(rpcResultBuilder.build());
+ }
+
@Override
public Future<RpcResult<GetPortFromInterfaceOutput>> getPortFromInterface(GetPortFromInterfaceInput input) {
RpcResultBuilder<GetPortFromInterfaceOutput> rpcResultBuilder;
getFlowRef(NwConstants.INTERNAL_TUNNEL_TABLE,input.getServiceId()), 5, String.format("%s:%d","ITM Flow Entry ",input.getServiceId()),
0, 0, ITMConstants.COOKIE_ITM.add(BigInteger.valueOf(input.getServiceId())),getTunnelMatchesForServiceId(input.getServiceId()), null );
- ListenableFuture<Void> installFlowResult = mdsalManager.installFlow(input.getDpnId(), terminatingServiceTableFlow);
+ ListenableFuture<Void> installFlowResult = mdsalManager.removeFlow(input.getDpnId(), terminatingServiceTableFlow);
Futures.addCallback(installFlowResult, new FutureCallback<Void>(){
@Override
// Matching metadata
mkMatches.add(new MatchInfo(MatchFieldType.tunnel_id, new BigInteger[]{
- new BigInteger(1, vxLANHeader),
- MetaDataUtil.METADA_MASK_VALID_TUNNEL_ID_BIT_AND_TUNNEL_ID}));
+ BigInteger.valueOf(serviceId)}));
return mkMatches;
}
@Override
public Future<RpcResult<GetInternalOrExternalInterfaceNameOutput>> getInternalOrExternalInterfaceName(
GetInternalOrExternalInterfaceNameInput input) {
- RpcResultBuilder<GetInternalOrExternalInterfaceNameOutput> resultBld = RpcResultBuilder.failed();
+ RpcResultBuilder<GetInternalOrExternalInterfaceNameOutput> resultBld = null;
BigInteger srcDpn = input.getSourceDpid() ;
IpAddress dstIp = input.getDestinationIp() ;
- InstanceIdentifier<ExternalTunnel> path1 = InstanceIdentifier.create(
- ExternalTunnelList.class)
- .child(ExternalTunnel.class, new ExternalTunnelKey(dstIp, srcDpn));
-
- Optional<ExternalTunnel> ext = ItmUtils.read(LogicalDatastoreType.CONFIGURATION, path1, dataBroker);
-
- if( ext != null && ext.isPresent())
- {
- ExternalTunnel extTunnel = ext.get();
- GetInternalOrExternalInterfaceNameOutputBuilder output = new GetInternalOrExternalInterfaceNameOutputBuilder().setInterfaceName(extTunnel.getTunnelInterfaceName() );
- resultBld = RpcResultBuilder.success();
- resultBld.withResult(output.build()) ;
- } else {
- List<DPNTEPsInfo> meshedDpnList = ItmUtils.getTunnelMeshInfo(dataBroker);
- // Look for external tunnels if not look for internal tunnel
- for (DPNTEPsInfo teps : meshedDpnList) {
- TunnelEndPoints firstEndPt = teps.getTunnelEndPoints().get(0);
- if (dstIp.equals(firstEndPt.getIpAddress())) {
- InstanceIdentifier<InternalTunnel> path = InstanceIdentifier.create(
- TunnelList.class)
- .child(InternalTunnel.class, new InternalTunnelKey(srcDpn, teps.getDPNID()));
-
- Optional<InternalTunnel>
- tnl =
- ItmUtils.read(LogicalDatastoreType.CONFIGURATION, path, dataBroker);
- if (tnl != null && tnl.isPresent()) {
- InternalTunnel tunnel = tnl.get();
- GetInternalOrExternalInterfaceNameOutputBuilder
- output =
- new GetInternalOrExternalInterfaceNameOutputBuilder()
- .setInterfaceName(tunnel.getTunnelInterfaceName());
- resultBld = RpcResultBuilder.success();
- resultBld.withResult(output.build());
- break;
- }
- }
- }
- }
+ List<DPNTEPsInfo> meshedDpnList = ItmUtils.getTunnelMeshInfo(dataBroker) ;
+ // Look for external tunnels if not look for internal tunnel
+ for( DPNTEPsInfo teps : meshedDpnList) {
+ TunnelEndPoints firstEndPt = teps.getTunnelEndPoints().get(0) ;
+ if( dstIp.equals(firstEndPt.getIpAddress())) {
+ InstanceIdentifier<InternalTunnel> path = InstanceIdentifier.create(
+ TunnelList.class)
+ .child(InternalTunnel.class, new InternalTunnelKey(srcDpn, teps.getDPNID()));
+
+ Optional<InternalTunnel> tnl = ItmUtils.read(LogicalDatastoreType.CONFIGURATION, path, dataBroker);
+ if( tnl != null && tnl.isPresent())
+ {
+ InternalTunnel tunnel = tnl.get();
+ GetInternalOrExternalInterfaceNameOutputBuilder output = new GetInternalOrExternalInterfaceNameOutputBuilder().setInterfaceName(tunnel.getTunnelInterfaceName() );
+ resultBld = RpcResultBuilder.success();
+ resultBld.withResult(output.build()) ;
+ }else {
+ //resultBld = RpcResultBuilder.failed();
+ InstanceIdentifier<ExternalTunnel> path1 = InstanceIdentifier.create(
+ ExternalTunnelList.class)
+ .child(ExternalTunnel.class, new ExternalTunnelKey(dstIp, srcDpn));
+
+ Optional<ExternalTunnel> ext = ItmUtils.read(LogicalDatastoreType.CONFIGURATION, path1, dataBroker);
+
+ if( ext != null && ext.isPresent())
+ {
+ ExternalTunnel extTunnel = ext.get();
+ GetInternalOrExternalInterfaceNameOutputBuilder output = new GetInternalOrExternalInterfaceNameOutputBuilder().setInterfaceName(extTunnel.getTunnelInterfaceName() );
+ resultBld = RpcResultBuilder.success();
+ resultBld.withResult(output.build()) ;
+ }else {
+ resultBld = RpcResultBuilder.failed();
+ }
+ }
+ }
+ }
return Futures.immediateFuture(resultBld.build());
}
m_actionType = actionType;
m_actionKey = 0;
m_asActionValues = asActionValues;
- }
+ }
+
+ public ActionInfo(ActionType actionType, String[] asActionValues, int actionKey) {
+ m_actionType = actionType;
+ m_actionKey = actionKey;
+ m_asActionValues = asActionValues;
+ }
public ActionInfo(ActionType actionType, BigInteger[] aBigIntValues) {
m_actionType = actionType;
m_aBigIntValues = aBigIntValues;
}
+ public ActionInfo(ActionType actionType, BigInteger[] aBigIntValues, int actionKey) {
+ m_actionType = actionType;
+ m_actionKey = actionKey;
+ m_aBigIntValues = aBigIntValues;
+ }
+
public void setActionKey(int key) {
m_actionKey = key;
}
import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.group.BucketsBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.group.buckets.Bucket;
import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.group.buckets.BucketBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.group.buckets.BucketKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.groups.Group;
import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.groups.GroupBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.groups.GroupKey;
public class MDSALUtil {
public static final String NODE_PREFIX = "openflow";
+ public static final int GROUP_WEIGHT = 0;
+ public static final long WATCH_PORT = 0xffffffffL;
+ public static final long WATCH_GROUP = 0xffffffffL;
public static final String SEPARATOR = ":";
private static final Buckets EMPTY_Buckets = new BucketsBuilder().build();
private static final Instructions EMPTY_Instructions = new InstructionsBuilder().setInstruction(
return groupEntity;
}
+ public static Group buildGroup(long groupId, String groupName, GroupTypes groupType, Buckets buckets) {
+ GroupId groupIdentifier = new GroupId(groupId);
+ return new GroupBuilder().setGroupId(groupIdentifier).setKey(new GroupKey(groupIdentifier)).setGroupName(groupName)
+ .setGroupType(groupType).setBuckets(buckets).build();
+ }
+
public static TransmitPacketInput getPacketOutDefault(List<ActionInfo> actionInfos, byte[] payload, BigInteger dpnId) {
return new TransmitPacketInputBuilder()
.setAction(buildActions(actionInfos))
.setIngress(ingress).setEgress(ingress).build();
}
- p
rivate static List<Action> buildActions(List<ActionInfo> actions) {
+ p
ublic static List<Action> buildActions(List<ActionInfo> actions) {
List<Action> actionsList = new ArrayList<Action>();
for (ActionInfo actionInfo : actions) {
actionsList.add(actionInfo.buildAction());
return sb.toString();
}
+
+ public static Bucket buildBucket(List<Action> actionsList, int weight, int bucketId, long watchPort, long watchGroup) {
+ return new BucketBuilder().setAction(actionsList).setWeight(weight)
+ .setWatchGroup(watchGroup).setWatchPort(watchPort).setBucketId(new BucketId(Long.valueOf(bucketId))).setKey(new BucketKey(new BucketId(Long.valueOf(bucketId)))).build();
+
+ }
+
+ public static Buckets buildBucketLists(List<Bucket> bucketList) {
+ return new BucketsBuilder().setBucket(bucketList).build();
+ }
+
protected static Buckets buildBuckets(List<BucketInfo> listBucketInfo) {
long i = 0;
if (listBucketInfo != null) {
return instructionBuilder.build();
}
+ public static Action buildAction(int actionKey, int instruction) {
+ return new ActionBuilder().setAction(
+ new PopVlanActionCaseBuilder().setPopVlanAction(new PopVlanActionBuilder().build()).build())
+ .setKey(new ActionKey(actionKey)).build();
+ }
+
public static Instruction buildAndGetWriteMetadaInstruction(BigInteger metadata,
BigInteger mask, int instructionKey) {
return new InstructionBuilder()
import org.opendaylight.vpnservice.mdsalutil.FlowEntity;
import org.opendaylight.vpnservice.mdsalutil.GroupEntity;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.Flow;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.groups.Group;
public interface IMdsalApiManager {
*/
public void syncInstallGroup(GroupEntity groupEntity, long delayTime);
+ public void syncInstallGroup(BigInteger dpId, Group group, long delayTime);
+
/**
* API to remove the Group on Data Plane Node synchronously. It internally waits for
* Group Change Notification to confirm group delete request is being sent.
* @param groupEntity
*/
public void syncRemoveGroup(GroupEntity groupEntity);
+
+ public void syncRemoveGroup(BigInteger dpId, Group groupEntity);
}
}
}
+ public void syncSetUpGroup(BigInteger dpId, Group group, long delayTime, boolean isRemove) {
+ s_logger.trace("syncSetUpGroup for group {} ", group);
+ Node nodeDpn = buildDpnNode(dpId);
+ long groupId = group.getGroupId().getValue();
+ GroupKey groupKey = new GroupKey(new GroupId(groupId));
+ InstanceIdentifier<Group> groupInstanceId = InstanceIdentifier.builder(Nodes.class)
+ .child(Node.class, nodeDpn.getKey()).augmentation(FlowCapableNode.class)
+ .child(Group.class, groupKey).build();
+ Runnable notifyTask = new NotifyTask();
+ GroupInfoKey groupInfoKey = new GroupInfoKey(dpId, groupId);
+ synchronized (groupInfoKey.toString().intern()) {
+ s_logger.trace("syncsetupGroupKey groupKey {}", groupInfoKey);
+ groupMap.put(groupInfoKey, notifyTask);
+ if (isRemove) {
+ MDSALUtil.syncDelete(m_dataBroker, LogicalDatastoreType.CONFIGURATION, groupInstanceId);
+ } else {
+ MDSALUtil.syncWrite(m_dataBroker, LogicalDatastoreType.CONFIGURATION, groupInstanceId, group);
+ }
+ synchronized (notifyTask) {
+ try {
+ notifyTask.wait(delayTime);
+ } catch (InterruptedException e){}
+ }
+ }
+ }
+
}
import org.opendaylight.vpnservice.mdsalutil.GroupEntity;
import org.opendaylight.vpnservice.mdsalutil.interfaces.IMdsalApiManager;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.Flow;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.groups.Group;
import org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service.rev130709.PacketProcessingService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
mdSalMgr.syncSetUpGroup(groupEntity, delayTime, false);
}
+ @Override
+ public void syncInstallGroup(BigInteger dpId, Group group, long delayTime) {
+ mdSalMgr.syncSetUpGroup(dpId, group, delayTime, false);
+ }
+
@Override
public void syncRemoveGroup(GroupEntity groupEntity) {
mdSalMgr.syncSetUpGroup(groupEntity, FIXED_DELAY_IN_MILLISECONDS, true);
}
+ @Override
+ public void syncRemoveGroup(BigInteger dpId, Group group) {
+ mdSalMgr.syncSetUpGroup(dpId, group, FIXED_DELAY_IN_MILLISECONDS, true);
+ }
+
}
Code Review / vpnservice.git / commitdiff