<classifier>features</classifier>
<type>xml</type>
</dependency>
+ <dependency>
+ <groupId>${project.groupId}</groupId>
+ <artifactId>openstack.net-virt-sfc-features</artifactId>
+ <version>${project.version}</version>
+ <classifier>features</classifier>
+ <type>xml</type>
+ </dependency>
<dependency>
<groupId>org.opendaylight.sfc</groupId>
<artifactId>features-sfc</artifactId>
<repository>mvn:org.opendaylight.neutron/features-neutron/{{VERSION}}/xml/features</repository>
<repository>mvn:org.opendaylight.sfc/features-sfc/{{VERSION}}/xml/features</repository>
<repository>mvn:org.opendaylight.netvirt/features-netvirt/{{VERSION}}/xml/features</repository>
+ <repository>mvn:org.opendaylight.netvirt/openstack.net-virt-sfc-features/{{VERSION}}/xml/features</repository>
<feature name='odl-netvirt-openstack-sfc-translator' version='${project.version}'
description='OpenStack SFC to OpenDaylight SFC API data translator'>
<feature version='${controller.mdsal.version}'>odl-mdsal-broker</feature>
<feature version="${neutron.version}">odl-neutron-service</feature>
<feature version='${sfc.version}'>odl-sfc-model</feature>
+ <feature version='${project.version}'>odl-ovsdb-sfc-api</feature>
<bundle>mvn:org.opendaylight.netvirt/utils.mdsal-utils/{{VERSION}}</bundle>
<bundle>mvn:org.opendaylight.netvirt/openstack.sfc-translator-impl/{{VERSION}}</bundle>
</feature>
<feature version="${project.version}">odl-netvirt-openstack-sfc-translator</feature>
<feature version="${restconf.version}">odl-restconf</feature>
</feature>
- <feature name='odl-netvirt-openstack-sfc-translator-ui' version='${project.version}'
- description='OpenStack SFC to OpenDaylight SFC API data translator with dlux UI'>
- <feature version="${project.version}">odl-netvirt-openstack-sfc-translator-rest</feature>
- <feature version="${restconf.version}">odl-mdsal-apidocs</feature>
- <feature version="${controller.mdsal.version}">odl-mdsal-xsql</feature>
- <feature version="${dlux.version}">odl-dlux-yangui</feature>
- </feature>
</features>
<artifactId>slf4j-simple</artifactId>
<scope>test</scope>
</dependency>
+ <dependency>
+ <groupId>${project.groupId}</groupId>
+ <artifactId>openstack.net-virt-sfc-api</artifactId>
+ <version>${project.version}</version>
+ </dependency>
<dependency>
<groupId>${project.groupId}</groupId>
<artifactId>utils.mdsal-utils</artifactId>
/**
* Data-tree listener which delegates data processing to a {@link INeutronSfcDataProcessor}.
*/
-public class DelegatingDataTreeListener<T extends DataObject> implements AutoCloseable, DataTreeChangeListener<T> {
+public abstract class DelegatingDataTreeListener<T extends DataObject> implements AutoCloseable,
+ DataTreeChangeListener<T>,
+ INeutronSfcDataProcessor<T> {
private static final Logger LOG = LoggerFactory.getLogger(DelegatingDataTreeListener.class);
private static final ThreadFactory threadFactory = new ThreadFactoryBuilder()
.setNameFormat("NeutronSfcListener-%d").build();
private final INeutronSfcDataProcessor<T> dataProcessor;
private ListenerRegistration<DelegatingDataTreeListener<T>> listenerRegistration;
- public DelegatingDataTreeListener(INeutronSfcDataProcessor<T> dataProcessor,
- DataBroker db, DataTreeIdentifier<T> treeId) {
- this.dataProcessor = Preconditions.checkNotNull(dataProcessor, "Data processor can not be null!");
+ public DelegatingDataTreeListener(DataBroker db, DataTreeIdentifier<T> treeId) {
+ this.dataProcessor = Preconditions.checkNotNull(this, "Data processor can not be null!");
registerListener(Preconditions.checkNotNull(db, "Data broker can not be null!"),
Preconditions.checkNotNull(treeId, "Tree identifier can not be null!"));
}
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.ports.attributes.ports.Port;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.ports.attributes.ports.PortKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.rev150712.Neutron;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.sfc.flow.classifier.rev160511.sfc.flow.classifiers.attributes.SfcFlowClassifiers;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.sfc.flow.classifier.rev160511.sfc.flow.classifiers.attributes.sfc.flow.classifiers.SfcFlowClassifier;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.sfc.flow.classifier.rev160511.sfc.flow.classifiers.attributes.sfc.flow.classifiers.SfcFlowClassifierKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.sfc.rev160511.sfc.attributes.PortPairGroups;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.sfc.rev160511.sfc.attributes.PortPairs;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.sfc.rev160511.sfc.attributes.port.pair.groups.PortPairGroup;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.sfc.rev160511.sfc.attributes.port.pair.groups.PortPairGroupKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.sfc.rev160511.sfc.attributes.port.pairs.PortPair;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.sfc.rev160511.sfc.attributes.port.pairs.PortPairKey;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
*/
public class NeutronMdsalHelper {
private static final Logger LOG = LoggerFactory.getLogger(NeutronMdsalHelper.class);
- private static final InstanceIdentifier<Ports> portsPairIid =
+ private static final InstanceIdentifier<SfcFlowClassifiers> fcIid =
+ InstanceIdentifier.create(Neutron.class).child(SfcFlowClassifiers.class);
+ private static final InstanceIdentifier<Ports> portsIid =
InstanceIdentifier.create(Neutron.class).child(Ports.class);
-
+ private static final InstanceIdentifier<PortPairs> portPairsIid =
+ InstanceIdentifier.create(Neutron.class).child(PortPairs.class);
+ private static final InstanceIdentifier<PortPairGroups> portPairGroupsIid =
+ InstanceIdentifier.create(Neutron.class).child(PortPairGroups.class);
private final DataBroker dataBroker;
private final MdsalUtils mdsalUtils;
return neutronPort;
}
+ public PortPair getNeutronPortPair(Uuid portPairId) {
+ PortPair neutronPortPair
+ = mdsalUtils.read(LogicalDatastoreType.CONFIGURATION , getNeutronPortPairPath(portPairId));
+ return neutronPortPair;
+ }
+
+ public PortPairGroup getNeutronPortPairGroup(Uuid portPairGroupId) {
+ PortPairGroup neutronPortPairGroup
+ = mdsalUtils.read(LogicalDatastoreType.CONFIGURATION , getNeutronPortPairGroupPath(portPairGroupId));
+ return neutronPortPairGroup;
+ }
+
+ public SfcFlowClassifier getNeutronFlowClassifier(Uuid flowClassifierId) {
+ SfcFlowClassifier sfcFlowClassifier
+ = mdsalUtils.read(LogicalDatastoreType.CONFIGURATION , getNeutronSfcFlowClassifierPath(flowClassifierId));
+ return sfcFlowClassifier;
+ }
+
private InstanceIdentifier<Port> getNeutronPortPath(Uuid portId) {
- return portsPairIid.builder().child(Port.class, new PortKey(portId)).build();
+ return portsIid.builder().child(Port.class, new PortKey(portId)).build();
+ }
+
+ private InstanceIdentifier<PortPair> getNeutronPortPairPath(Uuid portPairId) {
+ return portPairsIid.builder().child(PortPair.class, new PortPairKey(portPairId)).build();
+ }
+
+ private InstanceIdentifier<PortPairGroup> getNeutronPortPairGroupPath(Uuid portPairGroupId) {
+ return portPairGroupsIid.builder().child(PortPairGroup.class, new PortPairGroupKey(portPairGroupId)).build();
+ }
+
+ private InstanceIdentifier<SfcFlowClassifier> getNeutronSfcFlowClassifierPath(Uuid portId) {
+ return fcIid.builder().child(SfcFlowClassifier.class, new SfcFlowClassifierKey(portId)).build();
}
}
package org.opendaylight.netvirt.openstack.sfc.translator;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.netvirt.openstack.sfc.translator.flowclassifier.FlowClassifierTranslator;
-import org.opendaylight.netvirt.openstack.sfc.translator.portchain.PortChainTranslator;
-import org.opendaylight.netvirt.openstack.sfc.translator.portchain.PortPairGroupTranslator;
-import org.opendaylight.netvirt.openstack.sfc.translator.portchain.PortPairTranslator;
+import org.opendaylight.netvirt.openstack.sfc.translator.flowclassifier.NeutronFlowClassifierListener;
+import org.opendaylight.netvirt.openstack.sfc.translator.portchain.NeutronPortChainListener;
+import org.opendaylight.netvirt.openstack.sfc.translator.portchain.NeutronPortPairGroupListener;
+import org.opendaylight.netvirt.openstack.sfc.translator.portchain.NeutronPortPairListener;
+import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.sfc.rsp.rev140701.RenderedServicePathService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.netvirt.openstack.sfc.translator.config.rev160720.OpenstackSfcTranslatorConfig;
import org.osgi.framework.BundleContext;
import org.slf4j.Logger;
private static final Logger LOG = LoggerFactory.getLogger(OpenStackSFCTranslatorProvider.class);
private final DataBroker dataBroker;
- private final BundleContext bundleContext;
- private final FlowClassifierTranslator flowClassifierTranslator;
- private final PortPairTranslator portPairTranslator;
- private final PortPairGroupTranslator portPairGroupTranslator;
- private final PortChainTranslator portChainTranslator;
+ private final RenderedServicePathService rspService;
+
public OpenStackSFCTranslatorProvider(
final DataBroker dataBroker,
+ final RenderedServicePathService rspService,
final OpenstackSfcTranslatorConfig openstackSfcTranslatorConfig,
final BundleContext bundleContext) {
this.dataBroker = dataBroker;
- this.bundleContext = bundleContext;
- flowClassifierTranslator = new FlowClassifierTranslator(dataBroker);
- portPairTranslator = new PortPairTranslator(dataBroker);
- portPairGroupTranslator = new PortPairGroupTranslator(dataBroker);
- portChainTranslator = new PortChainTranslator(dataBroker);
+ this.rspService = rspService;
}
//This method will be called by blueprint, during bundle initialization.
public void start() {
LOG.info("OpenStack SFC Translator Session started");
- flowClassifierTranslator.start();
- portPairTranslator.start();
- portPairGroupTranslator.start();
- portChainTranslator.start();
+ new NeutronFlowClassifierListener(dataBroker);
+ new NeutronPortPairListener(dataBroker);
+ new NeutronPortPairGroupListener(dataBroker);
+ new NeutronPortChainListener(dataBroker, rspService);
}
@Override
mdsalUtils = new MdsalUtils(this.dataBroker);
}
- public OvsdbPortMetadata getOvsdbPortMetadata(Uuid ingress) {
- LOG.info("Extract ovsdb port details for neutron port {}", ingress.getValue());
+ public Topology getOvsdbTopologyTree() {
+ LOG.info("Reading OVSDB Topolog Tree (ovsdb:1)");
+ return mdsalUtils.read(LogicalDatastoreType.OPERATIONAL, topologyPath);
+ }
+
+ public OvsdbPortMetadata getOvsdbPortMetadata(Uuid ingressPort) {
+ LOG.info("Extract ovsdb port details for neutron port {}", ingressPort.getValue());
Topology ovsdbTopology = mdsalUtils.read(LogicalDatastoreType.OPERATIONAL, topologyPath);
+ return getOvsdbPortMetadata(ingressPort, ovsdbTopology);
+ }
+ public OvsdbPortMetadata getOvsdbPortMetadata(Uuid ingressPort, Topology ovsdbTopology) {
+ LOG.info("Extract ovsdb port details for neutron port {}", ingressPort.getValue());
OvsdbPortMetadata ovsdbPortMetadata = new OvsdbPortMetadata();
OvsdbBridgeAugmentation bridgeAugmentation = null;
if (ovsdbTopology != null) {
= tp.getAugmentation(OvsdbTerminationPointAugmentation.class);
List<InterfaceExternalIds> externalIds = tpAugmentation.getInterfaceExternalIds();
for (InterfaceExternalIds externalId : externalIds) {
- if(externalId.getExternalIdValue().equals(ingress.getValue())) {
+ if(externalId.getExternalIdValue().equals(ingressPort.getValue())) {
ovsdbPortMetadata.setOvsdbPort(tpAugmentation);
break;
}
return ovsdbPortMetadata;
}
- public String getOvsdbPortName(OvsdbTerminationPointAugmentation ovsdbPort) {
+ public static String getOvsdbPortName(OvsdbTerminationPointAugmentation ovsdbPort) {
return ovsdbPort.getName();
}
- public String getNodeIpAddress(OvsdbNodeAugmentation ovsdbNode) {
+ public static String getNodeIpAddress(OvsdbNodeAugmentation ovsdbNode) {
//Currently we support only ipv4
return ovsdbNode.getConnectionInfo().getRemoteIp().getIpv4Address().getValue();
}
+
+ public static String getNodeKey(InstanceIdentifier<?> node) {
+ return node.firstKeyOf(Node.class).getNodeId().getValue();
+ }
}
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.netvirt.utils.mdsal.utils.MdsalUtils;
-import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.sfc.common.rev151017.SffName;
import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.sfc.sf.rev140701.ServiceFunctions;
import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.sfc.sf.rev140701.service.functions.ServiceFunction;
import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.sfc.sf.rev140701.service.functions.ServiceFunctionKey;
import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.sfc.sfc.rev140701.ServiceFunctionChains;
+import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.sfc.sfc.rev140701.service.function.chain.grouping.ServiceFunctionChain;
+import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.sfc.sfc.rev140701.service.function.chain.grouping.ServiceFunctionChainKey;
import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.sfc.sff.rev140701.ServiceFunctionForwarders;
import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.sfc.sff.rev140701.service.function.forwarders.ServiceFunctionForwarder;
+import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.sfc.sff.rev140701.service.function.forwarders.ServiceFunctionForwarderKey;
import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.sfc.sfp.rev140701.ServiceFunctionPaths;
+import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.sfc.sfp.rev140701.service.function.paths.ServiceFunctionPath;
+import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.sfc.sfp.rev140701.service.function.paths.ServiceFunctionPathKey;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160218.AccessLists;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160218.access.lists.Acl;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160218.access.lists.AclKey;
mdsalUtils = new MdsalUtils(this.dataBroker);
}
+ //ACL Flow Classifier data store utility methods
public void addAclFlowClassifier(Acl aclFlowClassifier) {
InstanceIdentifier<Acl> aclIid = getAclPath(aclFlowClassifier.getKey());
LOG.info("Write ACL FlowClassifier {} to config data store at {}",aclFlowClassifier, aclIid);
mdsalUtils.delete(LogicalDatastoreType.CONFIGURATION, aclIid);
}
+ //Service Function
public void addServiceFunction(ServiceFunction sf) {
InstanceIdentifier<ServiceFunction> sfIid = getSFPath(sf.getKey());
LOG.info("Write Service Function {} to config data store at {}",sf, sfIid);
return sfIid.builder().child(ServiceFunction.class, key).build();
}
- public SffName getExistingSFF(String ipAddress) {
+ private InstanceIdentifier<ServiceFunctionForwarder> getSFFPath(ServiceFunctionForwarderKey key) {
+ return sffIid.builder().child(ServiceFunctionForwarder.class, key).build();
+ }
+
+ private InstanceIdentifier<ServiceFunctionChain> getSFCPath(ServiceFunctionChainKey key) {
+ return sfcIid.builder().child(ServiceFunctionChain.class, key).build();
+ }
+
+ private InstanceIdentifier<ServiceFunctionPath> getSFPPath(ServiceFunctionPathKey key) {
+ return sfpIid.builder().child(ServiceFunctionPath.class, key).build();
+ }
+
+ public ServiceFunctionForwarder getExistingSFF(String ipAddress) {
ServiceFunctionForwarders existingSffs = mdsalUtils.read(LogicalDatastoreType.CONFIGURATION, sffIid);
if (existingSffs != null
&& existingSffs.getServiceFunctionForwarder() != null
List<ServiceFunctionForwarder> existingSffList = existingSffs.getServiceFunctionForwarder();
for (ServiceFunctionForwarder sff : existingSffList) {
if (sff.getIpMgmtAddress().getIpv4Address().equals(new Ipv4Address(ipAddress))) {
- return sff.getName();
+ return sff;
}
}
}
return null;
}
+
+ public void addServiceFunctionForwarder(ServiceFunctionForwarder sff) {
+ InstanceIdentifier<ServiceFunctionForwarder> sffIid = getSFFPath(sff.getKey());
+ LOG.info("Write Service Function Forwarder {} to config data store at {}",sff, sffIid);
+ mdsalUtils.put(LogicalDatastoreType.CONFIGURATION, sffIid, sff);
+ }
+
+ public void addServiceFunctionChain(ServiceFunctionChain sfc) {
+ InstanceIdentifier<ServiceFunctionChain> sfcIid = getSFCPath(sfc.getKey());
+ LOG.info("Write Service Function Chain {} to config data store at {}",sfc, sfcIid);
+ mdsalUtils.put(LogicalDatastoreType.CONFIGURATION, sfcIid, sfc);
+ }
+
+ public void removeServiceFunctionChain(ServiceFunctionChainKey sfcKey) {
+ InstanceIdentifier<ServiceFunctionChain> sfcIid = getSFCPath(sfcKey);
+ LOG.info("Remove Service Function Chain {} from config data store at {}",sfcKey, sfcIid);
+ mdsalUtils.delete(LogicalDatastoreType.CONFIGURATION, sfcIid);
+ }
+
+ public void addServiceFunctionPath(ServiceFunctionPath sfp) {
+ InstanceIdentifier<ServiceFunctionPath> sfpIid = getSFPPath(sfp.getKey());
+ LOG.info("Write Service Function Path {} to config data store at {}",sfp, sfpIid);
+ mdsalUtils.put(LogicalDatastoreType.CONFIGURATION, sfpIid, sfp);
+ }
}
*/
package org.opendaylight.netvirt.openstack.sfc.translator.flowclassifier;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.netvirt.openstack.sfc.translator.INeutronSfcDataProcessor;
-import org.opendaylight.netvirt.openstack.sfc.translator.NeutronMdsalHelper;
-import org.opendaylight.netvirt.openstack.sfc.translator.SfcMdsalHelper;
-import org.opendaylight.netvirt.utils.mdsal.utils.MdsalUtils;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160218.AccessLists;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160218.Ipv4Acl;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160218.Ipv6Acl;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160218.access.lists.Acl;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160218.access.lists.AclBuilder;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160218.access.lists.AclKey;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160218.access.lists.acl.AccessListEntries;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160218.access.lists.acl.AccessListEntriesBuilder;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160218.access.lists.acl.access.list.entries.Ace;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160218.access.lists.acl.access.list.entries.AceBuilder;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160218.access.lists.acl.access.list.entries.AceKey;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160218.access.lists.acl.access.list.entries.ace.ActionsBuilder;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160218.access.lists.acl.access.list.entries.ace.MatchesBuilder;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160218.access.lists.acl.access.list.entries.ace.matches.ace.type.AceIpBuilder;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160218.access.lists.acl.access.list.entries.ace.matches.ace.type.ace.ip.AceIpVersion;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160218.access.lists.acl.access.list.entries.ace.matches.ace.type.ace.ip.ace.ip.version.AceIpv4Builder;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160218.access.lists.acl.access.list.entries.ace.matches.ace.type.ace.ip.ace.ip.version.AceIpv6Builder;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpPrefix;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.PortNumber;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.packet.fields.rev160218.acl.transport.header.fields.DestinationPortRange;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.packet.fields.rev160218.acl.transport.header.fields.DestinationPortRangeBuilder;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.packet.fields.rev160218.acl.transport.header.fields.SourcePortRangeBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.constants.rev150712.EthertypeV4;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.constants.rev150712.ProtocolTcp;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.constants.rev150712.ProtocolUdp;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.sfc.flow.classifier.rev160511.sfc.flow.classifiers.attributes.sfc.flow.classifiers.SfcFlowClassifier;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.netvirt.sfc.acl.rev150105.RedirectToSfc;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.netvirt.sfc.acl.rev150105.RedirectToSfcBuilder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import java.io.Closeable;
import java.util.ArrayList;
/**
* Class will convert OpenStack Flow Classifier API yang models to
* OpenDaylight ACL yang models.
*/
-public class FlowClassifierTranslator implements INeutronSfcDataProcessor<SfcFlowClassifier>{
+public class FlowClassifierTranslator {
private static final Logger LOG = LoggerFactory.getLogger(FlowClassifierTranslator.class);
private static final Short PROTO_TCP = 6;
private static final Short PROTO_UDP = 17;
private static final String RULE = "_rule";
- private final DataBroker db;
- private NeutronFlowClassifierListener neutronFlowClassifierListener;
- private final SfcMdsalHelper sfcMdsalHelper;
- private final NeutronMdsalHelper neutronMdsalHelper;
-
- public FlowClassifierTranslator(DataBroker db) {
- this.db = db;
- sfcMdsalHelper = new SfcMdsalHelper(db);
- neutronMdsalHelper = new NeutronMdsalHelper(db);
- }
-
- public void start() {
- LOG.info("Flow Classifier Translator Initialized.");
- if(neutronFlowClassifierListener == null) {
- neutronFlowClassifierListener = new NeutronFlowClassifierListener(db, this);
- }
- }
-
- /**
- * Method removes Acl respective to SfcFlowClassifier which is identified by InstanceIdentifier.
- *
- * @param path - the whole path to SfcFlowClassifier
- * @param deletedSfcFlowClassifier - SfcFlowClassifier for removing
- */
- @Override
- public void remove(InstanceIdentifier<SfcFlowClassifier> path, SfcFlowClassifier deletedSfcFlowClassifier) {
- Acl aclFlowClassifier = buildAcl(deletedSfcFlowClassifier);
- sfcMdsalHelper.removeAclFlowClassifier(aclFlowClassifier);
- }
-
- /**
- * Method updates the original SfcFlowClassifier to the update SfcFlowClassifier.
- * Both are identified by same InstanceIdentifier.
- *
- * @param path - the whole path to SfcFlowClassifier
- * @param originalSfcFlowClassifier - original SfcFlowClassifier (for update)
- * @param updatedSfcFlowClassifier - changed SfcFlowClassifier (contain updates)
- */
- @Override
- public void update(InstanceIdentifier<SfcFlowClassifier> path,
- SfcFlowClassifier originalSfcFlowClassifier,
- SfcFlowClassifier updatedSfcFlowClassifier) {
-
- Acl aclFlowClassifier = buildAcl(updatedSfcFlowClassifier);
- sfcMdsalHelper.updateAclFlowClassifier(aclFlowClassifier);
- }
-
- /**
- * Method adds the SfcFlowClassifier which is identified by InstanceIdentifier
- * to device.
- *
- * @param path - the whole path to new SfcFlowClassifier
- * @param sfcFlowClassifier - new SfcFlowClassifier
- */
- @Override
- public void add(InstanceIdentifier<SfcFlowClassifier> path, SfcFlowClassifier sfcFlowClassifier) {
- Acl aclFlowClassifier = buildAcl(sfcFlowClassifier);
- sfcMdsalHelper.addAclFlowClassifier(aclFlowClassifier);
+ public static Acl buildAcl(SfcFlowClassifier flowClassifier) {
+ return buildAcl(flowClassifier, null);
}
-
- private Acl buildAcl(SfcFlowClassifier flowClassifier) {
+ public static Acl buildAcl(SfcFlowClassifier flowClassifier, String rspName) {
LOG.info("OpenStack Networkgin SFC pushed Flow classfier : {}", flowClassifier);
AclBuilder aclBuilder = new AclBuilder();
AccessListEntriesBuilder accessListEntriesBuilder = new AccessListEntriesBuilder();
AceBuilder aceBuilder = new AceBuilder();
MatchesBuilder matchesBuilder = new MatchesBuilder();
+
+ ActionsBuilder actionsBuilder = new ActionsBuilder();
+ RedirectToSfcBuilder redirectToSfcBuilder = new RedirectToSfcBuilder();
+
AceIpBuilder aceIpBuilder = new AceIpBuilder();
DestinationPortRangeBuilder destinationPortRange = new DestinationPortRangeBuilder();
SourcePortRangeBuilder sourcePortRangeBuilder = new SourcePortRangeBuilder();
matchesBuilder.setAceType(aceIpBuilder.build());
+ //Set redirect-to-rsp action if rsp name is provided
+ if (rspName != null) {
+ redirectToSfcBuilder.setRspName(rspName);
+ actionsBuilder.addAugmentation(RedirectToSfc.class, redirectToSfcBuilder.build());
+ aceBuilder.setActions(actionsBuilder.build());
+ }
aceBuilder.setMatches(matchesBuilder.build());
//OpenStack networking-sfc don't pass action information
import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.netvirt.openstack.sfc.translator.DelegatingDataTreeListener;
+import org.opendaylight.netvirt.openstack.sfc.translator.SfcMdsalHelper;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160218.access.lists.Acl;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.rev150712.Neutron;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.sfc.flow.classifier.rev160511.sfc.flow.classifiers.attributes.SfcFlowClassifiers;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.sfc.flow.classifier.rev160511.sfc.flow.classifiers.attributes.sfc.flow.classifiers.SfcFlowClassifier;
private static final InstanceIdentifier<SfcFlowClassifier> flowClassifiersIid =
InstanceIdentifier.create(Neutron.class).child(SfcFlowClassifiers.class).child(SfcFlowClassifier.class);
- public NeutronFlowClassifierListener(DataBroker db, FlowClassifierTranslator flowClassifierTranslator) {
- super(flowClassifierTranslator, db,
- new DataTreeIdentifier<>(LogicalDatastoreType.CONFIGURATION,flowClassifiersIid));
+ private final SfcMdsalHelper sfcMdsalHelper;
+
+ public NeutronFlowClassifierListener(DataBroker db) {
+ super(db, new DataTreeIdentifier<>(LogicalDatastoreType.CONFIGURATION,flowClassifiersIid));
+ sfcMdsalHelper = new SfcMdsalHelper(db);
+
+ }
+
+ /**
+ * Method removes Acl respective to SfcFlowClassifier which is identified by InstanceIdentifier.
+ *
+ * @param path - the whole path to SfcFlowClassifier
+ * @param deletedSfcFlowClassifier - SfcFlowClassifier for removing
+ */
+ @Override
+ public void remove(InstanceIdentifier<SfcFlowClassifier> path, SfcFlowClassifier deletedSfcFlowClassifier) {
+ Acl aclFlowClassifier = FlowClassifierTranslator.buildAcl(deletedSfcFlowClassifier);
+ sfcMdsalHelper.removeAclFlowClassifier(aclFlowClassifier);
+ }
+
+ /**
+ * Method updates the original SfcFlowClassifier to the update SfcFlowClassifier.
+ * Both are identified by same InstanceIdentifier.
+ *
+ * @param path - the whole path to SfcFlowClassifier
+ * @param originalSfcFlowClassifier - original SfcFlowClassifier (for update)
+ * @param updatedSfcFlowClassifier - changed SfcFlowClassifier (contain updates)
+ */
+ @Override
+ public void update(InstanceIdentifier<SfcFlowClassifier> path,
+ SfcFlowClassifier originalSfcFlowClassifier,
+ SfcFlowClassifier updatedSfcFlowClassifier) {
+
+ Acl aclFlowClassifier = FlowClassifierTranslator.buildAcl(updatedSfcFlowClassifier);
+ sfcMdsalHelper.updateAclFlowClassifier(aclFlowClassifier);
}
+
+ /**
+ * Method adds the SfcFlowClassifier which is identified by InstanceIdentifier
+ * to device.
+ *
+ * @param path - the whole path to new SfcFlowClassifier
+ * @param sfcFlowClassifier - new SfcFlowClassifier
+ */
+ @Override
+ public void add(InstanceIdentifier<SfcFlowClassifier> path, SfcFlowClassifier sfcFlowClassifier) {
+ Acl aclFlowClassifier = FlowClassifierTranslator.buildAcl(sfcFlowClassifier);
+ sfcMdsalHelper.addAclFlowClassifier(aclFlowClassifier);
+ }
+
}
import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.netvirt.openstack.sfc.translator.DelegatingDataTreeListener;
+import org.opendaylight.netvirt.openstack.sfc.translator.NeutronMdsalHelper;
+import org.opendaylight.netvirt.openstack.sfc.translator.OvsdbMdsalHelper;
+import org.opendaylight.netvirt.openstack.sfc.translator.OvsdbPortMetadata;
+import org.opendaylight.netvirt.openstack.sfc.translator.SfcMdsalHelper;
+import org.opendaylight.netvirt.openstack.sfc.translator.flowclassifier.FlowClassifierTranslator;
+import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.sfc.rsp.rev140701.CreateRenderedPathInput;
+import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.sfc.rsp.rev140701.CreateRenderedPathOutput;
+import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.sfc.rsp.rev140701.RenderedServicePathService;
+import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.sfc.sf.rev140701.service.functions.ServiceFunction;
+import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.sfc.sf.rev140701.service.functions.ServiceFunctionBuilder;
+import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.sfc.sfc.rev140701.service.function.chain.grouping.ServiceFunctionChain;
+import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.sfc.sff.rev140701.service.function.forwarders.ServiceFunctionForwarder;
+import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.sfc.sff.rev140701.service.function.forwarders.ServiceFunctionForwarderBuilder;
+import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.sfc.sfp.rev140701.service.function.paths.ServiceFunctionPath;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160218.access.lists.Acl;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.ports.attributes.ports.Port;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.rev150712.Neutron;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.sfc.flow.classifier.rev160511.sfc.flow.classifiers.attributes.sfc.flow.classifiers.SfcFlowClassifier;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.sfc.rev160511.sfc.attributes.PortChains;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.sfc.rev160511.sfc.attributes.port.chains.PortChain;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.sfc.rev160511.sfc.attributes.port.pair.groups.PortPairGroup;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.sfc.rev160511.sfc.attributes.port.pairs.PortPair;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.Topology;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.common.RpcResult;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Future;
/**
* OpenDaylight Neutron Port Chain yang models data change listener
*/
public class NeutronPortChainListener extends DelegatingDataTreeListener<PortChain> {
+
+ private static final Logger LOG = LoggerFactory.getLogger(NeutronPortChainListener.class);
+
private static final InstanceIdentifier<PortChain> portChainIid =
InstanceIdentifier.create(Neutron.class).child(PortChains.class).child(PortChain.class);
+ private final SfcMdsalHelper sfcMdsalHelper;
+ private final NeutronMdsalHelper neutronMdsalHelper;
+ private final OvsdbMdsalHelper ovsdbMdsalHelper;
+ private final RenderedServicePathService rspService;
+
+ public NeutronPortChainListener(DataBroker db, RenderedServicePathService rspService) {
+ super(db,new DataTreeIdentifier<>(LogicalDatastoreType.CONFIGURATION, portChainIid));
+ sfcMdsalHelper = new SfcMdsalHelper(db);
+ neutronMdsalHelper = new NeutronMdsalHelper(db);
+ ovsdbMdsalHelper = new OvsdbMdsalHelper(db);
+ this.rspService = rspService;
+ }
+
+ /**
+ * Method removes PortChain which is identified by InstanceIdentifier.
+ *
+ * @param path - the whole path to PortChain
+ * @param deletedPortChain - PortChain for removing
+ */
+ @Override
+ public void remove(InstanceIdentifier<PortChain> path, PortChain deletedPortChain) {
+ sfcMdsalHelper.removeServiceFunctionChain(PortChainTranslator.getSFCKey(deletedPortChain));
+ }
+
+ /**
+ * Method updates the original PortChain to the update PortChain.
+ * Both are identified by same InstanceIdentifier.
+ *
+ * @param path - the whole path to PortChain
+ * @param originalPortChain - original PortChain (for update)
+ * @param updatePortChain - changed PortChain (contain updates)
+ */
+ @Override
+ public void update(InstanceIdentifier<PortChain> path, PortChain originalPortChain, PortChain updatePortChain) {
+ //TODO: Add support for chain update
+ }
+
+ /**
+ * Method adds the PortChain which is identified by InstanceIdentifier
+ * to device.
+ *
+ * @param path - the whole path to new PortChain
+ * @param newPortChain - new PortChain
+ */
+ @Override
+ public void add(InstanceIdentifier<PortChain> path, PortChain newPortChain) {
+ processPortChain(newPortChain);
+ }
+
+ private void processPortChain(PortChain newPortChain) {
+ //List of Port Pair Group attached to the Port Chain
+ List<PortPairGroup> portPairGroupList = new ArrayList<>();
+ //Port Pair Group and associated Port Pair
+ Map<Uuid, List<PortPair>> groupPortPairsList = new HashMap<>();
+ //Map of Port Pair uuid and Port pair ingress port related Neutron Port
+ Map<Uuid, Port> portPairToNeutronPortMap = new HashMap<>();
+
+ //Mapping of Port Pair UUID and OvsdbPortMetadata of the port pair ingress port
+ Map<Uuid, OvsdbPortMetadata> portPairOvsdbMetadata = new HashMap<>();
+
+ Map<Uuid, ServiceFunctionForwarderBuilder> portPairGroupToSFFMap = new HashMap<>();
+ List<ServiceFunction> portChainServiceFunctionList = new ArrayList<>();
+
+ //Read chain related port pair group, port pair and neutron port from neutron data store
+ for (Uuid ppgUuid : newPortChain.getPortPairGroups()) {
+ PortPairGroup ppg = neutronMdsalHelper.getNeutronPortPairGroup(ppgUuid);
+ if (ppg != null) {
+ List<PortPair> portPairList = new ArrayList<>();
+ portPairGroupList.add(ppg);
+ for(Uuid ppUuid : ppg.getPortPairs()) {
+ PortPair pp = neutronMdsalHelper.getNeutronPortPair(ppgUuid);
+ if (pp != null) {
+ portPairList.add(pp);
+ //NOTE:Assuming that ingress and egress port is same.
+ Port neutronPort = neutronMdsalHelper.getNeutronPort(pp.getIngress());
+ if (neutronPort != null) {
+ portPairToNeutronPortMap.put(ppgUuid, neutronPort);
+ }
+ }
+ }
+ groupPortPairsList.put(ppgUuid, portPairList);
+ }
+ }
+
+ Topology ovsdbTopology = ovsdbMdsalHelper.getOvsdbTopologyTree();
+
+ //Read ovsdb port details related to neutron port. Each Port pair has two neutron port
+ //With the current implementation, i am assuming that we support SF only with single port
+ //that act as a ingress as well as egress.
+ for(Map.Entry<Uuid, Port> neutronPortEntry : portPairToNeutronPortMap.entrySet()) {
+ OvsdbPortMetadata ovsdbPortMetadata =
+ ovsdbMdsalHelper.getOvsdbPortMetadata(
+ neutronPortEntry.getValue().getKey().getUuid(),
+ ovsdbTopology);
+
+ if(ovsdbPortMetadata != null) {
+ portPairOvsdbMetadata.put(neutronPortEntry.getKey(), ovsdbPortMetadata);
+ }
+ }
+
+ //For each port pair group
+ for (PortPairGroup ppg : portPairGroupList) {
+ List<ServiceFunctionBuilder> portPairSFList = new ArrayList<>();
+
+ List<PortPair> portPairList = groupPortPairsList.get(ppg.getUuid());
+ Map<Uuid, OvsdbPortMetadata> metadataList = new HashMap<>();
+ //Generate OvsdbPortMetadata for list of all the port pair
+ for (PortPair portPair : portPairList) {
+ OvsdbPortMetadata metadata = portPairOvsdbMetadata.get(portPair.getIngress());
+
+ if (metadata != null) {
+ metadataList.put(portPair.getIngress(), metadata);
+ }
+ }
+
+ //Build the SFF Builder from port pair group
+ ServiceFunctionForwarderBuilder sffBuilder =
+ PortPairGroupTranslator.buildServiceFunctionForwarder(ppg,portPairList, metadataList);
+
+ //Check if SFF already exist
+ ServiceFunctionForwarder existingSff =
+ sfcMdsalHelper.getExistingSFF(sffBuilder.getIpMgmtAddress().getIpv4Address().getValue());
+ if(existingSff != null) {
+ LOG.info("SFF already exist for Port Pair Group {}. Existing SFF is {}",ppg, existingSff);
+ sffBuilder = new ServiceFunctionForwarderBuilder(existingSff);
+ }
+ //Add SFF builder to the map for later reference
+ portPairGroupToSFFMap.put(ppg.getUuid(), sffBuilder);
+
+ //Generate all the SF and write it to SFC data store
+ for (PortPair portPair : portPairList) {
+ OvsdbPortMetadata metadata = portPairOvsdbMetadata.get(portPair.getIngress());
+ //Build the service function for the given port pair.
+ ServiceFunctionBuilder sfBuilder = PortPairTranslator.buildServiceFunction(portPair,
+ ppg,
+ portPairToNeutronPortMap.get(portPair.getIngress()),
+ metadata,
+ sffBuilder.build());
+
+ if (sfBuilder != null) {
+ //Write the Service Function to SFC data store.
+ sfcMdsalHelper.addServiceFunction(sfBuilder.build());
+
+ //Add to the list, to populated SFF Service Function Dictionary
+ portPairSFList.add(sfBuilder);
+
+ //Add the SF to Port Chain related SF list
+ portChainServiceFunctionList.add(sfBuilder.build());
+ } else {
+ LOG.warn("Service Function building failed for Port Pair {}", portPair);
+ }
+ }
+
+ //Update the Service Function Dictionary of SFF
+ for (ServiceFunctionBuilder sf : portPairSFList) {
+ PortPairGroupTranslator.buildServiceFunctionDictonary(sffBuilder, sf.build());
+ }
+ // Send SFF create request
+ LOG.info("Add Service Function Forwarder {} for Port Pair Group {}", sffBuilder.build(), ppg);
+ sfcMdsalHelper.addServiceFunctionForwarder(sffBuilder.build());
+ }
+ //Build Service Function Chain Builder
+ ServiceFunctionChain sfc =
+ PortChainTranslator.buildServiceFunctionChain(newPortChain, portChainServiceFunctionList);
+
+ //Write SFC to data store
+ if (sfc != null) {
+ sfcMdsalHelper.addServiceFunctionChain(sfc);
+ } else {
+ LOG.warn("Service Function Chain building failed for Port Chain {}", newPortChain);
+ }
+
+ // Build Service Function Path Builder
+ ServiceFunctionPath sfp = PortChainTranslator.buildServiceFunctionPath(sfc);
+ //Write SFP to data store
+ if (sfp != null) {
+ sfcMdsalHelper.addServiceFunctionPath(sfp);
+ } else {
+ LOG.warn("Service Function Path building failed for Service Chain {}", sfc);
+ }
+
+ //TODO:Generate Flow Classifiers and augment RSP on it.
+
+ if (this.rspService != null) {
+ // Build Create Rendered Service Path input
+ CreateRenderedPathInput rpInput = PortChainTranslator.buildRenderedServicePathInput(sfp);
+
+ //Call Create Rendered Service Path RPC call
+ if (rpInput != null) {
+ Future<RpcResult<CreateRenderedPathOutput>> result = this.rspService.createRenderedPath(rpInput);
+ try {
+ result.get();
+ processFlowClassifiers(newPortChain, newPortChain.getFlowClassifiers(), rpInput.getName());
+ } catch (InterruptedException | ExecutionException e) {
+ LOG.error("Error occurred during creating Rendered Service Path using RPC call", e);
+ }
+ }
+ } else {
+ LOG.error("Rendered Path Service is not available, can't create Rendered Path for Port Chain", newPortChain);
+ }
+ }
+
+ private void processFlowClassifiers(PortChain pc, List<Uuid> flowClassifiers, String rspName) {
+ for (Uuid uuid : flowClassifiers) {
+ SfcFlowClassifier fc = neutronMdsalHelper.getNeutronFlowClassifier(uuid);
+ if (fc != null) {
+ Acl acl = FlowClassifierTranslator.buildAcl(fc, rspName);
+ if (acl != null ) {
+ sfcMdsalHelper.addAclFlowClassifier(acl);
+ } else {
+ LOG.warn("Acl building failed for flow classifier {}. Traffic might not be redirected to RSP", fc);
+ }
- public NeutronPortChainListener(DataBroker db, PortChainTranslator portChainTranslator) {
- super(portChainTranslator, db,
- new DataTreeIdentifier<>(LogicalDatastoreType.CONFIGURATION, portChainIid));
+ } else {
+ LOG.error("Neutron Flow Classifier {} attached to Port Chain {} is not present in the neutron data " +
+ "store", uuid, pc);
+ }
+ }
}
}
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
/**
- * OpenDaylight Neutron Port Group yang models data change listener
+ * OpenDaylight Neutron Port Pair Group yang models data change listener
*/
public class NeutronPortPairGroupListener extends DelegatingDataTreeListener<PortPairGroup> {
private static final InstanceIdentifier<PortPairGroup> portPairGroupIid =
InstanceIdentifier.create(Neutron.class).child(PortPairGroups.class).child(PortPairGroup.class);
- public NeutronPortPairGroupListener(DataBroker db, PortPairGroupTranslator portPairGroupTranslator) {
- super(portPairGroupTranslator, db,
- new DataTreeIdentifier<>(LogicalDatastoreType.CONFIGURATION, portPairGroupIid));
+ public NeutronPortPairGroupListener(DataBroker db) {
+ super(db,new DataTreeIdentifier<>(LogicalDatastoreType.CONFIGURATION, portPairGroupIid));
+ }
+
+ /**
+ * Method removes PortPairGroup which is identified by InstanceIdentifier.
+ *
+ * @param path - the whole path to PortPairGroup
+ * @param deletedPortPairGroup - PortPairGroup for removing
+ */
+ @Override
+ public void remove(InstanceIdentifier<PortPairGroup> path, PortPairGroup deletedPortPairGroup) {
+ //NO-OP
+ }
+
+ /**
+ * Method updates the original PortPairGroup to the update PortPairGroup.
+ * Both are identified by same InstanceIdentifier.
+ *
+ * @param path - the whole path to PortPairGroup
+ * @param originalPortPairGroup - original PortPairGroup (for update)
+ * @param updatePortPairGroup - changed PortPairGroup (contain updates)
+ */
+ @Override
+ public void update(InstanceIdentifier<PortPairGroup> path,
+ PortPairGroup originalPortPairGroup,
+ PortPairGroup updatePortPairGroup) {
+ //NO-OP
+ }
+
+ /**
+ * Method adds the PortPairGroup which is identified by InstanceIdentifier
+ * to device.
+ *
+ * @param path - the whole path to new PortPairGroup
+ * @param newPortPairGroup - new PortPairGroup
+ */
+ @Override
+ public void add(InstanceIdentifier<PortPairGroup> path, PortPairGroup newPortPairGroup) {
+ //NO-OP
}
}
import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.netvirt.openstack.sfc.translator.DelegatingDataTreeListener;
+import org.opendaylight.netvirt.openstack.sfc.translator.NeutronMdsalHelper;
+import org.opendaylight.netvirt.openstack.sfc.translator.OvsdbMdsalHelper;
+import org.opendaylight.netvirt.openstack.sfc.translator.SfcMdsalHelper;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.rev150712.Neutron;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.sfc.rev160511.sfc.attributes.PortPairs;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.sfc.rev160511.sfc.attributes.port.pairs.PortPair;
private static final InstanceIdentifier<PortPair> portPairIid =
InstanceIdentifier.create(Neutron.class).child(PortPairs.class).child(PortPair.class);
- public NeutronPortPairListener(DataBroker db, PortPairTranslator portPairTranslator) {
- super(portPairTranslator, db,
- new DataTreeIdentifier<>(LogicalDatastoreType.CONFIGURATION, portPairIid));
+ private final DataBroker db;
+ private final SfcMdsalHelper sfcMdsalHelper;
+ private final NeutronMdsalHelper neutronMdsalHelper;
+ private final OvsdbMdsalHelper ovsdbMdsalHelper;
+
+ public NeutronPortPairListener(DataBroker db) {
+ super(db,new DataTreeIdentifier<>(LogicalDatastoreType.CONFIGURATION, portPairIid));
+ this.db = db;
+ sfcMdsalHelper = new SfcMdsalHelper(db);
+ neutronMdsalHelper = new NeutronMdsalHelper(db);
+ ovsdbMdsalHelper = new OvsdbMdsalHelper(db);
+ }
+
+ /**
+ * Method removes PortPair which is identified by InstanceIdentifier.
+ *
+ * @param path - the whole path to PortPair
+ * @param deletedPortPair - PortPair for removing
+ */
+ @Override
+ public void remove(InstanceIdentifier<PortPair> path, PortPair deletedPortPair) {
+ sfcMdsalHelper.removeServiceFunction(PortPairTranslator.getSFKey(deletedPortPair));
+ }
+
+ /**
+ * Method updates the original PortPair to the update PortPair.
+ * Both are identified by same InstanceIdentifier.
+ *
+ * @param path - the whole path to PortPair
+ * @param originalPortPair - original PortPair (for update)
+ * @param updatePortPair - changed PortPair (contain updates)
+ */
+ @Override
+ public void update(InstanceIdentifier<PortPair> path, PortPair originalPortPair, PortPair updatePortPair) {
+ //NO-OP
+ }
+
+ /**
+ * Method adds the PortPair which is identified by InstanceIdentifier
+ * to device.
+ *
+ * @param path - the whole path to new PortPair
+ * @param newPortPair - new PortPair
+ */
+ @Override
+ public void add(InstanceIdentifier<PortPair> path, PortPair newPortPair) {
+ //NO-OP
+ // Port Pair data written in neutron data store will be used
+ // When user will create port chain.
}
}
*/
package org.opendaylight.netvirt.openstack.sfc.translator.portchain;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.netvirt.openstack.sfc.translator.INeutronSfcDataProcessor;
-import org.opendaylight.netvirt.openstack.sfc.translator.NeutronMdsalHelper;
-import org.opendaylight.netvirt.openstack.sfc.translator.SfcMdsalHelper;
+import com.google.common.base.Preconditions;
+import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.sfc.common.rev151017.SfcName;
+import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.sfc.common.rev151017.SfpName;
+import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.sfc.rsp.rev140701.CreateRenderedPathInput;
+import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.sfc.rsp.rev140701.CreateRenderedPathInputBuilder;
+import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.sfc.sf.rev140701.service.functions.ServiceFunction;
+import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.sfc.sfc.rev140701.service.function.chain.grouping.ServiceFunctionChain;
+import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.sfc.sfc.rev140701.service.function.chain.grouping.ServiceFunctionChainBuilder;
+import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.sfc.sfc.rev140701.service.function.chain.grouping.ServiceFunctionChainKey;
+import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.sfc.sfc.rev140701.service.function.chain.grouping.service.function.chain.SfcServiceFunction;
+import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.sfc.sfc.rev140701.service.function.chain.grouping.service.function.chain.SfcServiceFunctionBuilder;
+import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.sfc.sfc.rev140701.service.function.chain.grouping.service.function.chain.SfcServiceFunctionKey;
+import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.sfc.sfp.rev140701.service.function.paths.ServiceFunctionPath;
+import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.sfc.sfp.rev140701.service.function.paths.ServiceFunctionPathBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.sfc.rev160511.port.chain.attributes.ChainParameters;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.sfc.rev160511.sfc.attributes.port.chains.PortChain;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
+import java.util.ArrayList;
+import java.util.List;
+
/**
* Class will convert OpenStack Port Chain API yang models present in
* neutron northbound project to OpenDaylight SFC yang models.
*/
-public class PortChainTranslator implements INeutronSfcDataProcessor<PortChain> {
+public class PortChainTranslator {
private static final Logger LOG = LoggerFactory.getLogger(PortChainTranslator.class);
+ private static final String SYMMETRIC_PARAM = "symmetric";
+ private static final String SFP_NAME_PREFIX = "Path-";
- private final DataBroker db;
- private NeutronPortChainListener neutronPortChainListener;
- private final SfcMdsalHelper sfcMdsalHelper;
- private final NeutronMdsalHelper neutronMdsalHelper;
+ public static ServiceFunctionChain buildServiceFunctionChain(
+ PortChain portChain, List<ServiceFunction> sfList) {
+ ServiceFunctionChainBuilder sfcBuilder = new ServiceFunctionChainBuilder();
+ sfcBuilder.setName(new SfcName(portChain.getName()));
+ sfcBuilder.setKey(new ServiceFunctionChainKey(sfcBuilder.getName()));
- public PortChainTranslator(DataBroker db) {
- this.db = db;
- sfcMdsalHelper = new SfcMdsalHelper(db);
- neutronMdsalHelper = new NeutronMdsalHelper(db);
- }
+ //By default set it to false. If user specify it in chain parameters, it
+ //will be overridden.
+ sfcBuilder.setSymmetric(false);
- public void start() {
- LOG.info("Port Chain Translator Initialized.");
- if(neutronPortChainListener == null) {
- neutronPortChainListener = new NeutronPortChainListener(db, this);
+ //Set service functions
+ List<SfcServiceFunction> sfcSfList = new ArrayList<>();
+ for(ServiceFunction sf : sfList) {
+ SfcServiceFunctionBuilder sfcSfBuilder = new SfcServiceFunctionBuilder();
+ sfcSfBuilder.setName(sf.getName().getValue());
+ sfcSfBuilder.setType(sf.getType());
+ sfcSfBuilder.setKey(new SfcServiceFunctionKey(sfcSfBuilder.getName()));
+
+ //NOTE: no explicit order is set.
+ sfcSfList.add(sfcSfBuilder.build());
+ }
+ List<ChainParameters> cpList = portChain.getChainParameters();
+ if (cpList != null && !cpList.isEmpty()) {
+ for (ChainParameters cp : cpList) {
+ if(cp.getChainParameter().equals(SYMMETRIC_PARAM)) {
+ //Override the symmetric default value.
+ sfcBuilder.setSymmetric(new Boolean(cp.getChainParameterValue()));
+ break;
+ }
+ }
}
+ sfcBuilder.setSfcServiceFunction(sfcSfList);
+ return sfcBuilder.build();
}
- /**
- * Method removes PortChain which is identified by InstanceIdentifier.
- *
- * @param path - the whole path to PortChain
- * @param deletedPortChain - PortChain for removing
- */
- @Override
- public void remove(InstanceIdentifier<PortChain> path, PortChain deletedPortChain) {
+ public static ServiceFunctionPath buildServiceFunctionPath(ServiceFunctionChain sfc) {
+ Preconditions.checkNotNull(sfc, "Service Function Chain must not be null");
+ ServiceFunctionPathBuilder sfpBuilder = new ServiceFunctionPathBuilder();
- }
-
- /**
- * Method updates the original PortChain to the update PortChain.
- * Both are identified by same InstanceIdentifier.
- *
- * @param path - the whole path to PortChain
- * @param originalPortChain - original PortChain (for update)
- * @param updatePortChain - changed PortChain (contain updates)
- */
- @Override
- public void update(InstanceIdentifier<PortChain> path, PortChain originalPortChain, PortChain updatePortChain) {
+ //Set the name
+ sfpBuilder.setName(new SfpName(SFP_NAME_PREFIX + sfc.getName().getValue()));
+ sfpBuilder.setSymmetric(sfc.isSymmetric());
+ //Set related SFC name
+ sfpBuilder.setServiceChainName(sfc.getName());
+ return sfpBuilder.build();
}
- /**
- * Method adds the PortChain which is identified by InstanceIdentifier
- * to device.
- *
- * @param path - the whole path to new PortChain
- * @param newPortChain - new PortChain
- */
- @Override
- public void add(InstanceIdentifier<PortChain> path, PortChain newPortChain) {
+ public static CreateRenderedPathInput buildRenderedServicePathInput(ServiceFunctionPath sfp) {
+ CreateRenderedPathInputBuilder rpInputBuilder = new CreateRenderedPathInputBuilder();
+ rpInputBuilder.setName(sfp.getName().getValue());
+ rpInputBuilder.setSymmetric(sfp.isSymmetric());
+ rpInputBuilder.setParentServiceFunctionPath(sfp.getName().getValue());
+ return rpInputBuilder.build();
+ }
+ public static ServiceFunctionChainKey getSFCKey(PortChain portChain) {
+ return new ServiceFunctionChainKey(new SfcName(portChain.getName()));
}
}
*/
package org.opendaylight.netvirt.openstack.sfc.translator.portchain;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.netvirt.openstack.sfc.translator.INeutronSfcDataProcessor;
-import org.opendaylight.netvirt.openstack.sfc.translator.NeutronMdsalHelper;
-import org.opendaylight.netvirt.openstack.sfc.translator.SfcMdsalHelper;
+import com.google.common.base.Preconditions;
+import org.opendaylight.netvirt.openstack.sfc.translator.OvsdbMdsalHelper;
+import org.opendaylight.netvirt.openstack.sfc.translator.OvsdbPortMetadata;
+import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.sfc.common.rev151017.SffName;
+import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.sfc.common.rev151017.SnName;
+import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.sfc.sf.rev140701.service.functions.ServiceFunction;
+import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.sfc.sff.ovs.rev140701.SffOvsBridgeAugmentation;
+import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.sfc.sff.ovs.rev140701.SffOvsBridgeAugmentationBuilder;
+import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.sfc.sff.ovs.rev140701.SffOvsLocatorOptionsAugmentation;
+import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.sfc.sff.ovs.rev140701.SffOvsLocatorOptionsAugmentationBuilder;
+import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.sfc.sff.ovs.rev140701.SffOvsNodeAugmentation;
+import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.sfc.sff.ovs.rev140701.SffOvsNodeAugmentationBuilder;
+import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.sfc.sff.ovs.rev140701.bridge.OvsBridgeBuilder;
+import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.sfc.sff.ovs.rev140701.node.OvsNodeBuilder;
+import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.sfc.sff.ovs.rev140701.options.OvsOptionsBuilder;
+import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.sfc.sff.rev140701.Open;
+import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.sfc.sff.rev140701.service.function.forwarder.base.SffDataPlaneLocator;
+import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.sfc.sff.rev140701.service.function.forwarder.base.SffDataPlaneLocatorBuilder;
+import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.sfc.sff.rev140701.service.function.forwarder.base.sff.data.plane.locator.DataPlaneLocatorBuilder;
+import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.sfc.sff.rev140701.service.function.forwarders.ServiceFunctionForwarderBuilder;
+import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.sfc.sff.rev140701.service.function.forwarders.ServiceFunctionForwarderKey;
+import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.sfc.sff.rev140701.service.function.forwarders.service.function.forwarder.ServiceFunctionDictionary;
+import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.sfc.sff.rev140701.service.function.forwarders.service.function.forwarder.ServiceFunctionDictionaryBuilder;
+import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.sfc.sff.rev140701.service.function.forwarders.service.function.forwarder.ServiceFunctionDictionaryKey;
+import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.sfc.sff.rev140701.service.function.forwarders.service.function.forwarder.service.function.dictionary.SffSfDataPlaneLocatorBuilder;
+import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.sfc.sl.rev140701.VxlanGpe;
+import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.sfc.sl.rev140701.data.plane.locator.locator.type.IpBuilder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.sfc.rev160511.sfc.attributes.port.pair.groups.PortPairGroup;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.sfc.rev160511.sfc.attributes.port.pairs.PortPair;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeAugmentation;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbNodeAugmentation;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.atomic.AtomicInteger;
+
/**
* Class will convert OpenStack Port Pair API yang models present in
* neutron northbound project to OpenDaylight SFC yang models.
*/
-public class PortPairGroupTranslator implements INeutronSfcDataProcessor<PortPairGroup> {
+public class PortPairGroupTranslator {
private static final Logger LOG = LoggerFactory.getLogger(PortPairGroupTranslator.class);
+ private static final String OPT_FLOW_STR = "flow";
+ private static final String OPT_DST_PORT = "6633";
- private final DataBroker db;
- private NeutronPortPairGroupListener neutronPortPairGroupListener;
- private final SfcMdsalHelper sfcMdsalHelper;
- private final NeutronMdsalHelper neutronMdsalHelper;
+ private static final AtomicInteger counter = new AtomicInteger(0);
+ private static final String SFF_DEFAULT_NAME = "sff";
- public PortPairGroupTranslator(DataBroker db) {
- this.db = db;
- sfcMdsalHelper = new SfcMdsalHelper(db);
- neutronMdsalHelper = new NeutronMdsalHelper(db);
- }
+ public static ServiceFunctionForwarderBuilder buildServiceFunctionForwarder(
+ PortPairGroup portPairGroup,
+ List<PortPair> portPairs,
+ Map<Uuid, OvsdbPortMetadata> ovsdbPortsMetadata) {
+ Preconditions.checkNotNull(portPairGroup, "Port pair group must not be null");
+
+ ServiceFunctionForwarderBuilder sffBuilder = new ServiceFunctionForwarderBuilder();
+ SffOvsBridgeAugmentationBuilder sffOvsBridgeAugBuilder = new SffOvsBridgeAugmentationBuilder();
+ SffOvsNodeAugmentationBuilder sffOvsNodeAugBuilder = new SffOvsNodeAugmentationBuilder();
+
+ List<SffDataPlaneLocator> sffDataPlaneLocator = new ArrayList<>();
+ SffDataPlaneLocatorBuilder sffDplBuilder = new SffDataPlaneLocatorBuilder();
+ DataPlaneLocatorBuilder dplBuilder = new DataPlaneLocatorBuilder();
- public void start() {
- LOG.info("Port Pair Group Translator Initialized.");
- if(neutronPortPairGroupListener == null) {
- neutronPortPairGroupListener = new NeutronPortPairGroupListener(db, this);
+ IpBuilder sffLocator = new IpBuilder();
+
+ //Currently we only support one SF per type. Mean, one port-pair per port-pair-group.
+ //Get port pair from neutron data store.
+ PortPair portPair = portPairs.get(0);
+ if (portPair == null) {
+ LOG.error("Port pair {} does not exist in the neutron data store. Port Pair Group {} request can't be " +
+ "processed.", portPairGroup.getPortPairs().get(0), portPairGroup);
+ return null;
}
- }
+ //Get metadata of neutron port related to port pair ingress port from ovsdb data store.
+ OvsdbPortMetadata ovsdbPortMetadata = ovsdbPortsMetadata.get(portPair.getIngress());
- /**
- * Method removes PortPairGroup which is identified by InstanceIdentifier.
- *
- * @param path - the whole path to PortPairGroup
- * @param deletedPortPairGroup - PortPairGroup for removing
- */
- @Override
- public void remove(InstanceIdentifier<PortPairGroup> path, PortPairGroup deletedPortPairGroup) {
+ //Convert the port pair to service function
- }
+ //Set SFF DPL transport type
+ dplBuilder.setTransport(VxlanGpe.class);
- /**
- * Method updates the original PortPairGroup to the update PortPairGroup.
- * Both are identified by same InstanceIdentifier.
- *
- * @param path - the whole path to PortPairGroup
- * @param originalPortPairGroup - original PortPairGroup (for update)
- * @param updatePortPairGroup - changed PortPairGroup (contain updates)
- */
- @Override
- public void update(InstanceIdentifier<PortPairGroup> path,
- PortPairGroup originalPortPairGroup,
- PortPairGroup updatePortPairGroup) {
+ //Set SFF Locator Type
+ OvsdbNodeAugmentation ovsdbNodeAug = ovsdbPortMetadata.getOvsdbNode();
+ if (ovsdbNodeAug != null ) {
+ sffLocator.setIp(ovsdbNodeAug.getConnectionInfo().getRemoteIp());
+ sffLocator.setPort(ovsdbNodeAug.getConnectionInfo().getRemotePort());
+ }
+ dplBuilder.setLocatorType(sffLocator.build());
+ //set data-path-locator for sff-data-path-locator
+ sffDplBuilder.setDataPlaneLocator(dplBuilder.build());
+
+ //Set location options for sff-dp-locator
+ sffDplBuilder.addAugmentation(SffOvsLocatorOptionsAugmentation.class, buildOvsOptions().build());
+
+ //Set ovsdb bridge name for sff
+ OvsBridgeBuilder ovsBridgeBuilder = new OvsBridgeBuilder();
+ OvsdbBridgeAugmentation ovsdbBridgeAugmentation = ovsdbPortMetadata.getOvsdbBridgeNode();
+ if (ovsdbBridgeAugmentation != null) {
+ ovsBridgeBuilder.setBridgeName(ovsdbBridgeAugmentation.getBridgeName().getValue());
+ //Set SFF name
+ String serviceNode = OvsdbMdsalHelper.getNodeKey(ovsdbBridgeAugmentation.getManagedBy().getValue());
+ if(serviceNode.isEmpty()) {
+ serviceNode += SFF_DEFAULT_NAME + counter.incrementAndGet();
+ sffBuilder.setName(new SffName(serviceNode));
+ sffBuilder.setServiceNode(new SnName(serviceNode));
+ } else {
+ //Set service node to ovsdbNode
+ sffBuilder.setServiceNode(new SnName(serviceNode));
+
+ //Set SFF name to ovsdbBridgeNode
+ serviceNode += "/" + ovsdbBridgeAugmentation.getBridgeName().getValue();
+ sffBuilder.setName(new SffName(serviceNode));
+ }
+
+ //Set ovsdb-node iid reference for SFF
+ OvsNodeBuilder ovsNodeBuilder = new OvsNodeBuilder();
+ ovsNodeBuilder.setNodeId(ovsdbBridgeAugmentation.getManagedBy());
+ sffOvsNodeAugBuilder.setOvsNode(ovsNodeBuilder.build());
+ sffBuilder.addAugmentation(SffOvsNodeAugmentation.class, sffOvsNodeAugBuilder.build());
+ }
+ sffOvsBridgeAugBuilder.setOvsBridge(ovsBridgeBuilder.build());
+ sffBuilder.addAugmentation(SffOvsBridgeAugmentation.class, sffOvsBridgeAugBuilder.build());
+
+ //Set management ip, same to the ovsdb node ip
+ sffBuilder.setIpMgmtAddress(sffLocator.getIp());
+
+ sffDataPlaneLocator.add(sffDplBuilder.build());
+ //set SFF key
+ sffBuilder.setKey(new ServiceFunctionForwarderKey(sffBuilder.getName()));
+ sffBuilder.setSffDataPlaneLocator(sffDataPlaneLocator);
+
+ return sffBuilder;
}
- /**
- * Method adds the PortPairGroup which is identified by InstanceIdentifier
- * to device.
- *
- * @param path - the whole path to new PortPairGroup
- * @param newPortPairGroup - new PortPairGroup
- */
- @Override
- public void add(InstanceIdentifier<PortPairGroup> path, PortPairGroup newPortPairGroup) {
+ public static void buildServiceFunctionDictonary(ServiceFunctionForwarderBuilder sffBuilder,
+ ServiceFunction sf) {
+ List<ServiceFunctionDictionary> sfdList = new ArrayList<>();
+ ServiceFunctionDictionaryBuilder sfdBuilder = new ServiceFunctionDictionaryBuilder();
+
+ //Build Sff-sf-data-plane-locator
+ SffSfDataPlaneLocatorBuilder sffSfDplBuilder = new SffSfDataPlaneLocatorBuilder();
+ sffSfDplBuilder.setSfDplName(sf.getSfDataPlaneLocator().get(0).getName());
+ sffSfDplBuilder.setSffDplName(sffBuilder.getSffDataPlaneLocator().get(0).getName());
+ sfdBuilder.setSffSfDataPlaneLocator(sffSfDplBuilder.build());
+
+ sfdBuilder.setName(sf.getName());
+ sfdBuilder.setKey(new ServiceFunctionDictionaryKey(sfdBuilder.getName()));
+
+ //NOTE: fail mode is set to Open by default
+ sfdBuilder.setFailmode(Open.class);
+
+ //TODO: set interface name list
+
+ for (Iterator<ServiceFunctionDictionary> sfdItr = sffBuilder.getServiceFunctionDictionary().iterator();sfdItr
+ .hasNext();) {
+ ServiceFunctionDictionary sfd = sfdItr.next();
+ if (sfd.getName().equals(sfdBuilder.getName())) {
+ LOG.info("Existing SF dictionary {} found in SFF {}, removing the SF dictionary", sfd.getName(),
+ sffBuilder.getName());
+ sfdItr.remove();
+ break;
+ }
+ }
+ sfdList.add(sfdBuilder.build());
+
+ if (sffBuilder.getServiceFunctionDictionary() != null) {
+ sffBuilder.getServiceFunctionDictionary().addAll(sfdList);
+ } else {
+ sffBuilder.setServiceFunctionDictionary(sfdList);
+ }
+ LOG.info("Final Service Function Dictionary {}", sffBuilder.getServiceFunctionDictionary());
+ }
+ private static SffOvsLocatorOptionsAugmentationBuilder buildOvsOptions() {
+ SffOvsLocatorOptionsAugmentationBuilder ovsOptions = new SffOvsLocatorOptionsAugmentationBuilder();
+ OvsOptionsBuilder ovsOptionsBuilder = new OvsOptionsBuilder();
+ ovsOptionsBuilder.setRemoteIp(OPT_FLOW_STR);
+ ovsOptionsBuilder.setDstPort(OPT_DST_PORT);
+ ovsOptionsBuilder.setKey(OPT_FLOW_STR);
+ ovsOptionsBuilder.setNsp(OPT_FLOW_STR);
+ ovsOptionsBuilder.setNsi(OPT_FLOW_STR);
+ ovsOptionsBuilder.setNshc1(OPT_FLOW_STR);
+ ovsOptionsBuilder.setNshc2(OPT_FLOW_STR);
+ ovsOptionsBuilder.setNshc3(OPT_FLOW_STR);
+ ovsOptionsBuilder.setNshc4(OPT_FLOW_STR);
+ ovsOptions.setOvsOptions(ovsOptionsBuilder.build());
+ return ovsOptions;
}
}
*/
package org.opendaylight.netvirt.openstack.sfc.translator.portchain;
+import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableBiMap;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.netvirt.openstack.sfc.translator.INeutronSfcDataProcessor;
-import org.opendaylight.netvirt.openstack.sfc.translator.NeutronMdsalHelper;
import org.opendaylight.netvirt.openstack.sfc.translator.OvsdbMdsalHelper;
import org.opendaylight.netvirt.openstack.sfc.translator.OvsdbPortMetadata;
-import org.opendaylight.netvirt.openstack.sfc.translator.SfcMdsalHelper;
import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.sfc.common.rev151017.SfDataPlaneLocatorName;
import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.sfc.common.rev151017.SfName;
import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.sfc.common.rev151017.SffName;
import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.sfc.sf.rev140701.service.function.base.SfDataPlaneLocator;
import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.sfc.sf.rev140701.service.function.base.SfDataPlaneLocatorBuilder;
import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.sfc.sf.rev140701.service.function.base.SfDataPlaneLocatorKey;
-import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.sfc.sf.rev140701.service.functions.ServiceFunction;
import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.sfc.sf.rev140701.service.functions.ServiceFunctionBuilder;
import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.sfc.sf.rev140701.service.functions.ServiceFunctionKey;
+import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.sfc.sff.rev140701.service.function.forwarders.ServiceFunctionForwarder;
import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.sfc.sl.rev140701.SlTransportType;
import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.sfc.sl.rev140701.VxlanGpe;
import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.sfc.sl.rev140701.data.plane.locator.locator.type.IpBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.port.attributes.AllowedAddressPairs;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.ports.attributes.ports.Port;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.sfc.rev160511.port.pair.attributes.ServiceFunctionParameters;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.sfc.rev160511.sfc.attributes.port.pair.groups.PortPairGroup;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.sfc.rev160511.sfc.attributes.port.pairs.PortPair;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
* Class will convert OpenStack Port Pair API yang models present in
* neutron northbound project to OpenDaylight SFC Service Function yang models.
*/
-public class PortPairTranslator implements INeutronSfcDataProcessor<PortPair> {
+public class PortPairTranslator {
private static final Logger LOG = LoggerFactory.getLogger(PortPairTranslator.class);
private static final String NSH_AWARE_PARAM = "nsh-aware";
private static final String SF_TYPE_PARAM = "type";
private static final AtomicInteger counter = new AtomicInteger(0);
private static final String SFF_NAME_PARAM = "sff-name";
- private final DataBroker db;
- private NeutronPortPairListener neutronPortPairListener;
- private final SfcMdsalHelper sfcMdsalHelper;
- private final NeutronMdsalHelper neutronMdsalHelper;
- private final OvsdbMdsalHelper ovsdbMdsalHelper;
-
- public PortPairTranslator(DataBroker db) {
- this.db = db;
- sfcMdsalHelper = new SfcMdsalHelper(db);
- neutronMdsalHelper = new NeutronMdsalHelper(db);
- ovsdbMdsalHelper = new OvsdbMdsalHelper(db);
- }
-
- public void start() {
- LOG.info("Port Pair Translator Initialized.");
- if(neutronPortPairListener == null) {
- neutronPortPairListener = new NeutronPortPairListener(db, this);
- }
- }
-
- /**
- * Method removes PortPair which is identified by InstanceIdentifier.
- *
- * @param path - the whole path to PortPair
- * @param deletedPortPair - PortPair for removing
- */
- @Override
- public void remove(InstanceIdentifier<PortPair> path, PortPair deletedPortPair) {
- sfcMdsalHelper.removeServiceFunction(getSFKey(deletedPortPair));
- }
-
- /**
- * Method updates the original PortPair to the update PortPair.
- * Both are identified by same InstanceIdentifier.
- *
- * @param path - the whole path to PortPair
- * @param originalPortPair - original PortPair (for update)
- * @param updatePortPair - changed PortPair (contain updates)
- */
- @Override
- public void update(InstanceIdentifier<PortPair> path, PortPair originalPortPair, PortPair updatePortPair) {
- ServiceFunction sf = buildServiceFunction(updatePortPair);
- sfcMdsalHelper.updateServiceFunction(sf);
- }
-
- /**
- * Method adds the PortPair which is identified by InstanceIdentifier
- * to device.
- *
- * @param path - the whole path to new PortPair
- * @param newPortPair - new PortPair
- */
- @Override
- public void add(InstanceIdentifier<PortPair> path, PortPair newPortPair) {
- ServiceFunction sf = buildServiceFunction(newPortPair);
- sfcMdsalHelper.addServiceFunction(sf);
- }
-
- private ServiceFunction buildServiceFunction(PortPair portPair) {
+ public static ServiceFunctionBuilder buildServiceFunction(
+ PortPair portPair,
+ PortPairGroup portPairGroup,
+ Port neutronPort,
+ OvsdbPortMetadata ovsdbPortMetadata,
+ ServiceFunctionForwarder sff) {
+ Preconditions.checkNotNull(portPair, "Port pair must not be null");
+ Preconditions.checkNotNull(portPairGroup, "Port pair group must not be null");
+ Preconditions.checkNotNull(neutronPort, "Neutron Port related to port pair must not be null");
LOG.info("Port pair received : {}", portPair);
ServiceFunctionBuilder serviceFunctionBuilder = new ServiceFunctionBuilder();
IpBuilder sfLocator = new IpBuilder();
List<ServiceFunctionParameters> sfParams = portPair.getServiceFunctionParameters();
-
+ //Set SF name, key and tenant-id
serviceFunctionBuilder.setName(new SfName(portPair.getName()));
serviceFunctionBuilder.setKey(new ServiceFunctionKey(serviceFunctionBuilder.getName()));
-
serviceFunctionBuilder.setTenantId(new TenantId(portPair.getTenantId().getValue()));
- //By default set it to true
+
+ //Set SF Type. Setting it to PortPairGroup Type, this will be overridden if user pass
+ //it through service_function_params
+ serviceFunctionBuilder.setType(SftTypeName.getDefaultInstance(portPairGroup.getName()));
+
+ //Set NSH Aware to true, later it will be overridden if user specified otherwise
+ //in service_function_parameters
serviceFunctionBuilder.setNshAware(true);
- //Set data path locator
+ //Set data path locator name and key
sfDataPlaneLocatorBuilder.setName(new SfDataPlaneLocatorName(portPair.getName() + DPL_SUFFIX_PARAM));
sfDataPlaneLocatorBuilder.setKey(new SfDataPlaneLocatorKey(sfDataPlaneLocatorBuilder.getName()));
//Set vxlan-gpe as a default transport type, unless user pass specific transport in
- //service_function_params
+ //service_function_parameters
sfDataPlaneLocatorBuilder.setTransport(VxlanGpe.class);
//Set locator type
- Port neutronPort = neutronMdsalHelper.getNeutronPort(portPair.getIngress());
- if (neutronPort == null) {
- //Try to get the neutron port for egress node. Currently assuming that
- //ingress port and egress port will be same.
- neutronPort = neutronMdsalHelper.getNeutronPort(portPair.getEgress());
- }
if (neutronPort != null) {
List<AllowedAddressPairs> attachedIpAddresses = neutronPort.getAllowedAddressPairs();
//Pick up the first ip address
LOG.warn("Neutron port mapped to Port pair ingress/egress port is not found : {}", portPair);
}
- //Set OVS_Port
- //This call is very costly call, as it reads ovsdb:1 topology from the operational data store.
- // Need to think of caching to optimize it further.
- OvsdbPortMetadata ovsdbPortMetadata = ovsdbMdsalHelper.getOvsdbPortMetadata(portPair.getIngress());
if (ovsdbPortMetadata.getOvsdbPort() != null ) {
- String ovsdbPortName = ovsdbMdsalHelper.getOvsdbPortName(ovsdbPortMetadata.getOvsdbPort());
+ String ovsdbPortName = OvsdbMdsalHelper.getOvsdbPortName(ovsdbPortMetadata.getOvsdbPort());
SfDplOvsAugmentationBuilder sfDplOvsAugmentationBuilder = new SfDplOvsAugmentationBuilder();
OvsPortBuilder ovsPortBuilder = new OvsPortBuilder();
ovsPortBuilder.setPortId(ovsdbPortName);
sfDplOvsAugmentationBuilder.setOvsPort(ovsPortBuilder.build());
sfDataPlaneLocatorBuilder.addAugmentation(SfDplOvsAugmentation.class, sfDplOvsAugmentationBuilder.build());
+ } else {
+ LOG.warn("No OVSDB Port found for the port pair {}. Lack of ovs-port information might not configure SF " +
+ "properly", portPair);
}
- //But if user pass specific param using service_function_parameters, set it accordingly
+ //But if user pass specific param using service_function_parameters, set/override it accordingly
for(ServiceFunctionParameters sfParam : sfParams) {
if (sfParam.getServiceFunctionParameter().equals(NSH_AWARE_PARAM)) {
serviceFunctionBuilder.setNshAware(new Boolean(sfParam.getServiceFunctionParameterValue()));
}
- //There is not default type set, user MUST pass it through service_function_parameters
+ //There is by default type set to port pair group name, override it if user pass it specific type
if (sfParam.getServiceFunctionParameter().equals(SF_TYPE_PARAM)) {
serviceFunctionBuilder.setType(new SftTypeName(sfParam.getServiceFunctionParameterValue()));
}
//Set service_function_forwarder
if (sfDataPlaneLocatorBuilder.getServiceFunctionForwarder() == null
&& ovsdbPortMetadata.getOvsdbNode() != null) {
- String ipAddress = ovsdbMdsalHelper.getNodeIpAddress(ovsdbPortMetadata.getOvsdbNode());
- SffName sffName = sfcMdsalHelper.getExistingSFF(ipAddress);
+ SffName sffName = sff.getName();
if(sffName != null ) {
sfDataPlaneLocatorBuilder.setServiceFunctionForwarder(sffName);
} else {
//Set all data plane locator
serviceFunctionBuilder.setSfDataPlaneLocator(sfDataPlaneLocatorList);
LOG.info("Port Pair translated to Service Function: {}", serviceFunctionBuilder);
- return serviceFunctionBuilder.build();
+ return serviceFunctionBuilder;
}
- private ServiceFunctionKey getSFKey(PortPair portPair) {
+ public static ServiceFunctionKey getSFKey(PortPair portPair) {
return new ServiceFunctionKey(new SfName(portPair.getName()));
}
-
}
<reference id="dataBroker"
interface="org.opendaylight.controller.md.sal.binding.api.DataBroker" />
+ <reference id="rspService"
+ interface="org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.sfc.rsp.rev140701.RenderedServicePathService"
+ availability="optional"/>
<odl:clustered-app-config id="openstackSfcTranslatorConfig"
binding-class="org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.netvirt.openstack.sfc.translator.config.rev160720.OpenstackSfcTranslatorConfig">
class="org.opendaylight.netvirt.openstack.sfc.translator.OpenStackSFCTranslatorProvider"
init-method="start" destroy-method="close">
<argument ref="dataBroker" />
+ <argument ref="rspService" />
<argument ref="openstackSfcTranslatorConfig" />
<argument ref="blueprintBundleContext" />
</bean>
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<parent>
- <groupId>org.opendaylight.controller</groupId>
+ <groupId>org.opendaylight.odlparent</groupId>
<artifactId>karaf-parent</artifactId>
<version>1.7.0-SNAPSHOT</version>
<relativePath/>
public String getDCGwIP();
+ void sendNotificationEvent(String pfx, int code, int subcode);
+ void setqBGPrestartTS(long qBGPrestartTS);
+ void bgpRestarted();
}
+++ /dev/null
-module bgpmanager-api {
- yang-version 1;
- namespace "urn:opendaylight:params:xml:ns:yang:bgpmanager:api";
- prefix "bgpmgr-api";
-
- import config { prefix config; revision-date 2013-04-05; }
-
- description
- "Service definition for bgpmanager project";
-
- revision "2015-04-20" {
- description
- "Initial revision";
- }
-
- identity bgpmanager-api {
- base "config:service-type";
- config:java-class "org.opendaylight.netvirt.bgpmanager.api.IBgpManager";
- }
-}
\ No newline at end of file
+++ /dev/null
-<?xml version="1.0" encoding="UTF-8"?>
-<!-- vi: set et smarttab sw=4 tabstop=4: -->
-<!--
-Copyright (c) 2015 Ericsson India Global Services Pvt Ltd. and others. All rights reserved.
-
-This program and the accompanying materials are made available under the
-terms of the Eclipse Public License v1.0 which accompanies this distribution,
-and is available at http://www.eclipse.org/legal/epl-v10.html
--->
-<snapshot>
- <required-capabilities>
- <capability>urn:opendaylight:params:xml:ns:yang:bgpmanager:impl?module=bgpmanager-impl&revision=2015-03-26</capability>
- <capability>urn:opendaylight:params:xml:ns:yang:controller:md:sal:binding?module=opendaylight-md-sal-binding&revision=2013-10-28</capability>
- <capability>urn:opendaylight:params:xml:ns:yang:controller:md:sal:binding:impl?module=opendaylight-sal-binding-broker-impl&revision=2013-10-28</capability>
- <capability>urn:opendaylight:params:xml:ns:yang:controller:md:sal:core:spi:entity-ownership-service?module=opendaylight-entity-ownership-service&revision=2015-08-10</capability>
- </required-capabilities>
- <configuration>
-
- <data xmlns="urn:ietf:params:xml:ns:netconf:base:1.0">
- <modules xmlns="urn:opendaylight:params:xml:ns:yang:controller:config">
- <module>
- <type xmlns:prefix="urn:opendaylight:params:xml:ns:yang:bgpmanager:impl">prefix:bgpmanager-impl</type>
- <name>bgpmanager-default</name>
- <broker>
- <type xmlns:binding="urn:opendaylight:params:xml:ns:yang:controller:md:sal:binding">binding:binding-broker-osgi-registry</type>
- <name>binding-osgi-broker</name>
- </broker>
- <rpcregistry>
- <type xmlns:binding="urn:opendaylight:params:xml:ns:yang:controller:md:sal:binding">binding:binding-rpc-registry</type>
- <name>binding-rpc-broker</name>
- </rpcregistry>
- <notification-service>
- <type xmlns:bindingimpl="urn:opendaylight:params:xml:ns:yang:controller:md:sal:binding:impl">bindingimpl:binding-new-notification-service</type>
- <name>binding-notification-adapter</name>
- </notification-service>
- <entity-ownership-service>
- <type xmlns:entity-ownership="urn:opendaylight:params:xml:ns:yang:controller:md:sal:core:spi:entity-ownership-service">entity-ownership:entity-ownership-service</type>
- <name>entity-ownership-service</name>
- </entity-ownership-service>
- <binding-normalized-node-serializer>
- <type xmlns:binding="urn:opendaylight:params:xml:ns:yang:controller:md:sal:binding">binding:binding-normalized-node-serializer</type>
- <name>runtime-mapping-singleton</name>
- </binding-normalized-node-serializer>
- <!--
- <broker>
- <type xmlns:binding="urn:opendaylight:params:xml:ns:yang:controller:md:sal:binding">binding:binding-broker-osgi-registry</type>
- <name>binding-osgi-broker</name>
- </broker>
- <entity-ownership-service>
- <type xmlns:entity-ownership="urn:opendaylight:params:xml:ns:yang:controller:md:sal:core:spi:entity-ownership-service">entity-ownership:entity-ownership-service</type>
- <name>entity-ownership-service</name>
- </entity-ownership-service>
-
- <itm>
- <type xmlns:itm="urn:opendaylight:vpnservice:itm">itm:itm</type>
- <name>itm</name>
- </itm> -->
- </module>
- </modules>
- <services xmlns="urn:opendaylight:params:xml:ns:yang:controller:config">
- <service>
- <type xmlns:prefix="urn:opendaylight:params:xml:ns:yang:bgpmanager:api">prefix:bgpmanager-api</type>
- <instance>
- <name>bgpmanager</name>
- <provider>/modules/module[type='bgpmanager-impl'][name='bgpmanager-default']</provider>
- </instance>
- </service>
- </services>
- </data>
- </configuration>
-</snapshot>
+++ /dev/null
-/*
- * Copyright (c) 2015 Ericsson India Global Services Pvt Ltd. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-
-package org.opendaylight.netvirt.bgpmanager;
-
-import com.google.common.base.Optional;
-import com.google.common.base.Preconditions;
-
-import org.opendaylight.controller.md.sal.binding.api.DataChangeListener;
-import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent;
-import org.opendaylight.yangtools.yang.binding.DataObject;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-
-import java.util.Collections;
-import java.util.Map;
-import java.util.Set;
-
-/**
- * AbstractDataChangeListener implemented basic {@link DataChangeListener} processing for
- * VPN related Data Objects.
- */
-public abstract class AbstractDataChangeListener <T extends DataObject> implements DataChangeListener {
-
- protected final Class<T> clazz;
-
- public AbstractDataChangeListener(Class<T> clazz) {
- this.clazz = Preconditions.checkNotNull(clazz, "Class can not be null!");
- }
-
- @Override
- public void onDataChanged(final AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> changeEvent) {
- Preconditions.checkNotNull(changeEvent,"Async ChangeEvent can not be null!");
-
- /* All DataObjects for create */
- final Map<InstanceIdentifier<?>, DataObject> createdData = changeEvent.getCreatedData() != null
- ? changeEvent.getCreatedData() : Collections.<InstanceIdentifier<?>, DataObject> emptyMap();
- /* All DataObjects for remove */
- final Set<InstanceIdentifier<?>> removeData = changeEvent.getRemovedPaths() != null
- ? changeEvent.getRemovedPaths() : Collections.<InstanceIdentifier<?>> emptySet();
- /* All DataObjects for updates */
- final Map<InstanceIdentifier<?>, DataObject> updateData = changeEvent.getUpdatedData() != null
- ? changeEvent.getUpdatedData() : Collections.<InstanceIdentifier<?>, DataObject> emptyMap();
- /* All Original DataObjects */
- final Map<InstanceIdentifier<?>, DataObject> originalData = changeEvent.getOriginalData() != null
- ? changeEvent.getOriginalData() : Collections.<InstanceIdentifier<?>, DataObject> emptyMap();
-
- this.createData(createdData);
- this.updateData(updateData, originalData);
- this.removeData(removeData, originalData);
- }
-
- @SuppressWarnings("unchecked")
- private void createData(final Map<InstanceIdentifier<?>, DataObject> createdData) {
- final Set<InstanceIdentifier<?>> keys = createdData.keySet() != null
- ? createdData.keySet() : Collections.<InstanceIdentifier<?>> emptySet();
- for (InstanceIdentifier<?> key : keys) {
- if (clazz.equals(key.getTargetType())) {
- InstanceIdentifier<T> createKeyIdent = key.firstIdentifierOf(clazz);
- final Optional<DataObject> value = Optional.of(createdData.get(key));
- if (value.isPresent()) {
- this.add(createKeyIdent, (T)value.get());
- }
- }
- }
- }
-
- @SuppressWarnings("unchecked")
- private void updateData(final Map<InstanceIdentifier<?>, DataObject> updateData,
- final Map<InstanceIdentifier<?>, DataObject> originalData) {
-
- final Set<InstanceIdentifier<?>> keys = updateData.keySet() != null
- ? updateData.keySet() : Collections.<InstanceIdentifier<?>> emptySet();
- for (InstanceIdentifier<?> key : keys) {
- if (clazz.equals(key.getTargetType())) {
- InstanceIdentifier<T> updateKeyIdent = key.firstIdentifierOf(clazz);
- final Optional<DataObject> value = Optional.of(updateData.get(key));
- final Optional<DataObject> original = Optional.of(originalData.get(key));
- if (value.isPresent() && original.isPresent()) {
- this.update(updateKeyIdent, (T)original.get(), (T)value.get());
- }
- }
- }
- }
-
- @SuppressWarnings("unchecked")
- private void removeData(final Set<InstanceIdentifier<?>> removeData,
- final Map<InstanceIdentifier<?>, DataObject> originalData) {
-
- for (InstanceIdentifier<?> key : removeData) {
- if (clazz.equals(key.getTargetType())) {
- final InstanceIdentifier<T> ident = key.firstIdentifierOf(clazz);
- final DataObject removeValue = originalData.get(key);
- this.remove(ident, (T)removeValue);
- }
- }
- }
-
- protected abstract void remove(InstanceIdentifier<T> identifier, T del);
-
- protected abstract void update(InstanceIdentifier<T> identifier, T original, T update);
-
- protected abstract void add(InstanceIdentifier<T> identifier, T add);
-
-}
-
-
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.netvirt.bgpmanager;
import com.google.common.base.Optional;
-
-import java.io.*;
-import java.util.*;
-import java.lang.reflect.*;
+import io.netty.util.concurrent.GlobalEventExecutor;
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.lang.reflect.Constructor;
import java.net.InetAddress;
import java.net.NetworkInterface;
-import java.util.concurrent.*;
+import java.util.Arrays;
+import java.util.Enumeration;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Timer;
+import java.util.TimerTask;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeoutException;
import java.util.concurrent.atomic.AtomicBoolean;
-
-import org.opendaylight.netvirt.bgpmanager.commands.ClearBgpCli;
-import org.opendaylight.netvirt.bgpmanager.thrift.gen.*;
-import org.opendaylight.netvirt.bgpmanager.thrift.client.*;
-import org.opendaylight.netvirt.bgpmanager.thrift.server.*;
+import org.opendaylight.controller.config.api.osgi.WaitingServiceTracker;
import org.opendaylight.controller.md.sal.binding.api.ClusteredDataTreeChangeListener;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.DataChangeListener;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.genius.datastoreutils.AsyncDataTreeChangeListenerBase;
import org.opendaylight.genius.utils.clustering.EntityOwnerUtils;
+import org.opendaylight.netvirt.bgpmanager.api.IBgpManager;
+import org.opendaylight.netvirt.bgpmanager.commands.ClearBgpCli;
+import org.opendaylight.netvirt.bgpmanager.oam.BgpConstants;
+import org.opendaylight.netvirt.bgpmanager.oam.BgpCounters;
+import org.opendaylight.netvirt.bgpmanager.thrift.client.BgpRouter;
+import org.opendaylight.netvirt.bgpmanager.thrift.client.BgpRouterException;
+import org.opendaylight.netvirt.bgpmanager.thrift.client.BgpSyncHandle;
+import org.opendaylight.netvirt.bgpmanager.thrift.gen.Routes;
+import org.opendaylight.netvirt.bgpmanager.thrift.gen.Update;
+import org.opendaylight.netvirt.bgpmanager.thrift.gen.af_afi;
+import org.opendaylight.netvirt.bgpmanager.thrift.gen.af_safi;
+import org.opendaylight.netvirt.bgpmanager.thrift.gen.qbgpConstants;
+import org.opendaylight.netvirt.bgpmanager.thrift.server.BgpThriftService;
import org.opendaylight.netvirt.fibmanager.api.RouteOrigin;
-import org.opendaylight.yang.gen.v1.urn.ericsson.params.xml.ns.yang.ebgp.rev150901.*;
-import org.opendaylight.yang.gen.v1.urn.ericsson.params.xml.ns.yang.ebgp.rev150901.bgp.*;
-import org.opendaylight.yang.gen.v1.urn.ericsson.params.xml.ns.yang.ebgp.rev150901.bgp.neighbors.*;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.*;
+import org.opendaylight.yang.gen.v1.urn.ericsson.params.xml.ns.yang.ebgp.rev150901.Bgp;
+import org.opendaylight.yang.gen.v1.urn.ericsson.params.xml.ns.yang.ebgp.rev150901.bgp.AsId;
+import org.opendaylight.yang.gen.v1.urn.ericsson.params.xml.ns.yang.ebgp.rev150901.bgp.AsIdBuilder;
+import org.opendaylight.yang.gen.v1.urn.ericsson.params.xml.ns.yang.ebgp.rev150901.bgp.ConfigServer;
+import org.opendaylight.yang.gen.v1.urn.ericsson.params.xml.ns.yang.ebgp.rev150901.bgp.ConfigServerBuilder;
+import org.opendaylight.yang.gen.v1.urn.ericsson.params.xml.ns.yang.ebgp.rev150901.bgp.GracefulRestart;
+import org.opendaylight.yang.gen.v1.urn.ericsson.params.xml.ns.yang.ebgp.rev150901.bgp.GracefulRestartBuilder;
+import org.opendaylight.yang.gen.v1.urn.ericsson.params.xml.ns.yang.ebgp.rev150901.bgp.Logging;
+import org.opendaylight.yang.gen.v1.urn.ericsson.params.xml.ns.yang.ebgp.rev150901.bgp.LoggingBuilder;
+import org.opendaylight.yang.gen.v1.urn.ericsson.params.xml.ns.yang.ebgp.rev150901.bgp.Neighbors;
+import org.opendaylight.yang.gen.v1.urn.ericsson.params.xml.ns.yang.ebgp.rev150901.bgp.NeighborsBuilder;
+import org.opendaylight.yang.gen.v1.urn.ericsson.params.xml.ns.yang.ebgp.rev150901.bgp.NeighborsKey;
+import org.opendaylight.yang.gen.v1.urn.ericsson.params.xml.ns.yang.ebgp.rev150901.bgp.Networks;
+import org.opendaylight.yang.gen.v1.urn.ericsson.params.xml.ns.yang.ebgp.rev150901.bgp.NetworksBuilder;
+import org.opendaylight.yang.gen.v1.urn.ericsson.params.xml.ns.yang.ebgp.rev150901.bgp.NetworksKey;
+import org.opendaylight.yang.gen.v1.urn.ericsson.params.xml.ns.yang.ebgp.rev150901.bgp.Vrfs;
+import org.opendaylight.yang.gen.v1.urn.ericsson.params.xml.ns.yang.ebgp.rev150901.bgp.VrfsBuilder;
+import org.opendaylight.yang.gen.v1.urn.ericsson.params.xml.ns.yang.ebgp.rev150901.bgp.VrfsKey;
+import org.opendaylight.yang.gen.v1.urn.ericsson.params.xml.ns.yang.ebgp.rev150901.bgp.neighbors.AddressFamilies;
+import org.opendaylight.yang.gen.v1.urn.ericsson.params.xml.ns.yang.ebgp.rev150901.bgp.neighbors.AddressFamiliesBuilder;
+import org.opendaylight.yang.gen.v1.urn.ericsson.params.xml.ns.yang.ebgp.rev150901.bgp.neighbors.AddressFamiliesKey;
+import org.opendaylight.yang.gen.v1.urn.ericsson.params.xml.ns.yang.ebgp.rev150901.bgp.neighbors.EbgpMultihop;
+import org.opendaylight.yang.gen.v1.urn.ericsson.params.xml.ns.yang.ebgp.rev150901.bgp.neighbors.EbgpMultihopBuilder;
+import org.opendaylight.yang.gen.v1.urn.ericsson.params.xml.ns.yang.ebgp.rev150901.bgp.neighbors.UpdateSource;
+import org.opendaylight.yang.gen.v1.urn.ericsson.params.xml.ns.yang.ebgp.rev150901.bgp.neighbors.UpdateSourceBuilder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Address;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.FibEntries;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.fibentries.VrfTables;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.vrfentries.VrfEntry;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import org.osgi.framework.Bundle;
import org.osgi.framework.BundleContext;
-import org.osgi.framework.FrameworkUtil;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class BgpConfigurationManager {
- private static final Logger LOG =
- LoggerFactory.getLogger(BgpConfigurationManager.class);
- private static DataBroker broker;
- private static FibDSWriter fib;
+ private static final Logger LOG = LoggerFactory.getLogger(BgpConfigurationManager.class);
+ private static DataBroker dataBroker;
+ private static FibDSWriter fibDSWriter;
+ public static IBgpManager bgpManager;
+ private final BundleContext bundleContext;
private static Bgp config;
private static BgpRouter bgpRouter;
private static BgpThriftService updateServer;
-
+ private BgpCounters bgpCounters;
+ private Timer bgpCountersTimer;
private static final String DEF_LOGFILE = "/var/log/bgp_debug.log";
private static final String DEF_LOGLEVEL = "errors";
private static final String UPDATE_PORT = "bgp.thrift.service.port";
private static String cPortStartup;
private static CountDownLatch initer = new CountDownLatch(1);
//static IITMProvider itmProvider;
- public static BgpManager bgpManager;
//map<rd, map<prefix/len, nexthop/label>>
private static Map<String, Map<String, String>> staledFibEntriesMap = new ConcurrentHashMap<>();
static int totalStaledCount = 0;
static int totalCleared = 0;
- private static final Class[] reactors =
- {
- ConfigServerReactor.class, AsIdReactor.class,
- GracefulRestartReactor.class, LoggingReactor.class,
- NeighborsReactor.class, UpdateSourceReactor.class,
- EbgpMultihopReactor.class, AddressFamiliesReactor.class,
- NetworksReactor.class, VrfsReactor.class, BgpReactor.class
- };
+ private static final Class[] reactors = {
+ ConfigServerReactor.class, AsIdReactor.class,
+ GracefulRestartReactor.class, LoggingReactor.class,
+ NeighborsReactor.class, UpdateSourceReactor.class,
+ EbgpMultihopReactor.class, AddressFamiliesReactor.class,
+ NetworksReactor.class, VrfsReactor.class, BgpReactor.class
+ };
private ListenerRegistration<DataChangeListener>[] registrations;
- EntityOwnershipService entityOwnershipService;
+
+ final BgpConfigurationManager bgpConfigurationManager;
+
+ public BgpConfigurationManager(final DataBroker dataBroker,
+ final EntityOwnershipService entityOwnershipService,
+ final FibDSWriter fibDSWriter,
+ final BundleContext bundleContext)
+ throws InterruptedException, ExecutionException, TimeoutException {
+ BgpConfigurationManager.dataBroker = dataBroker;
+ BgpConfigurationManager.fibDSWriter = fibDSWriter;
+ setEntityOwnershipService(entityOwnershipService);
+ this.bundleContext = bundleContext;
+ bgpRouter = BgpRouter.getInstance();
+ String uPort = getProperty(UPDATE_PORT, DEF_UPORT);
+ cHostStartup = getProperty(CONFIG_HOST, DEF_CHOST);
+ cPortStartup = getProperty(CONFIG_PORT, DEF_CPORT);
+ VtyshCli.setHostAddr(cHostStartup);
+ ClearBgpCli.setHostAddr(cHostStartup);
+ LOG.info("UpdateServer at localhost:" + uPort + " ConfigServer at "
+ + cHostStartup + ":" + cPortStartup);
+ readOdlThriftIpForBgpCommunication();
+ registerCallbacks();
+
+ LOG.info("BGP Configuration manager initialized");
+ initer.countDown();
+
+ bgpConfigurationManager = this;
+ BgpUtil.batchSize = BgpUtil.BATCH_SIZE;
+ if (Integer.getInteger("batch.size") != null) {
+ BgpUtil.batchSize = Integer.getInteger("batch.size");
+ }
+ BgpUtil.batchInterval = BgpUtil.PERIODICITY;
+ if (Integer.getInteger("batch.wait.time") != null) {
+ BgpUtil.batchInterval = Integer.getInteger("batch.wait.time");
+ }
+ BgpUtil.registerWithBatchManager(new BgpVrfBatchHandler());
+
+ GlobalEventExecutor.INSTANCE.execute(new Runnable() {
+ @Override
+ public void run() {
+ final WaitingServiceTracker<IBgpManager> tracker = WaitingServiceTracker.create(
+ IBgpManager.class, bundleContext);
+ bgpManager = tracker.waitForService(WaitingServiceTracker.FIVE_MINUTES);
+ updateServer = new BgpThriftService(Integer.parseInt(uPort), bgpManager, fibDSWriter);
+ updateServer.start();
+ LOG.info("BgpConfigurationManager initialized. IBgpManager={}", bgpManager);
+ }
+ });
+ }
private Object createListener(Class<?> cls) {
Constructor<?> ctor;
String dclName = obj.getClass().getName();
try {
AsyncDataTreeChangeListenerBase dcl = (AsyncDataTreeChangeListenerBase) obj;
- dcl.registerListener(LogicalDatastoreType.CONFIGURATION, broker);
+ dcl.registerListener(LogicalDatastoreType.CONFIGURATION, dataBroker);
} catch (Exception e) {
LOG.error(emsg, e);
throw new IllegalStateException(emsg + " " + dclName, e);
if (updateServer != null) {
updateServer.stop();
}
+ LOG.info("{} close", getClass().getSimpleName());
}
private boolean configExists() throws InterruptedException, ExecutionException, TimeoutException {
InstanceIdentifier.InstanceIdentifierBuilder<Bgp> iib =
InstanceIdentifier.builder(Bgp.class);
InstanceIdentifier<Bgp> iid = iib.build();
- Optional<Bgp> b = BgpUtil.read(broker,
+ Optional<Bgp> b = BgpUtil.read(dataBroker,
LogicalDatastoreType.CONFIGURATION, iid);
return b.isPresent();
}
private String getProperty(String var, String def) {
- Bundle b = FrameworkUtil.getBundle(BgpManager.class);
- if (b == null) {
- return def;
- }
- BundleContext context = b.getBundleContext();
- if (context == null) {
- return def;
- }
- String s = context.getProperty(var);
+ String s = bundleContext.getProperty(var);
return (s == null ? def : s);
}
- static BgpConfigurationManager bgpConfigurationManager;
-
- public BgpConfigurationManager(BgpManager bgpMgr) throws InterruptedException, ExecutionException, TimeoutException {
- broker = bgpMgr.getBroker();
- fib = bgpMgr.getFibWriter();
-
- bgpManager = bgpMgr;
- bgpRouter = BgpRouter.getInstance();
- String uPort = getProperty(UPDATE_PORT, DEF_UPORT);
- cHostStartup = getProperty(CONFIG_HOST, DEF_CHOST);
- cPortStartup = getProperty(CONFIG_PORT, DEF_CPORT);
- VtyshCli.setHostAddr(cHostStartup);
- ClearBgpCli.setHostAddr(cHostStartup);
- LOG.info("UpdateServer at localhost:" + uPort + " ConfigServer at "
- + cHostStartup + ":" + cPortStartup);
- updateServer = new BgpThriftService(Integer.parseInt(uPort), bgpMgr);
- updateServer.start();
- readOdlThriftIpForBgpCommunication();
- registerCallbacks();
-
- LOG.info("BGP Configuration manager initialized");
- initer.countDown();
-
- bgpConfigurationManager = this;
- BgpUtil.batchSize = BgpUtil.BATCH_SIZE;
- if (Integer.getInteger("batch.size") != null) {
- BgpUtil.batchSize = Integer.getInteger("batch.size");
- }
- BgpUtil.batchInterval = BgpUtil.PERIODICITY;
- if (Integer.getInteger("batch.wait.time") != null) {
- BgpUtil.batchInterval = Integer.getInteger("batch.wait.time");
- }
- BgpUtil.registerWithBatchManager(new BgpVrfBatchHandler());
- }
-
boolean ignoreClusterDcnEventForFollower() {
return !EntityOwnerUtils.amIEntityOwner(BGP_ENTITY_TYPE_FOR_OWNERSHIP, BGP_ENTITY_NAME);
}
public Bgp get() {
- config = bgpManager.getConfig();
+ config = getConfig();
return config;
}
- public void setEntityOwnershipService(EntityOwnershipService entityOwnershipService) {
- this.entityOwnershipService = entityOwnershipService;
+ public void setEntityOwnershipService(final EntityOwnershipService entityOwnershipService) {
try {
EntityOwnerUtils.registerEntityCandidateForOwnerShip(entityOwnershipService,
BGP_ENTITY_TYPE_FOR_OWNERSHIP, BGP_ENTITY_NAME, new EntityOwnershipListener() {
}
}
- public EntityOwnershipService getEntityOwnershipService() {
- return entityOwnershipService;
- }
-
private static final String addWarn =
"Config store updated; undo with Delete if needed.";
private static final String delWarn =
try {
super.close();
} catch (Exception e) {
- e.printStackTrace();
+ LOG.error("ConfigServerReactor failed to close: ", e);
}
}
}
boolean announceFbit = (afb == null) ? false : afb.booleanValue();
try {
br.startBgp(asNum, rid, stalepathTime, announceFbit);
- if (bgpManager.getBgpCounters() == null) {
- bgpManager.startBgpCountersTask();
+ if (getBgpCounters() == null) {
+ startBgpCountersTask();
}
} catch (BgpRouterException bre) {
if (bre.getErrorCode() == BgpRouterException.BGP_ERR_ACTIVE) {
} catch (Exception e) {
LOG.error(yangObj + " Delete received exception: \"" + e + "\"; " + delWarn);
}
- if (bgpManager.getBgpCounters() != null) {
- bgpManager.stopBgpCountersTask();
+ if (getBgpCounters() != null) {
+ stopBgpCountersTask();
}
}
}
public static long getStalePathtime(int defValue, AsId as_num) {
long spt = 0;
try {
- spt = bgpManager.getConfig().getGracefulRestart().getStalepathTime();
+ spt = getConfig().getGracefulRestart().getStalepathTime();
} catch (Exception e) {
try {
spt = as_num.getStalepathTime();
return;
}
setStaleStartTime(System.currentTimeMillis());
- LOG.error("started creating stale fib map ");
+ LOG.error("started creating stale fibDSWriter map ");
createStaleFibMap();
setStaleEndTime(System.currentTimeMillis());
- LOG.error("took {} msecs for stale fib map creation ", getStaleEndTime()- getStaleStartTime());
+ LOG.error("took {} msecs for stale fibDSWriter map creation ", getStaleEndTime()- getStaleStartTime());
LOG.error("started bgp config replay ");
setCfgReplayStartTime(System.currentTimeMillis());
replay();
}
/* onUpdatePushRoute
- * Get Stale fib map, and compare current route/fib entry.
+ * Get Stale fibDSWriter map, and compare current route/fibDSWriter entry.
* - Entry compare shall include NextHop, Label.
* - If entry matches: delete from STALE Map. NO Change to FIB Config DS.
* - If entry not found, add to FIB Config DS.
}
if (addroute) {
LOG.info("ADD: Adding Fib entry rd {} prefix {} nexthop {} label {}", rd, prefix, nextHop, label);
- fib.addFibEntryToDS(rd, prefix + "/" + plen, Arrays.asList(nextHop), label, RouteOrigin.BGP);
+ fibDSWriter.addFibEntryToDS(rd, prefix + "/" + plen, Arrays.asList(nextHop), label, RouteOrigin.BGP);
LOG.info("ADD: Added Fib entry rd {} prefix {} nexthop {} label {}", rd, prefix, nextHop, label);
}
}
ts.getPort().intValue());
}
- public static synchronized void replay() {
+ public static Bgp getConfig() {
+ //TODO cleanup this cache code
+ try {
+ Optional<Bgp> optional = BgpUtil.read(dataBroker,
+ LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(Bgp.class));
+ return optional.get();
+ } catch (Exception e) {
+ //LOG.error("failed to get bgp config",e);
+ }
+ return null;
+ }
+
+ public synchronized void replay() {
synchronized (bgpConfigurationManager) {
String host = getConfigHost();
int port = getConfigPort();
LOG.error(msg);
return;
}
- config = bgpManager.getConfig();
+ config = getConfig();
if (config == null) {
LOG.error("bgp config is empty nothing to push to bgp");
return;
LOG.error("Replay:startBgp() received exception: \"" + e + "\"");
}
- if (bgpManager.getBgpCounters() == null) {
- bgpManager.startBgpCountersTask();
+ if (getBgpCounters() == null) {
+ startBgpCountersTask();
}
Logging l = config.getLogging();
}
private <T extends DataObject> void update(InstanceIdentifier<T> iid, T dto) {
- BgpUtil.update(broker, LogicalDatastoreType.CONFIGURATION, iid, dto);
+ BgpUtil.update(dataBroker, LogicalDatastoreType.CONFIGURATION, iid, dto);
}
private <T extends DataObject> void asyncWrite(InstanceIdentifier<T> iid, T dto) {
- BgpUtil.write(broker, LogicalDatastoreType.CONFIGURATION, iid, dto);
+ BgpUtil.write(dataBroker, LogicalDatastoreType.CONFIGURATION, iid, dto);
}
private <T extends DataObject> void delete(InstanceIdentifier<T> iid) {
- BgpUtil.delete(broker, LogicalDatastoreType.CONFIGURATION, iid);
+ BgpUtil.delete(dataBroker, LogicalDatastoreType.CONFIGURATION, iid);
}
public synchronized void
try {
totalCleared++;
LOG.error("BGP: RouteCleanup deletePrefix called but not executed rd:{}, prefix{}" + rd.toString() + prefix);
- // fib.removeFibEntryFromDS(rd, prefix);
+ // fibDSWriter.removeFibEntryFromDS(rd, prefix);
} catch (Exception e) {
LOG.error("BGP: RouteCleanup deletePrefix failed rd:{}, prefix{}" + rd.toString() + prefix);
}
Thread.sleep(1000);
retry--;
if (retry == 0) {
- LOG.error("TimeOut occured {} seconds, in waiting stale fib create", STALE_FIB_WAIT);
+ LOG.error("TimeOut occured {} seconds, in waiting stale fibDSWriter create", STALE_FIB_WAIT);
}
}
staledFibEntriesMap.clear();
InstanceIdentifier<FibEntries> id = InstanceIdentifier.create(FibEntries.class);
DataBroker db = BgpUtil.getBroker();
if (db == null) {
- LOG.error("Couldn't find BgpUtil broker while creating createStaleFibMap");
+ LOG.error("Couldn't find BgpUtil dataBroker while creating createStaleFibMap");
return;
}
public static void onUpdateWithdrawRoute(String rd, String prefix, int plen) {
LOG.debug("Route del ** {} ** {}/{} ", rd, prefix, plen);
try {
- fib.removeFibEntryFromDS(rd, prefix + "/" + plen);
+ fibDSWriter.removeFibEntryFromDS(rd, prefix + "/" + plen);
} catch (Throwable e) {
LOG.error("failed to handle withdraw route ", e);
}
}
public static int getTotalStaledCount() {return totalStaledCount;}
public static int getTotalCleared() { return totalCleared;}
+
+ public Timer getBgpCountersTimer() {
+ return bgpCountersTimer;
+ }
+
+ public BgpCounters getBgpCounters() {
+ return bgpCounters;
+ }
+
+ public void setBgpCountersTimer (Timer t) {
+ bgpCountersTimer = t;
+ }
+
+ public void startBgpCountersTask() {
+ if (getBgpCounters() == null) {
+
+ try {
+ bgpCounters = new BgpCounters();
+ setBgpCountersTimer(new Timer(true));
+ getBgpCountersTimer().scheduleAtFixedRate(bgpCounters, 0, 120 * 1000);
+
+
+ LOG.info("Bgp Counters task scheduled for every two minutes.");
+ } catch (Exception e) {
+ System.out.println("Could not start the timertask for Bgp Counters.");
+ e.printStackTrace();
+ }
+
+ try {
+ bgpManager.setQbgpLog(BgpConstants.BGP_DEF_LOG_FILE, BgpConstants.BGP_DEF_LOG_LEVEL);
+ } catch (Exception e) {
+ System.out.println("Could not set the default options for logging");
+ }
+ }
+ }
+
+ public void stopBgpCountersTask() {
+ Timer t = getBgpCountersTimer();
+ if (getBgpCounters() != null) {
+ t.cancel();
+ setBgpCountersTimer(null);
+ bgpCounters = null;
+ }
+ }
}
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.netvirt.bgpmanager;
-import java.lang.management.ManagementFactory;
-import java.util.*;
-import java.util.concurrent.CountDownLatch;
-import java.util.concurrent.ExecutionException;
-import java.util.concurrent.TimeoutException;
-import javax.management.*;
-
-import com.google.common.base.*;
-import com.google.common.base.Optional;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
import org.apache.thrift.TException;
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.netvirt.bgpmanager.api.IBgpManager;
-import org.opendaylight.netvirt.bgpmanager.commands.Commands;
-import org.opendaylight.netvirt.bgpmanager.oam.*;
+import org.opendaylight.netvirt.bgpmanager.oam.BgpAlarmBroadcaster;
+import org.opendaylight.netvirt.bgpmanager.oam.BgpAlarmErrorCodes;
+import org.opendaylight.netvirt.bgpmanager.oam.BgpConstants;
import org.opendaylight.netvirt.bgpmanager.thrift.gen.af_afi;
import org.opendaylight.netvirt.bgpmanager.thrift.gen.af_safi;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.clustering.EntityOwnershipService;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.sal.binding.api.BindingAwareBroker.ProviderContext;
-import org.opendaylight.controller.sal.binding.api.BindingAwareProvider;
import org.opendaylight.netvirt.fibmanager.api.RouteOrigin;
import org.opendaylight.yang.gen.v1.urn.ericsson.params.xml.ns.yang.ebgp.rev150901.Bgp;
import org.opendaylight.yang.gen.v1.urn.ericsson.params.xml.ns.yang.ebgp.rev150901.bgp.Neighbors;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-public class BgpManager implements BindingAwareProvider, AutoCloseable, IBgpManager {
-
- private static final Logger LOGGER = LoggerFactory.getLogger(BgpManager.class);
- private BgpConfigurationManager bcm;
- private FibDSWriter fibDSWriter;
- //private IITMProvider itmProvider;
- private DataBroker dataBroker;
- private BgpAlarmBroadcaster qbgpAlarmProducer = null;
- private MBeanServer qbgpAlarmServer = null;
- private NotificationFilter qbgpAlarmFilter = null;
- final static int DEFAULT_STALEPATH_TIME = 210;
- final static boolean DEFAULT_FBIT = true;
-
+public class BgpManager implements AutoCloseable, IBgpManager {
+ private static final Logger LOG = LoggerFactory.getLogger(BgpManager.class);
+ private final DataBroker dataBroker;
+ private final BgpConfigurationManager bcm;
+ private final BgpAlarmBroadcaster qbgpAlarmProducer;
+ private final FibDSWriter fibDSWriter;
private long qBGPrestartTS = 0;
- EntityOwnershipService entityOwnershipService;
- public BgpCounters bgpCounters;
- public Timer bgpCountersTimer;
+ public BgpManager(final DataBroker dataBroker,
+ final BgpConfigurationManager bcm,
+ final BgpAlarmBroadcaster bgpAlarmProducer,
+ final FibDSWriter fibDSWriter) {
+ this.dataBroker = dataBroker;
+ this.bcm = bcm;
+ this.qbgpAlarmProducer = bgpAlarmProducer;
+ this.fibDSWriter = fibDSWriter;
+ }
- @Override
- public void onSessionInitiated(ProviderContext session) {
+ public void init() {
try {
- dataBroker = session.getSALService(DataBroker.class);
- fibDSWriter = new FibDSWriter(dataBroker);
BgpUtil.setBroker(dataBroker);
- bcm = new BgpConfigurationManager(this);
- bcm.setEntityOwnershipService(entityOwnershipService);
- Commands commands = new Commands(this);
ConfigureBgpCli.setBgpManager(this);
- LOGGER.info("BgpManager started");
+ LOG.info("{} start", getClass().getSimpleName());
} catch (Exception e) {
- LOGGER.error("Failed to start BgpManager: "+e);
- }
-
- // Set up the Infra for Posting BGP Alarms as JMX notifications.
- try {
- qbgpAlarmProducer = new BgpAlarmBroadcaster();
- MBeanServer mbs = ManagementFactory.getPlatformMBeanServer();
- ObjectName alarmObj = new ObjectName("SDNC.FM:name=BgpAlarmObj");
- mbs.registerMBean(qbgpAlarmProducer, alarmObj);
- } catch (JMException e) {
- LOGGER.error("Adding a NotificationBroadcaster failed." + e.toString());
- e.printStackTrace();
+ LOG.error("Failed to start BgpManager: ", e);
}
}
- public void setEntityOwnershipService(EntityOwnershipService entityOwnershipService) {
- this.entityOwnershipService = entityOwnershipService;
- }
-
@Override
public void close() throws Exception {
- bcm.close();
- LOGGER.info("BgpManager Closed");
- }
-
- /*public void setITMProvider(IITMProvider itmProvider) {
- this.itmProvider = itmProvider;
- }
-
- public IITMProvider getItmProvider() { return this.itmProvider; } */
-
- public Bgp getConfig() {
- //TODO cleanup this cache code
- try {
- Optional<Bgp> optional = BgpUtil.read(dataBroker,
- LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(Bgp.class));
- return optional.get();
- } catch (Exception e) {
- //LOGGER.error("failed to get bgp config",e);
- }
- return null;
+ LOG.info("{} close", getClass().getSimpleName());
}
public void configureGR(int stalepathTime) throws TException {
@Override
public void addVrf(String rd, Collection<String> importRts, Collection<String> exportRts) throws Exception {
- bcm.addVrf(rd, new ArrayList<String>(importRts), new ArrayList<String>(exportRts));
+ bcm.addVrf(rd, new ArrayList<>(importRts), new ArrayList<>(exportRts));
}
@Override
}
@Override
- public void addPrefix(String rd, String prefix, List<String> nextHopList, int vpnLabel, RouteOrigin origin) throws Exception {
+ public void addPrefix(String rd, String prefix, List<String> nextHopList, int vpnLabel, RouteOrigin origin)
+ throws Exception {
fibDSWriter.addFibEntryToDS(rd, prefix, nextHopList, vpnLabel, origin);
bcm.addPrefix(rd, prefix, nextHopList, vpnLabel);
}
@Override
- public void addPrefix(String rd, String prefix, String nextHop, int vpnLabel, RouteOrigin origin) throws Exception {
+ public void addPrefix(String rd, String prefix, String nextHop, int vpnLabel, RouteOrigin origin)
+ throws Exception {
addPrefix(rd, prefix, Arrays.asList(nextHop), vpnLabel, origin);
}
@Override
public void advertisePrefix(String rd, String prefix, String nextHop, int vpnLabel) throws Exception {
- LOGGER.info("ADVERTISE: Adding Prefix rd {} prefix {} nexthop {} label {}", rd, prefix, nextHop, vpnLabel);
+ LOG.info("ADVERTISE: Adding Prefix rd {} prefix {} nexthop {} label {}", rd, prefix, nextHop, vpnLabel);
bcm.addPrefix(rd, prefix, Arrays.asList(nextHop), vpnLabel);
- LOGGER.info("ADVERTISE: Added Prefix rd {} prefix {} nexthop {} label {}", rd, prefix, nextHop, vpnLabel);
+ LOG.info("ADVERTISE: Added Prefix rd {} prefix {} nexthop {} label {}", rd, prefix, nextHop, vpnLabel);
}
@Override
public void withdrawPrefix(String rd, String prefix) throws Exception {
- LOGGER.info("WITHDRAW: Removing Prefix rd {} prefix {}", rd, prefix);
+ LOG.info("WITHDRAW: Removing Prefix rd {} prefix {}", rd, prefix);
bcm.delPrefix(rd, prefix);
- LOGGER.info("WITHDRAW: Removed Prefix rd {} prefix {}", rd, prefix);
+ LOG.info("WITHDRAW: Removed Prefix rd {} prefix {}", rd, prefix);
}
public void setQbgpLog(String fileName, String debugLevel) throws Exception {
bcm.stopConfig();
}
+ public Bgp getConfig() {
+ return bcm.getConfig();
+ }
+
@Override
public String getDCGwIP() {
- Bgp conf = getConfig();
+ Bgp conf = bcm.getConfig();
if (conf == null) {
return null;
}
return nbrs.get(0).getAddress().getValue();
}
- public MBeanServer getBgpAlarmServer() {
- return qbgpAlarmServer;
- }
-
public synchronized void sendNotificationEvent(String pfx, int code, int subcode) {
BgpAlarmErrorCodes errorSubCode;
if (code != BgpConstants.BGP_NOTIFY_CEASE_CODE) {
// BgpAlarmErrorCodes enum class.
return;
}
- String alarmString = "";
- alarmString = "Alarm (" + code + "," + subcode + ") from neighbor " + pfx;
qbgpAlarmProducer.sendBgpAlarmInfo(pfx, code, subcode);
}
- public Timer getBgpCountersTimer() {
- return bgpCountersTimer;
- }
-
- public BgpCounters getBgpCounters() {
- return bgpCounters;
- }
-
- public void setBgpCountersTimer (Timer t) {
- bgpCountersTimer = t;
- }
-
- public void startBgpCountersTask() {
- if (getBgpCounters() == null) {
-
- try {
- bgpCounters = new BgpCounters();
- setBgpCountersTimer(new Timer(true));
- getBgpCountersTimer().scheduleAtFixedRate(bgpCounters, 0, 120 * 1000);
-
-
- LOGGER.info("Bgp Counters task scheduled for every two minutes.");
- } catch (Exception e) {
- System.out.println("Could not start the timertask for Bgp Counters.");
- e.printStackTrace();
- }
-
- try {
- setQbgpLog(BgpConstants.BGP_DEF_LOG_FILE, BgpConstants.BGP_DEF_LOG_LEVEL);
- } catch (Exception e) {
- System.out.println("Could not set the default options for logging");
- }
- }
- }
-
- public void stopBgpCountersTask() {
- Timer t = getBgpCountersTimer();
- if (getBgpCounters() != null) {
- t.cancel();
- setBgpCountersTimer(null);
- bgpCounters = null;
- }
- }
-
public FibDSWriter getFibWriter() {
return fibDSWriter;
}
- public DataBroker getBroker() {
- return dataBroker;
- }
-
public String getConfigHost() {
- return bcm.getConfigHost();
+ return BgpConfigurationManager.getConfigHost();
}
public int getConfigPort() {
- return bcm.getConfigPort();
+ return BgpConfigurationManager.getConfigPort();
}
public void bgpRestarted() {
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.netvirt.bgpmanager;
import com.google.common.base.Optional;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;
-/**
- * Created by emhamla on 8/31/2015.
- */
-
public class BgpUtil {
-
- private static final long FIB_READ_TIMEOUT = 1;
private static final Logger LOG = LoggerFactory.getLogger(BgpUtil.class);
private static DataBroker dataBroker;
private static BindingTransactionChain fibTransact;
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.netvirt.bgpmanager;
+import com.google.common.base.Optional;
+import com.google.common.base.Preconditions;
+import java.util.List;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.netvirt.fibmanager.api.RouteOrigin;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.InstanceIdentifierBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.vrfentries.VrfEntry;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.vrfentries.VrfEntryBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.FibEntries;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.fibentries.VrfTables;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.fibentries.VrfTablesKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.vrfentries.VrfEntry;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.vrfentries.VrfEntryBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.vrfentries.VrfEntryKey;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.FibEntries;
-
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.InstanceIdentifierBuilder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import com.google.common.base.Optional;
-import com.google.common.base.Preconditions;
-
-import java.util.*;
-
-
public class FibDSWriter {
private static final Logger logger = LoggerFactory.getLogger(FibDSWriter.class);
- private final DataBroker broker;
+ private final DataBroker dataBroker;
- public FibDSWriter(final DataBroker db) {
- broker = db;
+ public FibDSWriter(final DataBroker dataBroker) {
+ this.dataBroker = dataBroker;
}
public synchronized void addFibEntryToDS(String rd, String prefix, List<String> nextHopList,
InstanceIdentifier.builder(FibEntries.class)
.child(VrfTables.class, new VrfTablesKey(rd))
.child(VrfEntry.class, new VrfEntryKey(prefix)).build();
- Optional<VrfEntry> entry = BgpUtil.read(broker, LogicalDatastoreType.CONFIGURATION, vrfEntryId);
+ Optional<VrfEntry> entry = BgpUtil.read(dataBroker, LogicalDatastoreType.CONFIGURATION, vrfEntryId);
VrfEntry vrfEntry = new VrfEntryBuilder().setDestPrefix(prefix).setNextHopAddressList(nextHopList)
.setLabel((long)label).setOrigin(origin.getValue()).build();
- BgpUtil.write(broker, LogicalDatastoreType.CONFIGURATION, vrfEntryId, vrfEntry);
+ BgpUtil.write(dataBroker, LogicalDatastoreType.CONFIGURATION, vrfEntryId, vrfEntry);
} catch (Exception e) {
logger.error("addFibEntryToDS: error ", e);
}
InstanceIdentifierBuilder<VrfEntry> idBuilder =
InstanceIdentifier.builder(FibEntries.class).child(VrfTables.class, new VrfTablesKey(rd)).child(VrfEntry.class, new VrfEntryKey(prefix));
InstanceIdentifier<VrfEntry> vrfEntryId = idBuilder.build();
- BgpUtil.delete(broker, LogicalDatastoreType.CONFIGURATION, vrfEntryId);
+ BgpUtil.delete(dataBroker, LogicalDatastoreType.CONFIGURATION, vrfEntryId);
}
InstanceIdentifier.builder(FibEntries.class).child(VrfTables.class, new VrfTablesKey(rd));
InstanceIdentifier<VrfTables> vrfTableId = idBuilder.build();
- BgpUtil.delete(broker, LogicalDatastoreType.CONFIGURATION, vrfTableId);
+ BgpUtil.delete(dataBroker, LogicalDatastoreType.CONFIGURATION, vrfTableId);
}
-
-
-
}
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.netvirt.bgpmanager.oam;
-/**
- * Created by echiapt on 7/27/2015.
- */
-
- import javax.management.*;
-
- import org.slf4j.Logger;
- import org.slf4j.LoggerFactory;
-
- import java.util.ArrayList;
+import java.lang.management.ManagementFactory;
+import java.util.ArrayList;
+import javax.management.AttributeChangeNotification;
+import javax.management.JMException;
+import javax.management.MBeanServer;
+import javax.management.Notification;
+import javax.management.NotificationBroadcasterSupport;
+import javax.management.ObjectName;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
public class BgpAlarmBroadcaster extends NotificationBroadcasterSupport implements BgpAlarmBroadcasterMBean {
- private static final Logger LOGGER = LoggerFactory.getLogger(BgpAlarmBroadcaster.class);
+ private static final Logger LOG = LoggerFactory.getLogger(BgpAlarmBroadcaster.class);
private long sequenceNumber;
+
public BgpAlarmBroadcaster () {
this.sequenceNumber = 1;
}
+ public void init() {
+ // Set up the Infra for Posting BGP Alarms as JMX notifications.
+ try {
+ MBeanServer mbs = ManagementFactory.getPlatformMBeanServer();
+ ObjectName alarmObj = new ObjectName("SDNC.FM:name=BgpAlarmObj");
+ mbs.registerMBean(this, alarmObj);
+ } catch (JMException e) {
+ LOG.error("Adding a NotificationBroadcaster failed.", e);
+ }
+ LOG.info("{} start", getClass().getSimpleName());
+ }
+
public void sendBgpAlarmInfo(String pfx, int code , int subcode) {
Notification n;
String alarmAddText, alarmSrc = "BGP";
"raise Alarm Object notified", "raiseAlarmObject",
"ArrayList", "", arrayList);
sendNotification(n);
- LOGGER.info("BGP: Alarm :"+ userAlarm.getAlarmType() + " has been posted.");
- return;
+ LOG.info("BGP: Alarm :"+ userAlarm.getAlarmType() + " has been posted.");
}
}
package org.opendaylight.netvirt.bgpmanager.thrift.server;
-import java.util.*;
-
+import java.util.List;
import org.apache.thrift.protocol.TBinaryProtocol;
import org.apache.thrift.protocol.TProtocol;
-import org.apache.thrift.server.*;
-import org.apache.thrift.transport.*;
-import org.opendaylight.netvirt.bgpmanager.BgpManager;
+import org.apache.thrift.server.ServerContext;
+import org.apache.thrift.server.TServer;
+import org.apache.thrift.server.TServerEventHandler;
+import org.apache.thrift.server.TThreadedSelectorServer;
+import org.apache.thrift.transport.TFramedTransport;
+import org.apache.thrift.transport.TNonblockingServerSocket;
+import org.apache.thrift.transport.TNonblockingServerTransport;
+import org.apache.thrift.transport.TTransport;
import org.opendaylight.netvirt.bgpmanager.BgpConfigurationManager;
import org.opendaylight.netvirt.bgpmanager.FibDSWriter;
+import org.opendaylight.netvirt.bgpmanager.api.IBgpManager;
import org.opendaylight.netvirt.bgpmanager.thrift.gen.BgpUpdater;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.fibentries.VrfTables;
import org.slf4j.Logger;
public class BgpThriftService {
int ourPort;
- BgpManager bgpManager;
+ IBgpManager bgpManager;
FibDSWriter fibDSWriter;
TServer server;
private static final Logger LOGGER = LoggerFactory.getLogger(BgpThriftService.class);
- public BgpThriftService(int ourPort, BgpManager bm) {
+ public BgpThriftService(int ourPort, IBgpManager bm, FibDSWriter fibDSWriter) {
this.ourPort = ourPort;
bgpManager = bm;
- fibDSWriter = bm.getFibWriter();
+ this.fibDSWriter = fibDSWriter;
}
public static class ThriftClientContext implements ServerContext {
+++ /dev/null
-package org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgpmanager.impl.rev150326;
-
-import org.opendaylight.netvirt.bgpmanager.BgpManager;
-
-public class BgpManagerImplModule extends org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgpmanager.impl.rev150326.AbstractBgpManagerImplModule {
- public BgpManagerImplModule(org.opendaylight.controller.config.api.ModuleIdentifier identifier, org.opendaylight.controller.config.api.DependencyResolver dependencyResolver) {
- super(identifier, dependencyResolver);
- }
-
- public BgpManagerImplModule(org.opendaylight.controller.config.api.ModuleIdentifier identifier, org.opendaylight.controller.config.api.DependencyResolver dependencyResolver, org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgpmanager.impl.rev150326.BgpManagerImplModule oldModule, java.lang.AutoCloseable oldInstance) {
- super(identifier, dependencyResolver, oldModule, oldInstance);
- }
-
- @Override
- public void customValidation() {
- // add custom validation form module attributes here.
- }
-
- @Override
- public java.lang.AutoCloseable createInstance() {
- // TODO:implement
- //throw new java.lang.UnsupportedOperationException();
- BgpManager provider = new BgpManager();
- provider.setEntityOwnershipService(getEntityOwnershipServiceDependency());
- //provider.setITMProvider(getItmDependency());
- getBrokerDependency().registerProvider(provider);
- return provider;
- }
-
-}
+++ /dev/null
-/*
-* Generated file
-*
-* Generated from: yang module name: bgpmanager-impl yang module local name: bgpmanager-impl
-* Generated by: org.opendaylight.controller.config.yangjmxgenerator.plugin.JMXGenerator
-* Generated at: Wed Mar 25 12:33:33 IST 2015
-*
-* Do not modify this file unless it is present under src/main directory
-*/
-package org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgpmanager.impl.rev150326;
-public class BgpManagerImplModuleFactory extends org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgpmanager.impl.rev150326.AbstractBgpManagerImplModuleFactory {
-
-}
--- /dev/null
+<?xml version="1.0" encoding="UTF-8"?>
+<blueprint xmlns="http://www.osgi.org/xmlns/blueprint/v1.0.0"
+ xmlns:odl="http://opendaylight.org/xmlns/blueprint/v1.0.0"
+ odl:use-default-for-reference-types="true">
+
+ <reference id="dataBroker"
+ interface="org.opendaylight.controller.md.sal.binding.api.DataBroker"
+ odl:type="default" />
+ <reference id="entityOwnershipService"
+ interface="org.opendaylight.controller.md.sal.common.api.clustering.EntityOwnershipService" />
+
+ <bean id="bgpAlarmBroadcaster"
+ class="org.opendaylight.netvirt.bgpmanager.oam.BgpAlarmBroadcaster"
+ init-method="init" >
+ </bean>
+
+ <bean id="fibDSWriter" class="org.opendaylight.netvirt.bgpmanager.FibDSWriter">
+ <argument ref="dataBroker" />
+ </bean>
+
+ <bean id="bgpManager" class="org.opendaylight.netvirt.bgpmanager.BgpManager"
+ init-method="init" destroy-method="close">
+ <argument ref="dataBroker" />
+ <argument ref="bgpConfigurationManager" />
+ <argument ref="bgpAlarmBroadcaster" />
+ <argument ref="fibDSWriter" />
+ </bean>
+ <service ref="bgpManager" odl:type="default"
+ interface="org.opendaylight.netvirt.bgpmanager.api.IBgpManager" />
+
+ <bean id="bgpConfigurationManager"
+ class="org.opendaylight.netvirt.bgpmanager.BgpConfigurationManager"
+ destroy-method="close">
+ <argument ref="dataBroker" />
+ <argument ref="entityOwnershipService" />
+ <argument ref="fibDSWriter" />
+ <argument ref="blueprintBundleContext" />
+ </bean>
+</blueprint>
+++ /dev/null
-module bgpmanager-impl {
- yang-version 1;
- namespace "urn:opendaylight:params:xml:ns:yang:bgpmanager:impl";
- prefix "bgpmanager-impl";
-
- import config { prefix config; revision-date 2013-04-05; }
- import opendaylight-md-sal-binding { prefix md-sal-binding; revision-date 2013-10-28;}
- import opendaylight-sal-binding-broker-impl { prefix md-sal-binding-impl; revision-date 2013-10-28;}
- import opendaylight-entity-ownership-service { prefix eos; revision-date 2015-08-10;}
- import bgpmanager-api { prefix bgpmgr-api; revision-date 2015-04-20;}
-
- description
- "Service definition for bgpmanager project";
-
- revision "2015-03-26" {
- description
- "Initial revision";
- }
-
- identity bgpmanager-impl {
- base config:module-type;
- config:provided-service bgpmgr-api:bgpmanager-api;
- config:java-name-prefix BgpManagerImpl;
- }
-
- augment "/config:modules/config:module/config:configuration" {
- case bgpmanager-impl {
- when "/config:modules/config:module/config:type = 'bgpmanager-impl'";
- container broker {
- uses config:service-ref {
- refine type {
- mandatory true;
- config:required-identity md-sal-binding:binding-broker-osgi-registry;
- }
- }
- }
- container rpcregistry {
- uses config:service-ref {
- refine type {
- mandatory true;
- config:required-identity md-sal-binding:binding-rpc-registry;
- }
- }
- }
- container notification-service {
- uses config:service-ref {
- refine type {
- mandatory true;
- config:required-identity md-sal-binding-impl:binding-new-notification-service;
- }
- }
- }
- container entity-ownership-service {
- uses config:service-ref {
- refine type {
- mandatory true;
- config:required-identity eos:entity-ownership-service;
- }
- }
- }
- container binding-normalized-node-serializer {
- uses config:service-ref {
- refine type {
- mandatory true;
- config:required-identity md-sal-binding:binding-normalized-node-serializer;
- }
- }
- }
- }
- }
-}
interfaceManager.createVLANInterface(interfaceName, parentRef, null, null, null,
IfL2vlan.L2vlanMode.Transparent, true);
} else if (ElanUtils.isVlan(elanInstance)) {
- String trunkName = parentRef + IfmConstants.OF_URI_SEPARATOR + "trunk";
- interfaceManager.createVLANInterface(interfaceName, parentRef, null, null, null,
- IfL2vlan.L2vlanMode.Trunk, true);
Long segmentationId = elanInstance.getSegmentationId();
interfaceName = parentRef + IfmConstants.OF_URI_SEPARATOR + segmentationId;
+ String trunkName = parentRef + IfmConstants.OF_URI_SEPARATOR + "trunk";
+ interfaceManager.createVLANInterface(trunkName, parentRef, null, null, null,
+ IfL2vlan.L2vlanMode.Trunk, true);
+
interfaceManager.createVLANInterface(interfaceName, trunkName, null, segmentationId.intValue(), null,
IfL2vlan.L2vlanMode.TrunkMember, true);
}
<artifactId>vpnmanager-impl</artifactId>
<version>${vpnmanager.version}</version>
</dependency>
- <dependency>
- <groupId>${project.groupId}</groupId>
- <artifactId>vpnmanager-impl</artifactId>
- <version>${vpnmanager.version}</version>
- <classifier>config</classifier>
- <type>xml</type>
- </dependency>
<dependency>
<groupId>${project.groupId}</groupId>
<artifactId>elanmanager-impl</artifactId>
<artifactId>bgpmanager-impl</artifactId>
<version>${vpnservices.version}</version>
</dependency>
- <dependency>
- <groupId>${project.groupId}</groupId>
- <artifactId>bgpmanager-impl</artifactId>
- <version>${vpnservices.version}</version>
- <classifier>config</classifier>
- <type>xml</type>
- </dependency>
<dependency>
<groupId>${project.groupId}</groupId>
<artifactId>bgpmanager-api</artifactId>
<bundle>mvn:org.opendaylight.ovsdb/utils.southbound-utils/{{VERSION}}</bundle>
<bundle>mvn:org.opendaylight.ovsdb/utils.mdsal-utils/{{VERSION}}</bundle>
<bundle>mvn:org.opendaylight.ovsdb/utils.southbound-utils/{{VERSION}}</bundle>
- <!--<bundle>mvn:org.opendaylight.vpnservice.third-party/org.apache.thriftlib/1.1.0-SNAPSHOT</bundle>-->
<bundle>wrap:mvn:org.apache.thrift/libthrift/0.9.1$overwrite=merge&Bundle-Version=0.9.1&Export-Package=*;-noimport:=true;version="0.9.1"</bundle>
- <!--<bundle>wrap:mvn:javax.servlet/servlet-api/2.5</bundle>-->
- <configfile finalname="${configfile.directory}/bgpmanager-impl-default-config.xml">mvn:org.opendaylight.netvirt/bgpmanager-impl/{{VERSION}}/xml/config</configfile>
- <configfile finalname="${configfile.directory}/vpnmanager-impl-default-config.xml">mvn:org.opendaylight.netvirt/vpnmanager-impl/{{VERSION}}/xml/config</configfile>
<configfile finalname="${configfile.directory}/elanmanager-impl-default-config.xml">mvn:org.opendaylight.netvirt/elanmanager-impl/{{VERSION}}/xml/config</configfile>
<configfile finalname="${configfile.directory}/natservice-impl-default-config.xml">mvn:org.opendaylight.netvirt/natservice-impl/{{VERSION}}/xml/config</configfile>
<!--<configfile finalname="${configfile.directory}/cloud-servicechain-impl-default-config.xml">mvn:org.opendaylight.netvirt/cloud-servicechain-impl/{{VERSION}}/xml/config</configfile>-->
import java.util.Properties;
import java.util.concurrent.atomic.AtomicBoolean;
+import javax.inject.Inject;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.opendaylight.netvirt.it.NetvirtITConstants.DefaultFlow;
import org.opendaylight.netvirt.utils.netvirt.it.utils.FlowITUtil;
import org.opendaylight.netvirt.utils.netvirt.it.utils.NetITUtil;
-import org.opendaylight.netvirt.vpnmanager.VpnserviceProvider;
import org.opendaylight.ovsdb.utils.mdsal.utils.MdsalUtils;
import org.opendaylight.ovsdb.utils.ovsdb.it.utils.DockerOvs;
import org.opendaylight.ovsdb.utils.ovsdb.it.utils.NodeInfo;
import org.ops4j.pax.exam.options.MavenUrlReference;
import org.ops4j.pax.exam.spi.reactors.ExamReactorStrategy;
import org.ops4j.pax.exam.spi.reactors.PerClass;
+import org.ops4j.pax.exam.util.Filter;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
private static String connectionType;
private static String controllerStr;
private static AtomicBoolean setup = new AtomicBoolean(false);
- private static DataBroker dataBroker = null;
private static final String NETVIRT_TOPOLOGY_ID = "netvirt:1";
+ @Inject @Filter(timeout=60000)
+ private static DataBroker dataBroker = null;
@Override
public String getModuleName() {
Thread.sleep(10*1000);
getProperties();
- // get the dataBroker
- dataBroker = VpnserviceProvider.getDataBroker();
assertNotNull("dataBroker should not be null", dataBroker);
itUtils = new OvsdbItUtils(dataBroker);
mdsalUtils = new MdsalUtils(dataBroker);
<capability>urn:opendaylight:genius:mdsalutil?module=odl-mdsalutil&revision=2016-04-06</capability>
<capability>urn:opendaylight:params:xml:ns:yang:controller:md:sal:binding?module=opendaylight-md-sal-binding&revision=2013-10-28</capability>
<capability>urn:opendaylight:params:xml:ns:yang:controller:md:sal:binding:impl?module=opendaylight-sal-binding-broker-impl&revision=2013-10-28</capability>
- <capability>urn:opendaylight:params:xml:ns:yang:bgpmanager:api?module=bgpmanager-api&revision=2015-04-20</capability>
<capability>urn:opendaylight:genius:interfacemanager?module=odl-interface&revision=2016-04-06</capability>
</required-capabilities>
<configuration>
<type xmlns:binding="urn:opendaylight:params:xml:ns:yang:controller:md:sal:binding">binding:binding-rpc-registry</type>
<name>binding-rpc-broker</name>
</rpc-registry>
- <bgpmanager>
- <type xmlns:bgpmanager="urn:opendaylight:params:xml:ns:yang:bgpmanager:api">bgpmanager:bgpmanager-api</type>
- <name>bgpmanager</name>
- </bgpmanager>
<notification-service>
<type xmlns:bindingimpl="urn:opendaylight:params:xml:ns:yang:controller:md:sal:binding:impl">bindingimpl:binding-new-notification-service</type>
<name>binding-notification-adapter</name>
private IInterfaceManager interfaceManager;
private IFibManager fibManager;
private VpnFloatingIpHandler handler;
+ private NaptSwitchHA naptSwitchHA;
public NatServiceProvider(RpcProviderRegistry rpcProviderRegistry) {
this.rpcProviderRegistry = rpcProviderRegistry;
this.mdsalManager = mdsalManager;
}
- public void setBgpManager(IBgpManager bgpManager) {
- LOG.debug("BGP Manager reference initialized");
- this.bgpManager = bgpManager;
- }
-
public void setInterfaceManager(IInterfaceManager interfaceManager) {
this.interfaceManager = interfaceManager;
}
externalRouterListener.setInterfaceManager(interfaceService);
externalRouterListener.setIdManager(idManager);
externalRouterListener.setNaptManager(naptManager);
- externalRouterListener.setBgpManager(bgpManager);
externalRouterListener.setFibService(fibService);
externalRouterListener.setVpnService(vpnService);
externalRouterListener.setNaptSwitchSelector(naptSwitchSelector);
externalRouterListener.setDefaultProgrammer(defaultRouteProgrammer);
- NaptSwitchHA naptSwitchHA = new NaptSwitchHA(dataBroker,naptSwitchSelector);
+ naptSwitchHA = new NaptSwitchHA(dataBroker,naptSwitchSelector);
naptSwitchHA.setIdManager(idManager);
naptSwitchHA.setInterfaceManager(interfaceService);
naptSwitchHA.setMdsalManager(mdsalManager);
naptSwitchHA.setItmManager(itmManager);
- naptSwitchHA.setBgpManager(bgpManager);
naptSwitchHA.setFibService(fibService);
naptSwitchHA.setVpnService(vpnService);
naptSwitchHA.setExternalRoutersListener(externalRouterListener);
externalRouterListener.setFibManager(fibManager);
}
});
+
+ // TODO: Remove as part of blueprint fix.
+ // This is simply here to get the IBgpmanager service which is already
+ // moved to blueprint.
+ GlobalEventExecutor.INSTANCE.execute(new Runnable() {
+ @Override
+ public void run() {
+ Bundle b = FrameworkUtil.getBundle(this.getClass());
+ if (b == null) {
+ return;
+ }
+ BundleContext bundleContext = b.getBundleContext();
+ if (bundleContext == null) {
+ return;
+ }
+ final WaitingServiceTracker<IBgpManager> tracker = WaitingServiceTracker.create(
+ IBgpManager.class, bundleContext);
+ IBgpManager bgpManager = tracker.waitForService(WaitingServiceTracker.FIVE_MINUTES);
+ LOG.info("NatServiceProvider initialized. IBgpManager={}", bgpManager);
+ handler.setBgpManager(bgpManager);
+ externalRouterListener.setBgpManager(bgpManager);
+ naptSwitchHA.setBgpManager(bgpManager);
+ }
+ });
}
}
this.fibManager = fibManager;
}
+ void setBgpManager(IBgpManager bgpManager) {
+ this.bgpManager = bgpManager;
+ }
+
@Override
public void onAddFloatingIp(final BigInteger dpnId, final String routerId,
Uuid networkId, final String interfaceName, final String externalIp, final String internalIp) {
provider.setNotificationService(getNotificationServiceDependency());
provider.setMdsalManager(getMdsalutilDependency());
provider.setInterfaceManager(getOdlinterfaceDependency());
- provider.setBgpManager(getBgpmanagerDependency());
getBrokerDependency().registerProvider(provider);
return provider;
}
import opendaylight-md-sal-binding { prefix md-sal-binding; revision-date 2013-10-28;}
import opendaylight-sal-binding-broker-impl { prefix md-sal-binding-impl; revision-date 2013-10-28; }
import odl-mdsalutil { prefix odl-mdsal; revision-date 2016-04-06;}
- import bgpmanager-api { prefix bgpmgr-api; revision-date 2015-04-20;}
import odl-interface {prefix odlif; revision-date 2016-04-06;}
description
}
}
}
- container bgpmanager {
- uses config:service-ref {
- refine type {
- mandatory true;
- config:required-identity bgpmgr-api:bgpmanager-api;
- }
- }
- }
container notification-service {
uses config:service-ref {
refine type {
}
private void initReady() {
- readyMap.put("bgpmanager-impl", Pair.of("bgpmanager-default", false));
readyMap.put("dhcpservice-impl", Pair.of("dhcpservice-default", false)); // no service
readyMap.put("elanservice-impl", Pair.of("elanservice-default", false));
readyMap.put("natservice-impl", Pair.of("natservice-default", false)); // no service
- readyMap.put("vpnservice-impl", Pair.of("vpnservice-default", false));
}
private void getServices() {
+++ /dev/null
-module vpnmanager-api {
- yang-version 1;
- namespace "urn:opendaylight:params:xml:ns:yang:vpnmanager:api";
- prefix "vpnmanager-api";
-
- import config { prefix config; revision-date 2013-04-05; }
-
- description
- "Service definition for vpnmanager project";
-
- revision "2015-05-08" {
- description
- "Initial revision";
- }
-
- identity vpnmanager-api {
- base "config:service-type";
- config:java-class "org.opendaylight.netvirt.vpnmanager.api.IVpnManager";
- }
-}
\ No newline at end of file
+++ /dev/null
-<?xml version="1.0" encoding="UTF-8"?>
-<!-- vi: set et smarttab sw=4 tabstop=4: -->
-<!--
-Copyright (c) 2015 - 2016 Ericsson India Global Services Pvt Ltd. and others. All rights reserved.
-
-This program and the accompanying materials are made available under the
-terms of the Eclipse Public License v1.0 which accompanies this distribution,
-and is available at http://www.eclipse.org/legal/epl-v10.html
--->
-<snapshot>
- <required-capabilities>
- <capability>urn:opendaylight:params:xml:ns:yang:vpnservice:impl?module=vpnservice-impl&revision=2015-02-16</capability>
- <capability>urn:opendaylight:params:xml:ns:yang:controller:md:sal:binding?module=opendaylight-md-sal-binding&revision=2013-10-28</capability>
- <capability>urn:opendaylight:params:xml:ns:yang:bgpmanager:api?module=bgpmanager-api&revision=2015-04-20</capability>
- <capability>urn:opendaylight:genius:mdsalutil?module=odl-mdsalutil&revision=2016-04-06</capability>
- </required-capabilities>
- <configuration>
-
- <data xmlns="urn:ietf:params:xml:ns:netconf:base:1.0">
- <modules xmlns="urn:opendaylight:params:xml:ns:yang:controller:config">
- <module>
- <type xmlns:prefix="urn:opendaylight:params:xml:ns:yang:vpnservice:impl">prefix:vpnservice-impl</type>
- <name>vpnservice-default</name>
- <broker>
- <type xmlns:binding="urn:opendaylight:params:xml:ns:yang:controller:md:sal:binding">binding:binding-broker-osgi-registry</type>
- <name>binding-osgi-broker</name>
- </broker>
- <rpcregistry>
- <type xmlns:binding="urn:opendaylight:params:xml:ns:yang:controller:md:sal:binding">binding:binding-rpc-registry</type>
- <name>binding-rpc-broker</name>
- </rpcregistry>
- <bgpmanager>
- <type xmlns:bgpmanager="urn:opendaylight:params:xml:ns:yang:bgpmanager:api">bgpmanager:bgpmanager-api</type>
- <name>bgpmanager</name>
- </bgpmanager>
- <mdsalutil>
- <type xmlns:mdsalutil="urn:opendaylight:genius:mdsalutil">mdsalutil:odl-mdsalutil</type>
- <name>mdsalutil-service</name>
- </mdsalutil>
- <notification-service>
- <type xmlns:bindingimpl="urn:opendaylight:params:xml:ns:yang:controller:md:sal:binding:impl">bindingimpl:binding-new-notification-service</type>
- <name>binding-notification-adapter</name>
- </notification-service>
- <notification-publish-service>
- <type xmlns:bindingimpl="urn:opendaylight:params:xml:ns:yang:controller:md:sal:binding:impl">bindingimpl:binding-new-notification-publish-service</type>
- <name>binding-notification-publish-adapter</name>
- </notification-publish-service>
- </module>
- </modules>
- <services xmlns="urn:opendaylight:params:xml:ns:yang:controller:config">
- <service>
- <type xmlns:prefix="urn:opendaylight:params:xml:ns:yang:vpnmanager:api">prefix:vpnmanager-api</type>
- <instance>
- <name>vpnmanager</name>
- <provider>/modules/module[type='vpnservice-impl'][name='vpnservice-default']</provider>
- </instance>
- </service>
- </services>
- </data>
- </configuration>
-</snapshot>
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.genius.mdsalutil.MetaDataUtil;
+import org.opendaylight.netvirt.elanmanager.api.IElanService;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.MacAddress;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.PhysAddress;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
import java.math.BigInteger;
public class ArpNotificationHandler implements OdlArputilListener {
-
- VpnInterfaceManager vpnIfManager;
- DataBroker broker;
-
private static final Logger LOG = LoggerFactory.getLogger(ArpNotificationHandler.class);
+ DataBroker dataBroker;
+ VpnInterfaceManager vpnIfManager;
+ final IElanService elanService;
- public ArpNotificationHandler(VpnInterfaceManager vpnIfMgr, DataBroker dataBroker) {
+ public ArpNotificationHandler(DataBroker dataBroker, VpnInterfaceManager vpnIfMgr,
+ final IElanService elanService) {
+ this.dataBroker = dataBroker;
vpnIfManager = vpnIfMgr;
- broker = dataBroker;
+ this.elanService = elanService;
}
@Override
if (metadata != null && metadata != BigInteger.ZERO) {
long vpnId = MetaDataUtil.getVpnIdFromMetadata(metadata);
// Respond to ARP request only if vpnservice is configured on the interface
- if (VpnUtil.isVpnInterfaceConfigured(broker, srcInterface)) {
+ if (VpnUtil.isVpnInterfaceConfigured(dataBroker, srcInterface)) {
LOG.info("Received ARP Request for interface {} ", srcInterface);
InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.id.to.vpn.instance.VpnIds>
vpnIdsInstanceIdentifier = VpnUtil.getVpnIdToVpnInstanceIdentifier(vpnId);
Optional<VpnIds> vpnIdsOptional
- = VpnUtil.read(broker, LogicalDatastoreType.CONFIGURATION, vpnIdsInstanceIdentifier);
+ = VpnUtil.read(dataBroker, LogicalDatastoreType.CONFIGURATION, vpnIdsInstanceIdentifier);
if (!vpnIdsOptional.isPresent()) {
// Donot respond to ARP requests on unknown VPNs
LOG.trace("ARP NO_RESOLVE: VPN {} not configured. Ignoring responding to ARP requests on this VPN", vpnId);
String ipToQuery = notification.getSrcIpaddress().getIpv4Address().getValue();
LOG.trace("ArpRequest being processed for Source IP {}", ipToQuery);
VpnIds vpnIds = vpnIdsOptional.get();
- VpnPortipToPort vpnPortipToPort = VpnUtil.getNeutronPortFromVpnPortFixedIp(broker, vpnIds.getVpnInstanceName(), ipToQuery);
+ VpnPortipToPort vpnPortipToPort = VpnUtil.getNeutronPortFromVpnPortFixedIp(dataBroker, vpnIds.getVpnInstanceName(), ipToQuery);
if (vpnPortipToPort != null) {
String oldPortName = vpnPortipToPort.getPortName();
String oldMac = vpnPortipToPort.getMacAddress();
if (!vpnPortipToPort.isConfig()) {
synchronized ((vpnName + ipToQuery).intern()) {
vpnIfManager.removeMIPAdjacency(vpnName, oldPortName, srcIP);
- VpnUtil.removeVpnPortFixedIpToPort(broker, vpnName, ipToQuery);
+ VpnUtil.removeVpnPortFixedIpToPort(dataBroker, vpnName, ipToQuery);
}
try {
Thread.sleep(2000);
}
} else {
synchronized ((vpnName + ipToQuery).intern()) {
- VpnUtil.createVpnPortFixedIpToPort(broker, vpnName, ipToQuery, srcInterface, srcMac.getValue(), false, false, true);
+ VpnUtil.createVpnPortFixedIpToPort(dataBroker, vpnName, ipToQuery, srcInterface, srcMac.getValue(), false, false, true);
vpnIfManager.addMIPAdjacency(vpnName, srcInterface, srcIP);
}
}
String targetIpToQuery = notification.getDstIpaddress().getIpv4Address().getValue();
- VpnPortipToPort vpnTargetIpToPort = VpnUtil.getNeutronPortFromVpnPortFixedIp(broker,
+ VpnPortipToPort vpnTargetIpToPort = VpnUtil.getNeutronPortFromVpnPortFixedIp(dataBroker,
vpnIds.getVpnInstanceName(), targetIpToQuery);
//Process and respond from Controller only for GatewayIp ARP request
if (vpnTargetIpToPort != null) {
InstanceIdentifier<Port> inst = InstanceIdentifier.create(Neutron.class)
.child(Ports.class)
.child(Port.class, new PortKey(portUuid));
- Optional<Port> port = VpnUtil.read(broker, LogicalDatastoreType.CONFIGURATION, inst);
+ Optional<Port> port = VpnUtil.read(dataBroker, LogicalDatastoreType.CONFIGURATION, inst);
if (port.isPresent()) {
prt = port.get();
Uuid subnetUUID = prt.getFixedIps().get(0).getSubnetId();
InstanceIdentifier<Subnet> subnetidentifier = InstanceIdentifier.create(Neutron.class)
.child(Subnets.class)
.child(Subnet.class, subnetkey);
- Optional<Subnet> subnet = VpnUtil.read(broker, LogicalDatastoreType.CONFIGURATION, subnetidentifier);
+ Optional<Subnet> subnet = VpnUtil.read(dataBroker, LogicalDatastoreType.CONFIGURATION, subnetidentifier);
if (subnet.isPresent()) {
gw = subnet.get().getGatewayIp().getIpv4Address().getValue();
if (targetIpToQuery.equalsIgnoreCase(gw)) {
}
}
}
- } else if (VpnmanagerServiceAccessor.getElanProvider().isExternalInterface(srcInterface)) {
+ } else if (elanService.isExternalInterface(srcInterface)) {
handleArpRequestFromExternalInterface(srcInterface, srcIP, srcMac, targetIP);
} else {
LOG.trace("ARP request is not on an External VPN/Interface, so ignoring the request.");
InstanceIdentifier<VpnIds>
vpnIdsInstanceIdentifier = VpnUtil.getVpnIdToVpnInstanceIdentifier(vpnId);
Optional<VpnIds> vpnIdsOptional
- = VpnUtil.read(broker, LogicalDatastoreType.CONFIGURATION, vpnIdsInstanceIdentifier);
+ = VpnUtil.read(dataBroker, LogicalDatastoreType.CONFIGURATION, vpnIdsInstanceIdentifier);
if (!vpnIdsOptional.isPresent()) {
// Donot respond to ARP requests on unknown VPNs
LOG.trace("ARP NO_RESOLVE: VPN {} not configured. Ignoring responding to ARP requests on this VPN", vpnId);
return;
}
- if (VpnUtil.isVpnInterfaceConfigured(broker, srcInterface)) {
+ if (VpnUtil.isVpnInterfaceConfigured(dataBroker, srcInterface)) {
String vpnName = vpnIdsOptional.get().getVpnInstanceName();
String ipToQuery = notification.getIpaddress().getIpv4Address().getValue();
VpnIds vpnIds = vpnIdsOptional.get();
- VpnPortipToPort vpnPortipToPort = VpnUtil.getNeutronPortFromVpnPortFixedIp(broker, vpnIds.getVpnInstanceName(), ipToQuery);
+ VpnPortipToPort vpnPortipToPort = VpnUtil.getNeutronPortFromVpnPortFixedIp(dataBroker, vpnIds.getVpnInstanceName(), ipToQuery);
if (vpnPortipToPort != null) {
String oldMac = vpnPortipToPort.getMacAddress();
String oldPortName = vpnPortipToPort.getPortName();
if (!vpnPortipToPort.isConfig()) {
synchronized ((vpnName + ipToQuery).intern()) {
vpnIfManager.removeMIPAdjacency(vpnName, oldPortName, srcIP);
- VpnUtil.removeVpnPortFixedIpToPort(broker, vpnName, ipToQuery);
+ VpnUtil.removeVpnPortFixedIpToPort(dataBroker, vpnName, ipToQuery);
}
try {
Thread.sleep(2000);
}
} else {
synchronized ((vpnName + ipToQuery).intern()) {
- VpnUtil.createVpnPortFixedIpToPort(broker, vpnName, ipToQuery, srcInterface, srcMac.getValue(), false, false, true);
+ VpnUtil.createVpnPortFixedIpToPort(dataBroker, vpnName, ipToQuery, srcInterface, srcMac.getValue(), false, false, true);
vpnIfManager.addMIPAdjacency(vpnName, srcInterface, srcIP);
}
}
private void handleArpRequestFromExternalInterface(String srcInterface, IpAddress srcIP, PhysAddress srcMac,
IpAddress targetIP) {
- Port port = VpnUtil.getNeutronPortForFloatingIp(broker, targetIP);
+ Port port = VpnUtil.getNeutronPortForFloatingIp(dataBroker, targetIP);
String targetIpValue = targetIP.getIpv4Address().getValue();
if (port == null) {
LOG.trace("No neutron port found for with floating ip {}", targetIpValue);
import java.util.concurrent.*;
public class ArpScheduler extends AsyncDataTreeChangeListenerBase<VpnPortipToPort,ArpScheduler> {
-
+ private static final Logger LOG = LoggerFactory.getLogger(ArpScheduler.class);
+ private final DataBroker dataBroker;
+ private final OdlInterfaceRpcService intfRpc;
private ScheduledExecutorService executorService;
- private OdlInterfaceRpcService interfaceRpc;
- private DataBroker dataBroker;
private ScheduledFuture<?> scheduledResult;
- private static final Logger LOG = LoggerFactory.getLogger(ArpScheduler.class);
private DelayQueue<MacEntry> macEntryQueue = new DelayQueue<MacEntry>();
- private ListenerRegistration<ArpScheduler> listenerRegistration;
- public ArpScheduler(OdlInterfaceRpcService interfaceRpc, DataBroker dataBroker) {
+ public ArpScheduler(final DataBroker dataBroker, final OdlInterfaceRpcService interfaceRpc) {
super(VpnPortipToPort.class, ArpScheduler.class);
this.dataBroker = dataBroker;
- this.interfaceRpc = interfaceRpc;
+ this.intfRpc = interfaceRpc;
+ }
+
+ public void start() {
+ LOG.info("{} start", getClass().getSimpleName());
+ registerListener(LogicalDatastoreType.CONFIGURATION, dataBroker);
Long timeout = Long.getLong("arp.cache.timeout");
if (timeout == null) {
timeout = ArpConstants.DEFAULT_ARP_LEARNED_CACHE_TIMEOUT;
}
ArpConstants.arpCacheTimeout = timeout;
- registerListener();
executorService = Executors.newScheduledThreadPool(ArpConstants.THREAD_POOL_SIZE, getThreadFactory("Arp Cache Timer Tasks"));
scheduleExpiredEntryDrainerTask();
}
+ @Override
+ protected InstanceIdentifier<VpnPortipToPort> getWildCardPath() {
+ return InstanceIdentifier.create(NeutronVpnPortipPortData.class).child(VpnPortipToPort.class);
+ }
private void scheduleExpiredEntryDrainerTask() {
LOG.info("Scheduling expired entry drainer task");
.child(VpnPortipToPort.class, new VpnPortipToPortKey(ip,vpnName)).build();
}
- private void registerListener() {
- try {
- final DataTreeIdentifier<VpnPortipToPort> treeId = new DataTreeIdentifier<>(LogicalDatastoreType.CONFIGURATION, getWildCardPath());
- listenerRegistration = dataBroker.registerDataTreeChangeListener(treeId, this);
- } catch (final Exception e) {
- LOG.error("VPN Service DataChange listener registration fail !", e);
- throw new IllegalStateException("VPN Service registration Listener failed.", e);
- }
- }
-
@Override
protected ArpScheduler getDataTreeChangeListener() {
return this;
}
}
- @Override
- protected InstanceIdentifier<VpnPortipToPort> getWildCardPath() {
- return InstanceIdentifier.create(NeutronVpnPortipPortData.class).child(VpnPortipToPort.class);
- }
-
@Override
protected void remove(InstanceIdentifier<VpnPortipToPort> key, VpnPortipToPort dataObjectModification) {
}
import com.google.common.base.Optional;
import com.google.common.util.concurrent.CheckedFuture;
-import com.google.common.util.concurrent.ListenableFuture;
+import java.math.BigInteger;
+import java.util.Collection;
+import java.util.List;
+import java.util.concurrent.ExecutionException;
import 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;
import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
-import org.opendaylight.genius.datastoreutils.DataStoreJobCoordinator;
-import org.opendaylight.genius.mdsalutil.*;
-import org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.AddDpnEvent;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.OdlL3vpnListener;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.RemoveDpnEvent;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.remove.dpn.event.RemoveEventData;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data.VpnInstanceOpDataEntry;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data.vpn.instance.op.data.entry
- .VpnToDpnList;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.IdManagerService;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data.vpn.instance.op.data.entry.VpnToDpnList;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import java.math.BigInteger;
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.List;
-import java.util.concurrent.Callable;
-import java.util.concurrent.ExecutionException;
-
public class DpnInVpnChangeListener implements OdlL3vpnListener {
private static final Logger LOG = LoggerFactory.getLogger(DpnInVpnChangeListener.class);
- private DataBroker dataBroker;
- private IMdsalApiManager mdsalManager;
- private IdManagerService idManager;
+ private final DataBroker dataBroker;
public DpnInVpnChangeListener(DataBroker dataBroker) {
this.dataBroker = dataBroker;
} catch (InterruptedException | ExecutionException e) {
LOG.error("Error removing dpnToVpnList for vpn {} ", vpnName);
throw new RuntimeException(e.getMessage());
- }
+ }
}
}
}
--- /dev/null
+/*
+ * Copyright (c) 2015 - 2016 Ericsson India Global Services Pvt Ltd. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.netvirt.vpnmanager;
+
+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.DataChangeListener;
+import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker;
+import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.FibEntries;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.fibentries.VrfTables;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.fibentries.VrfTablesKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.vrfentries.VrfEntry;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data.VpnInstanceOpDataEntry;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data.VpnInstanceOpDataEntryBuilder;
+import org.opendaylight.yangtools.concepts.ListenerRegistration;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class FibEntriesListener extends AbstractDataChangeListener<VrfEntry> implements AutoCloseable {
+ private static final Logger LOG = LoggerFactory.getLogger(FibEntriesListener.class);
+ private ListenerRegistration<DataChangeListener> listenerRegistration;
+ private final DataBroker dataBroker;
+ private final VpnInstanceListener vpnInstanceListener;
+
+ public FibEntriesListener(final DataBroker dataBroker, final VpnInstanceListener vpnInstanceListener) {
+ super(VrfEntry.class);
+ this.dataBroker = dataBroker;
+ this.vpnInstanceListener = vpnInstanceListener;
+ }
+
+ public void start() {
+ LOG.info("{} start", getClass().getSimpleName());
+ listenerRegistration = dataBroker.registerDataChangeListener(LogicalDatastoreType.OPERATIONAL,
+ getWildCardPath(), this, AsyncDataBroker.DataChangeScope.BASE);
+ }
+
+ private InstanceIdentifier<VrfEntry> getWildCardPath() {
+ return InstanceIdentifier.create(FibEntries.class).child(VrfTables.class).child(VrfEntry.class);
+ }
+
+ @Override
+ public void close() throws Exception {
+ if (listenerRegistration != null) {
+ listenerRegistration.close();
+ listenerRegistration = null;
+ }
+ LOG.info("{} close", getClass().getSimpleName());
+ }
+
+ @Override
+ protected void remove(InstanceIdentifier<VrfEntry> identifier,
+ VrfEntry del) {
+ LOG.trace("Remove Fib event - Key : {}, value : {} ", identifier, del);
+ final VrfTablesKey key = identifier.firstKeyOf(VrfTables.class, VrfTablesKey.class);
+ String rd = key.getRouteDistinguisher();
+ Long label = del.getLabel();
+ VpnInstanceOpDataEntry vpnInstanceOpData = vpnInstanceListener.getVpnInstanceOpData(rd);
+ if(vpnInstanceOpData != null) {
+ List<Long> routeIds = vpnInstanceOpData.getRouteEntryId();
+ if(routeIds == null) {
+ LOG.debug("Fib Route entry is empty.");
+ return;
+ }
+ LOG.debug("Removing label from vpn info - {}", label);
+ routeIds.remove(label);
+ TransactionUtil.asyncWrite(dataBroker, LogicalDatastoreType.OPERATIONAL,
+ VpnUtil.getVpnInstanceOpDataIdentifier(rd),
+ new VpnInstanceOpDataEntryBuilder(vpnInstanceOpData).setRouteEntryId(routeIds).build(),
+ TransactionUtil.DEFAULT_CALLBACK);
+ } else {
+ LOG.warn("No VPN Instance found for RD: {}", rd);
+ }
+ }
+
+ @Override
+ protected void update(InstanceIdentifier<VrfEntry> identifier,
+ VrfEntry original, VrfEntry update) {
+ // TODO Auto-generated method stub
+
+ }
+
+ @Override
+ protected void add(InstanceIdentifier<VrfEntry> identifier,
+ VrfEntry add) {
+ LOG.trace("Add Vrf Entry event - Key : {}, value : {}", identifier, add);
+ final VrfTablesKey key = identifier.firstKeyOf(VrfTables.class, VrfTablesKey.class);
+ String rd = key.getRouteDistinguisher();
+ Long label = add.getLabel();
+ VpnInstanceOpDataEntry vpn = vpnInstanceListener.getVpnInstanceOpData(rd);
+ if(vpn != null) {
+ List<Long> routeIds = vpn.getRouteEntryId();
+ if(routeIds == null) {
+ routeIds = new ArrayList<>();
+ }
+ LOG.debug("Adding label to vpn info - {}", label);
+ routeIds.add(label);
+ TransactionUtil.asyncWrite(dataBroker, LogicalDatastoreType.OPERATIONAL,
+ VpnUtil.getVpnInstanceOpDataIdentifier(rd),
+ new VpnInstanceOpDataEntryBuilder(vpn).setRouteEntryId(routeIds).build(),
+ TransactionUtil.DEFAULT_CALLBACK);
+ } else {
+ LOG.warn("No VPN Instance found for RD: {}", rd);
+ }
+ }
+}
*/
package org.opendaylight.netvirt.vpnmanager;
+import com.google.common.net.InetAddresses;
import java.math.BigInteger;
import java.util.Collection;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
-
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.mdsalutil.MDSALUtil;
+import org.opendaylight.netvirt.elanmanager.api.IElanService;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddressBuilder;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.MacAddress;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import com.google.common.net.InetAddresses;
-
public class FloatingIpGarpHandler extends AsyncDataTreeChangeListenerBase<RouterPorts, FloatingIpGarpHandler>
implements AutoCloseable {
-
- private DataBroker broker;
- private PacketProcessingService packetService;
- OdlInterfaceRpcService intfRpc;
- private static final Logger s_logger = LoggerFactory.getLogger(FloatingIpGarpHandler.class);
-
- public FloatingIpGarpHandler(DataBroker broker) {
+ private static final Logger LOG = LoggerFactory.getLogger(FloatingIpGarpHandler.class);
+ private final DataBroker dataBroker;
+ private final PacketProcessingService packetService;
+ private final IElanService elanService;
+ private final OdlInterfaceRpcService intfRpc;
+
+ public FloatingIpGarpHandler(final DataBroker dataBroker, final PacketProcessingService packetService,
+ final IElanService elanService, final OdlInterfaceRpcService interfaceManager) {
super(RouterPorts.class, FloatingIpGarpHandler.class);
- this.broker = broker;
+ this.dataBroker = dataBroker;
+ this.packetService = packetService;
+ this.elanService = elanService;
+ this.intfRpc = interfaceManager;
}
- public void setPacketService(PacketProcessingService packetService) {
- this.packetService = packetService;
+ public void start() {
+ LOG.info("{} start", getClass().getSimpleName());
+ registerListener(LogicalDatastoreType.OPERATIONAL, dataBroker);
}
@Override
private void sendGarpForIp(RouterPorts dataObjectModificationAfter, IpAddress ip) {
if (ip.getIpv4Address() == null) {
- s_logger.warn("Faild to send GARP for IP. recieved IPv6.");
+ LOG.warn("Faild to send GARP for IP. recieved IPv6.");
return;
}
- Port floatingIpPort = VpnUtil.getNeutronPortForFloatingIp(broker, ip);
+ Port floatingIpPort = VpnUtil.getNeutronPortForFloatingIp(dataBroker, ip);
MacAddress floatingIpMac = floatingIpPort.getMacAddress();
- String extNet = VpnUtil.getAssociatedExternalNetwork(broker, dataObjectModificationAfter.getRouterId());
- Collection<String> interfaces = VpnmanagerServiceAccessor. getElanProvider().getExternalElanInterfaces(extNet);
+ String extNet = VpnUtil.getAssociatedExternalNetwork(dataBroker, dataObjectModificationAfter.getRouterId());
+ Collection<String> interfaces = elanService.getExternalElanInterfaces(extNet);
for (String externalInterface:interfaces) {
sendGarpOnInterface(ip, floatingIpMac, externalInterface);
TransmitPacketInput arpRequestInput = ArpUtils.createArpRequestInput(dpId, ArpUtils.getMacInBytes(floatingIpMac.getValue()), ipBytes, ipBytes, ingress);
packetService.transmitPacket(arpRequestInput);
} catch (InterruptedException e) {
- s_logger.warn("Faild to send GARP. rpc call getPortFromInterface did not return with a value.");
+ LOG.warn("Faild to send GARP. rpc call getPortFromInterface did not return with a value.");
} catch (ExecutionException e) {
- s_logger.warn("Faild to send GARP. rpc call getPortFromInterface did not return with a value.");
+ LOG.warn("Faild to send GARP. rpc call getPortFromInterface did not return with a value.");
}
}
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.OdlInterfaceRpcService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.router.interfaces.RouterInterface;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.ports.attributes.Ports;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.ports.attributes.ports.Port;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.rev150712.Neutron;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.math.BigInteger;
-import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
public class InterfaceStateChangeListener extends AbstractDataChangeListener<Interface> implements AutoCloseable {
private static final Logger LOG = LoggerFactory.getLogger(InterfaceStateChangeListener.class);
-
private ListenerRegistration<DataChangeListener> listenerRegistration;
- private final DataBroker broker;
- private VpnInterfaceManager vpnInterfaceManager;
- private OdlInterfaceRpcService interfaceManager;
-
+ private final DataBroker dataBroker;
+ private final VpnInterfaceManager vpnInterfaceManager;
- public InterfaceStateChangeListener(final DataBroker db, VpnInterfaceManager vpnInterfaceManager) {
+ public InterfaceStateChangeListener(final DataBroker dataBroker, VpnInterfaceManager vpnInterfaceManager) {
super(Interface.class);
- broker = db;
+ this.dataBroker = dataBroker;
this.vpnInterfaceManager = vpnInterfaceManager;
- registerListener(db);
}
- public void setIfaceMgrRpcService(OdlInterfaceRpcService interfaceManager) {
- this.interfaceManager = interfaceManager;
+ public void start() {
+ LOG.info("{} start", getClass().getSimpleName());
+ listenerRegistration = dataBroker.registerDataChangeListener(LogicalDatastoreType.OPERATIONAL,
+ getWildCardPath(), this, DataChangeScope.SUBTREE);
+ }
+
+ private InstanceIdentifier<Interface> getWildCardPath() {
+ return InstanceIdentifier.create(InterfacesState.class).child(Interface.class);
}
@Override
public void close() throws Exception {
if (listenerRegistration != null) {
- try {
- listenerRegistration.close();
- } catch (final Exception e) {
- LOG.error("Error when cleaning up DataChangeListener.", e);
- }
+ listenerRegistration.close();
listenerRegistration = null;
}
- LOG.info("Interface listener Closed");
- }
-
-
- private void registerListener(final DataBroker db) {
- try {
- listenerRegistration = db.registerDataChangeListener(LogicalDatastoreType.OPERATIONAL,
- getWildCardPath(), InterfaceStateChangeListener.this, DataChangeScope.SUBTREE);
- } catch (final Exception e) {
- LOG.error("Interface DataChange listener registration failed", e);
- throw new IllegalStateException("Nexthop Manager registration Listener failed.", e);
- }
+ LOG.info("{} close", getClass().getSimpleName());
}
@Override
final String interfaceName = intrf.getName();
LOG.info("Received interface add event for interface {} ", interfaceName);
org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface
- configInterface = InterfaceUtils.getInterface(broker, interfaceName);
+ configInterface = InterfaceUtils.getInterface(dataBroker, interfaceName);
if (configInterface != null) {
if (!configInterface.getType().equals(Tunnel.class)) {
// We service only VM interfaces and Router interfaces here.
// Tunnel events are directly serviced
// by TunnelInterfacesStateListener present as part of VpnInterfaceManager
LOG.debug("Config Interface Name {}", configInterface.getName());
- final VpnInterface vpnInterface = VpnUtil.getConfiguredVpnInterface(broker, interfaceName);
+ final VpnInterface vpnInterface = VpnUtil.getConfiguredVpnInterface(dataBroker, interfaceName);
if (vpnInterface != null) {
LOG.debug("VPN Interface Name {}", vpnInterface);
final BigInteger dpnId = InterfaceUtils.getDpIdFromInterface(intrf);
new Callable<List<ListenableFuture<Void>>>() {
@Override
public List<ListenableFuture<Void>> call() throws Exception {
- WriteTransaction writeConfigTxn = broker.newWriteOnlyTransaction();
- WriteTransaction writeOperTxn = broker.newWriteOnlyTransaction();
- WriteTransaction writeInvTxn = broker.newWriteOnlyTransaction();
+ WriteTransaction writeConfigTxn = dataBroker.newWriteOnlyTransaction();
+ WriteTransaction writeOperTxn = dataBroker.newWriteOnlyTransaction();
+ WriteTransaction writeInvTxn = dataBroker.newWriteOnlyTransaction();
vpnInterfaceManager.processVpnInterfaceUp(dpnId, vpnInterface, ifIndex, false,
writeConfigTxn, writeOperTxn, writeInvTxn);
- String routerName = VpnUtil.getNeutronRouterFromInterface(broker, interfaceName);
+ String routerName = VpnUtil.getNeutronRouterFromInterface(dataBroker, interfaceName);
if (routerName != null) {
LOG.debug("Router Name {} ", routerName);
handleRouterInterfacesUpEvent(routerName, interfaceName, writeOperTxn);
}
}
-
- private InstanceIdentifier<Interface> getWildCardPath() {
- return InstanceIdentifier.create(InterfacesState.class).child(Interface.class);
- }
-
@Override
protected void remove(InstanceIdentifier<Interface> identifier, Interface intrf) {
LOG.trace("Received interface {} down event", intrf);
} else {
BigInteger dpId = BigInteger.ZERO;
InstanceIdentifier<VpnInterface> id = VpnUtil.getVpnInterfaceIdentifier(interfaceName);
- Optional<VpnInterface> optVpnInterface = VpnUtil.read(broker, LogicalDatastoreType.OPERATIONAL, id);
+ Optional<VpnInterface> optVpnInterface = VpnUtil.read(dataBroker, LogicalDatastoreType.OPERATIONAL, id);
if (!optVpnInterface.isPresent()) {
LOG.debug("Interface {} is not a vpninterface, ignoring.", intrf.getName());
return;
new Callable<List<ListenableFuture<Void>>>() {
@Override
public List<ListenableFuture<Void>> call() throws Exception {
- WriteTransaction writeOperTxn = broker.newWriteOnlyTransaction();
- WriteTransaction writeConfigTxn = broker.newWriteOnlyTransaction();
- WriteTransaction writeInvTxn = broker.newWriteOnlyTransaction();
+ WriteTransaction writeOperTxn = dataBroker.newWriteOnlyTransaction();
+ WriteTransaction writeConfigTxn = dataBroker.newWriteOnlyTransaction();
+ WriteTransaction writeInvTxn = dataBroker.newWriteOnlyTransaction();
vpnInterfaceManager.processVpnInterfaceDown(dpnId, interfaceName, ifIndex, false, false,
writeConfigTxn, writeOperTxn, writeInvTxn);
- RouterInterface routerInterface = VpnUtil.getConfiguredRouterInterface(broker, interfaceName);
+ RouterInterface routerInterface = VpnUtil.getConfiguredRouterInterface(dataBroker, interfaceName);
if (routerInterface != null) {
handleRouterInterfacesDownEvent(routerInterface.getRouterName(), interfaceName, dpnId, writeOperTxn);
}
try {
futures.get();
} catch (InterruptedException | ExecutionException e) {
- LOG.error("Error removing Config data for interface {} from vpn {} on dpn {}", interfaceName,
+ LOG.error("Error removing Config data for interface {} from vpn {} on dpn {}", interfaceName,
vpnInterface.getVpnInstanceName(), dpnId);
throw new RuntimeException(e.getMessage());
}
LOG.error("Error removing Inventory/Flow data for interface {} from vpn {} on dpn {}", interfaceName,
vpnInterface.getVpnInstanceName(), dpnId);
throw new RuntimeException(e.getMessage());
- }
+ }
return null;
}
});
final int ifIndex = update.getIfIndex();
if (update != null) {
if (!update.getType().equals(Tunnel.class)) {
- final VpnInterface vpnInterface = VpnUtil.getConfiguredVpnInterface(broker, interfaceName);
+ final VpnInterface vpnInterface = VpnUtil.getConfiguredVpnInterface(dataBroker, interfaceName);
if (vpnInterface != null) {
if (update.getOperStatus().equals(Interface.OperStatus.Up)) {
DataStoreJobCoordinator dataStoreCoordinator = DataStoreJobCoordinator.getInstance();
new Callable<List<ListenableFuture<Void>>>() {
@Override
public List<ListenableFuture<Void>> call() throws Exception {
- WriteTransaction writeConfigTxn = broker.newWriteOnlyTransaction();
- WriteTransaction writeOperTxn = broker.newWriteOnlyTransaction();
- WriteTransaction writeInvTxn = broker.newWriteOnlyTransaction();
+ WriteTransaction writeConfigTxn = dataBroker.newWriteOnlyTransaction();
+ WriteTransaction writeOperTxn = dataBroker.newWriteOnlyTransaction();
+ WriteTransaction writeInvTxn = dataBroker.newWriteOnlyTransaction();
vpnInterfaceManager.processVpnInterfaceUp(dpnId, vpnInterface, ifIndex,
true, writeConfigTxn, writeOperTxn, writeInvTxn);
CheckedFuture<Void, TransactionCommitFailedException> futures = writeOperTxn.submit();
LOG.error("Error adding inventory/flow data for interface {} to vpn {} on dpn {}", interfaceName,
vpnInterface.getVpnInstanceName(), dpnId);
throw new RuntimeException(e.getMessage());
- }
+ }
return null;
}
});
new Callable<List<ListenableFuture<Void>>>() {
@Override
public List<ListenableFuture<Void>> call() throws Exception {
- WriteTransaction writeConfigTxn = broker.newWriteOnlyTransaction();
- WriteTransaction writeOperTxn = broker.newWriteOnlyTransaction();
- WriteTransaction writeInvTxn = broker.newWriteOnlyTransaction();
+ WriteTransaction writeConfigTxn = dataBroker.newWriteOnlyTransaction();
+ WriteTransaction writeOperTxn = dataBroker.newWriteOnlyTransaction();
+ WriteTransaction writeInvTxn = dataBroker.newWriteOnlyTransaction();
vpnInterfaceManager.processVpnInterfaceDown(dpnId, interfaceName, ifIndex, true, false,
writeConfigTxn, writeOperTxn, writeInvTxn);
CheckedFuture<Void, TransactionCommitFailedException> futures = writeOperTxn.submit();
LOG.error("Error updating inventory/flow for interface {} from vpn {} on dpn {}", interfaceName,
vpnInterface.getVpnInstanceName(), dpnId);
throw new RuntimeException(e.getMessage());
- }
+ }
return null;
}
});
-/*\r
- * Copyright (c) 2016 Ericsson India Global Services Pvt Ltd. and others. All rights reserved.\r
- *\r
- * This program and the accompanying materials are made available under the\r
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,\r
- * and is available at http://www.eclipse.org/legal/epl-v10.html\r
- */\r
-package org.opendaylight.netvirt.vpnmanager;\r
-\r
-import com.google.common.util.concurrent.ListenableFuture;\r
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;\r
-import org.opendaylight.controller.md.sal.binding.api.DataChangeListener;\r
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;\r
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;\r
-import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker.DataChangeScope;\r
-import org.opendaylight.genius.datastoreutils.DataStoreJobCoordinator;\r
-import org.opendaylight.genius.mdsalutil.MDSALUtil;\r
-import org.opendaylight.netvirt.vpnmanager.utilities.InterfaceUtils;\r
-import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.RouterInterfacesMap;\r
-import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.router.interfaces.map.RouterInterfaces;\r
-import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.router.interfaces.map.router.interfaces.Interfaces;\r
-import org.opendaylight.yangtools.concepts.ListenerRegistration;\r
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;\r
-import org.slf4j.Logger;\r
-import org.slf4j.LoggerFactory;\r
-\r
-import java.util.ArrayList;\r
-import java.util.List;\r
-import java.util.concurrent.Callable;\r
-\r
-public class RouterInterfaceListener extends AbstractDataChangeListener<Interfaces> {\r
- private static final Logger LOG = LoggerFactory.getLogger(RouterInterfaceListener.class);\r
- private ListenerRegistration<DataChangeListener> listenerRegistration;\r
- private DataBroker broker;\r
- private VpnInterfaceManager vpnInterfaceManager;\r
-\r
- public RouterInterfaceListener(final DataBroker db) {\r
- super(Interfaces.class);\r
- broker = db;\r
- registerListener(db);\r
- }\r
-\r
- void setVpnInterfaceManager(VpnInterfaceManager vpnInterfaceManager) {\r
- this.vpnInterfaceManager = vpnInterfaceManager;\r
- }\r
-\r
- private void registerListener(final DataBroker db) {\r
- try {\r
- listenerRegistration = db.registerDataChangeListener(LogicalDatastoreType.CONFIGURATION,\r
- getWildCardPath(), RouterInterfaceListener.this, DataChangeScope.SUBTREE);\r
- } catch (final Exception e) {\r
- LOG.error("Router interface DataChange listener registration fail !", e);\r
- }\r
- }\r
-\r
- private InstanceIdentifier<?> getWildCardPath() {\r
- return InstanceIdentifier.create(RouterInterfacesMap.class).child(RouterInterfaces.class).child(Interfaces.class);\r
- }\r
-\r
- @Override\r
- protected void add(InstanceIdentifier<Interfaces> identifier, Interfaces interfaceInfo) {\r
- LOG.trace("Add event - key: {}, value: {}", identifier, interfaceInfo);\r
- final String routerId = identifier.firstKeyOf(RouterInterfaces.class).getRouterId().getValue();\r
- final String interfaceName = interfaceInfo.getInterfaceId();\r
- org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface interfaceState =\r
- InterfaceUtils.getInterfaceStateFromOperDS(broker, interfaceName);\r
- DataStoreJobCoordinator dataStoreCoordinator = DataStoreJobCoordinator.getInstance();\r
- dataStoreCoordinator.enqueueJob(interfaceName,\r
- new Callable<List<ListenableFuture<Void>>>() {\r
- @Override\r
- public List<ListenableFuture<Void>> call() throws Exception {\r
- WriteTransaction writeTxn = broker.newWriteOnlyTransaction();\r
- LOG.debug("Handling interface {} in router {} add scenario", interfaceName, routerId);\r
- writeTxn.put(LogicalDatastoreType.CONFIGURATION,\r
- VpnUtil.getRouterInterfaceId(interfaceName),\r
- VpnUtil.getRouterInterface(interfaceName, routerId), true);\r
- LOG.debug("Added the Router {} and interface {} in the ODL-L3VPN RouterInterface map",\r
- routerId, interfaceName);\r
- vpnInterfaceManager.addToNeutronRouterDpnsMap(routerId, interfaceName, writeTxn);\r
- List<ListenableFuture<Void>> futures = new ArrayList<>();\r
- futures.add(writeTxn.submit());\r
- return futures;\r
- }\r
- });\r
- }\r
-\r
- @Override\r
- protected void remove(InstanceIdentifier<Interfaces> identifier, Interfaces interfaceInfo) {\r
- LOG.trace("Remove event - key: {}, value: {}", identifier, interfaceInfo);\r
- final String routerId = identifier.firstKeyOf(RouterInterfaces.class).getRouterId().getValue();\r
- final String interfaceName = interfaceInfo.getInterfaceId();\r
- DataStoreJobCoordinator dataStoreCoordinator = DataStoreJobCoordinator.getInstance();\r
- dataStoreCoordinator.enqueueJob(interfaceName,\r
- new Callable<List<ListenableFuture<Void>>>() {\r
- @Override\r
- public List<ListenableFuture<Void>> call() throws Exception {\r
- WriteTransaction writeTxn = broker.newWriteOnlyTransaction();\r
- vpnInterfaceManager.removeFromNeutronRouterDpnsMap(routerId, interfaceName, writeTxn);\r
- List<ListenableFuture<Void>> futures = new ArrayList<>();\r
- futures.add(writeTxn.submit());\r
- return futures;\r
- }\r
- });\r
- }\r
-\r
- @Override\r
- protected void update(InstanceIdentifier<Interfaces> identifier, Interfaces original, Interfaces update) {\r
- LOG.trace("Update event - key: {}, original: {}, update: {}", identifier, original, update);\r
- }\r
-\r
-}\r
+/*
+ * Copyright (c) 2016 Ericsson India Global Services Pvt Ltd. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.netvirt.vpnmanager;
+
+import com.google.common.util.concurrent.ListenableFuture;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.Callable;
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.controller.md.sal.binding.api.DataChangeListener;
+import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
+import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker.DataChangeScope;
+import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.genius.datastoreutils.DataStoreJobCoordinator;
+import org.opendaylight.netvirt.vpnmanager.utilities.InterfaceUtils;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.RouterInterfacesMap;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.router.interfaces.map.RouterInterfaces;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.router.interfaces.map.router.interfaces.Interfaces;
+import org.opendaylight.yangtools.concepts.ListenerRegistration;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class RouterInterfaceListener extends AbstractDataChangeListener<Interfaces> implements AutoCloseable {
+ private static final Logger LOG = LoggerFactory.getLogger(RouterInterfaceListener.class);
+ private ListenerRegistration<DataChangeListener> listenerRegistration;
+ private final DataBroker dataBroker;
+ private final VpnInterfaceManager vpnInterfaceManager;
+
+ public RouterInterfaceListener(final DataBroker dataBroker, final VpnInterfaceManager vpnInterfaceManager) {
+ super(Interfaces.class);
+ this.dataBroker = dataBroker;
+ this.vpnInterfaceManager = vpnInterfaceManager;
+ }
+
+ public void start() {
+ LOG.info("{} start", getClass().getSimpleName());
+ listenerRegistration = dataBroker.registerDataChangeListener(LogicalDatastoreType.CONFIGURATION,
+ getWildCardPath(), this, DataChangeScope.SUBTREE);
+ }
+
+ private InstanceIdentifier<?> getWildCardPath() {
+ return InstanceIdentifier.create(RouterInterfacesMap.class).child(RouterInterfaces.class).
+ child(Interfaces.class);
+ }
+
+ @Override
+ public void close() throws Exception {
+ if (listenerRegistration != null) {
+ listenerRegistration.close();
+ listenerRegistration = null;
+ }
+ LOG.info("{} close", getClass().getSimpleName());
+ }
+
+ @Override
+ protected void add(InstanceIdentifier<Interfaces> identifier, Interfaces interfaceInfo) {
+ LOG.trace("Add event - key: {}, value: {}", identifier, interfaceInfo);
+ final String routerId = identifier.firstKeyOf(RouterInterfaces.class).getRouterId().getValue();
+ final String interfaceName = interfaceInfo.getInterfaceId();
+ org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface interfaceState =
+ InterfaceUtils.getInterfaceStateFromOperDS(dataBroker, interfaceName);
+ DataStoreJobCoordinator dataStoreCoordinator = DataStoreJobCoordinator.getInstance();
+ dataStoreCoordinator.enqueueJob(interfaceName,
+ new Callable<List<ListenableFuture<Void>>>() {
+ @Override
+ public List<ListenableFuture<Void>> call() throws Exception {
+ WriteTransaction writeTxn = dataBroker.newWriteOnlyTransaction();
+ LOG.debug("Handling interface {} in router {} add scenario", interfaceName, routerId);
+ writeTxn.put(LogicalDatastoreType.CONFIGURATION,
+ VpnUtil.getRouterInterfaceId(interfaceName),
+ VpnUtil.getRouterInterface(interfaceName, routerId), true);
+ LOG.debug("Added the Router {} and interface {} in the ODL-L3VPN RouterInterface map",
+ routerId, interfaceName);
+ vpnInterfaceManager.addToNeutronRouterDpnsMap(routerId, interfaceName, writeTxn);
+ List<ListenableFuture<Void>> futures = new ArrayList<>();
+ futures.add(writeTxn.submit());
+ return futures;
+ }
+ });
+ }
+
+ @Override
+ protected void remove(InstanceIdentifier<Interfaces> identifier, Interfaces interfaceInfo) {
+ LOG.trace("Remove event - key: {}, value: {}", identifier, interfaceInfo);
+ final String routerId = identifier.firstKeyOf(RouterInterfaces.class).getRouterId().getValue();
+ final String interfaceName = interfaceInfo.getInterfaceId();
+ DataStoreJobCoordinator dataStoreCoordinator = DataStoreJobCoordinator.getInstance();
+ dataStoreCoordinator.enqueueJob(interfaceName,
+ new Callable<List<ListenableFuture<Void>>>() {
+ @Override
+ public List<ListenableFuture<Void>> call() throws Exception {
+ WriteTransaction writeTxn = dataBroker.newWriteOnlyTransaction();
+ vpnInterfaceManager.removeFromNeutronRouterDpnsMap(routerId, interfaceName, writeTxn);
+ List<ListenableFuture<Void>> futures = new ArrayList<>();
+ futures.add(writeTxn.submit());
+ return futures;
+ }
+ });
+ }
+
+ @Override
+ protected void update(InstanceIdentifier<Interfaces> identifier, Interfaces original, Interfaces update) {
+ LOG.trace("Update event - key: {}, original: {}, update: {}", identifier, original, update);
+ }
+}
*/
package org.opendaylight.netvirt.vpnmanager;
+import java.math.BigInteger;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.DataChangeListener;
-import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker.DataChangeScope;
+import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.netvirt.vpnmanager.utilities.InterfaceUtils;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.iana._if.type.rev140508.Tunnel;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import java.math.BigInteger;
-
-public class SubnetRouteInterfaceStateChangeListener extends AbstractDataChangeListener<Interface> implements AutoCloseable {
+public class SubnetRouteInterfaceStateChangeListener extends AbstractDataChangeListener<Interface>
+ implements AutoCloseable {
private static final Logger LOG = LoggerFactory.getLogger(InterfaceStateChangeListener.class);
-
private ListenerRegistration<DataChangeListener> listenerRegistration;
- private final DataBroker broker;
- private VpnInterfaceManager vpnInterfaceManager;
+ private final DataBroker dataBroker;
+ private final VpnInterfaceManager vpnInterfaceManager;
+ private final VpnSubnetRouteHandler vpnSubnetRouteHandler;
- public SubnetRouteInterfaceStateChangeListener(final DataBroker db, VpnInterfaceManager vpnInterfaceManager) {
+ public SubnetRouteInterfaceStateChangeListener(final DataBroker dataBroker,
+ final VpnInterfaceManager vpnInterfaceManager,
+ final VpnSubnetRouteHandler vpnSubnetRouteHandler) {
super(Interface.class);
- broker = db;
+ this.dataBroker = dataBroker;
this.vpnInterfaceManager = vpnInterfaceManager;
- registerListener(db);
+ this.vpnSubnetRouteHandler = vpnSubnetRouteHandler;
+ }
+
+ public void start() {
+ LOG.info("{} start", getClass().getSimpleName());
+ listenerRegistration = dataBroker.registerDataChangeListener(LogicalDatastoreType.OPERATIONAL,
+ getWildCardPath(), this, AsyncDataBroker.DataChangeScope.SUBTREE);
+ }
+
+ private InstanceIdentifier<Interface> getWildCardPath() {
+ return InstanceIdentifier.create(InterfacesState.class).child(Interface.class);
}
@Override
public void close() throws Exception {
if (listenerRegistration != null) {
- try {
- listenerRegistration.close();
- } catch (final Exception e) {
- LOG.error("Error when cleaning up DataChangeListener.", e);
- }
+ listenerRegistration.close();
listenerRegistration = null;
}
- LOG.info("Interface listener Closed");
- }
-
-
- private void registerListener(final DataBroker db) {
- try {
- listenerRegistration = db.registerDataChangeListener(LogicalDatastoreType.OPERATIONAL,
- getWildCardPath(), SubnetRouteInterfaceStateChangeListener.this, DataChangeScope.SUBTREE);
- } catch (final Exception e) {
- LOG.error("Interface DataChange listener registration failed", e);
- throw new IllegalStateException("Nexthop Manager registration Listener failed.", e);
- }
+ LOG.info("{} close", getClass().getSimpleName());
}
@Override
String interfaceName = intrf.getName();
LOG.info("Received port UP event for interface {} ", interfaceName);
org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface
- configInterface = InterfaceUtils.getInterface(broker, interfaceName);
+ configInterface = InterfaceUtils.getInterface(dataBroker, interfaceName);
if (configInterface != null) {
if (!configInterface.getType().equals(Tunnel.class)) {
BigInteger dpnId = InterfaceUtils.getDpIdFromInterface(intrf);
- vpnInterfaceManager.getVpnSubnetRouteHandler().onInterfaceUp(dpnId, intrf.getName());
+ vpnSubnetRouteHandler.onInterfaceUp(dpnId, intrf.getName());
}
}
} catch (Exception e) {
}
}
-
- private InstanceIdentifier<Interface> getWildCardPath() {
- return InstanceIdentifier.create(InterfacesState.class).child(Interface.class);
- }
-
@Override
protected void remove(InstanceIdentifier<Interface> identifier, Interface intrf) {
LOG.trace("Received interface {} down event", intrf);
} catch (Exception e){
LOG.error("Unable to retrieve dpnId from interface operational data store for interface {}. Fetching from vpn interface op data store. ", intrf.getName(), e);
}
- vpnInterfaceManager.getVpnSubnetRouteHandler().onInterfaceDown(dpnId, intrf.getName());
+ vpnSubnetRouteHandler.onInterfaceDown(dpnId, intrf.getName());
}
} catch (Exception e) {
LOG.error("Exception observed in handling deletion of VPN Interface {}. ", intrf.getName(), e);
if (update != null) {
if (!update.getType().equals(Tunnel.class)) {
if (update.getOperStatus().equals(Interface.OperStatus.Up)) {
- vpnInterfaceManager.getVpnSubnetRouteHandler().onInterfaceUp(dpId, update.getName());
+ vpnSubnetRouteHandler.onInterfaceUp(dpId, update.getName());
} else if (update.getOperStatus().equals(Interface.OperStatus.Down)) {
- if (VpnUtil.isVpnInterfaceConfigured(broker, interfaceName)) {
- vpnInterfaceManager.getVpnSubnetRouteHandler().onInterfaceDown(dpId, update.getName());
+ if (VpnUtil.isVpnInterfaceConfigured(dataBroker, interfaceName)) {
+ vpnSubnetRouteHandler.onInterfaceDown(dpId, update.getName());
}
}
}
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.netvirt.vpnmanager;
import com.google.common.base.Optional;
import com.google.common.primitives.Ints;
-
-import org.opendaylight.controller.liblldp.EtherTypes;
+import java.math.BigInteger;
+import java.net.InetAddress;
+import java.net.UnknownHostException;
+import java.util.ArrayList;
+import java.util.List;
import org.opendaylight.controller.liblldp.NetUtils;
+import org.opendaylight.controller.liblldp.Packet;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.genius.mdsalutil.MetaDataUtil;
+import org.opendaylight.genius.mdsalutil.NwConstants;
+import org.opendaylight.genius.mdsalutil.packet.Ethernet;
+import org.opendaylight.genius.mdsalutil.packet.IPv4;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
-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.netvirt.elan.rev150602.elan.tag.name.map.ElanTagName;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.SubnetOpData;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.VpnIdToVpnInstance;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.NetworkMaps;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.networkmaps.NetworkMap;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.networkmaps.NetworkMapKey;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service.rev130709.*;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.IdManagerService;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service.rev130709.PacketProcessingListener;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service.rev130709.PacketProcessingService;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service.rev130709.PacketReceived;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service.rev130709.TransmitPacketInput;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import org.opendaylight.genius.mdsalutil.packet.ARP;
-import org.opendaylight.genius.mdsalutil.packet.IPv4;
-import org.opendaylight.genius.mdsalutil.packet.Ethernet;
-import org.opendaylight.genius.mdsalutil.MDSALUtil;
-import org.opendaylight.controller.liblldp.Packet;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import java.math.BigInteger;
-import java.net.InetAddress;
-import java.net.UnknownHostException;
-import java.util.ArrayList;
-import java.util.List;
-
-import org.opendaylight.genius.mdsalutil.ActionInfo;
-import org.opendaylight.genius.mdsalutil.ActionType;
-import org.opendaylight.genius.mdsalutil.MetaDataUtil;
-import org.opendaylight.genius.mdsalutil.NwConstants;
-
public class SubnetRoutePacketInHandler implements PacketProcessingListener {
+ private static final Logger LOG = LoggerFactory.getLogger(SubnetRoutePacketInHandler.class);
+ private final DataBroker dataBroker;
+ private final PacketProcessingService packetService;
- private static final Logger s_logger = LoggerFactory.getLogger(SubnetRoutePacketInHandler.class);
- private final DataBroker broker;
- private PacketProcessingService packetService;
- private VpnInterfaceManager ifManager;
- private IdManagerService idManager;
- //List maintains info about the arp request sent - id src+dst ip
- private ArrayList<String> arpList = new ArrayList();
-
- public SubnetRoutePacketInHandler(DataBroker dataBroker, IdManagerService idManager) {
- broker = dataBroker;
- this.idManager = idManager;
+ public SubnetRoutePacketInHandler(final DataBroker dataBroker,
+ final PacketProcessingService packetService) {
+ this.dataBroker = dataBroker;
+ this.packetService =packetService;
}
public void onPacketReceived(PacketReceived notification) {
-
- s_logger.trace("SubnetRoutePacketInHandler: PacketReceived invoked...");
+ LOG.trace("SubnetRoutePacketInHandler: PacketReceived invoked...");
short tableId = notification.getTableId().getValue();
byte[] data = notification.getPayload();
Ethernet res = new Ethernet();
if (tableId == NwConstants.L3_SUBNET_ROUTE_TABLE) {
- s_logger.trace("SubnetRoutePacketInHandler: Some packet received as {}", notification);
+ LOG.trace("SubnetRoutePacketInHandler: Some packet received as {}", notification);
try {
res.deserialize(data, 0, data.length * NetUtils.NumBitsInAByte);
} catch (Exception e) {
- s_logger.warn("SubnetRoutePacketInHandler: Failed to decode Packet ", e);
+ LOG.warn("SubnetRoutePacketInHandler: Failed to decode Packet ", e);
return;
}
try {
byte[] dstIp = Ints.toByteArray(ipv4.getDestinationAddress());
String dstIpStr = toStringIpAddress(dstIp);
String srcIpStr = toStringIpAddress(srcIp);
- /*if (VpnUtil.getNeutronPortNamefromPortFixedIp(broker, dstIpStr) != null) {
- s_logger.debug("SubnetRoutePacketInHandler: IPv4 Packet received with "
+ /*if (VpnUtil.getNeutronPortNamefromPortFixedIp(dataBroker, dstIpStr) != null) {
+ LOG.debug("SubnetRoutePacketInHandler: IPv4 Packet received with "
+ "Target IP {} is a valid Neutron port, ignoring subnet route processing", dstIpStr);
return;
}*/
long vpnId = MetaDataUtil.getVpnIdFromMetadata(metadata);
- s_logger.info("SubnetRoutePacketInHandler: Processing IPv4 Packet received with Source IP {} "
+ LOG.info("SubnetRoutePacketInHandler: Processing IPv4 Packet received with Source IP {} "
+ "and Target IP {} and vpnId {}", srcIpStr, dstIpStr, vpnId);
InstanceIdentifier<VpnIds> vpnIdsInstanceIdentifier = getVpnIdToVpnInstanceIdentifier(vpnId);
- Optional<VpnIds> vpnIdsOptional = VpnUtil.read(broker, LogicalDatastoreType.CONFIGURATION, vpnIdsInstanceIdentifier);
+ Optional<VpnIds> vpnIdsOptional = VpnUtil.read(dataBroker, LogicalDatastoreType.CONFIGURATION, vpnIdsInstanceIdentifier);
if(!vpnIdsOptional.isPresent()) {
// Donot trigger subnetroute logic for packets from unknown VPNs
- s_logger.info("Ignoring IPv4 packet with destination Ip {} and source Ip {} as it came on unknown VPN with ID {}", dstIpStr, srcIpStr, vpnId);
+ LOG.info("Ignoring IPv4 packet with destination Ip {} and source Ip {} as it came on unknown VPN with ID {}", dstIpStr, srcIpStr, vpnId);
return;
}
// It is an ARP request on a configured VPN. So we must attempt to respond.
VpnIds vpnIds = vpnIdsOptional.get();
- if (VpnUtil.getNeutronPortFromVpnPortFixedIp(broker, vpnIds.getVpnInstanceName(), dstIpStr) !=
+ if (VpnUtil.getNeutronPortFromVpnPortFixedIp(dataBroker, vpnIds.getVpnInstanceName(), dstIpStr) !=
null) {
- s_logger.debug("SubnetRoutePacketInHandler: IPv4 Packet received with "
+ LOG.debug("SubnetRoutePacketInHandler: IPv4 Packet received with "
+ "Target IP {} is a valid Neutron port, ignoring subnet route processing", dstIpStr);
return;
}
long elanTag = getElanTagFromSubnetRouteMetadata(metadata);
if (elanTag == 0) {
- s_logger.error("SubnetRoutePacketInHandler: elanTag value from metadata found to be 0, for IPv4 " +
+ LOG.error("SubnetRoutePacketInHandler: elanTag value from metadata found to be 0, for IPv4 " +
" Packet received with Target IP {}", dstIpStr);
return;
}
- s_logger.info("SubnetRoutePacketInHandler: Processing IPv4 Packet received with Source IP {} "
+ LOG.info("SubnetRoutePacketInHandler: Processing IPv4 Packet received with Source IP {} "
+ "and Target IP {} and elan Tag {}", srcIpStr, dstIpStr, elanTag);
- BigInteger dpnId = getTargetDpnForPacketOut(broker, elanTag, ipv4.getDestinationAddress());
+ BigInteger dpnId = getTargetDpnForPacketOut(dataBroker, elanTag, ipv4.getDestinationAddress());
//Handle subnet routes ip requests
if (dpnId != BigInteger.ZERO) {
long groupid = VpnUtil.getRemoteBCGroup(elanTag);
}
} catch (Exception ex) {
//Failed to handle packet
- s_logger.error("SubnetRoutePacketInHandler: Failed to handle subnetroute packets ", ex);
+ LOG.error("SubnetRoutePacketInHandler: Failed to handle subnetroute packets ", ex);
}
return;
}
//All Arp responses learning for invisble IPs will now be handled by VpnManager
/*if (tableId == NwConstants.L3_INTERFACE_TABLE) {
- s_logger.trace("SubnetRoutePacketInHandler: Packet from Table {} received as {}",
+ LOG.trace("SubnetRoutePacketInHandler: Packet from Table {} received as {}",
NwConstants.L3_INTERFACE_TABLE, notification);
try {
res.deserialize(data, 0, data.length * NetUtils.NumBitsInAByte);
} catch (Exception e) {
- s_logger.warn("SubnetRoutePacketInHandler: Failed to decode Table " + NwConstants.L3_INTERFACE_TABLE + " Packet ", e);
+ LOG.warn("SubnetRoutePacketInHandler: Failed to decode Table " + NwConstants.L3_INTERFACE_TABLE + " Packet ", e);
return;
}
try {
Packet pkt = res.getPayload();
if (pkt instanceof ARP) {
- s_logger.debug("SubnetRoutePacketInHandler: ARP packet received");
+ LOG.debug("SubnetRoutePacketInHandler: ARP packet received");
ARP arpPacket = (ARP) pkt;
boolean arpReply = (arpPacket.getOpCode() == 2) ? true : false;
if (arpReply) {
//Handle subnet routes arp responses
- s_logger.debug("SubnetRoutePacketInHandler: ARP reply received");
+ LOG.debug("SubnetRoutePacketInHandler: ARP reply received");
byte[] respSrc = arpPacket.getSenderProtocolAddress();
byte[] respDst = arpPacket.getTargetProtocolAddress();
String respIp = toStringIpAddress(respSrc);
String check = toStringIpAddress(respDst) + respIp;
- if (VpnUtil.getNeutronPortNamefromPortFixedIp(broker, respIp) != null) {
- s_logger.debug("SubnetRoutePacketInHandler: ARP reply Packet received with "
+ if (VpnUtil.getNeutronPortNamefromPortFixedIp(dataBroker, respIp) != null) {
+ LOG.debug("SubnetRoutePacketInHandler: ARP reply Packet received with "
+ "Source IP {} which is a valid Neutron port, ignoring subnet route processing", respIp);
return;
}
String srcIp = toStringIpAddress(respSrc);
String destIp = toStringIpAddress(respDst);
long vpnId = MetaDataUtil.getVpnIdFromMetadata(metadata);
- s_logger.info("SubnetRoutePacketInHandler: Processing ARP response Packet received with Source IP {} "
+ LOG.info("SubnetRoutePacketInHandler: Processing ARP response Packet received with Source IP {} "
+ "and Target IP {} and vpnId {}", srcIp, destIp, vpnId);
InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.vpn.id.to.vpn.instance.VpnIds> vpnIdsInstanceIdentifier = getVpnIdToVpnInstanceIdentifier(vpnId);
- Optional<org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.vpn.id.to.vpn.instance.VpnIds> vpnIdsOptional = VpnUtil.read(broker, LogicalDatastoreType.CONFIGURATION, vpnIdsInstanceIdentifier);
+ Optional<org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.vpn.id.to.vpn.instance.VpnIds> vpnIdsOptional = VpnUtil.read(dataBroker, LogicalDatastoreType.CONFIGURATION, vpnIdsInstanceIdentifier);
if(!vpnIdsOptional.isPresent()) {
// Donot trigger subnetroute logic for packets from unknown VPNs
- s_logger.info("Ignoring ARP response packet with destination Ip {} and source Ip {} as it came on with VPN ID {}", destIp, srcIp, vpnId);
+ LOG.info("Ignoring ARP response packet with destination Ip {} and source Ip {} as it came on with VPN ID {}", destIp, srcIp, vpnId);
return;
}
// It is an ARP request on a configured VPN. So we must attempt to respond.
org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.vpn.id.to.vpn.instance.VpnIds vpnIds = vpnIdsOptional.get();
- if (VpnUtil.getNeutronPortFromVpnPortFixedIp(broker, vpnIds.getVpnInstanceName(), srcIp) != null) {
- s_logger.debug("SubnetRoutePacketInHandler: ARP response Packet received with "
+ if (VpnUtil.getNeutronPortFromVpnPortFixedIp(dataBroker, vpnIds.getVpnInstanceName(), srcIp) != null) {
+ LOG.debug("SubnetRoutePacketInHandler: ARP response Packet received with "
+ "Target IP {} is a valid Neutron port, ignoring subnet route processing", destIp);
return;
}
String destination = VpnUtil.getIpPrefix(srcIp);
long portTag = MetaDataUtil.getLportFromMetadata(metadata).intValue();
- s_logger.info("SubnetRoutePacketInHandler: ARP reply received for target IP {} from LPort {}" + srcIp, portTag);
- IfIndexInterface interfaceInfo = VpnUtil.getInterfaceInfoByInterfaceTag(broker, portTag);
+ LOG.info("SubnetRoutePacketInHandler: ARP reply received for target IP {} from LPort {}" + srcIp, portTag);
+ IfIndexInterface interfaceInfo = VpnUtil.getInterfaceInfoByInterfaceTag(dataBroker, portTag);
String ifName = interfaceInfo.getInterfaceName();
InstanceIdentifier<VpnInterface> vpnIfIdentifier = VpnUtil.getVpnInterfaceIdentifier(ifName);
- VpnInterface vpnInterface = VpnUtil.getConfiguredVpnInterface(broker, ifName);
+ VpnInterface vpnInterface = VpnUtil.getConfiguredVpnInterface(dataBroker, ifName);
//Get VPN interface adjacencies
if (vpnInterface != null) {
InstanceIdentifier<Adjacencies> path = vpnIfIdentifier.augmentation(Adjacencies.class);
- Optional<Adjacencies> adjacencies = VpnUtil.read(broker, LogicalDatastoreType.CONFIGURATION, path);
+ Optional<Adjacencies> adjacencies = VpnUtil.read(dataBroker, LogicalDatastoreType.CONFIGURATION, path);
String nextHopIpAddr = null;
String nextHopMacAddress = null;
if (adjacencies.isPresent()) {
}
}
if (nextHopMacAddress != null && destination != null) {
- String rd = VpnUtil.getVpnRd(broker, vpnInterface.getVpnInstanceName());
+ String rd = VpnUtil.getVpnRd(dataBroker, vpnInterface.getVpnInstanceName());
long label =
VpnUtil.getUniqueId(idManager, VpnConstants.VPN_IDPOOL_NAME,
VpnUtil.getNextHopLabelKey((rd != null) ? rd : vpnInterface.getVpnInstanceName(), destination));
VpnInterface newVpnIntf = new VpnInterfaceBuilder().setKey(new VpnInterfaceKey(vpnInterface.getName())).
setName(vpnInterface.getName()).setVpnInstanceName(vpnInterface.getVpnInstanceName()).
addAugmentation(Adjacencies.class, aug).build();
- VpnUtil.syncUpdate(broker, LogicalDatastoreType.CONFIGURATION, vpnIfIdentifier, newVpnIntf);
- s_logger.debug("SubnetRoutePacketInHandler: Successfully stored subnetroute Adjacency into VpnInterface {}", newVpnIntf);
+ VpnUtil.syncUpdate(dataBroker, LogicalDatastoreType.CONFIGURATION, vpnIfIdentifier, newVpnIntf);
+ LOG.debug("SubnetRoutePacketInHandler: Successfully stored subnetroute Adjacency into VpnInterface {}", newVpnIntf);
}
}
}
}
} catch (Exception ex) {
//Failed to decode packet
- s_logger.error("SubnetRoutePacketInHandler: Failed to handle subnetroute Table " + NwConstants.L3_INTERFACE_TABLE +
+ LOG.error("SubnetRoutePacketInHandler: Failed to handle subnetroute Table " + NwConstants.L3_INTERFACE_TABLE +
" packets ", ex);
}
}*/
BigInteger dpnid = BigInteger.ZERO;
ElanTagName elanInfo = VpnUtil.getElanInfoByElanTag(broker, elanTag);
if (elanInfo == null) {
- s_logger.trace("SubnetRoutePacketInHandler: Unable to retrieve ElanInfo for elanTag {}", elanTag);
+ LOG.trace("SubnetRoutePacketInHandler: Unable to retrieve ElanInfo for elanTag {}", elanTag);
return dpnid;
}
InstanceIdentifier<NetworkMap> networkId = InstanceIdentifier.builder(NetworkMaps.class)
Optional<NetworkMap> optionalNetworkMap = VpnUtil.read(broker, LogicalDatastoreType.CONFIGURATION, networkId);
if (optionalNetworkMap.isPresent()) {
List<Uuid> subnetList = optionalNetworkMap.get().getSubnetIdList();
- s_logger.trace("SubnetRoutePacketInHandler: Obtained subnetList as " + subnetList);
+ LOG.trace("SubnetRoutePacketInHandler: Obtained subnetList as " + subnetList);
for (Uuid subnetId : subnetList) {
InstanceIdentifier<SubnetOpDataEntry> subOpIdentifier = InstanceIdentifier.builder(SubnetOpData.class).
child(SubnetOpDataEntry.class, new SubnetOpDataEntryKey(subnetId)).build();
}
SubnetOpDataEntry subOpEntry = optionalSubs.get();
if (subOpEntry.getNhDpnId() != null) {
- s_logger.trace("SubnetRoutePacketInHandler: Viewing Subnet " + subnetId);
+ LOG.trace("SubnetRoutePacketInHandler: Viewing Subnet " + subnetId);
boolean match = VpnUtil.isIpInSubnet(ipAddress, subOpEntry.getSubnetCidr());
- s_logger.trace("SubnetRoutePacketInHandler: Viewing Subnet " + subnetId + " matching " + match);
+ LOG.trace("SubnetRoutePacketInHandler: Viewing Subnet " + subnetId + " matching " + match);
if (match) {
dpnid = subOpEntry.getNhDpnId();
return dpnid;
try {
ip = InetAddress.getByAddress(ipAddress).getHostAddress();
} catch(UnknownHostException e) {
- s_logger.error("SubnetRoutePacketInHandler: Unable to translate byt[] ipAddress to String {}", e);
+ LOG.error("SubnetRoutePacketInHandler: Unable to translate byt[] ipAddress to String {}", e);
}
return ip;
}
- public void setPacketProcessingService(PacketProcessingService service) {
- this.packetService = service;
- }
-
public static long getElanTagFromSubnetRouteMetadata(BigInteger metadata) {
return ((metadata.and(MetaDataUtil.METADATA_MASK_ELAN_SUBNET_ROUTE)).shiftRight(32)).longValue();
}
-
static InstanceIdentifier<VpnIds>
getVpnIdToVpnInstanceIdentifier(long vpnId) {
return InstanceIdentifier.builder(VpnIdToVpnInstance.class)
--- /dev/null
+/*
+ * Copyright (c) 2015 - 2016 Ericsson India Global Services Pvt Ltd. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.netvirt.vpnmanager;
+
+import com.google.common.base.Optional;
+import com.google.common.util.concurrent.CheckedFuture;
+import com.google.common.util.concurrent.FutureCallback;
+import com.google.common.util.concurrent.Futures;
+import java.util.concurrent.ExecutionException;
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
+import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
+import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
+import org.opendaylight.yangtools.yang.binding.DataObject;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class TransactionUtil {
+ private static final Logger LOG = LoggerFactory.getLogger(TransactionUtil.class);
+
+ private TransactionUtil() {
+ }
+
+ public static final FutureCallback<Void> DEFAULT_CALLBACK = new FutureCallback<Void>() {
+ public void onSuccess(Void result) {
+ LOG.debug("Success in Datastore operation");
+ }
+
+ public void onFailure(Throwable error) {
+ LOG.error("Error in Datastore operation", error);
+ };
+ };
+
+ public static <T extends DataObject> Optional<T> read(DataBroker dataBroker, LogicalDatastoreType datastoreType,
+ InstanceIdentifier<T> path) {
+
+ ReadOnlyTransaction tx = dataBroker.newReadOnlyTransaction();
+
+ Optional<T> result;
+ try {
+ result = tx.read(datastoreType, path).get();
+ } catch (Exception e) {
+ throw new RuntimeException(e);
+ }
+
+ return result;
+ }
+
+ public static <T extends DataObject> void asyncWrite(DataBroker dataBroker, LogicalDatastoreType datastoreType,
+ InstanceIdentifier<T> path, T data,
+ FutureCallback<Void> callback) {
+ WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
+ tx.put(datastoreType, path, data, true);
+ Futures.addCallback(tx.submit(), callback);
+ }
+
+ public static <T extends DataObject> void syncWrite(DataBroker dataBroker, LogicalDatastoreType datastoreType,
+ InstanceIdentifier<T> path,
+ T data, FutureCallback<Void> callback) {
+ WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
+ tx.put(datastoreType, path, data, true);
+ CheckedFuture<Void, TransactionCommitFailedException> futures = tx.submit();
+ try {
+ futures.get();
+ } catch (InterruptedException | ExecutionException e) {
+ LOG.error("Error writing VPN instance to ID info to datastore (path, data) : ({}, {})", path, data);
+ throw new RuntimeException(e.getMessage());
+ }
+ }
+}
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.netvirt.vpnmanager;
import com.google.common.base.Optional;
-
+import java.math.BigInteger;
+import java.util.Iterator;
+import java.util.List;
+import java.util.concurrent.Future;
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.DataChangeListener;
import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker;
-import org.opendaylight.netvirt.bgpmanager.api.IBgpManager;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.netvirt.bgpmanager.api.IBgpManager;
import org.opendaylight.netvirt.fibmanager.api.IFibManager;
import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.VpnAfConfig;
import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.VpnInstances;
import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.instances.VpnInstance;
import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.interfaces.VpnInterface;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.TunnelsState;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.Adjacencies;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.adjacency.list.Adjacency;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data.vpn.instance.op.data.entry.VpnToDpnList;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.vrfentries.VrfEntry;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.TepTypeExternal;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.TepTypeHwvtep;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.TepTypeInternal;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.TunnelsState;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.tunnels_state.StateTunnelList;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.IsDcgwPresentInputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.IsDcgwPresentOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.ItmRpcService;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.vrfentries.VrfEntry;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.Adjacencies;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.adjacency.list.Adjacency;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data.vpn.instance.op.data.entry.VpnToDpnList;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.common.RpcResult;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import java.math.BigInteger;
-import java.util.Iterator;
-import java.util.List;
-import java.util.concurrent.Future;
-
-public class TunnelInterfaceStateListener extends AbstractDataChangeListener<StateTunnelList> implements AutoCloseable{
-
+public class TunnelInterfaceStateListener extends AbstractDataChangeListener<StateTunnelList>
+ implements AutoCloseable{
private static final Logger LOG = LoggerFactory.getLogger(TunnelInterfaceStateListener.class);
- protected enum UpdateRouteAction {
- ADVERTISE_ROUTE, WITHDRAW_ROUTE
- }
-
- private ListenerRegistration<DataChangeListener> tunnelInterfaceStateListenerRegistration;
- private final DataBroker broker;
+ private ListenerRegistration<DataChangeListener> listenerRegistration;
+ private final DataBroker dataBroker;
private final IBgpManager bgpManager;
private IFibManager fibManager;
private ItmRpcService itmRpcService;
+ protected enum UpdateRouteAction {
+ ADVERTISE_ROUTE, WITHDRAW_ROUTE
+ }
/**
* Responsible for listening to tunnel interface state change
*
- * @param db - dataBroker service reference
- * @param bgpManager Used to advertise routes to the BGP Router
+ * @param dataBroker dataBroker
+ * @param bgpManager bgpManager
+ * @param fibManager fibManager
+ * @param itmRpcService itmRpcService
*/
- public TunnelInterfaceStateListener(final DataBroker db,
- final IBgpManager bgpManager) {
+ public TunnelInterfaceStateListener(final DataBroker dataBroker,
+ final IBgpManager bgpManager,
+ final IFibManager fibManager,
+ final ItmRpcService itmRpcService) {
super(StateTunnelList.class);
- broker = db;
+ this.dataBroker = dataBroker;
this.bgpManager = bgpManager;
- registerListener(db);
- }
-
- public void setITMRpcService(ItmRpcService itmRpcService) {
+ this.fibManager = fibManager;
this.itmRpcService = itmRpcService;
}
- public void setFibManager(IFibManager fibManager) {
- this.fibManager = fibManager;
+ public void start() {
+ LOG.info("{} start", getClass().getSimpleName());
+ listenerRegistration = dataBroker.registerDataChangeListener(LogicalDatastoreType.OPERATIONAL,
+ getWildCardPath(), this, AsyncDataBroker.DataChangeScope.SUBTREE);
}
- public IFibManager getFibManager() {
- return this.fibManager;
+ private InstanceIdentifier<StateTunnelList> getWildCardPath() {
+ return InstanceIdentifier.create(TunnelsState.class).child(StateTunnelList.class);
}
@Override
public void close() throws Exception {
- if (tunnelInterfaceStateListenerRegistration != null) {
- try {
- tunnelInterfaceStateListenerRegistration.close();
- } catch (final Exception e) {
- LOG.error("Error when cleaning up DataChangeListener.", e);
- }
- tunnelInterfaceStateListenerRegistration = null;
- }
- LOG.info("Tunnel Interface State Listener Closed");
- }
-
- private void registerListener(final DataBroker db) {
- try {
- tunnelInterfaceStateListenerRegistration = db.registerDataChangeListener(LogicalDatastoreType.OPERATIONAL,
- getWildCardPath(), TunnelInterfaceStateListener.this, AsyncDataBroker.DataChangeScope.SUBTREE);
- } catch (final Exception e) {
- LOG.error("Tunnel Interface State Listener DataChange listener registration fail!", e);
- throw new IllegalStateException("Tunnel Interface State Listener registration Listener failed.", e);
+ if (listenerRegistration != null) {
+ listenerRegistration.close();
+ listenerRegistration = null;
}
- }
-
- private InstanceIdentifier<StateTunnelList> getWildCardPath() {
- return InstanceIdentifier.create(TunnelsState.class).child(StateTunnelList.class);
+ LOG.info("{} close", getClass().getSimpleName());
}
@Override
InstanceIdentifier.InstanceIdentifierBuilder<VpnInstances> idBuilder = InstanceIdentifier.builder(VpnInstances.class);
InstanceIdentifier<VpnInstances> vpnInstancesId = idBuilder.build();
- Optional<VpnInstances> vpnInstances = VpnUtil.read(broker, LogicalDatastoreType.CONFIGURATION, vpnInstancesId);
+ Optional<VpnInstances> vpnInstances = VpnUtil.read(dataBroker, LogicalDatastoreType.CONFIGURATION, vpnInstancesId);
long tunTypeVal = 0, vpnId;
if (stateTunnelList.getDstInfo().getTepDeviceType() == TepTypeInternal.class) {
while (vpnInstIter.hasNext()) {
VpnInstance vpnInstance = vpnInstIter.next();
LOG.trace("vpnInstance {}", vpnInstance);
- vpnId = VpnUtil.getVpnId(broker, vpnInstance.getVpnInstanceName());
+ vpnId = VpnUtil.getVpnId(dataBroker, vpnInstance.getVpnInstanceName());
try {
VpnAfConfig vpnConfig = vpnInstance.getIpv4Family();
LOG.trace("vpnConfig {}", vpnConfig);
InstanceIdentifier<VpnToDpnList> srcId =
VpnUtil.getVpnToDpnListIdentifier(rd, srcDpnId);
Optional<VpnToDpnList> srcDpnInVpn =
- VpnUtil.read(broker, LogicalDatastoreType.OPERATIONAL, srcId);
+ VpnUtil.read(dataBroker, LogicalDatastoreType.OPERATIONAL, srcId);
if (tunTypeVal == VpnConstants.ITMTunnelLocType.Internal.getValue()) {
destDpnId = new BigInteger(stateTunnelList.getDstInfo().getTepDeviceId());
InstanceIdentifier<VpnToDpnList> destId =
VpnUtil.getVpnToDpnListIdentifier(rd, destDpnId);
Optional<VpnToDpnList> destDpnInVpn =
- VpnUtil.read(broker, LogicalDatastoreType.OPERATIONAL, destId);
+ VpnUtil.read(dataBroker, LogicalDatastoreType.OPERATIONAL, destId);
if (!(srcDpnInVpn.isPresent() &&
destDpnInVpn.isPresent())) {
LOG.trace(" srcDpn {} - destDPN {}, do not share the VPN {} with rd {}.",
InstanceIdentifier<Adjacencies> path =
vpnIntfId.augmentation(Adjacencies.class);
Optional<Adjacencies> adjacencies =
- VpnUtil.read(broker, LogicalDatastoreType.OPERATIONAL, path);
+ VpnUtil.read(dataBroker, LogicalDatastoreType.OPERATIONAL, path);
LOG.trace("adjacencies {}", adjacencies);
if (adjacencies.isPresent()) {
List<Adjacency> adjacencyList = adjacencies.get().getAdjacency();
fibManager.handleRemoteRoute(true,
new BigInteger(stateTunnelList.getSrcInfo().getTepDeviceId()),
new BigInteger(stateTunnelList.getDstInfo().getTepDeviceId()),
- VpnUtil.getVpnId(broker, vpnInstance.getVpnInstanceName()),
+ VpnUtil.getVpnId(dataBroker, vpnInstance.getVpnInstanceName()),
rd, adjacency.getIpAddress(), srcTepIp, destTepIp);
}
if (tunTypeVal == VpnConstants.ITMTunnelLocType.External.getValue()) {
}
}
// if (action == UpdateRouteAction.WITHDRAW_ROUTE) {
- // fibManager.cleanUpDpnForVpn(dpnId, VpnUtil.getVpnId(broker, vpnInstance.getVpnInstanceName()), rd);
+ // fibManager.cleanUpDpnForVpn(dpnId, VpnUtil.getVpnId(dataBroker, vpnInstance.getVpnInstanceName()), rd);
// }
// Go through all the VrfEntries and withdraw and readvertise the prefixes to BGP for which the nextHop is the SrcTepIp
if ((action == UpdateRouteAction.ADVERTISE_ROUTE) &&
(tunTypeVal == VpnConstants.ITMTunnelLocType.External.getValue())) {
- List<VrfEntry> vrfEntries = VpnUtil.getAllVrfEntries(broker, rd);
+ List<VrfEntry> vrfEntries = VpnUtil.getAllVrfEntries(dataBroker, rd);
if (vrfEntries != null) {
for (VrfEntry vrfEntry : vrfEntries) {
String destPrefix = vrfEntry.getDestPrefix().trim();
*/
package org.opendaylight.netvirt.vpnmanager;
+import com.google.common.base.Optional;
+import com.google.common.util.concurrent.CheckedFuture;
+import com.google.common.util.concurrent.FutureCallback;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.ThreadFactoryBuilder;
import java.util.ArrayList;
import java.util.List;
-import java.util.concurrent.*;
-
-import com.google.common.util.concurrent.*;
-
-import org.opendaylight.genius.datastoreutils.DataStoreJobCoordinator;
-import org.opendaylight.netvirt.bgpmanager.api.IBgpManager;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ThreadFactory;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.DataChangeListener;
-import org.opendaylight.controller.md.sal.binding.api.NotificationService;
+import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
+import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker.DataChangeScope;
import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
+import org.opendaylight.genius.datastoreutils.DataStoreJobCoordinator;
+import org.opendaylight.netvirt.bgpmanager.api.IBgpManager;
+import org.opendaylight.netvirt.fibmanager.api.IFibManager;
+import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.VpnAfConfig;
+import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.VpnInstances;
import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.af.config.vpntargets.VpnTarget;
+import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.instances.VpnInstance;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.IdManagerService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.id.to.vpn.instance.VpnIds;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data.VpnInstanceOpDataEntry;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data.VpnInstanceOpDataEntryBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data.VpnInstanceOpDataEntryKey;
-
-import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data.vpn.instance.op
- .data.entry.VpnToDpnList;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data.vpn.instance.op.data.entry.VpnToDpnList;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
-import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
-import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.VpnAfConfig;
-import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.VpnInterfaces;
-import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.instances.VpnInstance;
-import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.instances.VpnInstanceKey;
-import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.VpnInstances;
-import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.interfaces.VpnInterface;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.VpnInstanceOpData;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.FibEntries;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.fibentries.VrfTables;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.fibentries.VrfTablesKey;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.vrfentries.VrfEntry;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.IdManagerService;
-import org.opendaylight.netvirt.fibmanager.api.IFibManager;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import com.google.common.base.Optional;
-
-public class VpnManager extends AbstractDataChangeListener<VpnInstance> implements AutoCloseable {
- private static final Logger LOG = LoggerFactory.getLogger(VpnManager.class);
- private ListenerRegistration<DataChangeListener> listenerRegistration, fibListenerRegistration;
- private ConcurrentMap<String, Runnable> vpnOpMap = new ConcurrentHashMap<String, Runnable>();
- private ExecutorService executorService = Executors.newSingleThreadExecutor();
- private final DataBroker broker;
+public class VpnInstanceListener extends AbstractDataChangeListener<VpnInstance> implements AutoCloseable {
+ private static final Logger LOG = LoggerFactory.getLogger(VpnInstanceListener.class);
+ private ListenerRegistration<DataChangeListener> listenerRegistration;
+ private final DataBroker dataBroker;
private final IBgpManager bgpManager;
- private IdManagerService idManager;
- private VpnInterfaceManager vpnInterfaceManager;
- private final FibEntriesListener fibListener;
- private NotificationService notificationService;
-
- private static final FutureCallback<Void> DEFAULT_CALLBACK =
- new FutureCallback<Void>() {
- @Override
- public void onSuccess(Void result) {
- LOG.debug("Success in Datastore operation");
- }
+ private final IdManagerService idManager;
+ private final VpnInterfaceManager vpnInterfaceManager;
+ private final IFibManager fibManager;
+ private static final ThreadFactory threadFactory = new ThreadFactoryBuilder()
+ .setNameFormat("NV-VpnMgr-%d").build();
+ private ExecutorService executorService = Executors.newSingleThreadExecutor(threadFactory);
+ private ConcurrentMap<String, Runnable> vpnOpMap = new ConcurrentHashMap<String, Runnable>();
- @Override
- public void onFailure(Throwable error) {
- LOG.error("Error in Datastore operation", error);
- };
- };
-
- /**
- * Listens for data change related to VPN Instance
- * Informs the BGP about VRF information
- *
- * @param db dataBroker reference
- * @param bgpManager Used to advertise routes to the BGP Router
- */
- public VpnManager(final DataBroker db, final IBgpManager bgpManager) {
+ public VpnInstanceListener(final DataBroker dataBroker, final IBgpManager bgpManager,
+ final IdManagerService idManager,
+ final VpnInterfaceManager vpnInterfaceManager,
+ final IFibManager fibManager) {
super(VpnInstance.class);
- broker = db;
+ this.dataBroker = dataBroker;
this.bgpManager = bgpManager;
- this.fibListener = new FibEntriesListener();
- registerListener(db);
+ this.idManager = idManager;
+ this.vpnInterfaceManager = vpnInterfaceManager;
+ this.fibManager = fibManager;
}
- private void registerListener(final DataBroker db) {
- try {
- listenerRegistration = db.registerDataChangeListener(LogicalDatastoreType.CONFIGURATION,
- getWildCardPath(), VpnManager.this, DataChangeScope.SUBTREE);
- fibListenerRegistration = db.registerDataChangeListener(LogicalDatastoreType.OPERATIONAL,
- getFibEntryListenerPath(), fibListener, DataChangeScope.BASE);
- } catch (final Exception e) {
- LOG.error("VPN Service DataChange listener registration fail !", e);
- throw new IllegalStateException("VPN Service registration Listener failed.", e);
- }
+ public void start() {
+ LOG.info("{} start", getClass().getSimpleName());
+ listenerRegistration = dataBroker.registerDataChangeListener(LogicalDatastoreType.CONFIGURATION,
+ getWildCardPath(), this, AsyncDataBroker.DataChangeScope.SUBTREE);
}
- public void setIdManager(IdManagerService idManager) {
- this.idManager = idManager;
+ private InstanceIdentifier<VpnInstance> getWildCardPath() {
+ return InstanceIdentifier.create(VpnInstances.class).child(VpnInstance.class);
}
- public void setVpnInterfaceManager(VpnInterfaceManager vpnInterfaceManager) {
- this.vpnInterfaceManager = vpnInterfaceManager;
+ @Override
+ public void close() throws Exception {
+ if (listenerRegistration != null) {
+ listenerRegistration.close();
+ listenerRegistration = null;
+ }
+ LOG.info("{} close", getClass().getSimpleName());
+ }
+
+ void notifyTaskIfRequired(String vpnName) {
+ Runnable notifyTask = vpnOpMap.remove(vpnName);
+ if (notifyTask == null) {
+ LOG.trace("VpnInstanceListener update: No Notify Task queued for vpnName {}", vpnName);
+ return;
+ }
+ executorService.execute(notifyTask);
}
private void waitForOpRemoval(String rd, String vpnName) {
Integer retryCount = 1;
long timeout = VpnConstants.MIN_WAIT_TIME_IN_MILLISECONDS;
Optional<VpnInstanceOpDataEntry> vpnOpValue = null;
- vpnOpValue = VpnUtil.read(broker, LogicalDatastoreType.OPERATIONAL,
- VpnUtil.getVpnInstanceOpDataIdentifier(rd));
+ vpnOpValue = VpnUtil.read(dataBroker, LogicalDatastoreType.OPERATIONAL,
+ VpnUtil.getVpnInstanceOpDataIdentifier(rd));
if ((vpnOpValue != null) && (vpnOpValue.isPresent())) {
vpnOpEntry = vpnOpValue.get();
try {
Thread.sleep(timeout);
- } catch (java.lang.InterruptedException e) {
+ } catch (InterruptedException e) {
}
// Check current interface count
- vpnOpValue = VpnUtil.read(broker, LogicalDatastoreType.OPERATIONAL,
+ vpnOpValue = VpnUtil.read(dataBroker, LogicalDatastoreType.OPERATIONAL,
VpnUtil.getVpnInstanceOpDataIdentifier(rd));
if ((vpnOpValue != null) && (vpnOpValue.isPresent())) {
vpnOpEntry = vpnOpValue.get();
LOG.trace("Remove VPN event key: {}, value: {}", identifier, del);
final String vpnName = del.getVpnInstanceName();
final String rd = del.getIpv4Family().getRouteDistinguisher();
- final long vpnId = VpnUtil.getVpnId(broker, vpnName);
+ final long vpnId = VpnUtil.getVpnId(dataBroker, vpnName);
Optional<VpnInstanceOpDataEntry> vpnOpValue = null;
//TODO(vpnteam): Entire code would need refactoring to listen only on the parent object - VPNInstance
try {
if ((rd != null) && (!rd.isEmpty())) {
- vpnOpValue = VpnUtil.read(broker, LogicalDatastoreType.OPERATIONAL,
+ vpnOpValue = VpnUtil.read(dataBroker, LogicalDatastoreType.OPERATIONAL,
VpnUtil.getVpnInstanceOpDataIdentifier(rd));
} else {
- vpnOpValue = VpnUtil.read(broker, LogicalDatastoreType.OPERATIONAL,
+ vpnOpValue = VpnUtil.read(dataBroker, LogicalDatastoreType.OPERATIONAL,
VpnUtil.getVpnInstanceOpDataIdentifier(vpnName));
}
} catch (Exception e) {
DataStoreJobCoordinator dataStoreCoordinator = DataStoreJobCoordinator.getInstance();
dataStoreCoordinator.enqueueJob("VPN-" + vpnName,
- new DeleteVpnInstanceWorker(idManager, broker, del));
+ new DeleteVpnInstanceWorker(idManager, dataBroker, del));
}
private class DeleteVpnInstanceWorker implements Callable<List<ListenableFuture<Void>>> {
List<ListenableFuture<Void>> futures = new ArrayList<>();
futures.add(writeTxn.submit());
LOG.trace("Removed vpnIdentifier for rd{} vpnname {}", rd, vpnName);
- IFibManager fibManager = vpnInterfaceManager.getFibManager();
if (rd != null) {
synchronized (vpnName.intern()) {
fibManager.removeVrfTable(broker, rd, null);
DataStoreJobCoordinator dataStoreCoordinator = DataStoreJobCoordinator.getInstance();
dataStoreCoordinator.enqueueJob("VPN-" + vpnName,
- new AddVpnInstanceWorker(idManager, vpnInterfaceManager, broker, value));
+ new AddVpnInstanceWorker(idManager, vpnInterfaceManager, dataBroker, value));
}
private class AddVpnInstanceWorker implements Callable<List<ListenableFuture<Void>>> {
: vpnInstanceName);
if (writeConfigTxn != null) {
- writeConfigTxn.put(LogicalDatastoreType.CONFIGURATION, VpnUtil.getVpnInstanceToVpnIdIdentifier(vpnInstanceName),
+ writeConfigTxn.put(LogicalDatastoreType.CONFIGURATION,
+ VpnUtil.getVpnInstanceToVpnIdIdentifier(vpnInstanceName),
vpnInstanceToVpnId, true);
} else {
- syncWrite(LogicalDatastoreType.CONFIGURATION, VpnUtil.getVpnInstanceToVpnIdIdentifier(vpnInstanceName),
- vpnInstanceToVpnId, DEFAULT_CALLBACK);
+ TransactionUtil.syncWrite(dataBroker, LogicalDatastoreType.CONFIGURATION,
+ VpnUtil.getVpnInstanceToVpnIdIdentifier(vpnInstanceName),
+ vpnInstanceToVpnId, TransactionUtil.DEFAULT_CALLBACK);
}
- org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.id.to.vpn.instance.VpnIds
- vpnIdToVpnInstance = VpnUtil.getVpnIdToVpnInstance(vpnId, value.getVpnInstanceName(),
+ VpnIds vpnIdToVpnInstance = VpnUtil.getVpnIdToVpnInstance(vpnId, value.getVpnInstanceName(),
(rd != null) ? rd : value.getVpnInstanceName(), (rd != null)/*isExternalVpn*/);
if (writeConfigTxn != null) {
VpnUtil.getVpnIdToVpnInstanceIdentifier(vpnId),
vpnIdToVpnInstance, true);
} else {
- syncWrite(LogicalDatastoreType.CONFIGURATION,
- VpnUtil.getVpnIdToVpnInstanceIdentifier(vpnId),
- vpnIdToVpnInstance, DEFAULT_CALLBACK);
+ TransactionUtil.syncWrite(dataBroker, LogicalDatastoreType.CONFIGURATION,
+ VpnUtil.getVpnIdToVpnInstanceIdentifier(vpnId),
+ vpnIdToVpnInstance, TransactionUtil.DEFAULT_CALLBACK);
}
- IFibManager fibManager = vpnInterfaceManager.getFibManager();
try {
String cachedTransType = fibManager.getConfTransType();
LOG.trace("Value for confTransportType is " + cachedTransType);
.setVpnInstanceName(vpnInstanceName)
.setVpnInterfaceCount(0L);
if (writeOperTxn != null) {
- writeOperTxn.merge(LogicalDatastoreType.OPERATIONAL, VpnUtil.getVpnInstanceOpDataIdentifier(vpnInstanceName),
+ writeOperTxn.merge(LogicalDatastoreType.OPERATIONAL,
+ VpnUtil.getVpnInstanceOpDataIdentifier(vpnInstanceName),
builder.build(), true);
} else {
- syncWrite(LogicalDatastoreType.OPERATIONAL, VpnUtil.getVpnInstanceOpDataIdentifier(vpnInstanceName),
- builder.build(), DEFAULT_CALLBACK);
+ TransactionUtil.syncWrite(dataBroker, LogicalDatastoreType.OPERATIONAL,
+ VpnUtil.getVpnInstanceOpDataIdentifier(vpnInstanceName),
+ builder.build(), TransactionUtil.DEFAULT_CALLBACK);
}
synchronized (vpnInstanceName.intern()) {
- fibManager.addVrfTable(broker, vpnInstanceName, null);
+ fibManager.addVrfTable(dataBroker, vpnInstanceName, null);
}
} else {
- VpnInstanceOpDataEntryBuilder builder =
- new VpnInstanceOpDataEntryBuilder().setVrfId(rd).setVpnId(vpnId).setVpnInstanceName(vpnInstanceName)
- .setVpnInterfaceCount(0L);
+ VpnInstanceOpDataEntryBuilder builder = new VpnInstanceOpDataEntryBuilder()
+ .setVrfId(rd).setVpnId(vpnId).setVpnInstanceName(vpnInstanceName).setVpnInterfaceCount(0L);
if (writeOperTxn != null) {
writeOperTxn.merge(LogicalDatastoreType.OPERATIONAL,
VpnUtil.getVpnInstanceOpDataIdentifier(rd),
builder.build(), true);
} else {
- syncWrite(LogicalDatastoreType.OPERATIONAL,
+ TransactionUtil.syncWrite(dataBroker, LogicalDatastoreType.OPERATIONAL,
VpnUtil.getVpnInstanceOpDataIdentifier(rd),
- builder.build(), DEFAULT_CALLBACK);
+ builder.build(), TransactionUtil.DEFAULT_CALLBACK);
}
synchronized (vpnInstanceName.intern()) {
- fibManager.addVrfTable(broker, rd, null);
+ fibManager.addVrfTable(dataBroker, rd, null);
}
}
}
InstanceIdentifier<VpnInstances> vpnsIdentifier =
InstanceIdentifier.builder(VpnInstances.class).build();
- Optional<VpnInstances> optionalVpns = read( LogicalDatastoreType.CONFIGURATION,
+ Optional<VpnInstances> optionalVpns = TransactionUtil.read(dataBroker, LogicalDatastoreType.CONFIGURATION,
vpnsIdentifier);
if (!optionalVpns.isPresent() ||
optionalVpns.get().getVpnInstance() == null ||
return true;
}
- private InstanceIdentifier<?> getWildCardPath() {
- return InstanceIdentifier.create(VpnInstances.class).child(VpnInstance.class);
- }
-
- private InstanceIdentifier<?> getFibEntryListenerPath() {
- return InstanceIdentifier.create(FibEntries.class).child(VrfTables.class)
- .child(VrfEntry.class);
- }
-
- private InstanceIdentifier<?> getVpnInstanceOpListenerPath() {
- return InstanceIdentifier.create(VpnInstanceOpData.class).child(VpnInstanceOpDataEntry.class);
- }
-
- @Override
- public void close() throws Exception {
- if (listenerRegistration != null) {
- try {
- listenerRegistration.close();
- } catch (final Exception e) {
- LOG.error("Error when cleaning up Vpn DataChangeListener.", e);
- }
- listenerRegistration = null;
- }
- if (fibListenerRegistration != null) {
- try {
- fibListenerRegistration.close();
- } catch (final Exception e) {
- LOG.error("Error when cleaning up Fib entries DataChangeListener.", e);
- }
- fibListenerRegistration = null;
- }
- LOG.trace("VPN Manager Closed");
- }
-
- private <T extends DataObject> Optional<T> read(LogicalDatastoreType datastoreType,
- InstanceIdentifier<T> path) {
-
- ReadOnlyTransaction tx = broker.newReadOnlyTransaction();
-
- Optional<T> result = Optional.absent();
- try {
- result = tx.read(datastoreType, path).get();
- } catch (Exception e) {
- throw new RuntimeException(e);
- }
-
- return result;
- }
-
- private <T extends DataObject> void asyncWrite(LogicalDatastoreType datastoreType,
- InstanceIdentifier<T> path, T data, FutureCallback<Void> callback) {
- WriteTransaction tx = broker.newWriteOnlyTransaction();
- tx.put(datastoreType, path, data, true);
- Futures.addCallback(tx.submit(), callback);
- }
-
- private <T extends DataObject> void syncWrite(LogicalDatastoreType datastoreType,
- InstanceIdentifier<T> path, T data, FutureCallback<Void> callback) {
- WriteTransaction tx = broker.newWriteOnlyTransaction();
- tx.put(datastoreType, path, data, true);
- CheckedFuture<Void, TransactionCommitFailedException> futures = tx.submit();
- try {
- futures.get();
- } catch (InterruptedException | ExecutionException e) {
- LOG.error("Error writing VPN instance to ID info to datastore (path, data) : ({}, {})", path, data);
- throw new RuntimeException(e.getMessage());
- }
- }
-
- protected VpnInstance getVpnInstance(String vpnInstanceName) {
- return VpnUtil.getVpnInstance(broker, vpnInstanceName);
- }
-
protected VpnInstanceOpDataEntry getVpnInstanceOpData(String rd) {
InstanceIdentifier<VpnInstanceOpDataEntry> id = VpnUtil.getVpnInstanceOpDataIdentifier(rd);
- Optional<VpnInstanceOpDataEntry> vpnInstanceOpData = read(LogicalDatastoreType.OPERATIONAL, id);
+ Optional<VpnInstanceOpDataEntry> vpnInstanceOpData =
+ TransactionUtil.read(dataBroker, LogicalDatastoreType.OPERATIONAL, id);
if(vpnInstanceOpData.isPresent()) {
return vpnInstanceOpData.get();
}
return null;
}
-
- private class FibEntriesListener extends AbstractDataChangeListener<VrfEntry> {
-
- public FibEntriesListener() {
- super(VrfEntry.class);
- }
-
- @Override
- protected void remove(InstanceIdentifier<VrfEntry> identifier,
- VrfEntry del) {
- LOG.trace("Remove Fib event - Key : {}, value : {} ", identifier, del);
- final VrfTablesKey key = identifier.firstKeyOf(VrfTables.class, VrfTablesKey.class);
- String rd = key.getRouteDistinguisher();
- Long label = del.getLabel();
- VpnInstanceOpDataEntry vpnInstanceOpData = getVpnInstanceOpData(rd);
- if(vpnInstanceOpData != null) {
- List<Long> routeIds = vpnInstanceOpData.getRouteEntryId();
- if(routeIds == null) {
- LOG.debug("Fib Route entry is empty.");
- return;
- }
- LOG.debug("Removing label from vpn info - {}", label);
- routeIds.remove(label);
- asyncWrite(LogicalDatastoreType.OPERATIONAL, VpnUtil.getVpnInstanceOpDataIdentifier(rd),
- new VpnInstanceOpDataEntryBuilder(vpnInstanceOpData).setRouteEntryId(routeIds).build(), DEFAULT_CALLBACK);
- } else {
- LOG.warn("No VPN Instance found for RD: {}", rd);
- }
- }
-
- @Override
- protected void update(InstanceIdentifier<VrfEntry> identifier,
- VrfEntry original, VrfEntry update) {
- // TODO Auto-generated method stub
-
- }
-
- @Override
- protected void add(InstanceIdentifier<VrfEntry> identifier,
- VrfEntry add) {
- LOG.trace("Add Vrf Entry event - Key : {}, value : {}", identifier, add);
- final VrfTablesKey key = identifier.firstKeyOf(VrfTables.class, VrfTablesKey.class);
- String rd = key.getRouteDistinguisher();
- Long label = add.getLabel();
- VpnInstanceOpDataEntry vpn = getVpnInstanceOpData(rd);
- if(vpn != null) {
- List<Long> routeIds = vpn.getRouteEntryId();
- if(routeIds == null) {
- routeIds = new ArrayList<>();
- }
- LOG.debug("Adding label to vpn info - {}", label);
- routeIds.add(label);
- asyncWrite(LogicalDatastoreType.OPERATIONAL, VpnUtil.getVpnInstanceOpDataIdentifier(rd),
- new VpnInstanceOpDataEntryBuilder(vpn).setRouteEntryId(routeIds).build(), DEFAULT_CALLBACK);
- } else {
- LOG.warn("No VPN Instance found for RD: {}", rd);
- }
- }
- }
}
*/
package org.opendaylight.netvirt.vpnmanager;
-import com.google.common.base.*;
+import com.google.common.base.Function;
+import com.google.common.base.Optional;
+import com.google.common.base.Preconditions;
+import com.google.common.base.Predicate;
+import com.google.common.base.Predicates;
import com.google.common.collect.FluentIterable;
import com.google.common.collect.Iterators;
-import com.google.common.util.concurrent.*;
+import com.google.common.util.concurrent.CheckedFuture;
+import com.google.common.util.concurrent.FutureCallback;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.JdkFutureAdapters;
+import com.google.common.util.concurrent.ListenableFuture;
+import java.math.BigInteger;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.List;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.controller.md.sal.binding.api.DataChangeListener;
+import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService;
+import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
+import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker.DataChangeScope;
+import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
import org.opendaylight.genius.datastoreutils.DataStoreJobCoordinator;
+import org.opendaylight.genius.mdsalutil.AbstractDataChangeListener;
+import org.opendaylight.genius.mdsalutil.ActionInfo;
+import org.opendaylight.genius.mdsalutil.ActionType;
+import org.opendaylight.genius.mdsalutil.FlowEntity;
+import org.opendaylight.genius.mdsalutil.InstructionInfo;
+import org.opendaylight.genius.mdsalutil.InstructionType;
+import org.opendaylight.genius.mdsalutil.MDSALUtil;
+import org.opendaylight.genius.mdsalutil.MatchFieldType;
+import org.opendaylight.genius.mdsalutil.MatchInfo;
+import org.opendaylight.genius.mdsalutil.MetaDataUtil;
+import org.opendaylight.genius.mdsalutil.NwConstants;
+import org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager;
+import org.opendaylight.genius.utils.ServiceIndex;
import org.opendaylight.netvirt.bgpmanager.api.IBgpManager;
-import org.opendaylight.netvirt.fibmanager.api.RouteOrigin;
import org.opendaylight.netvirt.fibmanager.api.IFibManager;
+import org.opendaylight.netvirt.fibmanager.api.RouteOrigin;
import org.opendaylight.netvirt.vpnmanager.utilities.InterfaceUtils;
-
-import org.opendaylight.controller.md.sal.binding.api.*;
-import org.opendaylight.genius.mdsalutil.*;
-import org.opendaylight.genius.mdsalutil.AbstractDataChangeListener;
+import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.VpnAfConfig;
+import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.VpnInstances;
+import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.VpnInterfaces;
import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.af.config.VpnTargets;
import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.af.config.vpntargets.VpnTarget;
+import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.instances.VpnInstance;
+import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.instances.VpnInstanceKey;
+import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.interfaces.VpnInterface;
import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.interfaces.VpnInterfaceBuilder;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
+import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.interfaces.VpnInterfaceKey;
+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.yang.types.rev130715.PhysAddress;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNode;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.Table;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.TableKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.Flow;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.FlowKey;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.TepTypeExternal;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.TepTypeHwvtep;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.TepTypeInternal;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.TunnelsState;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.tunnels_state.StateTunnelList;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.IsDcgwPresentInputBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.IsDcgwPresentOutput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list.Instruction;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.arputil.rev160406.OdlArputilService;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.arputil.rev160406.SendArpResponseInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.arputil.rev160406.SendArpResponseInputBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.IdManagerService;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.OdlInterfaceRpcService;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.servicebinding.rev160406.service.bindings.services.info.BoundServices;
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.NodeBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeKey;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fib.rpc.rev160121.FibRpcService;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.FibEntries;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.LabelRouteMap;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.SubnetRoute;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.SubnetRouteBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.fibentries.VrfTables;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.fibentries.VrfTablesBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.fibentries.VrfTablesKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.label.route.map.LabelRouteInfo;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.label.route.map.LabelRouteInfoBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.label.route.map.LabelRouteInfoKey;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.*;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.PhysAddress;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.vrfentries.VrfEntry;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.vrfentries.VrfEntryBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.AddDpnEvent;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.AddDpnEventBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.Adjacencies;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.NeutronRouterDpns;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.RemoveDpnEvent;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.RemoveDpnEventBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.add.dpn.event.AddEventData;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.add.dpn.event.AddEventDataBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.adjacency.list.Adjacency;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.adjacency.list.AdjacencyBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.adjacency.list.AdjacencyKey;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.to.extraroute.Vpn;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.prefix.to._interface.vpn.ids.Prefixes;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.neutron.router.dpns.RouterDpnList;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.neutron.router.dpns.RouterDpnListBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.neutron.router.dpns.RouterDpnListKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.remove.dpn.event.RemoveEventData;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.remove.dpn.event.RemoveEventDataBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data.VpnInstanceOpDataEntry;
-
-import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data
- .VpnInstanceOpDataEntryBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data.vpn.instance.op.data.entry.VpnToDpnList;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data.vpn.instance.op.data.entry.VpnToDpnListBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data.vpn.instance.op.data.entry.vpn.to.dpn.list.IpAddresses;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data.vpn.instance.op.data.entry.vpn.to.dpn.list.VpnInterfacesBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data.vpn.instance.op.data.entry.vpn.to.dpn.list.VpnInterfacesKey;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list.Instruction;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.FibEntries;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.fibentries.VrfTables;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.fibentries.VrfTablesBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.fibentries.VrfTablesKey;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.vrfentries.VrfEntry;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.vrfentries.VrfEntryBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.arputil.rev160406.OdlArputilService;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.arputil.rev160406.SendArpResponseInput;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.arputil.rev160406.SendArpResponseInputBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.IdManagerService;
-
-import java.math.BigInteger;
-import java.util.Collection;
-import java.util.List;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Iterator;
-import java.util.concurrent.*;
-
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.OdlInterfaceRpcService;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.servicebinding.rev160406.service.bindings.services.info.BoundServices;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.ItmRpcService;
-import org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager;
-import org.opendaylight.genius.utils.ServiceIndex;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.NeutronvpnService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.neutron.vpn.portip.port.data.VpnPortipToPort;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.netvirt.inter.vpn.link.rev160311.inter.vpn.links.InterVpnLink;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.InstanceIdentifierBuilder;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker.DataChangeScope;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.InterfacesState;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.adjacency.list.Adjacency;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.adjacency.list.AdjacencyBuilder;
-import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.VpnInterfaces;
-import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.VpnAfConfig;
-import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.VpnInstances;
-import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.instances.VpnInstance;
-import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.instances.VpnInstanceKey;
-import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.interfaces.VpnInterface;
-import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.interfaces.VpnInterfaceKey;
import org.opendaylight.yangtools.yang.common.RpcError;
import org.opendaylight.yangtools.yang.common.RpcResult;
import org.slf4j.Logger;
public class VpnInterfaceManager extends AbstractDataChangeListener<VpnInterface> implements AutoCloseable {
private static final Logger LOG = LoggerFactory.getLogger(VpnInterfaceManager.class);
- private ListenerRegistration<DataChangeListener> listenerRegistration, opListenerRegistration;
- private final DataBroker broker;
+ private ListenerRegistration<DataChangeListener> listenerRegistration;
+ private final DataBroker dataBroker;
private final IBgpManager bgpManager;
- private IFibManager fibManager;
- private IMdsalApiManager mdsalManager;
- private OdlInterfaceRpcService ifaceMgrRpcService;
- private IdManagerService idManager;
- private OdlArputilService arpManager;
- private NeutronvpnService neuService;
- private VpnSubnetRouteHandler vpnSubnetRouteHandler;
+ private final IFibManager fibManager;
+ private final IMdsalApiManager mdsalManager;
+ private final IdManagerService idManager;
+ private final OdlArputilService arpManager;
+ private final OdlInterfaceRpcService ifaceMgrRpcService;
+ private final NotificationPublishService notificationPublishService;
private ConcurrentHashMap<String, Runnable> vpnIntfMap = new ConcurrentHashMap<String, Runnable>();
private ExecutorService executorService = Executors.newSingleThreadExecutor();
- private InterfaceStateChangeListener interfaceListener;
- private SubnetRouteInterfaceStateChangeListener subnetRouteInterfaceListener;
- private TunnelInterfaceStateListener tunnelInterfaceStateListener;
- private VpnInterfaceOpListener vpnInterfaceOpListener;
- private ArpNotificationHandler arpNotificationHandler;
- private DpnInVpnChangeListener dpnInVpnChangeListener;
- private NotificationPublishService notificationPublishService;
- private FibRpcService fibService;
-
- /**
- * Responsible for listening to data change related to VPN Interface
- * Bind VPN Service on the interface and informs the BGP service
- *
- * @param db - dataBroker service reference
- * @param bgpManager Used to advertise routes to the BGP Router
- * @param notificationService Used to subscribe to notification events
- */
- public VpnInterfaceManager(final DataBroker db, final IBgpManager bgpManager, NotificationService notificationService) {
+
+ public VpnInterfaceManager(final DataBroker dataBroker,
+ final IBgpManager bgpManager,
+ final OdlArputilService arpManager,
+ final IdManagerService idManager,
+ final IMdsalApiManager mdsalManager,
+ final IFibManager fibManager,
+ final OdlInterfaceRpcService ifaceMgrRpcService,
+ final NotificationPublishService notificationPublishService) {
super(VpnInterface.class);
- broker = db;
+ this.dataBroker = dataBroker;
this.bgpManager = bgpManager;
- interfaceListener = new InterfaceStateChangeListener(db, this);
- subnetRouteInterfaceListener = new SubnetRouteInterfaceStateChangeListener(db, this);
- vpnInterfaceOpListener = new VpnInterfaceOpListener();
- arpNotificationHandler = new ArpNotificationHandler(this, broker);
- vpnSubnetRouteHandler = new VpnSubnetRouteHandler(broker, bgpManager, this);
- dpnInVpnChangeListener = new DpnInVpnChangeListener(broker);
- notificationService.registerNotificationListener(vpnSubnetRouteHandler);
- notificationService.registerNotificationListener(arpNotificationHandler);
- notificationService.registerNotificationListener(dpnInVpnChangeListener);
- registerListener(db);
- }
-
- public void setMdsalManager(IMdsalApiManager mdsalManager) {
+ this.arpManager = arpManager;
+ this.idManager = idManager;
this.mdsalManager = mdsalManager;
- }
-
- public void setIfaceMgrRpcService(OdlInterfaceRpcService ifMgrRpcService) {
- this.ifaceMgrRpcService = ifMgrRpcService;
- interfaceListener.setIfaceMgrRpcService(ifMgrRpcService);
- }
-
- public void setFibManager(IFibManager fibManager) {
this.fibManager = fibManager;
- }
-
- public IFibManager getFibManager() {
- return this.fibManager;
- }
-
-
- public void setIdManager(IdManagerService idManager) {
- this.idManager = idManager;
- vpnSubnetRouteHandler.setIdManager(idManager);
- }
-
- public void setArpManager(OdlArputilService arpManager) {
- this.arpManager = arpManager;
- }
-
- void setNotificationPublishService(NotificationPublishService notificationPublishService) {
+ this.ifaceMgrRpcService = ifaceMgrRpcService;
this.notificationPublishService = notificationPublishService;
}
- public void setNeutronvpnManager(NeutronvpnService neuService) { this.neuService = neuService; }
-
- public void setFibRpcService(FibRpcService fibService) {
- this.fibService = fibService;
- }
-
- public FibRpcService getFibRpcService() {
- return fibService;
+ public void start() {
+ LOG.info("{} start", getClass().getSimpleName());
+ listenerRegistration = dataBroker.registerDataChangeListener(LogicalDatastoreType.CONFIGURATION,
+ getWildCardPath(), this, DataChangeScope.SUBTREE);
}
- public VpnSubnetRouteHandler getVpnSubnetRouteHandler() {
- return this.vpnSubnetRouteHandler;
+ private InstanceIdentifier<VpnInterface> getWildCardPath() {
+ return InstanceIdentifier.create(VpnInterfaces.class).child(VpnInterface.class);
}
@Override
public void close() throws Exception {
if (listenerRegistration != null) {
- try {
- listenerRegistration.close();
- opListenerRegistration.close();
- } catch (final Exception e) {
- LOG.error("Error when cleaning up DataChangeListener.", e);
- }
+ listenerRegistration.close();
listenerRegistration = null;
- opListenerRegistration = null;
- }
- LOG.info("VPN Interface Manager Closed");
- }
-
- private void registerListener(final DataBroker db) {
- try {
- listenerRegistration = db.registerDataChangeListener(LogicalDatastoreType.CONFIGURATION,
- getWildCardPath(), VpnInterfaceManager.this, DataChangeScope.SUBTREE);
- opListenerRegistration = db.registerDataChangeListener(LogicalDatastoreType.OPERATIONAL,
- getWildCardPath(), vpnInterfaceOpListener, DataChangeScope.SUBTREE);
- } catch (final Exception e) {
- LOG.error("VPN Service DataChange listener registration fail!", e);
- throw new IllegalStateException("VPN Service registration Listener failed.", e);
}
+ LOG.info("{} close", getClass().getSimpleName());
}
private InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface> getInterfaceListenerPath() {
final String interfaceName = key.getName();
org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface interfaceState =
- InterfaceUtils.getInterfaceStateFromOperDS(broker, interfaceName);
+ InterfaceUtils.getInterfaceStateFromOperDS(dataBroker, interfaceName);
if(interfaceState != null){
try{
final BigInteger dpnId = InterfaceUtils.getDpIdFromInterface(interfaceState);
new Callable<List<ListenableFuture<Void>>>() {
@Override
public List<ListenableFuture<Void>> call() throws Exception {
- WriteTransaction writeConfigTxn = broker.newWriteOnlyTransaction();
- WriteTransaction writeOperTxn = broker.newWriteOnlyTransaction();
- WriteTransaction writeInvTxn = broker.newWriteOnlyTransaction();
+ WriteTransaction writeConfigTxn = dataBroker.newWriteOnlyTransaction();
+ WriteTransaction writeOperTxn = dataBroker.newWriteOnlyTransaction();
+ WriteTransaction writeInvTxn = dataBroker.newWriteOnlyTransaction();
processVpnInterfaceUp(dpnId, vpnInterface, ifIndex, false, writeConfigTxn, writeOperTxn, writeInvTxn);
CheckedFuture<Void, TransactionCommitFailedException> futures = writeOperTxn.submit();
try {
try {
futures.get();
} catch (InterruptedException | ExecutionException e) {
- LOG.error("Error adding config data for interface {} to vpn {} on dpn {}", interfaceName,
+ LOG.error("Error adding config data for interface {} to vpn {} on dpn {}", interfaceName,
vpnInterface.getVpnInstanceName(), dpnId);
- throw new RuntimeException(e.getMessage());
- }
- futures = writeInvTxn.submit();
- try {
- futures.get();
- } catch (InterruptedException | ExecutionException e) {
- LOG.error("Error adding inventory/flow data for interface {} to vpn {} on dpn {}", interfaceName,
+ throw new RuntimeException(e.getMessage());
+ }
+ futures = writeInvTxn.submit();
+ try {
+ futures.get();
+ } catch (InterruptedException | ExecutionException e) {
+ LOG.error("Error adding inventory/flow data for interface {} to vpn {} on dpn {}", interfaceName,
vpnInterface.getVpnInstanceName(), dpnId);
- throw new RuntimeException(e.getMessage());
- }
- return null;
+ throw new RuntimeException(e.getMessage());
+ }
+ return null;
}
});
}catch (Exception e){
final int lPortTag, boolean isInterfaceUp,
WriteTransaction writeConfigTxn,
WriteTransaction writeOperTxn,
- WriteTransaction writeInvTxn) {
+ WriteTransaction writeInvTxn) {
final String interfaceName = vpnInterface.getName();
if (!isInterfaceUp) {
final String vpnName = vpnInterface.getVpnInstanceName();
LOG.info("Binding vpn service to interface {} ", interfaceName);
- long vpnId = VpnUtil.getVpnId(broker, vpnName);
+ long vpnId = VpnUtil.getVpnId(dataBroker, vpnName);
if (vpnId == VpnConstants.INVALID_ID) {
LOG.trace("VpnInstance to VPNId mapping is not yet available, bailing out now.");
return;
}
boolean waitForVpnInterfaceOpRemoval = false;
- VpnInterface opVpnInterface = VpnUtil.getOperationalVpnInterface(broker, vpnInterface.getName());
+ VpnInterface opVpnInterface = VpnUtil.getOperationalVpnInterface(dataBroker, vpnInterface.getName());
if (opVpnInterface != null ) {
String opVpnName = opVpnInterface.getVpnInstanceName();
String primaryInterfaceIp = null;
// If so, we have to process ADD, as this might be a DPN Restart with Remove and Add triggered
// back to back
// However, if the primary VRF Entry for this VPNInterface exists, please continue bailing out !
- List<Adjacency> adjs = VpnUtil.getAdjacenciesForVpnInterfaceFromConfig(broker, interfaceName);
+ List<Adjacency> adjs = VpnUtil.getAdjacenciesForVpnInterfaceFromConfig(dataBroker, interfaceName);
if (adjs == null) {
LOG.info("VPN Interface {} addition failed as adjacencies for this vpn interface could not be obtained", interfaceName);
return;
}
// Get the rd of the vpn instance
String rd = getRouteDistinguisher(opVpnName);
- rd = (rd == null) ? opVpnName : rd;
- VrfEntry vrf = VpnUtil.getVrfEntry(broker, rd, primaryInterfaceIp);
+ rd = (rd == null) ? opVpnName : rd;
+ VrfEntry vrf = VpnUtil.getVrfEntry(dataBroker, rd, primaryInterfaceIp);
if (vrf != null) {
LOG.info("VPN Interface {} already provisioned , bailing out from here.", interfaceName);
return;
vpnIntfMap.remove(interfaceName);
}
- opVpnInterface = VpnUtil.getOperationalVpnInterface(broker, interfaceName);
+ opVpnInterface = VpnUtil.getOperationalVpnInterface(dataBroker, interfaceName);
if (opVpnInterface != null) {
LOG.error("VPN Interface {} removal by FIB did not complete on time, bailing addition ...", interfaceName);
return;
// public List<ListenableFuture<Void>> call() throws Exception {
// // If another renderer(for eg : CSS) needs to be supported, check can be performed here
// // to call the respective helpers.
-// WriteTransaction writeTxn = broker.newWriteOnlyTransaction();
+// WriteTransaction writeTxn = dataBroker.newWriteOnlyTransaction();
// updateDpnDbs(dpnId, vpnName, interfaceName, addToDpn, writeTxn);
// List<ListenableFuture<Void>> futures = new ArrayList<>();
// futures.add(writeTxn.submit());
// */
// @Override
// public void onSuccess(List<Void> voids) {
-// WriteTransaction writeTxn = broker.newWriteOnlyTransaction();
+// WriteTransaction writeTxn = dataBroker.newWriteOnlyTransaction();
// bindService(dpnId, vpnName, interfaceName, lPortTag, writeTxn);
// processVpnInterfaceAdjacencies(dpnId, vpnName, interfaceName, writeTxn);
// writeTxn.submit();
VpnInterface intf) {
//Read NextHops
InstanceIdentifier<Adjacencies> path = identifier.augmentation(Adjacencies.class);
- Optional<Adjacencies> adjacencies = VpnUtil.read(broker, LogicalDatastoreType.OPERATIONAL, path);
+ Optional<Adjacencies> adjacencies = VpnUtil.read(dataBroker, LogicalDatastoreType.OPERATIONAL, path);
- String rd = VpnUtil.getVpnRd(broker, intf.getVpnInstanceName());
+ String rd = VpnUtil.getVpnRd(dataBroker, intf.getVpnInstanceName());
if (rd == null) {
LOG.error("advertiseAdjacenciesForVpnFromBgp: Unable to recover rd for interface {} in vpn {}",
intf.getName(), intf.getVpnInstanceName());
LOG.info("advertiseAdjacenciesForVpnToBgp: Advertising interface {} in vpn {} with rd {} ", intf.getName(),
intf.getVpnInstanceName(), rd);
- String nextHopIp = InterfaceUtils.getEndpointIpAddressForDPN(broker, dpnId);
+ String nextHopIp = InterfaceUtils.getEndpointIpAddressForDPN(dataBroker, dpnId);
if (nextHopIp == null){
LOG.trace("advertiseAdjacenciesForVpnToBgp: NextHop for interface {} is null, returning", intf.getName());
return;
private void withdrawAdjacenciesForVpnFromBgp(final InstanceIdentifier<VpnInterface> identifier, VpnInterface intf) {
//Read NextHops
InstanceIdentifier<Adjacencies> path = identifier.augmentation(Adjacencies.class);
- Optional<Adjacencies> adjacencies = VpnUtil.read(broker, LogicalDatastoreType.OPERATIONAL, path);
+ Optional<Adjacencies> adjacencies = VpnUtil.read(dataBroker, LogicalDatastoreType.OPERATIONAL, path);
- String rd = VpnUtil.getVpnRd(broker, intf.getVpnInstanceName());
+ String rd = VpnUtil.getVpnRd(dataBroker, intf.getVpnInstanceName());
if (rd == null) {
LOG.error("withdrawAdjacenciesForVpnFromBgp: Unable to recover rd for interface {} in vpn {}",
intf.getName(), intf.getVpnInstanceName());
}
}
- private void updateVpnToDpnMapping(BigInteger dpId, String vpnName, String interfaceName, boolean add) {
- long vpnId = VpnUtil.getVpnId(broker, vpnName);
+ public void updateVpnToDpnMapping(BigInteger dpId, String vpnName, String interfaceName, boolean add) {
+ long vpnId = VpnUtil.getVpnId(dataBroker, vpnName);
if (dpId == null) {
dpId = InterfaceUtils.getDpnForInterface(ifaceMgrRpcService, interfaceName);
}
private void bindService(BigInteger dpId, String vpnInstanceName, String vpnInterfaceName, int lPortTag,
WriteTransaction writeConfigTxn, WriteTransaction writeInvTxn) {
int priority = VpnConstants.DEFAULT_FLOW_PRIORITY;
- long vpnId = VpnUtil.getVpnId(broker, vpnInstanceName);
+ long vpnId = VpnUtil.getVpnId(dataBroker, vpnInstanceName);
int instructionKey = 0;
List<Instruction> instructions = new ArrayList<Instruction>();
BoundServices
serviceInfo =
InterfaceUtils.getBoundServices(String.format("%s.%s.%s", "vpn",vpnInstanceName, vpnInterfaceName),
- l3vpn_service_index, priority,
+ l3vpn_service_index, priority,
NwConstants.COOKIE_VM_INGRESS_TABLE, instructions);
writeConfigTxn.put(LogicalDatastoreType.CONFIGURATION,
InterfaceUtils.buildServiceId(vpnInterfaceName, l3vpn_service_index), serviceInfo, true);
InstanceIdentifier<VpnInterface> identifier = VpnUtil.getVpnInterfaceIdentifier(interfaceName);
// Read NextHops
InstanceIdentifier<Adjacencies> path = identifier.augmentation(Adjacencies.class);
- Optional<Adjacencies> adjacencies = VpnUtil.read(broker, LogicalDatastoreType.CONFIGURATION, path);
+ Optional<Adjacencies> adjacencies = VpnUtil.read(dataBroker, LogicalDatastoreType.CONFIGURATION, path);
if (adjacencies.isPresent()) {
List<Adjacency> nextHops = adjacencies.get().getAdjacency();
// Get the rd of the vpn instance
String rd = getRouteDistinguisher(vpnName);
- String nextHopIp = InterfaceUtils.getEndpointIpAddressForDPN(broker, dpnId);
+ String nextHopIp = InterfaceUtils.getEndpointIpAddressForDPN(dataBroker, dpnId);
if (nextHopIp == null){
LOG.error("NextHop for interface {} is null", interfaceName);
return;
writeOperTxn.merge(
LogicalDatastoreType.OPERATIONAL,
VpnUtil.getPrefixToInterfaceIdentifier(
- VpnUtil.getVpnId(broker, vpnName), prefix),
+ VpnUtil.getVpnId(dataBroker, vpnName), prefix),
VpnUtil.getPrefixToInterface(dpnId, interfaceName, prefix), true);
} else {
//Extra route adjacency
VpnInterface opInterface = VpnUtil.getVpnInterface(interfaceName, vpnName, aug, dpnId, Boolean.FALSE);
InstanceIdentifier<VpnInterface> interfaceId = VpnUtil.getVpnInterfaceIdentifier(interfaceName);
writeOperTxn.put(LogicalDatastoreType.OPERATIONAL, interfaceId, opInterface, true);
- long vpnId = VpnUtil.getVpnId(broker, vpnName);
+ long vpnId = VpnUtil.getVpnId(dataBroker, vpnName);
for (Adjacency nextHop : aug.getAdjacency()) {
long label = nextHop.getLabel();
String vpnRd = vpn.getIpv4Family().getRouteDistinguisher();
if (vpnRd != null) {
LOG.debug("Exporting route with rd {} prefix {} nexthop {} label {} to VPN {}", vpnRd, nextHop.getIpAddress(), nextHopIp, label, vpn);
- fibManager.addOrUpdateFibEntry(broker, vpnRd, nextHop.getIpAddress(), Arrays.asList(nextHopIp), (int) label,
+ fibManager.addOrUpdateFibEntry(dataBroker, vpnRd, nextHop.getIpAddress(), Arrays.asList(nextHopIp), (int) label,
RouteOrigin.SELF_IMPORTED, writeConfigTxn);
}
}
} else {
// ### add FIB route directly
- fibManager.addOrUpdateFibEntry(broker, vpnName, nextHop.getIpAddress(), Arrays.asList(nextHopIp),
+ fibManager.addOrUpdateFibEntry(dataBroker, vpnName, nextHop.getIpAddress(), Arrays.asList(nextHopIp),
(int) label, RouteOrigin.STATIC, writeConfigTxn);
}
}
InstanceIdentifier<VpnInstance> id = InstanceIdentifier.builder(VpnInstances.class)
.child(VpnInstance.class, new VpnInstanceKey(vpnName)).build();
- Optional<VpnInstance> optVpnInstance = VpnUtil.read(broker, LogicalDatastoreType.CONFIGURATION, id);
+ Optional<VpnInstance> optVpnInstance = VpnUtil.read(dataBroker, LogicalDatastoreType.CONFIGURATION, id);
final VpnInstance vpnInstance;
if (optVpnInstance.isPresent()) {
vpnInstance = optVpnInstance.get();
}
};
- vpnsToImportRoute = FluentIterable.from(VpnUtil.getAllVpnInstance(broker)).
+ vpnsToImportRoute = FluentIterable.from(VpnUtil.getAllVpnInstance(dataBroker)).
filter(excludeVpn).
filter(matchRTs).toList();
return vpnsToImportRoute;
InstanceIdentifier<VpnInstance> id = InstanceIdentifier.builder(VpnInstances.class)
.child(VpnInstance.class, new VpnInstanceKey(vpnName)).build();
- Optional<VpnInstance> optVpnInstance = VpnUtil.read(broker, LogicalDatastoreType.CONFIGURATION, id);
+ Optional<VpnInstance> optVpnInstance = VpnUtil.read(dataBroker, LogicalDatastoreType.CONFIGURATION, id);
final VpnInstance vpnInstance;
if (optVpnInstance.isPresent()) {
vpnInstance = optVpnInstance.get();
}
};
- vpnsToExportRoute = FluentIterable.from(VpnUtil.getAllVpnInstance(broker)).
+ vpnsToExportRoute = FluentIterable.from(VpnUtil.getAllVpnInstance(dataBroker)).
filter(excludeVpn).
filter(matchRTs).toList();
return vpnsToExportRoute;
private String getRouteDistinguisher(String vpnName) {
InstanceIdentifier<VpnInstance> id = InstanceIdentifier.builder(VpnInstances.class)
.child(VpnInstance.class, new VpnInstanceKey(vpnName)).build();
- Optional<VpnInstance> vpnInstance = VpnUtil.read(broker, LogicalDatastoreType.CONFIGURATION, id);
+ Optional<VpnInstance> vpnInstance = VpnUtil.read(dataBroker, LogicalDatastoreType.CONFIGURATION, id);
String rd = "";
if(vpnInstance.isPresent()) {
VpnInstance instance = vpnInstance.get();
String routeDistinguisher = getRouteDistinguisher(vpnName);
String rd = (routeDistinguisher == null) ? vpnName : routeDistinguisher;
Boolean newDpnOnVpn = Boolean.FALSE;
-
+
synchronized (vpnName.intern()) {
- WriteTransaction writeTxn = broker.newWriteOnlyTransaction();
+ WriteTransaction writeTxn = dataBroker.newWriteOnlyTransaction();
InstanceIdentifier<VpnToDpnList> id = VpnUtil.getVpnToDpnListIdentifier(rd, dpnId);
- Optional<VpnToDpnList> dpnInVpn = VpnUtil.read(broker, LogicalDatastoreType.OPERATIONAL, id);
+ Optional<VpnToDpnList> dpnInVpn = VpnUtil.read(dataBroker, LogicalDatastoreType.OPERATIONAL, id);
org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data.vpn.instance.op.data
.entry.vpn.to.dpn.list.VpnInterfaces
vpnInterface = new VpnInterfacesBuilder().setInterfaceName(intfName).build();
.op.data.vpn.instance.op.data.entry.vpn.to.dpn.list.VpnInterfaces.class,
new VpnInterfacesKey(intfName)), vpnInterface, true);
} else {
- VpnUtil.syncWrite(broker, LogicalDatastoreType.OPERATIONAL, id.child(
+ VpnUtil.syncWrite(dataBroker, LogicalDatastoreType.OPERATIONAL, id.child(
org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance
.op.data.vpn.instance.op.data.entry.vpn.to.dpn.list.VpnInterfaces.class,
new VpnInterfacesKey(intfName)), vpnInterface);
if (writeTxn != null) {
writeTxn.put(LogicalDatastoreType.OPERATIONAL, id, vpnToDpnListBuilder.build(), true);
} else {
- VpnUtil.syncWrite(broker, LogicalDatastoreType.OPERATIONAL, id, vpnToDpnListBuilder.build());
+ VpnUtil.syncWrite(dataBroker, LogicalDatastoreType.OPERATIONAL, id, vpnToDpnListBuilder.build());
}
newDpnOnVpn = Boolean.TRUE;
}
Boolean lastDpnOnVpn = Boolean.FALSE;
synchronized (vpnName.intern()) {
- String rd = VpnUtil.getVpnRd(broker, vpnName);
+ String rd = VpnUtil.getVpnRd(dataBroker, vpnName);
InstanceIdentifier<VpnToDpnList> id = VpnUtil.getVpnToDpnListIdentifier(rd, dpnId);
- Optional<VpnToDpnList> dpnInVpn = VpnUtil.read(broker, LogicalDatastoreType.OPERATIONAL, id);
- WriteTransaction writeTxn = broker.newWriteOnlyTransaction();
+ Optional<VpnToDpnList> dpnInVpn = VpnUtil.read(dataBroker, LogicalDatastoreType.OPERATIONAL, id);
+ WriteTransaction writeTxn = dataBroker.newWriteOnlyTransaction();
if (dpnInVpn.isPresent()) {
List<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data
.vpn.instance.op.data.entry.vpn.to.dpn.list.VpnInterfaces> vpnInterfaces = dpnInVpn.get().getVpnInterfaces();
if (writeTxn != null) {
writeTxn.put(LogicalDatastoreType.OPERATIONAL, id, dpnInVpnBuilder.build(), true);
} else {
- VpnUtil.syncWrite(broker, LogicalDatastoreType.OPERATIONAL, id, dpnInVpnBuilder.build());
+ VpnUtil.syncWrite(dataBroker, LogicalDatastoreType.OPERATIONAL, id, dpnInVpnBuilder.build());
}
lastDpnOnVpn = Boolean.TRUE;
} else {
.vpn.instance.op.data.entry.vpn.to.dpn.list.VpnInterfaces.class,
new VpnInterfacesKey(intfName)));
} else {
- VpnUtil.delete(broker, LogicalDatastoreType.OPERATIONAL, id.child(
+ VpnUtil.delete(dataBroker, LogicalDatastoreType.OPERATIONAL, id.child(
org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data
.vpn.instance.op.data.entry.vpn.to.dpn.list.VpnInterfaces.class,
new VpnInterfacesKey(intfName)), VpnUtil.DEFAULT_CALLBACK);
List<VpnInstance> vpnsToExportRoute = getVpnsExportingMyRoute(vpnName);
for (VpnInstance vpn : vpnsToExportRoute) {
String rd = vpn.getIpv4Family().getRouteDistinguisher();
- List<VrfEntry> vrfEntries = VpnUtil.getAllVrfEntries(broker, vpn.getIpv4Family().getRouteDistinguisher());
- WriteTransaction writeConfigTxn = broker.newWriteOnlyTransaction();
+ List<VrfEntry> vrfEntries = VpnUtil.getAllVrfEntries(dataBroker, vpn.getIpv4Family().getRouteDistinguisher());
+ WriteTransaction writeConfigTxn = dataBroker.newWriteOnlyTransaction();
if (vrfEntries != null) {
for (VrfEntry vrfEntry : vrfEntries) {
try {
importSubnetRouteForNewVpn(rd, prefix, nh, (int)label, route, writeConfigTxn);
} else {
LOG.info("Importing fib entry rd {} prefix {} nexthop {} label {} to vpn {}", vpnRd, prefix, nh, label, vpn.getVpnInstanceName());
- fibManager.addOrUpdateFibEntry(broker, vpnRd, prefix, Arrays.asList(nh), (int)label,
+ fibManager.addOrUpdateFibEntry(dataBroker, vpnRd, prefix, Arrays.asList(nh), (int)label,
RouteOrigin.SELF_IMPORTED, writeConfigTxn);
}
}
private void addPrefixToBGP(String rd, String prefix, String nextHopIp, long label, WriteTransaction writeConfigTxn) {
try {
LOG.info("ADD: Adding Fib entry rd {} prefix {} nextHop {} label {}", rd, prefix, nextHopIp, label);
- fibManager.addOrUpdateFibEntry(broker, rd, prefix, Arrays.asList(nextHopIp), (int)label, RouteOrigin.STATIC, writeConfigTxn);
+ fibManager.addOrUpdateFibEntry(dataBroker, rd, prefix, Arrays.asList(nextHopIp), (int)label, RouteOrigin.STATIC, writeConfigTxn);
bgpManager.advertisePrefix(rd, prefix, Arrays.asList(nextHopIp), (int)label);
LOG.info("ADD: Added Fib entry rd {} prefix {} nextHop {} label {}", rd, prefix, nextHopIp, label);
} catch(Exception e) {
}
}
-
- private InstanceIdentifier<VpnInterface> getWildCardPath() {
- return InstanceIdentifier.create(VpnInterfaces.class).child(VpnInterface.class);
- }
-
@Override
public void remove( InstanceIdentifier<VpnInterface> identifier, VpnInterface vpnInterface) {
LOG.trace("Remove event - key: {}, value: {}" ,identifier, vpnInterface );
final String interfaceName = key.getName();
InstanceIdentifier<VpnInterface> interfaceId = VpnUtil.getVpnInterfaceIdentifier(interfaceName);
- final Optional<VpnInterface> optVpnInterface = VpnUtil.read(broker, LogicalDatastoreType.OPERATIONAL, interfaceId);
+ final Optional<VpnInterface> optVpnInterface = VpnUtil.read(dataBroker, LogicalDatastoreType.OPERATIONAL, interfaceId);
org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface interfaceState =
- InterfaceUtils.getInterfaceStateFromOperDS(broker, interfaceName);
+ InterfaceUtils.getInterfaceStateFromOperDS(dataBroker, interfaceName);
if (optVpnInterface.isPresent()){
BigInteger dpnId = BigInteger.ZERO;
Boolean dpnIdRetrieved = Boolean.FALSE;
new Callable<List<ListenableFuture<Void>>>() {
@Override
public List<ListenableFuture<Void>> call() throws Exception {
- WriteTransaction writeConfigTxn = broker.newWriteOnlyTransaction();
- WriteTransaction writeOperTxn = broker.newWriteOnlyTransaction();
- WriteTransaction writeInvTxn = broker.newWriteOnlyTransaction();
+ WriteTransaction writeConfigTxn = dataBroker.newWriteOnlyTransaction();
+ WriteTransaction writeOperTxn = dataBroker.newWriteOnlyTransaction();
+ WriteTransaction writeInvTxn = dataBroker.newWriteOnlyTransaction();
processVpnInterfaceDown(dpId, interfaceName, ifIndex, false, true, writeConfigTxn, writeOperTxn, writeInvTxn);
CheckedFuture<Void, TransactionCommitFailedException> futures = writeOperTxn.submit();
try {
LOG.error("Error removing Inventory/Flow data for interface {} from vpn {} on dpn {}", interfaceName,
vpnOpInterface.getVpnInstanceName(), dpId);
throw new RuntimeException(e.getMessage());
- }
+ }
return null;
}
});
}
protected void processVpnInterfaceDown(BigInteger dpId,
- String interfaceName,
- int lPortTag,
- boolean isInterfaceStateDown,
+ String interfaceName,
+ int lPortTag,
+ boolean isInterfaceStateDown,
boolean isConfigRemoval,
- WriteTransaction writeConfigTxn,
- WriteTransaction writeOperTxn,
- WriteTransaction writeInvTxn) {
+ WriteTransaction writeConfigTxn,
+ WriteTransaction writeOperTxn,
+ WriteTransaction writeInvTxn) {
InstanceIdentifier<VpnInterface> identifier = VpnUtil.getVpnInterfaceIdentifier(interfaceName);
if (!isInterfaceStateDown) {
- VpnInterface vpnInterface = VpnUtil.getOperationalVpnInterface(broker, interfaceName);
+ VpnInterface vpnInterface = VpnUtil.getOperationalVpnInterface(dataBroker, interfaceName);
if(vpnInterface == null){
LOG.info("Unable to process delete/down for interface {} as it is not available in operational data store", interfaceName);
return;
}else{
final String vpnName = vpnInterface.getVpnInstanceName();
if(!vpnInterface.isScheduledForRemove()){
- VpnUtil.scheduleVpnInterfaceForRemoval(broker, interfaceName, dpId, vpnName, Boolean.TRUE, writeOperTxn);
+ VpnUtil.scheduleVpnInterfaceForRemoval(dataBroker, interfaceName, dpId, vpnName, Boolean.TRUE, writeOperTxn);
removeAdjacenciesFromVpn(dpId, interfaceName, vpnInterface.getVpnInstanceName(), writeConfigTxn);
LOG.info("Unbinding vpn service from interface {} ", interfaceName);
unbindService(dpId, vpnName, interfaceName, lPortTag, isInterfaceStateDown, isConfigRemoval, writeConfigTxn, writeInvTxn);
} else {
// Interface is retained in the DPN, but its Link Down.
// Only withdraw the prefixes for this interface from BGP
- VpnInterface vpnInterface = VpnUtil.getOperationalVpnInterface(broker, interfaceName);
+ VpnInterface vpnInterface = VpnUtil.getOperationalVpnInterface(dataBroker, interfaceName);
if(vpnInterface == null){
LOG.info("Unable to withdraw adjacencies for vpn interface {} from BGP as it is not available in operational data store", interfaceName);
return;
//Read NextHops
InstanceIdentifier<VpnInterface> identifier = VpnUtil.getVpnInterfaceIdentifier(interfaceName);
InstanceIdentifier<Adjacencies> path = identifier.augmentation(Adjacencies.class);
- Optional<Adjacencies> adjacencies = VpnUtil.read(broker, LogicalDatastoreType.OPERATIONAL, path);
+ Optional<Adjacencies> adjacencies = VpnUtil.read(dataBroker, LogicalDatastoreType.OPERATIONAL, path);
- String rd = VpnUtil.getVpnRd(broker, vpnName);
+ String rd = VpnUtil.getVpnRd(dataBroker, vpnName);
LOG.trace("removeAdjacenciesFromVpn: For interface {} RD recovered for vpn {} as rd {}", interfaceName,
vpnName, rd);
if (adjacencies.isPresent()) {
List<String> nhList = new ArrayList<String>();
if (nextHop.getMacAddress() == null || nextHop.getMacAddress().isEmpty()) {
// This is either an extra-route (or) a learned IP via subnet-route
- String nextHopIp = InterfaceUtils.getEndpointIpAddressForDPN(broker, dpnId);
+ String nextHopIp = InterfaceUtils.getEndpointIpAddressForDPN(dataBroker, dpnId);
if (nextHopIp == null || nextHopIp.isEmpty()) {
LOG.error("Unable to obtain nextHopIp for extra-route/learned-route in rd {} prefix {}",
rd, nextHop.getIpAddress());
//this is an internal vpn - the rd is assigned to the vpn instance name;
//remove from FIB directly
for(String nh : nhList) {
- fibManager.removeOrUpdateFibEntry(broker, vpnName, nextHop.getIpAddress(), nh, writeConfigTxn);
+ fibManager.removeOrUpdateFibEntry(dataBroker, vpnName, nextHop.getIpAddress(), nh, writeConfigTxn);
}
} else {
List<VpnInstance> vpnsToImportRoute = getVpnsImportingMyRoute(vpnName);
String vpnRd = vpn.getIpv4Family().getRouteDistinguisher();
if (vpnRd != null) {
LOG.info("Removing Exported route with rd {} prefix {} from VPN {}", vpnRd, nextHop.getIpAddress(), vpn.getVpnInstanceName());
- fibManager.removeOrUpdateFibEntry(broker, vpnRd, nextHop.getIpAddress(), nh, writeConfigTxn);
+ fibManager.removeOrUpdateFibEntry(dataBroker, vpnRd, nextHop.getIpAddress(), nh, writeConfigTxn);
}
}
}
}
String ip = nextHop.getIpAddress().split("/")[0];
- VpnPortipToPort vpnPortipToPort = VpnUtil.getNeutronPortFromVpnPortFixedIp(broker,
+ VpnPortipToPort vpnPortipToPort = VpnUtil.getNeutronPortFromVpnPortFixedIp(dataBroker,
vpnName, ip);
if (vpnPortipToPort != null && !vpnPortipToPort.isConfig()) {
LOG.trace("VpnInterfaceManager removing adjacency for Interface {} ip {} from VpnPortData Entry",
vpnPortipToPort.getPortName(),ip);
- VpnUtil.removeVpnPortFixedIpToPort(broker, vpnName, ip);
+ VpnUtil.removeVpnPortFixedIpToPort(dataBroker, vpnName, ip);
}
}
}
InterfaceUtils.buildServiceId(vpnInterfaceName,
l3vpn_service_index));
}
- long vpnId = VpnUtil.getVpnId(broker, vpnInstanceName);
+ long vpnId = VpnUtil.getVpnId(dataBroker, vpnInstanceName);
makeArpFlow(dpId, l3vpn_service_index, lPortTag, vpnInterfaceName,
vpnId, ArpReplyOrRequest.REQUEST, NwConstants.DEL_FLOW, writeInvTxn);
makeArpFlow(dpId, l3vpn_service_index, lPortTag, vpnInterfaceName,
private void removePrefixFromBGP(String rd, String prefix, String nextHop, WriteTransaction writeConfigTxn) {
try {
LOG.info("VPN WITHDRAW: Removing Fib Entry rd {} prefix {}", rd, prefix);
- fibManager.removeOrUpdateFibEntry(broker, rd, prefix, nextHop, writeConfigTxn);
+ fibManager.removeOrUpdateFibEntry(dataBroker, rd, prefix, nextHop, writeConfigTxn);
bgpManager.withdrawPrefix(rd, prefix); // TODO: Might be needed to include nextHop here
LOG.info("VPN WITHDRAW: Removed Fib Entry rd {} prefix {}", rd, prefix);
} catch(Exception e) {
lriBuilder.setVpnInterfaceName(vpnInterfaceName);
}
lriBuilder.setParentVpnRd(rd);
- VpnInstanceOpDataEntry vpnInstanceOpDataEntry = VpnUtil.getVpnInstanceOpData(broker, rd);
+ VpnInstanceOpDataEntry vpnInstanceOpDataEntry = VpnUtil.getVpnInstanceOpData(dataBroker, rd);
if (vpnInstanceOpDataEntry != null) {
List<String> vpnInstanceNames = Arrays.asList(vpnInstanceOpDataEntry.getVpnInstanceName());
lriBuilder.setVpnInstanceList(vpnInstanceNames);
if (writeOperTxn != null) {
writeOperTxn.merge(LogicalDatastoreType.OPERATIONAL, lriIid, lri, true);
} else {
- VpnUtil.syncUpdate(broker, LogicalDatastoreType.OPERATIONAL, lriIid, lri);
+ VpnUtil.syncUpdate(dataBroker, LogicalDatastoreType.OPERATIONAL, lriIid, lri);
}
} else {
LOG.trace("Can't add entry to label map for lable {},dpnId is null", label);
LOG.debug("Created vrfEntry for {} nexthop {} label {} and elantag {}", prefix, nextHop, label, elantag);
//TODO: What should be parentVpnId? Get it from RD?
- long vpnId = VpnUtil.getVpnId(broker, vpnName);
+ long vpnId = VpnUtil.getVpnId(dataBroker, vpnName);
addToLabelMapper((long)label, dpnId, prefix, Arrays.asList(nextHop), vpnId, null, elantag, true, rd, null);
List<VrfEntry> vrfEntryList = Arrays.asList(vrfEntry);
if (writeTxn != null) {
writeTxn.merge(LogicalDatastoreType.CONFIGURATION, vrfTableId, vrfTableNew, true);
} else {
- VpnUtil.syncUpdate(broker, LogicalDatastoreType.CONFIGURATION, vrfTableId, vrfTableNew);
+ VpnUtil.syncUpdate(dataBroker, LogicalDatastoreType.CONFIGURATION, vrfTableId, vrfTableNew);
}
List<VpnInstance> vpnsToImportRoute = getVpnsImportingMyRoute(vpnName);
if (writeTxn != null) {
writeTxn.merge(LogicalDatastoreType.CONFIGURATION, importingVrfTableId, importingVrfTable, true);
} else {
- VpnUtil.syncUpdate(broker, LogicalDatastoreType.CONFIGURATION, importingVrfTableId, importingVrfTable);
+ VpnUtil.syncUpdate(dataBroker, LogicalDatastoreType.CONFIGURATION, importingVrfTableId, importingVrfTable);
}
}
}
if (writeConfigTxn != null) {
writeConfigTxn.merge(LogicalDatastoreType.CONFIGURATION, vrfTableId, vrfTableNew, true);
} else {
- VpnUtil.syncUpdate(broker, LogicalDatastoreType.CONFIGURATION, vrfTableId, vrfTableNew);
+ VpnUtil.syncUpdate(dataBroker, LogicalDatastoreType.CONFIGURATION, vrfTableId, vrfTableNew);
}
}
public synchronized void deleteSubnetRouteFibEntryFromDS(String rd, String prefix, String vpnName){
- fibManager.removeOrUpdateFibEntry(broker, rd, prefix, null /* nextHopToRemove */, null);
+ fibManager.removeOrUpdateFibEntry(dataBroker, rd, prefix, null /* nextHopToRemove */, null);
List<VpnInstance> vpnsToImportRoute = getVpnsImportingMyRoute(vpnName);
for (VpnInstance vpnInstance : vpnsToImportRoute) {
String importingRd = vpnInstance.getIpv4Family().getRouteDistinguisher();
LOG.info("Deleting imported subnet route rd {} prefix {} from vpn {}", rd, prefix, vpnInstance.getVpnInstanceName());
- fibManager.removeOrUpdateFibEntry(broker, importingRd, prefix, null /* nextHopToRemove */, null);
+ fibManager.removeOrUpdateFibEntry(dataBroker, importingRd, prefix, null /* nextHopToRemove */, null);
}
}
protected void addNewAdjToVpnInterface(InstanceIdentifier<VpnInterface> identifier, Adjacency adj, BigInteger dpnId) {
- Optional<VpnInterface> optVpnInterface = VpnUtil.read(broker, LogicalDatastoreType.OPERATIONAL, identifier);
+ Optional<VpnInterface> optVpnInterface = VpnUtil.read(dataBroker, LogicalDatastoreType.OPERATIONAL, identifier);
if (optVpnInterface.isPresent()) {
VpnInterface currVpnIntf = optVpnInterface.get();
String prefix = VpnUtil.getIpPrefix(adj.getIpAddress());
String rd = getRouteDistinguisher(currVpnIntf.getVpnInstanceName());
InstanceIdentifier<Adjacencies> adjPath = identifier.augmentation(Adjacencies.class);
- Optional<Adjacencies> optAdjacencies = VpnUtil.read(broker, LogicalDatastoreType.OPERATIONAL, adjPath);
+ Optional<Adjacencies> optAdjacencies = VpnUtil.read(dataBroker, LogicalDatastoreType.OPERATIONAL, adjPath);
long label =
VpnUtil.getUniqueId(idManager, VpnConstants.VPN_IDPOOL_NAME,
VpnUtil.getNextHopLabelKey((rd != null) ? rd : currVpnIntf.getVpnInstanceName(), prefix));
Adjacencies aug = VpnUtil.getVpnInterfaceAugmentation(adjacencies);
VpnInterface newVpnIntf = VpnUtil.getVpnInterface(currVpnIntf.getName(), currVpnIntf.getVpnInstanceName(), aug, dpnId, currVpnIntf.isScheduledForRemove());
- VpnUtil.syncUpdate(broker, LogicalDatastoreType.OPERATIONAL, identifier, newVpnIntf);
+ VpnUtil.syncUpdate(dataBroker, LogicalDatastoreType.OPERATIONAL, identifier, newVpnIntf);
for (String nh : adj.getNextHopIpList()) {
addExtraRoute(adj.getIpAddress(), nh, rd, currVpnIntf.getVpnInstanceName(), (int) label,
currVpnIntf.getName());
}
protected void delAdjFromVpnInterface(InstanceIdentifier<VpnInterface> identifier, Adjacency adj, BigInteger dpnId) {
- Optional<VpnInterface> optVpnInterface = VpnUtil.read(broker, LogicalDatastoreType.OPERATIONAL, identifier);
+ Optional<VpnInterface> optVpnInterface = VpnUtil.read(dataBroker, LogicalDatastoreType.OPERATIONAL, identifier);
if (optVpnInterface.isPresent()) {
VpnInterface currVpnIntf = optVpnInterface.get();
InstanceIdentifier<Adjacencies> path = identifier.augmentation(Adjacencies.class);
- Optional<Adjacencies> optAdjacencies = VpnUtil.read(broker, LogicalDatastoreType.OPERATIONAL, path);
+ Optional<Adjacencies> optAdjacencies = VpnUtil.read(dataBroker, LogicalDatastoreType.OPERATIONAL, path);
if (optAdjacencies.isPresent()) {
List<Adjacency> adjacencies = optAdjacencies.get().getAdjacency();
currVpnIntf.getVpnInstanceName(),
aug, dpnId, currVpnIntf.isScheduledForRemove());
- VpnUtil.syncUpdate(broker, LogicalDatastoreType.OPERATIONAL, identifier, newVpnIntf);
+ VpnUtil.syncUpdate(dataBroker, LogicalDatastoreType.OPERATIONAL, identifier, newVpnIntf);
for (String nh : adj.getNextHopIpList()) {
delExtraRoute(adj.getIpAddress(), nh, rd, currVpnIntf.getVpnInstanceName(),
//add extra route to vpn mapping; advertise with nexthop as tunnel ip
VpnUtil.syncUpdate(
- broker,
+ dataBroker,
LogicalDatastoreType.OPERATIONAL,
VpnUtil.getVpnToExtrarouteIdentifier( (rd != null) ? rd : routerID, destination),
VpnUtil.getVpnToExtraroute(destination, Arrays.asList(nextHop)));
BigInteger dpnId = null;
if (intfName != null && !intfName.isEmpty()) {
dpnId = InterfaceUtils.getDpnForInterface(ifaceMgrRpcService, intfName);
- String nextHopIp = InterfaceUtils.getEndpointIpAddressForDPN(broker, dpnId);
+ String nextHopIp = InterfaceUtils.getEndpointIpAddressForDPN(dataBroker, dpnId);
if (nextHopIp == null || nextHopIp.isEmpty()) {
LOG.error("NextHop for interface {} is null / empty. Failed advertising extra route for prefix {}",
intfName, destination);
List<String> nextHopIpList = Arrays.asList(nextHop);
if (rd != null) {
/* Label mapper is required only for BGP VPN and not for Internal VPN */
- addToLabelMapper((long) label, dpnId, destination, nextHopIpList, VpnUtil.getVpnId(broker, routerID),
+ addToLabelMapper((long) label, dpnId, destination, nextHopIpList, VpnUtil.getVpnId(dataBroker, routerID),
intfName, null, false, rd, null);
}
// TODO (eperefr): This is a limitation to be stated in docs. When configuring static route to go to
// another VPN, there can only be one nexthop or, at least, the nexthop to the interVpnLink should be in
// first place.
- InterVpnLink interVpnLink = VpnUtil.getInterVpnLinkByEndpointIp(broker, nextHop);
+ InterVpnLink interVpnLink = VpnUtil.getInterVpnLinkByEndpointIp(dataBroker, nextHop);
if ( interVpnLink != null ) {
// If the nexthop is the endpoint of Vpn2, then prefix must be advertised to Vpn1 in DC-GW, with nexthops
// pointing to the DPNs where Vpn1 is instantiated. LFIB in these DPNS must have a flow entry, with lower
: interVpnLink.getFirstEndpoint().getVpnUuid().getValue();
String dstVpnUuid = (nexthopIsVpn2) ? interVpnLink.getFirstEndpoint().getVpnUuid().getValue()
: interVpnLink.getSecondEndpoint().getVpnUuid().getValue();
- String dstVpnRd = VpnUtil.getVpnRd(broker, dstVpnUuid);
+ String dstVpnRd = VpnUtil.getVpnRd(dataBroker, dstVpnUuid);
long newLabel = VpnUtil.getUniqueId(idManager, VpnConstants.VPN_IDPOOL_NAME,
VpnUtil.getNextHopLabelKey(dstVpnRd, destination));
- VpnUtil.leakRoute(broker, bgpManager, interVpnLink, srcVpnUuid, dstVpnUuid, destination, newLabel);
+ VpnUtil.leakRoute(dataBroker, bgpManager, interVpnLink, srcVpnUuid, dstVpnUuid, destination, newLabel);
} else {
if (rd != null) {
addPrefixToBGP(rd, destination, nextHop, label, null);
} else {
// ### add FIB route directly
- fibManager.addOrUpdateFibEntry(broker, routerID, destination, Arrays.asList(nextHop), label, RouteOrigin.STATIC, null);
+ fibManager.addOrUpdateFibEntry(dataBroker, routerID, destination, Arrays.asList(nextHop), label, RouteOrigin.STATIC, null);
}
}
}
protected void delExtraRoute(String destination, String nextHop, String rd, String routerID, String intfName) {
if (intfName != null && !intfName.isEmpty()) {
BigInteger dpnId = InterfaceUtils.getDpnForInterface(ifaceMgrRpcService, intfName);
- String nextHopIp = InterfaceUtils.getEndpointIpAddressForDPN(broker, dpnId);
+ String nextHopIp = InterfaceUtils.getEndpointIpAddressForDPN(dataBroker, dpnId);
if (nextHopIp == null || nextHopIp.isEmpty()) {
LOG.warn("NextHop for interface {} is null / empty. Failed advertising extra route for prefix {}",
intfName, destination);
removePrefixFromBGP(rd, destination, nextHop, null);
} else {
// ### add FIB route directly
- fibManager.removeOrUpdateFibEntry(broker, routerID, destination, nextHop, null);
- }
- }
-
- class VpnInterfaceOpListener extends org.opendaylight.genius.mdsalutil.AbstractDataChangeListener<VpnInterface> {
-
- public VpnInterfaceOpListener() {
- super(VpnInterface.class);
- }
-
- @Override
- protected void remove(final InstanceIdentifier<VpnInterface> identifier, final VpnInterface del) {
- final VpnInterfaceKey key = identifier.firstKeyOf(VpnInterface.class, VpnInterfaceKey.class);
- final String interfaceName = key.getName();
- final String vpnName = del.getVpnInstanceName();
- DataStoreJobCoordinator dataStoreCoordinator = DataStoreJobCoordinator.getInstance();
- dataStoreCoordinator.enqueueJob("VPNINTERFACE-" + interfaceName,
- new Callable<List<ListenableFuture<Void>>>() {
- @Override
- public List<ListenableFuture<Void>> call() throws Exception {
- WriteTransaction writeOperTxn = broker.newWriteOnlyTransaction();
- postProcessVpnInterfaceRemoval(identifier, del, writeOperTxn);
- CheckedFuture<Void, TransactionCommitFailedException> futures = writeOperTxn.submit();
- try {
- futures.get();
- } catch (InterruptedException | ExecutionException e) {
- LOG.error("Error handling removal of oper data for interface {} from vpn {}", interfaceName,
- vpnName);
- throw new RuntimeException(e.getMessage());
- }
- return null;
- }
- });
- }
-
- private void postProcessVpnInterfaceRemoval(InstanceIdentifier<VpnInterface> identifier, VpnInterface del,
- WriteTransaction writeOperTxn) {
- final VpnInterfaceKey key = identifier.firstKeyOf(VpnInterface.class, VpnInterfaceKey.class);
- String interfaceName = key.getName();
- String vpnName = del.getVpnInstanceName();
-
- LOG.trace("VpnInterfaceOpListener removed: interface name {} vpnName {}", interfaceName, vpnName);
- //decrement the vpn interface count in Vpn Instance Op Data
- InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.to
- .vpn.id.VpnInstance>
- id = VpnUtil.getVpnInstanceToVpnIdIdentifier(vpnName);
- Optional<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.to.vpn.id
- .VpnInstance> vpnInstance
- = VpnUtil.read(broker, LogicalDatastoreType.CONFIGURATION, id);
-
- if (vpnInstance.isPresent()) {
- String rd = null;
- rd = vpnInstance.get().getVrfId();
- //String rd = getRouteDistinguisher(del.getVpnInstanceName());
-
- VpnInstanceOpDataEntry vpnInstOp = VpnUtil.getVpnInstanceOpData(broker, rd);
- LOG.trace("VpnInterfaceOpListener removed: interface name {} rd {} vpnName {} in Vpn Op Instance {}",
- interfaceName, rd, vpnName, vpnInstOp);
-
- if (vpnInstOp != null) {
- // Vpn Interface removed => No more adjacencies from it.
- // Hence clean up interface from vpn-dpn-interface list.
- Adjacency adjacency = del.getAugmentation(Adjacencies.class).getAdjacency().get(0);
- List<Prefixes> prefixToInterface = new ArrayList<>();
- Optional<Prefixes> prefix = VpnUtil.read(broker, LogicalDatastoreType.OPERATIONAL,
- VpnUtil.getPrefixToInterfaceIdentifier(vpnInstOp.getVpnId(),
- VpnUtil.getIpPrefix(adjacency.getIpAddress())));
- if (prefix.isPresent()) {
- prefixToInterface.add(prefix.get());
- }
- if (prefixToInterface.isEmpty()) {
- for (String nh : adjacency.getNextHopIpList()) {
- prefix = VpnUtil.read(broker, LogicalDatastoreType.OPERATIONAL,
- VpnUtil.getPrefixToInterfaceIdentifier(vpnInstOp.getVpnId(),
- VpnUtil.getIpPrefix(nh)));
- if (prefix.isPresent())
- prefixToInterface.add(prefix.get());
- }
- }
- for (Prefixes pref : prefixToInterface) {
- if (writeOperTxn != null) {
- writeOperTxn.delete(LogicalDatastoreType.OPERATIONAL,
- VpnUtil.getPrefixToInterfaceIdentifier(vpnInstOp.getVpnId(), pref.getIpAddress()));
- } else {
- VpnUtil.delete(broker, LogicalDatastoreType.OPERATIONAL,
- VpnUtil.getPrefixToInterfaceIdentifier(vpnInstOp.getVpnId(), pref.getIpAddress()),
- VpnUtil.DEFAULT_CALLBACK);
- }
- updateVpnToDpnMapping(pref.getDpnId(), del.getVpnInstanceName(), interfaceName, false /* delete */);
- }
- }
- } else {
- LOG.error("rd not retrievable as vpninstancetovpnid for vpn {} is absent, trying rd as ", vpnName, vpnName);
- }
- notifyTaskIfRequired(interfaceName);
- }
-
- private void notifyTaskIfRequired(String intfName) {
- Runnable notifyTask = vpnIntfMap.remove(intfName);
- if (notifyTask == null) {
- LOG.trace("VpnInterfaceOpListener update: No Notify Task queued for vpnInterface {}", intfName);
- return;
- }
- executorService.execute(notifyTask);
- }
-
- @Override
- protected void update(final InstanceIdentifier<VpnInterface> identifier, final VpnInterface original,
- final VpnInterface update) {
- final VpnInterfaceKey key = identifier.firstKeyOf(VpnInterface.class, VpnInterfaceKey.class);
- final String interfaceName = key.getName();
-
- if (original.getVpnInstanceName().equals(update.getVpnInstanceName())) {
- return;
- }
-
- final String vpnName = update.getVpnInstanceName();
- DataStoreJobCoordinator dataStoreCoordinator = DataStoreJobCoordinator.getInstance();
- dataStoreCoordinator.enqueueJob("VPNINTERFACE-" + interfaceName,
- new Callable<List<ListenableFuture<Void>>>() {
- @Override
- public List<ListenableFuture<Void>> call() throws Exception {
- postProcessVpnInterfaceUpdate(identifier, original, update);
- return null;
- }
- });
- }
-
- private void postProcessVpnInterfaceUpdate(InstanceIdentifier<VpnInterface> identifier, VpnInterface original,
- VpnInterface update) {
- final VpnInterfaceKey key = identifier.firstKeyOf(VpnInterface.class, VpnInterfaceKey.class);
- String interfaceName = key.getName();
-
- //increment the vpn interface count in Vpn Instance Op Data
- VpnInstanceOpDataEntry vpnInstOp = null;
- InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.to
- .vpn.id.VpnInstance>
- origId = VpnUtil.getVpnInstanceToVpnIdIdentifier(original.getVpnInstanceName());
- Optional<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.to.vpn.id
- .VpnInstance> origVpnInstance
- = VpnUtil.read(broker, LogicalDatastoreType.CONFIGURATION, origId);
-
- if (origVpnInstance.isPresent()) {
- String rd = null;
- rd = origVpnInstance.get().getVrfId();
-
- vpnInstOp = VpnUtil.getVpnInstanceOpData(broker, rd);
- LOG.trace("VpnInterfaceOpListener updated: interface name {} original rd {} original vpnName {}",
- interfaceName, rd, original.getVpnInstanceName());
-
- if (vpnInstOp != null) {
- Adjacency adjacency = original.getAugmentation(Adjacencies.class).getAdjacency().get(0);
- List<Prefixes> prefixToInterfaceList = new ArrayList<>();
- Optional<Prefixes> prefixToInterface = VpnUtil.read(broker, LogicalDatastoreType.OPERATIONAL,
- VpnUtil.getPrefixToInterfaceIdentifier(vpnInstOp.getVpnId(),
- VpnUtil.getIpPrefix(adjacency.getIpAddress())));
- if (prefixToInterface.isPresent()) {
- prefixToInterfaceList.add(prefixToInterface.get());
- } else {
- for (String adj : adjacency.getNextHopIpList()) {
- prefixToInterface = VpnUtil.read(broker, LogicalDatastoreType.OPERATIONAL,
- VpnUtil.getPrefixToInterfaceIdentifier(vpnInstOp.getVpnId(),
- VpnUtil.getIpPrefix(adj)));
- if (prefixToInterface.isPresent()) {
- prefixToInterfaceList.add(prefixToInterface.get());
- }
- }
- }
- for (Prefixes prefix : prefixToInterfaceList) {
- updateVpnToDpnMapping(prefix.getDpnId(), original.getVpnInstanceName(), interfaceName, false /* delete */);
- }
- }
- }
- notifyTaskIfRequired(interfaceName);
- }
-
- @Override
- protected void add(InstanceIdentifier<VpnInterface> identifier, VpnInterface add) {
+ fibManager.removeOrUpdateFibEntry(dataBroker, routerID, destination, nextHop, null);
}
}
}
InstanceIdentifier<DpnVpninterfacesList> routerDpnListIdentifier = getRouterDpnId(routerName, dpId);
- Optional<DpnVpninterfacesList> optionalRouterDpnList = VpnUtil.read(broker, LogicalDatastoreType
+ Optional<DpnVpninterfacesList> optionalRouterDpnList = VpnUtil.read(dataBroker, LogicalDatastoreType
.OPERATIONAL, routerDpnListIdentifier);
RouterInterfaces routerInterface = new RouterInterfacesBuilder().setKey(new RouterInterfacesKey(vpnInterfaceName)).setInterface(vpnInterfaceName).build();
if (optionalRouterDpnList.isPresent()) {
return;
}
InstanceIdentifier<DpnVpninterfacesList> routerDpnListIdentifier = getRouterDpnId(routerName, dpId);
- Optional<DpnVpninterfacesList> optionalRouterDpnList = VpnUtil.read(broker, LogicalDatastoreType
+ Optional<DpnVpninterfacesList> optionalRouterDpnList = VpnUtil.read(dataBroker, LogicalDatastoreType
.OPERATIONAL, routerDpnListIdentifier);
if (optionalRouterDpnList.isPresent()) {
List<RouterInterfaces> routerInterfaces = optionalRouterDpnList.get().getRouterInterfaces();
if (writeOperTxn != null) {
writeOperTxn.delete(LogicalDatastoreType.OPERATIONAL, routerDpnListIdentifier);
} else {
- MDSALUtil.syncDelete(broker, LogicalDatastoreType.OPERATIONAL, routerDpnListIdentifier);
+ MDSALUtil.syncDelete(dataBroker, LogicalDatastoreType.OPERATIONAL, routerDpnListIdentifier);
}
} else {
if (writeOperTxn != null) {
RouterInterfaces.class,
new RouterInterfacesKey(vpnInterfaceName)));
} else {
- MDSALUtil.syncDelete(broker, LogicalDatastoreType.OPERATIONAL, routerDpnListIdentifier.child(
+ MDSALUtil.syncDelete(dataBroker, LogicalDatastoreType.OPERATIONAL, routerDpnListIdentifier.child(
RouterInterfaces.class,
new RouterInterfacesKey(vpnInterfaceName)));
}
return;
}
InstanceIdentifier<DpnVpninterfacesList> routerDpnListIdentifier = getRouterDpnId(routerName, dpId);
- Optional<DpnVpninterfacesList> optionalRouterDpnList = VpnUtil.read(broker, LogicalDatastoreType
+ Optional<DpnVpninterfacesList> optionalRouterDpnList = VpnUtil.read(dataBroker, LogicalDatastoreType
.OPERATIONAL, routerDpnListIdentifier);
if (optionalRouterDpnList.isPresent()) {
List<RouterInterfaces> routerInterfaces = optionalRouterDpnList.get().getRouterInterfaces();
LOG.trace("Adding {} adjacency to VPN Interface {} ",prefix,vpnInterface);
InstanceIdentifier<VpnInterface> vpnIfId = VpnUtil.getVpnInterfaceIdentifier(vpnInterface);
InstanceIdentifier<Adjacencies> path = vpnIfId.augmentation(Adjacencies.class);
- Optional<Adjacencies> adjacencies = VpnUtil.read(broker, LogicalDatastoreType.CONFIGURATION, path);
+ Optional<Adjacencies> adjacencies = VpnUtil.read(dataBroker, LogicalDatastoreType.CONFIGURATION, path);
String nextHopIpAddr = null;
String nextHopMacAddress = null;
String ip = prefix.getIpv4Address().getValue();
}
}
if (nextHopMacAddress != null && ip != null) {
- String rd = VpnUtil.getVpnRd(broker, vpnName);
+ String rd = VpnUtil.getVpnRd(dataBroker, vpnName);
long label =
VpnUtil.getUniqueId(idManager, VpnConstants.VPN_IDPOOL_NAME,
VpnUtil.getNextHopLabelKey((rd != null) ? rd : vpnName, ip));
Adjacencies aug = VpnUtil.getVpnInterfaceAugmentation(adjacencyList);
VpnInterface newVpnIntf = new VpnInterfaceBuilder().setKey(new VpnInterfaceKey(vpnInterface)).
setName(vpnInterface).setVpnInstanceName(vpnName).addAugmentation(Adjacencies.class, aug).build();
- VpnUtil.syncUpdate(broker, LogicalDatastoreType.CONFIGURATION, vpnIfId, newVpnIntf);
+ VpnUtil.syncUpdate(dataBroker, LogicalDatastoreType.CONFIGURATION, vpnIfId, newVpnIntf);
LOG.debug(" Successfully stored subnetroute Adjacency into VpnInterface {}", vpnInterface);
}
}
LOG.trace("Removing {} adjacency from Old VPN Interface {} ",ip,vpnInterface);
InstanceIdentifier<VpnInterface> vpnIfId = VpnUtil.getVpnInterfaceIdentifier(vpnInterface);
InstanceIdentifier<Adjacencies> path = vpnIfId.augmentation(Adjacencies.class);
- Optional<Adjacencies> adjacencies = VpnUtil.read(broker, LogicalDatastoreType.OPERATIONAL, path);
+ Optional<Adjacencies> adjacencies = VpnUtil.read(dataBroker, LogicalDatastoreType.OPERATIONAL, path);
if (adjacencies.isPresent()) {
InstanceIdentifier<Adjacency> adjacencyIdentifier = InstanceIdentifier.builder(VpnInterfaces.class).
child(VpnInterface.class, new VpnInterfaceKey(vpnInterface)).augmentation(Adjacencies.class)
.child(Adjacency.class, new AdjacencyKey(ip)).build();
- MDSALUtil.syncDelete(broker, LogicalDatastoreType.CONFIGURATION, adjacencyIdentifier);
+ MDSALUtil.syncDelete(dataBroker, LogicalDatastoreType.CONFIGURATION, adjacencyIdentifier);
LOG.trace("Successfully Deleted Adjacency into VpnInterface {}", vpnInterface);
}
}
+
+ void notifyTaskIfRequired(String intfName) {
+ Runnable notifyTask = vpnIntfMap.remove(intfName);
+ if (notifyTask == null) {
+ return;
+ }
+ executorService.execute(notifyTask);
+ }
}
--- /dev/null
+/*
+ * Copyright (c) 2015 - 2016 Ericsson India Global Services Pvt Ltd. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.netvirt.vpnmanager;
+
+import com.google.common.base.Optional;
+import com.google.common.util.concurrent.CheckedFuture;
+import com.google.common.util.concurrent.ListenableFuture;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.controller.md.sal.binding.api.DataChangeListener;
+import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
+import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker;
+import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
+import org.opendaylight.genius.datastoreutils.DataStoreJobCoordinator;
+import org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager;
+import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.VpnInterfaces;
+import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.interfaces.VpnInterface;
+import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.interfaces.VpnInterfaceKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.Adjacencies;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.adjacency.list.Adjacency;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.prefix.to._interface.vpn.ids.Prefixes;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data.VpnInstanceOpDataEntry;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.to.vpn.id.VpnInstance;
+import org.opendaylight.yangtools.concepts.ListenerRegistration;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class VpnInterfaceOpListener extends AbstractDataChangeListener<VpnInterface> implements AutoCloseable {
+ private static final Logger LOG = LoggerFactory.getLogger(VpnInterfaceOpListener.class);
+ private ListenerRegistration<DataChangeListener> listenerRegistration;
+ private final DataBroker dataBroker;
+ private final VpnInterfaceManager vpnInterfaceManager;
+ private ConcurrentHashMap<String, Runnable> vpnIntfMap = new ConcurrentHashMap<String, Runnable>();
+ private ExecutorService executorService = Executors.newSingleThreadExecutor();
+
+ /*public VpnInterfaceOpListener(final DataBroker dataBroker) {
+ super(VpnInterface.class);
+ this.dataBroker = dataBroker;
+ }*/
+
+ public VpnInterfaceOpListener(final DataBroker dataBroker, final VpnInterfaceManager vpnInterfaceManager) {
+ super(VpnInterface.class);
+ this.dataBroker = dataBroker;
+ this.vpnInterfaceManager = vpnInterfaceManager;
+ }
+
+ public void start() {
+ LOG.info("{} start", getClass().getSimpleName());
+ listenerRegistration = dataBroker.registerDataChangeListener(LogicalDatastoreType.OPERATIONAL,
+ getWildCardPath(), this, AsyncDataBroker.DataChangeScope.SUBTREE);
+ }
+
+ private InstanceIdentifier<VpnInterface> getWildCardPath() {
+ return InstanceIdentifier.create(VpnInterfaces.class).child(VpnInterface.class);
+ }
+
+ @Override
+ public void close() throws Exception {
+ if (listenerRegistration != null) {
+ listenerRegistration.close();
+ listenerRegistration = null;
+ }
+ LOG.info("{} close", getClass().getSimpleName());
+ }
+
+ @Override
+ protected void remove(final InstanceIdentifier<VpnInterface> identifier, final VpnInterface del) {
+ final VpnInterfaceKey key = identifier.firstKeyOf(VpnInterface.class, VpnInterfaceKey.class);
+ final String interfaceName = key.getName();
+ final String vpnName = del.getVpnInstanceName();
+ DataStoreJobCoordinator dataStoreCoordinator = DataStoreJobCoordinator.getInstance();
+ dataStoreCoordinator.enqueueJob("VPNINTERFACE-" + interfaceName,
+ new Callable<List<ListenableFuture<Void>>>() {
+ @Override
+ public List<ListenableFuture<Void>> call() throws Exception {
+ WriteTransaction writeOperTxn = dataBroker.newWriteOnlyTransaction();
+ postProcessVpnInterfaceRemoval(identifier, del, writeOperTxn);
+ CheckedFuture<Void, TransactionCommitFailedException> futures = writeOperTxn.submit();
+ try {
+ futures.get();
+ } catch (InterruptedException | ExecutionException e) {
+ LOG.error("Error handling removal of oper data for interface {} from vpn {}", interfaceName,
+ vpnName);
+ throw new RuntimeException(e.getMessage());
+ }
+ return null;
+ }
+ });
+ }
+
+ private void postProcessVpnInterfaceRemoval(InstanceIdentifier<VpnInterface> identifier, VpnInterface del,
+ WriteTransaction writeOperTxn) {
+ final VpnInterfaceKey key = identifier.firstKeyOf(VpnInterface.class, VpnInterfaceKey.class);
+ String interfaceName = key.getName();
+ String vpnName = del.getVpnInstanceName();
+
+ LOG.trace("VpnInterfaceOpListener removed: interface name {} vpnName {}", interfaceName, vpnName);
+ //decrement the vpn interface count in Vpn Instance Op Data
+ InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.to
+ .vpn.id.VpnInstance>
+ id = VpnUtil.getVpnInstanceToVpnIdIdentifier(vpnName);
+ Optional<VpnInstance> vpnInstance
+ = VpnUtil.read(dataBroker, LogicalDatastoreType.CONFIGURATION, id);
+
+ if (vpnInstance.isPresent()) {
+ String rd = null;
+ rd = vpnInstance.get().getVrfId();
+ //String rd = getRouteDistinguisher(del.getVpnInstanceName());
+
+ VpnInstanceOpDataEntry vpnInstOp = VpnUtil.getVpnInstanceOpData(dataBroker, rd);
+ LOG.trace("VpnInterfaceOpListener removed: interface name {} rd {} vpnName {} in Vpn Op Instance {}",
+ interfaceName, rd, vpnName, vpnInstOp);
+
+ if (vpnInstOp != null) {
+ // Vpn Interface removed => No more adjacencies from it.
+ // Hence clean up interface from vpn-dpn-interface list.
+ Adjacency adjacency = del.getAugmentation(Adjacencies.class).getAdjacency().get(0);
+ List<Prefixes> prefixToInterface = new ArrayList<>();
+ Optional<Prefixes> prefix = VpnUtil.read(dataBroker, LogicalDatastoreType.OPERATIONAL,
+ VpnUtil.getPrefixToInterfaceIdentifier(vpnInstOp.getVpnId(),
+ VpnUtil.getIpPrefix(adjacency.getIpAddress())));
+ if (prefix.isPresent()) {
+ prefixToInterface.add(prefix.get());
+ }
+ if (prefixToInterface.isEmpty()) {
+ for (String nh : adjacency.getNextHopIpList()) {
+ prefix = VpnUtil.read(dataBroker, LogicalDatastoreType.OPERATIONAL,
+ VpnUtil.getPrefixToInterfaceIdentifier(vpnInstOp.getVpnId(),
+ VpnUtil.getIpPrefix(nh)));
+ if (prefix.isPresent())
+ prefixToInterface.add(prefix.get());
+ }
+ }
+ for (Prefixes pref : prefixToInterface) {
+ if (writeOperTxn != null) {
+ writeOperTxn.delete(LogicalDatastoreType.OPERATIONAL,
+ VpnUtil.getPrefixToInterfaceIdentifier(vpnInstOp.getVpnId(), pref.getIpAddress()));
+ } else {
+ VpnUtil.delete(dataBroker, LogicalDatastoreType.OPERATIONAL,
+ VpnUtil.getPrefixToInterfaceIdentifier(vpnInstOp.getVpnId(), pref.getIpAddress()),
+ VpnUtil.DEFAULT_CALLBACK);
+ }
+ vpnInterfaceManager.updateVpnToDpnMapping(pref.getDpnId(), del.getVpnInstanceName(),
+ interfaceName, false /* delete */);
+ }
+ }
+ } else {
+ LOG.error("rd not retrievable as vpninstancetovpnid for vpn {} is absent, trying rd as ", vpnName, vpnName);
+ }
+ notifyTaskIfRequired(interfaceName);
+ }
+
+ private void notifyTaskIfRequired(String intfName) {
+ Runnable notifyTask = vpnIntfMap.remove(intfName);
+ if (notifyTask == null) {
+ LOG.trace("VpnInterfaceOpListener update: No Notify Task queued for vpnInterface {}", intfName);
+ return;
+ }
+ executorService.execute(notifyTask);
+ }
+
+ @Override
+ protected void update(final InstanceIdentifier<VpnInterface> identifier, final VpnInterface original,
+ final VpnInterface update) {
+ final VpnInterfaceKey key = identifier.firstKeyOf(VpnInterface.class, VpnInterfaceKey.class);
+ final String interfaceName = key.getName();
+
+ if (original.getVpnInstanceName().equals(update.getVpnInstanceName())) {
+ return;
+ }
+
+ final String vpnName = update.getVpnInstanceName();
+ DataStoreJobCoordinator dataStoreCoordinator = DataStoreJobCoordinator.getInstance();
+ dataStoreCoordinator.enqueueJob("VPNINTERFACE-" + interfaceName,
+ new Callable<List<ListenableFuture<Void>>>() {
+ @Override
+ public List<ListenableFuture<Void>> call() throws Exception {
+ postProcessVpnInterfaceUpdate(identifier, original, update);
+ return null;
+ }
+ });
+ }
+
+ private void postProcessVpnInterfaceUpdate(InstanceIdentifier<VpnInterface> identifier, VpnInterface original,
+ VpnInterface update) {
+ final VpnInterfaceKey key = identifier.firstKeyOf(VpnInterface.class, VpnInterfaceKey.class);
+ String interfaceName = key.getName();
+
+ //increment the vpn interface count in Vpn Instance Op Data
+ VpnInstanceOpDataEntry vpnInstOp = null;
+ InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.to
+ .vpn.id.VpnInstance>
+ origId = VpnUtil.getVpnInstanceToVpnIdIdentifier(original.getVpnInstanceName());
+ Optional<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.to.vpn.id
+ .VpnInstance> origVpnInstance
+ = VpnUtil.read(dataBroker, LogicalDatastoreType.CONFIGURATION, origId);
+
+ if (origVpnInstance.isPresent()) {
+ String rd = null;
+ rd = origVpnInstance.get().getVrfId();
+
+ vpnInstOp = VpnUtil.getVpnInstanceOpData(dataBroker, rd);
+ LOG.trace("VpnInterfaceOpListener updated: interface name {} original rd {} original vpnName {}",
+ interfaceName, rd, original.getVpnInstanceName());
+
+ if (vpnInstOp != null) {
+ Adjacency adjacency = original.getAugmentation(Adjacencies.class).getAdjacency().get(0);
+ List<Prefixes> prefixToInterfaceList = new ArrayList<>();
+ Optional<Prefixes> prefixToInterface = VpnUtil.read(dataBroker, LogicalDatastoreType.OPERATIONAL,
+ VpnUtil.getPrefixToInterfaceIdentifier(vpnInstOp.getVpnId(),
+ VpnUtil.getIpPrefix(adjacency.getIpAddress())));
+ if (prefixToInterface.isPresent()) {
+ prefixToInterfaceList.add(prefixToInterface.get());
+ } else {
+ for (String adj : adjacency.getNextHopIpList()) {
+ prefixToInterface = VpnUtil.read(dataBroker, LogicalDatastoreType.OPERATIONAL,
+ VpnUtil.getPrefixToInterfaceIdentifier(vpnInstOp.getVpnId(),
+ VpnUtil.getIpPrefix(adj)));
+ if (prefixToInterface.isPresent()) {
+ prefixToInterfaceList.add(prefixToInterface.get());
+ }
+ }
+ }
+ for (Prefixes prefix : prefixToInterfaceList) {
+ vpnInterfaceManager.updateVpnToDpnMapping(prefix.getDpnId(), original.getVpnInstanceName(),
+ interfaceName, false /* delete */);
+ }
+ }
+ }
+ notifyTaskIfRequired(interfaceName);
+ }
+
+ @Override
+ protected void add(InstanceIdentifier<VpnInterface> identifier, VpnInterface add) {
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2015 - 2016 Ericsson India Global Services Pvt Ltd. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.netvirt.vpnmanager;
+
+import java.math.BigInteger;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Future;
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.netvirt.fibmanager.api.IFibManager;
+import org.opendaylight.netvirt.vpnmanager.api.IVpnManager;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.CreateIdPoolInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.CreateIdPoolInputBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.IdManagerService;
+import org.opendaylight.yangtools.yang.common.RpcResult;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class VpnManagerImpl implements IVpnManager {
+ private static final Logger LOG = LoggerFactory.getLogger(VpnManagerImpl.class);
+ private final DataBroker dataBroker;
+ private final VpnInterfaceManager vpnInterfaceManager;
+ private final VpnInstanceListener vpnInstanceListener;
+ private final IdManagerService idManager;
+
+ public VpnManagerImpl(final DataBroker dataBroker,
+ final IdManagerService idManagerService,
+ final VpnInstanceListener vpnInstanceListener,
+ final VpnInterfaceManager vpnInterfaceManager) {
+ this.dataBroker = dataBroker;
+ this.vpnInterfaceManager = vpnInterfaceManager;
+ this.vpnInstanceListener = vpnInstanceListener;
+ this.idManager = idManagerService;
+ }
+
+ public void start() {
+ LOG.info("{} start", getClass().getSimpleName());
+ createIdPool();
+ }
+
+ private void createIdPool() {
+ CreateIdPoolInput createPool = new CreateIdPoolInputBuilder()
+ .setPoolName(VpnConstants.VPN_IDPOOL_NAME)
+ .setLow(VpnConstants.VPN_IDPOOL_START)
+ .setHigh(new BigInteger(VpnConstants.VPN_IDPOOL_SIZE).longValue())
+ .build();
+ try {
+ Future<RpcResult<Void>> result = idManager.createIdPool(createPool);
+ if ((result != null) && (result.get().isSuccessful())) {
+ LOG.info("Created IdPool for VPN Service");
+ }
+ } catch (InterruptedException | ExecutionException e) {
+ LOG.error("Failed to create idPool for VPN Service",e);
+ }
+ }
+
+ @Override
+ public void setFibManager(IFibManager fibManager) {
+
+ }
+
+ @Override
+ public void addExtraRoute(String destination, String nextHop, String rd, String routerID, int label) {
+ LOG.info("Adding extra route with destination {}, nextHop {} and label{}", destination, nextHop, label);
+ vpnInterfaceManager.addExtraRoute(destination, nextHop, rd, routerID, label, /*intfName*/ null);
+ }
+
+ @Override
+ public void delExtraRoute(String destination, String nextHop, String rd, String routerID) {
+ LOG.info("Deleting extra route with destination {} and nextHop {}", destination, nextHop);
+ vpnInterfaceManager.delExtraRoute(destination, nextHop, rd, routerID, null);
+ }
+
+ @Override
+ public boolean isVPNConfigured() {
+ return vpnInstanceListener.isVPNConfigured();
+ }
+
+ @Override
+ public boolean existsVpn(String vpnName) {
+ return VpnUtil.getVpnInstance(dataBroker, vpnName) != null;
+ }
+}
import java.util.concurrent.Future;
public class VpnRpcServiceImpl implements VpnRpcService {
-
private static final Logger LOG = LoggerFactory.getLogger(VpnRpcServiceImpl.class);
- private IdManagerService idManager;
- private VpnInterfaceManager vpnInterfaceMgr;
- private DataBroker dataBroker;
- private IFibManager fibManager;
+ private final DataBroker dataBroker;
+ private final IdManagerService idManager;
+ private final VpnInterfaceManager vpnInterfaceMgr;
+ private final IFibManager fibManager;
- public VpnRpcServiceImpl(IdManagerService idManager, VpnInterfaceManager vpnIfaceMgr, DataBroker dataBroker) {
+ public VpnRpcServiceImpl(final DataBroker dataBroker, final IdManagerService idManager,
+ final VpnInterfaceManager vpnIfaceMgr, final IFibManager fibManager) {
+ this.dataBroker = dataBroker;
this.idManager = idManager;
this.vpnInterfaceMgr = vpnIfaceMgr;
- this.dataBroker = dataBroker;
this.fibManager = fibManager;
}
*/
package org.opendaylight.netvirt.vpnmanager;
-import java.util.*;
-
+import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
-
-import org.opendaylight.netvirt.bgpmanager.api.IBgpManager;
+import java.math.BigInteger;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.genius.mdsalutil.MDSALUtil;
+import org.opendaylight.netvirt.bgpmanager.api.IBgpManager;
import org.opendaylight.netvirt.vpnmanager.utilities.InterfaceUtils;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface;
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.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.IdManagerService;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.*;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.PortOpData;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.SubnetOpData;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.TaskState;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.port.op.data.PortOpDataEntry;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.port.op.data.PortOpDataEntryKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.subnet.op.data.SubnetOpDataEntry;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.subnet.op.data.SubnetOpDataEntryKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.subnet.op.data.SubnetOpDataEntryBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.*;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.subnetmaps.Subnetmap;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.subnetmaps.SubnetmapKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.subnet.op.data.SubnetOpDataEntryKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.subnet.op.data.subnet.op.data.entry.SubnetToDpn;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.subnet.op.data.subnet.op.data.entry.subnet.to.dpn.VpnInterfaces;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.ExternalNetworks;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.external.networks.Networks;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.external.networks.NetworksKey;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.ExternalNetworks;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.NeutronvpnListener;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.PortAddedToSubnet;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.PortRemovedFromSubnet;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.RouterAssociatedToVpn;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.RouterDisassociatedFromVpn;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.SubnetAddedToVpn;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.SubnetAddedToVpnBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.SubnetDeletedFromVpn;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.SubnetDeletedFromVpnBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.SubnetUpdatedInVpn;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.Subnetmaps;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.subnetmaps.Subnetmap;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.subnetmaps.SubnetmapKey;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-
-import java.math.BigInteger;
-
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import com.google.common.base.Optional;
-
-
public class VpnSubnetRouteHandler implements NeutronvpnListener {
private static final Logger logger = LoggerFactory.getLogger(VpnSubnetRouteHandler.class);
-
- private final DataBroker broker;
- private SubnetOpDpnManager subOpDpnManager;
+ private final DataBroker dataBroker;
+ private final SubnetOpDpnManager subOpDpnManager;
private final IBgpManager bgpManager;
- private IdManagerService idManager;
- private VpnInterfaceManager vpnInterfaceManager;
-
- public VpnSubnetRouteHandler(final DataBroker db, IBgpManager bgpManager, VpnInterfaceManager vpnIntfManager) {
- broker = db;
- subOpDpnManager = new SubnetOpDpnManager(broker);
+ private final VpnInterfaceManager vpnInterfaceManager;
+ private final IdManagerService idManager;
+
+ public VpnSubnetRouteHandler(final DataBroker dataBroker, final SubnetOpDpnManager subnetOpDpnManager,
+ final IBgpManager bgpManager, final VpnInterfaceManager vpnIntfManager,
+ final IdManagerService idManager) {
+ this.dataBroker = dataBroker;
+ this.subOpDpnManager = subnetOpDpnManager;
this.bgpManager = bgpManager;
this.vpnInterfaceManager = vpnIntfManager;
- }
-
- public void setIdManager(IdManagerService idManager) {
this.idManager = idManager;
}
// Please check if subnetId belongs to an External Network
InstanceIdentifier<Subnetmap> subMapid = InstanceIdentifier.builder(Subnetmaps.class).
child(Subnetmap.class, new SubnetmapKey(subnetId)).build();
- Optional<Subnetmap> sm = VpnUtil.read(broker, LogicalDatastoreType.CONFIGURATION, subMapid);
+ Optional<Subnetmap> sm = VpnUtil.read(dataBroker, LogicalDatastoreType.CONFIGURATION, subMapid);
if (!sm.isPresent()) {
logger.error("onSubnetAddedToVpn: Unable to retrieve subnetmap entry for subnet : " + subnetId);
return;
subMap = sm.get();
InstanceIdentifier<Networks> netsIdentifier = InstanceIdentifier.builder(ExternalNetworks.class).
child(Networks.class, new NetworksKey(subMap.getNetworkId())).build();
- Optional<Networks> optionalNets = VpnUtil.read(broker, LogicalDatastoreType.CONFIGURATION, netsIdentifier);
+ Optional<Networks> optionalNets = VpnUtil.read(dataBroker, LogicalDatastoreType.CONFIGURATION, netsIdentifier);
if (optionalNets.isPresent()) {
logger.info("onSubnetAddedToVpn: subnet {} is an external subnet on external network {}, so ignoring this for SubnetRoute",
subnetId.getValue(), subMap.getNetworkId().getValue());
//Create and add SubnetOpDataEntry object for this subnet to the SubnetOpData container
InstanceIdentifier<SubnetOpDataEntry> subOpIdentifier = InstanceIdentifier.builder(SubnetOpData.class).
child(SubnetOpDataEntry.class, new SubnetOpDataEntryKey(subnetId)).build();
- Optional<SubnetOpDataEntry> optionalSubs = VpnUtil.read(broker,
+ Optional<SubnetOpDataEntry> optionalSubs = VpnUtil.read(dataBroker,
LogicalDatastoreType.OPERATIONAL,
subOpIdentifier);
if (optionalSubs.isPresent()) {
SubnetOpDataEntryBuilder subOpBuilder = new SubnetOpDataEntryBuilder().setKey(new SubnetOpDataEntryKey(subnetId));
subOpBuilder.setSubnetId(subnetId);
subOpBuilder.setSubnetCidr(subnetIp);
- String rd = VpnUtil.getVpnRdFromVpnInstanceConfig(broker, vpnName);
+ String rd = VpnUtil.getVpnRdFromVpnInstanceConfig(dataBroker, vpnName);
if (rd == null) {
logger.error("onSubnetAddedToVpn: The VPN Instance name " + notification.getVpnName() + " does not have RD ");
return;
List<Uuid> portList = subMap.getPortList();
if (portList != null) {
for (Uuid port: portList) {
- Interface intfState = InterfaceUtils.getInterfaceStateFromOperDS(broker,port.getValue());
+ Interface intfState = InterfaceUtils.getInterfaceStateFromOperDS(dataBroker,port.getValue());
if (intfState != null) {
dpnId = InterfaceUtils.getDpIdFromInterface(intfState);
if (dpnId == null) {
}
subOpEntry = subOpBuilder.build();
- MDSALUtil.syncWrite(broker, LogicalDatastoreType.OPERATIONAL, subOpIdentifier, subOpEntry);
- logger.info("onSubnetAddedToVpn: Added subnetopdataentry to OP Datastore for subnet " + subnetId.getValue());
+ MDSALUtil.syncWrite(dataBroker, LogicalDatastoreType.OPERATIONAL, subOpIdentifier, subOpEntry);
+ logger.info("onSubnetAddedToVpn: Added subnetopdataentry to OP Datastore for subnet {}",
+ subnetId.getValue());
} catch (Exception ex) {
logger.error("Creation of SubnetOpDataEntry for subnet " +
subnetId.getValue() + " failed {}", ex);
InstanceIdentifier<SubnetOpDataEntry> subOpIdentifier = InstanceIdentifier.builder(SubnetOpData.class).
child(SubnetOpDataEntry.class, new SubnetOpDataEntryKey(subnetId)).build();
logger.trace(" Removing the SubnetOpDataEntry node for subnet: " + subnetId.getValue());
- Optional<SubnetOpDataEntry> optionalSubs = VpnUtil.read(broker,
+ Optional<SubnetOpDataEntry> optionalSubs = VpnUtil.read(dataBroker,
LogicalDatastoreType.OPERATIONAL,
subOpIdentifier);
if (!optionalSubs.isPresent()) {
*/
InstanceIdentifier<Subnetmap> subMapid = InstanceIdentifier.builder(Subnetmaps.class).
child(Subnetmap.class, new SubnetmapKey(subnetId)).build();
- Optional<Subnetmap> sm = VpnUtil.read(broker, LogicalDatastoreType.CONFIGURATION, subMapid);
+ Optional<Subnetmap> sm = VpnUtil.read(dataBroker, LogicalDatastoreType.CONFIGURATION, subMapid);
if (!sm.isPresent()) {
logger.error("Stale ports removal: Unable to retrieve subnetmap entry for subnet : " + subnetId);
} else {
InstanceIdentifier<PortOpDataEntry> portOpIdentifier = InstanceIdentifier.builder(PortOpData.class).
child(PortOpDataEntry.class, new PortOpDataEntryKey(port.getValue())).build();
logger.trace("Deleting portOpData entry for port " + port.getValue());
- MDSALUtil.syncDelete(broker, LogicalDatastoreType.OPERATIONAL, portOpIdentifier);
+ MDSALUtil.syncDelete(dataBroker, LogicalDatastoreType.OPERATIONAL, portOpIdentifier);
}
}
}
String rd = subOpBuilder.getVrfId();
String subnetIp = subOpBuilder.getSubnetCidr();
String vpnName = subOpBuilder.getVpnName();
- MDSALUtil.syncDelete(broker, LogicalDatastoreType.OPERATIONAL, subOpIdentifier);
+ MDSALUtil.syncDelete(dataBroker, LogicalDatastoreType.OPERATIONAL, subOpIdentifier);
logger.info("onSubnetDeletedFromVpn: Removed subnetopdataentry for subnet {} successfully from Datastore", subnetId.getValue());
try {
//Withdraw the routes for all the interfaces on this subnet
InstanceIdentifier<SubnetOpDataEntry> subOpIdentifier = InstanceIdentifier.builder(SubnetOpData.class).
child(SubnetOpDataEntry.class, new SubnetOpDataEntryKey(subnetId)).build();
- Optional<SubnetOpDataEntry> optionalSubs = VpnUtil.read(broker,
+ Optional<SubnetOpDataEntry> optionalSubs = VpnUtil.read(dataBroker,
LogicalDatastoreType.OPERATIONAL,
subOpIdentifier);
if (optionalSubs.isPresent()) {
InstanceIdentifier<SubnetOpDataEntry> subOpIdentifier = InstanceIdentifier.builder(SubnetOpData.class).
child(SubnetOpDataEntry.class, new SubnetOpDataEntryKey(subnetId)).build();
- Optional<SubnetOpDataEntry> optionalSubs = VpnUtil.read(broker, LogicalDatastoreType.OPERATIONAL,
+ Optional<SubnetOpDataEntry> optionalSubs = VpnUtil.read(dataBroker, LogicalDatastoreType.OPERATIONAL,
subOpIdentifier);
if (!optionalSubs.isPresent()) {
logger.info("onPortAddedToSubnet: Port " + portId.getValue() + " is part of a subnet " + subnetId.getValue() +
" that is not in VPN, ignoring");
return;
}
- Interface intfState = InterfaceUtils.getInterfaceStateFromOperDS(broker,portId.getValue());
+ Interface intfState = InterfaceUtils.getInterfaceStateFromOperDS(dataBroker,portId.getValue());
if (intfState == null) {
// Interface State not yet available
subOpDpnManager.addPortOpDataEntry(portId.getValue(), subnetId, null);
}
}
SubnetOpDataEntry subOpEntry = subOpBuilder.build();
- MDSALUtil.syncWrite(broker, LogicalDatastoreType.OPERATIONAL, subOpIdentifier, subOpEntry);
+ MDSALUtil.syncWrite(dataBroker, LogicalDatastoreType.OPERATIONAL, subOpIdentifier, subOpEntry);
logger.info("onPortAddedToSubnet: Updated subnetopdataentry to OP Datastore for port " + portId.getValue());
} catch (Exception ex) {
boolean last = subOpDpnManager.removeInterfaceFromDpn(subnetId, dpnId, portId.getValue());
InstanceIdentifier<SubnetOpDataEntry> subOpIdentifier = InstanceIdentifier.builder(SubnetOpData.class).
child(SubnetOpDataEntry.class, new SubnetOpDataEntryKey(subnetId)).build();
- Optional<SubnetOpDataEntry> optionalSubs = VpnUtil.read(broker, LogicalDatastoreType.OPERATIONAL,
+ Optional<SubnetOpDataEntry> optionalSubs = VpnUtil.read(dataBroker, LogicalDatastoreType.OPERATIONAL,
subOpIdentifier);
if (!optionalSubs.isPresent()) {
logger.info("onPortRemovedFromSubnet: Port " + portId.getValue() + " is part of a subnet " + subnetId.getValue() +
}
}
subOpEntry = subOpBuilder.build();
- MDSALUtil.syncWrite(broker, LogicalDatastoreType.OPERATIONAL, subOpIdentifier, subOpEntry);
+ MDSALUtil.syncWrite(dataBroker, LogicalDatastoreType.OPERATIONAL, subOpIdentifier, subOpEntry);
logger.info("onPortRemovedFromSubnet: Updated subnetopdataentry to OP Datastore removing port " + portId.getValue());
} catch (Exception ex) {
logger.error("Creation of SubnetOpDataEntry for subnet " +
try {
InstanceIdentifier<SubnetOpDataEntry> subOpIdentifier = InstanceIdentifier.builder(SubnetOpData.class).
child(SubnetOpDataEntry.class, new SubnetOpDataEntryKey(subnetId)).build();
- Optional<SubnetOpDataEntry> optionalSubs = VpnUtil.read(broker, LogicalDatastoreType.OPERATIONAL,
+ Optional<SubnetOpDataEntry> optionalSubs = VpnUtil.read(dataBroker, LogicalDatastoreType.OPERATIONAL,
subOpIdentifier);
if (!optionalSubs.isPresent()) {
logger.error("onInterfaceUp: SubnetOpDataEntry for subnet " + subnetId.getValue() +
}
}
SubnetOpDataEntry subOpEntry = subOpBuilder.build();
- MDSALUtil.syncWrite(broker, LogicalDatastoreType.OPERATIONAL, subOpIdentifier, subOpEntry);
+ MDSALUtil.syncWrite(dataBroker, LogicalDatastoreType.OPERATIONAL, subOpIdentifier, subOpEntry);
logger.info("onInterfaceUp: Updated subnetopdataentry to OP Datastore port up " + intfName);
} catch (Exception ex) {
logger.error("Creation of SubnetOpDataEntry for subnet " +
boolean last = subOpDpnManager.removeInterfaceFromDpn(subnetId, dpnId, interfaceName);
InstanceIdentifier<SubnetOpDataEntry> subOpIdentifier = InstanceIdentifier.builder(SubnetOpData.class).
child(SubnetOpDataEntry.class, new SubnetOpDataEntryKey(subnetId)).build();
- Optional<SubnetOpDataEntry> optionalSubs = VpnUtil.read(broker,
+ Optional<SubnetOpDataEntry> optionalSubs = VpnUtil.read(dataBroker,
LogicalDatastoreType.OPERATIONAL,
subOpIdentifier);
if (!optionalSubs.isPresent()) {
}
}
subOpEntry = subOpBuilder.build();
- MDSALUtil.syncWrite(broker, LogicalDatastoreType.OPERATIONAL, subOpIdentifier, subOpEntry);
+ MDSALUtil.syncWrite(dataBroker, LogicalDatastoreType.OPERATIONAL, subOpIdentifier, subOpEntry);
logger.info("onInterfaceDown: Updated subnetopdataentry to OP Datastore port down " + interfaceName);
} catch (Exception ex) {
logger.error("Creation of SubnetOpDataEntry for subnet " +
Preconditions.checkNotNull(subnetIp, "SubnetRouteIp cannot be null or empty!");
Preconditions.checkNotNull(vpnName, "vpnName cannot be null or empty!");
Preconditions.checkNotNull(elanTag, "elanTag cannot be null or empty!");
- String nexthopIp = InterfaceUtils.getEndpointIpAddressForDPN(broker, nhDpnId);
+ String nexthopIp = InterfaceUtils.getEndpointIpAddressForDPN(dataBroker, nhDpnId);
if(nexthopIp != null)
vpnInterfaceManager.addSubnetRouteFibEntryToDS(rd, vpnName, subnetIp, nexthopIp, label, elanTag, nhDpnId , null);
else
Preconditions.checkNotNull(nhDpnId, "nhDpnId cannot be null or empty!");
Preconditions.checkNotNull(vpnName, "vpnName cannot be null or empty!");
String nexthopIp = null;
- nexthopIp = InterfaceUtils.getEndpointIpAddressForDPN(broker, nhDpnId);
+ nexthopIp = InterfaceUtils.getEndpointIpAddressForDPN(dataBroker, nhDpnId);
if (nexthopIp == null) {
logger.error("createSubnetRouteInVpn: Unable to obtain endpointIp address for DPNId " + nhDpnId);
throw new Exception("Unable to obtain endpointIp address for DPNId " + nhDpnId);
+++ /dev/null
-/*
- * Copyright (c) 2016 Hewlett Packard Enterprise, Co. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-
-package org.opendaylight.netvirt.vpnmanager;
-
-import org.opendaylight.netvirt.elanmanager.api.IElanService;
-
-/**
- * FIXME :This is a temp hack to access OSGi services from blueprint.
- * Can be removed after vpnmanager migration to blueprint is complete https://git.opendaylight.org/gerrit/#/c/39012/
- *
- */
-public class VpnmanagerServiceAccessor {
- private static IElanService elanProvider;
-
- public VpnmanagerServiceAccessor(IElanService elanProvider) {
- VpnmanagerServiceAccessor.elanProvider = elanProvider;
- }
-
- public static IElanService getElanProvider() {
- return elanProvider;
- }
-
-}
+++ /dev/null
-/*
- * Copyright (c) 2015 - 2016 Ericsson India Global Services Pvt Ltd. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.netvirt.vpnmanager;
-
-import java.math.BigInteger;
-import java.util.concurrent.ExecutionException;
-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.sal.binding.api.BindingAwareBroker;
-import org.opendaylight.controller.sal.binding.api.BindingAwareBroker.ProviderContext;
-import org.opendaylight.controller.sal.binding.api.BindingAwareProvider;
-import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
-import org.opendaylight.netvirt.bgpmanager.api.IBgpManager;
-import org.opendaylight.netvirt.fibmanager.api.IFibManager;
-import org.opendaylight.netvirt.vpnmanager.api.IVpnManager;
-import org.opendaylight.netvirt.vpnmanager.intervpnlink.InterVpnLinkListener;
-import org.opendaylight.netvirt.vpnmanager.intervpnlink.InterVpnLinkNodeListener;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fib.rpc.rev160121.FibRpcService;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.NeutronvpnService;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.vpn.rpc.rev160201.VpnRpcService;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service.rev130709.PacketProcessingService;
-import org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.arputil.rev160406.OdlArputilService;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.CreateIdPoolInput;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.CreateIdPoolInputBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.IdManagerService;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.OdlInterfaceRpcService;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.ItmRpcService;
-import org.opendaylight.yangtools.yang.common.RpcResult;
-import org.osgi.framework.BundleContext;
-import org.osgi.framework.ServiceRegistration;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-public class VpnserviceProvider implements BindingAwareProvider, IVpnManager, AutoCloseable {
-
- private static final Logger LOG = LoggerFactory.getLogger(VpnserviceProvider.class);
- private VpnInterfaceManager vpnInterfaceManager;
- private VpnManager vpnManager;
- private ArpScheduler arpscheduler;
- private IBgpManager bgpManager;
- private FibRpcService fibService;
- private IFibManager fibManager;
- private IMdsalApiManager mdsalManager;
- private OdlInterfaceRpcService odlInterfaceRpcService;
- private ItmRpcService itmRpcService;
- private IdManagerService idManager;
- private OdlArputilService arpManager;
- private NeutronvpnService neuService;
- private NotificationService notificationService;
- private RpcProviderRegistry rpcProviderRegistry;
- private BindingAwareBroker.RpcRegistration<VpnRpcService> rpcRegistration;
- private NotificationPublishService notificationPublishService;
- private PacketProcessingService m_packetProcessingService;
- private SubnetRoutePacketInHandler subnetRoutePacketInHandler;
- private InterVpnLinkListener interVpnLinkListener;
- private static DataBroker dataBroker;
- private InterVpnLinkNodeListener interVpnLinkNodeListener;
- private TunnelInterfaceStateListener tunIntfStateListener;
- private BundleContext bundleContext;
- private FloatingIpGarpHandler garpHandler;
-
- public VpnserviceProvider(BundleContext bundleContext) {
- this.bundleContext = bundleContext;
- }
-
- public static DataBroker getDataBroker() {
- return dataBroker;
- }
-
-
- @Override
- public void onSessionInitiated(ProviderContext session) {
- LOG.info("VpnserviceProvider Session Initiated");
- try {
- dataBroker = session.getSALService(DataBroker.class);
- vpnManager = new VpnManager(dataBroker, bgpManager);
- vpnManager.setIdManager(idManager);
- vpnInterfaceManager = new VpnInterfaceManager(dataBroker, bgpManager, notificationService);
- tunIntfStateListener = new TunnelInterfaceStateListener(dataBroker, bgpManager);
- vpnInterfaceManager.setMdsalManager(mdsalManager);
- vpnInterfaceManager.setIfaceMgrRpcService(odlInterfaceRpcService);
- vpnInterfaceManager.setIdManager(idManager);
- vpnInterfaceManager.setArpManager(arpManager);
- vpnInterfaceManager.setNeutronvpnManager(neuService);
- vpnInterfaceManager.setNotificationPublishService(notificationPublishService);
- vpnManager.setVpnInterfaceManager(vpnInterfaceManager);
- fibService = rpcProviderRegistry.getRpcService(FibRpcService.class);
- itmRpcService = rpcProviderRegistry.getRpcService(ItmRpcService.class);
- vpnInterfaceManager.setFibRpcService(fibService);
- tunIntfStateListener.setITMRpcService(itmRpcService);
- VpnRpcService vpnRpcService = new VpnRpcServiceImpl(idManager, vpnInterfaceManager, dataBroker);
- rpcRegistration = getRpcProviderRegistry().addRpcImplementation(VpnRpcService.class, vpnRpcService);
- //Handles subnet route entries
- subnetRoutePacketInHandler = new SubnetRoutePacketInHandler(dataBroker, idManager);
- m_packetProcessingService = session.getRpcService(PacketProcessingService.class);
- subnetRoutePacketInHandler.setPacketProcessingService(m_packetProcessingService);
- notificationService.registerNotificationListener(subnetRoutePacketInHandler);
- interVpnLinkListener = new InterVpnLinkListener(dataBroker, idManager, mdsalManager, bgpManager,
- notificationPublishService);
- interVpnLinkNodeListener = new InterVpnLinkNodeListener(dataBroker, mdsalManager);
- createIdPool();
- RouterInterfaceListener routerListener = new RouterInterfaceListener(dataBroker);
- arpscheduler = new ArpScheduler(odlInterfaceRpcService, dataBroker);
- routerListener.setVpnInterfaceManager(vpnInterfaceManager);
- garpHandler = new FloatingIpGarpHandler(dataBroker);
- garpHandler.setPacketService(m_packetProcessingService);
-
- //ServiceRegistration serviceRegistration = bundleContext.registerService(IVpnManager.)
- } catch (Exception e) {
- LOG.error("Error initializing services", e);
- }
- }
-
- public void setNotificationService(NotificationService notificationService) {
- this.notificationService = notificationService;
- }
-
- public void setBgpManager(IBgpManager bgpManager) {
- LOG.debug("BGP Manager reference initialized");
- this.bgpManager = bgpManager;
- }
-
- public void setMdsalManager(IMdsalApiManager mdsalManager) {
- this.mdsalManager = mdsalManager;
- }
-
- public void setOdlInterfaceRpcService(OdlInterfaceRpcService odlInterfaceRpcService) {
- this.odlInterfaceRpcService = odlInterfaceRpcService;
- }
-
- public void setIdManager(IdManagerService idManager) {
- this.idManager = idManager;
- }
-
- public void setArpManager(OdlArputilService arpManager) {
- this.arpManager = arpManager;
- }
-
- public void setRpcProviderRegistry(RpcProviderRegistry rpcProviderRegistry) {
- this.rpcProviderRegistry = rpcProviderRegistry;
- }
-
- private RpcProviderRegistry getRpcProviderRegistry() {
- return rpcProviderRegistry;
- }
-
- public void setNotificationPublishService(NotificationPublishService notificationPublishService) {
- this.notificationPublishService = notificationPublishService;
- }
-
- private void createIdPool() {
- CreateIdPoolInput createPool = new CreateIdPoolInputBuilder()
- .setPoolName(VpnConstants.VPN_IDPOOL_NAME)
- .setLow(VpnConstants.VPN_IDPOOL_START)
- .setHigh(new BigInteger(VpnConstants.VPN_IDPOOL_SIZE).longValue())
- .build();
- try {
- Future<RpcResult<Void>> result = idManager.createIdPool(createPool);
- if ((result != null) && (result.get().isSuccessful())) {
- LOG.debug("Created IdPool for VPN Service");
- }
- } catch (InterruptedException | ExecutionException e) {
- LOG.error("Failed to create idPool for VPN Service",e);
- }
- }
-
- @Override
- public void close() throws Exception {
- vpnManager.close();
- vpnInterfaceManager.close();
- tunIntfStateListener.close();
- interVpnLinkListener.close();
- interVpnLinkNodeListener.close();
-
- }
-
- @Override
- public void setFibManager(IFibManager fibManager) {
- LOG.debug("Fib service reference is initialized in VPN Manager");
- this.fibManager = fibManager;
- vpnInterfaceManager.setFibManager(fibManager);
- tunIntfStateListener.setFibManager(fibManager);
- }
-
- @Override
- public void addExtraRoute(String destination, String nextHop, String rd, String routerID, int label) {
- LOG.info("Adding extra route with destination {}, nextHop {} and label{}", destination, nextHop, label);
- vpnInterfaceManager.addExtraRoute(destination, nextHop, rd, routerID, label, /*intfName*/ null);
- }
-
- @Override
- public void delExtraRoute(String destination, String nextHop, String rd, String routerID) {
- LOG.info("Deleting extra route with destination {} and nextHop {}", destination, nextHop);
- vpnInterfaceManager.delExtraRoute(destination, nextHop, rd, routerID, null);
- }
-
- @Override
- public boolean existsVpn(String vpnName) {
- return vpnManager.getVpnInstance(vpnName) != null;
- }
-
- @Override
- public boolean isVPNConfigured() {
- return vpnManager.isVPNConfigured();
- }
-}
*/
package org.opendaylight.netvirt.vpnmanager.intervpnlink;
-
import com.google.common.base.Preconditions;
import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
+import java.math.BigInteger;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Future;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.DataChangeListener;
import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.Flow;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.FlowBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.FlowKey;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.*;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.AllocateIdInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.AllocateIdInputBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.AllocateIdOutput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.IdManagerService;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.ReleaseIdInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.ReleaseIdInputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.vrfentries.VrfEntry;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.netvirt.inter.vpn.link.rev160311.InterVpnLinkCreationError;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.netvirt.inter.vpn.link.rev160311.InterVpnLinkCreationErrorBuilder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import java.math.BigInteger;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.concurrent.ExecutionException;
-import java.util.concurrent.Future;
-
-public class InterVpnLinkListener extends AbstractDataChangeListener<InterVpnLink> {
- private static final Logger logger = LoggerFactory.getLogger(InterVpnLinkListener.class);
+public class InterVpnLinkListener extends AbstractDataChangeListener<InterVpnLink> implements AutoCloseable {
+ private static final Logger LOG = LoggerFactory.getLogger(InterVpnLinkListener.class);
+ private ListenerRegistration<DataChangeListener> listenerRegistration;
+ private final DataBroker dataBroker;
+ private final IMdsalApiManager mdsalManager;
+ private final IdManagerService idManager;
+ private final IBgpManager bgpManager;
+ private final NotificationPublishService notificationsService;
private static final String NBR_OF_DPNS_PROPERTY_NAME = "vpnservice.intervpnlink.number.dpns";
private static final int INVALID_ID = 0;
- private IMdsalApiManager mdsalManager;
- private IdManagerService idManager;
- private IBgpManager bgpManager;
- private NotificationPublishService notificationsService;
-
- private ListenerRegistration<DataChangeListener> listenerRegistration;
- private final DataBroker broker;
-
-
- public InterVpnLinkListener(DataBroker db, IdManagerService idManager, IMdsalApiManager mdsalManager,
- IBgpManager bgpManager, NotificationPublishService notifService) {
+ public InterVpnLinkListener(final DataBroker dataBroker, final IdManagerService idManager,
+ final IMdsalApiManager mdsalManager, final IBgpManager bgpManager,
+ final NotificationPublishService notifService) {
super(InterVpnLink.class);
- this.broker = db;
+ this.dataBroker = dataBroker;
this.idManager = idManager;
this.mdsalManager = mdsalManager;
this.bgpManager = bgpManager;
this.notificationsService = notifService;
- this.registerListener(db);
}
- public void close() {
- if (listenerRegistration != null) {
- try {
- listenerRegistration.close();
- } catch (final Exception e) {
- logger.error("Error when cleaning up DataChangeListener.", e);
- }
- listenerRegistration = null;
- }
- }
-
-
- /**
- * Register the databroker to all the possible changes from MDSAL - InterVpnLink class
- *
- * @param db dataBroker service reference
- */
- private void registerListener(DataBroker db) {
- try {
- this.listenerRegistration = db.registerDataChangeListener(LogicalDatastoreType.CONFIGURATION,
- this.getWildCardPath(),
- this,
- AsyncDataBroker.DataChangeScope.SUBTREE);
- } catch (Exception e) {
- logger.error("InterVpnLinkListener: DataChange listener registration fail!", e);
- throw new IllegalStateException("InterVpnLinkListener: registration Listener failed.", e);
- }
+ public void start() {
+ LOG.info("{} start", getClass().getSimpleName());
+ listenerRegistration = dataBroker.registerDataChangeListener(LogicalDatastoreType.CONFIGURATION,
+ getWildCardPath(), this, AsyncDataBroker.DataChangeScope.SUBTREE);
}
private InstanceIdentifier<InterVpnLink> getWildCardPath() {
return InstanceIdentifier.create(InterVpnLinks.class).child(InterVpnLink.class);
}
+ @Override
+ public void close() throws Exception {
+ if (listenerRegistration != null) {
+ listenerRegistration.close();
+ listenerRegistration = null;
+ }
+ LOG.info("{} close", getClass().getSimpleName());
+ }
+
private String getInterVpnLinkIfaceName(String vpnUuid, BigInteger dpnId ) {
return String.format("InterVpnLink.%s.%s", vpnUuid, dpnId.toString());
}
// Create VpnLink state
InstanceIdentifier<InterVpnLinkState> vpnLinkStateIid = VpnUtil.getInterVpnLinkStateIid(add.getName());
InterVpnLinkState vpnLinkState = new InterVpnLinkStateBuilder().setInterVpnLinkName(add.getName()).build();
- MDSALUtil.syncWrite(broker, LogicalDatastoreType.CONFIGURATION, vpnLinkStateIid, vpnLinkState);
+ MDSALUtil.syncWrite(dataBroker, LogicalDatastoreType.CONFIGURATION, vpnLinkStateIid, vpnLinkState);
InterVpnLinkKey key = add.getKey();
Uuid firstEndpointVpnUuid = add.getFirstEndpoint().getVpnUuid();
if (!checkVpnAvailability(key, firstEndpointVpnUuid)) {
String errMsg = String.format("Vpn already associated with a previous inter-vpn-link {}",
firstEndpointVpnUuid);
- logger.error(errMsg);
+ LOG.error(errMsg);
setInError(vpnLinkStateIid, vpnLinkState, errMsg);
return;
}
if (!checkVpnAvailability(key, secondEndpointVpnUuid)) {
String errMsg = String.format("Vpn already associated with a previous inter-vpn-link {}",
secondEndpointVpnUuid);
- logger.error(errMsg);
+ LOG.error(errMsg);
setInError(vpnLinkStateIid, vpnLinkState, errMsg);
return;
}
// TODO: Doing like this we are retrieving operative DPNs from MDSAL when we just need one. Fix it
- List<BigInteger> firstDpnList = VpnUtil.pickRandomDPNs(broker, numberOfDpns, null);
+ List<BigInteger> firstDpnList = VpnUtil.pickRandomDPNs(dataBroker, numberOfDpns, null);
if (firstDpnList != null && !firstDpnList.isEmpty()) {
// TODO: Limitation to be solved later
- // List<BigInteger> secondDpnList = VpnUtil.pickRandomDPNs(broker, numberOfDpns, firstDpnList);
+ // List<BigInteger> secondDpnList = VpnUtil.pickRandomDPNs(dataBroker, numberOfDpns, firstDpnList);
List<BigInteger> secondDpnList = firstDpnList;
Integer firstVpnLportTag = allocateVpnLinkLportTag(key.getName() + firstEndpointVpnUuid.getValue());
new SecondEndpointStateBuilder().setVpnUuid(secondEndpointVpnUuid).setDpId(secondDpnList)
.setLportTag(secondVpnLportTag).build();
- InterVpnLinkUtil.updateInterVpnLinkState(broker, add.getName(), InterVpnLinkState.State.Active, firstEndPointState,
+ InterVpnLinkUtil.updateInterVpnLinkState(dataBroker, add.getName(), InterVpnLinkState.State.Active, firstEndPointState,
secondEndPointState);
// Note that in the DPN of the firstEndpoint we install the lportTag of the secondEndpoint and viceversa
- InterVpnLinkUtil.installLPortDispatcherTableFlow(broker, mdsalManager, add, firstDpnList,
+ InterVpnLinkUtil.installLPortDispatcherTableFlow(dataBroker, mdsalManager, add, firstDpnList,
secondEndpointVpnUuid, secondVpnLportTag);
- InterVpnLinkUtil.installLPortDispatcherTableFlow(broker, mdsalManager, add, secondDpnList,
+ InterVpnLinkUtil.installLPortDispatcherTableFlow(dataBroker, mdsalManager, add, secondDpnList,
firstEndpointVpnUuid, firstVpnLportTag);
// Update the VPN -> DPNs Map.
// Note: when a set of DPNs is calculated for Vpn1, these DPNs are added to the VpnToDpn map of Vpn2. Why?
// because we do the handover from Vpn1 to Vpn2 in those DPNs, so in those DPNs we must know how to reach
// to Vpn2 targets. If new Vpn2 targets are added later, the Fib will be maintained in these DPNs even if
// Vpn2 is not physically present there.
- InterVpnLinkUtil.updateVpnToDpnMap(broker, firstDpnList, secondEndpointVpnUuid);
- InterVpnLinkUtil.updateVpnToDpnMap(broker, secondDpnList, firstEndpointVpnUuid);
+ InterVpnLinkUtil.updateVpnToDpnMap(dataBroker, firstDpnList, secondEndpointVpnUuid);
+ InterVpnLinkUtil.updateVpnToDpnMap(dataBroker, secondDpnList, firstEndpointVpnUuid);
// Now, if the corresponding flags are activated, there will be some routes exchange
leakRoutesIfNeeded(add);
SecondEndpointState secondEndPointState =
new SecondEndpointStateBuilder().setVpnUuid(secondEndpointVpnUuid)
.setLportTag(secondVpnLportTag).build();
- InterVpnLinkUtil.updateInterVpnLinkState(broker, add.getName(), InterVpnLinkState.State.Error, firstEndPointState,
+ InterVpnLinkUtil.updateInterVpnLinkState(dataBroker, add.getName(), InterVpnLinkState.State.Error, firstEndPointState,
secondEndPointState);
}
private void leakRoutes(InterVpnLink vpnLink, String srcVpnUuid, String dstVpnUuid,
List<RouteOrigin> originsToConsider) {
- String srcVpnRd = VpnUtil.getVpnRd(broker, srcVpnUuid);
- String dstVpnRd = VpnUtil.getVpnRd(broker, dstVpnUuid);
- List<VrfEntry> srcVpnRemoteVrfEntries = VpnUtil.getVrfEntriesByOrigin(broker, srcVpnRd, originsToConsider);
+ String srcVpnRd = VpnUtil.getVpnRd(dataBroker, srcVpnUuid);
+ String dstVpnRd = VpnUtil.getVpnRd(dataBroker, dstVpnUuid);
+ List<VrfEntry> srcVpnRemoteVrfEntries = VpnUtil.getVrfEntriesByOrigin(dataBroker, srcVpnRd, originsToConsider);
for ( VrfEntry vrfEntry : srcVpnRemoteVrfEntries ) {
long label = VpnUtil.getUniqueId(idManager, VpnConstants.VPN_IDPOOL_NAME,
VpnUtil.getNextHopLabelKey(dstVpnRd, vrfEntry.getDestPrefix()));
- VpnUtil.leakRoute(broker, bgpManager, vpnLink, srcVpnUuid, dstVpnUuid,
+ VpnUtil.leakRoute(dataBroker, bgpManager, vpnLink, srcVpnUuid, dstVpnUuid,
vrfEntry.getDestPrefix(), label);
}
}
*/
private void leakExtraRoutesToVpnEndpoint(InterVpnLink vpnLink, String vpn1Uuid, String vpn2Uuid) {
- String vpn1Rd = VpnUtil.getVpnRd(broker, vpn1Uuid);
+ String vpn1Rd = VpnUtil.getVpnRd(dataBroker, vpn1Uuid);
String vpn2Endpoint = vpnLink.getSecondEndpoint().getIpAddress().getValue();
- List<VrfEntry> allVpnVrfEntries = VpnUtil.getAllVrfEntries(broker, vpn1Rd);
+ List<VrfEntry> allVpnVrfEntries = VpnUtil.getAllVrfEntries(dataBroker, vpn1Rd);
for ( VrfEntry vrfEntry : allVpnVrfEntries ) {
if ( vrfEntry.getNextHopAddressList() != null
&& vrfEntry.getNextHopAddressList().contains(vpn2Endpoint) ) {
long label = VpnUtil.getUniqueId(idManager, VpnConstants.VPN_IDPOOL_NAME,
VpnUtil.getNextHopLabelKey(vpn1Rd, vrfEntry.getDestPrefix()));
- VpnUtil.leakRoute(broker, bgpManager, vpnLink, vpn2Uuid, vpn1Uuid, vrfEntry.getDestPrefix(),
+ VpnUtil.leakRoute(dataBroker, bgpManager, vpnLink, vpn2Uuid, vpn1Uuid, vrfEntry.getDestPrefix(),
label, RouteOrigin.value(vrfEntry.getOrigin()));
}
}
private boolean checkVpnAvailability(InterVpnLinkKey key, Uuid vpnId) {
Preconditions.checkNotNull(vpnId);
- List<InterVpnLink> interVpnLinks = VpnUtil.getAllInterVpnLinks(broker);
+ List<InterVpnLink> interVpnLinks = VpnUtil.getAllInterVpnLinks(dataBroker);
if ( interVpnLinks != null ) {
for (InterVpnLink interVpnLink : interVpnLinks) {
if (!key.equals(interVpnLink.getKey())
// For each endpoint, remove all routes that have been learnt by intervpnLink
String vpn1Uuid = del.getFirstEndpoint().getVpnUuid().getValue();
- String rd1 = VpnUtil.getVpnRdFromVpnInstanceConfig(broker, vpn1Uuid);
- VpnUtil.removeVrfEntriesByOrigin(broker, rd1, RouteOrigin.INTERVPN);
- VpnUtil.removeVrfEntriesByNexthop(broker, rd1, del.getSecondEndpoint().getIpAddress().getValue());
+ String rd1 = VpnUtil.getVpnRdFromVpnInstanceConfig(dataBroker, vpn1Uuid);
+ VpnUtil.removeVrfEntriesByOrigin(dataBroker, rd1, RouteOrigin.INTERVPN);
+ VpnUtil.removeVrfEntriesByNexthop(dataBroker, rd1, del.getSecondEndpoint().getIpAddress().getValue());
String vpn2Uuid = del.getSecondEndpoint().getVpnUuid().getValue();
- String rd2 = VpnUtil.getVpnRdFromVpnInstanceConfig(broker, vpn2Uuid);
- VpnUtil.removeVrfEntriesByOrigin(broker, rd2, RouteOrigin.INTERVPN);
- VpnUtil.removeVrfEntriesByNexthop(broker, rd2, del.getFirstEndpoint().getIpAddress().getValue());
+ String rd2 = VpnUtil.getVpnRdFromVpnInstanceConfig(dataBroker, vpn2Uuid);
+ VpnUtil.removeVrfEntriesByOrigin(dataBroker, rd2, RouteOrigin.INTERVPN);
+ VpnUtil.removeVrfEntriesByNexthop(dataBroker, rd2, del.getFirstEndpoint().getIpAddress().getValue());
- InterVpnLinkState interVpnLinkState = VpnUtil.getInterVpnLinkState(broker, del.getName());
+ InterVpnLinkState interVpnLinkState = VpnUtil.getInterVpnLinkState(dataBroker, del.getName());
Integer firstEndpointLportTag = interVpnLinkState.getFirstEndpointState().getLportTag();
Integer secondEndpointLportTag = interVpnLinkState.getSecondEndpointState().getLportTag();
mdsalManager.removeFlow(dpnId, flow);
// Also remove the 'fake' iface from the VpnToDpn map
- VpnUtil.removeIfaceFromVpnToDpnMap(broker, rd1, dpnId, getInterVpnLinkIfaceName(vpn1Uuid, dpnId));
+ VpnUtil.removeIfaceFromVpnToDpnMap(dataBroker, rd1, dpnId, getInterVpnLinkIfaceName(vpn1Uuid, dpnId));
}
// Removing the flow entries in 2nd Endpoint DPNs
mdsalManager.removeFlow(dpnId, flow);
// Also remove the 'fake' iface from the VpnToDpn map
- VpnUtil.removeIfaceFromVpnToDpnMap(broker, rd2, dpnId, getInterVpnLinkIfaceName(vpn2Uuid, dpnId));
+ VpnUtil.removeIfaceFromVpnToDpnMap(dataBroker, rd2, dpnId, getInterVpnLinkIfaceName(vpn2Uuid, dpnId));
}
// Release idManager wit LPortTag associated to endpoints
// Removing the InterVpnLinkState
InstanceIdentifier<InterVpnLinkState> interVpnLinkStateIid = VpnUtil.getInterVpnLinkStateIid(del.getName());
- VpnUtil.delete(broker, LogicalDatastoreType.CONFIGURATION, interVpnLinkStateIid);
+ VpnUtil.delete(dataBroker, LogicalDatastoreType.CONFIGURATION, interVpnLinkStateIid);
}
private void releaseVpnLinkLPortTag(String idKey) {
if(rpcResult.isSuccessful()) {
return rpcResult.getResult().getIdValue().intValue();
} else {
- logger.warn("RPC Call to Get Unique Id returned with Errors {}", rpcResult.getErrors());
+ LOG.warn("RPC Call to Get Unique Id returned with Errors {}", rpcResult.getErrors());
}
} catch (InterruptedException | ExecutionException e) {
- logger.warn("Exception when getting Unique Id",e);
+ LOG.warn("Exception when getting Unique Id",e);
}
return INVALID_ID;
}
new InterVpnLinkStateBuilder(vpnLinkState).setState(InterVpnLinkState.State.Error)
.setErrorDescription(errorMsg)
.build();
- WriteTransaction tx = broker.newWriteOnlyTransaction();
+ WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
tx.put(LogicalDatastoreType.CONFIGURATION, vpnLinkStateIid, vpnLinkErrorState, true);
tx.submit();
Futures.addCallback(eventFuture, new FutureCallback<Object>() {
@Override
public void onFailure(Throwable error) {
- logger.warn("Error when sending notification about InterVpnLink creation issue. InterVpnLink name={}. Error={}",
+ LOG.warn("Error when sending notification about InterVpnLink creation issue. InterVpnLink name={}. Error={}",
vpnLinkState.getInterVpnLinkName(), vpnLinkState, error);
}
@Override
public void onSuccess(Object arg) {
- logger.trace("Error notification for InterVpnLink successfully sent. VpnLink={} error={}",
+ LOG.trace("Error notification for InterVpnLink successfully sent. VpnLink={} error={}",
vpnLinkState.getInterVpnLinkName(), vpnLinkState);
}
});
* moved to some other DPN
*
*/
-public class InterVpnLinkNodeListener extends AbstractDataChangeListener<Node>
- implements AutoCloseable {
-
- private static final Logger logger = LoggerFactory.getLogger(InterVpnLinkNodeListener.class);
+public class InterVpnLinkNodeListener extends AbstractDataChangeListener<Node> implements AutoCloseable {
+ private static final Logger LOG = LoggerFactory.getLogger(InterVpnLinkNodeListener.class);
private ListenerRegistration<DataChangeListener> listenerRegistration;
+ private final DataBroker dataBroker;
+ private final IMdsalApiManager mdsalManager;
private static final String NBR_OF_DPNS_PROPERTY_NAME = "vpnservice.intervpnlink.number.dpns";
- private final DataBroker broker;
- final IMdsalApiManager mdsalManager;
- public InterVpnLinkNodeListener(final DataBroker db, IMdsalApiManager mdsalMgr) {
+ public InterVpnLinkNodeListener(final DataBroker dataBroker, final IMdsalApiManager mdsalMgr) {
super(Node.class);
- broker = db;
+ this.dataBroker = dataBroker;
mdsalManager = mdsalMgr;
- registerListener(db);
}
- @Override
- public void close() {
- if (listenerRegistration != null) {
- try {
- listenerRegistration.close();
- } catch (final Exception e) {
- logger.error("Error when cleaning up DataChangeListener.", e);
- }
- listenerRegistration = null;
- }
- }
-
- private void registerListener(final DataBroker db) {
- try {
- listenerRegistration = db.registerDataChangeListener(LogicalDatastoreType.OPERATIONAL,
- getWildCardPath(),
- InterVpnLinkNodeListener.this,
- AsyncDataBroker.DataChangeScope.SUBTREE);
- } catch (final Exception e) {
- logger.error("InterVpnLinkNodeListener: DataChange listener registration fail!", e);
- throw new IllegalStateException("InterVpnLinkNodeListener: registration Listener failed.", e);
- }
+ public void start() {
+ LOG.info("{} start", getClass().getSimpleName());
+ listenerRegistration = dataBroker.registerDataChangeListener(LogicalDatastoreType.CONFIGURATION,
+ getWildCardPath(), this, AsyncDataBroker.DataChangeScope.SUBTREE);
}
protected InstanceIdentifier<Node> getWildCardPath() {
return InstanceIdentifier.create(Nodes.class).child(Node.class);
}
+ @Override
+ public void close() throws Exception {
+ if (listenerRegistration != null) {
+ listenerRegistration.close();
+ listenerRegistration = null;
+ }
+ LOG.info("{} close", getClass().getSimpleName());
+ }
+
@Override
protected void add(InstanceIdentifier<Node> identifier, Node add) {
NodeId nodeId = add.getId();
String[] node = nodeId.getValue().split(":");
if(node.length < 2) {
- logger.warn("Unexpected nodeId {}", nodeId.getValue());
+ LOG.warn("Unexpected nodeId {}", nodeId.getValue());
return;
}
BigInteger dpId = new BigInteger(node[1]);
DataStoreJobCoordinator coordinator = DataStoreJobCoordinator.getInstance();
- coordinator.enqueueJob("IVpnLink" + dpId.toString(), new InterVpnLinkNodeAddTask(broker, mdsalManager, dpId));
+ coordinator.enqueueJob("IVpnLink" + dpId.toString(),
+ new InterVpnLinkNodeAddTask(dataBroker, mdsalManager, dpId));
}
@Override
protected void remove(InstanceIdentifier<Node> identifier, Node del) {
- logger.trace("Node {} has been deleted", identifier.firstKeyOf(Node.class).toString());
+ LOG.trace("Node {} has been deleted", identifier.firstKeyOf(Node.class).toString());
NodeId nodeId = del.getId();
String[] node = nodeId.getValue().split(":");
if(node.length < 2) {
- logger.warn("Unexpected nodeId {}", nodeId.getValue());
+ LOG.warn("Unexpected nodeId {}", nodeId.getValue());
return;
}
BigInteger dpId = new BigInteger(node[1]);
DataStoreJobCoordinator coordinator = DataStoreJobCoordinator.getInstance();
- coordinator.enqueueJob("IVpnLink" + dpId.toString(), new InterVpnLinkNodeWorker(broker, dpId));
+ coordinator.enqueueJob("IVpnLink" + dpId.toString(), new InterVpnLinkNodeWorker(dataBroker, dpId));
}
@Override
protected void update(InstanceIdentifier<Node> identifier, Node original, Node update) {
- logger.trace("Node {} has changed", identifier.firstKeyOf(Node.class).toString());
+ LOG.trace("Node {} has changed", identifier.firstKeyOf(Node.class).toString());
}
protected class InterVpnLinkNodeWorker implements Callable<List<ListenableFuture<Void>>> {
for ( InterVpnLink interVpnLink : allInterVpnLinks ) {
InterVpnLinkState interVpnLinkState = VpnUtil.getInterVpnLinkState(broker, interVpnLink.getName());
if ( interVpnLinkState == null ) {
- logger.warn("Could not find State info for InterVpnLink={}", interVpnLink.getName());
+ LOG.warn("Could not find State info for InterVpnLink={}", interVpnLink.getName());
continue;
}
try {
Thread.sleep(timeToWait);
} catch (InterruptedException e) {
- logger.warn("Interrupted while waiting for Flows removal sync.", e);
+ LOG.warn("Interrupted while waiting for Flows removal sync.", e);
}
InterVpnLink interVpnLink2 = new InterVpnLinkBuilder(interVpnLink).build();
+++ /dev/null
-/*
- * Copyright (c) 2015 - 2016 Ericsson India Global Services Pvt Ltd. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpnservice.impl.rev150216;
-
-import org.opendaylight.netvirt.vpnmanager.VpnserviceProvider;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.arputil.rev160406.OdlArputilService;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.IdManagerService;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.OdlInterfaceRpcService;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.ItmRpcService;
-import org.osgi.framework.BundleContext;
-
-public class VpnserviceImplModule extends org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpnservice.impl.rev150216.AbstractVpnserviceImplModule {
- private BundleContext bundleContext = null;
-
- public VpnserviceImplModule(org.opendaylight.controller.config.api.ModuleIdentifier identifier, org.opendaylight.controller.config.api.DependencyResolver dependencyResolver) {
- super(identifier, dependencyResolver);
- }
-
- public VpnserviceImplModule(org.opendaylight.controller.config.api.ModuleIdentifier identifier, org.opendaylight.controller.config.api.DependencyResolver dependencyResolver, org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpnservice.impl.rev150216.VpnserviceImplModule oldModule, java.lang.AutoCloseable oldInstance) {
- super(identifier, dependencyResolver, oldModule, oldInstance);
- }
-
- @Override
- public void customValidation() {
- // add custom validation form module attributes here.
- }
-
- @Override
- public java.lang.AutoCloseable createInstance() {
- IdManagerService idManager = getRpcregistryDependency().getRpcService(IdManagerService.class);
- OdlArputilService arpManager = getRpcregistryDependency().getRpcService(OdlArputilService.class);
- OdlInterfaceRpcService odlInterfaceRpcService = getRpcregistryDependency().getRpcService(OdlInterfaceRpcService.class);
-
- VpnserviceProvider provider = new VpnserviceProvider(bundleContext);
- provider.setNotificationService(getNotificationServiceDependency());
- provider.setBgpManager(getBgpmanagerDependency());
- provider.setMdsalManager(getMdsalutilDependency());
- provider.setOdlInterfaceRpcService(odlInterfaceRpcService);
- provider.setIdManager(idManager);
- provider.setArpManager(arpManager);
- provider.setRpcProviderRegistry(getRpcregistryDependency());
- provider.setNotificationPublishService(getNotificationPublishServiceDependency());
- getBrokerDependency().registerProvider(provider);
- return provider;
- }
-
- public void setBundleContext(BundleContext bundleContext) {
- this.bundleContext = bundleContext;
- }
-}
+++ /dev/null
-/*
- * Copyright (c) 2015 Ericsson India Global Services Pvt Ltd. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-/*
-* Generated file
-*
-* Generated from: yang module name: vpnservice yang module local name: vpnservice
-* Generated by: org.opendaylight.controller.config.yangjmxgenerator.plugin.JMXGenerator
-* Generated at: Fri Feb 13 17:27:11 IST 2015
-*
-* Do not modify this file unless it is present under src/main directory
-*/
-package org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpnservice.impl.rev150216;
-
-import org.opendaylight.controller.config.api.DependencyResolver;
-import org.opendaylight.controller.config.api.DynamicMBeanWithInstance;
-import org.opendaylight.controller.config.spi.Module;
-import org.osgi.framework.BundleContext;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-public class VpnserviceImplModuleFactory extends org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpnservice.impl.rev150216.AbstractVpnserviceImplModuleFactory {
- private static final Logger LOG = LoggerFactory.getLogger(VpnserviceImplModuleFactory.class);
-
- @Override
- public Module createModule(String instanceName,
- DependencyResolver dependencyResolver,
- DynamicMBeanWithInstance old, BundleContext bundleContext)
- throws Exception {
- Module module = super.createModule(instanceName, dependencyResolver, old, bundleContext);
- setModuleBundleContext(bundleContext, module);
- return module;
- }
-
- @Override
- public Module createModule(String instanceName,
- DependencyResolver dependencyResolver, BundleContext bundleContext) {
- Module module = super.createModule(instanceName, dependencyResolver, bundleContext);
- setModuleBundleContext(bundleContext, module);
- return module;
- }
-
- private void setModuleBundleContext(BundleContext bundleContext,
- Module module) {
- if (module instanceof VpnserviceImplModule) {
- ((VpnserviceImplModule)module).setBundleContext(bundleContext);
- } else {
- LOG.warn("Module is of type {} expected type {}",
- module.getClass(), VpnserviceImplModule.class);
- }
- }
-}
+++ /dev/null
-<blueprint xmlns="http://www.osgi.org/xmlns/blueprint/v1.0.0">
- <reference id="elanProvider" interface="org.opendaylight.netvirt.elanmanager.api.IElanService" availability="optional" />
- <bean id="vpnmanagerServiceAccessor" class="org.opendaylight.netvirt.vpnmanager.VpnmanagerServiceAccessor">
- <argument ref="elanProvider" />
- </bean>
-</blueprint>
--- /dev/null
+<?xml version="1.0" encoding="UTF-8"?>
+<blueprint xmlns="http://www.osgi.org/xmlns/blueprint/v1.0.0"
+ xmlns:odl="http://opendaylight.org/xmlns/blueprint/v1.0.0"
+ odl:use-default-for-reference-types="true">
+
+ <reference id="dataBroker"
+ interface="org.opendaylight.controller.md.sal.binding.api.DataBroker"
+ odl:type="default" />
+ <reference id="mdsalUtils"
+ interface="org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager" />
+ <reference id="notificationPublishService"
+ interface="org.opendaylight.controller.md.sal.binding.api.NotificationPublishService" />
+ <reference id="bgpmanager"
+ interface="org.opendaylight.netvirt.bgpmanager.api.IBgpManager" />
+ <reference id="elanService"
+ interface="org.opendaylight.netvirt.elanmanager.api.IElanService" />
+ <reference id="fibManager"
+ interface="org.opendaylight.netvirt.fibmanager.api.IFibManager" />
+
+ <odl:rpc-service id="idManagerService"
+ interface="org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.IdManagerService" />
+ <odl:rpc-service id="itmRpcService"
+ interface="org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.ItmRpcService" />
+ <odl:rpc-service id="odlInterfaceRpcService"
+ interface="org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.OdlInterfaceRpcService" />
+ <odl:rpc-service id="odlArputilService"
+ interface="org.opendaylight.yang.gen.v1.urn.opendaylight.genius.arputil.rev160406.OdlArputilService" />
+ <odl:rpc-service id="packetProcessingService"
+ interface="org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service.rev130709.PacketProcessingService" />
+
+ <bean id="dpnInVpnChangeListener"
+ class="org.opendaylight.netvirt.vpnmanager.DpnInVpnChangeListener">
+ <argument ref="dataBroker" />
+ </bean>
+ <service ref="dpnInVpnChangeListener" odl:type="default"
+ interface="org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.OdlL3vpnListener" />
+ <odl:notification-listener ref="dpnInVpnChangeListener" />
+
+ <bean id="vpnInterfaceManager"
+ class="org.opendaylight.netvirt.vpnmanager.VpnInterfaceManager"
+ init-method="start" destroy-method="close">
+ <argument ref="dataBroker" />
+ <argument ref="bgpmanager" />
+ <argument ref="odlArputilService" />
+ <argument ref="idManagerService" />
+ <argument ref="mdsalUtils" />
+ <argument ref="fibManager" />
+ <argument ref="odlInterfaceRpcService" />
+ <argument ref="notificationPublishService" />
+ </bean>
+
+ <bean id="tunnelInterfaceStateListener"
+ class="org.opendaylight.netvirt.vpnmanager.TunnelInterfaceStateListener"
+ init-method="start" destroy-method="close">
+ <argument ref="dataBroker" />
+ <argument ref="bgpmanager" />
+ <argument ref="fibManager" />
+ <argument ref="itmRpcService" />
+ </bean>
+
+ <bean id="interfaceStateChangeListener"
+ class="org.opendaylight.netvirt.vpnmanager.InterfaceStateChangeListener"
+ init-method="start" destroy-method="close">
+ <argument ref="dataBroker" />
+ <argument ref="vpnInterfaceManager" />
+ </bean>
+
+ <bean id="vpnInterfaceOpListener"
+ class="org.opendaylight.netvirt.vpnmanager.VpnInterfaceOpListener"
+ init-method="start" destroy-method="close">
+ <argument ref="dataBroker" />
+ <argument ref="vpnInterfaceManager" />
+ </bean>
+
+ <bean id="arpScheduler"
+ class="org.opendaylight.netvirt.vpnmanager.ArpScheduler"
+ init-method="start" destroy-method="close">
+ <argument ref="dataBroker" />
+ <argument ref="odlInterfaceRpcService" />
+ </bean>
+
+ <bean id="floatingIpGarpHandler"
+ class="org.opendaylight.netvirt.vpnmanager.FloatingIpGarpHandler"
+ init-method="start" destroy-method="close">
+ <argument ref="dataBroker" />
+ <argument ref="packetProcessingService" />
+ <argument ref="elanService" />
+ <argument ref="odlInterfaceRpcService" />
+ </bean>
+
+ <bean id="subnetRoutePacketInHandler"
+ class="org.opendaylight.netvirt.vpnmanager.SubnetRoutePacketInHandler">
+ <argument ref="dataBroker" />
+ <argument ref="packetProcessingService" />
+ </bean>
+ <service ref="subnetRoutePacketInHandler" odl:type="default"
+ interface="org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service.rev130709.PacketProcessingListener" />
+ <odl:notification-listener ref="subnetRoutePacketInHandler" />
+
+ <bean id="arpNotificationHandler"
+ class="org.opendaylight.netvirt.vpnmanager.ArpNotificationHandler">
+ <argument ref="vpnInterfaceManager" />
+ <argument ref="dataBroker" />
+ <argument ref="elanService" />
+ </bean>
+ <service ref="arpNotificationHandler" odl:type="default"
+ interface="org.opendaylight.yang.gen.v1.urn.opendaylight.genius.arputil.rev160406.OdlArputilListener" />
+ <odl:notification-listener ref="arpNotificationHandler" />
+
+ <bean id="subnetRouteInterfaceStateChangeListener"
+ class="org.opendaylight.netvirt.vpnmanager.SubnetRouteInterfaceStateChangeListener"
+ init-method="start" destroy-method="close">
+ <argument ref="dataBroker" />
+ <argument ref="vpnInterfaceManager" />
+ <argument ref="vpnSubnetRouteHandler" />
+ </bean>
+
+ <bean id="vpnSubnetRouteHandler"
+ class="org.opendaylight.netvirt.vpnmanager.VpnSubnetRouteHandler">
+ <argument ref="dataBroker" />
+ <argument ref="subnetOpDpnManager" />
+ <argument ref="bgpmanager" />
+ <argument ref="vpnInterfaceManager" />
+ <argument ref="idManagerService" />
+ </bean>
+ <service ref="vpnSubnetRouteHandler" odl:type="default"
+ interface="org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.NeutronvpnListener" />
+ <odl:notification-listener ref="vpnSubnetRouteHandler" />
+
+ <bean id="subnetOpDpnManager" class="org.opendaylight.netvirt.vpnmanager.SubnetOpDpnManager">
+ <argument ref="dataBroker" />
+ </bean>
+
+ <bean id="vpnManagerImpl" class="org.opendaylight.netvirt.vpnmanager.VpnManagerImpl"
+ init-method="start">
+ <argument ref="dataBroker" />
+ <argument ref="idManagerService" />
+ <argument ref="vpnInstanceListener" />
+ <argument ref="vpnInterfaceManager" />
+ </bean>
+ <service ref="vpnManagerImpl"
+ interface="org.opendaylight.netvirt.vpnmanager.api.IVpnManager" />
+
+ <bean id="vpnInstanceListener"
+ class="org.opendaylight.netvirt.vpnmanager.VpnInstanceListener"
+ init-method="start" destroy-method="close">
+ <argument ref="dataBroker" />
+ <argument ref="bgpmanager" />
+ <argument ref="idManagerService" />
+ <argument ref="vpnInterfaceManager" />
+ <argument ref="fibManager" />
+ </bean>
+
+ <bean id="fibEntriesListener" class="org.opendaylight.netvirt.vpnmanager.FibEntriesListener"
+ init-method="start" destroy-method="close">
+ <argument ref="dataBroker" />
+ <argument ref="vpnInstanceListener" />
+ </bean>
+
+ <bean id="VpnInterfaceOpListener"
+ class="org.opendaylight.netvirt.vpnmanager.VpnInterfaceOpListener"
+ init-method="start" destroy-method="close">
+ <argument ref="dataBroker" />
+ <argument ref="vpnInterfaceManager" />
+ </bean>
+
+ <bean id="routerInterfaceListener"
+ class="org.opendaylight.netvirt.vpnmanager.RouterInterfaceListener"
+ init-method="start" destroy-method="close">
+ <argument ref="dataBroker" />
+ <argument ref="vpnInterfaceManager" />
+ </bean>
+
+ <odl:rpc-implementation ref="vpnRpcServiceImpl" />
+ <bean id="vpnRpcServiceImpl"
+ class="org.opendaylight.netvirt.vpnmanager.VpnRpcServiceImpl">
+ <argument ref="dataBroker" />
+ <argument ref="idManagerService" />
+ <argument ref="vpnInterfaceManager" />
+ <argument ref="fibManager" />
+ </bean>
+ <service ref="vpnRpcServiceImpl"
+ interface="org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.vpn.rpc.rev160201.VpnRpcService" />
+
+ <bean id="interVpnLinkListener"
+ class="org.opendaylight.netvirt.vpnmanager.intervpnlink.InterVpnLinkListener"
+ init-method="start" destroy-method="close">
+ <argument ref="dataBroker" />
+ <argument ref="idManagerService" />
+ <argument ref="mdsalUtils" />
+ <argument ref="bgpmanager" />
+ <argument ref="notificationPublishService" />
+ </bean>
+
+ <bean id="interVpnLinkNodeListener"
+ class="org.opendaylight.netvirt.vpnmanager.intervpnlink.InterVpnLinkNodeListener"
+ init-method="start" destroy-method="close">
+ <argument ref="dataBroker" />
+ <argument ref="mdsalUtils" />
+ </bean>
+</blueprint>
+++ /dev/null
-module vpnservice-impl {
- yang-version 1;
- namespace "urn:opendaylight:params:xml:ns:yang:vpnservice:impl";
- prefix "vpnservice-impl";
-
- import config { prefix config; revision-date 2013-04-05; }
- import opendaylight-md-sal-binding { prefix md-sal-binding; revision-date 2013-10-28;}
- import opendaylight-sal-binding-broker-impl { prefix md-sal-binding-impl; revision-date 2013-10-28;}
- import bgpmanager-api { prefix bgpmgr-api; revision-date 2015-04-20;}
- import vpnmanager-api { prefix vpnmgr-api; revision-date 2015-05-08;}
- import odl-mdsalutil { prefix odl-mdsal; revision-date 2016-04-06;}
-
- description
- "Service definition for vpnservice project";
-
- revision "2015-02-16" {
- description
- "Initial revision";
- }
-
- identity vpnservice-impl {
- base config:module-type;
- config:provided-service vpnmgr-api:vpnmanager-api;
- config:java-name-prefix VpnserviceImpl;
- }
-
- augment "/config:modules/config:module/config:configuration" {
- case vpnservice-impl {
- when "/config:modules/config:module/config:type = 'vpnservice-impl'";
- container broker {
- uses config:service-ref {
- refine type {
- mandatory true;
- config:required-identity md-sal-binding:binding-broker-osgi-registry;
- }
- }
- }
- container rpcregistry {
- uses config:service-ref {
- refine type {
- mandatory true;
- config:required-identity md-sal-binding:binding-rpc-registry;
- }
- }
- }
- container bgpmanager {
- uses config:service-ref {
- refine type {
- mandatory true;
- config:required-identity bgpmgr-api:bgpmanager-api;
- }
- }
- }
- container mdsalutil {
- uses config:service-ref {
- refine type {
- mandatory true;
- config:required-identity odl-mdsal:odl-mdsalutil;
- }
- }
- }
- container notification-service {
- uses config:service-ref {
- refine type {
- mandatory true;
- config:required-identity md-sal-binding-impl:binding-new-notification-service;
- }
- }
- }
- container notification-publish-service {
- uses config:service-ref {
- refine type {
- mandatory true;
- config:required-identity md-sal-binding-impl:binding-new-notification-publish-service;
- }
- }
- }
- }
- }
-}
import org.opendaylight.controller.md.sal.binding.api.DataChangeListener;
import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker.DataChangeScope;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.netvirt.vpnmanager.VpnManager;
import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.af.config.vpntargets.VpnTarget;
import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.af.config.vpntargets.VpnTargetBuilder;
import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.af.config.vpntargets.VpnTargetKey;
import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.instances.*;
import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.af.config.*;
import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.af.config.apply.label.apply.label.mode.*;
-import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.af.config.apply.label.ApplyLabelMode;
import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.af.config.ApplyLabelBuilder;
import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.instances.vpn.instance.Ipv4FamilyBuilder;
VpnInstanceBuilder builder = new VpnInstanceBuilder().setKey(new VpnInstanceKey("Vpn1")).setIpv4Family
(ipv4Family);
VpnInstance instance = builder.build();
- VpnManager vpnManager = new VpnManager(dataBroker, bgpManager);
event.created.put(createVpnId("Vpn1"), instance);
//TODO: Need to enhance the test case to handle ds read/write ops
//vpnManager.onDataChanged(event);
import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.genius.interfacemanager.globals.IfmConstants;
+import org.opendaylight.netvirt.vpnmanager.SubnetOpDpnManager;
import org.opendaylight.netvirt.vpnmanager.VpnInterfaceManager;
import org.opendaylight.netvirt.vpnmanager.VpnSubnetRouteHandler;
import org.opendaylight.netvirt.vpnmanager.utilities.InterfaceUtils;
@Mock ReadOnlyTransaction mockReadTx;
@Mock WriteTransaction mockWriteTx;
@Mock IBgpManager bgpManager;
- @Mock
- VpnInterfaceManager vpnInterfaceManager;
+ @Mock VpnInterfaceManager vpnInterfaceManager;
@Mock IdManagerService idManager;
+ @Mock SubnetOpDpnManager subnetOpDpnManager;
VpnSubnetRouteHandler vpnSubnetRouteHandler;
.thenReturn(dataChangeListenerRegistration);
setupMocks();
- vpnSubnetRouteHandler = new VpnSubnetRouteHandler(dataBroker, bgpManager, vpnInterfaceManager);
- vpnSubnetRouteHandler.setIdManager(idManager);
- Future<RpcResult<AllocateIdOutput>> idOutputOptional = RpcResultBuilder.success(allocateIdOutput).buildFuture();
+ vpnSubnetRouteHandler = new VpnSubnetRouteHandler(dataBroker, subnetOpDpnManager, bgpManager,
+ vpnInterfaceManager, idManager);
+ Future<RpcResult<AllocateIdOutput>> idOutputOptional =
+ RpcResultBuilder.success(allocateIdOutput).buildFuture();
optionalIfState = Optional.of(stateInterface);
optionalSubs = Optional.of(subnetOp);
doReturn(mockReadTx).when(dataBroker).newReadOnlyTransaction();
doReturn(mockWriteTx).when(dataBroker).newWriteOnlyTransaction();
doReturn(Futures.immediateCheckedFuture(null)).when(mockWriteTx).submit();
-
}
@Test
Code Review / netvirt.git / commitdiff