<parent>
<groupId>org.opendaylight.vpnservice</groupId>
<artifactId>config-parent</artifactId>
- <version>0.0.1-SNAPSHOT</version>
+ <version>0.1.0-SNAPSHOT</version>
<relativePath>../../commons/config-parent</relativePath>
</parent>
<parent>
<groupId>org.opendaylight.vpnservice</groupId>
<artifactId>config-parent</artifactId>
- <version>0.0.1-SNAPSHOT</version>
+ <version>0.1.0-SNAPSHOT</version>
<relativePath>../../commons/config-parent</relativePath>
</parent>
protected void remove(InstanceIdentifier<BgpRouter> identifier,
BgpRouter del) {
- LOG.info("Bgp Router deleted in DS - " + "key: " + identifier + ", value=" + del);
+ LOG.debug("Bgp Router deleted in DS - key: {} value={} ", identifier, del);
removeBgpRouter(del);
protected void update(InstanceIdentifier<BgpRouter> identifier,
BgpRouter original, BgpRouter update) {
- LOG.info("Bgp Router Updated in DS - " + "key: " + identifier + ", original=" + original + ", update=" + update);
+ LOG.debug("Bgp Router Updated in DS - key: {}, original={}, update={} ", identifier, original, update);
updateBgpRouter(original, update);
}
@Override
protected void add(InstanceIdentifier<BgpRouter> identifier,
BgpRouter value) {
- LOG.info("Bgp Router added in DS - " + "key: " + identifier + ", value=" + value);
- LOG.info("Bgp Router localASNumber:" + value.getLocalAsNumber());
- LOG.info("Bgp Router localASIdentifier:" + value.getLocalAsIdentifier());
+ LOG.debug("Bgp Router added in DS - key: {}, value={} ",identifier, value);
addBgpRouter(value);
}
if(gateway != null) {
if ((gateway.getPeerAddressType() != null) && (gateway.getPeerAddressType() instanceof org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.bgp.rev130715.bgp.neighbors.bgp.neighbor.peer.address.type.IpAddress)) {
IpAddress neighborIPAddr = ((org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.bgp.rev130715.bgp.neighbors.bgp.neighbor.peer.address.type.IpAddress) gateway.getPeerAddressType()).getIpAddress();
- LOG.info("Bgp Neighbor IP Address " + neighborIPAddr.getIpv4Address().getValue());
+ LOG.debug("Bgp Neighbor IP Address {} ", neighborIPAddr.getIpv4Address().getValue());
configureBgpServer(BgpOp.DEL_NGHBR);
protected void remove(InstanceIdentifier<BgpNeighbors> identifier,
BgpNeighbors del) {
- LOG.info("Bgp Neighbors deleted in DS - " + "key: " + identifier + ", value=" + del);
+ LOG.debug("Bgp Neighbors deleted in DS - key: {}, value={} ", identifier, del);
removeBgpNeighbors(del);
}
configureBgpServer(BgpOp.DEL_NGHBR);
}
if(gateway.getAsNumber() != null) {
- LOG.info("Bgp Neighbor AS number " + gateway.getAsNumber());
+ LOG.debug("Bgp Neighbor AS number {} ", gateway.getAsNumber());
if(bgpConfiguration.getNeighbourAsNum() != gateway.getAsNumber()) {
bgpConfiguration.setNeighbourAsNum(gateway.getAsNumber());
bgpConfiguration.setConfigUpdated();
}
if((gateway.getPeerAddressType() != null) && (gateway.getPeerAddressType() instanceof org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.bgp.rev130715.bgp.neighbors.bgp.neighbor.peer.address.type.IpAddress)) {
IpAddress neighborIPAddr = ((org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.bgp.rev130715.bgp.neighbors.bgp.neighbor.peer.address.type.IpAddress)gateway.getPeerAddressType()).getIpAddress();
- LOG.info("Bgp Neighbor IP Address " + neighborIPAddr.getIpv4Address().getValue());
+ LOG.debug("Bgp Neighbor IP Address {}", neighborIPAddr.getIpv4Address().getValue());
if(bgpConfiguration.getNeighbourIp() != neighborIPAddr.getIpv4Address().getValue()) {
bgpConfiguration.setNeighbourIp(neighborIPAddr.getIpv4Address().getValue());
bgpConfiguration.setConfigUpdated();
protected void update(InstanceIdentifier<BgpNeighbors> identifier,
BgpNeighbors original, BgpNeighbors update) {
- LOG.info("Bgp Neighbors Updated in DS - " + "key: " + identifier + ", original=" + original + ", update=" + update);
+ LOG.debug("Bgp Neighbors Updated in DS - key: {}, original={}, update={} ", identifier, original, update);
updateBgpNeighbors(original, update);
if(gateway != null) {
if(gateway.getAsNumber() != null) {
- LOG.info("Bgp Neighbor AS number " + gateway.getAsNumber());
+ LOG.debug("Bgp Neighbor AS number {} ", gateway.getAsNumber());
bgpConfiguration.setNeighbourAsNum(gateway.getAsNumber());
}
if((gateway.getPeerAddressType() != null) && (gateway.getPeerAddressType() instanceof org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.bgp.rev130715.bgp.neighbors.bgp.neighbor.peer.address.type.IpAddress)) {
IpAddress neighborIPAddr = ((org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.bgp.rev130715.bgp.neighbors.bgp.neighbor.peer.address.type.IpAddress)gateway.getPeerAddressType()).getIpAddress();
- LOG.info("Bgp Neighbor IP Address " + neighborIPAddr.getIpv4Address().getValue());
+ LOG.debug("Bgp Neighbor IP Address {} ", neighborIPAddr.getIpv4Address().getValue());
bgpConfiguration.setNeighbourIp(neighborIPAddr.getIpv4Address().getValue());
}
@Override
protected void add(InstanceIdentifier<BgpNeighbors> identifier,
BgpNeighbors value) {
- LOG.info("key: " + identifier + ", value=" + value);
- LOG.info("Bgp Neighbor added in DS - " + "key: " + identifier + ", value=" + value);
+ LOG.debug("Bgp Neighbor added in DS - key: {}, value={} ", identifier, value);
addBgpNeighbors(value);
}
bgpManager.deleteNeighbor(bgpConfiguration.getNeighbourIp());
break;
default:
- LOG.info("Invalid configuration option");
+ LOG.error("Invalid configuration option {}", bgpOp);
}
retry = false;
public void startBgpService() throws TException {
if(bgpThriftClient == null) {
- LOGGER.info("Start Bgp Service - bgpThriftClient is null. Unable to start BGP service.");
+ LOGGER.error("Start Bgp Service - bgpThriftClient is null. Unable to start BGP service.");
return;
}
// Now try start bgp - if bgp is already Active, it will tell us, nothing to do then
try {
bgpThriftClient.startBgp((int)bgpConfiguration.getAsNum(), bgpConfiguration.getRouterId());
- LOGGER.info("Started BGP with AS number " + (int)bgpConfiguration.getAsNum() + " and router id " + bgpConfiguration.getRouterId());
+ LOGGER.debug("Started BGP with AS number " + (int)bgpConfiguration.getAsNum() + " and router id " + bgpConfiguration.getRouterId());
} catch (BgpRouterException be) {
if(be.getErrorCode() == BgpRouterException.BGP_ERR_ACTIVE) {
LOGGER.info("bgp server already active");
} catch (TException t) {
LOGGER.error("Could not set up thrift connection with bgp server");
- //LOGGER.trace("Transport error while starting bgp server ", t);
+ LOGGER.debug("Transport error while starting bgp server ", t);
reInitConn();
throw t;
} catch (Exception e) {
LOGGER.error("Error while starting bgp server");
- //LOGGER.trace("Bgp Service not started due to exception", e);
+ LOGGER.debug("Bgp Service not started due to exception", e);
return;
}
protected void addNeighbor(String ipAddress, long asNum) throws TException {
if(bgpThriftClient == null) {
- LOGGER.info("Add BGP Neighbor - bgpThriftClient is null. Unable to add BGP Neighbor.");
+ LOGGER.error("Add BGP Neighbor - bgpThriftClient is null. Unable to add BGP Neighbor.");
return;
}
try {
bgpThriftClient.addNeighbor(ipAddress, (int) asNum);
} catch (BgpRouterException b) {
- LOGGER.error("Failed to add BGP neighbor " + ipAddress + "due to BgpRouter Exception number " + b.getErrorCode());
- LOGGER.error("BgpRouterException trace ", b);
+ LOGGER.error("Failed to add BGP neighbor " + ipAddress + " due to BgpRouter Exception number " + b.getErrorCode());
+ LOGGER.debug("BgpRouterException trace ", b);
} catch (TException t) {
LOGGER.error(String.format("Failed adding neighbor %s due to Transport error", ipAddress));
reInitConn();
protected void deleteNeighbor(String ipAddress) throws TException {
if(bgpThriftClient == null) {
- LOGGER.info("Delete BGP Neighbor - bgpThriftClient is null. Unable to delete BGP Neighbor.");
+ LOGGER.error("Delete BGP Neighbor - bgpThriftClient is null. Unable to delete BGP Neighbor.");
return;
}
bgpThriftClient.delNeighbor(ipAddress);
} catch (BgpRouterException b) {
LOGGER.error("Failed to delete BGP neighbor " + ipAddress + "due to BgpRouter Exception number " + b.getErrorCode());
- LOGGER.error("BgpRouterException trace ", b);
+ LOGGER.debug("BgpRouterException trace ", b);
}catch (TException t) {
LOGGER.error(String.format("Failed deleting neighbor %s due to Transport error", ipAddress));
reInitConn();
@Override
public void addVrf(String rd, Collection<String> importRts, Collection<String> exportRts) throws Exception {
if(bgpThriftClient == null) {
- LOGGER.info("Add BGP vrf - bgpThriftClient is null. Unable to add BGP vrf.");
+ LOGGER.error("Add BGP vrf - bgpThriftClient is null. Unable to add BGP vrf.");
return;
}
try {
bgpThriftClient.addVrf(rd, new ArrayList<>(importRts), new ArrayList<>(exportRts));
} catch (BgpRouterException b) {
LOGGER.error("Failed to add BGP vrf " + rd + "due to BgpRouter Exception number " + b.getErrorCode());
- LOGGER.error("BgpRouterException trace ", b);
+ LOGGER.debug("BgpRouterException trace ", b);
throw b;
} catch (TException t) {
LOGGER.error(String.format("Failed adding vrf %s due to Transport error", rd));
bgpThriftClient.delVrf(rd);
} catch (BgpRouterException b) {
LOGGER.error("Failed to delete BGP vrf " + rd + "due to BgpRouter Exception number " + b.getErrorCode());
- LOGGER.error("BgpRouterException trace ", b);
+ LOGGER.debug("BgpRouterException trace ", b);
throw b;
} catch (TException t) {
LOGGER.error(String.format("Failed deleting vrf %s due to Transport error", rd));
bgpThriftClient.addPrefix(rd, prefix, nextHop, vpnLabel);
} catch (BgpRouterException b) {
LOGGER.error("Failed to add BGP prefix " + prefix + "due to BgpRouter Exception number " + b.getErrorCode());
- LOGGER.error("BgpRouterException trace ", b);
+ LOGGER.debug("BgpRouterException trace ", b);
throw b;
} catch (TException t) {
LOGGER.error(String.format("Failed adding prefix entry <vrf:prefix:nexthop:vpnlabel> %s:%s:%s:%d due to Transport error",
bgpThriftClient.delPrefix(rd, prefix);
} catch (BgpRouterException b) {
LOGGER.error("Failed to delete BGP prefix " + prefix + "due to BgpRouter Exception number " + b.getErrorCode());
- LOGGER.error("BgpRouterException trace ", b);
+ LOGGER.debug("BgpRouterException trace ", b);
throw b;
} catch (TException t) {
LOGGER.error(String.format("Failed deleting prefix entry <vrf:prefix> %s:%s due to Transport error",
}
try {
bgpThriftClient.connect(host, port);
- LOGGER.info("Connected to BGP server " + host + " on port " + port);
+ LOGGER.debug("Connected to BGP server {} on port {} ", host, port);
} catch (BgpRouterException b) {
LOGGER.error("Failed to connect to BGP server " + host + " on port " + port + " due to BgpRouter Exception number " + b.getErrorCode());
- //_logger.error("BgpRouterException trace ", b);
+ LOGGER.debug("BgpRouterException trace ", b);
throw b;
} catch (TException t) {
LOGGER.error("Failed to initialize BGP Connection due to Transport error ");
try {
bgpThriftClient.reInit();
- LOGGER.info("Reinitialized connection to BGP Server " + bgpHost);
+ LOGGER.debug("Reinitialized connection to BGP Server {}", bgpHost);
} catch (BgpRouterException b) {
- LOGGER.error("Failed to reinitialize connection to BGP server " + bgpHost + " on port " + bgpPort + " due to BgpRouter Exception number " + b.getErrorCode());
- LOGGER.error("BgpRouterException trace ", b);
+ LOGGER.error("Failed to reinitialize connection to BGP server {} on port {} due to BgpRouter Exception number {}", bgpHost, bgpPort, b.getErrorCode());
+ LOGGER.debug("BgpRouterException trace ", b);
} catch (TException t) {
LOGGER.error("Failed to reinitialize BGP Connection due to Transport error.");
}
import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.fibmanager.rev150330.fibentries.VrfTables;
import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.fibmanager.rev150330.fibentries.VrfTablesBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.fibmanager.rev150330.fibentries.VrfTablesKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.fibmanager.rev150330.vrfentries.VrfEntryKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.fibmanager.rev150330.FibEntries;
import org.slf4j.Logger;
VrfEntry vrfEntry = new VrfEntryBuilder().setDestPrefix(prefix).
setNextHopAddress(nexthop).setLabel((long)label).build();
+ logger.debug("Created vrfEntry for {} nexthop {} label {}", prefix, nexthop, label);
+
+ List<VrfEntry> vrfEntryList = new ArrayList<VrfEntry>();
+ vrfEntryList.add(vrfEntry);
- logger.info("Created vrfEntry for " + prefix + " nexthop " + nexthop + " label " + label);
InstanceIdentifierBuilder<VrfTables> idBuilder =
InstanceIdentifier.builder(FibEntries.class).child(VrfTables.class, new VrfTablesKey(rd));
-
-
InstanceIdentifier<VrfTables> vrfTableId = idBuilder.build();
- Optional<VrfTables> vrfTable = read(LogicalDatastoreType.CONFIGURATION, vrfTableId);
- if (vrfTable.isPresent()) {
- List<VrfEntry> vrfEntryListExisting = vrfTable.get().getVrfEntry();
- vrfEntryListExisting.add(vrfEntry);
+ VrfTables vrfTableNew = new VrfTablesBuilder().setRouteDistinguisher(rd).
+ setVrfEntry(vrfEntryList).build();
- VrfTables vrfTableUpdate = new VrfTablesBuilder().setRouteDistinguisher(rd).
- setVrfEntry(vrfEntryListExisting).build();
- write(LogicalDatastoreType.CONFIGURATION, vrfTableId, vrfTableUpdate);
- }
- else {
- List<VrfEntry> vrfEntryList = new ArrayList<VrfEntry>();
- vrfEntryList.add(vrfEntry);
-
- //add a new vrf table with this vrf entry
- VrfTables vrfTableNew = new VrfTablesBuilder().setRouteDistinguisher(rd).
- setVrfEntry(vrfEntryList).build();
-
-
- InstanceIdentifier<VrfTables> vrfTableNewId = InstanceIdentifier.builder(FibEntries.class)
- .child(VrfTables.class, new VrfTablesKey(rd)).build();
-
- write(LogicalDatastoreType.CONFIGURATION, vrfTableNewId, vrfTableNew);
- }
+ write(LogicalDatastoreType.CONFIGURATION, vrfTableId, vrfTableNew);
}
public synchronized void removeFibEntryFromDS(String rd, String prefix) {
- logger.debug("Removing fib entry with destination prefix " + prefix + " from vrf table for rd " + rd);
+ logger.debug("Removing fib entry with destination prefix {} from vrf table for rd {}", prefix, rd);
+
+ InstanceIdentifierBuilder<VrfEntry> idBuilder =
+ InstanceIdentifier.builder(FibEntries.class).child(VrfTables.class, new VrfTablesKey(rd)).child(VrfEntry.class, new VrfEntryKey(prefix));
+ InstanceIdentifier<VrfEntry> vrfEntryId = idBuilder.build();
+ delete(LogicalDatastoreType.CONFIGURATION, vrfEntryId);
- InstanceIdentifierBuilder<VrfTables> idBuilder =
- InstanceIdentifier.builder(FibEntries.class).child(VrfTables.class, new VrfTablesKey(rd));
- InstanceIdentifier<VrfTables> vrfTableId = idBuilder.build();
- Optional<VrfTables> vrfTable = read(LogicalDatastoreType.CONFIGURATION, vrfTableId);
- if (vrfTable.isPresent()) {
- String searchPfx = prefix;
-
- List<VrfEntry> vrfEntryListExisting = vrfTable.get().getVrfEntry();
- for (Iterator<VrfEntry> it = vrfEntryListExisting.iterator(); it.hasNext(); ) {
- VrfEntry elem = it.next();
- if (elem.getDestPrefix().equals(searchPfx)) {
- it.remove();
- break;
- }
- }
-
- VrfTables vrfTableUpdate = new VrfTablesBuilder().setRouteDistinguisher(rd).
- setVrfEntry(vrfEntryListExisting).build();
- write(LogicalDatastoreType.CONFIGURATION, vrfTableId, vrfTableUpdate);
- }
}
private <T extends DataObject> Optional<T> read(LogicalDatastoreType datastoreType,
private <T extends DataObject> void write(LogicalDatastoreType datastoreType,
InstanceIdentifier<T> path, T data) {
WriteTransaction tx = broker.newWriteOnlyTransaction();
- tx.put(datastoreType, path, data, true);
+ tx.merge(datastoreType, path, data, true);
+ tx.submit();
+ }
+
+ private <T extends DataObject> void delete(LogicalDatastoreType datastoreType, InstanceIdentifier<T> path) {
+ WriteTransaction tx = broker.newWriteOnlyTransaction();
+ tx.delete(datastoreType, path);
tx.submit();
}
}
this.bgpPort = bgpPort;
bop = new BgpOp();
try {
- LOGGER.info("Connecting to BGP Server " + bgpHost + " on port " + bgpPort);
+ LOGGER.debug("Connecting to BGP Server " + bgpHost + " on port " + bgpPort);
reInit();
} catch (Exception e) {
LOGGER.error("Failed connecting to BGP server ");
bop.type = START_BGP;
bop.asNum = asNum;
bop.rtrId = rtrId;
- LOGGER.info("Starting BGP Server with as number " + asNum + " and router ID " + rtrId);
+ LOGGER.debug("Starting BGP Server with as number {} and router ID {} ", asNum, rtrId);
dispatch(bop);
}
bop.type = ADD_NBR;
bop.nbrIp = nbrIp;
bop.nbrAsNum = nbrAsNum;
- LOGGER.info("Adding BGP Neighbor " + nbrIp + " with as number " + nbrAsNum);
+ LOGGER.debug("Adding BGP Neighbor {} with as number {} ", nbrIp, nbrAsNum);
dispatch(bop);
}
throws TException, BgpRouterException {
bop.type = DEL_NBR;
bop.nbrIp = nbrIp;
- LOGGER.info("Deleting BGP Neighbor " + nbrIp);
+ LOGGER.debug("Deleting BGP Neighbor {} ", nbrIp);
dispatch(bop);
}
bop.rd = rd;
bop.irts = irts;
bop.erts = erts;
- LOGGER.info("Adding BGP VRF rd: " + rd);
+ LOGGER.debug("Adding BGP VRF rd: {} ", rd);
dispatch(bop);
}
throws TException, BgpRouterException {
bop.type = DEL_VRF;
bop.rd = rd;
- LOGGER.info("Deleting BGP VRF rd: " + rd);
+ LOGGER.debug("Deleting BGP VRF rd: {} " + rd);
dispatch(bop);
}
bop.pfx = prefix;
bop.nh = nexthop;
bop.lbl = label;
- LOGGER.info("Adding BGP route - rd:" + rd + " prefix:" + prefix + " nexthop:" + nexthop + " label:" + label);
+ LOGGER.debug("Adding BGP route - rd:{} prefix:{} nexthop:{} label:{} ", rd ,prefix, nexthop, label);
dispatch(bop);
}
bop.type = DEL_PFX;
bop.rd = rd;
bop.pfx = prefix;
- LOGGER.info("Deleting BGP route - rd:" + rd + " prefix:" + prefix);
+ LOGGER.debug("Deleting BGP route - rd:{} prefix:{} ", rd, prefix);
dispatch(bop);
}
BgpSyncHandle bsh = BgpSyncHandle.getInstance();
try {
- LOGGER.info("Starting BGP Route sync.. ");
+ LOGGER.debug("Starting BGP Route sync.. ");
initRibSync(bsh);
while (bsh.getState() != bsh.DONE) {
Routes r = doRibSync(bsh);
}
}
endRibSync(bsh);
- LOGGER.info("Completed BGP Route sync.");
+ LOGGER.debug("Completed BGP Route sync.");
} catch (Exception e) {
throw e;
}
public void start() {
- LOGGER.info("BGP Thrift Server starting.");
+ LOGGER.debug("BGP Thrift Server starting...");
startBgpThriftServer();
}
public void stop() {
- LOGGER.info("BGP Thrift Server stopping.");
+ LOGGER.debug("BGP Thrift Server stopping...");
stopBgpThriftServer();
}
public void stopBgpThriftServer() {
try {
- LOGGER.debug("Server stopping");
-
if (serverTransport != null) {
serverTransport.close();
}
server.stop();
+ LOGGER.info("BGP Thrift Server stopped");
} catch (Exception e) {
LOGGER.error("Error while stopping the server - {} {}", getClass().getName(), e.getMessage());
}
try {
serverTransport = new TServerSocket(port);
- LOGGER.info("Server Socket on Port {} ", port);
+ LOGGER.info("BGP Thrift Server started on port {} ", port);
} catch (TTransportException e) {
LOGGER.error("Transport Exception while starting bgp thrift server", e);
return;
public void onUpdatePushRoute(String rd, String prefix, int plen,
String nexthop, int label) {
- LOGGER.info("Route add ** " + rd + " ** " + prefix + "/" + plen
- + " ** " + nexthop + " ** " + label);
+ LOGGER.debug("Route add ** {} ** {}/{} ** {} ** {} ", rd, prefix, plen, nexthop, label);
//Write to FIB in Data Store
fibDSWriter.addFibEntryToDS(rd, prefix + "/" + plen, nexthop, label);
}
public void onUpdateWithdrawRoute(String rd, String prefix, int plen) {
- LOGGER.info("Route del ** " + rd + " ** " + prefix + "/" + plen);
+ LOGGER.debug("Route del ** {} ** {}/{} ", rd, prefix, plen);
fibDSWriter.removeFibEntryFromDS(rd, prefix + "/" + plen);
}
public void onStartConfigResyncNotification() {
- LOGGER.info("BGP (re)started");
+ LOGGER.debug("BGP (re)started");
bgpManager.reInitConn();
}
-package org.opendaylight.vpnservice.test;
+package org.opendaylight.vpnservice.bgpmanager.test;
import java.util.Collection;
-package org.opendaylight.vpnservice.test;
+package org.opendaylight.vpnservice.bgpmanager.test;
import java.math.BigInteger;
import java.util.ArrayList;
-package org.opendaylight.vpnservice.test;
+package org.opendaylight.vpnservice.bgpmanager.test;
import java.util.Collection;
<groupId>org.opendaylight.vpnservice</groupId>
<artifactId>bgpmanager</artifactId>
- <version>0.0.1-SNAPSHOT</version>
+ <version>0.1.0-SNAPSHOT</version>
<name>bgpmanager</name>
<packaging>pom</packaging>
<modelVersion>4.0.0</modelVersion>
<modelVersion>4.0.0</modelVersion>
<groupId>org.opendaylight.vpnservice</groupId>
<artifactId>binding-parent</artifactId>
- <version>0.0.1-SNAPSHOT</version>
+ <version>0.1.0-SNAPSHOT</version>
<packaging>pom</packaging>
<properties>
- <vpnservices.version>0.0.1-SNAPSHOT</vpnservices.version>
+ <vpnservices.version>0.1.0-SNAPSHOT</vpnservices.version>
<ietf.inet.types.version>2010.09.24.7-SNAPSHOT</ietf.inet.types.version>
<ietf.yang.types.version>2010.09.24.7-SNAPSHOT</ietf.yang.types.version>
<ietf.interfaces.version>2014.05.08.7-SNAPSHOT</ietf.interfaces.version>
<yang.ext.version>2013.09.07.7-SNAPSHOT</yang.ext.version>
<yangtools.version>0.7.0-SNAPSHOT</yangtools.version>
<mdsal.version>1.2.0-SNAPSHOT</mdsal.version>
- <vpns.mdsalutil.version>0.0.1-SNAPSHOT</vpns.mdsalutil.version>
+ <vpns.mdsalutil.version>0.1.0-SNAPSHOT</vpns.mdsalutil.version>
<model.bgp.version>2013.07.15.7-SNAPSHOT</model.bgp.version>
</properties>
</project>
<modelVersion>4.0.0</modelVersion>
<groupId>org.opendaylight.vpnservice</groupId>
<artifactId>config-parent</artifactId>
- <version>0.0.1-SNAPSHOT</version>
+ <version>0.1.0-SNAPSHOT</version>
<packaging>pom</packaging>
<properties>
<!-- ODL -->
- <vpnservices.version>0.0.1-SNAPSHOT</vpnservices.version>
+ <vpnservices.version>0.1.0-SNAPSHOT</vpnservices.version>
+ <jacoco.version>0.7.2.201409121644</jacoco.version>
<ietf.inet.types.version>2010.09.24.7-SNAPSHOT</ietf.inet.types.version>
<ietf.yang.types.version>2010.09.24.7-SNAPSHOT</ietf.yang.types.version>
<ietf.interfaces.version>2014.05.08.7-SNAPSHOT</ietf.interfaces.version>
<yang.ext.version>2013.09.07.7-SNAPSHOT</yang.ext.version>
<yangtools.version>0.7.0-SNAPSHOT</yangtools.version>
<mdsal.version>1.2.0-SNAPSHOT</mdsal.version>
- <vpns.mdsalutil.version>0.0.1-SNAPSHOT</vpns.mdsalutil.version>
+ <vpns.mdsalutil.version>0.1.0-SNAPSHOT</vpns.mdsalutil.version>
<model.bgp.version>2013.07.15.7-SNAPSHOT</model.bgp.version>
+ <openflowplugin.version>0.1.0-SNAPSHOT</openflowplugin.version>
</properties>
<dependencies>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-checkstyle-plugin</artifactId>
+ <executions>
+ <execution>
+ <phase>process-sources</phase>
+ <goals>
+ <goal>check</goal>
+ </goals>
+ </execution>
+ </executions>
<configuration>
<configLocation>
${project.basedir}/../../commons/src/main/resources/vpns_checks.xml
</configLocation>
<failsOnError>true</failsOnError>
<includes>**/*.java,**/*.xml,**/*.ini,**/*.sh,**/*.bat</includes>
- <excludes>**/yang/</excludes>
+ <excludes>**\/target\/,**\/bin\/,**\/third-party,**\/yang-gen-sal</excludes>
</configuration>
</plugin>
+ <plugin>
+ <groupId>org.jacoco</groupId>
+ <artifactId>jacoco-maven-plugin</artifactId>
+ <configuration>
+ <includes>
+ <include>org.opendaylight.vpnservice.*</include>
+ </includes>
+ </configuration>
+ <executions>
+ <execution>
+ <id>pre-test</id>
+ <goals>
+ <goal>prepare-agent</goal>
+ </goals>
+ </execution>
+ <execution>
+ <id>post-test</id>
+ <goals>
+ <goal>report</goal>
+ </goals>
+ <phase>test</phase>
+ </execution>
+ </executions>
+ </plugin>
</plugins>
</build>
<mdsal.version>1.2.0-SNAPSHOT</mdsal.version>
<openflowplugin.version>0.1.0-SNAPSHOT</openflowplugin.version>
<yangtools.version>0.7.0-SNAPSHOT</yangtools.version>
- <vpnservices.version>0.0.1-SNAPSHOT</vpnservices.version>
- <mdsalutil.version>0.0.1-SNAPSHOT</mdsalutil.version>
- <vpnmanager.version>0.0.1-SNAPSHOT</vpnmanager.version>
- <interfacemgr.version>0.0.1-SNAPSHOT</interfacemgr.version>
- <nexthopmgr.version>0.0.1-SNAPSHOT</nexthopmgr.version>
- <fibmanager.version>0.0.1-SNAPSHOT</fibmanager.version>
- <idmanager.version>0.0.1-SNAPSHOT</idmanager.version>
+ <vpnservices.version>0.1.0-SNAPSHOT</vpnservices.version>
+ <mdsalutil.version>${vpnservices.version}</mdsalutil.version>
+ <vpnmanager.version>${vpnservices.version}</vpnmanager.version>
+ <interfacemgr.version>${vpnservices.version}</interfacemgr.version>
+ <nexthopmgr.version>${vpnservices.version}</nexthopmgr.version>
+ <fibmanager.version>${vpnservices.version}</fibmanager.version>
+ <idmanager.version>${vpnservices.version}</idmanager.version>
</properties>
<dependencyManagement>
<dependencies>
<repository>mvn:org.opendaylight.openflowplugin/features-openflowplugin/${openflowplugin.version}/xml/features</repository>
<repository>mvn:org.opendaylight.controller/features-restconf/${mdsal.version}/xml/features</repository>
<feature name='odl-vpnservice-api' version='${project.version}' description='OpenDaylight :: vpnservice :: api '>
+ <feature version='${mdsal.version}'>odl-mdsal-broker</feature>
<feature version='${yangtools.version}'>odl-yangtools-models</feature>
<feature version='${openflowplugin.version}'>odl-openflowplugin-nsf-model</feature>
<bundle>mvn:org.opendaylight.vpnservice/model-bgp/{{VERSION}}</bundle>
<!--<bundle>mvn:org.opendaylight.vpnservice.third-party/org.apache.thriftlib/1.0.1-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="idmanager-impl-default-config.xml">mvn:org.opendaylight.vpnservice/idmanager-impl/${idmanager.version}/xml/config</configfile>
<configfile finalname="bgpmanager-impl-default-config.xml">mvn:org.opendaylight.vpnservice/bgpmanager-impl/${vpnservices.version}/xml/config</configfile>
<configfile finalname="mdsalutil-impl-default-config.xml">mvn:org.opendaylight.vpnservice/mdsalutil-impl/${interfacemgr.version}/xml/config</configfile>
<configfile finalname="interfacemgr-impl-default-config.xml">mvn:org.opendaylight.vpnservice/interfacemgr-impl/${interfacemgr.version}/xml/config</configfile>
<configfile finalname="vpnmanager-impl-default-config.xml">mvn:org.opendaylight.vpnservice/vpnmanager-impl/${vpnmanager.version}/xml/config</configfile>
<configfile finalname="nexthopmgr-impl-default-config.xml">mvn:org.opendaylight.vpnservice/nexthopmgr-impl/${nexthopmgr.version}/xml/config</configfile>
- <configfile finalname="idmanager-impl-default-config.xml">mvn:org.opendaylight.vpnservice/idmanager-impl/${idmanager.version}/xml/config</configfile>
<configfile finalname="fibmanager-impl-default-config.xml">mvn:org.opendaylight.vpnservice/fibmanager-impl/${fibmanager.version}/xml/config</configfile>
</feature>
<parent>
<groupId>org.opendaylight.vpnservice</groupId>
<artifactId>binding-parent</artifactId>
- <version>0.0.1-SNAPSHOT</version>
+ <version>0.1.0-SNAPSHOT</version>
<relativePath>../../commons/binding-parent</relativePath>
</parent>
<parent>
<groupId>org.opendaylight.vpnservice</groupId>
<artifactId>config-parent</artifactId>
- <version>0.0.1-SNAPSHOT</version>
+ <version>0.1.0-SNAPSHOT</version>
<relativePath>../../commons/config-parent</relativePath>
</parent>
<artifactId>fibmanager-api</artifactId>
<version>${vpnservices.version}</version>
</dependency>
+ <dependency>
+ <groupId>${project.groupId}</groupId>
+ <artifactId>mdsalutil-api</artifactId>
+ <version>${vpnservices.version}</version>
+ </dependency>
<dependency>
<groupId>org.opendaylight.vpnservice</groupId>
<artifactId>vpnmanager-impl</artifactId>
<version>${vpnservices.version}</version>
</dependency>
-
+ <dependency>
+ <groupId>org.opendaylight.vpnservice</groupId>
+ <artifactId>vpnmanager-api</artifactId>
+ <version>${vpnservices.version}</version>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.vpnservice</groupId>
+ <artifactId>nexthopmgr-api</artifactId>
+ <version>${vpnservices.version}</version>
+ </dependency>
</dependencies>
</project>
<snapshot>
<required-capabilities>
<capability>urn:opendaylight:params:xml:ns:yang:fibmanager:impl?module=fibmanager-impl&revision=2015-03-25</capability>
+ <capability>urn:opendaylight:params:xml:ns:yang:vpnmanager:api?module=vpnmanager-api&revision=2015-05-08</capability>
+ <capability>urn:opendaylight:params:xml:ns:yang:mdsalutil:api?module=odl-mdsalutil&revision=2015-04-10</capability>
<capability>urn:opendaylight:params:xml:ns:yang:controller:md:sal:binding?module=opendaylight-md-sal-binding&revision=2013-10-28</capability>
</required-capabilities>
<configuration>
<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>
+ <mdsalutil>
+ <type xmlns:mdsalutil="urn:opendaylight:params:xml:ns:yang:mdsalutil:api">mdsalutil:odl-mdsalutil</type>
+ <name>mdsalutil-service</name>
+ </mdsalutil>
+ <vpnmanager>
+ <type xmlns:odl-vpn="urn:opendaylight:params:xml:ns:yang:vpnmanager:api">odl-vpn:vpnmanager-api</type>
+ <name>vpnmanager</name>
+ </vpnmanager>
</module>
</modules>
</data>
*/
package org.opendaylight.vpnservice.fibmanager;
+import com.google.common.base.Preconditions;
import com.google.common.util.concurrent.Futures;
import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
import com.google.common.util.concurrent.FutureCallback;
+
+import org.opendaylight.vpnmanager.api.IVpnManager;
import org.opendaylight.vpnservice.AbstractDataChangeListener;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.DataChangeListener;
+import org.opendaylight.vpnservice.mdsalutil.ActionInfo;
+import org.opendaylight.vpnservice.mdsalutil.ActionType;
+import org.opendaylight.vpnservice.mdsalutil.FlowEntity;
+import org.opendaylight.vpnservice.mdsalutil.InstructionInfo;
+import org.opendaylight.vpnservice.mdsalutil.InstructionType;
+import org.opendaylight.vpnservice.mdsalutil.MDSALUtil;
+import org.opendaylight.vpnservice.mdsalutil.MatchFieldType;
+import org.opendaylight.vpnservice.mdsalutil.MatchInfo;
+import org.opendaylight.vpnservice.mdsalutil.MetaDataUtil;
+import org.opendaylight.vpnservice.mdsalutil.NwConstants;
+import org.opendaylight.vpnservice.mdsalutil.interfaces.IMdsalApiManager;
+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.opendaylight.l3vpn.rev130911.VpnInstance1;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.fibmanager.rev150330.fibentries.VrfTables;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.fibmanager.rev150330.fibentries.VrfTablesKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.fibmanager.rev150330.vrfentries.VrfEntry;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.l3nexthop.rev150409.GetEgressPointerInputBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.l3nexthop.rev150409.GetEgressPointerOutput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.l3nexthop.rev150409.L3nexthopService;
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.common.api.data.LogicalDatastoreType;
import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker.DataChangeScope;
import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.fibmanager.rev150330.FibEntries;
+import org.opendaylight.yangtools.yang.binding.RpcService;
+import org.opendaylight.yangtools.yang.common.RpcResult;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.google.common.base.Optional;
-public class FibManager extends AbstractDataChangeListener<FibEntries> implements AutoCloseable{
+import java.math.BigInteger;
+import java.net.InetAddress;
+import java.net.UnknownHostException;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.Set;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Future;
+
+public class FibManager extends AbstractDataChangeListener<VrfEntry> implements AutoCloseable{
private static final Logger LOG = LoggerFactory.getLogger(FibManager.class);
+ private static final String FLOWID_PREFIX = "L3.";
private ListenerRegistration<DataChangeListener> listenerRegistration;
private final DataBroker broker;
+ private final L3nexthopService l3nexthopService;
+ private IMdsalApiManager mdsalManager;
+ private IVpnManager vpnmanager;
+
+ private static final short L3_FIB_TABLE = 20;
+ private static final short L3_LFIB_TABLE = 21;
+ private static final BigInteger COOKIE_VM_LFIB_TABLE = new BigInteger("8000002", 16);
+ private static final BigInteger COOKIE_VM_FIB_TABLE = new BigInteger("8000003", 16);
+ private static final int DEFAULT_FIB_FLOW_PRIORITY = 10;
+
private static final FutureCallback<Void> DEFAULT_CALLBACK =
new FutureCallback<Void>() {
};
};
- public FibManager(final DataBroker db) {
- super(FibEntries.class);
+ public FibManager(final DataBroker db, final RpcService nextHopService) {
+ super(VrfEntry.class);
broker = db;
+ l3nexthopService = (L3nexthopService)nextHopService;
registerListener(db);
}
LOG.info("Fib Manager Closed");
}
+
+ public void setMdsalManager(IMdsalApiManager mdsalManager) {
+ this.mdsalManager = mdsalManager;
+ }
+
+ public void setVpnmanager(IVpnManager vpnmanager) {
+ this.vpnmanager = vpnmanager;
+ }
+
private void registerListener(final DataBroker db) {
try {
listenerRegistration = db.registerDataChangeListener(LogicalDatastoreType.CONFIGURATION,
}
}
- @Override
- protected void add(final InstanceIdentifier<FibEntries> identifier,
- final FibEntries fibEntries) {
- LOG.trace("key: " + identifier + ", value=" + fibEntries );
- }
-
private <T extends DataObject> Optional<T> read(LogicalDatastoreType datastoreType,
InstanceIdentifier<T> path) {
return result;
}
- private InstanceIdentifier<FibEntries> getWildCardPath() {
- return InstanceIdentifier.create(FibEntries.class);
+ private InstanceIdentifier<VrfEntry> getWildCardPath() {
+ return InstanceIdentifier.create(FibEntries.class).child(VrfTables.class).child(VrfEntry.class);
+ }
+
+ 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);
}
@Override
- protected void remove(InstanceIdentifier<FibEntries> identifier, FibEntries del) {
- LOG.trace("key: " + identifier + ", value=" + del );
+ protected void add(final InstanceIdentifier<VrfEntry> identifier,
+ final VrfEntry vrfEntry) {
+ LOG.trace("key: " + identifier + ", value=" + vrfEntry );
+ createFibEntries(identifier, vrfEntry);
}
@Override
- protected void update(InstanceIdentifier<FibEntries> identifier, FibEntries original, FibEntries update) {
+ protected void remove(InstanceIdentifier<VrfEntry> identifier, VrfEntry vrfEntry) {
+ LOG.trace("key: " + identifier + ", value=" + vrfEntry);
+ deleteFibEntries(identifier, vrfEntry);
+ }
+
+ @Override
+ protected void update(InstanceIdentifier<VrfEntry> identifier, VrfEntry original, VrfEntry update) {
LOG.trace("key: " + identifier + ", original=" + original + ", update=" + update );
}
- 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 void createFibEntries(final InstanceIdentifier<VrfEntry> identifier,
+ final VrfEntry vrfEntry) {
+ final VrfTablesKey vrfTableKey = identifier.firstKeyOf(VrfTables.class, VrfTablesKey.class);
+ Preconditions.checkNotNull(vrfTableKey, "VrfTablesKey cannot be null or empty!");
+ Preconditions.checkNotNull(vrfEntry, "VrfEntry cannot be null or empty!");
+
+ Long vpnId = getVpnId(vrfTableKey.getRouteDistinguisher());
+ Preconditions.checkNotNull(vpnId, "Vpn Instance not available!");
+ Collection<Long> dpns = vpnmanager.getDpnsForVpn(vpnId);
+ for (Long dpId : dpns) {
+ addRouteInternal(dpId, vpnId, vrfTableKey, vrfEntry);
+ }
+ }
+
+ private void addRouteInternal(final long dpId, final long vpnId, final VrfTablesKey vrfTableKey,
+ final VrfEntry vrfEntry) {
+ String rd = vrfTableKey.getRouteDistinguisher();
+ LOG.debug("adding route " + vrfEntry.getDestPrefix() + " " + rd);
+
+ GetEgressPointerOutput adjacency = resolveAdjacency(dpId, vpnId, vrfEntry);
+ long groupId = -1;
+ boolean isLocalRoute = false;
+ if(adjacency != null) {
+ groupId = adjacency.getEgressPointer();
+ isLocalRoute = adjacency.isLocalDestination();
+ }
+ if(groupId == -1) {
+ LOG.error("Could not get nexthop group id for nexthop: {} in vpn {}",
+ vrfEntry.getNextHopAddress(), rd);
+ LOG.warn("Failed to add Route: {} in vpn: {}",
+ vrfEntry.getDestPrefix(), rd);
+ return;
+ }
+
+ makeConnectedRoute(dpId, vpnId, vrfEntry, rd, groupId, NwConstants.ADD_FLOW);
+
+ if (isLocalRoute) {
+ makeLFibTableEntry(dpId, vrfEntry.getLabel(), groupId, vrfEntry.getNextHopAddress(), NwConstants.ADD_FLOW);
+ }
+
+ LOG.debug(
+ "Successfully added fib entry for " + vrfEntry.getDestPrefix() + " vpnId " + vpnId);
+ }
+
+ private void deleteFibEntries(final InstanceIdentifier<VrfEntry> identifier,
+ final VrfEntry vrfEntry) {
+ final VrfTablesKey vrfTableKey = identifier.firstKeyOf(VrfTables.class, VrfTablesKey.class);
+ Preconditions.checkNotNull(vrfTableKey, "VrfTablesKey cannot be null or empty!");
+ Preconditions.checkNotNull(vrfEntry, "VrfEntry cannot be null or empty!");
+
+ Long vpnId = getVpnId(vrfTableKey.getRouteDistinguisher());
+ Preconditions.checkNotNull(vpnId, "Vpn Instance not available!");
+ Collection<Long> dpns = vpnmanager.getDpnsForVpn(vpnId);
+ for (Long dpId : dpns) {
+ deleteRoute(dpId, vpnId, vrfTableKey, vrfEntry);
+ }
+ }
+
+ public void deleteRoute(final long dpId, final long vpnId, final VrfTablesKey vrfTableKey,
+ final VrfEntry vrfEntry) {
+ LOG.debug("deleting route "+ vrfEntry.getDestPrefix() + " "+vpnId);
+ String rd = vrfTableKey.getRouteDistinguisher();
+ GetEgressPointerOutput adjacency = resolveAdjacency(dpId, vpnId, vrfEntry);
+ long groupId = -1;
+ boolean isLocalRoute = false;
+ if(adjacency != null) {
+ groupId = adjacency.getEgressPointer();
+ isLocalRoute = adjacency.isLocalDestination();
+ }
+ if(groupId == -1) {
+ LOG.error("Could not get nexthop group id for nexthop: {} in vpn {}",
+ vrfEntry.getNextHopAddress(), rd);
+ LOG.warn("Failed to add Route: {} in vpn: {}",
+ vrfEntry.getDestPrefix(), rd);
+ return;
+ }
+
+ makeConnectedRoute(dpId, vpnId, vrfEntry, rd, groupId, NwConstants.DEL_FLOW);
+
+ if (isLocalRoute) {
+ makeLFibTableEntry(dpId, vrfEntry.getLabel(), groupId, vrfEntry.getNextHopAddress(), NwConstants.DEL_FLOW);
+ }
+
+ LOG.debug("Successfully delete fib entry for "+ vrfEntry.getDestPrefix() + " vpnId "+vpnId);
+ }
+
+ private long getIpAddress(byte[] rawIpAddress) {
+ return (((rawIpAddress[0] & 0xFF) << (3 * 8)) + ((rawIpAddress[1] & 0xFF) << (2 * 8))
+ + ((rawIpAddress[2] & 0xFF) << (1 * 8)) + (rawIpAddress[3] & 0xFF)) & 0xffffffffL;
+ }
+
+ private void makeConnectedRoute(long dpId, long vpnId, VrfEntry vrfEntry, String rd,
+ long groupId, int addOrRemove) {
+ String values[] = vrfEntry.getDestPrefix().split("/");
+ LOG.debug("Adding route to DPN. ip {} masklen {}", values[0], values[1]);
+ String ipAddress = values[0];
+ int prefixLength = Integer.parseInt(values[1]);
+ InetAddress destPrefix = null;
+ try {
+ destPrefix = InetAddress.getByName(ipAddress);
+ } catch (UnknownHostException e) {
+ LOG.error("UnknowHostException in addRoute. Failed to add Route for ipPrefix {}", vrfEntry.getDestPrefix());
+ return;
+ }
+
+ List<MatchInfo> matches = new ArrayList<MatchInfo>();
+
+ matches.add(new MatchInfo(MatchFieldType.metadata, new BigInteger[] {
+ BigInteger.valueOf(vpnId), MetaDataUtil.METADATA_MASK_VRFID }));
+
+ matches.add(new MatchInfo(MatchFieldType.eth_type,
+ new long[] { 0x0800L }));
+
+ if(prefixLength != 0) {
+ matches.add(new MatchInfo(MatchFieldType.ipv4_dst, new long[] {
+ getIpAddress(destPrefix.getAddress()), prefixLength }));
+ }
+
+ List<InstructionInfo> instructions = new ArrayList<InstructionInfo>();
+ List<ActionInfo> actionsInfos = new ArrayList<ActionInfo>();
+
+ if(addOrRemove == NwConstants.ADD_FLOW) {
+ actionsInfos.add(new ActionInfo(ActionType.group, new String[] { String.valueOf(groupId)}));
+ actionsInfos.add(new ActionInfo(ActionType.push_mpls, new String[] { Long.toString(vrfEntry.getLabel())}));
+ instructions.add(new InstructionInfo(InstructionType.write_actions, actionsInfos));
+ }
+
+ String flowRef = getFlowRef(dpId, L3_FIB_TABLE, rd, destPrefix);
+
+ FlowEntity flowEntity;
+
+ int priority = DEFAULT_FIB_FLOW_PRIORITY + prefixLength;
+ flowEntity = MDSALUtil.buildFlowEntity(dpId, L3_FIB_TABLE, flowRef,
+ priority, flowRef, 0, 0,
+ COOKIE_VM_FIB_TABLE, matches, instructions);
+
+ if (addOrRemove == NwConstants.ADD_FLOW) {
+ mdsalManager.installFlow(flowEntity);
+ } else {
+ mdsalManager.removeFlow(flowEntity);
+ }
+ }
+
+ private void makeLFibTableEntry(long dpId, long label, long groupId,
+ String nextHop, int addOrRemove) {
+ List<MatchInfo> matches = new ArrayList<MatchInfo>();
+ matches.add(new MatchInfo(MatchFieldType.eth_type,
+ new long[] { 0x8847L }));
+ matches.add(new MatchInfo(MatchFieldType.mpls_label, new String[]{Long.toString(label)}));
+
+ List<InstructionInfo> instructions = new ArrayList<InstructionInfo>();
+ List<ActionInfo> actionsInfos = new ArrayList<ActionInfo>();
+ actionsInfos.add(new ActionInfo(ActionType.group, new String[] { String.valueOf(groupId) }));
+ instructions.add(new InstructionInfo(InstructionType.write_actions, actionsInfos));
+
+ // Install the flow entry in L3_LFIB_TABLE
+ String flowRef = getFlowRef(dpId, L3_LFIB_TABLE, label, nextHop);
+
+ FlowEntity flowEntity;
+ flowEntity = MDSALUtil.buildFlowEntity(dpId, L3_LFIB_TABLE, flowRef,
+ DEFAULT_FIB_FLOW_PRIORITY, flowRef, 0, 0,
+ COOKIE_VM_LFIB_TABLE, matches, instructions);
+
+ if (addOrRemove == NwConstants.ADD_FLOW) {
+ mdsalManager.installFlow(flowEntity);
+ } else {
+ mdsalManager.removeFlow(flowEntity);
+ }
+ LOG.debug("LFIB Entry for dpID {} : label : {} grpup {} modified successfully {}",dpId, label, groupId );
+ }
+
+ private String getFlowRef(long dpnId, short tableId, long label, String nextHop) {
+ return new StringBuilder(64).append(FLOWID_PREFIX).append(dpnId).append(NwConstants.FLOWID_SEPARATOR)
+ .append(tableId).append(NwConstants.FLOWID_SEPARATOR)
+ .append(label).append(NwConstants.FLOWID_SEPARATOR)
+ .append(nextHop).toString();
+ }
+
+ private String getFlowRef(long dpnId, short tableId, String rd, InetAddress destPrefix) {
+ return new StringBuilder(64).append(FLOWID_PREFIX).append(dpnId).append(NwConstants.FLOWID_SEPARATOR)
+ .append(tableId).append(NwConstants.FLOWID_SEPARATOR)
+ .append(rd).append(NwConstants.FLOWID_SEPARATOR)
+ .append(destPrefix.getHostAddress()).toString();
+ }
+
+ private GetEgressPointerOutput resolveAdjacency(final long dpId, final long vpnId,
+ final VrfEntry vrfEntry) {
+ GetEgressPointerOutput adjacency = null;
+ LOG.trace("resolveAdjacency called with dpid {}, vpnId{}, VrfEntry {}",dpId, vpnId, vrfEntry);;
+ try {
+ Future<RpcResult<GetEgressPointerOutput>> result =
+ l3nexthopService.getEgressPointer(new GetEgressPointerInputBuilder().setDpnId(dpId)
+ .setIpPrefix(vrfEntry.getDestPrefix())
+ .setNexthopIp(vrfEntry.getNextHopAddress())
+ .setVpnId(vpnId)
+ .build());
+ RpcResult<GetEgressPointerOutput> rpcResult = result.get();
+ if (rpcResult.isSuccessful()) {
+ adjacency = rpcResult.getResult();
+ } else {
+ LOG.error("Next hop information not available");
+ }
+ } catch (NullPointerException | InterruptedException | ExecutionException e) {
+ LOG.trace("", e);
+ }
+ return adjacency;
+ }
+
+ private Long getVpnId(String rd) {
+ Long vpnId = null;
+ InstanceIdentifier<VpnInstances> id = InstanceIdentifier.create(VpnInstances.class);
+ Optional<VpnInstances> vpnInstances = read(LogicalDatastoreType.OPERATIONAL, id);
+ if(vpnInstances.isPresent()) {
+ List<VpnInstance> vpns = vpnInstances.get().getVpnInstance();
+ for(VpnInstance vpn : vpns) {
+ if(vpn.getIpv4Family().getRouteDistinguisher().equals(rd)) {
+ VpnInstance1 vpnInstanceId = vpn.getAugmentation(VpnInstance1.class);
+ if (vpnInstanceId != null) {
+ vpnId = vpnInstanceId.getVpnId();
+ break;
+ }
+ }
+ }
+ }
+ return vpnId;
}
}
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.sal.binding.api.BindingAwareBroker.ProviderContext;
import org.opendaylight.controller.sal.binding.api.BindingAwareProvider;
+import org.opendaylight.vpnmanager.api.IVpnManager;
+import org.opendaylight.vpnservice.mdsalutil.interfaces.IMdsalApiManager;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.l3nexthop.rev150409.L3nexthopService;
+import org.opendaylight.yangtools.yang.binding.RpcService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
private static final Logger LOG = LoggerFactory.getLogger(FibManagerProvider.class);
private FibManager fibManager;
+ private IMdsalApiManager mdsalManager;
+ private IVpnManager vpnmanager;
@Override
public void onSessionInitiated(ProviderContext session) {
LOG.info("FibManagerProvider Session Initiated");
try {
final DataBroker dataBroker = session.getSALService(DataBroker.class);
- fibManager = new FibManager(dataBroker);
+ final RpcService nexthopService = session.getRpcService(L3nexthopService.class);
+ fibManager = new FibManager(dataBroker, nexthopService);
+ fibManager.setMdsalManager(mdsalManager);
+ fibManager.setVpnmanager(vpnmanager);
} catch (Exception e) {
LOG.error("Error initializing services", e);
}
fibManager.close();
}
+ public void setMdsalManager(IMdsalApiManager mdsalManager) {
+ this.mdsalManager = mdsalManager;
+ }
+
+ public void setVpnmanager(IVpnManager vpnmanager) {
+ this.vpnmanager = vpnmanager;
+ }
}
\ No newline at end of file
@Override
public java.lang.AutoCloseable createInstance() {
FibManagerProvider provider = new FibManagerProvider();
+ provider.setMdsalManager(getMdsalutilDependency());
+ provider.setVpnmanager(getVpnmanagerDependency());
getBrokerDependency().registerProvider(provider);
return provider;
}
import config { prefix config; revision-date 2013-04-05; }
import opendaylight-md-sal-binding { prefix md-sal-binding; revision-date 2013-10-28;}
+ import odl-mdsalutil { prefix odl-mdsal; revision-date 2015-04-10;}
+ import vpnmanager-api { prefix odl-vpn; revision-date 2015-05-08;}
description
"Service definition for fibmanager project";
}
}
}
+ container mdsalutil {
+ uses config:service-ref {
+ refine type {
+ mandatory true;
+ config:required-identity odl-mdsal:odl-mdsalutil;
+ }
+ }
+ }
+ container vpnmanager {
+ uses config:service-ref {
+ refine type {
+ mandatory true;
+ config:required-identity odl-vpn:vpnmanager-api;
+ }
+ }
+ }
}
}
}
<groupId>org.opendaylight.vpnservice</groupId>
<artifactId>fibmanager-aggregator</artifactId>
- <version>0.0.1-SNAPSHOT</version>
+ <version>0.1.0-SNAPSHOT</version>
<name>fibmanager</name>
<packaging>pom</packaging>
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>org.opendaylight.vpnservice</groupId>
<artifactId>binding-parent</artifactId>
- <version>0.0.1-SNAPSHOT</version>
+ <version>0.1.0-SNAPSHOT</version>
<relativePath>../../commons/binding-parent</relativePath>
</parent>
<parent>
<groupId>org.opendaylight.vpnservice</groupId>
<artifactId>config-parent</artifactId>
- <version>0.0.1-SNAPSHOT</version>
+ <version>0.1.0-SNAPSHOT</version>
<relativePath>../../commons/config-parent</relativePath>
</parent>
<groupId>org.opendaylight.vpnservice</groupId>
<artifactId>idmanager-aggregator</artifactId>
- <version>0.0.1-SNAPSHOT</version>
+ <version>0.1.0-SNAPSHOT</version>
<name>idmanager</name>
<packaging>pom</packaging>
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>org.opendaylight.vpnservice</groupId>
<artifactId>config-parent</artifactId>
- <version>0.0.1-SNAPSHOT</version>
+ <version>0.1.0-SNAPSHOT</version>
<relativePath>../../commons/config-parent</relativePath>
</parent>
<parent>
<groupId>org.opendaylight.vpnservice</groupId>
<artifactId>config-parent</artifactId>
- <version>0.0.1-SNAPSHOT</version>
+ <version>0.1.0-SNAPSHOT</version>
<relativePath>../../commons/config-parent</relativePath>
</parent>
<modelVersion>4.0.0</modelVersion>
<groupId>org.opendaylight.vpnservice</groupId>
<artifactId>interfacemgr-impl</artifactId>
- <version>0.0.1-SNAPSHOT</version>
+ <version>0.1.0-SNAPSHOT</version>
<packaging>bundle</packaging>
<dependencies>
<dependency>
Node node = getNodeFromDataStore(delInterface);
if((node != null) &&(node.getNodeConnector().isEmpty())) {
dbDpnEndpoints.remove(node.getId());
+ LOG.trace("dbDpnEndpoints: {}",dbDpnEndpoints);
}
}
}
void processPortUpdate(NodeConnector oldPort, NodeConnector update) {
//TODO: Currently nothing to do here.
- LOG.trace("ifMap: {}, dpnMap: {}", mapNcToInterfaceName, dbDpnEndpoints);
}
void processPortDelete(NodeConnector port) {
org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.InterfaceBuilder ifaceBuilder =
new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.InterfaceBuilder();
if (stateIf.isPresent()) {
- stateIface = ifaceBuilder.setOperStatus(opStatus).build();
+ stateIface = ifaceBuilder.setOperStatus(opStatus).setKey(IfmUtil.getStateInterfaceKeyFromName(ifName)).build();
LOG.trace("Setting OperStatus for {} to {} in OPERATIONAL DS", ifName, opStatus);
asyncUpdate(LogicalDatastoreType.OPERATIONAL, id, stateIface, DEFAULT_CALLBACK);
}
Class<? extends InterfaceType> ifType = iface.getType();
long dpn = this.getDpnForInterface(ifName);
long portNo = this.getPortNumForInterface(iface).longValue();
-
if (iface.isEnabled()) {
if(ifType.isAssignableFrom(L2vlan.class)) {
IfL2vlan vlanIface = iface.getAugmentation(IfL2vlan.class);
- long vlanVid = vlanIface.getVlanId();
LOG.trace("L2Vlan: {}",vlanIface);
+ long vlanVid = (vlanIface == null) ? 0 : vlanIface.getVlanId();
if (vlanVid != 0) {
listActionInfo.add(new ActionInfo(ActionType.push_vlan, new String[] {}));
listActionInfo.add(new ActionInfo(ActionType.set_field_vlan_vid,
} catch (Exception e) {
LOG.error("OFPort for Interface {} not found", iface.getName());
}
- return null;
+ return 0L;
}
}
<groupId>org.opendaylight.vpnservice</groupId>
<artifactId>interfacemgr-aggregator</artifactId>
- <version>0.0.1-SNAPSHOT</version>
+ <version>0.1.0-SNAPSHOT</version>
<name>interfacemgr</name>
<packaging>pom</packaging>
<modelVersion>4.0.0</modelVersion>
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.vpnservice</groupId>
<artifactId>config-parent</artifactId>
- <version>0.3.0-SNAPSHOT</version>
- <relativePath/>
- </parent>
+ <version>0.1.0-SNAPSHOT</version>
+ <relativePath>../../commons/config-parent</relativePath>
+ </parent>
<modelVersion>4.0.0</modelVersion>
<groupId>org.opendaylight.vpnservice</groupId>
<artifactId>mdsalutil-api</artifactId>
- <version>0.0.1-SNAPSHOT</version>
+ <version>0.1.0-SNAPSHOT</version>
<packaging>bundle</packaging>
- <properties>
- <!-- ODL -->
- <openflowplugin.version>0.1.0-SNAPSHOT</openflowplugin.version>
- </properties>
-
- <build>
- <plugins>
- <!--
- <plugin>
- <groupId>org.apache.felix</groupId>
- <artifactId>maven-bundle-plugin</artifactId>
- <version>${bundle.plugin.version}</version>
- <extensions>true</extensions>
- <configuration>
- <instructions>
- <Export-Package>
- org.opendaylight.vpnservice.mdsalutil,
- org.opendaylight.vpnservice.mdsalutil.interfaces
- </Export-Package>
- <Import-Package>
- com.google.common.*,
- org.opendaylight.yang.*,
- org.opendaylight.yangtools.*,
- org.opendaylight.controller.sal.binding.api.*,
- org.opendaylight.controller.md.sal.common.api.*,
- org.opendaylight.controller.sal.common
- </Import-Package
- </instructions>
- <manifestLocation>${project.basedir}/META-INF</manifestLocation>
- </configuration>
- </plugin>
- -->
- <plugin>
- <groupId>org.opendaylight.yangtools</groupId>
- <artifactId>yang-maven-plugin</artifactId>
- <executions>
- <execution>
- <goals>
- <goal>generate-sources</goal>
- </goals>
- <configuration>
- <codeGenerators>
- <generator>
- <codeGeneratorClass>org.opendaylight.yangtools.maven.sal.api.gen.plugin.CodeGeneratorImpl</codeGeneratorClass>
- <outputBaseDir>${salGeneratorPath}</outputBaseDir>
- </generator>
- <generator>
- <codeGeneratorClass>org.opendaylight.controller.config.yangjmxgenerator.plugin.JMXGenerator</codeGeneratorClass>
- <outputBaseDir>${jmxGeneratorPath}</outputBaseDir>
- <additionalConfiguration>
- <namespaceToPackage1>urn:opendaylight:params:xml:ns:yang==org.opendaylight.controller.config.yang</namespaceToPackage1>
- </additionalConfiguration>
- </generator>
- <generator>
- <codeGeneratorClass>org.opendaylight.yangtools.yang.unified.doc.generator.maven.DocumentationGeneratorImpl</codeGeneratorClass>
- <outputBaseDir>target/site/models</outputBaseDir>
- </generator>
- </codeGenerators>
- <inspectDependencies>true</inspectDependencies>
- </configuration>
- </execution>
- </executions>
- </plugin>
- </plugins>
- </build>
<dependencies>
<dependency>
<groupId>org.opendaylight.openflowplugin.model</groupId>
<artifactId>model-flow-service</artifactId>
<version>${openflowplugin.version}</version>
</dependency>
- <!--
- <dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>sal-binding-api</artifactId>
- </dependency>
- -->
- <!-- removed due to missing constraint
- <dependency>
- <groupId>org.opendaylight.controller.model</groupId>
- <artifactId>model-flow-service</artifactId>
- </dependency>
- <dependency>
- <groupId>org.opendaylight.controller.model</groupId>
- <artifactId>model-flow-base</artifactId>
- </dependency>
- -->
- <!-- <dependency>
- <groupId>org.opendaylight.controller.model</groupId>
- <artifactId>model-flow-management</artifactId>
- </dependency>
- <dependency>
- <groupId>org.opendaylight.controller.model</groupId>
- <artifactId>model-inventory</artifactId>
- </dependency>
- -->
- <!--
- <dependency>
- <groupId>org.opendaylight.controller.model</groupId>
- <artifactId>model-flow-statistics</artifactId>
- </dependency>
-
- <dependency>
- <groupId>org.opendaylight.controller.adsal</groupId>
- <artifactId>sal</artifactId>
- </dependency>
- -->
- <dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>config-api</artifactId>
- </dependency>
- <dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>sal-common</artifactId>
- </dependency>
- <dependency>
- <groupId>com.google.guava</groupId>
- <artifactId>guava</artifactId>
- </dependency>
- <!--
- <dependency>
- <groupId>org.opendaylight.controller.model</groupId>
- <artifactId>model-topology</artifactId>
- </dependency>
- -->
-
+
</dependencies>
</project>
public class MDSALDataStoreUtils {
- public <T extends DataObject> Optional<T> read(final DataBroker broker,final LogicalDatastoreType datastoreType,
+ public static <T extends DataObject> Optional<T> read(final DataBroker broker,final LogicalDatastoreType datastoreType,
InstanceIdentifier<T> path) {
ReadOnlyTransaction tx = broker.newReadOnlyTransaction();
Futures.addCallback(tx.submit(), callback);
}
- public <T extends DataObject> void asyncUpdate(final DataBroker broker,final LogicalDatastoreType datastoreType,
+ public static <T extends DataObject> void asyncUpdate(final DataBroker broker,final LogicalDatastoreType datastoreType,
InstanceIdentifier<T> path, T data, FutureCallback<Void> callback) {
WriteTransaction tx = broker.newWriteOnlyTransaction();
tx.merge(datastoreType, path, data, true);
Futures.addCallback(tx.submit(), callback);
}
- public <T extends DataObject> void asyncRemove(final DataBroker broker,final LogicalDatastoreType datastoreType,
+ public static <T extends DataObject> void asyncRemove(final DataBroker broker,final LogicalDatastoreType datastoreType,
InstanceIdentifier<T> path, FutureCallback<Void> callback) {
WriteTransaction tx = broker.newWriteOnlyTransaction();
tx.delete(datastoreType, path);
public void sendPacketOutWithActions(long lDpnId, long groupId, byte[] payload, List<ActionInfo> actionInfos);
public void sendARPPacketOutWithActions(long dpid, byte[] payload, List<ActionInfo> action_info);
-
- public void printTest() ;
- }
+}
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.vpnservice</groupId>
<artifactId>config-parent</artifactId>
- <version>0.3.0-SNAPSHOT</version>
- <relativePath/>
- </parent>
+ <version>0.1.0-SNAPSHOT</version>
+ <relativePath>../../commons/config-parent</relativePath>
+ </parent>
<modelVersion>4.0.0</modelVersion>
<groupId>org.opendaylight.vpnservice</groupId>
<artifactId>mdsalutil-impl</artifactId>
- <version>0.0.1-SNAPSHOT</version>
+ <version>0.1.0-SNAPSHOT</version>
<packaging>bundle</packaging>
<properties>
<dependency>
<groupId>org.opendaylight.openflowplugin.model</groupId>
<artifactId>model-flow-base</artifactId>
- <version>0.1.0-SNAPSHOT</version>
+ <version>${openflowplugin.version}</version>
</dependency>
<dependency>
<groupId>org.opendaylight.openflowplugin.model</groupId>
<artifactId>model-flow-service</artifactId>
- <version>0.1.0-SNAPSHOT</version>
+ <version>${openflowplugin.version}</version>
</dependency>
<!-- TEST Dependencies -->
- <dependency>
- <groupId>junit</groupId>
- <artifactId>junit</artifactId>
- </dependency>
- <dependency>
- <groupId>org.mockito</groupId>
- <artifactId>mockito-all</artifactId>
- <scope>test</scope>
- </dependency>
- <dependency>
+ <dependency>
<groupId>org.powermock</groupId>
<artifactId>powermock-module-junit4</artifactId>
<version>1.5.2</version>
<scope>test</scope>
<type>test-jar</type>
</dependency>
- <dependency>
- <groupId>commons-lang</groupId>
- <artifactId>commons-lang</artifactId>
- </dependency>
- <dependency>
- <groupId>com.google.guava</groupId>
- <artifactId>guava</artifactId>
- </dependency>
<dependency>
<groupId>${project.groupId}</groupId>
<artifactId>mdsalutil-api</artifactId>
<build>
<plugins>
- <plugin>
- <groupId>org.apache.felix</groupId>
- <artifactId>maven-bundle-plugin</artifactId>
- <version>${bundle.plugin.version}</version>
- <extensions>true</extensions>
- <configuration>
- <instructions>
- <Export-Package>
- </Export-Package>
- <Service-Component>
- </Service-Component>
- </instructions>
- <manifestLocation>${project.basedir}/META-INF</manifestLocation>
- </configuration>
- </plugin>
- <plugin>
- <artifactId>maven-clean-plugin</artifactId>
- <version>${maven.clean.plugin.version}</version>
- <configuration>
- <filesets>
- <fileset>
- <directory>${basedir}/src/main/xtend-gen</directory>
- <includes>
- <include>**</include>
- </includes>
- </fileset>
- </filesets>
- </configuration>
- </plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-surefire-plugin</artifactId>
import java.math.BigInteger;
import java.util.ArrayList;
-import java.util.Collections;
import java.util.List;
-import java.util.concurrent.atomic.AtomicInteger;
-
import org.opendaylight.vpnservice.mdsalutil.ActionInfo;
import org.opendaylight.vpnservice.mdsalutil.ActionType;
import org.opendaylight.vpnservice.mdsalutil.FlowEntity;
import org.opendaylight.vpnservice.mdsalutil.GroupEntity;
import org.opendaylight.vpnservice.mdsalutil.MDSALUtil;
-import org.opendaylight.vpnservice.mdsalutil.interfaces.IMdsalApiManager;
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.TableBuilder;
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.FlowBuilder;
private PacketProcessingService m_packetProcessingService;
- private final AtomicInteger m_atomicInteger = new AtomicInteger();
-
- //TODO : IF ID MANAGER IS RQD
-
/**
* Writes the flows and Groups to the MD SAL DataStore
* which will be sent to the openflowplugin for installing flows/groups on the switch.
}
-
@Override
public void close() throws Exception {
s_logger.info("MDSAL Manager Closed");
}
-
- public void printTest() {
-
- s_logger.info(" INTER MODULECOMMUNICATION IS WORKING!!!!");
- }
-
public void installFlow(FlowEntity flowEntity) {
try {
- s_logger.info("within installFlow {}", flowEntity.getDpnId());
+ s_logger.info("InstallFlow for flowEntity {} ", flowEntity);
if (flowEntity.getCookie() == null) {
- // s_logger.info("Helium_sync: Cookie is null");
- flowEntity.setCookie(new BigInteger("0110000", 16));
+ flowEntity.setCookie(new BigInteger("0110000", 16));
}
FlowKey flowKey = new FlowKey( new FlowId(flowEntity.getFlowId()) );
FlowBuilder flowbld = flowEntity.getFlowBuilder();
- Flow flow = flowbld.build() ;
-
Node nodeDpn = buildDpnNode(flowEntity.getDpnId());
- InstanceIdentifier<Node> nodeInstanceId = InstanceIdentifier.builder(Nodes.class)
- .child(Node.class, nodeDpn.getKey()).build();
-
InstanceIdentifier<Flow> flowInstanceId = InstanceIdentifier.builder(Nodes.class)
.child(Node.class, nodeDpn.getKey()).augmentation(FlowCapableNode.class)
.child(Table.class, new TableKey(flowEntity.getTableId())).child(Flow.class,flowKey).build();
- String sTransactionUri = generateTransactionUri();
-
- TableKey tableKey = new TableKey(flowEntity.getTableId() );
- InstanceIdentifier<Table> tableInstanceId = InstanceIdentifier.create(Nodes.class).child(Node.class, nodeDpn.getKey())
- .augmentation(FlowCapableNode.class).child(Table.class, tableKey);
- Table table = new TableBuilder().setKey(tableKey).setFlow(Collections.<Flow>emptyList()).build();
-
WriteTransaction modification = m_dataBroker.newWriteOnlyTransaction();
- //CHECK IF RQD
- // modification.put(LogicalDatastoreType.CONFIGURATION, nodeInstanceId, nodeDpn, true);
-
-
- modification.put(LogicalDatastoreType.CONFIGURATION, tableInstanceId, table);
-
- modification.put(LogicalDatastoreType.CONFIGURATION, flowInstanceId, flowbld.build());
+ modification.put(LogicalDatastoreType.CONFIGURATION, flowInstanceId, flowbld.build(),true );
CheckedFuture<Void,TransactionCommitFailedException> submitFuture = modification.submit();
}
});
} catch (Exception e) {
- s_logger.error("Could not install flow: {}, exception: {}", flowEntity, e.getMessage());
+ s_logger.error("Could not install flow: {}, exception: {}", flowEntity, e);
}
}
Group group = groupEntity.getGroupBuilder().build();
Node nodeDpn = buildDpnNode(groupEntity.getDpnId());
- InstanceIdentifier<Node> nodeInstanceId = InstanceIdentifier.builder(Nodes.class)
- .child(Node.class, nodeDpn.getKey()).build();
+
InstanceIdentifier<Group> groupInstanceId = InstanceIdentifier.builder(Nodes.class)
.child(Node.class, nodeDpn.getKey()).augmentation(FlowCapableNode.class)
.child(Group.class, new GroupKey(new GroupId(groupEntity.getGroupId()))).build();
WriteTransaction modification = m_dataBroker.newWriteOnlyTransaction();
- //CHECK IF RQD
- // modification.put(LogicalDatastoreType.CONFIGURATION, nodeInstanceId, nodeDpn);
- modification.put(LogicalDatastoreType.CONFIGURATION, groupInstanceId, group);
+ modification.put(LogicalDatastoreType.CONFIGURATION, groupInstanceId, group, true);
CheckedFuture<Void,TransactionCommitFailedException> submitFuture = modification.submit();
}
});
} catch (Exception e) {
- s_logger.error("Could not install Group: {}, exception: {}", groupEntity, e.getMessage());
+ s_logger.error("Could not install Group: {}, exception: {}", groupEntity, e);
throw e;
}
}
});
} catch (Exception e) {
- s_logger.error("Could not remove Flow: {}, exception: {}", flowEntity, e.getMessage());
+ s_logger.error("Could not remove Flow: {}, exception: {}", flowEntity, e);
}
}
}
});
} catch (Exception e) {
- s_logger.error("Could not remove Group: {}, exception: {}", groupEntity, e.getMessage());
+ s_logger.error("Could not remove Group: {}, exception: {}", groupEntity, e);
}
}
installGroup(groupEntity);
}
- private String generateTransactionUri() {
- long lTransactionIdOut = m_atomicInteger.incrementAndGet();
-
- // TO DO Introduce this later
- // return "" + (lTransactionIdOut | m_lTransactionIdPrefix);
- return "" + (lTransactionIdOut );
- }
-/*
- private String generateTransactionUriForFlow(long nTransactionId) {
- long lTransactionIdOut = m_atomicInteger.incrementAndGet();
- return Long.toString((lTransactionIdOut | m_lTransactionIdPrefix)) + EUtil.TRANSACTION_ID_SEPARATOR
- + Long.toString(nTransactionId);
- }
-*/
-
public void sendPacketOut(long lDpnId, int groupId, byte[] payload) {
List<ActionInfo> actionInfos = new ArrayList<ActionInfo>();
getNodeConnRef("openflow:" + lDpnId, "0xfffffffd")));
}
- private NodeKey getNodeKey(long dpId) {
- String nodeId = "openflow:" + dpId;
- NodeKey nodeKey = new NodeKey(new NodeId(nodeId));
- return nodeKey;
- }
-
public InstanceIdentifier<Node> nodeToInstanceId(Node node) {
return InstanceIdentifier.builder(Nodes.class).child(Node.class, node.getKey()).toInstance();
}
return _nodeConnectorRef;
}
- private long getDpnIdFromNodeName(String nodeName) {
- String dpId = nodeName.substring(nodeName.lastIndexOf(":") + 1);
- return Long.parseLong(dpId);
- }
-
private Node buildDpnNode(long lDpnId) {
NodeId nodeId = new NodeId("openflow:" + lDpnId);
Node nodeDpn = new NodeBuilder().setId(nodeId).setKey(new NodeKey(nodeId)).build();
mdSalMgr.sendARPPacketOutWithActions(dpid, payload, action_info);
}
-
- @Override
- public void printTest() {
- // TODO Auto-generated method stub
- mdSalMgr.printTest();
- }
-
}
<groupId>org.opendaylight.vpnservice</groupId>
<artifactId>mdsalutil-aggregator</artifactId>
- <version>0.0.1-SNAPSHOT</version>
+ <version>0.1.0-SNAPSHOT</version>
<name>mdsalutil</name>
<packaging>pom</packaging>
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>org.opendaylight.vpnservice</groupId>
<artifactId>binding-parent</artifactId>
- <version>0.0.1-SNAPSHOT</version>
+ <version>0.1.0-SNAPSHOT</version>
<relativePath>../commons/binding-parent</relativePath>
</parent>
<parent>
<groupId>org.opendaylight.vpnservice</groupId>
<artifactId>binding-parent</artifactId>
- <version>0.0.1-SNAPSHOT</version>
+ <version>0.1.0-SNAPSHOT</version>
<relativePath>../../commons/binding-parent</relativePath>
</parent>
}
output {
leaf egressPointer {type uint32;}
+ leaf localDestination {type boolean;}
}
}
}
\ No newline at end of file
<parent>
<groupId>org.opendaylight.vpnservice</groupId>
<artifactId>config-parent</artifactId>
- <version>0.0.1-SNAPSHOT</version>
+ <version>0.1.0-SNAPSHOT</version>
<relativePath>../../commons/config-parent</relativePath>
</parent>
<type xmlns:odlif="urn:opendaylight:vpnservice:interfacemgr">odlif:odl-interface</type>
<name>interfacemgr-service</name>
</odlinterface>
+ <rpc-registry>
+ <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>
</module>
</modules>
</data>
InstanceIdentifier<VpnInstance> id = idBuilder.build();
InstanceIdentifier<VpnInstance1> idx = id.augmentation(VpnInstance1.class);
- Optional<VpnInstance1> vpn = read(LogicalDatastoreType.CONFIGURATION, idx);
+ Optional<VpnInstance1> vpn = read(LogicalDatastoreType.OPERATIONAL, idx);
if (vpn.isPresent()) {
return vpn.get().getVpnId();
} else {
- return 0;
+ return -1;
}
}
BucketInfo bucket = new BucketInfo(listActionInfo);
// MAC re-write
if (macAddress != null) {
- listActionInfo.add(new ActionInfo(ActionType.set_field_eth_dest, new String[]{macAddress}));
+ listActionInfo.add(0, new ActionInfo(ActionType.set_field_eth_dest, new String[]{macAddress}));
} else {
//FIXME: Log message here.
}
// check if vpn node is there or to be created
InstanceIdentifier<VpnNexthops> id = idBuilder.build();
- Optional<VpnNexthops> nexthops = read(LogicalDatastoreType.CONFIGURATION, id);
+ Optional<VpnNexthops> nexthops = read(LogicalDatastoreType.OPERATIONAL, id);
if (!nexthops.isPresent()) {
// create a new node
VpnNexthops node = new VpnNexthopsBuilder().setKey(new VpnNexthopsKey(vpnId)).setVpnId(vpnId).build();
// check if dpn node is there or to be created
InstanceIdentifier<TunnelNexthops> id = idBuilder.build();
- Optional<TunnelNexthops> nexthops = read(LogicalDatastoreType.CONFIGURATION, id);
+ Optional<TunnelNexthops> nexthops = read(LogicalDatastoreType.OPERATIONAL, id);
if (!nexthops.isPresent()) {
// create a new node
TunnelNexthops node = new TunnelNexthopsBuilder()
InstanceIdentifierBuilder<VpnNexthops> idBuilder = InstanceIdentifier.builder(L3nexthop.class)
.child(VpnNexthops.class, new VpnNexthopsKey(vpnId));
InstanceIdentifier<VpnNexthops> id = idBuilder.build();
- Optional<VpnNexthops> vpnNexthops = read(LogicalDatastoreType.CONFIGURATION, id);
- if (!vpnNexthops.isPresent()) {
+ Optional<VpnNexthops> vpnNexthops = read(LogicalDatastoreType.OPERATIONAL, id);
+ if (vpnNexthops.isPresent()) {
// get nexthops list for vpn
List<VpnNexthop> nexthops = vpnNexthops.get().getVpnNexthop();
// check if vpn node is there
InstanceIdentifier<TunnelNexthops> id = idBuilder.build();
- Optional<TunnelNexthops> dpnNexthops = read(LogicalDatastoreType.CONFIGURATION, id);
- if (!dpnNexthops.isPresent()) {
+ Optional<TunnelNexthops> dpnNexthops = read(LogicalDatastoreType.OPERATIONAL, id);
+ if (dpnNexthops.isPresent()) {
List<TunnelNexthop> nexthops = dpnNexthops.get().getTunnelNexthop();
for (TunnelNexthop nexthop : nexthops) {
if (nexthop.getIpAddress().equals(ipAddress)) {
@Override
public Future<RpcResult<GetEgressPointerOutput>> getEgressPointer(
GetEgressPointerInput input) {
- long egressGroupId =
- getNextHopPointer(input.getDpnId(), input.getVpnId(), input.getIpPrefix(), input.getNexthopIp());
GetEgressPointerOutputBuilder output = new GetEgressPointerOutputBuilder();
- output.setEgressPointer(egressGroupId);
+
+ String endpointIp = interfaceManager.getEndpointIpForDpn(input.getDpnId());
+ if (input.getNexthopIp().equals(endpointIp)) {
+ VpnNexthop vpnNextHop = getVpnNexthop(input.getVpnId(), input.getIpPrefix());
+ output.setEgressPointer(vpnNextHop.getEgressPointer());
+ output.setLocalDestination(true);
+ } else {
+ TunnelNexthop tunnelNextHop = getTunnelNexthop(input.getDpnId(), input.getNexthopIp());
+ output.setEgressPointer(tunnelNextHop.getEgressPointer());
+ output.setLocalDestination(false);
+ }
RpcResultBuilder<GetEgressPointerOutput> rpcResultBuilder = RpcResultBuilder.success();
rpcResultBuilder.withResult(output.build());
package org.opendaylight.vpnservice.nexthopmgr;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+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.vpnservice.nexthopmgr.NexthopManager;
import org.opendaylight.vpnservice.interfacemgr.interfaces.IInterfaceManager;
import org.opendaylight.vpnservice.mdsalutil.interfaces.IMdsalApiManager;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.l3nexthop.rev150409.L3nexthopService;
import org.opendaylight.idmanager.IdManager;
-
+import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
private IMdsalApiManager mdsalManager;
private IInterfaceManager interfaceManager;
private IdManager idManager;
+ private RpcProviderRegistry rpcProviderRegistry;
+
+ public RpcProviderRegistry getRpcProviderRegistry() {
+ return rpcProviderRegistry;
+ }
+
+ public void setRpcProviderRegistry(RpcProviderRegistry rpcProviderRegistry) {
+ this.rpcProviderRegistry = rpcProviderRegistry;
+ }
@Override
public void onSessionInitiated(ProviderContext session) {
vpnIfListener = new VpnInterfaceChangeListener(dbx, nhManager);
odlIfListener = new OdlInterfaceChangeListener(dbx, nhManager, interfaceManager);
idManager = new IdManager(dbx);
+ final BindingAwareBroker.RpcRegistration<L3nexthopService> rpcRegistration = getRpcProviderRegistry().addRpcImplementation(L3nexthopService.class, nhManager);
nhManager.setMdsalManager(mdsalManager);
nhManager.setInterfaceManager(interfaceManager);
nhManager.setIdManager(idManager);
this.interfaceManager = interfaceManager;
}
+ public NexthopmgrProvider(RpcProviderRegistry rpcRegistry) {
+ this.rpcProviderRegistry = rpcRegistry;
+ }
+
@Override
public void close() throws Exception {
vpnIfListener.close();
@Override
public java.lang.AutoCloseable createInstance() {
- NexthopmgrProvider provider = new NexthopmgrProvider();
+ NexthopmgrProvider provider = new NexthopmgrProvider(getRpcRegistryDependency());
provider.setMdsalManager(getMdsalutilDependency());
provider.setInterfaceManager(getOdlinterfaceDependency());
-
getBrokerDependency().registerProvider(provider);
return provider;
}
}
}
}
+ container rpc-registry {
+ uses config:service-ref {
+ refine type {
+ mandatory true;
+ config:required-identity md-sal-binding:binding-rpc-registry;
+ }
+ }
+ }
}
}
}
<groupId>org.opendaylight.vpnservice</groupId>
<artifactId>nexthopmgr-aggregator</artifactId>
- <version>0.0.1-SNAPSHOT</version>
+ <version>0.1.0-SNAPSHOT</version>
<name>nexthopmgr</name>
<packaging>pom</packaging>
<modelVersion>4.0.0</modelVersion>
<project xmlns="http://maven.apache.org/POM/4.0.0" 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">
<groupId>org.opendaylight.vpnservice</groupId>
<artifactId>vpnservice</artifactId>
- <version>0.0.1-SNAPSHOT</version>
+ <version>0.1.0-SNAPSHOT</version>
<name>${project.artifactId}</name>
<packaging>pom</packaging>
<modelVersion>4.0.0</modelVersion>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent</artifactId>
<version>1.5.0-SNAPSHOT</version>
- <relativePath/>
+ <relativePath/>
</parent>
<groupId>org.opendaylight.vpnservice</groupId>
<artifactId>vpnmanager</artifactId>
- <version>0.0.1-SNAPSHOT</version>
+ <version>0.1.0-SNAPSHOT</version>
<name>vpnmanager</name>
<packaging>pom</packaging>
<modelVersion>4.0.0</modelVersion>
<project xmlns="http://maven.apache.org/POM/4.0.0" 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.vpnservice</groupId>
- <artifactId>binding-parent</artifactId>
- <version>0.0.1-SNAPSHOT</version>
+ <artifactId>config-parent</artifactId>
+ <version>0.1.0-SNAPSHOT</version>
<relativePath>../../commons/binding-parent</relativePath>
</parent>
<artifactId>model-bgp</artifactId>
<version>${model.bgp.version}</version>
</dependency>
+ <dependency>
+ <groupId>org.opendaylight.controller</groupId>
+ <artifactId>config-api</artifactId>
+ </dependency>
</dependencies>
</project>
--- /dev/null
+package org.opendaylight.vpnmanager.api;
+
+import java.util.Collection;
+
+public interface IVpnManager {
+ Collection<Long> getDpnsForVpn(long vpnId);
+}
--- /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.vpnmanager.api.IVpnManager";
+ }
+}
\ No newline at end of file
<parent>
<groupId>org.opendaylight.vpnservice</groupId>
<artifactId>config-parent</artifactId>
- <version>0.0.1-SNAPSHOT</version>
+ <version>0.1.0-SNAPSHOT</version>
<relativePath>../../commons/config-parent</relativePath>
</parent>
<artifactId>interfacemgr-api</artifactId>
<version>${vpnservices.version}</version>
</dependency>
+ <dependency>
+ <groupId>org.opendaylight.vpnservice</groupId>
+ <artifactId>idmanager-api</artifactId>
+ <version>${vpnservices.version}</version>
+ </dependency>
</dependencies>
</project>
<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>
</odlinterface>
</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>
--- /dev/null
+package org.opendaylight.vpnservice;
+
+public class VpnConstants {
+ public static final String VPN_IDPOOL_NAME = "vpnservices";
+ public static final long VPN_IDPOOL_START = 1L;
+ public static final String VPN_IDPOOL_SIZE = "65535";
+ public static final short LPORT_INGRESS_TABLE = 0;
+ public static final short FIB_TABLE = 21;
+ public static final short DEFAULT_FLOW_PRIORITY = 10;
+}
package org.opendaylight.vpnservice;
import java.math.BigInteger;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashSet;
import java.util.List;
import java.util.ArrayList;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Future;
import com.google.common.base.Optional;
+import com.google.common.collect.ImmutableList;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.FutureCallback;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.InstanceIdentifierBuilder;
+import org.opendaylight.yangtools.yang.common.RpcResult;
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.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.adjacency.list.Adjacency;
import org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.adjacency.list.AdjacencyBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.VpnInstance1;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.GetUniqueIdInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.GetUniqueIdInputBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.GetUniqueIdOutput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.IdManagerService;
import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.VpnInterfaces;
import org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.Adjacencies;
import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.VpnAfConfig;
private final IBgpManager bgpManager;
private IMdsalApiManager mdsalManager;
private IInterfaceManager interfaceManager;
+ private IdManagerService idManager;
+ private Map<Long, Collection<Long>> vpnToDpnsDb;
+ private Map<Long, Collection<String>> dpnToInterfaceDb;
private static final FutureCallback<Void> DEFAULT_CALLBACK =
new FutureCallback<Void>() {
super(VpnInterface.class);
broker = db;
this.bgpManager = bgpManager;
+ vpnToDpnsDb = new ConcurrentHashMap<>();
+ dpnToInterfaceDb = new ConcurrentHashMap<>();
registerListener(db);
}
this.mdsalManager = mdsalManager;
}
+ public void setInterfaceManager(IInterfaceManager interfaceManager) {
+ this.interfaceManager = interfaceManager;
+ }
+
+ public void setIdManager(IdManagerService idManager) {
+ this.idManager = idManager;
+ }
+
@Override
public void close() throws Exception {
if (listenerRegistration != null) {
@Override
protected void add(final InstanceIdentifier<VpnInterface> identifier,
final VpnInterface vpnInterface) {
- LOG.info("key: {} , value: {}", identifier, vpnInterface );
+ LOG.trace("key: {} , value: {}", identifier, vpnInterface );
addInterface(identifier, vpnInterface);
}
//Get the rd of the vpn instance
String rd = getRouteDistinguisher(intf.getVpnInstanceName());
- //TODO: Get the endpoint IP from interface manager
- String nextHopIp = "10.0.0.1";
+
+ long dpnId = interfaceManager.getDpnForInterface(intfName);
+ String nextHopIp = interfaceManager.getEndpointIpForDpn(dpnId);
if (!nextHops.isEmpty()) {
- LOG.info("NextHops are {}", nextHops);
+ LOG.trace("NextHops are {}", nextHops);
for (Adjacency nextHop : nextHops) {
- //TODO: Generate label for the prefix and store it in the next hop model
- long label = 200;
+ String key = nextHop.getIpAddress();
+ long label = getUniqueId(key);
- //TODO: Update BGP
- updatePrefixToBGP(rd, nextHop, nextHopIp);
+ updatePrefixToBGP(rd, nextHop, nextHopIp, label);
value.add(new AdjacencyBuilder(nextHop).setLabel(label).build());
}
}
}
}
+ private Integer getUniqueId(String idKey) {
+ GetUniqueIdInput getIdInput = new GetUniqueIdInputBuilder()
+ .setPoolName(VpnConstants.VPN_IDPOOL_NAME)
+ .setIdKey(idKey).build();
+
+ try {
+ Future<RpcResult<GetUniqueIdOutput>> result = idManager.getUniqueId(getIdInput);
+ RpcResult<GetUniqueIdOutput> rpcResult = result.get();
+ if(rpcResult.isSuccessful()) {
+ return rpcResult.getResult().getIdValue().intValue();
+ } else {
+ LOG.warn("RPC Call to Get Unique Id returned with Errors {}", rpcResult.getErrors());
+ }
+ } catch (NullPointerException | InterruptedException | ExecutionException e) {
+ LOG.warn("Exception when getting Unique Id",e);
+ }
+ return 0;
+ }
+
private long getVpnId(String vpnName) {
+ //TODO: This should be a Util function
InstanceIdentifier<VpnInstance1> id = InstanceIdentifier.builder(VpnInstances.class)
.child(VpnInstance.class, new VpnInstanceKey(vpnName)).augmentation(VpnInstance1.class).build();
- Optional<VpnInstance1> vpnInstance = read(LogicalDatastoreType.CONFIGURATION, id);
+ Optional<VpnInstance1> vpnInstance = read(LogicalDatastoreType.OPERATIONAL, id);
+ //TODO: Default vpnid should be a constant.
long vpnId = -1;
if(vpnInstance.isPresent()) {
vpnId = vpnInstance.get().getVpnId();
return rd;
}
+ private synchronized void updateMappingDbs(long vpnId, long dpnId, String intfName) {
+ Collection<Long> dpnIds = vpnToDpnsDb.get(vpnId);
+ if(dpnIds == null) {
+ dpnIds = new HashSet<>();
+ }
+ if(dpnIds.add(dpnId)) {
+ vpnToDpnsDb.put(vpnId, dpnIds);
+ //TODO: Send an Event that new DPN added...
+ }
+
+ Collection<String> intfNames = dpnToInterfaceDb.get(dpnId);
+ if(intfNames == null) {
+ intfNames = new ArrayList<>();
+ }
+ intfNames.add(intfName);
+ dpnToInterfaceDb.put(dpnId, intfNames);
+ }
+
+ private synchronized void remoteFromMappingDbs(long vpnId, long dpnId, String inftName) {
+ Collection<String> intfNames = dpnToInterfaceDb.get(dpnId);
+ if(intfNames == null) {
+ return;
+ }
+ intfNames.remove(inftName);
+ dpnToInterfaceDb.put(dpnId, intfNames);
+ if(intfNames.isEmpty()) {
+ Collection<Long> dpnIds = vpnToDpnsDb.get(vpnId);
+ if(dpnIds == null) {
+ return;
+ }
+ dpnIds.remove(dpnId);
+ vpnToDpnsDb.put(vpnId, dpnIds);
+ }
+ }
+
private void bindServiceOnInterface(Interface intf, long vpnId) {
- LOG.info("Bind service on interface {} for VPN: {}", intf, vpnId);
- //TODO: Create Ingress flow on the interface to bind the VPN service
- //TODO: Get dpn ID from the interface manager
- long dpId = 1;
- short LPORT_INGRESS_TABLE = 0;
- //TODO: Get the port no from interface manager
- int portNo = 1;
- String flowRef = getL3InterfaceFlowRef(dpId, LPORT_INGRESS_TABLE, vpnId, portNo);
+ LOG.trace("Bind service on interface {} for VPN: {}", intf, vpnId);
+
+ long dpId = interfaceManager.getDpnForInterface(intf.getName());
+ if(dpId == 0L) {
+ LOG.warn("DPN for interface {} not found. Bind service on this interface aborted.", intf.getName());
+ return;
+ } else {
+ updateMappingDbs(vpnId, dpId, intf.getName());
+ }
+
+ long portNo = interfaceManager.getPortForInterface(intf.getName());
+ String flowRef = getVpnInterfaceFlowRef(dpId, VpnConstants.LPORT_INGRESS_TABLE, vpnId, portNo);
String flowName = intf.getName();
BigInteger COOKIE_VM_INGRESS_TABLE = new BigInteger("8000001", 16);
- int priority = 10; //L3Constants.DEFAULT_L3_FLOW_PRIORITY;
- short gotoTableId = 21; //L3Constants.L3_FIB_TABLE;
+ int priority = VpnConstants.DEFAULT_FLOW_PRIORITY;
+ short gotoTableId = VpnConstants.FIB_TABLE;
List<InstructionInfo> mkInstructions = new ArrayList<InstructionInfo>();
mkInstructions.add(new InstructionInfo(InstructionType.write_metadata, new BigInteger[] {
matches.add(new MatchInfo(MatchFieldType.in_port, new long[] {
dpId, portNo }));
- FlowEntity flowEntity = MDSALUtil.buildFlowEntity(dpId, LPORT_INGRESS_TABLE, flowRef,
+ FlowEntity flowEntity = MDSALUtil.buildFlowEntity(dpId, VpnConstants.LPORT_INGRESS_TABLE, flowRef,
priority, flowName, 0, 0, COOKIE_VM_INGRESS_TABLE, matches, mkInstructions);
mdsalManager.installFlow(flowEntity);
}
- private String getL3InterfaceFlowRef(long dpId, short tableId,
- long vpnId, int portNo) {
+ private String getVpnInterfaceFlowRef(long dpId, short tableId,
+ long vpnId, long portNo) {
return new StringBuilder().append(dpId).append(tableId).append(vpnId).append(portNo).toString();
}
- private void updatePrefixToBGP(String rd, Adjacency nextHop, String nextHopIp) {
- //TODO: Update the Prefix to BGP
- //public void addPrefix(String rd, String prefix, String nextHop, int vpnLabel)
- int label = nextHop.getLabel().intValue();
+ private void updatePrefixToBGP(String rd, Adjacency nextHop, String nextHopIp, long label) {
try {
- bgpManager.addPrefix(rd, nextHop.getIpAddress(), nextHopIp, label);
+ bgpManager.addPrefix(rd, nextHop.getIpAddress(), nextHopIp, (int)label);
} catch(Exception e) {
LOG.error("Add prefix failed", e);
}
@Override
protected void remove( InstanceIdentifier<VpnInterface> identifier, VpnInterface vpnInterface) {
- LOG.info("Remove event - key: {}, value: {}" ,identifier, vpnInterface );
+ LOG.trace("Remove event - key: {}, value: {}" ,identifier, vpnInterface );
final VpnInterfaceKey key = identifier.firstKeyOf(VpnInterface.class, VpnInterfaceKey.class);
String interfaceName = key.getName();
InstanceIdentifierBuilder<Interface> idBuilder =
Optional<Interface> port = read(LogicalDatastoreType.CONFIGURATION, id);
if (port.isPresent()) {
Interface interf = port.get();
- unbindServiceOnInterface(interf);
removeNextHops(identifier, vpnInterface);
+ unbindServiceOnInterface(interf, getVpnId(vpnInterface.getVpnInstanceName()));
} else {
- LOG.info("No nexthops were available to handle remove event {}", interfaceName);
+ LOG.warn("No nexthops were available to handle remove event {}", interfaceName);
}
}
InstanceIdentifier<Adjacencies> path = identifier.augmentation(Adjacencies.class);
Optional<Adjacencies> adjacencies = read(LogicalDatastoreType.OPERATIONAL, path);
String intfName = intf.getName();
-
+ String rd = getRouteDistinguisher(intf.getVpnInstanceName());
if (adjacencies.isPresent()) {
List<Adjacency> nextHops = adjacencies.get().getAdjacency();
if (!nextHops.isEmpty()) {
LOG.trace("NextHops are " + nextHops);
for (Adjacency nextHop : nextHops) {
- //TODO: Update BGP
- removePrefixFromBGP(nextHop);
+ removePrefixFromBGP(rd, nextHop);
}
}
-
- InstanceIdentifier<VpnInterface> interfaceId = VpnUtil.getVpnInterfaceIdentifier(intfName);
- delete(LogicalDatastoreType.OPERATIONAL, interfaceId);
}
+ InstanceIdentifier<VpnInterface> interfaceId = VpnUtil.getVpnInterfaceIdentifier(intfName);
+ delete(LogicalDatastoreType.OPERATIONAL, interfaceId);
}
private <T extends DataObject> void delete(LogicalDatastoreType datastoreType, InstanceIdentifier<T> path) {
Futures.addCallback(tx.submit(), DEFAULT_CALLBACK);
}
- private void unbindServiceOnInterface(Interface intf) {
- //TODO: Remove Ingress flow on the interface to unbind the VPN service
+ private void unbindServiceOnInterface(Interface intf, long vpnId) {
+ LOG.trace("Unbind service on interface {} for VPN: {}", intf, vpnId);
+
+ long dpId = interfaceManager.getDpnForInterface(intf.getName());
+ if(dpId == 0L) {
+ LOG.warn("DPN for interface {} not found. Unbind service on this interface aborted.", intf.getName());
+ return;
+ } else {
+ remoteFromMappingDbs(vpnId, dpId, intf.getName());
+ }
+
+ long portNo = interfaceManager.getPortForInterface(intf.getName());
+ String flowRef = getVpnInterfaceFlowRef(dpId, VpnConstants.LPORT_INGRESS_TABLE, vpnId, portNo);
+
+ String flowName = intf.getName();
+
+ int priority = VpnConstants.DEFAULT_FLOW_PRIORITY;
+
+ List<MatchInfo> matches = new ArrayList<MatchInfo>();
+ matches.add(new MatchInfo(MatchFieldType.in_port, new long[] {
+ dpId, portNo }));
+
+ FlowEntity flowEntity = MDSALUtil.buildFlowEntity(dpId, VpnConstants.LPORT_INGRESS_TABLE, flowRef,
+ priority, flowName, 0, 0, null, matches, null);
+
+ mdsalManager.removeFlow(flowEntity);
}
- private void removePrefixFromBGP(Adjacency nextHop) {
- //TODO: Update the Prefix to BGP
+ private void removePrefixFromBGP(String rd, Adjacency nextHop) {
+ //public void deletePrefix(String rd, String prefix) throws Exception;
+ try {
+ bgpManager.deletePrefix(rd, nextHop.getIpAddress());
+ } catch(Exception e) {
+ LOG.error("Delete prefix failed", e);
+ }
}
@Override
tx.put(datastoreType, path, data, true);
Futures.addCallback(tx.submit(), callback);
}
+
+ synchronized Collection<Long> getDpnsForVpn(long vpnId) {
+ Collection<Long> dpnIds = vpnToDpnsDb.get(vpnId);
+ if(dpnIds != null) {
+ return ImmutableList.copyOf(dpnIds);
+ } else {
+ return Collections.emptyList();
+ }
+ }
}
import java.util.Arrays;
import java.util.Collection;
import java.util.List;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Future;
import org.opendaylight.bgpmanager.api.IBgpManager;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.common.RpcResult;
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.opendaylight.vpnservice.fibmanager.rev150330.fibentries.VrfTables;
import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.fibmanager.rev150330.fibentries.VrfTablesKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.fibmanager.rev150330.vrfentries.VrfEntry;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.GetUniqueIdInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.GetUniqueIdInputBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.GetUniqueIdOutput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.IdManagerService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
private ListenerRegistration<DataChangeListener> listenerRegistration, fibListenerRegistration;
private final DataBroker broker;
private final IBgpManager bgpManager;
+ private IdManagerService idManager;
private final FibEntriesListener fibListener;
private static final FutureCallback<Void> DEFAULT_CALLBACK =
}
}
+ public void setIdManager(IdManagerService idManager) {
+ this.idManager = idManager;
+ }
+
@Override
- protected void remove(InstanceIdentifier<VpnInstance> identifier,
- VpnInstance del) {
- // TODO Auto-generated method stub
+ protected void remove(InstanceIdentifier<VpnInstance> identifier, VpnInstance del) {
+ LOG.trace("Remove event - Key: {}, value: {}", identifier, del);
+ String vpnName = del.getVpnInstanceName();
+ InstanceIdentifier<VpnInstance> vpnIdentifier = VpnUtil.getVpnInstanceIdentifier(vpnName);
+ delete(LogicalDatastoreType.OPERATIONAL, vpnIdentifier);
+
+ String rd = del.getIpv4Family().getRouteDistinguisher();
+ try {
+ bgpManager.deleteVrf(rd);
+ } catch(Exception e) {
+ LOG.error("Exception when removing VRF from BGP", e);
+ }
}
@Override
protected void update(InstanceIdentifier<VpnInstance> identifier,
VpnInstance original, VpnInstance update) {
- // TODO Auto-generated method stub
+ LOG.trace("Update event - Key: {}, value: {}", identifier, update);
}
@Override
protected void add(InstanceIdentifier<VpnInstance> identifier,
VpnInstance value) {
- LOG.info("key: {}, value: {}" +identifier, value);
- //TODO: Generate VPN ID for this instance, where to store in model ... ?
- long vpnId = 1000;
- InstanceIdentifier<VpnInstance1> augId = identifier.augmentation(VpnInstance1.class);
- Optional<VpnInstance1> vpnAugmenation = read(LogicalDatastoreType.CONFIGURATION, augId);
- if(vpnAugmenation.isPresent()) {
- VpnInstance1 vpn = vpnAugmenation.get();
- vpnId = vpn.getVpnId();
- LOG.info("VPN ID is {}", vpnId);
- }
+ LOG.trace("key: {}, value: {}", identifier, value);
+
+ long vpnId = getUniqueId(value.getVpnInstanceName());
VpnInstance opValue = new VpnInstanceBuilder(value).
addAugmentation(VpnInstance1.class, new VpnInstance1Builder().setVpnId(vpnId).build()).build();
asyncWrite(LogicalDatastoreType.OPERATIONAL, identifier, opValue, DEFAULT_CALLBACK);
- //TODO: Add VRF to BGP
//public void addVrf(String rd, Collection<String> importRts, Collection<String> exportRts)
VpnAfConfig config = value.getIpv4Family();
String rd = config.getRouteDistinguisher();
return null;
}
+ private Integer getUniqueId(String idKey) {
+ GetUniqueIdInput getIdInput = new GetUniqueIdInputBuilder()
+ .setPoolName(VpnConstants.VPN_IDPOOL_NAME)
+ .setIdKey(idKey).build();
+
+ try {
+ Future<RpcResult<GetUniqueIdOutput>> result = idManager.getUniqueId(getIdInput);
+ RpcResult<GetUniqueIdOutput> rpcResult = result.get();
+ if(rpcResult.isSuccessful()) {
+ return rpcResult.getResult().getIdValue().intValue();
+ } else {
+ LOG.warn("RPC Call to Get Unique Id returned with Errors {}", rpcResult.getErrors());
+ }
+ } catch (NullPointerException | InterruptedException | ExecutionException e) {
+ LOG.warn("Exception when getting Unique Id",e);
+ }
+ return 0;
+ }
+
+ private <T extends DataObject> void delete(LogicalDatastoreType datastoreType, InstanceIdentifier<T> path) {
+ WriteTransaction tx = broker.newWriteOnlyTransaction();
+ tx.delete(datastoreType, path);
+ Futures.addCallback(tx.submit(), DEFAULT_CALLBACK);
+ }
+
private class FibEntriesListener extends AbstractDataChangeListener<VrfEntry> {
public FibEntriesListener() {
@Override
protected void remove(InstanceIdentifier<VrfEntry> identifier,
VrfEntry del) {
- // TODO Auto-generated method stub
-
+ 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();
+ VpnInstance vpn = getVpnForRD(rd);
+ if(vpn != null) {
+ InstanceIdentifier<VpnInstance> id = VpnUtil.getVpnInstanceIdentifier(vpn.getVpnInstanceName());
+ InstanceIdentifier<VpnInstance1> augId = id.augmentation(VpnInstance1.class);
+ Optional<VpnInstance1> vpnAugmenation = read(LogicalDatastoreType.OPERATIONAL, augId);
+ if(vpnAugmenation.isPresent()) {
+ VpnInstance1 vpnAug = vpnAugmenation.get();
+ List<Long> routeIds = vpnAug.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, augId,
+ new VpnInstance1Builder(vpnAug).setRouteEntryId(routeIds).build(), DEFAULT_CALLBACK);
+ } else {
+ LOG.warn("VPN Augmentation not found for vpn instance {}", vpn.getVpnInstanceName());
+ }
+ } else {
+ LOG.warn("No VPN Instance found for RD: {}", rd);
+ }
}
@Override
@Override
protected void add(InstanceIdentifier<VrfEntry> identifier,
VrfEntry add) {
- LOG.info("Key : " + identifier + " value : " + 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();
if(routeIds == null) {
routeIds = new ArrayList<>();
}
- LOG.info("Adding label to vpn info " + label);
+ LOG.debug("Adding label to vpn info - {}", label);
routeIds.add(label);
asyncWrite(LogicalDatastoreType.OPERATIONAL, augId,
new VpnInstance1Builder(vpnAug).setRouteEntryId(routeIds).build(), DEFAULT_CALLBACK);
} else {
- LOG.info("VPN Augmentation not found");
+ LOG.warn("VPN Augmentation not found for vpn instance {}", vpn.getVpnInstanceName());
}
} else {
LOG.warn("No VPN Instance found for RD: {}", rd);
package org.opendaylight.vpnservice;
import java.util.List;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Future;
+
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.VpnInstances;
import org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.adjacency.list.Adjacency;
import org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.Adjacencies;
import org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.AdjacenciesBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.Pools;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.pools.IdPool;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.pools.IdPoolKey;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.common.RpcResult;
public class VpnUtil {
static InstanceIdentifier<VpnInterface> getVpnInterfaceIdentifier(String vpnInterfaceName) {
static Adjacencies getVpnInterfaceAugmentation(List<Adjacency> nextHops) {
return new AdjacenciesBuilder().setAdjacency(nextHops).build();
}
+
+ public static InstanceIdentifier<IdPool> getPoolId(String poolName){
+ InstanceIdentifier.InstanceIdentifierBuilder<IdPool> idBuilder =
+ InstanceIdentifier.builder(Pools.class).child(IdPool.class, new IdPoolKey(poolName));
+ InstanceIdentifier<IdPool> id = idBuilder.build();
+ return id;
+ }
}
*/
package org.opendaylight.vpnservice;
+import java.math.BigInteger;
+import java.util.Collection;
import java.util.Collections;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Future;
import org.opendaylight.bgpmanager.api.IBgpManager;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.sal.binding.api.BindingAwareBroker.ProviderContext;
import org.opendaylight.controller.sal.binding.api.BindingAwareProvider;
+import org.opendaylight.vpnmanager.api.IVpnManager;
import org.opendaylight.vpnservice.interfacemgr.interfaces.IInterfaceManager;
import org.opendaylight.vpnservice.mdsalutil.interfaces.IMdsalApiManager;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.CreateIdPoolInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.CreateIdPoolInputBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.IdManagerService;
+import org.opendaylight.yangtools.yang.common.RpcResult;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-public class VpnserviceProvider implements BindingAwareProvider,
+public class VpnserviceProvider implements BindingAwareProvider, IVpnManager,
AutoCloseable {
private static final Logger LOG = LoggerFactory.getLogger(VpnserviceProvider.class);
private IBgpManager bgpManager;
private IMdsalApiManager mdsalManager;
private IInterfaceManager interfaceManager;
+ private IdManagerService idManager;
@Override
public void onSessionInitiated(ProviderContext session) {
try {
final DataBroker dataBroker = session.getSALService(DataBroker.class);
vpnManager = new VpnManager(dataBroker, bgpManager);
+ vpnManager.setIdManager(idManager);
vpnInterfaceManager = new VpnInterfaceManager(dataBroker, bgpManager);
vpnInterfaceManager.setMdsalManager(mdsalManager);
+ vpnInterfaceManager.setInterfaceManager(interfaceManager);
+ vpnInterfaceManager.setIdManager(idManager);
+ createIdPool();
} catch (Exception e) {
LOG.error("Error initializing services", e);
}
this.interfaceManager = interfaceManager;
}
+ public void setIdManager(IdManagerService idManager) {
+ this.idManager = idManager;
+ }
+
+ private void createIdPool() {
+ CreateIdPoolInput createPool = new CreateIdPoolInputBuilder()
+ .setPoolName(VpnConstants.VPN_IDPOOL_NAME)
+ .setIdStart(VpnConstants.VPN_IDPOOL_START)
+ .setPoolSize(new BigInteger(VpnConstants.VPN_IDPOOL_SIZE))
+ .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();
}
+
+ @Override
+ public Collection<Long> getDpnsForVpn(long vpnId) {
+ return vpnInterfaceManager.getDpnsForVpn(vpnId);
+ }
}
package org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpnservice.impl.rev150216;
import org.opendaylight.vpnservice.VpnserviceProvider;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.IdManagerService;
public class VpnserviceImplModule extends org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpnservice.impl.rev150216.AbstractVpnserviceImplModule {
public VpnserviceImplModule(org.opendaylight.controller.config.api.ModuleIdentifier identifier, org.opendaylight.controller.config.api.DependencyResolver dependencyResolver) {
@Override
public java.lang.AutoCloseable createInstance() {
+ IdManagerService idManager = getRpcregistryDependency().getRpcService(IdManagerService.class);
VpnserviceProvider provider = new VpnserviceProvider();
provider.setBgpManager(getBgpmanagerDependency());
provider.setMdsalManager(getMdsalutilDependency());
provider.setInterfaceManager(getOdlinterfaceDependency());
+ provider.setIdManager(idManager);
getBrokerDependency().registerProvider(provider);
return provider;
}
import config { prefix config; revision-date 2013-04-05; }
import opendaylight-md-sal-binding { prefix md-sal-binding; 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 2015-04-10;}
import odl-interface {prefix odlif; revision-date 2015-03-31;}
identity vpnservice-impl {
base config:module-type;
+ config:provided-service vpnmgr-api:vpnmanager-api;
config:java-name-prefix VpnserviceImpl;
}
}
}
}
+ 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 {
<dependencyManagement>
<dependencies>
- <!--<dependency>
- <groupId>${project.groupId}</groupId>
- <artifactId>vpnmanager-api</artifactId>
- <version>${project.version}</version>
- </dependency>
- <dependency>
- <groupId>${project.groupId}</groupId>
- <artifactId>vpnmanager-impl</artifactId>
- <version>${project.version}</version>
- </dependency> -->
<dependency>
<groupId>${project.groupId}</groupId>
<artifactId>vpnservice-features</artifactId>
Code Review / vpnservice.git / commitdiff