홍길동 / onos

Go to a project
Toggle navigation Toggle navigation pinning
Phanendra Manda
Committed by Gerrit Code Review
37b97fba 1 parent 5dc1e07f

[ONOS-2287,ONOS-2288]Pcep TunnelProvider implementation 

Change-Id: I4184336c200f1060e93be5dc28076ba35f6b98f4
Expand all
Inline Side-by-side
Showing 9 changed files with 787 additions and 17 deletions
......@@ -85,6 +85,23 @@ public class ConnectPoint {
}
/**
* Returns the identifier of the infrastructure device if the connection
* point belongs to a network element which is indeed an ip of pcc
* client identifier.
*
* @return network element identifier as a pcc client identifier
* @throws java.lang.IllegalStateException if connection point is not
* associated with a pcc client
*/
public IpElementId ipElementId() {
if (elementId instanceof IpElementId) {
return (IpElementId) elementId;
}
throw new IllegalStateException("Connection point not associated " +
"with an pcc client");
}
/**
* Returns the connection port number.
*
* @return port number
......
package org.onosproject.net;
import java.util.Objects;
import org.onlab.packet.IpAddress;
import com.google.common.base.MoreObjects;
/**
* Represent for a Element ID using ip address.
*/
public final class IpElementId extends ElementId {
private final IpAddress ipAddress;
/**
* Public construction is prohibited.
* @param ipAddress ip address
*/
private IpElementId(IpAddress ipAddress) {
this.ipAddress = ipAddress;
}
/**
* Create a IP Element ID.
* @param ipAddress IP address
* @return IpElementId
*/
public static IpElementId ipElement(IpAddress ipAddress) {
return new IpElementId(ipAddress);
}
/**
* Returns the ip address.
*
* @return ipAddress
*/
public IpAddress ipAddress() {
return ipAddress;
}
@Override
public int hashCode() {
return Objects.hash(ipAddress);
}
@Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (obj instanceof IpElementId) {
final IpElementId other = (IpElementId) obj;
return Objects.equals(this.ipAddress, other.ipAddress);
}
return false;
}
@Override
public String toString() {
return MoreObjects.toStringHelper(getClass()).add("ipAddress", ipAddress).toString();
}
}
......@@ -220,5 +220,4 @@ public class PcepFactoryVer1 implements PcepFactory {
public PcepLabelRangeResvMsg.Builder buildPcepLabelRangeResvMsg() {
return new PcepLabelRangeResvMsgVer1.Builder();
}
}
......
<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">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>org.onosproject</groupId>
<artifactId>onos-pcep-providers</artifactId>
<version>1.3.0-SNAPSHOT</version>
<relativePath>../pom.xml</relativePath>
</parent>
<artifactId>onos-pcep-provider-tunnel</artifactId>
<packaging>bundle</packaging>
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>org.onosproject</groupId>
<artifactId>onos-pcep-providers</artifactId>
<version>1.3.0-SNAPSHOT</version>
<relativePath>../pom.xml</relativePath>
</parent>
<artifactId>onos-pcep-provider-tunnel</artifactId>
<packaging>bundle</packaging>
<description>PCEP-based tunnel provider</description>
<dependencies>
<dependency>
<groupId>org.onosproject</groupId>
<artifactId>onos-app-pcep-api</artifactId>
</dependency>
</dependencies>
<dependencies>
<dependency>
<groupId>org.onosproject</groupId>
<artifactId>onos-app-pcep-api</artifactId>
</dependency>
<dependency>
<groupId>org.onosproject</groupId>
<artifactId>onos-pcep-controller-api</artifactId>
</dependency>
</dependencies>
</project>
\ No newline at end of file
......
/*
* Copyright 2015 Open Networking Laboratory
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.onosproject.provider.pcep.tunnel.impl;
import java.util.HashMap;
import java.util.Map;
import org.apache.commons.collections.map.MultiKeyMap;
import org.onosproject.incubator.net.tunnel.TunnelId;
import org.onosproject.incubator.net.tunnel.TunnelProviderService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* Entity to provide tunnel DB and mapping for request/response between CORE to PCEP
* and PCEP to PCC.
*/
public class PcepTunnelApiMapper {
protected static final Logger log = LoggerFactory.getLogger(PcepTunnelApiMapper.class);
static final String PROVIDER_ID = "org.onosproject.provider.tunnel.pcep";
// Map to store all the tunnel requests.
private Map<Integer, PcepTunnelData> tunnelRequestQueue;
//Map to store all core related tunnel requests.
private Map<TunnelId, PcepTunnelData> coreTunnelRequestQueue;
//Map to store all the created tunnels.
private Map<Integer, PcepTunnelData> tunnelDB;
// Map to store the tunnel ids, given by core and given by pcc.
private Map<TunnelId, Integer> tunnelIdMap;
//Map to store all the learnt tunnels.
private MultiKeyMap pccTunnelDB = new MultiKeyMap();
TunnelProviderService tunnelApiMapperservice;
/**
* Default constructor.
*/
public PcepTunnelApiMapper() {
//TODO check if the map need to initialize
tunnelRequestQueue = new HashMap<Integer, PcepTunnelData>();
coreTunnelRequestQueue = new HashMap<TunnelId, PcepTunnelData>();
tunnelDB = new HashMap<Integer, PcepTunnelData>();
tunnelIdMap = new HashMap<TunnelId, Integer>();
}
/**
* Add tunnels to tunnel Request queues.
*
* @param srpId srp id
* @param pcepTunnelData pcep tunnel data
*/
public void addToTunnelRequestQueue(int srpId, PcepTunnelData pcepTunnelData) {
tunnelRequestQueue.put(new Integer(srpId), pcepTunnelData);
log.debug("Tunnel Added to TunnelRequestQueue");
}
/**
* Map between Tunnel ID and pcc provided Tunnel ID.
*
* @param pcepTunnelData pcep tunnel data
*/
public void addToTunnelIdMap(PcepTunnelData pcepTunnelData) {
int value = pcepTunnelData.statefulIpv4IndentifierTlv().getTunnelId() & 0xFFFF;
tunnelIdMap.put(pcepTunnelData.tunnel().tunnelId(), (new Integer(value)));
log.debug("Tunnel ID Added to tunnelIdMap");
}
/**
* Add tunnels to core tunnel request queue.
*
* @param pcepTunnelData pcep tunnel data
*/
public void addToCoreTunnelRequestQueue(PcepTunnelData pcepTunnelData) {
coreTunnelRequestQueue.put(pcepTunnelData.tunnel().tunnelId(), pcepTunnelData);
log.debug("Tunnel Added to CoreTunnelRequestQueue");
}
/**
* Removes tunnels from the core tunnel request queue.
*
* @param tunnelId tunnel id
*/
public void removeFromCoreTunnelRequestQueue(TunnelId tunnelId) {
coreTunnelRequestQueue.remove(tunnelId);
log.debug("Tunnnel create response sent to core and removed from CoreTunnelRequestQueue");
}
/**
* Handle the report which comes after initiate message.
*
* @param srpId srp id
* @param pcepTunnelData pcep tunnel data
*/
public void handleCreateTunnelRequestQueue(int srpId, PcepTunnelData pcepTunnelData) {
int value = tunnelIdMap.get(pcepTunnelData.tunnel().tunnelId());
tunnelDB.put(new Integer(value), pcepTunnelData);
tunnelRequestQueue.remove(new Integer(srpId), pcepTunnelData);
log.debug("Tunnel Added to TunnelDBQueue and removed from TunnelRequestQueue. tunnel id {}"
+ (new Integer(value)).toString());
}
/**
* Handle report which comes for update message.
*
* @param srpId srp id
* @param pcepTunnelData pcep tunnel data
*/
public void handleUpdateTunnelRequestQueue(int srpId, PcepTunnelData pcepTunnelData) {
if (pcepTunnelData.rptFlag()) {
pcepTunnelData.setRptFlag(false);
int value = tunnelIdMap.get(pcepTunnelData.tunnel().tunnelId());
tunnelDB.put(new Integer(value), pcepTunnelData);
tunnelRequestQueue.remove(new Integer(srpId), pcepTunnelData);
log.debug("Tunnel Added to TunnelDBQueue and removed from TunnelRequestQueue. tunnel id {}" ,
(new Integer(value)).toString());
} else {
pcepTunnelData.setRptFlag(true);
tunnelRequestQueue.put(new Integer(srpId), pcepTunnelData);
log.debug("Tunnel updated in TunnelRequestQueue");
}
}
/**
* Handle report for tunnel Release request.
*
* @param srpId srp id
* @param pcepTunnelData pcep tunnel data
*/
public void handleRemoveFromTunnelRequestQueue(int srpId, PcepTunnelData pcepTunnelData) {
int value = tunnelIdMap.get(pcepTunnelData.tunnel().tunnelId());
tunnelIdMap.remove(pcepTunnelData.tunnel().tunnelId());
tunnelDB.remove(new Integer(value));
tunnelRequestQueue.remove(srpId);
log.debug("Tunnel removed from TunnelDBQueue and TunnelRequestQueue");
}
/**
* Returns PcepTunnelData from the tunnel request queue.
*
* @param srpId srp id
* @return PcepTunnelData pcep tunnel data
*/
public PcepTunnelData getDataFromTunnelRequestQueue(int srpId) {
return tunnelRequestQueue.get(new Integer(srpId));
}
/**
* Returns PcepTunnelData from the tunnel DB.
*
* @param tunnelId tunnel id
* @return PcepTunnelData pcep tunnel data
*/
public PcepTunnelData getDataFromTunnelDBQueue(TunnelId tunnelId) {
int value = tunnelIdMap.get(tunnelId);
return tunnelDB.get((new Integer(value)));
}
/**
* Checks whether the tunnel exist in tunnel request queue.
*
* @param srpId srp id
* @return true if tunnel exist in reuest queue, false otherwise
*/
public boolean checkFromTunnelRequestQueue(int srpId) {
boolean retValue = tunnelRequestQueue.containsKey(srpId);
return retValue;
}
/**
* Returns whether tunnel exist in tunnel db.
*
* @param tunnelId
* @return true/false
*/
public boolean checkFromTunnelDBQueue(TunnelId tunnelId) {
int value = tunnelIdMap.get(tunnelId);
boolean retValue = tunnelDB.containsKey((new Integer(value)));
return retValue;
}
/**
* Add Learnt tunnels to pcc tunnel DB.
*
* @param pcepTunnelData pcep tunnel data
*/
public void addPccTunnelDB(PcepTunnelData pcepTunnelData) {
pccTunnelDB.put(pcepTunnelData.statefulIpv4IndentifierTlv().getTunnelId() & 0xFFFFL,
pcepTunnelData.statefulIpv4IndentifierTlv().getIpv4IngressAddress(), pcepTunnelData);
}
}
/*
* Copyright 2015 Open Networking Laboratory
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.onosproject.provider.pcep.tunnel.impl;
import java.util.Objects;
import org.onosproject.incubator.net.tunnel.Tunnel;
import org.onosproject.net.ElementId;
import org.onosproject.net.Path;
import org.onosproject.pcepio.types.StatefulIPv4LspIdentidiersTlv;
import com.google.common.base.MoreObjects;
/**
* To store all tunnel related information from Core and Path computation client.
*/
public class PcepTunnelData {
private Tunnel tunnel;
private Path path;
private int plspId;
private ElementId elementId;
private RequestType requestType;
private boolean rptFlag;
// data need to store from LSP object
private boolean lspAFlag;
private boolean lspDFlag;
private byte lspOFlag;
private short tunnelId;
private int extTunnelId;
private short lspId;
private StatefulIPv4LspIdentidiersTlv statefulIpv4IndentifierTlv;
/**
* Default constructor.
*/
public PcepTunnelData() {
this.elementId = null;
this.tunnel = null;
this.path = null;
this.requestType = null;
this.rptFlag = false;
this.plspId = 0;
}
/**
* Constructor to initialize Tunnel, Path and Request type.
*
* @param tunnel mpls tunnel
* @param path Path in network
* @param requestType request type for tunnel
*/
public PcepTunnelData(Tunnel tunnel, Path path, RequestType requestType) {
this.tunnel = tunnel;
this.path = path;
this.requestType = requestType;
}
/**
* Constructor to initialize ElemendId, Tunnel, Path and Request type.
*
* @param elementId Ip element id
* @param tunnel mpls tunnel
* @param path Path in network
* @param requestType request type for tunnel
*/
public PcepTunnelData(ElementId elementId, Tunnel tunnel, Path path, RequestType requestType) {
this.elementId = elementId;
this.tunnel = tunnel;
this.path = path;
this.requestType = requestType;
}
/**
* Constructor to initialize Tunnel and Request type.
*
* @param tunnel Tunnel from core
* @param requestType request type for tunnel
*/
public PcepTunnelData(Tunnel tunnel, RequestType requestType) {
this.tunnel = tunnel;
this.requestType = requestType;
}
/**
* Constructor to initialize ElementId, Tunnel and Request type.
*
* @param elementId Ip element id
* @param tunnel mpls tunnel
* @param requestType request type for tunnel
*/
public PcepTunnelData(ElementId elementId, Tunnel tunnel, RequestType requestType) {
this.elementId = elementId;
this.tunnel = tunnel;
this.requestType = requestType;
}
/**
* Sets ip element id.
*
* @param elementId Ip element id
*/
public void setElementId(ElementId elementId) {
this.elementId = elementId;
}
/**
* Sets tunnel.
*
* @param tunnel mpls tunnel
*/
public void setTunnel(Tunnel tunnel) {
this.tunnel = tunnel;
}
/**
* Sets Path.
*
* @param path Path in network
*/
public void setPath(Path path) {
this.path = path;
}
/**
* Request type for tunnel.
*
* @param requestType request type for tunnel
*/
public void setRequestType(RequestType requestType) {
this.requestType = requestType;
}
/**
* Sets plspid generated from pcc.
*
* @param plspId plsp identifier
*/
public void setPlspId(int plspId) {
this.plspId = plspId;
}
/**
* Sets A flag from lsp object.
*
* @param value A flag value
*/
public void setLspAFlag(boolean value) {
this.lspAFlag = value;
}
/**
* Sets OF flag from lsp object.
*
* @param value OF flag value
*/
public void setLspOFlag(byte value) {
this.lspOFlag = value;
}
/**
* Sets tunnel id from PCC.
*
* @param value tunnel id value
*/
public void setTunnelId(short value) {
this.tunnelId = value;
}
/**
* Sets extended tunnel id from PCC.
*
* @param value extended tunnel id value
*/
public void setExtTunnelId(int value) {
this.extTunnelId = value;
}
/**
* Sets lsp id from pcc.
*
* @param value lsp id
*/
public void setLspId(short value) {
this.lspId = value;
}
/**
* Sets statefulIpv4Identifiers tlv.
* @param value statefulIpv4Identifiers tlv
*/
public void setStatefulIpv4IndentifierTlv(StatefulIPv4LspIdentidiersTlv value) {
this.statefulIpv4IndentifierTlv = value;
}
/**
* Sets report flag.
*
* @param rptFlag report flag
*/
public void setRptFlag(boolean rptFlag) {
this.rptFlag = rptFlag;
}
/**
* Sets D flag from lsp object.
*
* @param value D flag value
*/
public void setLspDFlag(boolean value) {
this.lspDFlag = value;
}
/**
* To get Ip element id.
*
* @return Ip elemend id
*/
public ElementId elementId() {
return this.elementId;
}
/**
* To get Tunnel.
*
* @return tunnel
*/
public Tunnel tunnel() {
return this.tunnel;
}
/**
* To get Path.
*
* @return path
*/
public Path path() {
return this.path;
}
/**
* To get request type.
*
* @return request type
*/
public RequestType requestType() {
return this.requestType;
}
/**
* To get pLspId.
*
* @return pLspId
*/
public int plspId() {
return this.plspId;
}
/**
* To get A flag.
*
* @return A flag
*/
public boolean lspAFlag() {
return this.lspAFlag;
}
/**
* To get OF flag.
*
* @return OF flag
*/
public byte lspOFlag() {
return this.lspOFlag;
}
/**
* To get tunnel id.
*
* @return tunnel id
*/
public short tunnelId() {
return this.tunnelId;
}
/**
* To get extended tunnel id.
*
* @return extended tunnel id
*/
public int extTunnelId() {
return this.extTunnelId;
}
/**
* To get pLspId.
*
* @return pLspId
*/
public short lspId() {
return this.lspId;
}
/**
* To get D Flag.
*
* @return d flag
*/
public boolean lspDFlag() {
return this.lspDFlag;
}
/**
* To get statefulIpv4Indentifier tlv.
*
* @return statefulIpv4Indentifier tlv
*/
public StatefulIPv4LspIdentidiersTlv statefulIpv4IndentifierTlv() {
return this.statefulIpv4IndentifierTlv;
}
/**
* To get report flag.
*
* @return report flag
*/
public boolean rptFlag() {
return this.rptFlag;
}
@Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (obj instanceof PcepTunnelData) {
PcepTunnelData other = (PcepTunnelData) obj;
return Objects.equals(tunnel, other.tunnel)
&& Objects.equals(path, other.path)
&& Objects.equals(plspId, other.plspId)
&& Objects.equals(elementId, other.elementId)
&& Objects.equals(requestType, other.requestType)
&& Objects.equals(rptFlag, other.rptFlag)
&& Objects.equals(lspAFlag, other.lspAFlag)
&& Objects.equals(lspDFlag, other.lspDFlag)
&& Objects.equals(lspOFlag, other.lspOFlag)
&& Objects.equals(tunnelId, other.tunnelId)
&& Objects.equals(extTunnelId, other.extTunnelId)
&& Objects.equals(lspId, other.lspId)
&& Objects.equals(statefulIpv4IndentifierTlv, other.statefulIpv4IndentifierTlv);
}
return false;
}
@Override
public int hashCode() {
return Objects.hash(tunnel, path, plspId, elementId, requestType, rptFlag, lspAFlag,
lspDFlag, lspOFlag, tunnelId, extTunnelId, lspId, statefulIpv4IndentifierTlv);
}
@Override
public String toString() {
return MoreObjects.toStringHelper(getClass()).add("Tunnel", tunnel)
.add("Path", path).add("PlspId", plspId).add("ElementId", elementId)
.add("RequestType", requestType).add("RptFlag", rptFlag).add("LspAFlag", lspAFlag)
.add("LspDFlag", lspDFlag).add("LspOFlag", lspOFlag).add("TunnelId", tunnelId)
.add("ExtTunnelid", extTunnelId).add("LspId", lspId)
.add("StatefulIpv4IndentifierTlv", statefulIpv4IndentifierTlv).toString();
}
}
/*
* Copyright 2015 Open Networking Laboratory
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.onosproject.provider.pcep.tunnel.impl;
/**
* Enum of request types between pcc and pcep.
*/
public enum RequestType {
/**
* Specifies the request type for PCC is to create new tunnel.
*/
CREATE,
/**
* Specifies the request type for PCC is to update existing tunnel.
*/
UPDATE,
/**
* Specifies the request type for PCC is to delete existing tunnel.
*/
DELETE,
/**
* Specifies the request type for PCC to report existing tunnel.
*/
LSP_STATE_RPT;
}
\ No newline at end of file
/*
* Copyright 2015 Open Networking Laboratory
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.onosproject.provider.pcep.tunnel.impl;
import static org.slf4j.LoggerFactory.getLogger;
import java.util.concurrent.atomic.AtomicInteger;
import org.slf4j.Logger;
/**
* Unique Srp Id generator for pcep messages.
*/
public final class SrpIdGenerators {
private static final Logger log = getLogger(SrpIdGenerators.class);
private static final AtomicInteger SRP_ID_GEN = new AtomicInteger();
private static final int MAX_SRP_ID = 0x7FFFFFFF;
private static int srpId;
/**
* Default constructor.
*/
private SrpIdGenerators() {
}
/**
* Get the next srp id.
*
* @return srp id
*/
public static int create() {
do {
if (srpId >= MAX_SRP_ID) {
if (SRP_ID_GEN.get() >= MAX_SRP_ID) {
SRP_ID_GEN.set(0);
}
}
srpId = SRP_ID_GEN.incrementAndGet();
} while (srpId > MAX_SRP_ID);
return srpId;
}
}