From e63291850fd0795c5700e25e67e5dee89ba54c5f Mon Sep 17 00:00:00 2001 From: Ashlee Young Date: Tue, 1 Dec 2015 05:49:27 -0800 Subject: onos commit hash c2999f30c69e50df905a9d175ef80b3f23a98514 Change-Id: I2bb8562c4942b6d6a6d60b663db2e17540477b81 Signed-off-by: Ashlee Young --- .../pcepio/protocol/ver1/PcepLspaObjectVer1.java | 529 +++++++++++++++++++++ 1 file changed, 529 insertions(+) create mode 100644 framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepLspaObjectVer1.java (limited to 'framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepLspaObjectVer1.java') diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepLspaObjectVer1.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepLspaObjectVer1.java new file mode 100644 index 00000000..f4000509 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepLspaObjectVer1.java @@ -0,0 +1,529 @@ +/* + * 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.pcepio.protocol.ver1; + +import java.util.LinkedList; +import java.util.ListIterator; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.pcepio.exceptions.PcepParseException; +import org.onosproject.pcepio.protocol.PcepLspaObject; +import org.onosproject.pcepio.types.PcepObjectHeader; +import org.onosproject.pcepio.types.PcepValueType; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.google.common.base.MoreObjects; + +/** + * Provides PCEP label Object . + */ +public class PcepLspaObjectVer1 implements PcepLspaObject { + + /* LSPA Object Body Format + + 0 1 2 3 + 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Exclude-any | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Include-any | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Include-all | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Setup Prio | Holding Prio | Flags |L| Reserved | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | | + | Optional TLVs | + | | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + */ + + protected static final Logger log = LoggerFactory.getLogger(PcepLspaObjectVer1.class); + + public static final byte LSPA_OBJ_TYPE = 1; + public static final byte LSPA_OBJ_CLASS = 9; + public static final byte LSPA_OBJECT_VERSION = 1; + public static final short LSPA_OBJ_MINIMUM_LENGTH = 20; + public static final int OBJECT_HEADER_LENGTH = 4; + + static final PcepObjectHeader DEFAULT_LSPA_OBJECT_HEADER = new PcepObjectHeader(LSPA_OBJ_CLASS, LSPA_OBJ_TYPE, + PcepObjectHeader.REQ_OBJ_OPTIONAL_PROCESS, PcepObjectHeader.RSP_OBJ_PROCESSED, LSPA_OBJ_MINIMUM_LENGTH); + + public static final int SETUP_PRIORITY_SHIFT_VALUE = 24; + public static final int HOLD_PRIORITY_SHIFT_VALUE = 16; + public static final int BFLAG_SHIFT_VALUE = 8; + public static final int LFLAG_SET = 1; + public static final int LFLAG_RESET = 0; + private PcepObjectHeader lspaObjHeader; + private int iExcludeAny; + private int iIncludeAny; + private int iIncludeAll; + private byte cSetupPriority; + private byte cHoldPriority; + private boolean bLFlag; + private LinkedList llOptionalTlv; //Optional TLV + + /** + * Constructor to initialize member variables. + * + * @param lspaObjHeader lspa object header + * @param bLFlag b l flag + * @param iExcludeAny excludeAny value + * @param iIncludeAny includeAny value + * @param iIncludeAll includeAll value + * @param cSetupPriority setup priority value + * @param cHoldPriority hold priority value + * @param llOptionalTlv list of optional tlv + */ + public PcepLspaObjectVer1(PcepObjectHeader lspaObjHeader, boolean bLFlag, int iExcludeAny, int iIncludeAny, + int iIncludeAll, byte cSetupPriority, byte cHoldPriority, LinkedList llOptionalTlv) { + + this.lspaObjHeader = lspaObjHeader; + this.bLFlag = bLFlag; + this.iExcludeAny = iExcludeAny; + this.iIncludeAny = iIncludeAny; + this.iIncludeAll = iIncludeAll; + this.cSetupPriority = cSetupPriority; + this.cHoldPriority = cHoldPriority; + this.llOptionalTlv = llOptionalTlv; + } + + /** + * Sets Object Header. + * + * @param obj lspa object header + */ + public void setLspaObjHeader(PcepObjectHeader obj) { + this.lspaObjHeader = obj; + } + + @Override + public void setExcludeAny(int iExcludeAny) { + this.iExcludeAny = iExcludeAny; + } + + @Override + public void setIncludeAny(int iIncludeAny) { + this.iIncludeAny = iIncludeAny; + } + + @Override + public void setSetupPriority(byte cSetupPriority) { + this.cSetupPriority = cSetupPriority; + } + + @Override + public void setHoldPriority(byte cHoldPriority) { + this.cHoldPriority = cHoldPriority; + } + + @Override + public void setLFlag(boolean bLFlag) { + this.bLFlag = bLFlag; + } + + /** + * Returns lspa Object Header. + * + * @return lspa Object Header + */ + public PcepObjectHeader getLspaObjHeader() { + return this.lspaObjHeader; + } + + @Override + public int getExcludeAny() { + return this.iExcludeAny; + } + + @Override + public int getIncludeAny() { + return this.iIncludeAny; + } + + @Override + public int getIncludeAll() { + return this.iIncludeAll; + } + + @Override + public byte getSetupPriority() { + return this.cSetupPriority; + } + + @Override + public byte getHoldPriority() { + return this.cHoldPriority; + } + + @Override + public boolean getLFlag() { + return this.bLFlag; + } + + @Override + public void setIncludeAll(int value) { + this.iIncludeAll = value; + + } + + @Override + public LinkedList getOptionalTlv() { + return this.llOptionalTlv; + } + + @Override + public void setOptionalTlv(LinkedList llOptionalTlv) { + this.llOptionalTlv = llOptionalTlv; + + } + + /** + * Reads channel buffer and returns object of PcepLspaObject. + * + * @param cb of type channel buffer. + * @return object of PcepLspaObject + * @throws PcepParseException while parsing lspa object from channel buffer + */ + public static PcepLspaObject read(ChannelBuffer cb) throws PcepParseException { + + log.debug("LspaObject::read"); + PcepObjectHeader lspaObjHeader; + int iExcludeAny; + int iIncludeAny; + int iIncludeAll; + byte cSetupPriority; + byte cHoldPriority; + boolean bLFlag; + byte flags; + + // Optional TLV + LinkedList llOptionalTlv; + + lspaObjHeader = PcepObjectHeader.read(cb); + + //take only Lspa Object buffer. + ChannelBuffer tempCb = cb.readBytes(lspaObjHeader.getObjLen() - OBJECT_HEADER_LENGTH); + iExcludeAny = tempCb.readInt(); + iIncludeAny = tempCb.readInt(); + iIncludeAll = tempCb.readInt(); + cSetupPriority = tempCb.readByte(); + cHoldPriority = tempCb.readByte(); + flags = tempCb.readByte(); + tempCb.readByte(); + + bLFlag = (flags & (byte) LFLAG_SET) == LFLAG_SET; + + llOptionalTlv = parseOptionalTlv(tempCb); + + return new PcepLspaObjectVer1(lspaObjHeader, bLFlag, iExcludeAny, iIncludeAny, iIncludeAll, cSetupPriority, + cHoldPriority, llOptionalTlv); + } + + @Override + public int write(ChannelBuffer cb) throws PcepParseException { + + //write Object header + int objStartIndex = cb.writerIndex(); + + int objLenIndex = lspaObjHeader.write(cb); + + if (objLenIndex <= 0) { + throw new PcepParseException("Failed to write lspa object header. Index " + objLenIndex); + } + + cb.writeInt(iExcludeAny); + cb.writeInt(iIncludeAny); + cb.writeInt(iIncludeAll); + + int iTemp = cSetupPriority << SETUP_PRIORITY_SHIFT_VALUE; + iTemp = iTemp | (cHoldPriority << HOLD_PRIORITY_SHIFT_VALUE); + byte bFlag; + bFlag = (bLFlag) ? (byte) LFLAG_SET : LFLAG_RESET; + iTemp = iTemp | (bFlag << BFLAG_SHIFT_VALUE); + cb.writeInt(iTemp); + + // Add optional TLV + if (!packOptionalTlv(cb)) { + throw new PcepParseException("Faild to write lspa objects tlv to channel buffer"); + } + + short length = (short) (cb.writerIndex() - objStartIndex); + + lspaObjHeader.setObjLen(length); //will be helpful during print(). + + //As per RFC the length of object should be multiples of 4 + short pad = (short) (length % 4); + + if (pad != 0) { + pad = (short) (4 - pad); + for (int i = 0; i < pad; i++) { + cb.writeByte((byte) 0); + } + length = (short) (length + pad); + } + cb.setShort(objLenIndex, length); + return cb.writerIndex(); + } + + /** + * Parse list of optional tlvs. + * + * @param cb channel buffer + * @return list of optional tlvs. + * @throws PcepParseException when fails to parse optional tlv list. + */ + public static LinkedList parseOptionalTlv(ChannelBuffer cb) throws PcepParseException { + + LinkedList llOutOptionalTlv = new LinkedList<>(); + + return llOutOptionalTlv; + } + + /** + * Writes optional tlvs to channel buffer. + * + * @param cb channel buffer + * @return true + */ + protected boolean packOptionalTlv(ChannelBuffer cb) { + int hTlvType; + int hTlvLength; + + ListIterator listIterator = llOptionalTlv.listIterator(); + while (listIterator.hasNext()) { + PcepValueType tlv = listIterator.next(); + if (tlv == null) { + log.debug("Warning: tlv is null from OptionalTlv list"); + continue; + } + hTlvType = tlv.getType(); + hTlvLength = tlv.getLength(); + if (0 == hTlvLength) { + log.debug("Warning: invalid length in tlv of OptionalTlv list"); + continue; + } + + cb.writeShort(hTlvType); + cb.writeShort(hTlvLength); + + switch (hTlvType) { + //TODO: optional TLV for LSPA to be added + + default: + log.debug("Warning: PcepLspaObject: unknown tlv"); + } + + // As per RFC the length of object should + // be multiples of 4 + int pad = hTlvLength % 4; + + if (0 < pad) { + pad = 4 - pad; + if (pad <= cb.readableBytes()) { + cb.skipBytes(pad); + } + } + } + return true; + } + + /** + * Builder class for PCEP lspa object. + */ + public static class Builder implements PcepLspaObject.Builder { + private boolean bIsHeaderSet = false; + + private PcepObjectHeader lspaObjHeader; + + private boolean bLFlag; + private int iExcludeAny; + private boolean bIsExcludeAnySet = false; + private int iIncludeAny; + private boolean bIsIncludeAnySet = false; + private int iIncludeAll; + private boolean bIsIncludeAllSet = false; + private byte cSetupPriority; + private boolean bIsSetupPrioritySet = false; + private byte cHoldPriority; + private boolean bIsHoldPrioritySet = false; + private LinkedList llOptionalTlv; + + private boolean bIsPFlagSet = false; + private boolean bPFlag; + + private boolean bIsIFlagSet = false; + private boolean bIFlag; + + @Override + public PcepLspaObject build() throws PcepParseException { + + PcepObjectHeader lspaObjHeader = this.bIsHeaderSet ? this.lspaObjHeader : DEFAULT_LSPA_OBJECT_HEADER; + + if (!this.bIsExcludeAnySet) { + throw new PcepParseException("ExcludeAny NOT Set while building PcepLspaObject."); + } + if (!this.bIsIncludeAnySet) { + throw new PcepParseException("IncludeAny NOT Set while building PcepLspaObject."); + } + if (!this.bIsIncludeAllSet) { + throw new PcepParseException("IncludeAll NOT Set while building PcepLspaObject."); + } + if (!this.bIsSetupPrioritySet) { + throw new PcepParseException("Setup Priority NOT Set while building PcepLspaObject."); + } + if (!this.bIsHoldPrioritySet) { + throw new PcepParseException("Hold Priority NOT Set while building PcepLspaObject."); + } + + if (bIsPFlagSet) { + lspaObjHeader.setPFlag(bPFlag); + } + + if (bIsIFlagSet) { + lspaObjHeader.setIFlag(bIFlag); + } + + return new PcepLspaObjectVer1(lspaObjHeader, bLFlag, iExcludeAny, iIncludeAny, iIncludeAll, cSetupPriority, + cHoldPriority, llOptionalTlv); + } + + @Override + public PcepObjectHeader getLspaObjHeader() { + return this.lspaObjHeader; + } + + @Override + public Builder setLspaObjHeader(PcepObjectHeader obj) { + this.lspaObjHeader = obj; + this.bIsHeaderSet = true; + return this; + } + + @Override + public boolean getLFlag() { + return this.bLFlag; + } + + @Override + public Builder setLFlag(boolean value) { + this.bLFlag = value; + return this; + } + + @Override + public int getExcludeAny() { + return this.iExcludeAny; + } + + @Override + public Builder setExcludeAny(int value) { + this.iExcludeAny = value; + this.bIsExcludeAnySet = true; + return this; + } + + @Override + public int getIncludeAny() { + return this.iIncludeAny; + } + + @Override + public Builder setIncludeAny(int value) { + this.iIncludeAny = value; + this.bIsIncludeAnySet = true; + return this; + } + + @Override + public int getIncludeAll() { + return this.iIncludeAll; + } + + @Override + public Builder setIncludeAll(int value) { + this.iIncludeAll = value; + this.bIsIncludeAllSet = true; + return this; + } + + @Override + public byte getSetupPriority() { + return this.cSetupPriority; + } + + @Override + public Builder setSetupPriority(byte value) { + this.cSetupPriority = value; + this.bIsSetupPrioritySet = true; + return this; + } + + @Override + public byte getHoldPriority() { + return this.cHoldPriority; + } + + @Override + public Builder setHoldPriority(byte value) { + this.cHoldPriority = value; + this.bIsHoldPrioritySet = true; + return this; + } + + @Override + public LinkedList getOptionalTlv() { + return this.llOptionalTlv; + } + + @Override + public Builder setOptionalTlv(LinkedList llOptionalTlv) { + this.llOptionalTlv = llOptionalTlv; + + return this; + } + + @Override + public Builder setPFlag(boolean value) { + this.bPFlag = value; + this.bIsPFlagSet = true; + return this; + } + + @Override + public Builder setIFlag(boolean value) { + this.bIFlag = value; + this.bIsIFlagSet = true; + return this; + } + + } + + @Override + public String toString() { + return MoreObjects.toStringHelper(getClass()) + .add("LFlag", bLFlag) + .add("SetupPriority", cSetupPriority) + .add("HoldPriority", cHoldPriority) + .add("IncludeAll", iIncludeAll) + .add("IncludeAny", iIncludeAny) + .add("ExcludeAny", iExcludeAny) + .add("OptionalTlvList", llOptionalTlv) + .toString(); + } +} -- cgit 1.2.3-korg