[ONOS-2287,ONOS-2288]Pcep TunnelProvider implementation
Change-Id: I4184336c200f1060e93be5dc28076ba35f6b98f4
diff --git a/providers/pcep/tunnel/src/main/java/org/onosproject/provider/pcep/tunnel/impl/PcepTunnelProvider.java b/providers/pcep/tunnel/src/main/java/org/onosproject/provider/pcep/tunnel/impl/PcepTunnelProvider.java
index 4a7cbca..e859870 100644
--- a/providers/pcep/tunnel/src/main/java/org/onosproject/provider/pcep/tunnel/impl/PcepTunnelProvider.java
+++ b/providers/pcep/tunnel/src/main/java/org/onosproject/provider/pcep/tunnel/impl/PcepTunnelProvider.java
@@ -16,13 +16,18 @@
package org.onosproject.provider.pcep.tunnel.impl;
import static com.google.common.base.Preconditions.checkNotNull;
+import static org.onosproject.net.DefaultAnnotations.EMPTY;
import static org.onosproject.net.DeviceId.deviceId;
import static org.onosproject.net.PortNumber.portNumber;
+import static org.onosproject.pcep.api.PcepDpid.uri;
import static org.slf4j.LoggerFactory.getLogger;
import java.util.ArrayList;
+import java.util.Collections;
import java.util.HashMap;
+import java.util.LinkedList;
import java.util.List;
+import java.util.ListIterator;
import java.util.Optional;
import org.apache.felix.scr.annotations.Activate;
@@ -31,9 +36,12 @@
import org.apache.felix.scr.annotations.Reference;
import org.apache.felix.scr.annotations.ReferenceCardinality;
import org.apache.felix.scr.annotations.Service;
+import org.onlab.packet.IpAddress;
import org.onosproject.core.DefaultGroupId;
import org.onosproject.incubator.net.tunnel.DefaultOpticalTunnelEndPoint;
+import org.onosproject.incubator.net.tunnel.DefaultTunnel;
import org.onosproject.incubator.net.tunnel.DefaultTunnelDescription;
+import org.onosproject.incubator.net.tunnel.IpTunnelEndPoint;
import org.onosproject.incubator.net.tunnel.OpticalLogicId;
import org.onosproject.incubator.net.tunnel.OpticalTunnelEndPoint;
import org.onosproject.incubator.net.tunnel.Tunnel;
@@ -50,9 +58,11 @@
import org.onosproject.net.DefaultPath;
import org.onosproject.net.DeviceId;
import org.onosproject.net.ElementId;
+import org.onosproject.net.IpElementId;
import org.onosproject.net.Link;
import org.onosproject.net.Path;
import org.onosproject.net.PortNumber;
+import org.onosproject.net.SparseAnnotations;
import org.onosproject.net.provider.AbstractProvider;
import org.onosproject.net.provider.ProviderId;
import org.onosproject.pcep.api.PcepController;
@@ -60,9 +70,34 @@
import org.onosproject.pcep.api.PcepHopNodeDescription;
import org.onosproject.pcep.api.PcepOperator.OperationType;
import org.onosproject.pcep.api.PcepTunnel;
-import org.onosproject.pcep.api.PcepTunnel.PathState;
import org.onosproject.pcep.api.PcepTunnel.PATHTYPE;
+import org.onosproject.pcep.api.PcepTunnel.PathState;
import org.onosproject.pcep.api.PcepTunnelListener;
+import org.onosproject.pcep.controller.PccId;
+import org.onosproject.pcep.controller.PcepClient;
+import org.onosproject.pcep.controller.PcepClientController;
+import org.onosproject.pcep.controller.PcepClientListener;
+import org.onosproject.pcep.controller.PcepEventListener;
+import org.onosproject.pcepio.exceptions.PcepParseException;
+import org.onosproject.pcepio.protocol.PcInitiatedLspRequest;
+import org.onosproject.pcepio.protocol.PcepAttribute;
+import org.onosproject.pcepio.protocol.PcepBandwidthObject;
+import org.onosproject.pcepio.protocol.PcepEndPointsObject;
+import org.onosproject.pcepio.protocol.PcepEroObject;
+import org.onosproject.pcepio.protocol.PcepInitiateMsg;
+import org.onosproject.pcepio.protocol.PcepLspObject;
+import org.onosproject.pcepio.protocol.PcepMessage;
+import org.onosproject.pcepio.protocol.PcepMsgPath;
+import org.onosproject.pcepio.protocol.PcepReportMsg;
+import org.onosproject.pcepio.protocol.PcepRroObject;
+import org.onosproject.pcepio.protocol.PcepSrpObject;
+import org.onosproject.pcepio.protocol.PcepStateReport;
+import org.onosproject.pcepio.protocol.PcepUpdateMsg;
+import org.onosproject.pcepio.protocol.PcepUpdateRequest;
+import org.onosproject.pcepio.types.IPv4SubObject;
+import org.onosproject.pcepio.types.PcepValueType;
+import org.onosproject.pcepio.types.StatefulIPv4LspIdentidiersTlv;
+import org.onosproject.pcepio.types.SymbolicPathNameTlv;
import org.slf4j.Logger;
import static org.onosproject.pcep.api.PcepDpid.*;
@@ -73,14 +108,13 @@
*/
@Component(immediate = true)
@Service
-public class PcepTunnelProvider extends AbstractProvider
- implements TunnelProvider {
+public class PcepTunnelProvider extends AbstractProvider implements TunnelProvider {
private static final Logger log = getLogger(PcepTunnelProvider.class);
private static final long MAX_BANDWIDTH = 99999744;
private static final long MIN_BANDWIDTH = 64;
private static final String BANDWIDTH_UINT = "kbps";
- static final String PROVIDER_ID = "org.onosproject.provider.tunnel.default";
+ static final String PROVIDER_ID = "org.onosproject.provider.tunnel.pcep";
private static final String TUNNLE_NOT_NULL = "Create failed,The given port may be wrong or has been occupied.";
@@ -90,23 +124,30 @@
@Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
protected PcepController controller;
+ @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
+ protected PcepClientController pcepClientController;
TunnelProviderService service;
HashMap<String, TunnelId> tunnelMap = new HashMap<String, TunnelId>();
- private InnerTunnerProvider listener = new InnerTunnerProvider();
+ private InnerTunnelProvider listener = new InnerTunnelProvider();
+
+ protected PcepTunnelApiMapper pcepTunnelAPIMapper = new PcepTunnelApiMapper();
+ private static final int DEFAULT_BANDWIDTH_VALUE = 10;
/**
* Creates a Tunnel provider.
*/
public PcepTunnelProvider() {
- super(new ProviderId("default", PROVIDER_ID));
+ super(new ProviderId("pcep", PROVIDER_ID));
}
@Activate
public void activate() {
service = tunnelProviderRegistry.register(this);
controller.addTunnelListener(listener);
+ pcepClientController.addListener(listener);
+ pcepClientController.addEventListener(listener);
log.info("Started");
}
@@ -114,47 +155,173 @@
public void deactivate() {
tunnelProviderRegistry.unregister(this);
controller.removeTunnelListener(listener);
+ pcepClientController.removeListener(listener);
log.info("Stopped");
}
@Override
public void setupTunnel(Tunnel tunnel, Path path) {
- // TODO Auto-generated method stub
+ if (tunnel.type() != Tunnel.Type.MPLS) {
+ log.error("Tunnel Type MPLS is only supported");
+ return;
+ }
+ // check for tunnel end points
+ if (!(tunnel.src() instanceof IpTunnelEndPoint) || !(tunnel.dst() instanceof IpTunnelEndPoint)) {
+ log.error("Tunnel source or destination is not valid");
+ return;
+ }
+
+ // Get the pcc client
+ PcepClient pc = pcepClientController.getClient(PccId.pccId(((IpTunnelEndPoint) tunnel.src()).ip()));
+
+ if (!(pc instanceof PcepClient)) {
+ log.error("There is no PCC connected with ip addresss {}"
+ + ((IpTunnelEndPoint) tunnel.src()).ip().toString());
+ return;
+ }
+ pcepSetupTunnel(tunnel, path, pc);
}
@Override
public void setupTunnel(ElementId srcElement, Tunnel tunnel, Path path) {
- // TODO Auto-generated method stub
+ if (tunnel.type() != Tunnel.Type.MPLS) {
+ log.error("Tunnel Type MPLS is only supported");
+ return;
+ }
+
+ if (!(srcElement instanceof IpElementId)) {
+ log.error("Element id is not valid");
+ return;
+ }
+
+ // check for tunnel end points
+ if (!(tunnel.src() instanceof IpTunnelEndPoint) || !(tunnel.dst() instanceof IpTunnelEndPoint)) {
+ log.error("Tunnel source or destination is not valid");
+ return;
+ }
+
+ PcepClient pc = pcepClientController.getClient(PccId.pccId(((IpElementId) srcElement).ipAddress()));
+
+ if (!(pc instanceof PcepClient)) {
+ log.error("There is no PCC connected with ip addresss {}"
+ + ((IpElementId) srcElement).ipAddress().toString());
+ return;
+ }
+ pcepSetupTunnel(tunnel, path, pc);
}
@Override
public void releaseTunnel(Tunnel tunnel) {
- // TODO Auto-generated method stub
+ if (tunnel.type() != Tunnel.Type.MPLS) {
+ log.error("Tunnel Type MPLS is only supported");
+ return;
+ }
+
+ // check for tunnel end points
+ if (!(tunnel.src() instanceof IpTunnelEndPoint) || !(tunnel.dst() instanceof IpTunnelEndPoint)) {
+ log.error("Tunnel source or destination is not valid");
+ return;
+ }
+
+ PcepClient pc = pcepClientController.getClient(PccId.pccId(((IpTunnelEndPoint) tunnel.src()).ip()));
+
+ if (!(pc instanceof PcepClient)) {
+ log.error("There is no PCC connected with ip addresss {}"
+ + ((IpTunnelEndPoint) tunnel.src()).ip().toString());
+ return;
+ }
+ pcepReleaseTunnel(tunnel, pc);
}
@Override
public void releaseTunnel(ElementId srcElement, Tunnel tunnel) {
- // TODO Auto-generated method stub
+ if (tunnel.type() != Tunnel.Type.MPLS) {
+ log.error("Tunnel Type MPLS is only supported");
+ return;
+ }
+ if (!(srcElement instanceof IpElementId)) {
+ log.error("Element id is not valid");
+ return;
+ }
+
+ // check for tunnel end points
+ if (!(tunnel.src() instanceof IpTunnelEndPoint) || !(tunnel.dst() instanceof IpTunnelEndPoint)) {
+ log.error("Tunnel source or destination is not valid");
+ return;
+ }
+
+ PcepClient pc = pcepClientController.getClient(PccId.pccId(((IpElementId) srcElement).ipAddress()));
+
+ if (!(pc instanceof PcepClient)) {
+ log.error("There is no PCC connected with ip addresss {}"
+ + ((IpElementId) srcElement).ipAddress().toString());
+ return;
+ }
+ pcepReleaseTunnel(tunnel, pc);
}
@Override
public void updateTunnel(Tunnel tunnel, Path path) {
- // TODO Auto-generated method stub
+ if (tunnel.type() != Tunnel.Type.MPLS) {
+ log.error("Tunnel Type MPLS is only supported");
+ return;
+ }
+ // check for tunnel end points
+ if (!(tunnel.src() instanceof IpTunnelEndPoint) || !(tunnel.dst() instanceof IpTunnelEndPoint)) {
+ log.error("Tunnel source or destination is not valid");
+ return;
+ }
+
+ PcepClient pc = pcepClientController.getClient(PccId.pccId(((IpTunnelEndPoint) tunnel.src()).ip()));
+
+ if (!(pc instanceof PcepClient)) {
+ log.error("There is no PCC connected with ip addresss {}"
+ + ((IpTunnelEndPoint) tunnel.src()).ip().toString());
+ return;
+ }
+ pcepUpdateTunnel(tunnel, path, pc);
}
@Override
public void updateTunnel(ElementId srcElement, Tunnel tunnel, Path path) {
- // TODO Auto-generated method stub
+ if (tunnel.type() != Tunnel.Type.MPLS) {
+ log.error("Tunnel Type MPLS is only supported");
+ return;
+ }
+
+ if (!(srcElement instanceof IpElementId)) {
+ log.error("Element id is not valid");
+ return;
+ }
+
+ // check for tunnel end points
+ if (!(tunnel.src() instanceof IpTunnelEndPoint) || !(tunnel.dst() instanceof IpTunnelEndPoint)) {
+ log.error("Tunnel source or destination is not valid");
+ return;
+ }
+
+ PcepClient pc = pcepClientController.getClient(PccId.pccId(((IpElementId) srcElement).ipAddress()));
+
+ if (!(pc instanceof PcepClient)) {
+ log.error("There is no PCC connected with ip addresss {}"
+ + ((IpElementId) srcElement).ipAddress().toString());
+ return;
+ }
+ pcepUpdateTunnel(tunnel, path, pc);
}
@Override
public TunnelId tunnelAdded(TunnelDescription tunnel) {
+ if (tunnel.type() == Tunnel.Type.MPLS) {
+ pcepTunnelAPIMapper.removeFromCoreTunnelRequestQueue(tunnel.id());
+ return service.tunnelAdded(tunnel);
+ }
long bandwidth = Long
.parseLong(tunnel.annotations().value("bandwidth"));
@@ -185,7 +352,7 @@
PcepTunnel pcepTunnel = controller.applyTunnel(srcId, dstId, srcPort,
dstPort, bandwidth,
tunnel.tunnelName()
- .value());
+ .value());
checkNotNull(pcepTunnel, TUNNLE_NOT_NULL);
TunnelDescription tunnelAdded = buildOpticalTunnel(pcepTunnel, null);
@@ -197,6 +364,11 @@
@Override
public void tunnelRemoved(TunnelDescription tunnel) {
+ if (tunnel.type() == Tunnel.Type.MPLS) {
+ pcepTunnelAPIMapper.removeFromCoreTunnelRequestQueue(tunnel.id());
+ service.tunnelRemoved(tunnel);
+ }
+
Tunnel tunnelOld = tunnelQueryById(tunnel.id());
checkNotNull(tunnelOld, "The tunnel id is not exsited.");
if (tunnelOld.type() != Tunnel.Type.VLAN) {
@@ -215,6 +387,10 @@
@Override
public void tunnelUpdated(TunnelDescription tunnel) {
+ if (tunnel.type() == Tunnel.Type.MPLS) {
+ pcepTunnelAPIMapper.removeFromCoreTunnelRequestQueue(tunnel.id());
+ service.tunnelUpdated(tunnel);
+ }
Tunnel tunnelOld = tunnelQueryById(tunnel.id());
if (tunnelOld.type() != Tunnel.Type.VLAN) {
@@ -380,7 +556,6 @@
* @return corresponding tunnel id of the a tunnel key.
*/
private TunnelId getTunnelId(String tunnelKey) {
-
for (String key : tunnelMap.keySet()) {
if (key.equals(tunnelKey)) {
return tunnelMap.get(key);
@@ -405,11 +580,274 @@
}
- private class InnerTunnerProvider implements PcepTunnelListener {
+ /**
+ * Creates list of hops for ERO object from Path.
+ *
+ * @param path network path
+ * @return list of ipv4 subobjects
+ */
+ private LinkedList<PcepValueType> createPcepPath(Path path) {
+ LinkedList<PcepValueType> llSubObjects = new LinkedList<PcepValueType>();
+ List<Link> listLink = path.links();
+ ConnectPoint source = null;
+ ConnectPoint destination = null;
+ IpAddress ipDstAddress = null;
+ IpAddress ipSrcAddress = null;
+ PcepValueType subObj = null;
+
+ for (Link link : listLink) {
+ source = link.src();
+ if (!(source.equals(destination))) {
+ //set IPv4SubObject for ERO object
+ ipSrcAddress = source.ipElementId().ipAddress();
+ subObj = new IPv4SubObject(ipSrcAddress.getIp4Address().toInt());
+ llSubObjects.add(subObj);
+ }
+
+ destination = link.dst();
+ ipDstAddress = destination.ipElementId().ipAddress();
+ subObj = new IPv4SubObject(ipDstAddress.getIp4Address().toInt());
+ llSubObjects.add(subObj);
+ }
+ return llSubObjects;
+ }
+
+ /**
+ * Creates PcInitiated lsp request list for setup tunnel.
+ *
+ * @param tunnel mpls tunnel
+ * @param path network path
+ * @param pc pcep client
+ * @param srpId unique id for pcep message
+ * @return list of PcInitiatedLspRequest
+ * @throws PcepParseException while building pcep objects fails
+ */
+ LinkedList<PcInitiatedLspRequest> createPcInitiatedLspReqList(Tunnel tunnel, Path path,
+ PcepClient pc, int srpId)
+ throws PcepParseException {
+ PcepValueType tlv;
+ LinkedList<PcepValueType> llSubObjects = createPcepPath(path);
+
+ if (null == llSubObjects || 0 == llSubObjects.size()) {
+ log.error("There is no link information to create tunnel");
+ return null;
+ }
+
+ //build SRP object
+ PcepSrpObject srpobj = pc.factory().buildSrpObject().setSrpID(srpId).setRFlag(false).build();
+
+ LinkedList<PcepValueType> llOptionalTlv = new LinkedList<PcepValueType>();
+ LinkedList<PcInitiatedLspRequest> llPcInitiatedLspRequestList = new LinkedList<PcInitiatedLspRequest>();
+ // set LSP identifiers TLV
+ tlv = new StatefulIPv4LspIdentidiersTlv((((IpTunnelEndPoint) tunnel.src()).ip().getIp4Address().toInt()),
+ (short) 0, (short) 0, 0,
+ (((IpTunnelEndPoint) tunnel.dst()).ip().getIp4Address().toInt()));
+ llOptionalTlv.add(tlv);
+ //set SymbolicPathNameTlv of LSP object
+ tlv = new SymbolicPathNameTlv(tunnel.tunnelName().value().getBytes());
+ llOptionalTlv.add(tlv);
+
+ //build LSP object
+ PcepLspObject lspobj = pc.factory().buildLspObject().setAFlag(true).setOFlag((byte) 0).setPlspId(0)
+ .setOptionalTlv(llOptionalTlv).build();
+
+ //build ENDPOINTS object
+ PcepEndPointsObject endpointsobj = pc.factory().buildEndPointsObject()
+ .setSourceIpAddress(((IpTunnelEndPoint) tunnel.src()).ip().getIp4Address().toInt())
+ .setDestIpAddress(((IpTunnelEndPoint) tunnel.dst()).ip().getIp4Address().toInt())
+ .setPFlag(true).build();
+
+ //build ERO object
+ PcepEroObject eroobj = pc.factory().buildEroObject().setSubObjects(llSubObjects).build();
+
+ int iBandwidth = DEFAULT_BANDWIDTH_VALUE;
+ if (null != tunnel.annotations().value("bandwidth")) {
+ iBandwidth = Integer.parseInt(tunnel.annotations().value("bandwidth"));
+ }
+ // build bandwidth object
+ PcepBandwidthObject bandwidthObject = pc.factory().buildBandwidthObject().setBandwidth(iBandwidth).build();
+ // build pcep attribute
+ PcepAttribute pcepAttribute = pc.factory().buildPcepAttribute().setBandwidthObject(bandwidthObject).build();
+
+ PcInitiatedLspRequest initiateLspRequest = pc.factory().buildPcInitiatedLspRequest().setSrpObject(srpobj)
+ .setLspObject(lspobj).setEndPointsObject(endpointsobj).setEroObject(eroobj)
+ .setPcepAttribute(pcepAttribute).build();
+ llPcInitiatedLspRequestList.add(initiateLspRequest);
+ return llPcInitiatedLspRequestList;
+ }
+
+ /**
+ * To send initiate tunnel message to pcc.
+ *
+ * @param tunnel mpls tunnel info
+ * @param path explicit route for the tunnel
+ * @param pc pcep client to send message
+ */
+ private void pcepSetupTunnel(Tunnel tunnel, Path path, PcepClient pc) {
+ try {
+ int srpId = SrpIdGenerators.create();
+ PcepTunnelData pcepTunnelData = new PcepTunnelData(tunnel, path, RequestType.CREATE);
+
+ pcepTunnelAPIMapper.addToCoreTunnelRequestQueue(pcepTunnelData);
+
+ LinkedList<PcInitiatedLspRequest> llPcInitiatedLspRequestList = createPcInitiatedLspReqList(tunnel, path,
+ pc, srpId);
+ if (null == llPcInitiatedLspRequestList || 0 == llPcInitiatedLspRequestList.size()) {
+ log.error("Failed to create PcInitiatedLspRequestList");
+ return;
+ }
+
+ //build PCInitiate message
+ PcepInitiateMsg pcInitiateMsg = pc.factory().buildPcepInitiateMsg()
+ .setPcInitiatedLspRequestList(llPcInitiatedLspRequestList)
+ .build();
+
+ pc.sendMessage(Collections.singletonList(pcInitiateMsg));
+
+ pcepTunnelAPIMapper.addToTunnelRequestQueue(srpId, pcepTunnelData);
+ } catch (PcepParseException e) {
+ log.error("PcepParseException occurred while processing setup tunnel {}", e.getMessage());
+ }
+ }
+
+ /**
+ * To send Release tunnel message to pcc.
+ *
+ * @param tunnel mpls tunnel info
+ * @param pc pcep client to send message
+ */
+ private void pcepReleaseTunnel(Tunnel tunnel, PcepClient pc) {
+ try {
+ PcepTunnelData pcepTunnelData = new PcepTunnelData(tunnel, RequestType.DELETE);
+ pcepTunnelAPIMapper.addToCoreTunnelRequestQueue(pcepTunnelData);
+ int srpId = SrpIdGenerators.create();
+ TunnelId tunnelId = tunnel.tunnelId();
+ int plspId = 0;
+ StatefulIPv4LspIdentidiersTlv statefulIpv4IndentifierTlv = null;
+
+ if (!(pcepTunnelAPIMapper.checkFromTunnelDBQueue(tunnelId))) {
+ log.error("Tunnel doesnot exists. Tunnel id {}" + tunnelId.toString());
+ return;
+ } else {
+ PcepTunnelData pcepTunnelDbData = pcepTunnelAPIMapper.getDataFromTunnelDBQueue(tunnelId);
+ plspId = pcepTunnelDbData.plspId();
+ statefulIpv4IndentifierTlv = pcepTunnelDbData.statefulIpv4IndentifierTlv();
+ }
+ // build srp object
+ PcepSrpObject srpobj = pc.factory().buildSrpObject().setSrpID(srpId).setRFlag(true).build();
+
+ PcepValueType tlv;
+ LinkedList<PcepValueType> llOptionalTlv = new LinkedList<PcepValueType>();
+ LinkedList<PcInitiatedLspRequest> llPcInitiatedLspRequestList = new LinkedList<PcInitiatedLspRequest>();
+
+ if (null != statefulIpv4IndentifierTlv) {
+ tlv = statefulIpv4IndentifierTlv;
+ } else {
+ tlv = new StatefulIPv4LspIdentidiersTlv((
+ ((IpTunnelEndPoint) tunnel.src()).ip().getIp4Address().toInt()),
+ (short) 0, (short) 0, 0,
+ (((IpTunnelEndPoint) tunnel.dst()).ip().getIp4Address().toInt()));
+ }
+ llOptionalTlv.add(tlv);
+ tlv = new SymbolicPathNameTlv(tunnel.tunnelName().value().getBytes());
+ llOptionalTlv.add(tlv);
+ // build lsp object, set r flag as false to delete the tunnel
+ PcepLspObject lspobj = pc.factory().buildLspObject().setRFlag(false).setPlspId(plspId)
+ .setOptionalTlv(llOptionalTlv).build();
+
+ PcInitiatedLspRequest releaseLspRequest = pc.factory().buildPcInitiatedLspRequest().setSrpObject(srpobj)
+ .setLspObject(lspobj).build();
+
+ llPcInitiatedLspRequestList.add(releaseLspRequest);
+
+ PcepInitiateMsg pcInitiateMsg = pc.factory().buildPcepInitiateMsg()
+ .setPcInitiatedLspRequestList(llPcInitiatedLspRequestList).build();
+
+ pc.sendMessage(Collections.singletonList(pcInitiateMsg));
+
+ pcepTunnelAPIMapper.addToTunnelRequestQueue(srpId, pcepTunnelData);
+ } catch (PcepParseException e) {
+ log.error("PcepParseException occurred while processing release tunnel {}", e.getMessage());
+ }
+ }
+
+ /**
+ * To send Update tunnel request message to pcc.
+ *
+ * @param tunnel mpls tunnel info
+ * @param path explicit route for the tunnel
+ * @param pc pcep client to send message
+ */
+ private void pcepUpdateTunnel(Tunnel tunnel, Path path, PcepClient pc) {
+ try {
+ PcepTunnelData pcepTunnelData = new PcepTunnelData(tunnel, path, RequestType.UPDATE);
+ pcepTunnelAPIMapper.addToCoreTunnelRequestQueue(pcepTunnelData);
+ int srpId = SrpIdGenerators.create();
+ TunnelId tunnelId = tunnel.tunnelId();
+ PcepValueType tlv;
+ int plspId = 0;
+
+ LinkedList<PcepValueType> llSubObjects = createPcepPath(path);
+ LinkedList<PcepValueType> llOptionalTlv = new LinkedList<PcepValueType>();
+ LinkedList<PcepUpdateRequest> llUpdateRequestList = new LinkedList<PcepUpdateRequest>();
+
+ //build SRP object
+ PcepSrpObject srpobj = pc.factory().buildSrpObject().setSrpID(srpId).setRFlag(false).build();
+
+ if (!(pcepTunnelAPIMapper.checkFromTunnelDBQueue(tunnelId))) {
+ log.error("Tunnel doesnot exists in DB");
+ return;
+ } else {
+ PcepTunnelData pcepTunnelDBData = pcepTunnelAPIMapper.getDataFromTunnelDBQueue(tunnelId);
+ plspId = pcepTunnelDBData.plspId();
+ }
+
+ tlv = new StatefulIPv4LspIdentidiersTlv((((IpTunnelEndPoint) tunnel.src()).ip().getIp4Address().toInt()),
+ (short) 0, (short) 0, 0,
+ (((IpTunnelEndPoint) tunnel.dst()).ip().getIp4Address().toInt()));
+ llOptionalTlv.add(tlv);
+
+ if (tunnel.tunnelName().value() != null) {
+ tlv = new SymbolicPathNameTlv(tunnel.tunnelName().value().getBytes());
+ llOptionalTlv.add(tlv);
+ }
+
+ // build lsp object
+ PcepLspObject lspobj = pc.factory().buildLspObject().setAFlag(true).setPlspId(plspId)
+ .setOptionalTlv(llOptionalTlv).build();
+ // build ero object
+ PcepEroObject eroobj = pc.factory().buildEroObject().setSubObjects(llSubObjects).build();
+
+ int iBandwidth = DEFAULT_BANDWIDTH_VALUE;
+ if (null != tunnel.annotations().value("bandwidth")) {
+ iBandwidth = Integer.parseInt(tunnel.annotations().value("bandwidth"));
+ }
+ // build bandwidth object
+ PcepBandwidthObject bandwidthObject = pc.factory().buildBandwidthObject().setBandwidth(iBandwidth).build();
+ // build pcep attribute
+ PcepAttribute pcepAttribute = pc.factory().buildPcepAttribute().setBandwidthObject(bandwidthObject).build();
+ // build pcep msg path
+ PcepMsgPath msgPath = pc.factory().buildPcepMsgPath().setEroObject(eroobj).setPcepAttribute(pcepAttribute)
+ .build();
+
+ PcepUpdateRequest updateRequest = pc.factory().buildPcepUpdateRequest().setSrpObject(srpobj)
+ .setLspObject(lspobj).setMsgPath(msgPath).build();
+
+ llUpdateRequestList.add(updateRequest);
+
+ PcepUpdateMsg pcUpdateMsg = pc.factory().buildUpdateMsg().setUpdateRequestList(llUpdateRequestList).build();
+
+ pc.sendMessage(Collections.singletonList(pcUpdateMsg));
+ pcepTunnelAPIMapper.addToTunnelRequestQueue(srpId, pcepTunnelData);
+ } catch (PcepParseException e) {
+ log.error("PcepParseException occurred while processing release tunnel {}", e.getMessage());
+ }
+ }
+
+ private class InnerTunnelProvider implements PcepTunnelListener, PcepEventListener, PcepClientListener {
@Override
public void handlePCEPTunnel(PcepTunnel pcepTunnel) {
-
TunnelDescription tunnel = null;
// instance and id identify a tunnel together
String tunnelKey = String.valueOf(pcepTunnel.getInstance())
@@ -442,9 +880,263 @@
default:
log.error("Invalid tunnel operation");
+ }
+ }
+ @Override
+ public void handleMessage(PccId pccId, PcepMessage msg) {
+ try {
+ log.debug("tunnel provider handle message {}", msg.getType().toString());
+ switch (msg.getType()) {
+ case REPORT:
+ int srpId = 0;
+ LinkedList<PcepStateReport> llStateReportList = null;
+ llStateReportList = ((PcepReportMsg) msg).getStateReportList();
+ ListIterator<PcepStateReport> listIterator = llStateReportList.listIterator();
+ PcepSrpObject srpObj = null;
+ PcepLspObject lspObj = null;
+ while (listIterator.hasNext()) {
+ PcepStateReport stateRpt = listIterator.next();
+ srpObj = stateRpt.getSrpObject();
+ lspObj = stateRpt.getLspObject();
+
+ if (srpObj instanceof PcepSrpObject) {
+ srpId = srpObj.getSrpID();
+ }
+
+ log.debug("Plsp ID in handle message " + lspObj.getPlspId());
+ log.debug("SRP ID in handle message " + srpId);
+
+ if (!(pcepTunnelAPIMapper.checkFromTunnelRequestQueue(srpId))) {
+
+ // Check the sync status
+ if (lspObj.getSFlag()) {
+ handleSyncReport(stateRpt);
+ } else if (!pcepClientController.getClient(pccId).isSyncComplete()) {
+ // sync is done
+ pcepClientController.getClient(pccId).setIsSyncComplete(true);
+ }
+ continue;
+ }
+
+ handleReportMessage(srpId, lspObj);
+ }
+ break;
+
+ default:
+ log.debug("Received unsupported message type {}", msg.getType().toString());
+ }
+ } catch (Exception e) {
+ log.error("Exception occured while processing report message {}", e.getMessage());
+ }
+ }
+
+ /**
+ * Handles report message for setup/update/delete tunnel request.
+ *
+ * @param srpId unique identifier for pcep message
+ * @param lspObj lsp object
+ */
+ private void handleReportMessage(int srpId, PcepLspObject lspObj) {
+ ProviderId providerId = new ProviderId("pcep", PROVIDER_ID);
+ PcepTunnelData pcepTunnelData = pcepTunnelAPIMapper.getDataFromTunnelRequestQueue(srpId);
+ SparseAnnotations annotations = (SparseAnnotations) pcepTunnelData.tunnel().annotations();
+
+ // store the values required from report message
+ pcepTunnelData.setPlspId(lspObj.getPlspId());
+ pcepTunnelData.setLspAFlag(lspObj.getAFlag());
+ pcepTunnelData.setLspOFlag(lspObj.getOFlag());
+ pcepTunnelData.setLspDFlag(lspObj.getDFlag());
+
+ StatefulIPv4LspIdentidiersTlv ipv4LspTlv = null;
+ ListIterator<PcepValueType> listTlvIterator = lspObj.getOptionalTlv().listIterator();
+ while (listTlvIterator.hasNext()) {
+ PcepValueType tlv = listTlvIterator.next();
+ if (tlv.getType() == StatefulIPv4LspIdentidiersTlv.TYPE) {
+ ipv4LspTlv = (StatefulIPv4LspIdentidiersTlv) tlv;
+ break;
+ }
+ }
+ if (null != ipv4LspTlv) {
+ pcepTunnelData.setStatefulIpv4IndentifierTlv(ipv4LspTlv);
}
+ Path path = pcepTunnelData.path();
+ Tunnel tunnel = pcepTunnelData.tunnel();
+ DefaultTunnelDescription td = new DefaultTunnelDescription(tunnel.tunnelId(), tunnel.src(),
+ tunnel.dst(), tunnel.type(), tunnel.groupId(),
+ providerId, tunnel.tunnelName(), path,
+ annotations);
+
+ if (RequestType.CREATE == pcepTunnelData.requestType()) {
+ log.debug("Report received for create request");
+
+ pcepTunnelAPIMapper.handleCreateTunnelRequestQueue(srpId, pcepTunnelData);
+ if (0 == lspObj.getOFlag()) {
+ log.warn("The tunnel is in down state");
+ }
+ tunnelAdded(td);
+ }
+ if (RequestType.DELETE == pcepTunnelData.requestType()) {
+ log.debug("Report received for delete request");
+ pcepTunnelAPIMapper.handleRemoveFromTunnelRequestQueue(srpId, pcepTunnelData);
+ tunnelRemoved(td);
+ }
+
+ if (RequestType.UPDATE == pcepTunnelData.requestType()) {
+ log.debug("Report received for update request");
+ pcepTunnelData.setRptFlag(true);
+ pcepTunnelAPIMapper.addToTunnelIdMap(pcepTunnelData);
+ pcepTunnelAPIMapper.handleUpdateTunnelRequestQueue(srpId, pcepTunnelData);
+
+ if (0 == lspObj.getOFlag()) {
+ log.warn("The tunnel is in down state");
+ }
+ if (!(pcepTunnelAPIMapper.checkFromTunnelRequestQueue(srpId))) {
+ tunnelUpdated(td);
+ }
+ }
+ }
+
+ /**
+ * Handles sync report received from pcc.
+ *
+ * @param stateRpt pcep state report
+ */
+ private void handleSyncReport(PcepStateReport stateRpt) {
+ PcepLspObject lspObj = stateRpt.getLspObject();
+ PcepStateReport.PcepMsgPath msgPath = stateRpt.getMsgPath();
+ checkNotNull(msgPath);
+ PcepRroObject rroObj = msgPath.getRroObject();
+ checkNotNull(rroObj);
+ int bandwidth = 0;
+
+ log.debug("Handle Sync report received from PCC.");
+
+ if (0 == lspObj.getOFlag()) {
+ log.warn("The PCC reported tunnel is in down state");
+ }
+ log.debug("Sync report received");
+
+ if (null != msgPath.getBandwidthObject()) {
+ bandwidth = msgPath.getBandwidthObject().getBandwidth();
+ }
+
+ buildAndStorePcepTunnelData(lspObj, rroObj, bandwidth);
+ }
+
+ /**
+ * To build Path in network from RRO object.
+ *
+ * @param rroObj rro object
+ * @param providerId provider id
+ * @return path object
+ */
+ private Path buildPathFromRroObj(PcepRroObject rroObj, ProviderId providerId) {
+ checkNotNull(rroObj);
+ List<Link> links = new ArrayList<Link>();
+ LinkedList<PcepValueType> llSubObj = rroObj.getSubObjects();
+ if (0 == llSubObj.size()) {
+ log.error("RRO in report message does not have hop information");
+ }
+ ListIterator<PcepValueType> tlvIterator = llSubObj.listIterator();
+
+ ConnectPoint src = null;
+ ConnectPoint dst = null;
+ boolean isSrcSet = false;
+ while (tlvIterator.hasNext()) {
+ PcepValueType subObj = tlvIterator.next();
+ switch (subObj.getType()) {
+
+ case IPv4SubObject.TYPE:
+
+ IPv4SubObject ipv4SubObj = (IPv4SubObject) subObj;
+ if (!isSrcSet) {
+ IpAddress srcIp = IpAddress.valueOf(ipv4SubObj.getIpAddress());
+ src = new ConnectPoint(IpElementId.ipElement(srcIp), PortNumber.portNumber(0));
+ isSrcSet = true;
+ } else {
+ IpAddress dstIp = IpAddress.valueOf(ipv4SubObj.getIpAddress());
+ dst = new ConnectPoint(IpElementId.ipElement(dstIp), PortNumber.portNumber(0));
+ Link link = new DefaultLink(providerId, src, dst, Link.Type.DIRECT, EMPTY);
+ links.add(link);
+ src = dst;
+ }
+ break;
+ default:
+ // the other sub objects are not required
+ }
+ }
+ return new DefaultPath(providerId, links, 0, EMPTY);
+ }
+
+ /**
+ * To build pcepTunnelData and informs core about the pcc reported tunnel.
+ *
+ * @param lspObj pcep lsp object
+ * @param rroObj pcep rro object
+ * @param bandwidth bandwidth of tunnel
+ */
+ private void buildAndStorePcepTunnelData(PcepLspObject lspObj, PcepRroObject rroObj,
+ int bandwidth) {
+
+ ProviderId providerId = new ProviderId("pcep", PROVIDER_ID);
+
+ // StatefulIPv4LspIdentidiersTlv in LSP object will have the source and destination address.
+ StatefulIPv4LspIdentidiersTlv lspIdenTlv = null;
+ SymbolicPathNameTlv pathNameTlv = null;
+ LinkedList<PcepValueType> llOptionalTlv = lspObj.getOptionalTlv();
+ ListIterator<PcepValueType> listIterator = llOptionalTlv.listIterator();
+ while (listIterator.hasNext()) {
+ PcepValueType tlv = listIterator.next();
+ switch (tlv.getType()) {
+ case StatefulIPv4LspIdentidiersTlv.TYPE:
+ lspIdenTlv = (StatefulIPv4LspIdentidiersTlv) tlv;
+ break;
+ case SymbolicPathNameTlv.TYPE:
+ pathNameTlv = (SymbolicPathNameTlv) tlv;
+ break;
+ default:
+ // currently this tlv is not required
+ }
+ }
+
+ IpTunnelEndPoint tunnelEndPointSrc;
+ tunnelEndPointSrc = IpTunnelEndPoint.ipTunnelPoint(IpAddress.valueOf(lspIdenTlv.getIpv4IngressAddress()));
+ IpTunnelEndPoint tunnelEndPointDst;
+ tunnelEndPointDst = IpTunnelEndPoint.ipTunnelPoint(IpAddress.valueOf(lspIdenTlv.getIpv4EgressAddress()));
+
+ Path path = buildPathFromRroObj(rroObj, providerId);
+
+ SparseAnnotations annotations = DefaultAnnotations.builder()
+ .set("bandwidth", (new Integer(bandwidth)).toString())
+ .build();
+
+ DefaultTunnelDescription td = new DefaultTunnelDescription(null, tunnelEndPointSrc,
+ tunnelEndPointDst, Tunnel.Type.MPLS,
+ new DefaultGroupId(0), providerId,
+ TunnelName.tunnelName(pathNameTlv.toString()),
+ path, annotations);
+ TunnelId tId = tunnelAdded(td);
+
+ Tunnel tunnel = new DefaultTunnel(providerId, tunnelEndPointSrc, tunnelEndPointDst, Tunnel.Type.MPLS,
+ new DefaultGroupId(0), tId,
+ TunnelName.tunnelName(pathNameTlv.toString()), path, annotations);
+
+ PcepTunnelData pcepTunnelData = new PcepTunnelData(tunnel, path, RequestType.LSP_STATE_RPT);
+ pcepTunnelData.setStatefulIpv4IndentifierTlv(lspIdenTlv);
+ pcepTunnelAPIMapper.addPccTunnelDB(pcepTunnelData);
+ pcepTunnelAPIMapper.addToTunnelIdMap(pcepTunnelData);
+ }
+
+ @Override
+ public void clientConnected(PccId pccId) {
+ // TODO
+ }
+
+ @Override
+ public void clientDisconnected(PccId pccId) {
+ // TODO
}
}
@@ -452,5 +1144,4 @@
public Tunnel tunnelQueryById(TunnelId tunnelId) {
return service.tunnelQueryById(tunnelId);
}
-
}