diff options
Diffstat (limited to 'framework/src/onos/protocols/pcep')
262 files changed, 47056 insertions, 0 deletions
diff --git a/framework/src/onos/protocols/pcep/api/pom.xml b/framework/src/onos/protocols/pcep/api/pom.xml new file mode 100644 index 00000000..4588ad6f --- /dev/null +++ b/framework/src/onos/protocols/pcep/api/pom.xml @@ -0,0 +1,99 @@ +<?xml version="1.0" encoding="UTF-8"?> +<!-- + ~ Copyright 2014 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. + --> +<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/maven-v4_0_0.xsd"> + <modelVersion>4.0.0</modelVersion> + + <parent> + <groupId>org.onosproject</groupId> + <artifactId>onos-pcep-controller</artifactId> + <version>1.4.0-SNAPSHOT</version> + <relativePath>../pom.xml</relativePath> + </parent> + + <artifactId>onos-pcep-controller-api</artifactId> + <packaging>bundle</packaging> + + <description>ONOS Pcep client controller subsystem API</description> + + <dependencies> + <dependency> + <groupId>org.onosproject</groupId> + <artifactId>onos-app-pcep-api</artifactId> + </dependency> + <dependency> + <groupId>org.onosproject</groupId> + <artifactId>onos-pcepio</artifactId> + </dependency> + <dependency> + <groupId>io.netty</groupId> + <artifactId>netty</artifactId> + </dependency> + <dependency> + <groupId>org.onosproject</groupId> + <artifactId>onos-api</artifactId> + </dependency> + <dependency> + <groupId>org.onosproject</groupId> + <artifactId>onlab-misc</artifactId> + </dependency> + + </dependencies> + + <build> + <plugins> + <plugin> + <groupId>org.apache.maven.plugins</groupId> + <artifactId>maven-shade-plugin</artifactId> + <version>2.3</version> + <configuration> + <artifactSet> + <excludes> + <exclude>io.netty:netty</exclude> + <exclude>com.google.guava:guava</exclude> + <exclude>org.slf4j:slfj-api</exclude> + <exclude>ch.qos.logback:logback-core</exclude> + <exclude>ch.qos.logback:logback-classic</exclude> + <exclude>com.google.code.findbugs:annotations</exclude> + </excludes> + </artifactSet> + </configuration> + <executions> + <execution> + <phase>package</phase> + <goals> + <goal>shade</goal> + </goals> + </execution> + </executions> + </plugin> + <plugin> + <groupId>org.apache.felix</groupId> + <artifactId>maven-bundle-plugin</artifactId> + <configuration> + <instructions> + <Export-Package> + org.onosproject.pcep.*,org.onosproject.pcepio.* + </Export-Package> + </instructions> + </configuration> + </plugin> + </plugins> + </build> + +</project> diff --git a/framework/src/onos/protocols/pcep/api/src/main/java/org/onosproject/pcep/controller/PccId.java b/framework/src/onos/protocols/pcep/api/src/main/java/org/onosproject/pcep/controller/PccId.java new file mode 100755 index 00000000..3ff622bf --- /dev/null +++ b/framework/src/onos/protocols/pcep/api/src/main/java/org/onosproject/pcep/controller/PccId.java @@ -0,0 +1,120 @@ +/* + * 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.pcep.controller; + +import static com.google.common.base.Preconditions.checkArgument; +import java.net.URI; +import java.net.URISyntaxException; +import java.util.Objects; + +import org.onlab.packet.IpAddress; + +/** + * The class representing a network client pc ip. + * This class is immutable. + */ +public final class PccId { + + private static final String SCHEME = "pcep"; + private static final long UNKNOWN = 0; + private final IpAddress ipAddress; + + /** + * Private constructor. + */ + private PccId(IpAddress ipAddress) { + this.ipAddress = ipAddress; + } + + /** + * Create a PccId from ip address. + * + * @param ipAddress IP address + * @return ipAddress + */ + public static PccId pccId(IpAddress ipAddress) { + return new PccId(ipAddress); + } + + /** + * Returns the ip address. + * + * @return ipAddress + */ + public IpAddress ipAddress() { + return ipAddress; + } + + /** + * Convert the PccId value to a ':' separated hexadecimal string. + * + * @return the PccId value as a ':' separated hexadecimal string. + */ + @Override + public String toString() { + return ipAddress.toString(); + } + + @Override + public boolean equals(Object other) { + if (!(other instanceof PccId)) { + return false; + } + + PccId otherPccid = (PccId) other; + return Objects.equals(ipAddress, otherPccid.ipAddress); + } + + @Override + public int hashCode() { + return Objects.hash(ipAddress); + } + + /** + * Returns PccId created from the given client URI. + * + * @param uri device URI + * @return pccid + */ + public static PccId pccid(URI uri) { + checkArgument(uri.getScheme().equals(SCHEME), "Unsupported URI scheme"); + return new PccId(IpAddress.valueOf(uri.getSchemeSpecificPart())); + } + + /** + * Produces client URI from the given DPID. + * + * @param pccid client pccid + * @return client URI + */ + public static URI uri(PccId pccid) { + return uri(pccid.ipAddress()); + } + + /** + * Produces client URI from the given ip address. + * + * @param ipAddress ip of client + * @return client URI + */ + public static URI uri(IpAddress ipAddress) { + try { + return new URI(SCHEME, ipAddress.toString(), null); + } catch (URISyntaxException e) { + return null; + } + } +} diff --git a/framework/src/onos/protocols/pcep/api/src/main/java/org/onosproject/pcep/controller/PcepClient.java b/framework/src/onos/protocols/pcep/api/src/main/java/org/onosproject/pcep/controller/PcepClient.java new file mode 100755 index 00000000..95e7789f --- /dev/null +++ b/framework/src/onos/protocols/pcep/api/src/main/java/org/onosproject/pcep/controller/PcepClient.java @@ -0,0 +1,110 @@ +/* + * 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.pcep.controller; + +import java.util.List; + +import org.onosproject.pcepio.protocol.PcepFactory; +import org.onosproject.pcepio.protocol.PcepMessage; + +/** + * Represents to provider facing side of a path computation client(pcc). + */ +public interface PcepClient { + + /** + * Writes the message to the driver. + * + * @param msg the message to write + */ + void sendMessage(PcepMessage msg); + + /** + * Writes the PcepMessage list to the driver. + * + * @param msgs the messages to be written + */ + void sendMessage(List<PcepMessage> msgs); + + /** + * Handle a message from the pcc. + * + * @param fromClient the message to handle + */ + void handleMessage(PcepMessage fromClient); + + /** + * Provides the factory for this PCEP version. + * + * @return PCEP version specific factory. + */ + PcepFactory factory(); + + /** + * Gets a string version of the ID for this pcc. + * + * @return string version of the ID + */ + String getStringId(); + + /** + * Gets the ipAddress of the client. + * + * @return the client pccId in IPAddress format + */ + PccId getPccId(); + + /** + * Checks if the pcc is still connected. + * + * @return true if client is connected, false otherwise + */ + boolean isConnected(); + + /** + * Disconnects the pcc by closing the TCP connection. Results in a call + * to the channel handler's channelDisconnected method for cleanup. + */ + void disconnectClient(); + + /** + * Indicates if this pcc is optical. + * + * @return true if optical + */ + boolean isOptical(); + + /** + * Identifies the channel used to communicate with the pcc. + * + * @return string representation of the connection to the client + */ + String channelId(); + + /** + * To set the status of state synchronization. + * + * @param value to set the synchronization status + */ + void setIsSyncComplete(boolean value); + + /** + * Indicates the state synchronization status of this pcc. + * + * @return true/false if the synchronization is completed/not completed + */ + boolean isSyncComplete(); +} diff --git a/framework/src/onos/protocols/pcep/api/src/main/java/org/onosproject/pcep/controller/PcepClientController.java b/framework/src/onos/protocols/pcep/api/src/main/java/org/onosproject/pcep/controller/PcepClientController.java new file mode 100644 index 00000000..37453eac --- /dev/null +++ b/framework/src/onos/protocols/pcep/api/src/main/java/org/onosproject/pcep/controller/PcepClientController.java @@ -0,0 +1,93 @@ +/* + * 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.pcep.controller; + +import java.util.Collection; + +import org.onosproject.pcepio.protocol.PcepMessage; + +/** + * Abstraction of an Pcep client controller. Serves as a one stop + * shop for obtaining Pcep devices and (un)register listeners + * on pcep events + */ +public interface PcepClientController { + + /** + * Returns list of pcc clients connected to this Pcep controller. + * + * @return list of PcepClient elements + */ + Collection<PcepClient> getClients(); + + /** + * Returns the actual pcc client for the given ip address. + * + * @param pccId the id of the pcc client to fetch + * @return the interface to this pcc client + */ + PcepClient getClient(PccId pccId); + + /** + * Register a listener for meta events that occur to pcep + * devices. + * + * @param listener the listener to notify + */ + void addListener(PcepClientListener listener); + + /** + * Unregister a listener. + * + * @param listener the listener to unregister + */ + void removeListener(PcepClientListener listener); + + /** + * Register a listener for OF msg events. + * + * @param listener the listener to notify + */ + void addEventListener(PcepEventListener listener); + + /** + * Unregister a listener. + * + * @param listener the listener to unregister + */ + void removeEventListener(PcepEventListener listener); + + /** + * Send a message to a particular pcc client. + * + * @param pccId the id of the client to send message. + * @param msg the message to send + */ + void writeMessage(PccId pccId, PcepMessage msg); + + /** + * Process a message and notify the appropriate listeners. + * + * @param pccId id of the client the message arrived on + * @param msg the message to process. + */ + void processClientMessage(PccId pccId, PcepMessage msg); + + /** + * Close all connected PCC clients. + */ + void closeConnectedClients(); +} diff --git a/framework/src/onos/protocols/pcep/api/src/main/java/org/onosproject/pcep/controller/PcepClientListener.java b/framework/src/onos/protocols/pcep/api/src/main/java/org/onosproject/pcep/controller/PcepClientListener.java new file mode 100755 index 00000000..e7e0a736 --- /dev/null +++ b/framework/src/onos/protocols/pcep/api/src/main/java/org/onosproject/pcep/controller/PcepClientListener.java @@ -0,0 +1,36 @@ +/* + * 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.pcep.controller; + +/** + * Allows for providers interested in PCC client events to be notified. + */ +public interface PcepClientListener { + + /** + * Notify that the PCC was connected. + * + * @param pccId the id of the client that connected + */ + void clientConnected(PccId pccId); + + /** + * Notify that the PCC was disconnected. + * + * @param pccId the id of the client that disconnected. + */ + void clientDisconnected(PccId pccId); +} diff --git a/framework/src/onos/protocols/pcep/api/src/main/java/org/onosproject/pcep/controller/PcepEventListener.java b/framework/src/onos/protocols/pcep/api/src/main/java/org/onosproject/pcep/controller/PcepEventListener.java new file mode 100644 index 00000000..f7de215a --- /dev/null +++ b/framework/src/onos/protocols/pcep/api/src/main/java/org/onosproject/pcep/controller/PcepEventListener.java @@ -0,0 +1,31 @@ +/* + * 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.pcep.controller; + +import org.onosproject.pcepio.protocol.PcepMessage; +/** + * Notifies providers about PCEP message events. + */ +public interface PcepEventListener { + + /** + * Handles the message event. + * + * @param pccId id of the pcc + * @param msg the message + */ + void handleMessage(PccId pccId, PcepMessage msg); +} diff --git a/framework/src/onos/protocols/pcep/api/src/main/java/org/onosproject/pcep/controller/PcepPacketStats.java b/framework/src/onos/protocols/pcep/api/src/main/java/org/onosproject/pcep/controller/PcepPacketStats.java new file mode 100644 index 00000000..d00cd5a8 --- /dev/null +++ b/framework/src/onos/protocols/pcep/api/src/main/java/org/onosproject/pcep/controller/PcepPacketStats.java @@ -0,0 +1,50 @@ +/* + * 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.pcep.controller; + +/** + * The representation for PCEP packet statistics. + */ +public interface PcepPacketStats { + + /** + * Returns the count for no of packets sent out. + * + * @return int value of no of packets sent + */ + int outPacketCount(); + + /** + * Returns the count for no of packets received. + * + * @return int value of no of packets sent + */ + int inPacketCount(); + + /** + * Returns the count for no of wrong packets received. + * + * @return int value of no of wrong packets received + */ + int wrongPacketCount(); + + /** + * Returns the time value. + * + * @return long value of time + */ + long getTime(); +} diff --git a/framework/src/onos/protocols/pcep/api/src/main/java/org/onosproject/pcep/controller/driver/PcepAgent.java b/framework/src/onos/protocols/pcep/api/src/main/java/org/onosproject/pcep/controller/driver/PcepAgent.java new file mode 100755 index 00000000..4810417c --- /dev/null +++ b/framework/src/onos/protocols/pcep/api/src/main/java/org/onosproject/pcep/controller/driver/PcepAgent.java @@ -0,0 +1,63 @@ +/* + * 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.pcep.controller.driver; + +import org.onosproject.pcep.controller.PccId; +import org.onosproject.pcep.controller.PcepClient; +import org.onosproject.pcepio.protocol.PcepMessage; + +/** + * Responsible for keeping track of the current set Pcep clients + * connected to the system. + * + */ +public interface PcepAgent { + + /** + * Add a pcc client that has just connected to the system. + * + * @param pccId the id of pcc client to add + * @param pc the actual pce client object. + * @return true if added, false otherwise. + */ + boolean addConnectedClient(PccId pccId, PcepClient pc); + + /** + * Checks if the activation for this pcc client is valid. + * + * @param pccId the id of pcc client to check + * @return true if valid, false otherwise + */ + boolean validActivation(PccId pccId); + + /** + * Clear all state in controller client maps for a pcc client that has + * disconnected from the local controller. Also release control for + * that pccIds client from the global repository. Notify client listeners. + * + * @param pccIds the id of pcc client to remove. + */ + void removeConnectedClient(PccId pccIds); + + /** + * Process a message coming from a pcc client. + * + * @param pccId the id of pcc client the message was received. + * @param m the message to process + */ + void processPcepMessage(PccId pccId, PcepMessage m); + +} diff --git a/framework/src/onos/protocols/pcep/api/src/main/java/org/onosproject/pcep/controller/driver/PcepClientDriver.java b/framework/src/onos/protocols/pcep/api/src/main/java/org/onosproject/pcep/controller/driver/PcepClientDriver.java new file mode 100755 index 00000000..f728de54 --- /dev/null +++ b/framework/src/onos/protocols/pcep/api/src/main/java/org/onosproject/pcep/controller/driver/PcepClientDriver.java @@ -0,0 +1,110 @@ +/* + * 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.pcep.controller.driver; + +import org.jboss.netty.channel.Channel; +import org.onosproject.pcep.controller.PccId; +import org.onosproject.pcep.controller.PcepClient; +import org.onosproject.pcep.controller.PcepPacketStats; +import org.onosproject.pcepio.protocol.PcepVersion; + + +/** + * Represents the driver side of an Path computation client(pcc). + * + */ +public interface PcepClientDriver extends PcepClient { + + /** + * Sets the Pcep agent to be used. This method + * can only be called once. + * + * @param agent the agent to set. + */ + void setAgent(PcepAgent agent); + + /** + * Announce to the Pcep agent that this pcc client has connected. + * + * @return true if successful, false if duplicate switch. + */ + boolean connectClient(); + + /** + * Remove this pcc client from the Pcep agent. + */ + void removeConnectedClient(); + + /** + * Sets the PCEP version for this pcc. + * + * @param pcepVersion the version to set. + */ + void setPcVersion(PcepVersion pcepVersion); + + /** + * Sets the associated Netty channel for this pcc. + * + * @param channel the Netty channel + */ + void setChannel(Channel channel); + + + /** + * Sets the keep alive time for this pcc. + * + * @param keepAliveTime the keep alive time to set. + */ + void setPcKeepAliveTime(byte keepAliveTime); + + /** + * Sets the dead time for this pcc. + * + * @param deadTime the dead timer value to set. + */ + void setPcDeadTime(byte deadTime); + + /** + * Sets the session id for this pcc. + * + * @param sessionId the session id value to set. + */ + void setPcSessionId(byte sessionId); + + /** + * Sets whether the pcc is connected. + * + * @param connected whether the pcc is connected + */ + void setConnected(boolean connected); + + /** + * Initializes the behavior. + * + * @param pccId id of pcc + * @param pcepVersion Pcep version + * @param pktStats Pcep Packet Stats + */ + void init(PccId pccId, PcepVersion pcepVersion, PcepPacketStats pktStats); + + /** + * Checks whether the handshake is complete. + * + * @return true is finished, false if not. + */ + boolean isHandshakeComplete(); + +} diff --git a/framework/src/onos/protocols/pcep/api/src/main/java/org/onosproject/pcep/controller/driver/PcepClientDriverFactory.java b/framework/src/onos/protocols/pcep/api/src/main/java/org/onosproject/pcep/controller/driver/PcepClientDriverFactory.java new file mode 100755 index 00000000..6ce75bca --- /dev/null +++ b/framework/src/onos/protocols/pcep/api/src/main/java/org/onosproject/pcep/controller/driver/PcepClientDriverFactory.java @@ -0,0 +1,38 @@ +/* + * 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.pcep.controller.driver; + +import org.onlab.packet.IpAddress; +import org.onosproject.pcepio.protocol.PcepVersion; + +/** + * Pcc Client factory which returns concrete pcc client objects for the + * physical pcc client in use. + * + */ +public interface PcepClientDriverFactory { + + + /** + * Constructs the real Pcep Client representation. + * + * @param pccIpAddress the ip address for this pcc client. + * @param pcepVersion the Pcep version in use + * @return the Pcep client representation. + */ + PcepClientDriver getPcepClientImpl(IpAddress pccIpAddress, + PcepVersion pcepVersion); +} diff --git a/framework/src/onos/protocols/pcep/api/src/main/java/org/onosproject/pcep/controller/driver/package-info.java b/framework/src/onos/protocols/pcep/api/src/main/java/org/onosproject/pcep/controller/driver/package-info.java new file mode 100644 index 00000000..9d105ff2 --- /dev/null +++ b/framework/src/onos/protocols/pcep/api/src/main/java/org/onosproject/pcep/controller/driver/package-info.java @@ -0,0 +1,20 @@ +/* + * 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. + */ + +/** + * PCEP client controller driver API. + */ +package org.onosproject.pcep.controller.driver; diff --git a/framework/src/onos/protocols/pcep/api/src/main/java/org/onosproject/pcep/controller/package-info.java b/framework/src/onos/protocols/pcep/api/src/main/java/org/onosproject/pcep/controller/package-info.java new file mode 100644 index 00000000..a0cb2482 --- /dev/null +++ b/framework/src/onos/protocols/pcep/api/src/main/java/org/onosproject/pcep/controller/package-info.java @@ -0,0 +1,20 @@ +/* + * 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. + */ + +/** + * PCEP client controller API. + */ +package org.onosproject.pcep.controller; diff --git a/framework/src/onos/protocols/pcep/ctl/pom.xml b/framework/src/onos/protocols/pcep/ctl/pom.xml new file mode 100644 index 00000000..f0ed5c2f --- /dev/null +++ b/framework/src/onos/protocols/pcep/ctl/pom.xml @@ -0,0 +1,65 @@ +<!-- + ~ Copyright 2014 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. + --> +<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/maven-v4_0_0.xsd"> + <modelVersion>4.0.0</modelVersion> + + <parent> + <groupId>org.onosproject</groupId> + <artifactId>onos-pcep-controller</artifactId> + <version>1.4.0-SNAPSHOT</version> + <relativePath>../pom.xml</relativePath> + </parent> + + <artifactId>onos-pcep-controller-impl</artifactId> + <packaging>bundle</packaging> + + <description>ONOS PCEP client controller subsystem API implementation</description> + + <dependencies> + <dependency> + <groupId>org.onosproject</groupId> + <artifactId>onos-pcep-controller-api</artifactId> + </dependency> + <dependency> + <groupId>io.netty</groupId> + <artifactId>netty</artifactId> + </dependency> + <dependency> + <groupId>org.apache.felix</groupId> + <artifactId>org.apache.felix.scr.annotations</artifactId> + </dependency> + <dependency> + <groupId>org.osgi</groupId> + <artifactId>org.osgi.compendium</artifactId> + </dependency> + <dependency> + <groupId>org.onosproject</groupId> + <artifactId>onlab-misc</artifactId> + </dependency> + </dependencies> + + <build> + <plugins> + <plugin> + <groupId>org.apache.felix</groupId> + <artifactId>maven-scr-plugin</artifactId> + </plugin> + </plugins> + </build> + +</project> diff --git a/framework/src/onos/protocols/pcep/ctl/src/main/java/org/onosproject/pcep/controller/impl/Controller.java b/framework/src/onos/protocols/pcep/ctl/src/main/java/org/onosproject/pcep/controller/impl/Controller.java new file mode 100644 index 00000000..9c27810c --- /dev/null +++ b/framework/src/onos/protocols/pcep/ctl/src/main/java/org/onosproject/pcep/controller/impl/Controller.java @@ -0,0 +1,188 @@ +/* + * 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.pcep.controller.impl; + +import static org.onlab.util.Tools.groupedThreads; + +import java.lang.management.ManagementFactory; +import java.lang.management.RuntimeMXBean; +import java.net.InetSocketAddress; +import java.util.HashMap; +import java.util.Map; +import java.util.concurrent.Executors; + +import org.jboss.netty.bootstrap.ServerBootstrap; +import org.jboss.netty.channel.ChannelPipelineFactory; +import org.jboss.netty.channel.group.ChannelGroup; +import org.jboss.netty.channel.group.DefaultChannelGroup; +import org.jboss.netty.channel.socket.nio.NioServerSocketChannelFactory; +import org.onosproject.pcep.controller.PccId; +import org.onosproject.pcep.controller.PcepPacketStats; +import org.onosproject.pcep.controller.driver.PcepAgent; +import org.onosproject.pcep.controller.driver.PcepClientDriver; +import org.onosproject.pcepio.protocol.PcepFactories; +import org.onosproject.pcepio.protocol.PcepFactory; +import org.onosproject.pcepio.protocol.PcepVersion; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +/** + * The main controller class. Handles all setup and network listeners - + * Distributed ownership control of pcc through IControllerRegistryService + */ +public class Controller { + + private static final Logger log = LoggerFactory.getLogger(Controller.class); + + private static final PcepFactory FACTORY1 = PcepFactories.getFactory(PcepVersion.PCEP_1); + + private ChannelGroup cg; + + // Configuration options + private int pcepPort = 4189; + private int workerThreads = 10; + + // Start time of the controller + private long systemStartTime; + + private PcepAgent agent; + + private NioServerSocketChannelFactory execFactory; + + // Perf. related configuration + private static final int SEND_BUFFER_SIZE = 4 * 1024 * 1024; + + /** + * Returns factory version for processing pcep messages. + * + * @return instance of factory version + */ + public PcepFactory getPcepMessageFactory1() { + return FACTORY1; + } + + /** + * To get system start time. + * + * @return system start time in milliseconds + */ + public long getSystemStartTime() { + return (this.systemStartTime); + } + + /** + * Tell controller that we're ready to accept pcc connections. + */ + public void run() { + try { + final ServerBootstrap bootstrap = createServerBootStrap(); + + bootstrap.setOption("reuseAddr", true); + bootstrap.setOption("child.keepAlive", true); + bootstrap.setOption("child.tcpNoDelay", true); + bootstrap.setOption("child.sendBufferSize", Controller.SEND_BUFFER_SIZE); + + ChannelPipelineFactory pfact = new PcepPipelineFactory(this); + + bootstrap.setPipelineFactory(pfact); + InetSocketAddress sa = new InetSocketAddress(pcepPort); + cg = new DefaultChannelGroup(); + cg.add(bootstrap.bind(sa)); + log.info("Listening for PCC connection on {}", sa); + } catch (Exception e) { + throw new RuntimeException(e); + } + } + + /** + * Creates server boot strap. + * + * @return ServerBootStrap + */ + private ServerBootstrap createServerBootStrap() { + if (workerThreads == 0) { + execFactory = new NioServerSocketChannelFactory( + Executors.newCachedThreadPool(groupedThreads("onos/pcep", "boss-%d")), + Executors.newCachedThreadPool(groupedThreads("onos/pcep", "worker-%d"))); + return new ServerBootstrap(execFactory); + } else { + execFactory = new NioServerSocketChannelFactory( + Executors.newCachedThreadPool(groupedThreads("onos/pcep", "boss-%d")), + Executors.newCachedThreadPool(groupedThreads("onos/pcep", "worker-%d")), workerThreads); + return new ServerBootstrap(execFactory); + } + } + + /** + * Initialize internal data structures. + */ + public void init() { + // These data structures are initialized here because other + // module's startUp() might be called before ours + this.systemStartTime = System.currentTimeMillis(); + } + + public Map<String, Long> getMemory() { + Map<String, Long> m = new HashMap<>(); + Runtime runtime = Runtime.getRuntime(); + m.put("total", runtime.totalMemory()); + m.put("free", runtime.freeMemory()); + return m; + } + + public Long getUptime() { + RuntimeMXBean rb = ManagementFactory.getRuntimeMXBean(); + return rb.getUptime(); + } + + /** + * Creates instance of Pcep client. + * + * @param pccId pcc identifier + * @param sessionID session id + * @param pv pcep version + * @param pktStats pcep packet statistics + * @return instance of PcepClient + */ + protected PcepClientDriver getPcepClientInstance(PccId pccId, int sessionID, PcepVersion pv, + PcepPacketStats pktStats) { + PcepClientDriver pcepClientDriver = new PcepClientImpl(); + pcepClientDriver.init(pccId, pv, pktStats); + pcepClientDriver.setAgent(agent); + return pcepClientDriver; + } + + /** + * Starts the pcep controller. + * + * @param ag Pcep agent + */ + public void start(PcepAgent ag) { + log.info("Started"); + this.agent = ag; + this.init(); + this.run(); + } + + /** + * Stops the pcep controller. + */ + public void stop() { + log.info("Stopped"); + execFactory.shutdown(); + cg.close(); + } +} diff --git a/framework/src/onos/protocols/pcep/ctl/src/main/java/org/onosproject/pcep/controller/impl/PcepChannelHandler.java b/framework/src/onos/protocols/pcep/ctl/src/main/java/org/onosproject/pcep/controller/impl/PcepChannelHandler.java new file mode 100644 index 00000000..bc8721d7 --- /dev/null +++ b/framework/src/onos/protocols/pcep/ctl/src/main/java/org/onosproject/pcep/controller/impl/PcepChannelHandler.java @@ -0,0 +1,652 @@ +/* + * 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.pcep.controller.impl; + +import java.io.IOException; +import java.net.InetSocketAddress; +import java.net.SocketAddress; +import java.nio.channels.ClosedChannelException; +import java.util.Collections; +import java.util.Date; +import java.util.LinkedList; +import java.util.List; +import java.util.ListIterator; +import java.util.concurrent.RejectedExecutionException; + +import org.jboss.netty.channel.Channel; +import org.jboss.netty.channel.ChannelHandlerContext; +import org.jboss.netty.channel.ChannelStateEvent; +import org.jboss.netty.channel.ExceptionEvent; +import org.jboss.netty.channel.MessageEvent; +import org.jboss.netty.handler.timeout.IdleState; +import org.jboss.netty.handler.timeout.IdleStateAwareChannelHandler; +import org.jboss.netty.handler.timeout.IdleStateEvent; +import org.jboss.netty.handler.timeout.IdleStateHandler; +import org.jboss.netty.handler.timeout.ReadTimeoutException; +import org.onlab.packet.IpAddress; +import org.onosproject.pcep.controller.PccId; +import org.onosproject.pcep.controller.driver.PcepClientDriver; +import org.onosproject.pcepio.exceptions.PcepParseException; +import org.onosproject.pcepio.protocol.PcepError; +import org.onosproject.pcepio.protocol.PcepErrorInfo; +import org.onosproject.pcepio.protocol.PcepErrorMsg; +import org.onosproject.pcepio.protocol.PcepErrorObject; +import org.onosproject.pcepio.protocol.PcepFactory; +import org.onosproject.pcepio.protocol.PcepMessage; +import org.onosproject.pcepio.protocol.PcepOpenMsg; +import org.onosproject.pcepio.protocol.PcepOpenObject; +import org.onosproject.pcepio.protocol.PcepType; +import org.onosproject.pcepio.protocol.PcepVersion; +import org.onosproject.pcepio.types.ErrorObjListWithOpen; +import org.onosproject.pcepio.types.PceccCapabilityTlv; +import org.onosproject.pcepio.types.StatefulPceCapabilityTlv; +import org.onosproject.pcepio.types.PcepErrorDetailInfo; +import org.onosproject.pcepio.types.PcepValueType; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +/** + * Channel handler deals with the pcc client connection and dispatches + * messages from client to the appropriate locations. + */ +class PcepChannelHandler extends IdleStateAwareChannelHandler { + static final byte DEADTIMER_MAXIMUM_VALUE = (byte) 0xFF; + static final byte KEEPALIVE_MULTIPLE_FOR_DEADTIMER = 4; + private static final Logger log = LoggerFactory.getLogger(PcepChannelHandler.class); + private final Controller controller; + private PcepClientDriver pc; + private PccId thispccId; + private Channel channel; + private byte sessionId = 0; + private byte keepAliveTime; + private byte deadTime; + private PcepPacketStatsImpl pcepPacketStats; + static final int MAX_WRONG_COUNT_PACKET = 5; + static final int BYTE_MASK = 0xFF; + + // State needs to be volatile because the HandshakeTimeoutHandler + // needs to check if the handshake is complete + private volatile ChannelState state; + + // When a pcc client with a ip addresss is found (i.e we already have a + // connected client with the same ip), the new client is immediately + // disconnected. At that point netty callsback channelDisconnected() which + // proceeds to cleaup client state - we need to ensure that it does not cleanup + // client state for the older (still connected) client + private volatile Boolean duplicatePccIdFound; + + //Indicates the pcep version used by this pcc client + protected PcepVersion pcepVersion; + protected PcepFactory factory1; + + /** + * Create a new unconnected PcepChannelHandler. + * @param controller parent controller + */ + PcepChannelHandler(Controller controller) { + this.controller = controller; + this.state = ChannelState.INIT; + factory1 = controller.getPcepMessageFactory1(); + duplicatePccIdFound = Boolean.FALSE; + pcepPacketStats = new PcepPacketStatsImpl(); + } + + /** + * To disconnect a PCC. + */ + public void disconnectClient() { + pc.disconnectClient(); + } + + //************************* + // Channel State Machine + //************************* + + /** + * The state machine for handling the client/channel state. All state + * transitions should happen from within the state machine (and not from other + * parts of the code) + */ + enum ChannelState { + /** + * Initial state before channel is connected. + */ + INIT(false) { + + }, + /** + * Once the session is established, wait for open message. + */ + OPENWAIT(false) { + @Override + void processPcepMessage(PcepChannelHandler h, PcepMessage m) throws IOException, PcepParseException { + + log.debug("Message received in OPEN WAIT State"); + + //check for open message + if (m.getType() != PcepType.OPEN) { + // When the message type is not open message increment the wrong packet statistics + h.processUnknownMsg(); + log.debug("message is not OPEN message"); + } else { + + h.pcepPacketStats.addInPacket(); + PcepOpenMsg pOpenmsg = (PcepOpenMsg) m; + // do Capability validation. + if (h.capabilityValidation(pOpenmsg)) { + log.debug("Sending handshake OPEN message"); + h.sessionId = pOpenmsg.getPcepOpenObject().getSessionId(); + h.pcepVersion = pOpenmsg.getPcepOpenObject().getVersion(); + + //setting keepalive and deadTimer + byte yKeepalive = pOpenmsg.getPcepOpenObject().getKeepAliveTime(); + byte yDeadTimer = pOpenmsg.getPcepOpenObject().getDeadTime(); + h.keepAliveTime = yKeepalive; + if (yKeepalive < yDeadTimer) { + h.deadTime = yDeadTimer; + } else { + if (DEADTIMER_MAXIMUM_VALUE > (yKeepalive * KEEPALIVE_MULTIPLE_FOR_DEADTIMER)) { + h.deadTime = (byte) (yKeepalive * KEEPALIVE_MULTIPLE_FOR_DEADTIMER); + } else { + h.deadTime = DEADTIMER_MAXIMUM_VALUE; + } + } + h.sendHandshakeOpenMessage(); + h.pcepPacketStats.addOutPacket(); + h.setState(KEEPWAIT); + } else { + log.debug("Capability validation failed. Sending PCEP-ERROR message to PCC."); + // Send PCEP-ERROR message. + PcepErrorMsg errMsg = h.getErrorMsg(PcepErrorDetailInfo.ERROR_TYPE_2, + PcepErrorDetailInfo.ERROR_VALUE_2); + h.channel.write(Collections.singletonList(errMsg)); + } + } + } + }, + /** + * Once the open messages are exchanged, wait for keep alive message. + */ + KEEPWAIT(false) { + @Override + void processPcepMessage(PcepChannelHandler h, PcepMessage m) throws IOException, PcepParseException { + log.debug("message received in KEEPWAIT state"); + //check for keep alive message + if (m.getType() != PcepType.KEEP_ALIVE) { + // When the message type is not keep alive message increment the wrong packet statistics + h.processUnknownMsg(); + log.debug("message is not KEEPALIVE message"); + } else { + // Set the client connected status + h.pcepPacketStats.addInPacket(); + final SocketAddress address = h.channel.getRemoteAddress(); + if (!(address instanceof InetSocketAddress)) { + throw new IOException("Invalid client connection. Pcc is indentifed based on IP"); + } + log.debug("sending keep alive message in KEEPWAIT state"); + + final InetSocketAddress inetAddress = (InetSocketAddress) address; + h.thispccId = PccId.pccId(IpAddress.valueOf(inetAddress.getAddress())); + h.pc = h.controller.getPcepClientInstance(h.thispccId, h.sessionId, h.pcepVersion, + h.pcepPacketStats); + // set the status of pcc as connected + h.pc.setConnected(true); + h.pc.setChannel(h.channel); + + // set any other specific parameters to the pcc + h.pc.setPcVersion(h.pcepVersion); + h.pc.setPcSessionId(h.sessionId); + h.pc.setPcKeepAliveTime(h.keepAliveTime); + h.pc.setPcDeadTime(h.deadTime); + int keepAliveTimer = h.keepAliveTime & BYTE_MASK; + int deadTimer = h.deadTime & BYTE_MASK; + if (0 == h.keepAliveTime) { + h.deadTime = 0; + } + // handle keep alive and dead time + if (keepAliveTimer != PcepPipelineFactory.DEFAULT_KEEP_ALIVE_TIME + || deadTimer != PcepPipelineFactory.DEFAULT_DEAD_TIME) { + + h.channel.getPipeline().replace("idle", "idle", + new IdleStateHandler(PcepPipelineFactory.TIMER, deadTimer, keepAliveTimer, 0)); + } + log.debug("Dead timer : " + deadTimer); + log.debug("Keep alive time : " + keepAliveTimer); + + //set the state handshake completion. + h.sendKeepAliveMessage(); + h.pcepPacketStats.addOutPacket(); + h.setHandshakeComplete(true); + + if (!h.pc.connectClient()) { + disconnectDuplicate(h); + } else { + h.setState(ESTABLISHED); + } + } + } + }, + /** + * Once the keep alive messages are exchanged, the state is established. + */ + ESTABLISHED(true) { + @Override + void processPcepMessage(PcepChannelHandler h, PcepMessage m) throws IOException, PcepParseException { + + //h.channel.getPipeline().remove("waittimeout"); + log.debug("Message received in established state " + m.getType()); + //dispatch the message + h.dispatchMessage(m); + } + }; + private boolean handshakeComplete; + + ChannelState(boolean handshakeComplete) { + this.handshakeComplete = handshakeComplete; + } + + void processPcepMessage(PcepChannelHandler h, PcepMessage m) throws IOException, PcepParseException { + // do nothing + } + + /** + * Is this a state in which the handshake has completed. + * + * @return true if the handshake is complete + */ + public boolean isHandshakeComplete() { + return this.handshakeComplete; + } + + protected void disconnectDuplicate(PcepChannelHandler h) { + log.error("Duplicated Pcc IP or incompleted cleanup - " + "disconnecting channel {}", + h.getClientInfoString()); + h.duplicatePccIdFound = Boolean.TRUE; + h.channel.disconnect(); + } + + /** + * Sets handshake complete status. + * + * @param handshakeComplete status of handshake + */ + public void setHandshakeComplete(boolean handshakeComplete) { + this.handshakeComplete = handshakeComplete; + } + + } + + @Override + public void channelConnected(ChannelHandlerContext ctx, ChannelStateEvent e) throws Exception { + channel = e.getChannel(); + log.info("PCC connected from {}", channel.getRemoteAddress()); + + // Wait for open message from pcc client + setState(ChannelState.OPENWAIT); + } + + @Override + public void channelDisconnected(ChannelHandlerContext ctx, ChannelStateEvent e) throws Exception { + log.info("Pcc disconnected callback for pc:{}. Cleaning up ...", getClientInfoString()); + if (thispccId != null) { + if (!duplicatePccIdFound) { + // if the disconnected client (on this ChannelHandler) + // was not one with a duplicate-dpid, it is safe to remove all + // state for it at the controller. Notice that if the disconnected + // client was a duplicate-ip, calling the method below would clear + // all state for the original client (with the same ip), + // which we obviously don't want. + log.debug("{}:removal called", getClientInfoString()); + if (pc != null) { + pc.removeConnectedClient(); + } + } else { + // A duplicate was disconnected on this ChannelHandler, + // this is the same client reconnecting, but the original state was + // not cleaned up - XXX check liveness of original ChannelHandler + log.debug("{}:duplicate found", getClientInfoString()); + duplicatePccIdFound = Boolean.FALSE; + } + } else { + log.warn("no pccip in channelHandler registered for " + "disconnected client {}", getClientInfoString()); + } + } + + @Override + public void exceptionCaught(ChannelHandlerContext ctx, ExceptionEvent e) throws Exception { + PcepErrorMsg errMsg; + log.info("exceptionCaught: " + e.toString()); + + if (e.getCause() instanceof ReadTimeoutException) { + if (ChannelState.OPENWAIT == state) { + // When ReadTimeout timer is expired in OPENWAIT state, it is considered + // OpenWait timer. + errMsg = getErrorMsg(PcepErrorDetailInfo.ERROR_TYPE_1, PcepErrorDetailInfo.ERROR_VALUE_2); + log.debug("Sending PCEP-ERROR message to PCC."); + channel.write(Collections.singletonList(errMsg)); + channel.close(); + state = ChannelState.INIT; + return; + } else if (ChannelState.KEEPWAIT == state) { + // When ReadTimeout timer is expired in KEEPWAIT state, is is considered + // KeepWait timer. + errMsg = getErrorMsg(PcepErrorDetailInfo.ERROR_TYPE_1, PcepErrorDetailInfo.ERROR_VALUE_7); + log.debug("Sending PCEP-ERROR message to PCC."); + channel.write(Collections.singletonList(errMsg)); + channel.close(); + state = ChannelState.INIT; + return; + } + } else if (e.getCause() instanceof ClosedChannelException) { + log.debug("Channel for pc {} already closed", getClientInfoString()); + } else if (e.getCause() instanceof IOException) { + log.error("Disconnecting client {} due to IO Error: {}", getClientInfoString(), e.getCause().getMessage()); + if (log.isDebugEnabled()) { + // still print stack trace if debug is enabled + log.debug("StackTrace for previous Exception: ", e.getCause()); + } + channel.close(); + } else if (e.getCause() instanceof PcepParseException) { + PcepParseException errMsgParse = (PcepParseException) e.getCause(); + byte errorType = errMsgParse.getErrorType(); + byte errorValue = errMsgParse.getErrorValue(); + + if ((errorType == (byte) 0x0) && (errorValue == (byte) 0x0)) { + processUnknownMsg(); + } else { + errMsg = getErrorMsg(errorType, errorValue); + log.debug("Sending PCEP-ERROR message to PCC."); + channel.write(Collections.singletonList(errMsg)); + } + } else if (e.getCause() instanceof RejectedExecutionException) { + log.warn("Could not process message: queue full"); + } else { + log.error("Error while processing message from client " + getClientInfoString() + "state " + this.state); + channel.close(); + } + } + + @Override + public String toString() { + return getClientInfoString(); + } + + @Override + public void channelIdle(ChannelHandlerContext ctx, IdleStateEvent e) throws Exception { + if (!isHandshakeComplete()) { + return; + } + + if (e.getState() == IdleState.READER_IDLE) { + // When no message is received on channel for read timeout, then close + // the channel + log.info("Disconnecting client {} due to read timeout", getClientInfoString()); + ctx.getChannel().close(); + } else if (e.getState() == IdleState.WRITER_IDLE) { + // Send keep alive message + log.debug("Sending keep alive message due to IdleState timeout " + pc.toString()); + pc.sendMessage(Collections.singletonList(pc.factory().buildKeepaliveMsg().build())); + } + } + + @Override + public void messageReceived(ChannelHandlerContext ctx, MessageEvent e) throws Exception { + if (e.getMessage() instanceof List) { + @SuppressWarnings("unchecked") + List<PcepMessage> msglist = (List<PcepMessage>) e.getMessage(); + for (PcepMessage pm : msglist) { + // Do the actual packet processing + state.processPcepMessage(this, pm); + } + } else { + state.processPcepMessage(this, (PcepMessage) e.getMessage()); + } + } + + /** + * To set the handshake status. + * + * @param handshakeComplete value is handshake status + */ + public void setHandshakeComplete(boolean handshakeComplete) { + this.state.setHandshakeComplete(handshakeComplete); + } + + /** + * Is this a state in which the handshake has completed. + * + * @return true if the handshake is complete + */ + public boolean isHandshakeComplete() { + return this.state.isHandshakeComplete(); + } + + /** + * To handle the pcep message. + * + * @param m pcep message + */ + private void dispatchMessage(PcepMessage m) { + pc.handleMessage(m); + } + + /** + * Return a string describing this client based on the already available + * information (ip address and/or remote socket). + * + * @return display string + */ + private String getClientInfoString() { + if (pc != null) { + return pc.toString(); + } + String channelString; + if (channel == null || channel.getRemoteAddress() == null) { + channelString = "?"; + } else { + channelString = channel.getRemoteAddress().toString(); + } + String pccIpString; + // TODO : implement functionality to get pcc id string + pccIpString = "?"; + return String.format("[%s PCCIP[%s]]", channelString, pccIpString); + } + + /** + * Update the channels state. Only called from the state machine. + * + * @param state + */ + private void setState(ChannelState state) { + this.state = state; + } + + /** + * Send handshake open message. + * + * @throws IOException,PcepParseException + */ + private void sendHandshakeOpenMessage() throws IOException, PcepParseException { + PcepOpenObject pcepOpenobj = factory1.buildOpenObject() + .setSessionId(sessionId) + .setKeepAliveTime(keepAliveTime) + .setDeadTime(deadTime) + .build(); + PcepMessage msg = factory1.buildOpenMsg() + .setPcepOpenObj(pcepOpenobj) + .build(); + log.debug("Sending OPEN message to {}", channel.getRemoteAddress()); + channel.write(Collections.singletonList(msg)); + } + + /** + * Capability Validation. + * + * @param pOpenmsg pcep open message + * @return success or failure + */ + private boolean capabilityValidation(PcepOpenMsg pOpenmsg) { + LinkedList<PcepValueType> tlvList = pOpenmsg.getPcepOpenObject().getOptionalTlv(); + boolean bFoundPceccCapability = false; + boolean bFoundStatefulPceCapability = false; + boolean bFoundPcInstantiationCapability = false; + + ListIterator<PcepValueType> listIterator = tlvList.listIterator(); + while (listIterator.hasNext()) { + PcepValueType tlv = listIterator.next(); + + switch (tlv.getType()) { + case PceccCapabilityTlv.TYPE: + bFoundPceccCapability = true; + break; + case StatefulPceCapabilityTlv.TYPE: + bFoundStatefulPceCapability = true; + StatefulPceCapabilityTlv stetefulPcCapTlv = (StatefulPceCapabilityTlv) tlv; + if (stetefulPcCapTlv.getIFlag()) { + bFoundPcInstantiationCapability = true; + } + break; + default: + continue; + } + } + + return (bFoundPceccCapability && bFoundStatefulPceCapability && bFoundPcInstantiationCapability); + } + + /** + * Send keep alive message. + * + * @throws IOException when channel is disconnected + * @throws PcepParseException while building keep alive message + */ + private void sendKeepAliveMessage() throws IOException, PcepParseException { + PcepMessage msg = factory1.buildKeepaliveMsg().build(); + log.debug("Sending KEEPALIVE message to {}", channel.getRemoteAddress()); + channel.write(Collections.singletonList(msg)); + } + + /** + * Send error message and close channel with pcc. + */ + private void sendErrMsgAndCloseChannel() { + // TODO send error message + channel.close(); + } + + /** + * Send error message when an invalid message is received. + * + * @throws PcepParseException while building error message + */ + private void sendErrMsgForInvalidMsg() throws PcepParseException { + byte errorType = 0x02; + byte errorValue = 0x00; + PcepErrorMsg errMsg = getErrorMsg(errorType, errorValue); + channel.write(Collections.singletonList(errMsg)); + } + + /** + * Builds pcep error message based on error value and error type. + * + * @param errorType pcep error type + * @param errorValue pcep error value + * @return pcep error message + * @throws PcepParseException while bulding error message + */ + public PcepErrorMsg getErrorMsg(byte errorType, byte errorValue) throws PcepParseException { + LinkedList<PcepErrorObject> llerrObj = new LinkedList<>(); + PcepErrorMsg errMsg; + + PcepErrorObject errObj = factory1.buildPcepErrorObject() + .setErrorValue(errorValue) + .setErrorType(errorType) + .build(); + + llerrObj.add(errObj); + + if (state == ChannelState.OPENWAIT) { + //If Error caught in Openmessage + PcepOpenObject openObj = null; + ErrorObjListWithOpen errorObjListWithOpen = null; + + if (0 != sessionId) { + openObj = factory1.buildOpenObject().setSessionId(sessionId).build(); + errorObjListWithOpen = new ErrorObjListWithOpen(llerrObj, openObj); + } else { + errorObjListWithOpen = new ErrorObjListWithOpen(llerrObj, null); + } + + errMsg = factory1.buildPcepErrorMsg() + .setErrorObjListWithOpen(errorObjListWithOpen) + .build(); + } else { + + //If Error caught in other than Openmessage + LinkedList<PcepError> llPcepErr = new LinkedList<>(); + + PcepError pcepErr = factory1.buildPcepError() + .setErrorObjList(llerrObj) + .build(); + + llPcepErr.add(pcepErr); + + PcepErrorInfo errInfo = factory1.buildPcepErrorInfo() + .setPcepErrorList(llPcepErr) + .build(); + + errMsg = factory1.buildPcepErrorMsg() + .setPcepErrorInfo(errInfo) + .build(); + } + return errMsg; + } + + /** + * Process unknown pcep message received. + * + * @throws PcepParseException while building pcep error message + */ + public void processUnknownMsg() throws PcepParseException { + Date now = null; + if (pcepPacketStats.wrongPacketCount() == 0) { + now = new Date(); + pcepPacketStats.setTime(now.getTime()); + pcepPacketStats.addWrongPacket(); + sendErrMsgForInvalidMsg(); + } + + if (pcepPacketStats.wrongPacketCount() > 1) { + Date lastest = new Date(); + pcepPacketStats.addWrongPacket(); + //converting to seconds + if (((lastest.getTime() - pcepPacketStats.getTime()) / 1000) > 60) { + now = lastest; + pcepPacketStats.setTime(now.getTime()); + pcepPacketStats.resetWrongPacket(); + pcepPacketStats.addWrongPacket(); + } else if (((int) (lastest.getTime() - now.getTime()) / 1000) < 60) { + if (MAX_WRONG_COUNT_PACKET <= pcepPacketStats.wrongPacketCount()) { + //reset once wrong packet count reaches MAX_WRONG_COUNT_PACKET + pcepPacketStats.resetWrongPacket(); + // max wrong packets received send error message and close the session + sendErrMsgAndCloseChannel(); + } + } + } + } +} diff --git a/framework/src/onos/protocols/pcep/ctl/src/main/java/org/onosproject/pcep/controller/impl/PcepClientControllerImpl.java b/framework/src/onos/protocols/pcep/ctl/src/main/java/org/onosproject/pcep/controller/impl/PcepClientControllerImpl.java new file mode 100644 index 00000000..00c8c694 --- /dev/null +++ b/framework/src/onos/protocols/pcep/ctl/src/main/java/org/onosproject/pcep/controller/impl/PcepClientControllerImpl.java @@ -0,0 +1,222 @@ +/* + * 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.pcep.controller.impl; + +import java.util.Collection; +import java.util.Collections; +import java.util.HashSet; +import java.util.Set; +import java.util.concurrent.ConcurrentHashMap; + +import org.apache.felix.scr.annotations.Activate; +import org.apache.felix.scr.annotations.Component; +import org.apache.felix.scr.annotations.Deactivate; +import org.apache.felix.scr.annotations.Service; +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.pcep.controller.driver.PcepAgent; +import org.onosproject.pcepio.protocol.PcepMessage; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.google.common.collect.Sets; + +/** + * Implementation of PCEP client controller. + */ +@Component(immediate = true) +@Service +public class PcepClientControllerImpl implements PcepClientController { + + private static final Logger log = LoggerFactory.getLogger(PcepClientControllerImpl.class); + + protected ConcurrentHashMap<PccId, PcepClient> connectedClients = + new ConcurrentHashMap<>(); + + protected PcepClientAgent agent = new PcepClientAgent(); + protected Set<PcepClientListener> pcepClientListener = new HashSet<>(); + + protected Set<PcepEventListener> pcepEventListener = Sets.newHashSet(); + + private final Controller ctrl = new Controller(); + + @Activate + public void activate() { + ctrl.start(agent); + log.info("Started"); + } + + @Deactivate + public void deactivate() { + // Close all connected clients + closeConnectedClients(); + ctrl.stop(); + log.info("Stopped"); + } + + @Override + public Collection<PcepClient> getClients() { + return connectedClients.values(); + } + + @Override + public PcepClient getClient(PccId pccId) { + return connectedClients.get(pccId); + } + + @Override + public void addListener(PcepClientListener listener) { + if (!pcepClientListener.contains(listener)) { + this.pcepClientListener.add(listener); + } + } + + @Override + public void removeListener(PcepClientListener listener) { + this.pcepClientListener.remove(listener); + } + + @Override + public void addEventListener(PcepEventListener listener) { + pcepEventListener.add(listener); + } + + @Override + public void removeEventListener(PcepEventListener listener) { + pcepEventListener.remove(listener); + } + + @Override + public void writeMessage(PccId pccId, PcepMessage msg) { + this.getClient(pccId).sendMessage(msg); + } + + @Override + public void processClientMessage(PccId pccId, PcepMessage msg) { + PcepClient pc = getClient(pccId); + + switch (msg.getType()) { + case NONE: + break; + case OPEN: + break; + case KEEP_ALIVE: + break; + case PATH_COMPUTATION_REQUEST: + break; + case PATH_COMPUTATION_REPLY: + break; + case NOTIFICATION: + break; + case ERROR: + break; + case CLOSE: + log.info("Sending Close Message to {" + pccId.toString() + "}"); + pc.sendMessage(Collections.singletonList(pc.factory().buildCloseMsg().build())); + //now disconnect client + pc.disconnectClient(); + break; + case REPORT: + for (PcepEventListener l : pcepEventListener) { + l.handleMessage(pccId, msg); + } + break; + case UPDATE: + for (PcepEventListener l : pcepEventListener) { + l.handleMessage(pccId, msg); + } + break; + case INITIATE: + for (PcepEventListener l : pcepEventListener) { + l.handleMessage(pccId, msg); + } + break; + case LABEL_UPDATE: + break; + case MAX: + break; + case END: + break; + default: + break; + } + } + + @Override + public void closeConnectedClients() { + PcepClient pc; + for (PccId id : connectedClients.keySet()) { + pc = getClient(id); + pc.disconnectClient(); + } + } + + /** + * Implementation of an Pcep Agent which is responsible for + * keeping track of connected clients and the state in which + * they are. + */ + public class PcepClientAgent implements PcepAgent { + + private final Logger log = LoggerFactory.getLogger(PcepClientAgent.class); + + @Override + public boolean addConnectedClient(PccId pccId, PcepClient pc) { + + if (connectedClients.get(pccId) != null) { + log.error("Trying to add connectedClient but found a previous " + + "value for pcc ip: {}", pccId.toString()); + return false; + } else { + log.debug("Added Client {}", pccId.toString()); + connectedClients.put(pccId, pc); + for (PcepClientListener l : pcepClientListener) { + l.clientConnected(pccId); + } + return true; + } + } + + @Override + public boolean validActivation(PccId pccId) { + if (connectedClients.get(pccId) == null) { + log.error("Trying to activate client but is not in " + + "connected client: pccIp {}. Aborting ..", pccId.toString()); + return false; + } + + return true; + } + + @Override + public void removeConnectedClient(PccId pccId) { + + connectedClients.remove(pccId); + for (PcepClientListener l : pcepClientListener) { + log.warn("removal for {}", pccId.toString()); + l.clientDisconnected(pccId); + } + } + + @Override + public void processPcepMessage(PccId pccId, PcepMessage m) { + processClientMessage(pccId, m); + } + } +} diff --git a/framework/src/onos/protocols/pcep/ctl/src/main/java/org/onosproject/pcep/controller/impl/PcepClientImpl.java b/framework/src/onos/protocols/pcep/ctl/src/main/java/org/onosproject/pcep/controller/impl/PcepClientImpl.java new file mode 100644 index 00000000..a10ff5c8 --- /dev/null +++ b/framework/src/onos/protocols/pcep/ctl/src/main/java/org/onosproject/pcep/controller/impl/PcepClientImpl.java @@ -0,0 +1,220 @@ +/* + * 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.pcep.controller.impl; + +import java.net.InetSocketAddress; +import java.net.SocketAddress; +import java.util.Collections; +import java.util.List; +import java.util.concurrent.RejectedExecutionException; + +import org.jboss.netty.channel.Channel; +import org.onlab.packet.IpAddress; +import org.onosproject.pcep.controller.PccId; +import org.onosproject.pcep.controller.PcepPacketStats; +import org.onosproject.pcep.controller.driver.PcepAgent; +import org.onosproject.pcep.controller.driver.PcepClientDriver; +import org.onosproject.pcepio.protocol.PcepFactories; +import org.onosproject.pcepio.protocol.PcepFactory; +import org.onosproject.pcepio.protocol.PcepMessage; +import org.onosproject.pcepio.protocol.PcepVersion; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.google.common.base.MoreObjects; + +/** + * An abstract representation of an OpenFlow switch. Can be extended by others + * to serve as a base for their vendor specific representation of a switch. + */ +public class PcepClientImpl implements PcepClientDriver { + + protected final Logger log = LoggerFactory.getLogger(PcepClientImpl.class); + + private static final String SHUTDOWN_MSG = "Worker has already been shutdown"; + + private Channel channel; + protected String channelId; + + private boolean connected; + protected boolean startDriverHandshakeCalled = false; + protected boolean isHandShakeComplete = false; + protected boolean isSyncComplete = false; + private PccId pccId; + private PcepAgent agent; + + private PcepVersion pcepVersion; + private byte keepAliveTime; + private byte deadTime; + private byte sessionId; + private PcepPacketStatsImpl pktStats; + + @Override + public void init(PccId pccId, PcepVersion pcepVersion, PcepPacketStats pktStats) { + this.pccId = pccId; + this.pcepVersion = pcepVersion; + this.pktStats = (PcepPacketStatsImpl) pktStats; + } + + @Override + public final void disconnectClient() { + this.channel.close(); + } + + @Override + public final void sendMessage(PcepMessage m) { + log.debug("Sending message to {}", channel.getRemoteAddress()); + try { + channel.write(Collections.singletonList(m)); + this.pktStats.addOutPacket(); + } catch (RejectedExecutionException e) { + log.warn(e.getMessage()); + if (!e.getMessage().contains(SHUTDOWN_MSG)) { + throw e; + } + } + } + + @Override + public final void sendMessage(List<PcepMessage> msgs) { + try { + channel.write(msgs); + this.pktStats.addOutPacket(msgs.size()); + } catch (RejectedExecutionException e) { + log.warn(e.getMessage()); + if (!e.getMessage().contains(SHUTDOWN_MSG)) { + throw e; + } + } + } + + @Override + public final boolean isConnected() { + return this.connected; + } + + @Override + public final void setConnected(boolean connected) { + this.connected = connected; + }; + + @Override + public final void setChannel(Channel channel) { + this.channel = channel; + final SocketAddress address = channel.getRemoteAddress(); + if (address instanceof InetSocketAddress) { + final InetSocketAddress inetAddress = (InetSocketAddress) address; + final IpAddress ipAddress = IpAddress.valueOf(inetAddress.getAddress()); + if (ipAddress.isIp4()) { + channelId = ipAddress.toString() + ':' + inetAddress.getPort(); + } else { + channelId = '[' + ipAddress.toString() + "]:" + inetAddress.getPort(); + } + } + }; + + @Override + public String channelId() { + return channelId; + } + + @Override + public final PccId getPccId() { + return this.pccId; + } + + @Override + public final String getStringId() { + return this.pccId.toString(); + } + + @Override + public final void setPcVersion(PcepVersion pcepVersion) { + this.pcepVersion = pcepVersion; + } + + @Override + public void setPcKeepAliveTime(byte keepAliveTime) { + this.keepAliveTime = keepAliveTime; + } + + @Override + public void setPcDeadTime(byte deadTime) { + this.deadTime = deadTime; + } + + @Override + public void setPcSessionId(byte sessionId) { + this.sessionId = sessionId; + } + + @Override + public void setIsSyncComplete(boolean value) { + this.isSyncComplete = value; + } + + @Override + public boolean isSyncComplete() { + return isSyncComplete; + } + + @Override + public final void handleMessage(PcepMessage m) { + this.pktStats.addInPacket(); + this.agent.processPcepMessage(pccId, m); + } + + @Override + public final boolean connectClient() { + return this.agent.addConnectedClient(pccId, this); + } + + @Override + public final void removeConnectedClient() { + this.agent.removeConnectedClient(pccId); + } + + @Override + public PcepFactory factory() { + return PcepFactories.getFactory(pcepVersion); + } + + @Override + public boolean isHandshakeComplete() { + return isHandShakeComplete; + } + + @Override + public final void setAgent(PcepAgent ag) { + if (this.agent == null) { + this.agent = ag; + } + } + + @Override + public boolean isOptical() { + return false; + } + + @Override + public String toString() { + return MoreObjects.toStringHelper(getClass()) + .add("channel", channelId()) + .add("pccId", getPccId()) + .toString(); + } +} diff --git a/framework/src/onos/protocols/pcep/ctl/src/main/java/org/onosproject/pcep/controller/impl/PcepMessageDecoder.java b/framework/src/onos/protocols/pcep/ctl/src/main/java/org/onosproject/pcep/controller/impl/PcepMessageDecoder.java new file mode 100644 index 00000000..b1065891 --- /dev/null +++ b/framework/src/onos/protocols/pcep/ctl/src/main/java/org/onosproject/pcep/controller/impl/PcepMessageDecoder.java @@ -0,0 +1,68 @@ +/* + * 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.pcep.controller.impl; + +import java.util.LinkedList; +import java.util.List; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.jboss.netty.channel.Channel; +import org.jboss.netty.channel.ChannelHandlerContext; +import org.jboss.netty.handler.codec.frame.FrameDecoder; +import org.onosproject.pcepio.protocol.PcepFactories; +import org.onosproject.pcepio.protocol.PcepMessage; +import org.onosproject.pcepio.protocol.PcepMessageReader; +import org.onosproject.pcepio.util.HexDump; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +/** + * Decode an pcep message from a Channel, for use in a netty pipeline. + */ +public class PcepMessageDecoder extends FrameDecoder { + + protected static final Logger log = LoggerFactory.getLogger(PcepMessageDecoder.class); + + @Override + protected Object decode(ChannelHandlerContext ctx, Channel channel, + ChannelBuffer buffer) throws Exception { + log.debug("Message received."); + if (!channel.isConnected()) { + log.info("Channel is not connected."); + // In testing, I see decode being called AFTER decode last. + // This check avoids that from reading corrupted frames + return null; + } + + HexDump.pcepHexDump(buffer); + + // Note that a single call to decode results in reading a single + // PcepMessage from the channel buffer, which is passed on to, and processed + // by, the controller (in PcepChannelHandler). + // This is different from earlier behavior (with the original pcepIO), + // where we parsed all the messages in the buffer, before passing on + // a list of the parsed messages to the controller. + // The performance *may or may not* not be as good as before. + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + List<PcepMessage> msgList = new LinkedList<>(); + + while (buffer.readableBytes() > 0) { + PcepMessage message = reader.readFrom(buffer); + msgList.add(message); + } + return msgList; + } +} diff --git a/framework/src/onos/protocols/pcep/ctl/src/main/java/org/onosproject/pcep/controller/impl/PcepMessageEncoder.java b/framework/src/onos/protocols/pcep/ctl/src/main/java/org/onosproject/pcep/controller/impl/PcepMessageEncoder.java new file mode 100644 index 00000000..ae97221e --- /dev/null +++ b/framework/src/onos/protocols/pcep/ctl/src/main/java/org/onosproject/pcep/controller/impl/PcepMessageEncoder.java @@ -0,0 +1,58 @@ +/* + * 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.pcep.controller.impl; + +import java.util.List; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.jboss.netty.buffer.ChannelBuffers; +import org.jboss.netty.channel.Channel; +import org.jboss.netty.channel.ChannelHandlerContext; +import org.jboss.netty.handler.codec.oneone.OneToOneEncoder; +import org.onosproject.pcepio.protocol.PcepMessage; +import org.onosproject.pcepio.util.HexDump; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +/** + * Encode an pcep message for output into a ChannelBuffer, for use in a + * netty pipeline. + */ +public class PcepMessageEncoder extends OneToOneEncoder { + protected static final Logger log = LoggerFactory.getLogger(PcepMessageEncoder.class); + + @Override + protected Object encode(ChannelHandlerContext ctx, Channel channel, Object msg) throws Exception { + log.debug("Sending message"); + if (!(msg instanceof List)) { + log.debug("Invalid msg."); + return msg; + } + + @SuppressWarnings("unchecked") + List<PcepMessage> msglist = (List<PcepMessage>) msg; + + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + + for (PcepMessage pm : msglist) { + pm.writeTo(buf); + } + + HexDump.pcepHexDump(buf); + + return buf; + } +} diff --git a/framework/src/onos/protocols/pcep/ctl/src/main/java/org/onosproject/pcep/controller/impl/PcepPacketStatsImpl.java b/framework/src/onos/protocols/pcep/ctl/src/main/java/org/onosproject/pcep/controller/impl/PcepPacketStatsImpl.java new file mode 100644 index 00000000..f2bc51eb --- /dev/null +++ b/framework/src/onos/protocols/pcep/ctl/src/main/java/org/onosproject/pcep/controller/impl/PcepPacketStatsImpl.java @@ -0,0 +1,105 @@ +/* + * 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.pcep.controller.impl; + +import org.onosproject.pcep.controller.PcepPacketStats; + +/** + * The implementation for PCEP packet statistics. + */ +public class PcepPacketStatsImpl implements PcepPacketStats { + + private int inPacketCount; + private int outPacketCount; + private int wrongPacketCount; + private long time; + + /** + * Default constructor. + */ + public PcepPacketStatsImpl() { + this.inPacketCount = 0; + this.outPacketCount = 0; + this.wrongPacketCount = 0; + this.time = 0; + } + + @Override + public int outPacketCount() { + return outPacketCount; + } + + @Override + public int inPacketCount() { + return inPacketCount; + } + + @Override + public int wrongPacketCount() { + return wrongPacketCount; + } + + /** + * Increments the received packet counter. + */ + public void addInPacket() { + this.inPacketCount++; + } + + /** + * Increments the sent packet counter. + */ + public void addOutPacket() { + this.outPacketCount++; + } + + /** + * Increments the sent packet counter by specified value. + * + * @param value of no of packets sent + */ + public void addOutPacket(int value) { + this.outPacketCount = this.outPacketCount + value; + } + + /** + * Increments the wrong packet counter. + */ + public void addWrongPacket() { + this.wrongPacketCount++; + } + + /** + * Resets wrong packet count. + */ + public void resetWrongPacket() { + this.wrongPacketCount = 0; + } + + @Override + public long getTime() { + return this.time; + } + + /** + * Sets the time value. + * + * @param time long value of time + */ + public void setTime(long time) { + this.time = time; + } +} diff --git a/framework/src/onos/protocols/pcep/ctl/src/main/java/org/onosproject/pcep/controller/impl/PcepPipelineFactory.java b/framework/src/onos/protocols/pcep/ctl/src/main/java/org/onosproject/pcep/controller/impl/PcepPipelineFactory.java new file mode 100644 index 00000000..f32b87a8 --- /dev/null +++ b/framework/src/onos/protocols/pcep/ctl/src/main/java/org/onosproject/pcep/controller/impl/PcepPipelineFactory.java @@ -0,0 +1,66 @@ +/* + * 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.pcep.controller.impl; + +import org.jboss.netty.channel.ChannelPipeline; +import org.jboss.netty.channel.ChannelPipelineFactory; +import org.jboss.netty.channel.Channels; +import org.jboss.netty.handler.timeout.IdleStateHandler; +import org.jboss.netty.handler.timeout.ReadTimeoutHandler; +import org.jboss.netty.util.ExternalResourceReleasable; +import org.jboss.netty.util.HashedWheelTimer; +import org.jboss.netty.util.Timer; + +/** + * Creates a ChannelPipeline for a server-side pcep channel. + */ +public class PcepPipelineFactory + implements ChannelPipelineFactory, ExternalResourceReleasable { + + protected Controller controller; + static final Timer TIMER = new HashedWheelTimer(); + protected IdleStateHandler idleHandler; + protected ReadTimeoutHandler readTimeoutHandler; + static final int DEFAULT_KEEP_ALIVE_TIME = 30; + static final int DEFAULT_DEAD_TIME = 120; + static final int DEFAULT_WAIT_TIME = 60; + + public PcepPipelineFactory(Controller controller) { + super(); + this.controller = controller; + this.idleHandler = new IdleStateHandler(TIMER, DEFAULT_DEAD_TIME, DEFAULT_KEEP_ALIVE_TIME, 0); + this.readTimeoutHandler = new ReadTimeoutHandler(TIMER, DEFAULT_WAIT_TIME); + } + + @Override + public ChannelPipeline getPipeline() throws Exception { + PcepChannelHandler handler = new PcepChannelHandler(controller); + + ChannelPipeline pipeline = Channels.pipeline(); + pipeline.addLast("pcepmessagedecoder", new PcepMessageDecoder()); + pipeline.addLast("pcepmessageencoder", new PcepMessageEncoder()); + pipeline.addLast("idle", idleHandler); + pipeline.addLast("waittimeout", readTimeoutHandler); + pipeline.addLast("handler", handler); + return pipeline; + } + + @Override + public void releaseExternalResources() { + TIMER.stop(); + } +} diff --git a/framework/src/onos/protocols/pcep/ctl/src/main/java/org/onosproject/pcep/controller/impl/package-info.java b/framework/src/onos/protocols/pcep/ctl/src/main/java/org/onosproject/pcep/controller/impl/package-info.java new file mode 100644 index 00000000..d86eefc3 --- /dev/null +++ b/framework/src/onos/protocols/pcep/ctl/src/main/java/org/onosproject/pcep/controller/impl/package-info.java @@ -0,0 +1,20 @@ +/* + * 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. + */ + +/** + * Implementation of the PCEP client controller subsystem. + */ +package org.onosproject.pcep.controller.impl; diff --git a/framework/src/onos/protocols/pcep/pcepio/pom.xml b/framework/src/onos/protocols/pcep/pcepio/pom.xml new file mode 100755 index 00000000..d121a83e --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/pom.xml @@ -0,0 +1,77 @@ +<?xml version="1.0" encoding="UTF-8"?> +<!-- + ~ Copyright 2014 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. + --> +<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/maven-v4_0_0.xsd"> + <modelVersion>4.0.0</modelVersion> + + <parent> + <groupId>org.onosproject</groupId> + <artifactId>onos-pcep-controller</artifactId> + <version>1.4.0-SNAPSHOT</version> + <relativePath>../pom.xml</relativePath> + </parent> + + <artifactId>onos-pcepio</artifactId> + <packaging>bundle</packaging> + + <description>ONOS Pcepio Protocol subsystem</description> + + + <dependencies> + <dependency> + <groupId>org.onosproject</groupId> + <artifactId>onos-api</artifactId> + </dependency> + <dependency> + <groupId>org.onosproject</groupId> + <artifactId>onlab-osgi</artifactId> + </dependency> + + <dependency> + <groupId>com.fasterxml.jackson.core</groupId> + <artifactId>jackson-databind</artifactId> + </dependency> + <dependency> + <groupId>com.fasterxml.jackson.core</groupId> + <artifactId>jackson-annotations</artifactId> + </dependency> + + <dependency> + <groupId>org.osgi</groupId> + <artifactId>org.osgi.core</artifactId> + </dependency> + <dependency> + <groupId>org.apache.karaf.shell</groupId> + <artifactId>org.apache.karaf.shell.console</artifactId> + </dependency> + <dependency> + <groupId>org.apache.felix</groupId> + <artifactId>org.apache.felix.scr.annotations</artifactId> + </dependency> + </dependencies> + + <build> + <plugins> + <plugin> + <groupId>org.apache.felix</groupId> + <artifactId>maven-bundle-plugin</artifactId> + </plugin> + </plugins> + </build> + +</project> diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/exceptions/PcepParseException.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/exceptions/PcepParseException.java new file mode 100755 index 00000000..85bc33fb --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/exceptions/PcepParseException.java @@ -0,0 +1,92 @@ +/* + * 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.exceptions; + +/** + * Custom Exception for PCEP IO. + */ +public class PcepParseException extends Exception { + + private static final long serialVersionUID = 7960991379951448423L; + private byte errType = 0; + private byte errValue = 0; + + /** + * Default constructor to create a new exception. + */ + public PcepParseException() { + super(); + } + + /** + * Constructor to create exception from message and cause. + * + * @param message the detail of exception in string + * @param cause underlying cause of the error + */ + public PcepParseException(final String message, final Throwable cause) { + super(message, cause); + } + + /** + * Constructor to create exception from message. + * + * @param message the detail of exception in string + */ + public PcepParseException(final String message) { + super(message); + } + + /** + * Constructor to create exception from error type and error value. + * + * @param errType error type of pcep + * @param errValue error value of pcep + */ + public PcepParseException(final byte errType, final byte errValue) { + super(); + this.errType = errType; + this.errValue = errValue; + } + + /** + * Constructor to create exception from cause. + * + * @param cause underlying cause of the error + */ + public PcepParseException(final Throwable cause) { + super(cause); + } + + /** + * Returns error type for this exception. + * + * @return ErrorType + */ + public byte getErrorType() { + return this.errType; + } + + /** + * Returns error value for this exception. + * + * @return ErrorValue + */ + public byte getErrorValue() { + return this.errValue; + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/exceptions/PcepTunnelAttributeException.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/exceptions/PcepTunnelAttributeException.java new file mode 100755 index 00000000..25bdf5b6 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/exceptions/PcepTunnelAttributeException.java @@ -0,0 +1,60 @@ +/* + * 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.exceptions; + +/** + * Custom exception for Tunnel Attributes. + */ +public class PcepTunnelAttributeException extends Exception { + + private static final long serialVersionUID = 7860981378961458434L; + + /** + * Default constructor to create a new exception. + */ + public PcepTunnelAttributeException() { + super(); + } + + /** + * Constructor to create exception from message and cause. + * + * @param message the detail of exception in string + * @param cause underlying cause of the error + */ + public PcepTunnelAttributeException(final String message, final Throwable cause) { + super(message, cause); + } + + /** + * Constructor to create exception from message. + * + * @param message the detail of exception in string + */ + public PcepTunnelAttributeException(final String message) { + super(message); + } + + /** + * Constructor to create exception from cause. + * + * @param cause underlying cause of the error + */ + public PcepTunnelAttributeException(final Throwable cause) { + super(cause); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/exceptions/package-info.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/exceptions/package-info.java new file mode 100644 index 00000000..44d09f0d --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/exceptions/package-info.java @@ -0,0 +1,20 @@ +/* + * 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. + */ + +/** + * PCEP custom exceptions. + */ +package org.onosproject.pcepio.exceptions; diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcInitiatedLspRequest.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcInitiatedLspRequest.java new file mode 100755 index 00000000..6a2fdc88 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcInitiatedLspRequest.java @@ -0,0 +1,185 @@ +/* + * 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; + +import org.onosproject.pcepio.exceptions.PcepParseException; + +/** + * Abstraction of an entity Provides PcInitiatedLspRequest for PCEP Initiate message. + * Reference : PCE initiated tunnel setup draft-ietf-pce-pce-initiated-lsp-03. + */ +public interface PcInitiatedLspRequest { + + /** + * Returns object of PcepSrpObject. + * + * @return srpObject PCEP SRP object + */ + PcepSrpObject getSrpObject(); + + /** + * Returns object of PcepLspObject. + * + * @return lspObject PCEP LSP object + */ + PcepLspObject getLspObject(); + + /** + * Returns object of PcepEndPointsObject. + * + * @return endPointsObject PCEP EndPoints object + */ + PcepEndPointsObject getEndPointsObject(); + + /** + * Returns object of PcepEroObject. + * + * @return eroObject PCEP ERO object + */ + PcepEroObject getEroObject(); + + /** + * Returns object of PcepAttribute. + * + * @return pcepAttribute PCEP Attributes + */ + PcepAttribute getPcepAttribute(); + + /** + * Sets PcepSrpObject. + * + * @param srpobj PCEP SRP object + */ + void setSrpObject(PcepSrpObject srpobj); + + /** + * Sets PcepLspObject. + * + * @param lspObject PCEP LSP object + */ + void setLspObject(PcepLspObject lspObject); + + /** + * Sets PcepEndPointsObject. + * + * @param endPointsObject PCEP EndPoints object + */ + void setEndPointsObject(PcepEndPointsObject endPointsObject); + + /** + * Sets PcepEroObject. + * + * @param eroObject PCEP ERO object + */ + void setEroObject(PcepEroObject eroObject); + + /** + * Sets PcepAttribute. + * + * @param pcepAttribute PCEP Attributes + */ + void setPcepAttribute(PcepAttribute pcepAttribute); + + /** + * Builder interface with get and set functions to build PcInitiatedLspRequest. + */ + interface Builder { + + /** + * Builds PcInitiatedLspRequest. + * + * @return PcInitiatedLspRequest + * @throws PcepParseException when mandatory object is not set + */ + PcInitiatedLspRequest build() throws PcepParseException; + + /** + * Returns object of PcepSrpObject. + * + * @return srpObject + */ + PcepSrpObject getSrpObject(); + + /** + * Returns object of PcepLspObject. + * + * @return lspObject + */ + PcepLspObject getLspObject(); + + /** + * Returns object of PcepEndPointsObject. + * + * @return endPointsObject + */ + PcepEndPointsObject getEndPointsObject(); + + /** + * Returns object of PcepEroObject. + * + * @return eroObject + */ + PcepEroObject getEroObject(); + + /** + * Returns object of PcepAttribute. + * + * @return pcepAttribute + */ + PcepAttribute getPcepAttribute(); + + /** + * Sets PcepSrpObject. + * + * @param srpobj PCEP SRP Object + * @return builder by setting PcepSrpObject + */ + Builder setSrpObject(PcepSrpObject srpobj); + + /** + * Sets PcepLspObject. + * + * @param lspObject PCEP LSP Object + * @return builder by setting PcepLspObject + */ + Builder setLspObject(PcepLspObject lspObject); + + /** + * Sets PcepEndPointsObject. + * + * @param endPointsObject EndPoints Object + * @return builder by setting PcepEndPointsObject + */ + Builder setEndPointsObject(PcepEndPointsObject endPointsObject); + + /** + * Sets PcepEroObject. + * + * @param eroObject PCEP ERO Object + * @return builder by setting PcepEroObject + */ + Builder setEroObject(PcepEroObject eroObject); + + /** + * Sets PcepAttribute. + * + * @param pcepAttribute PCEP Attributes + * @return builder by setting PcepAttribute + */ + Builder setPcepAttribute(PcepAttribute pcepAttribute); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepAttribute.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepAttribute.java new file mode 100644 index 00000000..122b943f --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepAttribute.java @@ -0,0 +1,166 @@ +/* + * 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; + +import java.util.LinkedList; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.pcepio.exceptions.PcepParseException; + +/** + * Abstraction of an entity which Provides List of PCEP Attributes. + */ +public interface PcepAttribute { + + /** + * writes lspa , bandwidth , Metriclist and Iro objects to the channel. + * + * @param bb of type channel buffer. + * @return object length index. + * @throws PcepParseException while writing objects to channel buffer + */ + int write(ChannelBuffer bb) throws PcepParseException; + + /** + * Returns PcepLspaObject. + * + * @return LspaObject + */ + PcepLspaObject getLspaObject(); + + /** + * Returns PcepBandwidthObject. + * + * @return BandwidthObject + */ + PcepBandwidthObject getBandwidthObject(); + + /** + * Returns PcepIroObject. + * + * @return iroObject + */ + PcepIroObject getIroObject(); + + /** + * Sets the PcepBandwidthObject. + * + * @param bandwidthObject bandwidth object + */ + void setBandwidthObject(PcepBandwidthObject bandwidthObject); + + /** + * Sets the PcepLspaObject. + * + * @param lspaObject lspa object + */ + void setLspaObject(PcepLspaObject lspaObject); + + /** + * Sets the PcepIroObject. + * + * @param iroObject iro object + */ + void setIroObject(PcepIroObject iroObject); + + /** + * Returns PcepMetricObject List. + * + * @return list of metric objects + */ + LinkedList<PcepMetricObject> getMetricObjectList(); + + /** + * Sets PcepMetricObject List. + * + * @param llMetricList list of metric objects + */ + void setMetricObjectList(LinkedList<PcepMetricObject> llMetricList); + + /** + * Builder interface with get and set functions to build PcepAttribute. + */ + interface Builder { + + /** + * Builds PcepAttribute. + * + * @return PcepAttribute + */ + PcepAttribute build(); + + /** + * Returns PcepLspaObject. + * + * @return LspaObject + */ + PcepLspaObject getLspaObject(); + + /** + * Returns PcepBandwidthObject. + * + * @return BandwidthObject + */ + PcepBandwidthObject getBandwidthObject(); + + /** + * Returns PcepIroObject. + * + * @return iroObject + */ + PcepIroObject getIroObject(); + + /** + * Sets the PcepBandwidthObject. + * + * @param bandwidthObject bandwidth object + * @return Builder object for PcepAttrubute + */ + Builder setBandwidthObject(PcepBandwidthObject bandwidthObject); + + /** + * Sets the PcepLspaObject. + * + * @param lspaObject lspa object + * @return Builder object for PcepAttrubute + */ + Builder setLspaObject(PcepLspaObject lspaObject); + + /** + * Sets the PcepIroObject. + * + * @param iroObject iro object + * @return Builder object for PcepAttrubute + */ + Builder setIroObject(PcepIroObject iroObject); + + /** + * Returns PcepMetricObject List. + * + * @return list of metric objects + */ + LinkedList<PcepMetricObject> getMetricObjectList(); + + /** + * Sets PcepMetricObject List. + * + * @param llMetricList list of metric objects + * @return Builder object for PcepAttrubute + */ + Builder setMetricObjectList(LinkedList<PcepMetricObject> llMetricList); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepBandwidthObject.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepBandwidthObject.java new file mode 100755 index 00000000..58d05821 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepBandwidthObject.java @@ -0,0 +1,109 @@ +/* + * 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; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.pcepio.exceptions.PcepParseException; +import org.onosproject.pcepio.types.PcepObjectHeader; + +/** + * Abstraction of an entity providing PCEP Bandwidth Object. + */ +public interface PcepBandwidthObject { + + /** + * Returns bandwidth value. + * + * @return bandwidth value + */ + int getBandwidth(); + + /** + * Sets bandwidth with specified value. + * + * @param iBandwidth Bandwidth's value + */ + void setBandwidth(int iBandwidth); + + /** + * Writes the BandwidthObject into channel buffer. + * + * @param bb channel buffer + * @return Returns the writerIndex of this buffer + * @throws PcepParseException if bandwidth object header fails to write in channel buffer + */ + int write(ChannelBuffer bb) throws PcepParseException; + + /** + * Builder interface with get and set functions to build bandwidth object. + */ + interface Builder { + + /** + * Builds BandwidthObject. + * + * @return BandwidthObject + * @throws PcepParseException if build fails while creating PcepBandwidthObject + */ + PcepBandwidthObject build() throws PcepParseException; + + /** + * Returns bandwidth object header. + * + * @return bandwidth object header + */ + PcepObjectHeader getBandwidthObjHeader(); + + /** + * Sets bandwidth object header and returns its builder. + * + * @param obj Bandwidth object header + * @return Builder by setting Bandwidth object header + */ + Builder setBandwidthObjHeader(PcepObjectHeader obj); + + /** + * Returns bandwidth value. + * + * @return bandwidth + */ + int getBandwidth(); + + /** + * Sets bandwidth value and return its builder. + * + * @param iBandwidth bandwidth value + * @return Builder by setting bandwidth + */ + Builder setBandwidth(int iBandwidth); + + /** + * Sets P flag in Bandwidth object header and returns its builder. + * + * @param value boolean value to set P flag + * @return Builder by setting P flag + */ + Builder setPFlag(boolean value); + + /** + * Sets I flag in Bandwidth object header and returns its builder. + * + * @param value boolean value to set I flag + * @return Builder by setting I flag + */ + Builder setIFlag(boolean value); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepCloseMsg.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepCloseMsg.java new file mode 100644 index 00000000..00fad800 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepCloseMsg.java @@ -0,0 +1,143 @@ +/* + * 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; + +import java.util.LinkedList; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.pcepio.exceptions.PcepParseException; +import org.onosproject.pcepio.types.PcepObjectHeader; +import org.onosproject.pcepio.types.PcepValueType; + +/** + * Abstraction of an entity providing PCEP Close Message. + */ +public interface PcepCloseMsg extends PcepObject, PcepMessage { + + @Override + PcepVersion getVersion(); + + @Override + PcepType getType(); + + /** + * Returns reason field in Close message. + * + * @return reason field + */ + byte getReason(); + + /** + * Sets reason field in Close message with specified value. + * + * @param value of Reason field + */ + void setReason(byte value); + + /** + * Returns LinkedList of Optional Tlv in Close Message. + * + * @return list of optional tlv + */ + LinkedList<PcepValueType> getOptionalTlv(); + + /** + * Sets LinkedList of Optional Tlvs in Close Message. + * + * @param llOptionalTlv LinkedList of type PcepValueType + */ + void setOptionalTlv(LinkedList<PcepValueType> llOptionalTlv); + + @Override + void writeTo(ChannelBuffer channelBuffer) throws PcepParseException; + + /** + * Builder interface with get and set functions to build Close message. + */ + interface Builder extends PcepMessage.Builder { + + @Override + PcepCloseMsg build(); + + @Override + PcepVersion getVersion(); + + @Override + PcepType getType(); + + /** + * Returns Close Object header. + * + * @return Close Object header + */ + PcepObjectHeader getCloseObjHeader(); + + /** + * Sets close object header and returns its builder. + * + * @param obj close object header + * @return Builder by setting Close object header + */ + Builder setCloseObjHeader(PcepObjectHeader obj); + + /** + * Returns reason field in Close message. + * + * @return reason field in Close message + */ + byte getReason(); + + /** + * Sets reason field and return its builder. + * + * @param value of Reason field + * @return builder by setting reason field + */ + Builder setReason(byte value); + + /** + * Returns LinkedList of Optional Tlvs. + * + * @return list of optional tlv + */ + LinkedList<PcepValueType> getOptionalTlv(); + + /** + * Sets LinkedList of Optional Tlvs in Close Message. + * + * @param llOptionalTlv list of optional tlv + * @return Builder by setting Optional Tlvs + */ + Builder setOptionalTlv(LinkedList<PcepValueType> llOptionalTlv); + + /** + * Sets P flag in Close object header and returns its builder. + * + * @param value boolean value to set P flag + * @return Builder by setting P flag + */ + Builder setPFlag(boolean value); + + /** + * Sets I flag in Close object header and returns its builder. + * + * @param value boolean value to set I flag + * @return Builder by setting I flag + */ + Builder setIFlag(boolean value); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepEndPointsObject.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepEndPointsObject.java new file mode 100755 index 00000000..92d43874 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepEndPointsObject.java @@ -0,0 +1,139 @@ +/* + * 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; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.pcepio.exceptions.PcepParseException; +import org.onosproject.pcepio.types.PcepObjectHeader; + +/** + * Abstraction of an entity providing PCEP End Points Object. + */ +public interface PcepEndPointsObject { + + /** + * Returns Source IpAddress from End Points Object. + * + * @return Source IpAddress from End Points Object + */ + int getSourceIpAddress(); + + /** + * Sets Source IpAddress in End Points Object. + * + * @param sourceIpAddress Source IP Address + */ + void setSourceIpAddress(int sourceIpAddress); + + /** + * Returns Destination IpAddress from End Points Object. + * + * @return Destination IpAddress from End Points Object + */ + int getDestIpAddress(); + + /** + * Sets Destination IpAddress in End Points Object. + * + * @param destIpAddress Destination IP Address + */ + void setDestIpAddress(int destIpAddress); + + /** + * Writes the EndPointsObject into channel buffer. + * + * @param bb channel buffer + * @return Returns the writerIndex of this buffer + * @throws PcepParseException while writing EndPointObject into ChannelBuffer + */ + int write(ChannelBuffer bb) throws PcepParseException; + + /** + * Builder interface with get and set functions to build EndPoints object. + */ + interface Builder { + + /** + * Builds End Points Object. + * + * @return End Points Object + * @throws PcepParseException while building EndPointObject + */ + PcepEndPointsObject build() throws PcepParseException; + + /** + * Returns End Points Object header. + * + * @return End Points Object header + */ + PcepObjectHeader getEndPointsObjHeader(); + + /** + * Sets End Points Object header and returns its builder. + * + * @param obj End Points Object header + * @return Builder by setting End Points Object header + */ + Builder setEndPointsObjHeader(PcepObjectHeader obj); + + /** + * Returns Source IpAddress from End Points Object. + * + * @return Source IpAddress from End Points Object + */ + int getSourceIpAddress(); + + /** + * Sets Source IpAddress in End Points Object and returns builder. + * + * @param sourceIpAddress Source IP Address + * @return Builder by setting Source IpAddress in End Points Object + */ + Builder setSourceIpAddress(int sourceIpAddress); + + /** + * Returns Destination IpAddress from End Points Object. + * + * @return Destination IpAddress from End Points Object + */ + int getDestIpAddress(); + + /** + * Sets Destination IpAddress in End Points Object. + * + * @param destIpAddress Destination IP Address + * @return Builder by setting Destination IpAddress in End Points Object + */ + Builder setDestIpAddress(int destIpAddress); + + /** + * Sets P flag in Bandwidth object header and returns its builder. + * + * @param value boolean value to set P flag + * @return Builder by setting P flag + */ + Builder setPFlag(boolean value); + + /** + * Sets I flag in Bandwidth object header and returns its builder. + * + * @param value boolean value to set I flag + * @return Builder by setting I flag + */ + Builder setIFlag(boolean value); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepEroObject.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepEroObject.java new file mode 100755 index 00000000..3af6b759 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepEroObject.java @@ -0,0 +1,112 @@ +/* + * 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; + +import java.util.LinkedList; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.pcepio.exceptions.PcepParseException; +import org.onosproject.pcepio.types.PcepObjectHeader; +import org.onosproject.pcepio.types.PcepValueType; + +/** + * Abstraction of an entity providing PCEP ERO Object. + */ +public interface PcepEroObject { + + /** + * Return LinkedList of SubObjects of ERO Object. + * + * @return list of subobjects + */ + LinkedList<PcepValueType> getSubObjects(); + + /** + * Sets LinkedList of SubObjects in ERO Object. + * + * @param llSubObjects list of subobjects + */ + void setSubObjects(LinkedList<PcepValueType> llSubObjects); + + /** + * Writes the ERO Object into channel buffer. + * + * @param bb channel buffer + * @return Returns the writerIndex of this buffer + * @throws PcepParseException while writing ERO Object into ChannelBuffer + */ + int write(ChannelBuffer bb) throws PcepParseException; + + /** + * Builder interface with get and set functions to build ERO object. + */ + interface Builder { + + /** + * Builds ERO Object. + * + * @return ERO Object + */ + PcepEroObject build(); + + /** + * Returns ERO Object Header. + * + * @return ERO Object Header + */ + PcepObjectHeader getEroObjHeader(); + + /** + * Sets ERO Object header and returns its builder. + * + * @param obj ERO Object header + * @return Builder by setting ERO Object header + */ + Builder setEroObjHeader(PcepObjectHeader obj); + + /** + * Returns LinkedList of SubObjects in ERO Objects. + * + * @return list of subobjects + */ + LinkedList<PcepValueType> getSubObjects(); + + /** + * Sets LinkedList of SubObjects and returns its builder. + * + * @param llSubObjects list of SubObjects + * @return Builder by setting list of SubObjects + */ + Builder setSubObjects(LinkedList<PcepValueType> llSubObjects); + + /** + * Sets P flag in ERO object header and returns its builder. + * + * @param value boolean value to set P flag + * @return Builder by setting P flag + */ + Builder setPFlag(boolean value); + + /** + * Sets I flag in ERO object header and returns its builder. + * + * @param value boolean value to set I flag + * @return Builder by setting I flag + */ + Builder setIFlag(boolean value); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepError.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepError.java new file mode 100755 index 00000000..b61bfb9f --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepError.java @@ -0,0 +1,136 @@ +/* + * 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; + +import java.util.LinkedList; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.pcepio.exceptions.PcepParseException; + +/** + * Abstraction of an entity which provides PCEP error for PCEP error message. + */ +public interface PcepError { + + /** + * Returns the PcepRPObject List. + * + * @return list of type PcepRPObject + */ + LinkedList<PcepRPObject> getRPObjList(); + + /** + * Sets the RP Objects lists. + * + * @param llRPObjList list of type PcepRPObject + */ + void setRPObjList(LinkedList<PcepRPObject> llRPObjList); + + /** + * Returns the PcepTEObject List. + * + * @return list of type PcepTEObject + */ + LinkedList<PcepTEObject> getTEObjList(); + + /** + * Sets the TE Objects lists. + * + * @param llTEObjList list of type PcepTEObject + */ + void setTEObjList(LinkedList<PcepTEObject> llTEObjList); + + /** + * Returns the PcepErrorObject. + * + * @return list of type PcepErrorObject + */ + LinkedList<PcepErrorObject> getErrorObjList(); + + /** + * Sets the Error Objects lists. + * + * @param llErrorObjList list of type PcepErrorObject + */ + void setErrorObjList(LinkedList<PcepErrorObject> llErrorObjList); + + /** + * Writes the byte stream of PCEP error to the channel buffer. + * + * @param bb of type channel buffer + * @return object length index + * @throws PcepParseException while writing Error part into ChannelBuffer + */ + int write(ChannelBuffer bb) throws PcepParseException; + + /** + * Builder interface with get and set functions to build PcepError. + */ + interface Builder { + + /** + * Builds PcepError Object. + * + * @return PcepError Object + */ + PcepError build(); + + /** + * Returns the PcepRPObject. + * + * @return list of type PcepRPObject + */ + LinkedList<PcepRPObject> getRPObjList(); + + /** + * Sets RP Object lists and returns its builder. + * + * @param llRPObjList list of type PcepRpObject + * @return builder by setting Linked list of RP Object + */ + Builder setRPObjList(LinkedList<PcepRPObject> llRPObjList); + + /** + * Returns the PcepTEObject. + * + * @return llTEObjList of type PcepTEObject + */ + LinkedList<PcepTEObject> getTEObjList(); + + /** + * Sets TE Object lists and returns its builder. + * + * @param llTEObjList list of type PcepTEObject + * @return builder by setting list of type PcepTEObject + */ + Builder setTEObjList(LinkedList<PcepTEObject> llTEObjList); + + /** + * Returns the PcepErrorObject. + * + * @return list of type PcepErrorObject + */ + LinkedList<PcepErrorObject> getErrorObjList(); + + /** + * Sets Error Object lists and returns its builder. + * + * @param llErrorObjList list of type PcepErrorObject + * @return builder by setting list of type PcepErrorObject + */ + Builder setErrorObjList(LinkedList<PcepErrorObject> llErrorObjList); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepErrorInfo.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepErrorInfo.java new file mode 100755 index 00000000..0c625a03 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepErrorInfo.java @@ -0,0 +1,93 @@ +/* + * 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; + +import java.util.LinkedList; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.pcepio.exceptions.PcepParseException; + +/** + * Abstraction of an entity which provides PCEP Error Info. + * Reference :PCEP Extension for Transporting TE Data draft-dhodylee-pce-pcep-te-data-extn-02. + */ +public interface PcepErrorInfo { + + /** + * Returns whether error info list is present or not. + * + * @return true if error info present, false otherwise + */ + boolean isErrorInfoPresent(); + + /** + * Reads from channel buffer for TE and RP objects. + * + * @param bb of channel buffer + * @throws PcepParseException while parsing Error info part. + */ + void read(ChannelBuffer bb) throws PcepParseException; + + /** + * Writes byte stream of PCEP error info to channel buffer. + * + * @param bb of type channel buffer + * @throws PcepParseException while writing Error info part into Channel Buffer. + */ + void write(ChannelBuffer bb) throws PcepParseException; + + /** + * Returns Error Value in PCEP-ERROR Object. + * + * @return list of Error Value in PCEP-ERROR Object + */ + LinkedList<Integer> getErrorValue(); + + /** + * Returns Error Type in PCEP-ERROR Object. + * + * @return list of Error Type in PCEP-ERROR Object + */ + LinkedList<Integer> getErrorType(); + + /** + * Builder interface with get and set functions to build ErrorInfo. + */ + interface Builder { + + /** + * Builds ErrorInfo Object. + * + * @return ErrorInfo Object. + */ + PcepErrorInfo build(); + + /** + * Returns list of PcepError. + * + * @return list of PcepError + */ + LinkedList<PcepError> getPcepErrorList(); + + /** + * Sets PcepError lists and returns its builder. + * + * @param llPcepErrorList list of PcepError + * @return builder by setting list of PcepError. + */ + Builder setPcepErrorList(LinkedList<PcepError> llPcepErrorList); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepErrorMsg.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepErrorMsg.java new file mode 100644 index 00000000..ff06885d --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepErrorMsg.java @@ -0,0 +1,109 @@ +/* + * 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; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.pcepio.exceptions.PcepParseException; +import org.onosproject.pcepio.types.ErrorObjListWithOpen; + +/** + * Abstraction of an entity providing PCEP Error Message. + */ +public interface PcepErrorMsg extends PcepMessage { + + @Override + PcepVersion getVersion(); + + @Override + PcepType getType(); + + /** + * Returns Object of ErrorObjListWithOpen. + * + * @return Object of ErrorObjListWithOpen + */ + ErrorObjListWithOpen getErrorObjListWithOpen(); + + /** + * Sets errObjListWithOpen object. + * + * @param errObjListWithOpen error object List with open object + */ + void setErrorObjListWithOpen(ErrorObjListWithOpen errObjListWithOpen); + + /** + * Returns Object of PcepErrorInfo. + * + * @return Object of PcepErrorInfo + */ + PcepErrorInfo getPcepErrorInfo(); + + /** + * Sets errInfo Object. + * + * @param errInfo error information + */ + void setPcepErrorInfo(PcepErrorInfo errInfo); + + @Override + void writeTo(ChannelBuffer channelBuffer) throws PcepParseException; + + /** + * Builder interface with get and set functions to build PCEP Error message. + */ + interface Builder extends PcepMessage.Builder { + + @Override + PcepErrorMsg build(); + + @Override + PcepVersion getVersion(); + + @Override + PcepType getType(); + + /** + * Returns Object of ErrorObjListWithOpen. + * + * @return Object of ErrorObjListWithOpen + */ + ErrorObjListWithOpen getErrorObjListWithOpen(); + + /** + * Sets errObjListWithOpen object. + * + * @param errObjListWithOpen error object with open object + * @return builder by setting Object of ErrorObjListWithOpen + */ + Builder setErrorObjListWithOpen(ErrorObjListWithOpen errObjListWithOpen); + + /** + * Returns Object of PcepErrorInfo. + * + * @return Object of PcepErrorInfo + */ + PcepErrorInfo getPcepErrorInfo(); + + /** + * Sets errInfo Object. + * + * @param errInfo error information + * @return builder by getting Object of PcepErrorInfo + */ + Builder setPcepErrorInfo(PcepErrorInfo errInfo); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepErrorObject.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepErrorObject.java new file mode 100644 index 00000000..16374d5b --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepErrorObject.java @@ -0,0 +1,169 @@ +/* + * 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; + +import java.util.LinkedList; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.pcepio.exceptions.PcepParseException; +import org.onosproject.pcepio.types.PcepObjectHeader; +import org.onosproject.pcepio.types.PcepValueType; + +/** + * Abstraction of an entity providing PCEP Error Object. + */ +public interface PcepErrorObject { + + /** + * Returns Error Type in Error Object. + * + * @return Error Type in Error Object + */ + int getErrorType(); + + /** + * Sets Error Type in Error Object. + * + * @param value Error Type + */ + void setErrorType(byte value); + + /** + * Returns Error Value in Error Object. + * + * @return Error Value + */ + byte getErrorValue(); + + /** + * Sets Error Value in Error Object. + * + * @param value Error Value + */ + void setErrorValue(byte value); + + /** + * Returns Optional Tlvs in Error Object. + * + * @return list of Optional Tlvs in Error Object + */ + LinkedList<PcepValueType> getOptionalTlv(); + + /** + * Sets Optional Tlvs in Error Object. + * + * @param llOptionalTlv list of Optional Tlvs + */ + void setOptionalTlv(LinkedList<PcepValueType> llOptionalTlv); + + /** + * Writes the Error Object into channel buffer. + * + * @param bb channel buffer + * @return Returns the writerIndex of this buffer + * @throws PcepParseException while writing Error Object into ChannelBuffer + */ + int write(ChannelBuffer bb) throws PcepParseException; + + /** + * Builder interface with get and set functions to build Error object. + */ + interface Builder { + + /** + * Builds Error Object. + * + * @return Error Object. + */ + PcepErrorObject build(); + + /** + * Returns Error Object header. + * + * @return Error Object header + */ + PcepObjectHeader getErrorObjHeader(); + + /** + * Sets Error Object header and returns its Builder. + * + * @param obj Error Object header + * @return Builder by setting Error Object header + */ + Builder setErrorObjHeader(PcepObjectHeader obj); + + /** + * Returns Error Type in Error Object. + * + * @return Error Type in Error Object + */ + int getErrorType(); + + /** + * Sets Error Type and returns its builder. + * + * @param value of Error-Type field + * @return builder by setting Error Type field. + */ + Builder setErrorType(byte value); + + /** + * Returns Error Value in Error Object. + * + * @return Error Value + */ + byte getErrorValue(); + + /** + * Sets Error Value and returns its builder. + * + * @param value of Error-Value field + * @return Builder by setting Error Value field. + */ + Builder setErrorValue(byte value); + + /** + * Returns list of Optional Tlvs of Error Object. + * + * @return list of Optional Tlvs of Error Object + */ + LinkedList<PcepValueType> getOptionalTlv(); + + /** + * Sets Optional Tlvs of Error Object and returns its Builder. + * + * @param llOptionalTlv Optional Tlvs of Error Object + * @return Builder by setting Optional Tlvs. + */ + Builder setOptionalTlv(LinkedList<PcepValueType> llOptionalTlv); + + /** + * Sets P flag in Error object header and returns its builder. + * + * @param value boolean value to set P flag + * @return Builder by setting P flag + */ + Builder setPFlag(boolean value); + + /** + * Sets I flag in Error object header and returns its builder. + * + * @param value boolean value to set I flag + * @return Builder by setting I flag + */ + Builder setIFlag(boolean value); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepFactories.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepFactories.java new file mode 100644 index 00000000..85416f98 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepFactories.java @@ -0,0 +1,98 @@ +/* + * 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; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.pcepio.exceptions.PcepParseException; +import org.onosproject.pcepio.protocol.ver1.PcepFactoryVer1; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +/** + * Abstraction to provide the version for PCEP. + */ +public final class PcepFactories { + + protected static final Logger log = LoggerFactory.getLogger(PcepFactories.class); + + private static final GenericReader GENERIC_READER = new GenericReader(); + + public static final byte SHIFT_FLAG = 5; + + private PcepFactories() { + } + + /** + * Returns the instance of PCEP Version. + * + * @param version PCEP version + * @return PCEP version + */ + public static PcepFactory getFactory(PcepVersion version) { + switch (version) { + case PCEP_1: + return PcepFactoryVer1.INSTANCE; + default: + throw new IllegalArgumentException("Unknown version: " + version); + } + } + + private static class GenericReader implements PcepMessageReader<PcepMessage> { + + @Override + public PcepMessage readFrom(ChannelBuffer bb) throws PcepParseException { + + if (!bb.readable()) { + throw new PcepParseException("Empty message received"); + } + + /* + * 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 + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + * | Ver | Flags | | + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + * + * Currently Version 1 is supported + * Currently no flags are used, it is all ignored + */ + + byte packetVersion = bb.getByte(bb.readerIndex()); + packetVersion = (byte) (packetVersion >> SHIFT_FLAG); + PcepFactory factory; + + switch (packetVersion) { + + case 1: + factory = org.onosproject.pcepio.protocol.ver1.PcepFactoryVer1.INSTANCE; + break; + default: + throw new PcepParseException("Unknown Packet version: " + packetVersion); + } + return factory.getReader().readFrom(bb); + } + } + + /** + * Returns GENERIC_READER. + * + * @return GENERIC_READER + */ + public static PcepMessageReader<PcepMessage> getGenericReader() { + return GENERIC_READER; + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepFactory.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepFactory.java new file mode 100755 index 00000000..1a31e0a3 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepFactory.java @@ -0,0 +1,255 @@ +/* + * 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; + +/** + * Abstraction of an Message factory providing Builder functions to PCEP Messages and Objects. + * + */ +public interface PcepFactory { + + /** + * To get Builder Object for Open Message. + * + * @return Builder Object for Open Message + */ + PcepOpenMsg.Builder buildOpenMsg(); + + /** + * To get Builder Object for Open Object. + * + * @return Builder Object for Open Object + */ + PcepOpenObject.Builder buildOpenObject(); + + /** + * To get Builder Object for Keepalive Message. + * + * @return Builder Object for Keepalive Message + */ + PcepKeepaliveMsg.Builder buildKeepaliveMsg(); + + /** + * To get Builder Object for Close Message. + * + * @return Builder Object for Close Message + */ + PcepCloseMsg.Builder buildCloseMsg(); + + /** + * To get Builder Object for Report Message. + * + * @return Builder Object for Report Message + */ + PcepReportMsg.Builder buildReportMsg(); + + /** + * To get Builder Object for Update Message. + * + * @return Builder Object for Update Message + */ + PcepUpdateMsg.Builder buildUpdateMsg(); + + /** + * To get Builder Object for Initiate Message. + * + * @return Builder Object for Initiate Message + */ + PcepInitiateMsg.Builder buildPcepInitiateMsg(); + + /** + * To get Builder Object for LSP Object. + * + * @return Builder Object for LSP Object + */ + PcepLspObject.Builder buildLspObject(); + + /** + * To get Builder Object for SRP Object. + * + * @return Builder Object for SRP Object + */ + PcepSrpObject.Builder buildSrpObject(); + + /** + * To get Builder Object for EndPoints Object. + * + * @return Builder Object for EndPoints Object + */ + PcepEndPointsObject.Builder buildEndPointsObject(); + + /** + * To get Builder Object for ERO Object. + * + * @return Builder Object for ERO Object + */ + PcepEroObject.Builder buildEroObject(); + + /** + * To get Builder Object for RRO Object. + * + * @return Builder Object for RRO Object + */ + PcepRroObject.Builder buildRroObject(); + + /** + * To get Builder Object for LSPA Object. + * + * @return Builder Object for LSPA Object + */ + PcepLspaObject.Builder buildLspaObject(); + + /** + * To get Builder Object for IRO Object. + * + * @return Builder Object for IRO Object + */ + PcepIroObject.Builder buildIroObject(); + + /** + * To get Builder Object for METRIC Object. + * + * @return Builder Object for METRIC Object + */ + PcepMetricObject.Builder buildMetricObject(); + + /** + * To get Builder Object for Bandwidth Object. + * + * @return Builder Object for Bandwidth Object + */ + PcepBandwidthObject.Builder buildBandwidthObject(); + + /** + * Returns PCEP Message Reader. + * + * @return PCEP Message Reader + */ + PcepMessageReader<PcepMessage> getReader(); + + /** + * Returns PCEP version. + * + * @return PCEP version + */ + PcepVersion getVersion(); + + /** + * Returns PcepStateReport. + * + * @return PcepStateReport + */ + PcepStateReport.Builder buildPcepStateReport(); + + /** + * Returns PcepUpdateRequest. + * + * @return PcepUpdateRequest + */ + PcepUpdateRequest.Builder buildPcepUpdateRequest(); + + /** + * Returns PcInitiatedLspRequest. + * + * @return PcInitiatedLspRequest + */ + PcInitiatedLspRequest.Builder buildPcInitiatedLspRequest(); + + /** + * Returns PcepMsgPath. + * + * @return PcepMsgPath + */ + PcepMsgPath.Builder buildPcepMsgPath(); + + /** + * Return PcepAttribute list. + * + * @return PcepAttribute + */ + PcepAttribute.Builder buildPcepAttribute(); + + /** + * To get Builder Object for LabelUpdate message. + * + * @return Builder Object for LabelUpdate message + */ + PcepLabelUpdateMsg.Builder buildPcepLabelUpdateMsg(); + + /** + * To get Builder Object for PcepLabelUpdate Object. + * + * @return Builder Object for PcepLabelUpdate Object + */ + PcepLabelUpdate.Builder buildPcepLabelUpdateObject(); + + /** + * To get Builder Object for PcepLabel Object. + * + * @return Builder Object for PcepLabel Object + */ + PcepLabelObject.Builder buildLabelObject(); + + /** + * To get Builder Object for Error Message. + * + * @return Builder Object for Error Message + */ + PcepErrorMsg.Builder buildPcepErrorMsg(); + + /** + * To get Builder Object for Error Object. + * + * @return Builder Object for Error Object + */ + PcepErrorObject.Builder buildPcepErrorObject(); + + /** + * To get Builder Object for FecIpv4Adjacency. + * + * @return Builder Object for FecIpv4Adjacency + */ + PcepFecObjectIPv4Adjacency.Builder buildFecIpv4Adjacency(); + + /** + * To get Builder Object for ErrorInfo. + * + * @return Builder Object for ErrorInfo + */ + PcepErrorInfo.Builder buildPcepErrorInfo(); + + /** + * To get Builder Object for PcepError. + * + * @return Builder Object for PcepError + */ + PcepError.Builder buildPcepError(); + + /** + * To get Builder Object for PcepLabelRangeObject. + * + * @return Builder Object for PcepLabelRangeObject + */ + PcepLabelRangeObject.Builder buildPcepLabelRangeObject(); + + /** + * To get Builder Object for PcepLabelRangeResvMsg. + * + * @return Builder Object for PcepLabelRangeResvMsg + */ + PcepLabelRangeResvMsg.Builder buildPcepLabelRangeResvMsg(); +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepFecObject.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepFecObject.java new file mode 100755 index 00000000..2df7cc9c --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepFecObject.java @@ -0,0 +1,49 @@ +/* + * 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; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.pcepio.exceptions.PcepParseException; + +/** + * Abstraction of an entity providing PCEP FEC Object. + */ +public interface PcepFecObject { + + /** + * Returns PCEP Version of FEC Object. + * + * @return PCEP Version of FEC Object + */ + PcepVersion getVersion(); + + /** + * Returns FEC Object type. + * + * @return FEC Object type + */ + int getType(); + + /** + * Writes the FEC into channel buffer. + * + * @param bb channel buffer + * @return Returns the writerIndex of this buffer + * @throws PcepParseException while writing FEC Object into Channel Buffer. + */ + int write(ChannelBuffer bb) throws PcepParseException; +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepFecObjectIPv4.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepFecObjectIPv4.java new file mode 100755 index 00000000..5ed4e1e3 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepFecObjectIPv4.java @@ -0,0 +1,104 @@ +/* + * 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; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.pcepio.exceptions.PcepParseException; +import org.onosproject.pcepio.types.PcepObjectHeader; + +/** + * Abstraction of an entity providing PCEP FEC Object of Type 1 IPv4 Node ID. + */ +public interface PcepFecObjectIPv4 extends PcepFecObject { + + /** + * Returns NodeID of FEC Object. + * + * @return NodeID of FEC Object + */ + int getNodeID(); + + /** + * Sets NodeID with specified value. + * + * @param value node id + */ + void setNodeID(int value); + + @Override + int write(ChannelBuffer bb) throws PcepParseException; + + /** + * Builder interface with get and set functions to build FEC object. + */ + interface Builder { + + /** + * Builds FEC Object IPv4. + * + * @return FEC Object IPv4 + * @throws PcepParseException while creating FEC IPv4 Object. + */ + PcepFecObjectIPv4 build() throws PcepParseException; + + /** + * Returns FEC Object IPv4 header. + * + * @return FEC Object IPv4 header + */ + PcepObjectHeader getFecIpv4ObjHeader(); + + /** + * Sets FEC Object IPv4 header and returns its builder. + * + * @param obj FEC Object IPv4 header + * @return Builder by setting FEC Object IPv4 header + */ + Builder setFecIpv4ObjHeader(PcepObjectHeader obj); + + /** + * Returns NodeID of FEC Object. + * + * @return NodeID of FEC Object + */ + int getNodeID(); + + /** + * Sets NodeID and returns its builder. + * + * @param value node id + * @return builder by setting NodeID + */ + Builder setNodeID(int value); + + /** + * Sets P flag in FEC object header and returns its builder. + * + * @param value boolean value to set P flag + * @return Builder by setting P flag + */ + Builder setPFlag(boolean value); + + /** + * Sets I flag in FEC object header and returns its builder. + * + * @param value boolean value to set I flag + * @return Builder by setting I flag + */ + Builder setIFlag(boolean value); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepFecObjectIPv4Adjacency.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepFecObjectIPv4Adjacency.java new file mode 100755 index 00000000..55205299 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepFecObjectIPv4Adjacency.java @@ -0,0 +1,133 @@ +/* + * 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; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.pcepio.exceptions.PcepParseException; +import org.onosproject.pcepio.types.PcepObjectHeader; + +/** + * Abstraction of an entity providing FEC Object of Type 3 IPv4 Adjacency. + */ +public interface PcepFecObjectIPv4Adjacency extends PcepFecObject { + + /** + * Returns Local IPv4Address of FEC Object. + * + * @return Local IPv4Address of FEC Object + */ + int getLocalIPv4Address(); + + /** + * Sets Local IPv4Address with specified value. + * + * @param value Local IPv4Address + */ + void seLocalIPv4Address(int value); + + /** + * Returns Remote IPv4Address of FEC Object. + * + * @return Remote IPv4Address of FEC Object + */ + int getRemoteIPv4Address(); + + /** + * Sets Remote IPv4Address with specified value. + * + * @param value Remote IPv4Address + */ + void seRemoteIPv4Address(int value); + + @Override + int write(ChannelBuffer bb) throws PcepParseException; + + /** + * Builder interface with get and set functions to build FEC object. + */ + interface Builder { + + /** + * Builds FEC Object IPv4 Adjacency. + * + * @return FEC Object IPv4 Adjacency + * @throws PcepParseException while building FEC IPv4 Adjacency object. + */ + PcepFecObjectIPv4Adjacency build() throws PcepParseException; + + /** + * Returns FEC Object IPv4 Adjacency header. + * + * @return FEC Object IPv4 Adjacency header + */ + PcepObjectHeader getFecIpv4AdjacencyObjHeader(); + + /** + * Sets FEC Object IPv4 Adjacency header and returns its builder. + * + * @param obj FEC Object IPv4 Adjacency header + * @return Builder by setting FEC Object IPv4 header + */ + Builder setFecIpv4AdjacencyObjHeader(PcepObjectHeader obj); + + /** + * Returns Local IPv4Address of FEC Object. + * + * @return Local IPv4Address of FEC Object + */ + int getLocalIPv4Address(); + + /** + * Sets Local IPv4Address and returns its builder. + * + * @param value Local IPv4Address + * @return Builder by setting Local IPv4Address + */ + Builder seLocalIPv4Address(int value); + + /** + * Sets Remote IPv4Address with specified value. + * + * @return Remote IPv4 Address + */ + int getRemoteIPv4Address(); + + /** + * Sets Remote IPv4Address and returns its builder. + * + * @param value Remote IPv4Address + * @return Builder by setting Remote IPv4Address + */ + Builder seRemoteIPv4Address(int value); + + /** + * Sets P flag in FEC object header and returns its builder. + * + * @param value boolean value to set P flag + * @return Builder by setting P flag + */ + Builder setPFlag(boolean value); + + /** + * Sets I flag in FEC object header and returns its builder. + * + * @param value boolean value to set I flag + * @return Builder by setting I flag + */ + Builder setIFlag(boolean value); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepFecObjectIPv4UnnumberedAdjacency.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepFecObjectIPv4UnnumberedAdjacency.java new file mode 100755 index 00000000..d240445e --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepFecObjectIPv4UnnumberedAdjacency.java @@ -0,0 +1,191 @@ +/* + * 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; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.pcepio.exceptions.PcepParseException; +import org.onosproject.pcepio.types.PcepObjectHeader; + +/** + * Abstraction of an entity providing PCEP FEC Object of Type is 5 Unnumbered Adjacency with IPv4 NodeIDs. + */ +public interface PcepFecObjectIPv4UnnumberedAdjacency extends PcepFecObject { + + /** + * Returns Local NodeID of FEC Object. + * + * @return Local NodeID of FEC Object + */ + int getLocalNodeID(); + + /** + * Sets Local NodeID with specified value. + * + * @param value Local NodeID + */ + void setLocalNodeID(int value); + + /** + * Returns Local InterfaceID of FEC Object. + * + * @return Local InterfaceID of FEC Object + */ + int getLocalInterfaceID(); + + /** + * Sets Local InterfaceID with specified value. + * + * @param value Local InterfaceID + */ + void setLocalInterfaceID(int value); + + /** + * Returns Remote NodeID of FEC Object. + * + * @return Remote NodeID of FEC Object + */ + int getRemoteNodeID(); + + /** + * Sets Remote NodeID with specified value. + * + * @param value Remote NodeID + */ + void setRemoteNodeID(int value); + + /** + * Returns Remote InterfaceID of FEC Object. + * + * @return Remote InterfaceID of FEC Object + */ + int getRemoteInterfaceID(); + + /** + * Sets Remote InterfaceID with specified value. + * + * @param value Remote InterfaceID + */ + void setRemoteInterfaceID(int value); + + @Override + int write(ChannelBuffer bb) throws PcepParseException; + + /** + * Builder interface with get and set functions to build bandwidth object. + */ + interface Builder { + + /** + * Builds FEC Unnumbered Adjacency with IPv4 Object. + * + * @return FEC Unnumbered Adjacency with IPv4 Object + * @throws PcepParseException when building FEC IPv4 Unnumbered Adjacency object. + */ + PcepFecObjectIPv4UnnumberedAdjacency build() throws PcepParseException; + + /** + * Returns FEC Unnumbered Adjacency with IPv4 header. + * + * @return FEC Unnumbered Adjacency with IPv4 header + */ + PcepObjectHeader getFecIpv4UnnumberedAdjacencyObjHeader(); + + /** + * Sets FEC Unnumbered Adjacency with IPv4 header and returns its builder. + * + * @param obj FEC Unnumbered Adjacency with IPv4 header + * @return Builder by setting FEC Unnumbered Adjacency with IPv4 header + */ + Builder setFecIpv4UnnumberedAdjacencyObjHeader(PcepObjectHeader obj); + + /** + * Returns Local NodeID of FEC Object. + * + * @return Local NodeID of FEC Object + */ + int getLocalNodeID(); + + /** + * Sets Local NodeID and returns its builder. + * + * @param value Local NodeID + * @return Builder by setting Local NodeID + */ + Builder setLocalNodeID(int value); + + /** + * Returns Local InterfaceID of FEC Object. + * + * @return Local InterfaceID of FEC Object + */ + int getLocalInterfaceID(); + + /** + * Sets Local InterfaceID and returns its builder. + * + * @param value Local InterfaceID + * @return Builder by setting Local InterfaceID + */ + Builder setLocalInterfaceID(int value); + + /** + * Returns Remote NodeID of FEC Object. + * + * @return Remote NodeID of FEC Object + */ + int getRemoteNodeID(); + + /** + * Sets Remote NodeID and returns its builder. + * + * @param value Remote NodeID + * @return Builder by setting Remote NodeID + */ + Builder setRemoteNodeID(int value); + + /** + * Returns Remote InterfaceID of FEC Object. + * + * @return Remote InterfaceID of FEC Object + */ + int getRemoteInterfaceID(); + + /** + * Sets Remote InterfaceID and returns its builder. + * + * @param value Remote InterfaceID + * @return Builder by setting Remote InterfaceID + */ + Builder setRemoteInterfaceID(int value); + + /** + * Sets P flag in FEC object header and returns its builder. + * + * @param value boolean value to set P flag + * @return Builder by setting P flag + */ + Builder setPFlag(boolean value); + + /** + * Sets I flag in FEC object header and returns its builder. + * + * @param value boolean value to set I flag + * @return Builder by setting I flag + */ + Builder setIFlag(boolean value); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepFecObjectIPv6.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepFecObjectIPv6.java new file mode 100755 index 00000000..1c29b76a --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepFecObjectIPv6.java @@ -0,0 +1,104 @@ +/* + * 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; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.pcepio.exceptions.PcepParseException; +import org.onosproject.pcepio.types.PcepObjectHeader; + +/** + * Abstraction of an entity providing FEC Object of Type is 2 IPv6 Node ID. + */ +public interface PcepFecObjectIPv6 extends PcepFecObject { + + /** + * Returns NodeID of FEC Object. + * + * @return NodeID of FEC Object + */ + byte[] getNodeID(); + + /** + * Sets NodeID with specified value. + * + * @param value node id + */ + void setNodeID(byte[] value); + + @Override + int write(ChannelBuffer bb) throws PcepParseException; + + /** + * Builder interface with get and set functions to build FEC object. + */ + interface Builder { + + /** + * Builds FEC Object IPv6. + * + * @return FEC Object IPv6 + * @throws PcepParseException while building FEC IPv6 Object. + */ + PcepFecObjectIPv6 build() throws PcepParseException; + + /** + * Returns FEC Object IPv6 header. + * + * @return FEC Object IPv6 header + */ + PcepObjectHeader getFecIpv6ObjHeader(); + + /** + * Sets FEC Object IPv6 header and returns its builder. + * + * @param obj FEC Object IPv6 header + * @return Builder by setting FEC Object IPv6 header + */ + Builder setFecIpv6ObjHeader(PcepObjectHeader obj); + + /** + * Returns NodeID of FEC Object. + * + * @return NodeID of FEC Object + */ + byte[] getNodeID(); + + /** + * Sets NodeID and returns its builder. + * + * @param value node id + * @return Builder by setting NodeID + */ + Builder setNodeID(byte[] value); + + /** + * Sets P flag in FEC object header and returns its builder. + * + * @param value boolean value to set P flag + * @return Builder by setting P flag + */ + Builder setPFlag(boolean value); + + /** + * Sets I flag in FEC object header and returns its builder. + * + * @param value boolean value to set I flag + * @return Builder by setting I flag + */ + Builder setIFlag(boolean value); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepFecObjectIPv6Adjacency.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepFecObjectIPv6Adjacency.java new file mode 100755 index 00000000..ef802780 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepFecObjectIPv6Adjacency.java @@ -0,0 +1,133 @@ +/* + * 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; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.pcepio.exceptions.PcepParseException; +import org.onosproject.pcepio.types.PcepObjectHeader; + +/** + * Abstraction of an entity providing FEC Object of Type is 4 IPv6 Adjacency. + */ +public interface PcepFecObjectIPv6Adjacency extends PcepFecObject { + + /** + * Returns Local IPv6Address of FEC Object. + * + * @return Local IPv6Address of FEC Object + */ + byte[] getLocalIPv6Address(); + + /** + * Sets Local IPv6Address with specified value. + * + * @param value Local IPv6Address + */ + void seLocalIPv6Address(byte[] value); + + /** + * Returns Remote IPv6Address of FEC Object. + * + * @return Remote IPv6Address of FEC Object + */ + byte[] getRemoteIPv6Address(); + + /** + * Sets Remote IPv6Address with specified value. + * + * @param value Remote IPv6Address + */ + void seRemoteIPv6Address(byte[] value); + + @Override + int write(ChannelBuffer bb) throws PcepParseException; + + /** + * Builder interface with get and set functions to build FEC object. + */ + interface Builder { + + /** + * Builds FEC Object IPv6 Adjacency. + * + * @return FEC Object IPv6 Adjacency + * @throws PcepParseException while building FEC IPv6 Adjacency object. + */ + PcepFecObjectIPv6Adjacency build() throws PcepParseException; + + /** + * Returns FEC Object IPv6 Adjacency header. + * + * @return FEC Object IPv6 Adjacency header + */ + PcepObjectHeader getFecIpv6AdjacencyObjHeader(); + + /** + * Sets FEC Object IPv6 Adjacency header and returns its builder. + * + * @param obj FEC Object IPv6 Adjacency header + * @return Builder by setting FEC Object IPv6 Adjacency header + */ + Builder setFecIpv6AdjacencyObjHeader(PcepObjectHeader obj); + + /** + * Returns Local IPv6Address of FEC Object. + * + * @return Local IPv6Address of FEC Object + */ + byte[] getLocalIPv6Address(); + + /** + * Sets Local IPv6Address and returns its builder. + * + * @param value Local IPv6Address + * @return Builder by setting Local IPv6Address + */ + Builder setLocalIPv6Address(byte[] value); + + /** + * Returns Remote IPv6Address of FEC Object. + * + * @return Remote IPv6Address of FEC Object + */ + byte[] getRemoteIPv6Address(); + + /** + * Sets Remote IPv6Address and returns its builder. + * + * @param value Remote IPv6Address + * @return Builder by setting Remote IPv6Address + */ + Builder setRemoteIPv6Address(byte[] value); + + /** + * Sets P flag in FEC object header and returns its builder. + * + * @param value boolean value to set P flag + * @return Builder by setting P flag + */ + Builder setPFlag(boolean value); + + /** + * Sets I flag in FEC object header and returns its builder. + * + * @param value boolean value to set I flag + * @return Builder by setting I flag + */ + Builder setIFlag(boolean value); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepInitiateMsg.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepInitiateMsg.java new file mode 100755 index 00000000..2b061430 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepInitiateMsg.java @@ -0,0 +1,81 @@ +/* + * 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; + +import java.util.LinkedList; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.pcepio.exceptions.PcepParseException; + +/** + * Abstraction of an entity providing PCEP Initiate Message. + */ +public interface PcepInitiateMsg extends PcepObject, PcepMessage { + + @Override + PcepVersion getVersion(); + + @Override + PcepType getType(); + + /** + * Returns list of PcInitiatedLspRequestList. + * + * @return list of PcInitiatedLspRequestList + */ + LinkedList<PcInitiatedLspRequest> getPcInitiatedLspRequestList(); + + /** + * Sets list of PcInitiatedLspRequestList. + * + * @param llPcInitiatedLspRequestList list of PcInitiatedLspRequestList + */ + void setPcInitiatedLspRequestList(LinkedList<PcInitiatedLspRequest> llPcInitiatedLspRequestList); + + @Override + void writeTo(ChannelBuffer channelBuffer) throws PcepParseException; + + /** + * Builder interface with get and set functions to build Initiate message. + */ + interface Builder extends PcepMessage.Builder { + + @Override + PcepInitiateMsg build(); + + @Override + PcepVersion getVersion(); + + @Override + PcepType getType(); + + /** + * Returns list of PcInitiatedLspRequestList. + * + * @return list of PcInitiatedLspRequestList + */ + LinkedList<PcInitiatedLspRequest> getPcInitiatedLspRequestList(); + + /** + * Sets PcInitiatedLspRequestList. + * + * @param llPcInitiatedLspRequestList list of PcInitiatedLspRequestList + * @return builder by setting list of PcInitiatedLspRequestList + */ + Builder setPcInitiatedLspRequestList(LinkedList<PcInitiatedLspRequest> llPcInitiatedLspRequestList); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepInterLayerObject.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepInterLayerObject.java new file mode 100755 index 00000000..675e0557 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepInterLayerObject.java @@ -0,0 +1,137 @@ +/* + * 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; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.pcepio.exceptions.PcepParseException; +import org.onosproject.pcepio.types.PcepObjectHeader; + +/** + * Abstraction of an entity providing PCEP INTER Layer Object. + */ +public interface PcepInterLayerObject { + + /** + * Returns N Flag in INTER Layer Object. + * + * @return N Flag in INTER Layer Object + */ + boolean getbNFlag(); + + /** + * Sets N Flag in INTER Layer Object with specified value. + * + * @param value N Flag + */ + void setbNFlag(boolean value); + + /** + * Returns I Flag in INTER Layer Object. + * + * @return I Flag in INTER Layer Object + */ + boolean getbIFlag(); + + /** + * Sets I Flag in INTER Layer Object with specified value. + * + * @param value I Flag + */ + void setbIFlag(boolean value); + + /** + * Writes the INTER Layer Object into channel buffer. + * + * @param bb channel buffer + * @return Returns the writerIndex of this buffer + * @throws PcepParseException while writing Inter Layer Object. + */ + int write(ChannelBuffer bb) throws PcepParseException; + + /** + * Builder interface with get and set functions to build INTER Layer object. + */ + interface Builder { + + /** + * Builds INTER Layer object. + * + * @return INTER Layer object + */ + PcepInterLayerObject build(); + + /** + * Returns INTER Layer object header. + * + * @return INTER Layer object header + */ + PcepObjectHeader getInterLayerObjHeader(); + + /** + * Sets INTER Layer object header and returns its builder. + * + * @param obj INTER Layer object header + * @return Builder by setting INTER Layer object header + */ + Builder setInterLayerObjHeader(PcepObjectHeader obj); + + /** + * Returns N Flag in INTER Layer Object. + * + * @return N Flag in INTER Layer Object + */ + boolean getbNFlag(); + + /** + * Sets N flag and return its builder. + * + * @param value N flag + * @return Builder by setting N flag + */ + Builder setbNFlag(boolean value); + + /** + * Returns I Flag in INTER Layer Object. + * + * @return I Flag in INTER Layer Object + */ + boolean getbIFlag(); + + /** + * Sets I flag and return its builder. + * + * @param value I flag + * @return Builder by setting N flag + */ + Builder setbIFlag(boolean value); + + /** + * Sets P flag in INTER Layer object header and returns its builder. + * + * @param value boolean value to set P flag + * @return Builder by setting P flag + */ + Builder setPFlag(boolean value); + + /** + * Sets I flag in INTER Layer object header and returns its builder. + * + * @param value boolean value to set I flag + * @return Builder by setting I flag + */ + Builder setIFlag(boolean value); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepIroObject.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepIroObject.java new file mode 100755 index 00000000..a1c1fc59 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepIroObject.java @@ -0,0 +1,110 @@ +/* + * 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; + +import java.util.LinkedList; +import org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.pcepio.exceptions.PcepParseException; +import org.onosproject.pcepio.types.PcepObjectHeader; +import org.onosproject.pcepio.types.PcepValueType; + +/** + * Abstraction of an entity providing PCEP IRO Object. + */ +public interface PcepIroObject { + + /** + * Returns list of SubObjects. + * + * @return list of SubObjects + */ + LinkedList<PcepValueType> getSubObjects(); + + /** + * Sets list of SubObjects. + * + * @param llSubObjects list of SubObjects + */ + void setSubObjects(LinkedList<PcepValueType> llSubObjects); + + /** + * Writes the IRO into channel buffer. + * + * @param bb channel buffer + * @return Returns the writerIndex of this buffer + * @throws PcepParseException while writing IRO object. + */ + int write(ChannelBuffer bb) throws PcepParseException; + + /** + * Builder interface with get and set functions to build IRO object. + */ + interface Builder { + + /** + * Builds IRO Object. + * + * @return IRO Object + */ + PcepIroObject build(); + + /** + * Returns IRO object header. + * + * @return IRO object header + */ + PcepObjectHeader getIroObjHeader(); + + /** + * Sets IRO object header and returns its builder. + * + * @param obj IRO object header + * @return Builder by setting IRO object header + */ + Builder setIroObjHeader(PcepObjectHeader obj); + + /** + * Returns list of SubObjects. + * + * @return list of SubObjects + */ + LinkedList<PcepValueType> getSubObjects(); + + /** + * Sets list of SubObjects in IRO Object and returns its builder. + * + * @param llSubObjects list of SubObjects + * @return Builder by setting list of SubObjects + */ + Builder setSubObjects(LinkedList<PcepValueType> llSubObjects); + + /** + * Sets P flag in IRO object header and returns its builder. + * + * @param value boolean value to set P flag + * @return Builder by setting P flag + */ + Builder setPFlag(boolean value); + + /** + * Sets I flag in IRO object header and returns its builder. + * + * @param value boolean value to set I flag + * @return Builder by setting I flag + */ + Builder setIFlag(boolean value); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepKeepaliveMsg.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepKeepaliveMsg.java new file mode 100755 index 00000000..160f0a2a --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepKeepaliveMsg.java @@ -0,0 +1,49 @@ +/* + * 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; + +import org.jboss.netty.buffer.ChannelBuffer; + +/** + * Abstraction of an entity providing PCEP Keepalive Message. + */ +public interface PcepKeepaliveMsg extends PcepObject, PcepMessage { + + @Override + PcepVersion getVersion(); + + @Override + PcepType getType(); + + @Override + void writeTo(ChannelBuffer channelBuffer); + + /** + * Builder interface with get and set functions to build Keepalive message. + */ + interface Builder extends PcepMessage.Builder { + + @Override + PcepKeepaliveMsg build(); + + @Override + PcepVersion getVersion(); + + @Override + PcepType getType(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepLabelObject.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepLabelObject.java new file mode 100755 index 00000000..b64c21e0 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepLabelObject.java @@ -0,0 +1,171 @@ +/* + * 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; + +import java.util.LinkedList; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.pcepio.exceptions.PcepParseException; +import org.onosproject.pcepio.types.PcepObjectHeader; +import org.onosproject.pcepio.types.PcepValueType; + +/** + * Abstraction of an entity providing PCEP Label Object. + */ +public interface PcepLabelObject { + + /** + * Returns O flag in Label Object. + * + * @return Boolean value + */ + boolean getOFlag(); + + /** + * Sets O flag in Label Object with specified value. + * + * @param value O flag + */ + void setOFlag(boolean value); + + /** + * Returns Label from Label Object. + * + * @return Label value + */ + int getLabel(); + + /** + * Sets Label field in Label Object with specified value. + * + * @param value Label + */ + void setLabel(int value); + + /** + * Returns list of Optional Tlvs. + * + * @return list of Optional Tlvs + */ + LinkedList<PcepValueType> getOptionalTlv(); + + /** + * Sets Optional Tlvs in Label Object. + * + * @param llOptionalTlv list of Optional Tlvs + */ + void setOptionalTlv(LinkedList<PcepValueType> llOptionalTlv); + + /** + * Writes the Label Object into channel buffer. + * + * @param bb channel buffer + * @return Returns the writerIndex of this buffer + * @throws PcepParseException while writing LABEL object into Channel Buffer. + */ + int write(ChannelBuffer bb) throws PcepParseException; + + /** + * Builder interface with get and set functions to build Label object. + */ + interface Builder { + + /** + * Builds Label Object. + * + * @return Label Object + * @throws PcepParseException while building LABEL object. + */ + PcepLabelObject build() throws PcepParseException; + + /** + * Returns Label object header. + * + * @return Label object header + */ + PcepObjectHeader getLabelObjHeader(); + + /** + * Sets Label object header and returns its builder. + * + * @param obj Label object header + * @return Builder by setting Label object header + */ + Builder setLabelObjHeader(PcepObjectHeader obj); + + /** + * Returns O flag in Label Object. + * + * @return Label value + */ + boolean getOFlag(); + + /** + * Sets O flag and return its builder. + * + * @param value O flag + * @return Builder by setting O flag + */ + Builder setOFlag(boolean value); + + /** + * Returns Label from Label Object. + * + * @return Label value + */ + int getLabel(); + + /** + * Sets Label field and return its builder. + * + * @param value Label field + * @return Builder by setting Label field + */ + Builder setLabel(int value); + + /** + * Returns list of Optional Tlvs. + * + * @return list of Optional Tlvs + */ + LinkedList<PcepValueType> getOptionalTlv(); + + /** + * Sets list of Optional Tlvs and return its builder. + * + * @param llOptionalTlv list of Optional Tlvs + * @return Builder by setting list of Optional Tlvs + */ + Builder setOptionalTlv(LinkedList<PcepValueType> llOptionalTlv); + + /** + * Sets P flag in Label object header and returns its builder. + * + * @param value boolean value to set P flag + * @return Builder by setting P flag + */ + Builder setPFlag(boolean value); + + /** + * Sets I flag in Label object header and returns its builder. + * + * @param value boolean value to set I flag + * @return Builder by setting I flag + */ + Builder setIFlag(boolean value); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepLabelRange.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepLabelRange.java new file mode 100755 index 00000000..72d0a38e --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepLabelRange.java @@ -0,0 +1,65 @@ +/* + * 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; + +import java.util.LinkedList; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.pcepio.exceptions.PcepParseException; + +/** + * Abstraction of an entity providing PCEP Label Range. + */ +public interface PcepLabelRange { + + /** + * Returns object of PCEP SRP Object. + * + * @return srpObject + */ + PcepSrpObject getSrpObject(); + + /** + * Sets PCEP SRP Object. + * + * @param srpObject SRP object. + */ + void setSrpObject(PcepSrpObject srpObject); + + /** + * Returns list of PcepLabelRangeObject. + * + * @return Label Range List + */ + LinkedList<PcepLabelRangeObject> getLabelRangeList(); + + /** + * Sets list of PcepLabelRangeObject. + * + * @param llLabelRangeList Label Range List + */ + void setLabelRangeList(LinkedList<PcepLabelRangeObject> llLabelRangeList); + + /** + * Write the byte stream of PcepLabelRange to channel buffer. + * + * @param bb of type channel buffer + * @return object length index + * @throws PcepParseException while writing LABEL RANGE into Channel Buffer. + */ + int write(ChannelBuffer bb) throws PcepParseException; +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepLabelRangeObject.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepLabelRangeObject.java new file mode 100755 index 00000000..9155434e --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepLabelRangeObject.java @@ -0,0 +1,182 @@ +/* + * 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; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.pcepio.exceptions.PcepParseException; +import org.onosproject.pcepio.types.PcepObjectHeader; + +/** + * Abstraction of an entity providing PCEP LabelRange Object. + */ +public interface PcepLabelRangeObject { + + /** + * Sets LabelRange Object header. + * + * @param obj LabelRange Object header + */ + void setLabelRangeObjHeader(PcepObjectHeader obj); + + /** + * Sets LabelType in LabelRange Object. + * + * @param labelType label type value + */ + void setLabelType(byte labelType); + + /** + * Sets RangeSize in LabelRange Object. + * + * @param rangeSize range size value + */ + void setRangeSize(int rangeSize); + + /** + * Sets LabelBase in LabelRange Object. + * + * @param labelBase label base value + */ + void setLabelBase(int labelBase); + + /** + * Returns LabelRange object header. + * + * @return LabelRange object header + */ + PcepObjectHeader getLabelRangeObjHeader(); + + /** + * Returns LabelType field in LabelRange object. + * + * @return LabelType field in LabelRange object + */ + byte getLabelType(); + + /** + * Returns RangeSize field in LabelRange object. + * + * @return RangeSize field in LabelRange object + */ + int getRangeSize(); + + /** + * Returns LabelBase field in LabelRange object. + * + * @return LabelBase field in LabelRange object + */ + int getLabelBase(); + + /** + * Writes the LabelRange Object into channel buffer. + * + * @param bb channel buffer + * @return Returns the writerIndex of this buffer + * @throws PcepParseException while writing LABEL RANGE object into Channel Buffer. + */ + int write(ChannelBuffer bb) throws PcepParseException; + + /** + * Builder interface with get and set functions to build LabelRange object. + */ + interface Builder { + + /** + * Builds LabelRange Object. + * + * @return LabelRange Object + * @throws PcepParseException while building LABEL RANGE object. + */ + PcepLabelRangeObject build() throws PcepParseException; + + /** + * Returns LabelRange object header. + * + * @return LabelRange object header + */ + PcepObjectHeader getLabelRangeObjHeader(); + + /** + * Sets LabelRange object header and returns its builder. + * + * @param obj LabelRange object header + * @return Builder by setting LabelRange object header + */ + Builder setLabelRangeObjHeader(PcepObjectHeader obj); + + /** + * Returns LabelType field in LabelRange object. + * + * @return LabelType field in LabelRange object + */ + byte getLabelType(); + + /** + * Sets LabelType field and returns its builder. + * + * @param labelType LabelType field + * @return Builder by setting LabelType field + */ + Builder setLabelType(byte labelType); + + /** + * Returns RangeSize field in LabelRange object. + * + * @return RangeSize field in LabelRange object + */ + int getRangeSize(); + + /** + * Sets RangeSize field and returns its builder. + * + * @param rangeSize RangeSize field + * @return Builder by setting RangeSize field + */ + Builder setRangeSize(int rangeSize); + + /** + * Returns LabelBase field in LabelRange object. + * + * @return LabelBase field in LabelRange object + */ + int getLabelBase(); + + /** + * Sets LabelBase field and returns its builder. + * + * @param labelBase LabelBase field + * @return Builder by setting LabelBase field + */ + Builder setLabelBase(int labelBase); + + /** + * Sets P flag in TE object header and returns its builder. + * + * @param value boolean value to set P flag + * @return Builder by setting P flag + */ + Builder setPFlag(boolean value); + + /** + * Sets I flag in TE object header and returns its builder. + * + * @param value boolean value to set I flag + * @return Builder by setting I flag + */ + Builder setIFlag(boolean value); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepLabelRangeResvMsg.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepLabelRangeResvMsg.java new file mode 100755 index 00000000..3e2a3a95 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepLabelRangeResvMsg.java @@ -0,0 +1,79 @@ +/* + * 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; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.pcepio.exceptions.PcepParseException; + +/** + * Abstraction of an entity providing PCEP Label Range Reservation Message. + */ +public interface PcepLabelRangeResvMsg extends PcepObject, PcepMessage { + + @Override + PcepVersion getVersion(); + + @Override + PcepType getType(); + + /** + * Returns LabelRange field in Label Range Reservation message. + * + * @return LabelRange field + */ + PcepLabelRange getLabelRange(); + + /** + * Sets LabelRange field in Label Range Reservation message with specified value. + * + * @param lR label range object + */ + void setLabelRange(PcepLabelRange lR); + + @Override + void writeTo(ChannelBuffer channelBuffer) throws PcepParseException; + + /** + * Builder interface with get and set functions to build Label Range Reservation message. + */ + interface Builder extends PcepMessage.Builder { + + @Override + PcepLabelRangeResvMsg build(); + + @Override + PcepVersion getVersion(); + + @Override + PcepType getType(); + + /** + * Returns LabelRange field in Label Range Reservation message. + * + * @return LabelRange object + */ + PcepLabelRange getLabelRange(); + + /** + * Sets LabelRange field and returns its Builder. + * + * @param lR label range object + * @return builder by setting LabelRange field + */ + Builder setLabelRange(PcepLabelRange lR); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepLabelUpdate.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepLabelUpdate.java new file mode 100644 index 00000000..5ef870d4 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepLabelUpdate.java @@ -0,0 +1,108 @@ +/* + * 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; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.pcepio.exceptions.PcepParseException; +import org.onosproject.pcepio.types.PcepLabelDownload; +import org.onosproject.pcepio.types.PcepLabelMap; + +/*** + * Abstraction to provide PCEP Label Updates. + */ +public interface PcepLabelUpdate { + + /** + * Writes the byte stream of PcepLabelUpdate into channel buffer. + * + * @param bb of type channel buffer + * @throws PcepParseException while writing LABEL UPDATE. + */ + void write(ChannelBuffer bb) throws PcepParseException; + + /** + * Sets the Label Download object. + * + * @param labelDownload PCEP Label Download object + */ + void setLabelDownload(PcepLabelDownload labelDownload); + + /** + * Returns the PcepLabelDownload object. + * + * @return labelDownload PCEP Label Download + */ + PcepLabelDownload getLabelDownload(); + + /** + * Sets the Label map object. + * + * @param labelMap PCEP Label Map object + */ + void setLabelMap(PcepLabelMap labelMap); + + /** + * Returns the PcepLabelMap object. + * + * @return labelMap PCEP Label Map + */ + PcepLabelMap getLabelMap(); + + /** + * Builder interface with get and set functions to build Label Update message. + */ + interface Builder { + + /** + * Builds PcepLableUpdate Object. + * + * @return PcepLableUpdate Object + * @throws PcepParseException while building LABEL-UPDATE. + */ + PcepLabelUpdate build() throws PcepParseException; + + /** + * Sets the Label Download object. + * + * @param labelDownload PCEP Label Download object + * @return Builder by setting labelDownload object + */ + Builder setLabelDownload(PcepLabelDownload labelDownload); + + /** + * Returns the PcepLabelDownload object. + * + * @return labelDownload PCEP Label Download + */ + PcepLabelDownload getLabelDownload(); + + /** + * Sets the Label map object. + * + * @param labelMap PCEP Label Map object + * @return Builder by setting PcepLabelMap object + */ + Builder setLabelMap(PcepLabelMap labelMap); + + /** + * Returns the PcepLabelMap object. + * + * @return labelMap PCEP Label Map + */ + PcepLabelMap getLabelMap(); + } + +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepLabelUpdateMsg.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepLabelUpdateMsg.java new file mode 100755 index 00000000..3740df3b --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepLabelUpdateMsg.java @@ -0,0 +1,81 @@ +/* + * 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; + +import java.util.LinkedList; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.pcepio.exceptions.PcepParseException; + +/** + * Abstraction of an entity providing PCEP Label Update Message. + */ +public interface PcepLabelUpdateMsg extends PcepObject, PcepMessage { + + @Override + PcepVersion getVersion(); + + @Override + PcepType getType(); + + /** + * Returns list of PcLabelUpdateList. + * + * @return list of PcLabelUpdateList. + */ + LinkedList<PcepLabelUpdate> getPcLabelUpdateList(); + + /** + * Sets list of PcLabelUpdateList. + * + * @param llPcLabelUpdateList list of PcLabelUpdateList + */ + void setPcLabelUpdateList(LinkedList<PcepLabelUpdate> llPcLabelUpdateList); + + @Override + void writeTo(ChannelBuffer channelBuffer) throws PcepParseException; + + /** + * Builder interface with get and set functions to build Label Update message. + */ + interface Builder extends PcepMessage.Builder { + + @Override + PcepLabelUpdateMsg build(); + + @Override + PcepVersion getVersion(); + + @Override + PcepType getType(); + + /** + * Returns list of PcLabelUpdateList. + * + * @return list of PcLabelUpdateList. + */ + LinkedList<PcepLabelUpdate> getPcLabelUpdateList(); + + /** + * Sets list of PcLabelUpdateList. + * + * @param llPcLabelUpdateList list of PcLabelUpdateList. + * @return Builder by setting list of PcLabelUpdateList. + */ + Builder setPcLabelUpdateList(LinkedList<PcepLabelUpdate> llPcLabelUpdateList); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepLspObject.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepLspObject.java new file mode 100755 index 00000000..5d55250a --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepLspObject.java @@ -0,0 +1,286 @@ +/* + * 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; + +import java.util.LinkedList; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.pcepio.exceptions.PcepParseException; +import org.onosproject.pcepio.types.PcepObjectHeader; +import org.onosproject.pcepio.types.PcepValueType; + +/** + * Abstraction of an entity providing PCEP LSP Object. + */ +public interface PcepLspObject { + + /** + * Returns PlspId of LSP Object. + * + * @return PlspId of LSP Object + */ + int getPlspId(); + + /** + * Sets PlspId with specified value. + * + * @param value PlspId + */ + void setPlspId(int value); + + /** + * Returns O flag in LSP Object. + * + * @return O flag in LSP Object + */ + byte getOFlag(); + + /** + * Sets O flag with specified value. + * + * @param value O flag + */ + void setOFlag(byte value); + + /** + * Returns A flag in LSP Object. + * + * @return A flag in LSP Object + */ + boolean getAFlag(); + + /** + * Sets A flag with specified value. + * + * @param value A flag + */ + void setAFlag(boolean value); + + /** + * Returns R flag in LSP Object. + * + * @return R flag in LSP Object + */ + boolean getRFlag(); + + /** + * Sets R flag with specified value. + * + * @param value R flag + */ + void setRFlag(boolean value); + + /** + * Returns S flag in LSP Object. + * + * @return S flag in LSP Object + */ + boolean getSFlag(); + + /** + * Sets S flag with specified value. + * + * @param value S flag + */ + void setSFlag(boolean value); + + /** + * Returns D flag in LSP Object. + * + * @return D flag in LSP Object + */ + boolean getDFlag(); + + /** + * Sets D flag with specified value. + * + * @param value D flag + */ + void setDFlag(boolean value); + + /** + * Returns list of Optional Tlvs in LSP Object. + * + * @return list of Optional Tlvs + */ + LinkedList<PcepValueType> getOptionalTlv(); + + /** + * Sets list of Optional Tlvs in LSP Object. + * + * @param llOptionalTlv list of Optional Tlvs + */ + void setOptionalTlv(LinkedList<PcepValueType> llOptionalTlv); + + /** + * Writes the LSP Object into channel buffer. + * + * @param bb channel buffer + * @return Returns the writerIndex of this buffer + * @throws PcepParseException while writing LSP object into Channel Buffer. + */ + int write(ChannelBuffer bb) throws PcepParseException; + + /** + * Builder interface with get and set functions to build LSP object. + */ + interface Builder { + + /** + * Builds LSP Object. + * + * @return LSP Object + */ + PcepLspObject build(); + + /** + * Returns LSP object header. + * + * @return LSP object header + */ + PcepObjectHeader getLspObjHeader(); + + /** + * Sets LSP object header and returns its builder. + * + * @param obj LSP object header + * @return Builder by setting LSP object header + */ + Builder setLspObjHeader(PcepObjectHeader obj); + + /** + * Returns PlspId of LSP Object. + * + * @return PlspId of LSP Object + */ + int getPlspId(); + + /** + * Sets PlspId with specific value and return its builder. + * + * @param value PlspId + * @return Builder by setting PlspId + */ + Builder setPlspId(int value); + + /** + * Returns O flag in LSP Object. + * + * @return O flag in LSP Object + */ + byte getOFlag(); + + /** + * Sets O flag with specific value and return its builder. + * + * @param value O flag + * @return Builder by setting O flag + */ + Builder setOFlag(byte value); + + /** + * Returns A flag in LSP Object. + * + * @return A flag in LSP Object + */ + boolean getAFlag(); + + /** + * Sets A flag with specific value and return its builder. + * + * @param value A flag + * @return Builder by setting A flag + */ + Builder setAFlag(boolean value); + + /** + * Returns A flag in LSP Object. + * + * @return A flag in LSP Object + */ + boolean getRFlag(); + + /** + * Sets R flag with specific value and return its builder. + * + * @param value r flag + * @return Builder by setting r flag + */ + Builder setRFlag(boolean value); + + /** + * Returns S flag in LSP Object. + * + * @return S flag in LSP Object + */ + boolean getSFlag(); + + /** + * Sets S flag with specific value and return its builder. + * + * @param value s flag + * @return Builder by setting S flag + */ + Builder setSFlag(boolean value); + + /** + * Returns D flag in LSP Object. + * + * @return D flag in LSP Object + */ + boolean getDFlag(); + + /** + * Sets D flag with specific value and return its builder. + * + * @param value D flag + * @return Builder by setting D flag + */ + Builder setDFlag(boolean value); + + /** + * Returns list of Optional Tlvs in LSP Object. + * + * @return list of Optional Tlvs in LSP Object + */ + LinkedList<PcepValueType> getOptionalTlv(); + + /** + * Sets list of Optional Tlvs and return its builder. + * + * @param llOptionalTlv list of Optional Tlvs + * @return Builder by setting list of Optional Tlvs + */ + Builder setOptionalTlv(LinkedList<PcepValueType> llOptionalTlv); + + /** + * Sets P flag in LSP object header and returns its builder. + * + * @param value boolean value to set P flag + * @return Builder by setting P flag + */ + Builder setPFlag(boolean value); + + /** + * Sets I flag in LSP object header and returns its builder. + * + * @param value boolean value to set I flag + * @return Builder by setting I flag + */ + Builder setIFlag(boolean value); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepLspaObject.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepLspaObject.java new file mode 100755 index 00000000..d541e92b --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepLspaObject.java @@ -0,0 +1,286 @@ +/* + * 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; + +import java.util.LinkedList; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.pcepio.exceptions.PcepParseException; +import org.onosproject.pcepio.types.PcepObjectHeader; +import org.onosproject.pcepio.types.PcepValueType; + +/** + * Abstraction of an entity providing PCEP LSPA Object. + */ +public interface PcepLspaObject { + + /** + * Returns L flag in LSPA Object. + * + * @return L flag in LSPA Object + */ + boolean getLFlag(); + + /** + * Sets L flag in LSPA Object. + * + * @param value L flag + */ + void setLFlag(boolean value); + + /** + * Returns Exclude Any field in LSPA Object. + * + * @return Exclude Any field in LSPA Object + */ + int getExcludeAny(); + + /** + * Sets Exclude Any field in LSPA Object. + * + * @param value Exclude Any field + */ + void setExcludeAny(int value); + + /** + * Returns Include Any field in LSPA Object. + * + * @return Include Any field in LSPA Object + */ + int getIncludeAny(); + + /** + * Sets Include Any field in LSPA Object. + * + * @param value Include Any field + */ + void setIncludeAny(int value); + + /** + * Returns Include All field in LSPA Object. + * + * @return Include All field in LSPA Object + */ + int getIncludeAll(); + + /** + * Sets Include All field in LSPA Object. + * + * @param value Include All field + */ + void setIncludeAll(int value); + + /** + * Returns Setup Priority field in LSPA Object. + * + * @return Setup Priority field in LSPA Object + */ + byte getSetupPriority(); + + /** + * Sets Setup Priority field in LSPA Object. + * + * @param value Setup Priority field + */ + void setSetupPriority(byte value); + + /** + * Returns Hold Priority field in LSPA Object. + * + * @return Hold Priority field in LSPA Object + */ + byte getHoldPriority(); + + /** + * Sets Hold Priority field in LSPA Object. + * + * @param value Hold Priority field + */ + void setHoldPriority(byte value); + + /** + * Returns list of Optional Tlvs in LSPA Object. + * + * @return list of Optional Tlvs in LSPA Object + */ + LinkedList<PcepValueType> getOptionalTlv(); + + /** + * Sets Optional Tlvs in LSPA Object. + * + * @param llOptionalTlv Optional Tlvs in LSPA Object + */ + void setOptionalTlv(LinkedList<PcepValueType> llOptionalTlv); + + /** + * Writes the LSPA Object into channel buffer. + * + * @param bb channel buffer + * @return Returns the writerIndex of this buffer + * @throws PcepParseException while writing LSPA object into Channel Buffer. + */ + int write(ChannelBuffer bb) throws PcepParseException; + + /** + * Builder interface with get and set functions to build bandwidth object. + */ + interface Builder { + + /** + * Builds LSPA Object. + * + * @return LSPA Object + * @throws PcepParseException while building LSPA object. + */ + PcepLspaObject build() throws PcepParseException; + + /** + * Returns LSPA object header. + * + * @return LSPA object header + */ + PcepObjectHeader getLspaObjHeader(); + + /** + * Sets LSPA object header and returns its builder. + * + * @param obj LSPA object header + * @return Builder by setting LSPA object header + */ + Builder setLspaObjHeader(PcepObjectHeader obj); + + /** + * Returns L flag in LSPA Object. + * + * @return L flag in LSPA Object + */ + boolean getLFlag(); + + /** + * Sets L flag in LSPA Object and return its builder. + * + * @param value L flag in LSPA Object + * @return Builder by setting L flag + */ + Builder setLFlag(boolean value); + + /** + * Returns Exclude Any field in LSPA Object. + * + * @return Exclude Any field in LSPA Object + */ + int getExcludeAny(); + + /** + * Sets Exclude Any field in LSPA Object and return its builder. + * + * @param value Exclude Any field in LSPA Object + * @return Builder by setting Exclude Any field + */ + Builder setExcludeAny(int value); + + /** + * Returns Include Any field in LSPA Object. + * + * @return Include Any field in LSPA Object + */ + int getIncludeAny(); + + /** + * Sets Include Any field in LSPA Object and return its builder. + * + * @param value Include Any field in LSPA Object + * @return Builder by setting Include Any field + */ + Builder setIncludeAny(int value); + + /** + * Returns Include All field in LSPA Object. + * + * @return Include All field in LSPA Object + */ + int getIncludeAll(); + + /** + * Sets Include All field in LSPA Object and return its builder. + * + * @param value Include All field in LSPA Object + * @return Builder by setting Include All field + */ + Builder setIncludeAll(int value); + + /** + * Returns Setup Priority field in LSPA Object. + * + * @return Setup Priority field in LSPA Object + */ + byte getSetupPriority(); + + /** + * Sets Setup Priority field in LSPA Object and return its builder. + * + * @param value Setup Priority field in LSPA Object + * @return Builder by setting Setup Priority field + */ + Builder setSetupPriority(byte value); + + /** + * Returns Hold Priority field in LSPA Object. + * + * @return Hold Priority field in LSPA Object + */ + byte getHoldPriority(); + + /** + * Sets Hold Priority field in LSPA Object and return its builder. + * + * @param value Hold Priority field in LSPA Object + * @return Builder by setting Hold Priority field + */ + Builder setHoldPriority(byte value); + + /** + * Returns list of Optional Tlvs in LSPA Object. + * + * @return list of Optional Tlvs in LSPA Object + */ + LinkedList<PcepValueType> getOptionalTlv(); + + /** + * Sets list of Optional Tlvs in LSPA Object. + * + * @param llOptionalTlv list of Optional Tlvs + * @return builder by setting list of Optional Tlvs + */ + Builder setOptionalTlv(LinkedList<PcepValueType> llOptionalTlv); + + /** + * Sets P flag in LSPA object header and returns its builder. + * + * @param value boolean value to set P flag + * @return Builder by setting P flag + */ + Builder setPFlag(boolean value); + + /** + * Sets I flag in LSPA object header and returns its builder. + * + * @param value boolean value to set I flag + * @return Builder by setting I flag + */ + Builder setIFlag(boolean value); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepMessage.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepMessage.java new file mode 100755 index 00000000..7de07169 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepMessage.java @@ -0,0 +1,67 @@ +/* + * 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; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.pcepio.exceptions.PcepParseException; + +/** + * Abstraction of an entity providing PCEP Messages. + */ +public interface PcepMessage extends PcepObject { + + @Override + PcepVersion getVersion(); + + /** + * Returns Type of PCEP Message. + * + * @return Type of PCEP Message + */ + PcepType getType(); + + @Override + void writeTo(ChannelBuffer channelBuffer) throws PcepParseException; + + /** + * Builder interface with get and set functions to build PCEP Message. + */ + interface Builder { + + /** + * Builds PCEP Message. + * + * @return PCEP Message + * @throws PcepParseException when build fails to create PCEP message + */ + PcepMessage build() throws PcepParseException; + + /** + * Returns Version of PCEP Message. + * + * @return Version of PCEP Message + */ + PcepVersion getVersion(); + + /** + * Returns Type of PCEP Message. + * + * @return Type of PCEP Message + */ + PcepType getType(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepMessageReader.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepMessageReader.java new file mode 100755 index 00000000..591a033d --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepMessageReader.java @@ -0,0 +1,36 @@ +/* + * 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; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.pcepio.exceptions.PcepParseException; + +/** + * Abstraction of an entity providing PCEP Message Reader. + */ +public interface PcepMessageReader<T> { + + /** + * Reads the Objects in the PCEP Message and Returns PCEP Message. + * + * @param bb Channel Buffer + * @return PCEP Message + * @throws PcepParseException while parsing PCEP message. + * @throws PcepParseException when received message is empty + */ + T readFrom(ChannelBuffer bb) throws PcepParseException; +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepMessageWriter.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepMessageWriter.java new file mode 100755 index 00000000..e7477b51 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepMessageWriter.java @@ -0,0 +1,35 @@ +/* + * 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; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.pcepio.exceptions.PcepParseException; + +/** + * Abstraction of an entity providing PCEP Message Writer. + */ +public interface PcepMessageWriter<T> { + + /** + * Writes the Objects of the PCEP Message into Channel Buffer. + * + * @param bb Channel Buffer + * @param message PCEP Message + * @throws PcepParseException while writing PCEP message. + */ + void write(ChannelBuffer bb, T message) throws PcepParseException; +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepMetricObject.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepMetricObject.java new file mode 100755 index 00000000..380fb42e --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepMetricObject.java @@ -0,0 +1,225 @@ +/* + * 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; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.pcepio.exceptions.PcepParseException; +import org.onosproject.pcepio.types.PcepObjectHeader; + +/** + * Abstraction of an entity providing PCEP Metric Object. + */ +public interface PcepMetricObject { + + /** + * Returns Metric value in Metric Object. + * + * @return Metric value + */ + int getMetricVal(); + + /** + * Sets Metric value in Metric Object with specified value. + * + * @param value Metric value + */ + void setMetricVal(int value); + + /** + * Returns Y flag in Metric Object. + * + * @return Y flag in Metric Object + */ + byte getYFlag(); + + /** + * Sets Y flag in Metric Object with specified value. + * + * @param value Y flag + */ + void setYFlag(byte value); + + /** + * Returns C flag in Metric Object. + * + * @return C flag in Metric Object + */ + boolean getCFlag(); + + /** + * Sets C flag in Metric Object with specified value. + * + * @param value C flag + */ + void setCFlag(boolean value); + + /** + * Returns B flag in Metric Object. + * + * @return B flag in Metric Object + */ + boolean getBFlag(); + + /** + * Sets B flag in Metric Object with specified value. + * + * @param value B flag + */ + void setBFlag(boolean value); + + /** + * Returns BType field in Metric Object. + * + * @return BType field in Metric Object + */ + byte getBType(); + + /** + * Sets BType field in Metric Object with specified value. + * + * @param value BType field + */ + void setBType(byte value); + + /** + * Writes the Metric Object into channel buffer. + * + * @param bb channel buffer + * @return Returns the writerIndex of this buffer + * @throws PcepParseException while writing METRIC object into Channel Buffer. + */ + int write(ChannelBuffer bb) throws PcepParseException; + + /** + * Builder interface with get and set functions to build Metric object. + */ + interface Builder { + + /** + * Builds Metric Object. + * + * @return Metric Object + * @throws PcepParseException when mandatory object is not set + */ + PcepMetricObject build() throws PcepParseException; + + /** + * Returns Metric object header. + * + * @return Metric object header + */ + PcepObjectHeader getMetricObjHeader(); + + /** + * Sets Metric object header and returns its builder. + * + * @param obj Metric object header + * @return Builder by setting Metric object header + */ + Builder setMetricObjHeader(PcepObjectHeader obj); + + /** + * Returns Metric value in Metric Object. + * + * @return Metric value + */ + int getMetricVal(); + + /** + * Sets Metric Value in Metric Object and returns its builder. + * + * @param value Metric Value + * @return Builder by setting Metric Value + */ + Builder setMetricVal(int value); + + /** + * Returns Flags in Metric Object. + * + * @return Flags in Metric Object + */ + byte getYFlag(); + + /** + * Sets Flags in Metric Object and returns its builder. + * + * @param value Flags + * @return Builder by setting Flags + */ + Builder setYFlag(byte value); + + /** + * Returns C flag in Metric Object. + * + * @return C flag in Metric Object + */ + boolean getCFlag(); + + /** + * Sets C flag in Metric Object and returns its builder. + * + * @param value C flag + * @return Builder by setting C flag + */ + Builder setCFlag(boolean value); + + /** + * Returns B flag in Metric Object. + * + * @return B flag in Metric Object + */ + boolean getBFlag(); + + /** + * Sets B flag in Metric Object and returns its builder. + * + * @param value B flag + * @return Builder by setting B flag + */ + Builder setBFlag(boolean value); + + /** + * Returns BType field in Metric Object. + * + * @return BType field in Metric Object + */ + byte getBType(); + + /** + * Sets B Type field in Metric Object and returns its builder. + * + * @param value B Type field + * @return Builder by setting B Type field + */ + Builder setBType(byte value); + + /** + * Sets P flag in Metric object header and returns its builder. + * + * @param value boolean value to set P flag + * @return Builder by setting P flag + */ + Builder setPFlag(boolean value); + + /** + * Sets I flag in Metric object header and returns its builder. + * + * @param value boolean value to set I flag + * @return Builder by setting I flag + */ + Builder setIFlag(boolean value); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepMsgPath.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepMsgPath.java new file mode 100644 index 00000000..4b1d50a5 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepMsgPath.java @@ -0,0 +1,117 @@ +/* + * 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; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.pcepio.exceptions.PcepParseException; + +/** + * Abstraction of an entity Provides PCEP Message PAth for update message. + * Reference :PCE extensions for stateful draft-ietf-pce-stateful-pce-10. + */ +public interface PcepMsgPath { + + /** + * Returns object of PcepEroObject. + * + * @return eroObject + */ + PcepEroObject getEroObject(); + + /** + * Returns object of PcepAttribute. + * + * @return pcepAttribute + */ + PcepAttribute getPcepAttribute(); + + /** + * Sets PcepEroObject. + * + * @param eroObject PCEP ERO Object. + */ + void setEroObject(PcepEroObject eroObject); + + /** + * Sets PcepAttribute. + * + * @param pcepAttribute PCEP-Attribute. + */ + void setPcepAttribute(PcepAttribute pcepAttribute); + + /** + * reads ERO object and attribute list. + * + * @param bb of type channel buffer + * @return PcepMsgPath + * @throws PcepParseException while parsing Message Path from Channel Buffer. + */ + PcepMsgPath read(ChannelBuffer bb) throws PcepParseException; + + /** + * writes ERO object and attribute list to channel. + * + * @param bb of type channel buffer + * @return object length index + * @throws PcepParseException while writing Message Path into Channel Buffer. + */ + + int write(ChannelBuffer bb) throws PcepParseException; + + /** + * Builder interface with get and set functions to build PcepMsgPath. + */ + interface Builder { + + /** + * Builds PcepMsgPath. + * + * @return PcepMsgPath + * @throws PcepParseException when mandatory object is not set + */ + PcepMsgPath build() throws PcepParseException; + + /** + * Returns object of PcepEroObject. + * + * @return PcepEroObject + */ + PcepEroObject getEroObject(); + + /** + * Returns object of PcepAttribute. + * + * @return pcepAttribute + */ + PcepAttribute getPcepAttribute(); + + /** + * Sets PcepEroObject. + * + * @param eroObject PcepEroObject + * @return Builder by setting ERO object. + */ + Builder setEroObject(PcepEroObject eroObject); + + /** + * Sets PcepAttribute. + * + * @param pcepAttribute PCEP-Attribute + * @return Builder by setting PCEP-Attribute. + */ + Builder setPcepAttribute(PcepAttribute pcepAttribute); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepNai.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepNai.java new file mode 100755 index 00000000..6be8c65a --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepNai.java @@ -0,0 +1,40 @@ +/* + * 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; + +import org.jboss.netty.buffer.ChannelBuffer; + +/** + * Abstraction of an entity provides NAI information in SR ERO Object. + */ +public interface PcepNai { + + /** + * To get the ST type of the NAI information. + * + * @return type of ST info + */ + byte getType(); + + /** + * To write the object information to channelBuffer. + * + * @param cb of type channel buffer + * @return length of written bytes. + */ + int write(ChannelBuffer cb); +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepObject.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepObject.java new file mode 100755 index 00000000..26dad566 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepObject.java @@ -0,0 +1,30 @@ +/* + * 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; + +/** + * Abstraction of an entity providing PCEP Object. + */ +public interface PcepObject extends Writeable { + + /** + * Returns Version of PCEP Object. + * + * @return Version of PCEP Object + */ + PcepVersion getVersion(); +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepOpenMsg.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepOpenMsg.java new file mode 100644 index 00000000..904156f0 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepOpenMsg.java @@ -0,0 +1,73 @@ +/* + * 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; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.pcepio.exceptions.PcepParseException; + +/** + * Abstraction of an entity providing PCEP Open Message. + */ +public interface PcepOpenMsg extends PcepObject, PcepMessage { + + @Override + PcepVersion getVersion(); + + @Override + PcepType getType(); + + /** + * Sets OpenObject in Open Message with Specified Obj. + * + * @param obj OpenObject + */ + void setPcepOpenObject(PcepOpenObject obj); + + /** + * Returns OpenObject in Open Message. + * + * @return OpenObject in Open Message + */ + PcepOpenObject getPcepOpenObject(); + + @Override + void writeTo(ChannelBuffer channelBuffer) throws PcepParseException; + + /** + * Builder interface with get and set functions to build Open message. + */ + interface Builder extends PcepMessage.Builder { + + @Override + PcepOpenMsg build() throws PcepParseException; + + /** + * Sets Open Object in Open Message and return its builder. + * + * @param obj Open Object + * @return builder by setting Open Object + */ + Builder setPcepOpenObj(PcepOpenObject obj); + + /** + * Returns OpenObject in Open Message. + * + * @return OpenObject in Open Message + */ + PcepOpenObject getPcepOpenObj(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepOpenObject.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepOpenObject.java new file mode 100755 index 00000000..13dd2fa8 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepOpenObject.java @@ -0,0 +1,221 @@ +/* + * 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; + +import java.util.LinkedList; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.pcepio.exceptions.PcepParseException; +import org.onosproject.pcepio.types.PcepObjectHeader; +import org.onosproject.pcepio.types.PcepValueType; + +/** + * Abstraction of an entity providing PCEP Open Object. + */ +public interface PcepOpenObject { + + /** + * Returns Open object header. + * + * @return Open object header + */ + PcepObjectHeader getOpenObjHeader(); + + /** + * Sets Open object header in Open Object. + * + * @param obj Open object header + */ + void setOpenObjHeader(PcepObjectHeader obj); + + /** + * Returns version of Open Object. + * + * @return Version of Open Object + */ + PcepVersion getVersion(); + + /** + * Returns KeepAlive Time in Open Object. + * + * @return KeepAlive Time in Open Object + */ + byte getKeepAliveTime(); + + /** + * Sets KeepAlive Time in Open Object with specified value. + * + * @param value KeepAlive Time + */ + void setKeepAliveTime(byte value); + + /** + * Returns Dead Time in Open Object. + * + * @return Dead Time in Open Object + */ + byte getDeadTime(); + + /** + * Sets Dead Time in Open Object with specified value. + * + * @param value Dead Time + */ + void setDeadTime(byte value); + + /** + * Returns SessionId in Open Object. + * + * @return SessionId in Open Object + */ + byte getSessionId(); + + /** + * Sets SessionId in Open Object with specified value. + * + * @param value SessionId + */ + void setSessionId(byte value); + + /** + * Returns list of Optional Tlvs in Open Object. + * + * @return list of Optional Tlvs + */ + LinkedList<PcepValueType> getOptionalTlv(); + + /** + * Sets list of Optional Tlvs in Open Object. + * + * @param llOptionalTlv list of Optional Tlvs + */ + void setOptionalTlv(LinkedList<PcepValueType> llOptionalTlv); + + /** + * Writes the Open into channel buffer. + * + * @param bb channel buffer + * @return Returns the writerIndex of this buffer + * @throws PcepParseException while writing Open Object into Channel Buffer. + */ + int write(ChannelBuffer bb) throws PcepParseException; + + /** + * Builder interface with get and set functions to build Open object. + */ + interface Builder { + + /** + * Builds Open Object. + * + * @return Open Object + * @throws PcepParseException while building PCEP-Open object + */ + PcepOpenObject build() throws PcepParseException; + + /** + * Returns Open object header. + * + * @return Open object header + */ + PcepObjectHeader getOpenObjHeader(); + + /** + * Sets Open object header and returns its builder. + * + * @param obj Open object header + * @return Builder by setting Open object header + */ + Builder setOpenObjHeader(PcepObjectHeader obj); + + /** + * Returns KeepAlive Time in Open Object. + * + * @return KeepAlive Time in Open Object + */ + byte getKeepAliveTime(); + + /** + * Sets KeepAlive Time and returns its builder. + * + * @param value KeepAlive Time + * @return Builder by setting KeepAlive Time + */ + Builder setKeepAliveTime(byte value); + + /** + * Returns Dead Time in Open Object. + * + * @return Dead Time in Open Object + */ + byte getDeadTime(); + + /** + * Sets Dead Time and returns its builder. + * + * @param value Dead Time + * @return Builder by setting Dead Time + */ + Builder setDeadTime(byte value); + + /** + * Returns SessionId in Open Object. + * + * @return SessionId in Open Object + */ + byte getSessionId(); + + /** + * Sets SessionId and returns its builder. + * + * @param value SessionId + * @return Builder by setting SessionId + */ + Builder setSessionId(byte value); + + /** + * Returns list of Optional Tlvs in Open Object. + * + * @return list of Optional Tlvs in Open Object + */ + LinkedList<PcepValueType> getOptionalTlv(); + + /** + * Sets list of Optional Tlvs and return its Builder. + * + * @param llOptionalTlv list of Optional Tlvs + * @return builder by setting list of Optional Tlvs + */ + Builder setOptionalTlv(LinkedList<PcepValueType> llOptionalTlv); + + /** + * Sets P flag in Open object header and returns its builder. + * + * @param value boolean value to set P flag + * @return Builder by setting P flag + */ + Builder setPFlag(boolean value); + + /** + * Sets I flag in Open object header and returns its builder. + * + * @param value boolean value to set I flag + * @return Builder by setting I flag + */ + Builder setIFlag(boolean value); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepRPObject.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepRPObject.java new file mode 100755 index 00000000..c6993c3a --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepRPObject.java @@ -0,0 +1,256 @@ +/* + * 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; + +import java.util.LinkedList; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.pcepio.exceptions.PcepParseException; +import org.onosproject.pcepio.types.PcepObjectHeader; +import org.onosproject.pcepio.types.PcepValueType; + +/** + * Abstraction of an entity providing PCEP RP Object. + */ +public interface PcepRPObject { + + /** + * Returns RequestId Number in RP Object. + * + * @return RequestId Number in RP Object + */ + int getRequestIdNum(); + + /** + * Sets RequestId Number with specified value. + * + * @param value RequestId Number + */ + void setRequestIdNum(int value); + + /** + * Returns O flag in RP Object. + * + * @return O flag in RP Object + */ + boolean getOFlag(); + + /** + * Sets O flag with specified value. + * + * @param value O flag + */ + void setOFlag(boolean value); + + /** + * Returns B flag in RP Object. + * + * @return B flag in RP Object + */ + boolean getBFlag(); + + /** + * Sets B flag with specified value. + * + * @param value B flag + */ + void setBFlag(boolean value); + + /** + * Returns R flag in RP Object. + * + * @return R flag in RP Object + */ + boolean getRFlag(); + + /** + * Sets R flag with specified value. + * + * @param value R flag + */ + void setRFlag(boolean value); + + /** + * Returns Priority Flag in RP Object. + * + * @return Priority Flag in RP Object + */ + byte getPriFlag(); + + /** + * Sets Priority Flag with specified value. + * + * @param value Priority Flag + */ + void setPriFlag(byte value); + + /** + * Returns list of Optional Tlvs in RP Object. + * + * @return list of Optional Tlvs in RP Object + */ + LinkedList<PcepValueType> getOptionalTlv(); + + /** + * Sets list of Optional Tlvs in RP Object and returns its builder. + * + * @param llOptionalTlv list of Optional Tlvs + */ + void setOptionalTlv(LinkedList<PcepValueType> llOptionalTlv); + + /** + * Writes the RP Object into channel buffer. + * + * @param bb channel buffer + * @return Returns the writerIndex of this buffer + * @throws PcepParseException while writing RP object into Channel Buffer. + */ + int write(ChannelBuffer bb) throws PcepParseException; + + /** + * Builder interface with get and set functions to build bandwidth object. + */ + interface Builder { + + /** + * Builds RP Object. + * + * @return RP Object + */ + PcepRPObject build(); + + /** + * Returns RP object header. + * + * @return RP object header + */ + PcepObjectHeader getRPObjHeader(); + + /** + * Sets RP object header and returns its builder. + * + * @param obj RP object header + * @return Builder by setting RP object header + */ + Builder setRPObjHeader(PcepObjectHeader obj); + + /** + * Returns Request Id Number in RP Object. + * + * @return Request Id Number in RP Object + */ + int getRequestIdNum(); + + /** + * Sets Request Id Number and returns its builder. + * + * @param value Request Id Number + * @return Builder by setting Request Id Number + */ + Builder setRequestIdNum(int value); + + /** + * Returns O flag in RP Object. + * + * @return O flag in RP Object + */ + boolean getOFlag(); + + /** + * Sets O flag and returns its builder. + * + * @param value O flag + * @return Builder by setting O flag + */ + Builder setOFlag(boolean value); + + /** + * Returns B flag in RP Object. + * + * @return B flag in RP Object + */ + boolean getBFlag(); + + /** + * Sets B flag and returns its builder. + * + * @param value B flag + * @return Builder by setting B flag + */ + Builder setBFlag(boolean value); + + /** + * Returns R flag in RP Object. + * + * @return R flag in RP Object + */ + boolean getRFlag(); + + /** + * Sets R flag and returns its builder. + * + * @param value R flag + * @return Builder by setting R flag + */ + Builder setRFlag(boolean value); + + /** + * Returns Priority Flag in RP Object. + * + * @return Priority Flag in RP Object + */ + byte getPriFlag(); + + /** + * Sets Priority Flag and returns its builder. + * + * @param value Priority Flag + * @return Builder by setting Priority Flag + */ + Builder setPriFlag(byte value); + + /** + * Returns list of Optional Tlvs in RP Object. + * + * @return list of Optional Tlvs + */ + LinkedList<PcepValueType> getOptionalTlv(); + + /** + * Sets list of Optional Tlvs and returns its builder. + * + * @param llOptionalTlv list of Optional Tlvs + * @return Builder by setting list of Optional Tlvs + */ + Builder setOptionalTlv(LinkedList<PcepValueType> llOptionalTlv); + + /** + * Sets P flag in RP object header and returns its builder. + * + * @param value boolean value to set P flag + * @return Builder by setting P flag + */ + Builder setPFlag(boolean value); + + /** + * Sets I flag in RP object header and returns its builder. + * + * @param value boolean value to set I flag + * @return Builder by setting I flag + */ + Builder setIFlag(boolean value); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepReportMsg.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepReportMsg.java new file mode 100755 index 00000000..f4355206 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepReportMsg.java @@ -0,0 +1,81 @@ +/* + * 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; + +import java.util.LinkedList; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.pcepio.exceptions.PcepParseException; + +/** + * Abstraction of an entity providing PCEP Report Message. + */ +public interface PcepReportMsg extends PcepObject, PcepMessage { + + @Override + PcepVersion getVersion(); + + @Override + PcepType getType(); + + /** + * Returns PcepStateReport list. + * + * @return list of PcepStateReport + */ + LinkedList<PcepStateReport> getStateReportList(); + + /** + * Sets StateReportList. + * + * @param llStateReportList list of PcepStateReport. + */ + void setStateReportList(LinkedList<PcepStateReport> llStateReportList); + + @Override + void writeTo(ChannelBuffer channelBuffer) throws PcepParseException; + + /** + * Builder interface with get and set functions to build Report message. + */ + interface Builder extends PcepMessage.Builder { + + @Override + PcepReportMsg build(); + + @Override + PcepVersion getVersion(); + + @Override + PcepType getType(); + + /** + * Returns StateReportList. + * + * @return StateReportList. + */ + LinkedList<PcepStateReport> getStateReportList(); + + /** + * Sets list of PcepStateReport and returns builder. + * + * @param llStateReportList list of PcepStateReport. + * @return Builder by setting list of PcepStateReport. + */ + Builder setStateReportList(LinkedList<PcepStateReport> llStateReportList); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepRroObject.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepRroObject.java new file mode 100755 index 00000000..928ce1a6 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepRroObject.java @@ -0,0 +1,111 @@ +/* + * 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; + +import java.util.LinkedList; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.pcepio.exceptions.PcepParseException; +import org.onosproject.pcepio.types.PcepObjectHeader; +import org.onosproject.pcepio.types.PcepValueType; + +/** + * Abstraction of an entity providing PCEP RRO Object. + */ +public interface PcepRroObject { + + /** + * Returns list of SubObjects. + * + * @return list of SubObjects + */ + LinkedList<PcepValueType> getSubObjects(); + + /** + * Sets list of SubObjects and return its builder. + * + * @param llSubObjects list of SubObjects + */ + void setSubObjects(LinkedList<PcepValueType> llSubObjects); + + /** + * Writes the RRO Object into channel buffer. + * + * @param bb channel buffer + * @return Returns the writerIndex of this buffer + * @throws PcepParseException when object header failed to write in channel buffer + */ + int write(ChannelBuffer bb) throws PcepParseException; + + /** + * Builder interface with get and set functions to build RRO object. + */ + interface Builder { + + /** + * Builds RRO Object. + * + * @return RRO Object + */ + PcepRroObject build(); + + /** + * Returns RRO object header. + * + * @return RRO object header + */ + PcepObjectHeader getRroObjHeader(); + + /** + * Sets RRO object header and returns its builder. + * + * @param obj RRO object header + * @return Builder by setting RRO object header + */ + Builder setRroObjHeader(PcepObjectHeader obj); + + /** + * Returns list of SubObjects. + * + * @return list of SubObjects + */ + LinkedList<PcepValueType> getSubObjects(); + + /** + * Sets list of SubObjects in RRO Object and returns its builder. + * + * @param llSubObjects list of SubObjects + * @return Builder by setting list of SubObjects + */ + Builder setSubObjects(LinkedList<PcepValueType> llSubObjects); + + /** + * Sets P flag in RRO object header and returns its builder. + * + * @param value boolean value to set P flag + * @return Builder by setting P flag + */ + Builder setPFlag(boolean value); + + /** + * Sets I flag in RRO object header and returns its builder. + * + * @param value boolean value to set I flag + * @return Builder by setting I flag + */ + Builder setIFlag(boolean value); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepSrpObject.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepSrpObject.java new file mode 100755 index 00000000..e4816efd --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepSrpObject.java @@ -0,0 +1,171 @@ +/* + * 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; + +import java.util.LinkedList; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.pcepio.exceptions.PcepParseException; +import org.onosproject.pcepio.types.PcepObjectHeader; +import org.onosproject.pcepio.types.PcepValueType; + +/** + * Abstraction of an entity providing PCEP SRP Object. + */ +public interface PcepSrpObject { + + /** + * Returns SRP ID of SRP Object. + * + * @return SRP ID of SRP Object + */ + int getSrpID(); + + /** + * Sets SRP ID with specified value. + * + * @param srpID SRP ID of SRP Object + */ + void setSrpID(int srpID); + + /** + * Returns R flag of SRP Object. + * + * @return R flag of SRP Object + */ + boolean getRFlag(); + + /** + * Sets R flag with specified value. + * + * @param bRFlag R Flag of SRP Object + */ + void setRFlag(boolean bRFlag); + + /** + * sets the optional TLvs. + * + * @param llOptionalTlv list of optional tlvs + */ + void setOptionalTlv(LinkedList<PcepValueType> llOptionalTlv); + + /** + * Returns list of optional tlvs. + * + * @return llOptionalTlv list of optional tlvs + */ + LinkedList<PcepValueType> getOptionalTlv(); + + /** + * Writes the SRP Object into channel buffer. + * + * @param bb channel buffer + * @return Returns the writerIndex of this buffer + * @throws PcepParseException when tlv is null + */ + int write(ChannelBuffer bb) throws PcepParseException; + + /** + * Builder interface with get and set functions to build SRP object. + */ + interface Builder { + + /** + * Builds SRP Object. + * + * @return SRP Object + * @throws PcepParseException when mandatory object is not set + */ + PcepSrpObject build() throws PcepParseException; + + /** + * Returns SRP object header. + * + * @return SRP object header + */ + PcepObjectHeader getSrpObjHeader(); + + /** + * Sets SRP object header and returns its builder. + * + * @param obj SRP object header + * @return Builder by setting SRP object header + */ + Builder setSrpObjHeader(PcepObjectHeader obj); + + /** + * Returns SRP ID of SRP Object. + * + * @return SRP ID of SRP Object + */ + int getSrpID(); + + /** + * Sets SRP ID and returns its builder. + * + * @param srpID SRP ID + * @return Builder by setting SRP ID + */ + Builder setSrpID(int srpID); + + /** + * Returns R flag of SRP Object. + * + * @return R flag of SRP Object + */ + boolean getRFlag(); + + /** + * Sets R flag and returns its builder. + * + * @param bRFlag R flag + * @return Builder by setting R flag + */ + Builder setRFlag(boolean bRFlag); + + /** + * Returns list of optional tlvs. + * + * @return llOptionalTlv list of optional tlvs + */ + LinkedList<PcepValueType> getOptionalTlv(); + + /** + * sets the optional TLvs. + * + * @param llOptionalTlv List of optional tlv + * @return builder by setting list of optional tlv. + */ + Builder setOptionalTlv(LinkedList<PcepValueType> llOptionalTlv); + + /** + * Sets P flag in SRP object header and returns its builder. + * + * @param value boolean value to set P flag + * @return Builder by setting P flag + */ + Builder setPFlag(boolean value); + + /** + * Sets I flag in SRP object header and returns its builder. + * + * @param value boolean value to set I flag + * @return Builder by setting I flag + */ + Builder setIFlag(boolean value); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepStateReport.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepStateReport.java new file mode 100755 index 00000000..b8ab9ec8 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepStateReport.java @@ -0,0 +1,207 @@ +/* + * 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; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.pcepio.exceptions.PcepParseException; + +/** + * Abstraction of an entity provides State Report for PCEP Report Message. + */ +public interface PcepStateReport { + + /** + * Provides PCEP Message path for report message. + */ + interface PcepMsgPath { + + /** + * Returns PcepEroObject. + * + * @return eroObj + */ + PcepEroObject getEroObject(); + + /** + * Sets PcepEroObject. + * + * @param eroObject Ero Object + */ + void setEroObject(PcepEroObject eroObject); + + /** + * Returns PcepAttribute. + * + * @return attrList + */ + PcepAttribute getPcepAttribute(); + + /** + * Sets PcepAttribute. + * + * @param pcepAttribute Pcep Attribute object + */ + void setPcepAttribute(PcepAttribute pcepAttribute); + + /** + * Returns PcepRroObject. + * + * @return rroObj + */ + PcepRroObject getRroObject(); + + /** + * Sets PcepRroObject. + * + * @param rroObject Rro object + */ + void setRroObject(PcepRroObject rroObject); + + /** + * Returns PcepBandwidthObject. + * + * @return bandwidth object + */ + PcepBandwidthObject getBandwidthObject(); + + /** + * Sets PcepBandwidthObject. + * + * @param bandwidth bandwidth object + */ + void setBandwidthObject(PcepBandwidthObject bandwidth); + + /** + * Reads all the Objects for PCEP Message Path. + * + * @param bb of type channel buffer + * @return PCEP Message path + * @throws PcepParseException when invalid buffer received + */ + PcepMsgPath read(ChannelBuffer bb) throws PcepParseException; + + /** + * Writes all the objects for pcep message path. + * + * @param bb of type channel buffer. + * @return object length index + * @throws PcepParseException when mandatory object is not set + */ + int write(ChannelBuffer bb) throws PcepParseException; + } + + /** + * Returns PcepSrpObject. + * + * @return srpObject + */ + PcepSrpObject getSrpObject(); + + /** + * Returns PcepLspObject. + * + * @return lspObject + */ + PcepLspObject getLspObject(); + + /** + * Returns PcepMsgPath. + * + * @return msgPath + */ + PcepMsgPath getMsgPath(); + + /** + * Sets the SRP Object. + * + * @param srpObj Pcep Srp Object + */ + void setSrpObject(PcepSrpObject srpObj); + + /** + * Sets the LSP Object. + * + * @param lspObject Pcep Lsp Object + */ + void setLspObject(PcepLspObject lspObject); + + /** + * Sets the Path Object. + * + * @param msgPath Pcep MsgPath object + */ + void setMsgPath(PcepMsgPath msgPath); + + /** + * Builder interface with get and set functions to build PcepStateReport. + */ + interface Builder { + + /** + * Builds PcepStateReport. + * + * @return PcepStateReport + * @throws PcepParseException when mandatory object is not set + */ + PcepStateReport build() throws PcepParseException; + + /** + * Returns PcepSrpObject. + * + * @return srpObject + */ + PcepSrpObject getSrpObject(); + + /** + * Returns PcepLspObject. + * + * @return lspObject + */ + PcepLspObject getLspObject(); + + /** + * Returns PcepMsgPath. + * + * @return msgPath + */ + PcepMsgPath getMsgPath(); + + /** + * Sets the SRP Object. + * + * @param srpObj Pcep Srp Object + * @return builder by setting PcepSrpObject + */ + Builder setSrpObject(PcepSrpObject srpObj); + + /** + * Sets the LSP Object. + * + * @param lspObject Pcep Lsp Object + * @return builder by setting PcepLspObject + */ + Builder setLspObject(PcepLspObject lspObject); + + /** + * Sets the Path Object. + * + * @param msgPath Pcep MsgPath object + * @return builder by setting PcepMsgPath + */ + Builder setMsgPath(PcepMsgPath msgPath); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepTEObject.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepTEObject.java new file mode 100755 index 00000000..21f6c71c --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepTEObject.java @@ -0,0 +1,241 @@ +/* + * 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; + +import java.util.LinkedList; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.pcepio.exceptions.PcepParseException; +import org.onosproject.pcepio.types.PcepObjectHeader; +import org.onosproject.pcepio.types.PcepValueType; + +/** + * Abstraction of an entity providing PCEP TE Object. + */ +public interface PcepTEObject { + + /** + * Returns TE object header. + * + * @return TE object header + */ + PcepObjectHeader getTEObjHeader(); + + /** + * Sets TE Object header. + * + * @param obj TE Object header + */ + void setTEObjHeader(PcepObjectHeader obj); + + /** + * Returns ProtocolId in TE Object. + * + * @return ProtocolId in TE Object + */ + byte getProtocolId(); + + /** + * Sets ProtocolId in TE Object. + * + * @param yProtId ProtocolId in TE Object + */ + void setProtocolId(byte yProtId); + + /** + * Returns R flag in TE Object. + * + * @return R flag in TE Object + */ + boolean getRFlag(); + + /** + * Sets R flag in TE Object. + * + * @param bRFlag R flag in TE Object + */ + void setRFlag(boolean bRFlag); + + /** + * Returns S flag in TE Object. + * + * @return S flag in TE Object + */ + boolean getSFlag(); + + /** + * Sets S flag in TE Object. + * + * @param bSFlag S flag in TE Object + */ + void setSFlag(boolean bSFlag); + + /** + * Returns TE ID in TE Object. + * + * @return TE ID in TE Object + */ + int getTEId(); + + /** + * Sets TE ID in TE Object. + * + * @param iTEId TE ID in TE Object + */ + void setTEId(int iTEId); + + /** + * Returns list of Optional Tlvs in TE Object. + * + * @return list of Optional Tlvs + */ + LinkedList<PcepValueType> getOptionalTlv(); + + /** + * Sets list of Optional Tlvs in TE Object. + * + * @param llOptionalTlv list of Optional Tlvs + */ + void setOptionalTlv(LinkedList<PcepValueType> llOptionalTlv); + + /** + * Writes the TE Object into channel buffer. + * + * @param bb channel buffer + * @return Returns the writerIndex of this buffer + * @throws PcepParseException when obj header is not written to channel buffer + */ + int write(ChannelBuffer bb) throws PcepParseException; + + /** + * Builder interface with get and set functions to build TE object. + */ + interface Builder { + + /** + * Builds TE Object. + * + * @return TE Object + */ + PcepTEObject build(); + + /** + * Returns TE object header. + * + * @return TE object header + */ + PcepObjectHeader getTEObjHeader(); + + /** + * Sets TE object header and returns its builder. + * + * @param obj TE object header + * @return Builder by setting TE object header + */ + Builder setTEObjHeader(PcepObjectHeader obj); + + /** + * Returns ProtocolId in TE Object. + * + * @return ProtocolId in TE Object + */ + byte getProtocolId(); + + /** + * Sets ProtocolId in TE Object and returns its builder. + * + * @param yProtId ProtocolId in TE Object + * @return Builder by setting ProtocolId + */ + Builder setProtocolId(byte yProtId); + + /** + * Returns R flag in TE Object. + * + * @return R flag in TE Object + */ + boolean getRFlag(); + + /** + * Sets R flag in TE Object and returns its builder. + * + * @param bRFlag R flag in TE Object + * @return Builder by setting R flag + */ + Builder setRFlag(boolean bRFlag); + + /** + * Returns S flag in TE Object. + * + * @return S flag in TE Object + */ + boolean getSFlag(); + + /** + * Sets S flag in TE Object and returns its builder. + * + * @param bSFlag S flag in TE Object + * @return Builder by setting S flag + */ + Builder setSFlag(boolean bSFlag); + + /** + * Returns TE ID in TE Object. + * + * @return TE ID in TE Object + */ + int getTEId(); + + /** + * Sets TE ID in TE Object and returns its builder. + * + * @param iTEId TE ID in TE Object + * @return Builder by setting TE ID + */ + Builder setTEId(int iTEId); + + /** + * Returns list of Optional Tlvs in TE Object. + * + * @return list of Optional Tlvs + */ + LinkedList<PcepValueType> getOptionalTlv(); + + /** + * Sets list of Optional Tlvs in TE Object and returns its builder. + * + * @param llOptionalTlv list of Optional Tlvs + * @return Builder by setting list of Optional Tlvs + */ + Builder setOptionalTlv(LinkedList<PcepValueType> llOptionalTlv); + + /** + * Sets P flag in TE object header and returns its builder. + * + * @param value boolean value to set P flag + * @return Builder by setting P flag + */ + Builder setPFlag(boolean value); + + /** + * Sets I flag in TE object header and returns its builder. + * + * @param value boolean value to set I flag + * @return Builder by setting I flag + */ + Builder setIFlag(boolean value); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepTEReportMsg.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepTEReportMsg.java new file mode 100755 index 00000000..3bc5034e --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepTEReportMsg.java @@ -0,0 +1,81 @@ +/* + * 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; + +import java.util.LinkedList; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.pcepio.exceptions.PcepParseException; + +/** + * Abstraction of an entity providing PCEP TE Report Message. + */ +public interface PcepTEReportMsg extends PcepObject, PcepMessage { + + @Override + PcepVersion getVersion(); + + @Override + PcepType getType(); + + /** + * Returns list of PCEP TE Objects. + * + * @return list of PCEP TE Objects + */ + LinkedList<PcepTEObject> getTEReportList(); + + /** + * Sets list of Optional Tlvs in TE Report Message. + * + * @param llTEReportList list of optional Tlvs + */ + void setTEReportList(LinkedList<PcepTEObject> llTEReportList); + + @Override + void writeTo(ChannelBuffer channelBuffer) throws PcepParseException; + + /** + * Builder interface with get and set functions to build TE Report message. + */ + interface Builder extends PcepMessage.Builder { + + @Override + PcepTEReportMsg build(); + + @Override + PcepVersion getVersion(); + + @Override + PcepType getType(); + + /** + * Returns list of Optional Tlv in TE Report Message. + * + * @return list of Optional Tlv + */ + LinkedList<PcepTEObject> getTEReportList(); + + /** + * Sets list of Optional Tlvs and returns its builder. + * + * @param llTEReportList list of Optional Tlvs + * @return Builder object for TE report message + */ + Builder setTEReportList(LinkedList<PcepTEObject> llTEReportList); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepType.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepType.java new file mode 100755 index 00000000..450fdfac --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepType.java @@ -0,0 +1,49 @@ +/* + * 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; + +/** + * Enum to Provide the Different types of PCEP messages. + */ +public enum PcepType { + + NONE(0), OPEN(1), KEEP_ALIVE(2), PATH_COMPUTATION_REQUEST(3), PATH_COMPUTATION_REPLY(4), + NOTIFICATION(5), ERROR(6), CLOSE(7), REPORT(10), UPDATE(11), INITIATE(12), LABEL_UPDATE(13), + TE_REPORT(14), LABEL_RANGE_RESERV(15), MAX(16), END(17); + + int iValue; + + /** + * Assign iValue with the value iVal as the types of PCEP message. + * + * @param iVal type of pcep message + */ + PcepType(int iVal) { + + iValue = iVal; + } + + /** + * Returns iValue as type of PCEP message. + * + * @return iValue type of pcep message + */ + public byte getType() { + + return (byte) iValue; + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepUpdateMsg.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepUpdateMsg.java new file mode 100755 index 00000000..dc2ac3a8 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepUpdateMsg.java @@ -0,0 +1,81 @@ +/* + * 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; + +import java.util.LinkedList; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.pcepio.exceptions.PcepParseException; + +/** + * Abstraction of an entity providing PCEP Update Message. + */ +public interface PcepUpdateMsg extends PcepObject, PcepMessage { + + @Override + PcepVersion getVersion(); + + @Override + PcepType getType(); + + /** + * Returns the update request list for PCEP Update Message. + * + * @return list of Update Requests + */ + LinkedList<PcepUpdateRequest> getUpdateRequestList(); + + /** + * Sets the update request list for PCEP update message. + * + * @param llUpdateRequestList is a list of PCEP Update Requests + */ + void setUpdateRequestList(LinkedList<PcepUpdateRequest> llUpdateRequestList); + + @Override + void writeTo(ChannelBuffer channelBuffer) throws PcepParseException; + + /** + * Builder interface with Get and Set Functions to build the PCEP update Message. + */ + interface Builder extends PcepMessage.Builder { + + @Override + PcepUpdateMsg build(); + + @Override + PcepVersion getVersion(); + + @Override + PcepType getType(); + + /** + * Returns the update request list for the PCEP update message. + * + * @return list of Update Requests + */ + LinkedList<PcepUpdateRequest> getUpdateRequestList(); + + /** + * Sets the update request list for the PCEP update message. + * + * @param llUpdateRequestList list of Update requests + * @return builder by setting list llUpdateRequestList of PcepUpdateRequest. + */ + Builder setUpdateRequestList(LinkedList<PcepUpdateRequest> llUpdateRequestList); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepUpdateRequest.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepUpdateRequest.java new file mode 100755 index 00000000..8d1c89e2 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepUpdateRequest.java @@ -0,0 +1,126 @@ +/* + * 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; + +import org.onosproject.pcepio.exceptions.PcepParseException; + +/** + * Abstraction of an entity providing PCEP Update Request List. + */ +public interface PcepUpdateRequest { + + /** + * Returns object of PCEP SRP Object. + * + * @return srpObject of type PCEP SRP Object + */ + PcepSrpObject getSrpObject(); + + /** + * Returns object of PCEP LSP Object. + * + * @return lspObject of type PCEP LSP Object + */ + PcepLspObject getLspObject(); + + /** + * Returns object of PCEP MSG PATH. + * + * @return msgPath of type PCEP MSG PATH + */ + PcepMsgPath getMsgPath(); + + /** + * Sets the PCEP SRP Object. + * + * @param srpObject object of type PCEP SRP Object + */ + void setSrpObject(PcepSrpObject srpObject); + + /** + * Sets the PCEP LSP Object. + * + * @param lspObject object of type PCEP LSP Object + */ + void setLspObject(PcepLspObject lspObject); + + /** + * sets the PCEP MSG PATH. + * + * @param msgPath object of type PCEP MSG PATH + */ + void setMsgPath(PcepMsgPath msgPath); + + /** + * Builder interface with get and set functions to build PcepUpdateRequest. + */ + interface Builder { + + /** + * Builds PcepUpdateRequest. + * + * @return PcepUpdateRequest + * @throws PcepParseException if mandatory object is not set + */ + PcepUpdateRequest build() throws PcepParseException; + + /** + * Returns PcepSrpObject. + * + * @return srpObject + */ + PcepSrpObject getSrpObject(); + + /** + * Returns PcepLspObject. + * + * @return lspObject + */ + PcepLspObject getLspObject(); + + /** + * Returns PcepMsgPath. + * + * @return msgPath + */ + PcepMsgPath getMsgPath(); + + /** + * Sets the SRP Object. + * + * @param srpObj of type PcepSrpObject + * @return builder by setting PcepSrpObject + */ + Builder setSrpObject(PcepSrpObject srpObj); + + /** + * Sets the LSP Object. + * + * @param lspObject of type PcepLspObject + * @return builder by setting PcepLspObject + */ + Builder setLspObject(PcepLspObject lspObject); + + /** + * Sets the Path Object. + * + * @param msgPath of type PcepMsgPath + * @return builder by setting PcepMsgPath + */ + Builder setMsgPath(PcepMsgPath msgPath); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepVersion.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepVersion.java new file mode 100755 index 00000000..c761ed08 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepVersion.java @@ -0,0 +1,46 @@ +/* + * 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; + +/** + * Enum to provide PCEP Message Version. + */ +public enum PcepVersion { + + PCEP_1(1); + + public final int packetVersion; + + /** + * Assign PCEP PacketVersion with WireVersion. + * + * @param wireVersion version of pcep + */ + PcepVersion(final int wireVersion) { + + this.packetVersion = wireVersion; + } + + /** + * Returns Wire version of PCEP Message. + * + * @return packetVersion + */ + public int getWireVersion() { + return packetVersion; + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/Writeable.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/Writeable.java new file mode 100755 index 00000000..37aef58d --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/Writeable.java @@ -0,0 +1,35 @@ +/* + * 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; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.pcepio.exceptions.PcepParseException; + +/** + * Abstraction of an entity providing functionality to write byte streams of + * Messages to channel buffer. + */ +public interface Writeable { + + /** + * Writes byte streams of messages to channel buffer. + * + * @param bb parameter of type channel buffer + * @throws PcepParseException when error occurs while writing pcep message to channel buffer + */ + void writeTo(ChannelBuffer bb) throws PcepParseException; +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/package-info.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/package-info.java new file mode 100644 index 00000000..53ee5934 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/package-info.java @@ -0,0 +1,20 @@ +/* + * 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. + */ + +/** + * Abstraction of an entity providing PCEP messages. + */ +package org.onosproject.pcepio.protocol; diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcInitiatedLspRequestVer1.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcInitiatedLspRequestVer1.java new file mode 100644 index 00000000..d61f7319 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcInitiatedLspRequestVer1.java @@ -0,0 +1,291 @@ +/* + * 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 org.onosproject.pcepio.exceptions.PcepParseException; +import org.onosproject.pcepio.protocol.PcInitiatedLspRequest; +import org.onosproject.pcepio.protocol.PcepAttribute; +import org.onosproject.pcepio.protocol.PcepEndPointsObject; +import org.onosproject.pcepio.protocol.PcepEroObject; +import org.onosproject.pcepio.protocol.PcepLspObject; +import org.onosproject.pcepio.protocol.PcepSrpObject; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.google.common.base.MoreObjects; + +/** + * Provides PcInitiatedLspRequest for PCEP Initiate message. + * Reference : PCE initiated tunnel setup draft-ietf-pce-pce-initiated-lsp-03. + */ +public class PcInitiatedLspRequestVer1 implements PcInitiatedLspRequest { + + /* + * <PCE-initiated-lsp-request> ::= (<PCE-initiated-lsp-instantiation>|<PCE-initiated-lsp-deletion>) + <PCE-initiated-lsp-instantiation> ::= <SRP> + <LSP> + <END-POINTS> + <ERO> + [<attribute-list>] + <PCE-initiated-lsp-deletion> ::= <SRP> + <LSP> + */ + + protected static final Logger log = LoggerFactory.getLogger(PcInitiatedLspRequestVer1.class); + + //PCEP SRP Object + private PcepSrpObject srpObject; + //PCEP LSP Object + private PcepLspObject lspObject; + //PCEP End Point Object + private PcepEndPointsObject endPointsObject; + //PCEP ERO Object + private PcepEroObject eroObject; + //PCEP Attribute list + private PcepAttribute pcepAttribute; + + /** + * Default constructor. + */ + public PcInitiatedLspRequestVer1() { + srpObject = null; + lspObject = null; + endPointsObject = null; + eroObject = null; + pcepAttribute = null; + + } + + /** + * Constructor to initialize all parameters of PC initiated lsp request. + * + * @param srpObject PCEP srp Object + * @param lspObject PCEP lsp object + * @param endPointsObject PCPE endpoints object + * @param eroObject PCEP ero object + * @param pcepAttribute PCEP attribute + */ + public PcInitiatedLspRequestVer1(PcepSrpObject srpObject, PcepLspObject lspObject, + PcepEndPointsObject endPointsObject, PcepEroObject eroObject, PcepAttribute pcepAttribute) { + this.srpObject = srpObject; + this.lspObject = lspObject; + this.endPointsObject = endPointsObject; + this.eroObject = eroObject; + this.pcepAttribute = pcepAttribute; + + } + + @Override + public PcepSrpObject getSrpObject() { + return srpObject; + } + + @Override + public PcepLspObject getLspObject() { + return lspObject; + } + + @Override + public PcepEndPointsObject getEndPointsObject() { + return endPointsObject; + } + + @Override + public PcepEroObject getEroObject() { + return eroObject; + } + + @Override + public PcepAttribute getPcepAttribute() { + return pcepAttribute; + } + + @Override + public void setSrpObject(PcepSrpObject srpobj) { + this.srpObject = srpobj; + + } + + @Override + public void setLspObject(PcepLspObject lspObject) { + this.lspObject = lspObject; + } + + @Override + public void setEndPointsObject(PcepEndPointsObject endPointsObject) { + this.endPointsObject = endPointsObject; + } + + @Override + public void setEroObject(PcepEroObject eroObject) { + this.eroObject = eroObject; + } + + @Override + public void setPcepAttribute(PcepAttribute pcepAttribute) { + this.pcepAttribute = pcepAttribute; + } + + /** + * Builder class for PC initiated lsp reuqest. + */ + public static class Builder implements PcInitiatedLspRequest.Builder { + + private boolean bIsSRPObjectSet = false; + private boolean bIsLSPObjectSet = false; + private boolean bIsEndPointsObjectSet = false; + private boolean bIsEROObjectSet = false; + private boolean bIsPcepAttributeSet = false; + private boolean bIsbRFlagSet = false; + + //PCEP SRP Object + private PcepSrpObject srpObject; + //PCEP LSP Object + private PcepLspObject lspObject; + //PCEP End Point Object + private PcepEndPointsObject endPointsObject; + //PCEP ERO Object + private PcepEroObject eroObject; + //PCEP Attribute list + private PcepAttribute pcepAttribute; + + @Override + public PcInitiatedLspRequest build() throws PcepParseException { + + //PCEP SRP Object + PcepSrpObject srpObject = null; + //PCEP LSP Object + PcepLspObject lspObject = null; + //PCEP End Point Object + PcepEndPointsObject endPointsObject = null; + //PCEP ERO Object + PcepEroObject eroObject = null; + //PCEP Attribute list + PcepAttribute pcepAttribute = null; + boolean bRFlag = false; + + if (!this.bIsSRPObjectSet) { + throw new PcepParseException("Srp object NOT Set while building PcInitiatedLspRequest"); + } else { + srpObject = this.srpObject; + bRFlag = srpObject.getRFlag(); + } + + if (bRFlag) { + this.bIsbRFlagSet = true; + } else { + this.bIsbRFlagSet = false; + } + + if (!this.bIsLSPObjectSet) { + throw new PcepParseException("LSP Object NOT Set while building PcInitiatedLspRequest"); + } else { + lspObject = this.lspObject; + } + if (!this.bIsbRFlagSet) { + + if (!this.bIsEndPointsObjectSet) { + throw new PcepParseException("EndPoints Object NOT Set while building PcInitiatedLspRequest"); + } else { + endPointsObject = this.endPointsObject; + } + if (!this.bIsEROObjectSet) { + throw new PcepParseException("ERO Object NOT Set while building PcInitiatedLspRequest"); + } else { + eroObject = this.eroObject; + } + if (bIsPcepAttributeSet) { + pcepAttribute = this.pcepAttribute; + } + } + return new PcInitiatedLspRequestVer1(srpObject, lspObject, endPointsObject, eroObject, pcepAttribute); + } + + @Override + public PcepSrpObject getSrpObject() { + return this.srpObject; + } + + @Override + public PcepLspObject getLspObject() { + return this.lspObject; + } + + @Override + public PcepEndPointsObject getEndPointsObject() { + return this.endPointsObject; + } + + @Override + public PcepEroObject getEroObject() { + return this.eroObject; + } + + @Override + public PcepAttribute getPcepAttribute() { + return this.pcepAttribute; + } + + @Override + public Builder setSrpObject(PcepSrpObject srpobj) { + this.srpObject = srpobj; + this.bIsSRPObjectSet = true; + return this; + + } + + @Override + public Builder setLspObject(PcepLspObject lspObject) { + this.lspObject = lspObject; + this.bIsLSPObjectSet = true; + return this; + } + + @Override + public Builder setEndPointsObject(PcepEndPointsObject endPointsObject) { + this.endPointsObject = endPointsObject; + this.bIsEndPointsObjectSet = true; + return this; + } + + @Override + public Builder setEroObject(PcepEroObject eroObject) { + this.eroObject = eroObject; + this.bIsEROObjectSet = true; + return this; + } + + @Override + public Builder setPcepAttribute(PcepAttribute pcepAttribute) { + this.pcepAttribute = pcepAttribute; + this.bIsPcepAttributeSet = true; + return this; + } + } + + @Override + public String toString() { + return MoreObjects.toStringHelper(getClass()) + .omitNullValues() + .add("SrpObject", srpObject) + .add("LspObject", lspObject) + .add("EndPointObject", endPointsObject) + .add("EroObject", eroObject) + .add("PcepAttribute", pcepAttribute) + .toString(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepAttributeVer1.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepAttributeVer1.java new file mode 100644 index 00000000..65a844c2 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepAttributeVer1.java @@ -0,0 +1,431 @@ +/* + * 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.PcepAttribute; +import org.onosproject.pcepio.protocol.PcepBandwidthObject; +import org.onosproject.pcepio.protocol.PcepIroObject; +import org.onosproject.pcepio.protocol.PcepLspaObject; +import org.onosproject.pcepio.protocol.PcepMetricObject; +import org.onosproject.pcepio.types.PcepObjectHeader; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.google.common.base.MoreObjects; + +/** + * Provides PCEP Attribute List. + */ +public class PcepAttributeVer1 implements PcepAttribute { + + /* Reference : RFC5440 + * where: + * <attribute-list> ::=[<LSPA>] + * [<BANDWIDTH>] + * [<metric-list>] + * [<IRO>] + * + * <metric-list> ::=<METRIC>[<metric-list>] + */ + protected static final Logger log = LoggerFactory.getLogger(PcepAttributeVer1.class); + + public static final int OBJECT_HEADER_LENGTH = 4; + + //PCEP LSPA Object + private PcepLspaObject lspaObject; + private boolean isLspaObjectSet; + + //PCEP Bandwidth Object + private PcepBandwidthObject bandwidthObject; + private boolean isBandwidthObjectSet; + + //PCEP Metric list + private LinkedList<PcepMetricObject> llMetricList; + private boolean isMetricListSet; + + //PCEP IRO object + private PcepIroObject iroObject; + private boolean isIroObjectSet; + + /** + * Default constructor to initialize member variables. + */ + public PcepAttributeVer1() { + + lspaObject = null; + bandwidthObject = null; + llMetricList = null; + iroObject = null; + this.isLspaObjectSet = false; + this.isBandwidthObjectSet = false; + this.isMetricListSet = false; + this.isIroObjectSet = false; + } + + /** + * Constructor to initialize all parameters for PCEP attribute. + * + * @param lspaObject PCEP lspa Object. + * @param bandwidthObject PCEP bandwidth object. + * @param llMetricList list of PCEP metric objects. + * @param iroObject PCEP iro object. + */ + public PcepAttributeVer1(PcepLspaObject lspaObject, PcepBandwidthObject bandwidthObject, + LinkedList<PcepMetricObject> llMetricList, PcepIroObject iroObject) { + + this.lspaObject = lspaObject; + this.bandwidthObject = bandwidthObject; + this.llMetricList = llMetricList; + this.iroObject = iroObject; + if (lspaObject == null) { + this.isLspaObjectSet = false; + } else { + this.isLspaObjectSet = true; + } + if (bandwidthObject == null) { + this.isBandwidthObjectSet = false; + } else { + this.isBandwidthObjectSet = true; + } + if (llMetricList == null) { + this.isMetricListSet = false; + } else { + this.isMetricListSet = true; + } + if (iroObject == null) { + this.isIroObjectSet = false; + } else { + this.isIroObjectSet = true; + } + } + + /** + * constructor to initialize bandwidthObject. + * + * @param bandwidthObject bandwidth object + */ + public PcepAttributeVer1(PcepBandwidthObject bandwidthObject) { + this.isLspaObjectSet = false; + + this.bandwidthObject = bandwidthObject; + this.isBandwidthObjectSet = true; + + this.isMetricListSet = false; + + this.isIroObjectSet = false; + } + + /** + * Parse list for MeticObject. + * + * @param cb of type channel buffer + * @return true if parsing metric list is success + * @throws PcepParseException when a non metric object is received + */ + public boolean parseMetricList(ChannelBuffer cb) throws PcepParseException { + + if (llMetricList == null) { + llMetricList = new LinkedList<>(); + } + + PcepMetricObject metriclist; + + //caller should verify for metric object + byte yObjClass = PcepMetricObjectVer1.METRIC_OBJ_CLASS; + byte yObjType = PcepMetricObjectVer1.METRIC_OBJ_TYPE; + + while ((yObjClass == PcepMetricObjectVer1.METRIC_OBJ_CLASS) + && (yObjType == PcepMetricObjectVer1.METRIC_OBJ_TYPE)) { + + metriclist = PcepMetricObjectVer1.read(cb); + llMetricList.add(metriclist); + yObjClass = 0; + yObjType = 0; + + if (cb.readableBytes() > OBJECT_HEADER_LENGTH) { + cb.markReaderIndex(); + PcepObjectHeader tempObjHeader = PcepObjectHeader.read(cb); + cb.resetReaderIndex(); + yObjClass = tempObjHeader.getObjClass(); + yObjType = tempObjHeader.getObjType(); + } + } + return true; + } + + /** + * Reads lspa , bandwidth , Metriclist and Iro objects and sets the objects. + * + * @param cb of type channel buffer + * @return instance of Pcep Attribute + * @throws PcepParseException while parsing Pcep Attributes from channel buffer + */ + + public static PcepAttribute read(ChannelBuffer cb) throws PcepParseException { + if (cb.readableBytes() < OBJECT_HEADER_LENGTH) { + return null; + } + //check whether any pcep attribute is present + cb.markReaderIndex(); + PcepObjectHeader tempObjHeader = PcepObjectHeader.read(cb); + cb.resetReaderIndex(); + byte yObjClass = tempObjHeader.getObjClass(); + + if (PcepLspaObjectVer1.LSPA_OBJ_CLASS != yObjClass && PcepBandwidthObjectVer1.BANDWIDTH_OBJ_CLASS != yObjClass + && PcepMetricObjectVer1.METRIC_OBJ_CLASS != yObjClass && PcepIroObjectVer1.IRO_OBJ_CLASS != yObjClass) { + //No PCEP attribute is present + return null; + } + + PcepAttributeVer1 pcepAttribute = new PcepAttributeVer1(); + + //If LSPA present then store it.LSPA is optional + if (yObjClass == PcepLspaObjectVer1.LSPA_OBJ_CLASS) { + pcepAttribute.setLspaObject(PcepLspaObjectVer1.read(cb)); + yObjClass = checkNextObject(cb); + } + + //If BANDWIDTH present then store it.BANDWIDTH is optional + if (yObjClass == PcepBandwidthObjectVer1.BANDWIDTH_OBJ_CLASS) { + pcepAttribute.setBandwidthObject(PcepBandwidthObjectVer1.read(cb)); + yObjClass = checkNextObject(cb); + } + + //If Metric list present then store it.MetricList is optional + if (yObjClass == PcepMetricObjectVer1.METRIC_OBJ_CLASS) { + pcepAttribute.parseMetricList(cb); + yObjClass = checkNextObject(cb); + } + + //If IRO present then store it.IRO is optional + if (yObjClass == PcepIroObjectVer1.IRO_OBJ_CLASS) { + pcepAttribute.setIroObject(PcepIroObjectVer1.read(cb)); + } + + PcepLspaObject lspaObject = pcepAttribute.getLspaObject(); + PcepBandwidthObject bandwidthObject = pcepAttribute.getBandwidthObject(); + LinkedList<PcepMetricObject> metriclist = pcepAttribute.llMetricList; + PcepIroObject iroObject = pcepAttribute.getIroObject(); + + return new PcepAttributeVer1(lspaObject, bandwidthObject, metriclist, iroObject); + } + + /** + * Checks whether there is a more object or not. + * + * @param cb of type channel buffer + * @return instance of object header + */ + private static byte checkNextObject(ChannelBuffer cb) { + if (cb.readableBytes() < OBJECT_HEADER_LENGTH) { + return 0; + } + cb.markReaderIndex(); + PcepObjectHeader tempObjHeader = PcepObjectHeader.read(cb); + cb.resetReaderIndex(); + return tempObjHeader.getObjClass(); + } + + @Override + public int write(ChannelBuffer cb) throws PcepParseException { + int iLenStartIndex = cb.writerIndex(); + //PCEP LSPA object is optional + if (this.isLspaObjectSet) { + this.lspaObject.write(cb); + } + + //PCEP BANDWIDTH object is optional + if (this.isBandwidthObjectSet) { + this.bandwidthObject.write(cb); + } + + //PCEP Metric list is optional + if (this.isMetricListSet) { + ListIterator<PcepMetricObject> listIterator = this.llMetricList.listIterator(); + while (listIterator.hasNext()) { + listIterator.next().write(cb); + } + } + + //PCEP IRO object is optional + if (this.isIroObjectSet) { + this.iroObject.write(cb); + } + return cb.writerIndex() - iLenStartIndex; + } + + @Override + public PcepLspaObject getLspaObject() { + return lspaObject; + } + + @Override + public PcepBandwidthObject getBandwidthObject() { + return bandwidthObject; + } + + @Override + public LinkedList<PcepMetricObject> getMetricObjectList() { + return llMetricList; + } + + @Override + public PcepIroObject getIroObject() { + return iroObject; + } + + @Override + public void setBandwidthObject(PcepBandwidthObject bandwidthObject) { + this.isBandwidthObjectSet = true; + this.bandwidthObject = bandwidthObject; + } + + @Override + public void setMetricObjectList(LinkedList<PcepMetricObject> llMetricList) { + this.isMetricListSet = true; + this.llMetricList = llMetricList; + + } + + @Override + public void setLspaObject(PcepLspaObject lspaObject) { + this.isLspaObjectSet = true; + this.lspaObject = lspaObject; + } + + @Override + public void setIroObject(PcepIroObject iroObject) { + this.isIroObjectSet = true; + this.iroObject = iroObject; + } + + /** + * Builder class for PCEP attributes. + */ + public static class Builder implements PcepAttribute.Builder { + + //PCEP LSPA Object + private PcepLspaObject lspaObject; + private boolean isLspaObjectSet; + + //PCEP BANDWIDTH Object + private PcepBandwidthObject bandwidthObject; + private boolean isBandwidthObjectSet; + + //PCEP Metric list + private LinkedList<PcepMetricObject> llMetricList; + private boolean isMetricListSet; + + //PCEP IRO object + private PcepIroObject iroObject; + private boolean isIroObjectSet; + + @Override + public PcepAttribute build() { + + //PCEP LSPA Object + PcepLspaObject lspaObject = null; + + //PCEP BANDWIDTH Object + PcepBandwidthObject bandwidthObject = null; + + //PCEP Metric list + LinkedList<PcepMetricObject> llMetricList = null; + + //PCEP IRO object + PcepIroObject iroObject = null; + + if (this.isLspaObjectSet) { + lspaObject = this.lspaObject; + } + if (this.isBandwidthObjectSet) { + bandwidthObject = this.bandwidthObject; + } + if (this.isMetricListSet) { + llMetricList = this.llMetricList; + } + if (this.isIroObjectSet) { + iroObject = this.iroObject; + } + return new PcepAttributeVer1(lspaObject, bandwidthObject, llMetricList, iroObject); + } + + @Override + public PcepLspaObject getLspaObject() { + return this.lspaObject; + } + + @Override + public PcepBandwidthObject getBandwidthObject() { + return this.bandwidthObject; + } + + @Override + public LinkedList<PcepMetricObject> getMetricObjectList() { + return this.llMetricList; + } + + @Override + public PcepIroObject getIroObject() { + return this.iroObject; + } + + @Override + public Builder setBandwidthObject(PcepBandwidthObject bandwidthObject) { + this.isBandwidthObjectSet = true; + this.bandwidthObject = bandwidthObject; + return this; + } + + @Override + public Builder setMetricObjectList(LinkedList<PcepMetricObject> llMetricList) { + this.isMetricListSet = true; + this.llMetricList = llMetricList; + return this; + } + + @Override + public Builder setLspaObject(PcepLspaObject lspaObject) { + this.isLspaObjectSet = true; + this.lspaObject = lspaObject; + return this; + } + + @Override + public Builder setIroObject(PcepIroObject iroObject) { + this.isIroObjectSet = true; + this.iroObject = iroObject; + return this; + } + } + + @Override + public String toString() { + return MoreObjects.toStringHelper(getClass()) + .omitNullValues() + .add("lspaObject", lspaObject) + .add("bandwidthObject", bandwidthObject) + .add("MetricObjectList", llMetricList) + .add("IroObject", iroObject) + .toString(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepBandwidthObjectVer1.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepBandwidthObjectVer1.java new file mode 100644 index 00000000..1c78d5b4 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepBandwidthObjectVer1.java @@ -0,0 +1,233 @@ +/* + * 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 org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.pcepio.exceptions.PcepParseException; +import org.onosproject.pcepio.protocol.PcepBandwidthObject; +import org.onosproject.pcepio.types.PcepObjectHeader; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.google.common.base.MoreObjects; + +/** + * Provides PcepBandwidthObject. + */ +public class PcepBandwidthObjectVer1 implements PcepBandwidthObject { + + /* + * RFC : 5440 , section : 7.7. + 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 + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Bandwidth | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + + The BANDWIDTH Object format + */ + + protected static final Logger log = LoggerFactory.getLogger(PcepBandwidthObjectVer1.class); + /* + * Requested bandwidth: BANDWIDTH Object-Type is 1. + Bandwidth of an existing TE LSP for which a re-optimization is + requested. BANDWIDTH Object-Type is 2. + */ + //Right now handling type 1 + public static final byte BANDWIDTH_OBJ_TYPE = 1; + public static final byte BANDWIDTH_OBJ_CLASS = 5; + public static final byte BANDWIDTH_OBJECT_VERSION = 1; + public static final short BANDWIDTH_OBJ_MINIMUM_LENGTH = 8; + + static final PcepObjectHeader DEFAULT_BANDWIDTH_OBJECT_HEADER = new PcepObjectHeader(BANDWIDTH_OBJ_CLASS, + BANDWIDTH_OBJ_TYPE, PcepObjectHeader.REQ_OBJ_OPTIONAL_PROCESS, PcepObjectHeader.RSP_OBJ_PROCESSED, + BANDWIDTH_OBJ_MINIMUM_LENGTH); + + private PcepObjectHeader bandwidthObjHeader; + private int iBandwidth; + + /** + * Constructor to bandwidth object header and bandwidth. + * + * @param bandwidthObjHeader bandwidth object header + * @param iBandwidth bandwidth value + */ + public PcepBandwidthObjectVer1(PcepObjectHeader bandwidthObjHeader, int iBandwidth) { + this.bandwidthObjHeader = bandwidthObjHeader; + this.iBandwidth = iBandwidth; + } + + /** + * Constructor to initialize bandwidth. + * + * @param iBandwidth bandwidth value + */ + public PcepBandwidthObjectVer1(int iBandwidth) { + this.bandwidthObjHeader = DEFAULT_BANDWIDTH_OBJECT_HEADER; + this.iBandwidth = iBandwidth; + } + + /** + * Returns Object Header. + * + * @return bandwidthObjHeader + */ + public PcepObjectHeader getBandwidthObjHeader() { + return this.bandwidthObjHeader; + } + + /** + * Sets Object Header. + * + * @param obj bandwidth object header + */ + public void setBandwidthObjHeader(PcepObjectHeader obj) { + this.bandwidthObjHeader = obj; + } + + @Override + public int getBandwidth() { + return this.iBandwidth; + } + + @Override + public void setBandwidth(int iBandwidth) { + this.iBandwidth = iBandwidth; + } + + /** + * Reads from channel buffer and returns object of PcepBandwidthObject. + * + * @param cb channel buffer to parse + * @return object of PcepBandwidthObject + * @throws PcepParseException while parsing channel buffer + */ + public static PcepBandwidthObject read(ChannelBuffer cb) throws PcepParseException { + + PcepObjectHeader bandwidthObjHeader; + int iBandwidth; + + bandwidthObjHeader = PcepObjectHeader.read(cb); + iBandwidth = cb.readInt(); + + return new PcepBandwidthObjectVer1(bandwidthObjHeader, iBandwidth); + } + + @Override + public int write(ChannelBuffer cb) throws PcepParseException { + + //write Object header + int objStartIndex = cb.writerIndex(); + int objLenIndex = bandwidthObjHeader.write(cb); + + if (objLenIndex <= 0) { + throw new PcepParseException("Failed to write bandwidth object header. Index " + objLenIndex); + } + + cb.writeInt(iBandwidth); + short hLength = (short) (cb.writerIndex() - objStartIndex); + cb.setShort(objLenIndex, hLength); + //will be helpful during print(). + bandwidthObjHeader.setObjLen(hLength); + + return cb.writerIndex() - objStartIndex; + } + + /** + * builder class for PCEP bandwidth object. + */ + public static class Builder implements PcepBandwidthObject.Builder { + + private PcepObjectHeader bandwidthObjHeader; + private boolean bIsHeaderSet = false; + + private int iBandwidth; + private boolean bIsBandwidthSet = false; + + private boolean bPFlag; + private boolean bIsPFlagSet = false; + + private boolean bIFlag; + private boolean bIsIFlagSet = false; + + @Override + public PcepBandwidthObject build() throws PcepParseException { + + PcepObjectHeader bandwidthObjHeader = this.bIsHeaderSet ? this.bandwidthObjHeader + : DEFAULT_BANDWIDTH_OBJECT_HEADER; + + if (bIsPFlagSet) { + bandwidthObjHeader.setPFlag(bPFlag); + } + + if (bIsIFlagSet) { + bandwidthObjHeader.setIFlag(bIFlag); + } + + if (!this.bIsBandwidthSet) { + throw new PcepParseException("bandwidth not Set while building Bandwidth Object."); + } + + return new PcepBandwidthObjectVer1(bandwidthObjHeader, iBandwidth); + } + + @Override + public int getBandwidth() { + return this.iBandwidth; + } + + @Override + public PcepObjectHeader getBandwidthObjHeader() { + return this.bandwidthObjHeader; + } + + @Override + public Builder setBandwidthObjHeader(PcepObjectHeader obj) { + this.bandwidthObjHeader = obj; + return this; + } + + @Override + public Builder setBandwidth(int iBandwidth) { + this.iBandwidth = iBandwidth; + this.bIsBandwidthSet = true; + 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("BandwidthObjectHeader", bandwidthObjHeader) + .add("Bandwidth", iBandwidth).toString(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepCloseMsgVer1.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepCloseMsgVer1.java new file mode 100644 index 00000000..bcc679d3 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepCloseMsgVer1.java @@ -0,0 +1,351 @@ +/* + * 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.PcepCloseMsg; +import org.onosproject.pcepio.protocol.PcepMessageReader; +import org.onosproject.pcepio.protocol.PcepMessageWriter; +import org.onosproject.pcepio.protocol.PcepType; +import org.onosproject.pcepio.protocol.PcepVersion; +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 Close Message. + */ +class PcepCloseMsgVer1 implements PcepCloseMsg { + + /* + * RFC : 5440 , section : 6.8 + * <Close Message> ::= <Common Header> <CLOSE> + * + 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 + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Ver | Flags | Message-Type | Message-Length | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Object-Class | OT |Res|P|I| Object Length (bytes) | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Reserved | Flags | Reason | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | | + // Optional TLVs // + | | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + */ + + protected static final Logger log = LoggerFactory.getLogger(PcepCloseMsgVer1.class); + + // Pcep version: 1 + public static final byte PACKET_VERSION = 1; + public static final int PACKET_MINIMUM_LENGTH = 12; + public static final PcepType MSG_TYPE = PcepType.CLOSE; + public static final byte CLOSE_OBJ_TYPE = 1; + public static final byte CLOSE_OBJ_CLASS = 15; + public static final byte CLOSE_OBJECT_VERSION = 1; + public static final byte DEFAULT_REASON = 1; // Default reason to close + public static final short CLOSE_OBJ_MINIMUM_LENGTH = 8; + public static final int SHIFT_FLAG = 5; + static final PcepObjectHeader DEFAULT_CLOSE_HEADER = new PcepObjectHeader(CLOSE_OBJ_CLASS, CLOSE_OBJ_TYPE, + PcepObjectHeader.REQ_OBJ_OPTIONAL_PROCESS, PcepObjectHeader.RSP_OBJ_PROCESSED, CLOSE_OBJ_MINIMUM_LENGTH); + + private final PcepObjectHeader closeObjHeader; + private byte yReason; + private LinkedList<PcepValueType> llOptionalTlv; + + public static final PcepCloseMsgVer1.Reader READER = new Reader(); + + /** + * Reader class for reading close message for channel buffer. + */ + static class Reader implements PcepMessageReader<PcepCloseMsg> { + PcepObjectHeader closeObjHeader; + byte yReason; + // Optional TLV + private LinkedList<PcepValueType> llOptionalTlv; + + @Override + public PcepCloseMsg readFrom(ChannelBuffer cb) throws PcepParseException { + + if (cb.readableBytes() < PACKET_MINIMUM_LENGTH) { + throw new PcepParseException("Packet size is less than the minimum length."); + } + // fixed value property version == 1 + byte version = cb.readByte(); + version = (byte) (version >> SHIFT_FLAG); + if (version != PACKET_VERSION) { + throw new PcepParseException("Wrong version. Expected=PcepVersion.PCEP_1(1), got=" + version); + } + // fixed value property type == 7 + byte type = cb.readByte(); + if (type != MSG_TYPE.getType()) { + throw new PcepParseException("Wrong type. Expected=PcepType.CLOSE(7), got=" + type); + } + short length = cb.readShort(); + if (length < PACKET_MINIMUM_LENGTH) { + throw new PcepParseException("Wrong length. Expected to be >= " + PACKET_MINIMUM_LENGTH + ", was: " + + length); + } + closeObjHeader = PcepObjectHeader.read(cb); + // Reserved + cb.readShort(); + // Flags + cb.readByte(); + // Reason + yReason = cb.readByte(); + // parse optional TLV + llOptionalTlv = parseOptionalTlv(cb); + return new PcepCloseMsgVer1(closeObjHeader, yReason, llOptionalTlv); + } + } + + /** + * Parse the list of Optional Tlvs. + * + * @param cb channel buffer + * @return list of Optional Tlvs + * @throws PcepParseException when fails to parse optional tlvs + */ + public static LinkedList<PcepValueType> parseOptionalTlv(ChannelBuffer cb) throws PcepParseException { + + LinkedList<PcepValueType> llOptionalTlv = new LinkedList<>(); + /* + rfc 5440: + Optional TLVs may be included within the CLOSE object body. The + specification of such TLVs is outside the scope of this document. + */ + return llOptionalTlv; + } + + /** + * constructor to initialize PCEP close Message with all the parameters. + * + * @param closeObjHeader object header for close message + * @param yReason reason for closing the channel + * @param llOptionalTlv list of optional tlvs + */ + PcepCloseMsgVer1(PcepObjectHeader closeObjHeader, byte yReason, LinkedList<PcepValueType> llOptionalTlv) { + + this.closeObjHeader = closeObjHeader; + this.yReason = yReason; + this.llOptionalTlv = llOptionalTlv; + } + + /** + * Builder class for PCEP close message. + */ + static class Builder implements PcepCloseMsg.Builder { + + // PCEP Close message fields + private boolean bIsHeaderSet = false; + private PcepObjectHeader closeObjHeader; + private boolean bIsReasonSet = false; + private byte yReason; + private LinkedList<PcepValueType> llOptionalTlv = new LinkedList<>(); + + private boolean bIsPFlagSet = false; + private boolean bPFlag; + + private boolean bIsIFlagSet = false; + private boolean bIFlag; + + @Override + public PcepVersion getVersion() { + return PcepVersion.PCEP_1; + } + + @Override + public PcepType getType() { + return PcepType.CLOSE; + } + + @Override + public PcepCloseMsg build() { + + PcepObjectHeader closeObjHeader = this.bIsHeaderSet ? this.closeObjHeader : DEFAULT_CLOSE_HEADER; + byte yReason = this.bIsReasonSet ? this.yReason : DEFAULT_REASON; + + if (bIsPFlagSet) { + closeObjHeader.setPFlag(bPFlag); + } + + if (bIsIFlagSet) { + closeObjHeader.setIFlag(bIFlag); + } + return new PcepCloseMsgVer1(closeObjHeader, yReason, this.llOptionalTlv); + } + + @Override + public PcepObjectHeader getCloseObjHeader() { + return this.closeObjHeader; + } + + @Override + public Builder setCloseObjHeader(PcepObjectHeader obj) { + this.closeObjHeader = obj; + this.bIsHeaderSet = true; + return this; + } + + @Override + public byte getReason() { + return this.yReason; + } + + @Override + public Builder setReason(byte value) { + this.yReason = value; + this.bIsReasonSet = true; + return this; + } + + @Override + public Builder setOptionalTlv(LinkedList<PcepValueType> llOptionalTlv) { + this.llOptionalTlv = llOptionalTlv; + return this; + } + + @Override + public LinkedList<PcepValueType> getOptionalTlv() { + return this.llOptionalTlv; + } + + @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 void writeTo(ChannelBuffer cb) throws PcepParseException { + WRITER.write(cb, this); + } + + static final Writer WRITER = new Writer(); + + /** + * Writer class for writing close message to channel buffer. + */ + static class Writer implements PcepMessageWriter<PcepCloseMsgVer1> { + + @Override + public void write(ChannelBuffer cb, PcepCloseMsgVer1 message) throws PcepParseException { + int startIndex = cb.writerIndex(); + // first 3 bits set to version + cb.writeByte((byte) (PACKET_VERSION << SHIFT_FLAG)); + // message type + cb.writeByte(MSG_TYPE.getType()); + // length is length of variable message, will be updated at the end + // Store the position of message + // length in buffer + int msgLenIndex = cb.writerIndex(); + cb.writeShort((short) 0); + int objStartIndex = cb.writerIndex(); + int objLenIndex = message.closeObjHeader.write(cb); + if (objLenIndex <= 0) { + throw new PcepParseException("Failed to write Close object header."); + } + // first 3 bits set to version + cb.writeShort(0); // Reserved + cb.writeByte(0); // Flags + cb.writeByte(message.yReason); + // Pack optional TLV + packOptionalTlv(cb, message); + int length = cb.writerIndex() - objStartIndex; + cb.setShort(objLenIndex, (short) length); + // will be helpful during print(). + message.closeObjHeader.setObjLen((short) length); + // As per RFC the length of object should be + // multiples of 4 + int pad = length % 4; + if (pad != 0) { + pad = 4 - pad; + for (int i = 0; i < pad; i++) { + cb.writeByte((byte) 0); + } + length = length + pad; + } + // update message length field + length = cb.writerIndex() - startIndex; + cb.setShort(msgLenIndex, (short) length); + } + + public void packOptionalTlv(ChannelBuffer cb, PcepCloseMsgVer1 message) { + + LinkedList<PcepValueType> llOptionalTlv = message.llOptionalTlv; + ListIterator<PcepValueType> listIterator = llOptionalTlv.listIterator(); + while (listIterator.hasNext()) { + listIterator.next().write(cb); + } + } + } + + @Override + public PcepVersion getVersion() { + return PcepVersion.PCEP_1; + } + + @Override + public PcepType getType() { + return MSG_TYPE; + } + + @Override + public byte getReason() { + return this.yReason; + } + + @Override + public void setReason(byte value) { + this.yReason = value; + } + + @Override + public LinkedList<PcepValueType> getOptionalTlv() { + return this.llOptionalTlv; + } + + @Override + public void setOptionalTlv(LinkedList<PcepValueType> llOptionalTlv) { + this.llOptionalTlv = llOptionalTlv; + } + + @Override + public String toString() { + return MoreObjects.toStringHelper(getClass()) + .add("closeObjectHeader", closeObjHeader).add("Reason", yReason) + .add("OptionalTlvlist", llOptionalTlv).toString(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepEndPointsObjectVer1.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepEndPointsObjectVer1.java new file mode 100644 index 00000000..08dc0c9b --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepEndPointsObjectVer1.java @@ -0,0 +1,256 @@ +/* + * 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 org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.pcepio.exceptions.PcepParseException; +import org.onosproject.pcepio.protocol.PcepEndPointsObject; +import org.onosproject.pcepio.types.PcepObjectHeader; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.google.common.base.MoreObjects; + +/** + * Provides PCEP Endpoints Object. + */ +public class PcepEndPointsObjectVer1 implements PcepEndPointsObject { + + /* + * RFC : 5440 , section : 7.6 + * An End point is defined as follows: + END-POINTS Object-Class is 4. + + END-POINTS Object-Type is 1 for IPv4 and 2 for IPv6. + 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 + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Object-Class | OT |Res|P|I| Object Length (bytes) | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Source IPv4 address | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Destination IPv4 address | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + + */ + protected static final Logger log = LoggerFactory.getLogger(PcepEndPointsObjectVer1.class); + + static final byte END_POINTS_OBJ_TYPE = 1; + static final byte END_POINTS_OBJ_CLASS = 4; + static final byte END_POINTS_OBJECT_VERSION = 1; + static final short END_POINTS_OBJ_MINIMUM_LENGTH = 12; + public static byte endPointObjType; + + static final PcepObjectHeader DEFAULT_END_POINTS_OBJECT_HEADER = new PcepObjectHeader(END_POINTS_OBJ_CLASS, + END_POINTS_OBJ_TYPE, PcepObjectHeader.REQ_OBJ_OPTIONAL_PROCESS, PcepObjectHeader.RSP_OBJ_PROCESSED, + END_POINTS_OBJ_MINIMUM_LENGTH); + + private PcepObjectHeader endPointsObjHeader; + public int sourceIpAddress; + public int destIpAddress; + + /** + * Constructor to initialize all variables. + * + * @param endPointsObjHeader end points object header + * @param sourceIpAddress source IP address + * @param destIpAddress destination IP address + */ + public PcepEndPointsObjectVer1(PcepObjectHeader endPointsObjHeader, int sourceIpAddress, int destIpAddress) { + + this.endPointsObjHeader = endPointsObjHeader; + this.sourceIpAddress = sourceIpAddress; + this.destIpAddress = destIpAddress; + } + + /** + * Sets End Points Object Header. + * + * @param obj of PcepObjectHeader + */ + public void setEndPointsObjHeader(PcepObjectHeader obj) { + this.endPointsObjHeader = obj; + } + + @Override + public void setSourceIpAddress(int sourceIpAddress) { + this.sourceIpAddress = sourceIpAddress; + } + + @Override + public void setDestIpAddress(int destIpAddress) { + this.destIpAddress = destIpAddress; + } + + @Override + public int getSourceIpAddress() { + return this.sourceIpAddress; + } + + @Override + public int getDestIpAddress() { + return this.destIpAddress; + } + + /** + * Reads from channel buffer and returns object of PcepEndPointsObject. + * + * @param cb of channel buffer + * @return object of PcepEndPointsObject + * @throws PcepParseException while parsing channel buffer + */ + public static PcepEndPointsObject read(ChannelBuffer cb) throws PcepParseException { + + PcepObjectHeader endPointsObjHeader; + int sourceIpAddress; + int destIpAddress; + + endPointsObjHeader = PcepObjectHeader.read(cb); + if (endPointsObjHeader.getObjType() == END_POINTS_OBJ_TYPE + && endPointsObjHeader.getObjClass() == END_POINTS_OBJ_CLASS) { + sourceIpAddress = cb.readInt(); + destIpAddress = cb.readInt(); + } else { + throw new PcepParseException("Expected PcepEndPointsObject."); + } + return new PcepEndPointsObjectVer1(endPointsObjHeader, sourceIpAddress, destIpAddress); + } + + @Override + public int write(ChannelBuffer cb) throws PcepParseException { + + int objStartIndex = cb.writerIndex(); + //write common header + int objLenIndex = endPointsObjHeader.write(cb); + + //write source IPv4 IP + cb.writeInt(sourceIpAddress); + //write destination IPv4 IP + cb.writeInt(destIpAddress); + + int length = cb.writerIndex() - objStartIndex; + //now write EndPoints Object Length + cb.setShort(objLenIndex, (short) length); + //will be helpful during print(). + endPointsObjHeader.setObjLen((short) length); + + return cb.writerIndex(); + + } + + /** + * Builder class for PCEP end points objects. + */ + public static class Builder implements PcepEndPointsObject.Builder { + + private boolean bIsHeaderSet = false; + private boolean bIsSourceIpAddressset = false; + private boolean bIsDestIpAddressset = false; + private PcepObjectHeader endpointsObjHeader; + private int sourceIpAddress; + private int destIpAddress; + + private boolean bIsPFlagSet = false; + private boolean bPFlag; + + private boolean bIsIFlagSet = false; + private boolean bIFlag; + + @Override + public PcepEndPointsObject build() throws PcepParseException { + + PcepObjectHeader endpointsObjHeader = this.bIsHeaderSet ? this.endpointsObjHeader + : DEFAULT_END_POINTS_OBJECT_HEADER; + + if (bIsPFlagSet) { + endpointsObjHeader.setPFlag(bPFlag); + } + + if (bIsIFlagSet) { + endpointsObjHeader.setIFlag(bIFlag); + } + + if (!this.bIsSourceIpAddressset) { + throw new PcepParseException("SourceIpAddress not set while building EndPoints object"); + } + + if (!this.bIsDestIpAddressset) { + throw new PcepParseException("DestIpAddress not set while building EndPoints object"); + } + + return new PcepEndPointsObjectVer1(endpointsObjHeader, this.sourceIpAddress, this.destIpAddress); + } + + @Override + public PcepObjectHeader getEndPointsObjHeader() { + return this.endpointsObjHeader; + } + + @Override + public Builder setEndPointsObjHeader(PcepObjectHeader obj) { + this.endpointsObjHeader = obj; + this.bIsHeaderSet = true; + return this; + } + + @Override + public int getSourceIpAddress() { + return this.sourceIpAddress; + } + + @Override + public Builder setSourceIpAddress(int sourceIpAddress) { + this.sourceIpAddress = sourceIpAddress; + this.bIsSourceIpAddressset = true; + return this; + } + + @Override + public int getDestIpAddress() { + return this.destIpAddress; + } + + @Override + public Builder setDestIpAddress(int destIpAddress) { + this.destIpAddress = destIpAddress; + this.bIsDestIpAddressset = true; + 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("sourceIpAddress", sourceIpAddress) + .add("destIpAddress", destIpAddress).toString(); + } + +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepEroObjectVer1.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepEroObjectVer1.java new file mode 100644 index 00000000..4d7cb16e --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepEroObjectVer1.java @@ -0,0 +1,407 @@ +/* + * 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.PcepEroObject; +import org.onosproject.pcepio.types.AutonomousSystemTlv; +import org.onosproject.pcepio.types.IPv4SubObject; +import org.onosproject.pcepio.types.IPv6SubObject; +import org.onosproject.pcepio.types.PathKeySubObject; +import org.onosproject.pcepio.types.PcepErrorDetailInfo; +import org.onosproject.pcepio.types.PcepObjectHeader; +import org.onosproject.pcepio.types.PcepValueType; +import org.onosproject.pcepio.types.SrEroSubObject; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.google.common.base.MoreObjects; + +/** + * Provides PCEP Ero Object. + */ +public class PcepEroObjectVer1 implements PcepEroObject { + /* + * rfc3209 + 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 + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Object-Class | OT |Res|P|I| Object Length (bytes) | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | | + // (Subobjects) // + | | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + + If a Path message contains multiple EXPLICIT_ROUTE objects, only the + first object is meaningful. Subsequent EXPLICIT_ROUTE objects MAY be + ignored and SHOULD NOT be propagated. + + In current implementation, only strict hops are supported. So, + empty ERO with no sub-objects is considered illegal. + + Subobjects: + 0 1 + 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-------------//----------------+ + |L| Type | Length | (Subobject contents) | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-------------//----------------+ + + L + + The L bit is an attribute of the subobject. The L bit is set + if the subobject represents a loose hop in the explicit route. + If the bit is not set, the subobject represents a strict hop in + the explicit route. + + Type + + The Type indicates the type of contents of the subobject. + + + Subobject 1: IPv4 address + + 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 + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + |L| Type | Length | IPv4 address (4 bytes) | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | IPv4 address (continued) | Prefix Length | Resvd | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + + Subobject 2: IPv6 Prefix + + 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 + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + |L| Type | Length | IPv6 address (16 bytes) | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | IPv6 address (continued) | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | IPv6 address (continued) | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | IPv6 address (continued) | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | IPv6 address (continued) | Prefix Length | Resvd | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + + Subobject 3: Autonomous System Number + + The contents of an Autonomous System (AS) number subobject are a 2- + octet AS number. The abstract node represented by this subobject is + the set of nodes belonging to the autonomous system. + + The length of the AS number subobject is 4 octets. + + Subobject 4: PATH_KEY_32_BIT_SUB_OBJ_TYPE: + + Pathkey subobject(RFC 5520): + 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 + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + |L| Type | Length | Path-Key | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | PCE ID (4 bytes) | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + + Subobject 5: SR_ERO_SUB_OBJ_TYPE: + + SR-ERO subobject: (draft-ietf-pce-segment-routing-00) + 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 + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + |L| Type | Length | ST | Flags |F|S|C|M| + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | SID | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + // NAI (variable) // + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + */ + + protected static final Logger log = LoggerFactory.getLogger(PcepEroObjectVer1.class); + + public static final byte ERO_OBJ_TYPE = 1; + public static final byte ERO_OBJ_CLASS = 7; + public static final byte ERO_OBJECT_VERSION = 1; + public static final short ERO_OBJ_MINIMUM_LENGTH = 12; + public static final byte IPV4_TYPE = 1; + public static final byte PATH_KEY_32_BIT_SUB_OBJ_TYPE = 64; + public static final int LABEL_SUB_OBJ_TYPE = 3; + public static final int SR_ERO_SUB_OBJ_TYPE = 96; + public static final int OBJECT_HEADER_LENGTH = 4; + public static final int YTYPE_SHIFT_VALUE = 0x7F; + + static final PcepObjectHeader DEFAULT_ERO_OBJECT_HEADER = new PcepObjectHeader(ERO_OBJ_CLASS, ERO_OBJ_TYPE, + PcepObjectHeader.REQ_OBJ_OPTIONAL_PROCESS, PcepObjectHeader.RSP_OBJ_PROCESSED, ERO_OBJ_MINIMUM_LENGTH); + + private PcepObjectHeader eroObjHeader; + private LinkedList<PcepValueType> llSubObjects = new LinkedList<>(); + + /** + * reset variables. + */ + public PcepEroObjectVer1() { + this.eroObjHeader = null; + this.llSubObjects = null; + } + + /** + * Constructor to initialize parameters of ERO object. + * + * @param eroObjHeader ERO object header + * @param llSubObjects list of sub objects. + */ + public PcepEroObjectVer1(PcepObjectHeader eroObjHeader, LinkedList<PcepValueType> llSubObjects) { + + this.eroObjHeader = eroObjHeader; + this.llSubObjects = llSubObjects; + } + + /** + * Returns ERO object header. + * + * @return eroObjHeader ERO object header + */ + public PcepObjectHeader getEroObjHeader() { + return this.eroObjHeader; + } + + /** + * Sets Object Header. + * + * @param obj ERO object header + */ + public void setEroObjHeader(PcepObjectHeader obj) { + this.eroObjHeader = obj; + } + + @Override + public LinkedList<PcepValueType> getSubObjects() { + return this.llSubObjects; + } + + @Override + public void setSubObjects(LinkedList<PcepValueType> llSubObjects) { + this.llSubObjects = llSubObjects; + } + + /** + * Reads from channel buffer and returns object of PcepEroObject. + * + * @param cb channel buffer. + * @return object of PcepEroObject + * @throws PcepParseException when ERO object is not present in channel buffer + */ + public static PcepEroObject read(ChannelBuffer cb) throws PcepParseException { + + PcepObjectHeader eroObjHeader; + LinkedList<PcepValueType> llSubObjects = new LinkedList<>(); + + eroObjHeader = PcepObjectHeader.read(cb); + + if (eroObjHeader.getObjClass() != PcepEroObjectVer1.ERO_OBJ_CLASS) { + log.debug("ErrorType:" + PcepErrorDetailInfo.ERROR_TYPE_6 + " ErrorValue:" + + PcepErrorDetailInfo.ERROR_VALUE_9); + throw new PcepParseException(PcepErrorDetailInfo.ERROR_TYPE_6, PcepErrorDetailInfo.ERROR_VALUE_9); + } + + if (eroObjHeader.getObjLen() > OBJECT_HEADER_LENGTH) { + ChannelBuffer tempCb = cb.readBytes(eroObjHeader.getObjLen() - OBJECT_HEADER_LENGTH); + llSubObjects = parseSubObjects(tempCb); + } + return new PcepEroObjectVer1(eroObjHeader, llSubObjects); + } + + /** + * Parse list of Sub Objects. + * + * @param cb channel buffer + * @return list of Sub Objects + * @throws PcepParseException when fails to parse sub object list + */ + protected static LinkedList<PcepValueType> parseSubObjects(ChannelBuffer cb) throws PcepParseException { + + LinkedList<PcepValueType> llSubObjects = new LinkedList<>(); + + while (0 < cb.readableBytes()) { + + //check the Type of the TLV + byte yType = cb.readByte(); + yType = (byte) (yType & (YTYPE_SHIFT_VALUE)); + byte hLength = cb.readByte(); + + PcepValueType subObj; + + switch (yType) { + + case IPv4SubObject.TYPE: + subObj = IPv4SubObject.read(cb); + break; + case IPv6SubObject.TYPE: + byte[] ipv6Value = new byte[IPv6SubObject.VALUE_LENGTH]; + cb.readBytes(ipv6Value, 0, IPv6SubObject.VALUE_LENGTH); + subObj = new IPv6SubObject(ipv6Value); + break; + case AutonomousSystemTlv.TYPE: + subObj = AutonomousSystemTlv.read(cb); + break; + case PathKeySubObject.TYPE: + subObj = PathKeySubObject.read(cb); + break; + case SrEroSubObject.TYPE: + subObj = SrEroSubObject.read(cb); + break; + default: + throw new PcepParseException("Unexpected sub object. Type: " + (int) yType); + } + // Check for the padding + int pad = hLength % 4; + if (0 < pad) { + pad = 4 - pad; + if (pad <= cb.readableBytes()) { + cb.skipBytes(pad); + } + } + + llSubObjects.add(subObj); + } + if (0 < cb.readableBytes()) { + throw new PcepParseException("Subobject parsing error. Extra bytes received."); + } + return llSubObjects; + } + + @Override + public int write(ChannelBuffer cb) throws PcepParseException { + + //write Object header + int objStartIndex = cb.writerIndex(); + + int objLenIndex = eroObjHeader.write(cb); + + if (objLenIndex <= 0) { + throw new PcepParseException("Failed to write ERO object header. Index " + objLenIndex); + } + + ListIterator<PcepValueType> listIterator = llSubObjects.listIterator(); + + while (listIterator.hasNext()) { + listIterator.next().write(cb); + } + + //Update object length now + int length = cb.writerIndex() - objStartIndex; + cb.setShort(objLenIndex, (short) length); + //will be helpful during print(). + eroObjHeader.setObjLen((short) length); + + //As per RFC the length of object should be multiples of 4 + int pad = length % 4; + + if (pad != 0) { + pad = 4 - pad; + for (int i = 0; i < pad; i++) { + cb.writeByte((byte) 0); + } + length = length + pad; + } + + objLenIndex = cb.writerIndex(); + return objLenIndex; + } + + /** + * Builder class for PCEP ERO object. + */ + public static class Builder implements PcepEroObject.Builder { + + private boolean bIsHeaderSet = false; + + private boolean bIsPFlagSet = false; + private boolean bPFlag; + + private boolean bIsIFlagSet = false; + private boolean bIFlag; + + private PcepObjectHeader eroObjHeader; + LinkedList<PcepValueType> llSubObjects = new LinkedList<>(); + + @Override + public PcepEroObject build() { + + PcepObjectHeader eroObjHeader = this.bIsHeaderSet ? this.eroObjHeader : DEFAULT_ERO_OBJECT_HEADER; + + if (bIsPFlagSet) { + eroObjHeader.setPFlag(bPFlag); + } + + if (bIsIFlagSet) { + eroObjHeader.setIFlag(bIFlag); + } + + return new PcepEroObjectVer1(eroObjHeader, this.llSubObjects); + } + + @Override + public PcepObjectHeader getEroObjHeader() { + return this.eroObjHeader; + } + + @Override + public Builder setEroObjHeader(PcepObjectHeader obj) { + this.eroObjHeader = obj; + this.bIsHeaderSet = true; + return this; + } + + @Override + public LinkedList<PcepValueType> getSubObjects() { + return this.llSubObjects; + } + + @Override + public Builder setSubObjects(LinkedList<PcepValueType> llSubObjects) { + this.llSubObjects = llSubObjects; + 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("EroObjHeader", eroObjHeader).add("SubObjects", llSubObjects) + .toString(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepErrorInfoVer1.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepErrorInfoVer1.java new file mode 100644 index 00000000..594e40c1 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepErrorInfoVer1.java @@ -0,0 +1,204 @@ +/* + * 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.PcepError; +import org.onosproject.pcepio.protocol.PcepErrorInfo; +import org.onosproject.pcepio.protocol.PcepErrorObject; +import org.onosproject.pcepio.protocol.PcepRPObject; +import org.onosproject.pcepio.protocol.PcepTEObject; +import org.onosproject.pcepio.types.PcepObjectHeader; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.google.common.base.MoreObjects; + +/** + * Provides PCEP Error Info. + * Reference :PCEP Extension for Transporting TE Data draft-dhodylee-pce-pcep-te-data-extn-02. + */ +public class PcepErrorInfoVer1 implements PcepErrorInfo { + + protected static final Logger log = LoggerFactory.getLogger(PcepErrorInfoVer1.class); + //Error list is optional + private LinkedList<PcepError> errList; + + /** + * Constructor to add PCEP error object to the list. + * + * @param llRPObjList list of PCEP RP object + * @param llTEObjList list of PCEP TE object + * @param llErrObjList list of PCEP error object + */ + public PcepErrorInfoVer1(LinkedList<PcepRPObject> llRPObjList, LinkedList<PcepTEObject> llTEObjList, + LinkedList<PcepErrorObject> llErrObjList) { + this.errList = new LinkedList<>(); + if ((llErrObjList != null) && (!llErrObjList.isEmpty())) { + this.errList.add(new PcepErrorVer1(llRPObjList, llTEObjList, llErrObjList)); + } + } + + /** + * Constructor to initialize error info. + * + * @param errll linked list or pcep error + */ + public PcepErrorInfoVer1(LinkedList<PcepError> errll) { + this.errList = errll; + } + + @Override + public boolean isErrorInfoPresent() { + return !this.errList.isEmpty(); + } + + @Override + public void read(ChannelBuffer cb) throws PcepParseException { + PcepObjectHeader tempObjHeader; + + while (0 < cb.readableBytes()) { + cb.markReaderIndex(); + tempObjHeader = PcepObjectHeader.read(cb); + cb.resetReaderIndex(); + byte yObjClass = tempObjHeader.getObjClass(); + if ((yObjClass != PcepRPObjectVer1.RP_OBJ_CLASS) && (yObjClass != PcepTEObjectVer1.TE_OBJ_CLASS) + && (yObjClass != PcepErrorObjectVer1.ERROR_OBJ_CLASS)) { + throw new PcepParseException("Unknown Object is present in PCEP-ERROR. Object Class: " + yObjClass); + } + + this.errList.add(PcepErrorVer1.read(cb)); + } + } + + @Override + public void write(ChannelBuffer cb) throws PcepParseException { + //write <error> + ListIterator<PcepError> listIterator = errList.listIterator(); + while (listIterator.hasNext()) { + PcepError pcepError = listIterator.next(); + + //RP Object list is optional + LinkedList<PcepRPObject> llRPObjList = pcepError.getRPObjList(); + if (llRPObjList != null) { + ListIterator<PcepRPObject> rpListIterator = llRPObjList.listIterator(); + while (rpListIterator.hasNext()) { + rpListIterator.next().write(cb); + } + } + + //TE Object list is optional + LinkedList<PcepTEObject> llTEObjList = pcepError.getTEObjList(); + if (llTEObjList != null) { + ListIterator<PcepTEObject> teListIterator = llTEObjList.listIterator(); + while (teListIterator.hasNext()) { + teListIterator.next().write(cb); + } + } + + // <error-obj-list> is mandatory + boolean bIsErrorObjListFound = false; + + LinkedList<PcepErrorObject> llErrObjList = pcepError.getErrorObjList(); + if (llErrObjList != null) { + ListIterator<PcepErrorObject> errObjListIterator = llErrObjList.listIterator(); + while (errObjListIterator.hasNext()) { + errObjListIterator.next().write(cb); + bIsErrorObjListFound = true; + } + } + + if (!bIsErrorObjListFound) { + throw new PcepParseException("<error-obj-list> is mandatory."); + } + } + } + + @Override + public LinkedList<Integer> getErrorType() { + LinkedList<Integer> errorType = new LinkedList<>(); + ListIterator<PcepError> listIterator = errList.listIterator(); + PcepErrorObject errObj; + int error; + while (listIterator.hasNext()) { + PcepError pcepError = listIterator.next(); + LinkedList<PcepErrorObject> llErrObjList = pcepError.getErrorObjList(); + if (llErrObjList != null) { + ListIterator<PcepErrorObject> errObjListIterator = llErrObjList.listIterator(); + while (errObjListIterator.hasNext()) { + errObj = errObjListIterator.next(); + error = errObj.getErrorType(); + errorType.add(error); + } + } + } + return errorType; + } + + @Override + public LinkedList<Integer> getErrorValue() { + LinkedList<Integer> errorValue = new LinkedList<>(); + ListIterator<PcepError> listIterator = errList.listIterator(); + PcepErrorObject errObj; + int error; + while (listIterator.hasNext()) { + PcepError pcepError = listIterator.next(); + LinkedList<PcepErrorObject> llErrObjList = pcepError.getErrorObjList(); + if (llErrObjList != null) { + ListIterator<PcepErrorObject> errObjListIterator = llErrObjList.listIterator(); + while (errObjListIterator.hasNext()) { + errObj = errObjListIterator.next(); + error = errObj.getErrorValue(); + errorValue.add(error); + } + } + } + return errorValue; + } + + /** + * Builder class for PCEP error info. + */ + public static class Builder implements PcepErrorInfo.Builder { + private LinkedList<PcepError> errll; + + @Override + public PcepErrorInfo build() { + return new PcepErrorInfoVer1(errll); + } + + @Override + public LinkedList<PcepError> getPcepErrorList() { + return this.errll; + } + + @Override + public Builder setPcepErrorList(LinkedList<PcepError> errll) { + this.errll = errll; + return this; + } + } + + @Override + public String toString() { + return MoreObjects.toStringHelper(getClass()) + .add("ErrorList", errList).toString(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepErrorMsgVer1.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepErrorMsgVer1.java new file mode 100644 index 00000000..927d83d6 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepErrorMsgVer1.java @@ -0,0 +1,383 @@ +/* + * 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 org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.pcepio.exceptions.PcepParseException; +import org.onosproject.pcepio.protocol.PcepErrorInfo; +import org.onosproject.pcepio.protocol.PcepErrorMsg; +import org.onosproject.pcepio.protocol.PcepErrorObject; +import org.onosproject.pcepio.protocol.PcepMessageReader; +import org.onosproject.pcepio.protocol.PcepMessageWriter; +import org.onosproject.pcepio.protocol.PcepOpenObject; +import org.onosproject.pcepio.protocol.PcepType; +import org.onosproject.pcepio.protocol.PcepVersion; +import org.onosproject.pcepio.types.ErrorObjListWithOpen; +import org.onosproject.pcepio.types.PcepObjectHeader; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.google.common.base.MoreObjects; +import com.google.common.base.MoreObjects.ToStringHelper; + +/** + * Provides PCEP Error Message. + */ +public class PcepErrorMsgVer1 implements PcepErrorMsg { + + /* + * PCE Error message format. + + <PCErr Message> ::= <Common Header> + ( <error-obj-list> [<Open>] ) | <error> + [<error-list>] + + <error-obj-list> ::=<PCEP-ERROR>[<error-obj-list>] + + <error> ::=[<request-id-list> | <te-id-list>] + <error-obj-list> + + <request-id-list> ::=<RP>[<request-id-list>] + + <te-id-list> ::=<TE>[<te-id-list>] + + <error-list> ::=<error>[<error-list>] + */ + + protected static final Logger log = LoggerFactory.getLogger(PcepOpenMsgVer1.class); + public static final byte PACKET_VERSION = 1; + public static final int PACKET_MINIMUM_LENGTH = 12; + public static final PcepType MSG_TYPE = PcepType.ERROR; + + //Below either one should be present. + private ErrorObjListWithOpen errObjListWithOpen; //optional ( <error-obj-list> [<Open>] ) + private PcepErrorInfo errInfo; //optional <error> [<error-list>] + + public static final PcepErrorMsgVer1.Reader READER = new Reader(); + + /** + * constructor to initialize variables. + */ + public PcepErrorMsgVer1() { + errObjListWithOpen = null; + errInfo = null; + } + + /** + * Constructor to initialize variables. + * + * @param errObjListWithOpen error-object-list with open object + * @param errInfo error information + */ + public PcepErrorMsgVer1(ErrorObjListWithOpen errObjListWithOpen, PcepErrorInfo errInfo) { + this.errObjListWithOpen = errObjListWithOpen; + this.errInfo = errInfo; + } + + /** + * Reader class for reading PCEP error Message from channel buffer. + */ + public static class Reader implements PcepMessageReader<PcepErrorMsg> { + + ErrorObjListWithOpen errObjListWithOpen; + PcepErrorInfo errInfo; + PcepObjectHeader tempObjHeader; + + @Override + public PcepErrorMsg readFrom(ChannelBuffer cb) throws PcepParseException { + + errObjListWithOpen = null; + errInfo = null; + tempObjHeader = null; + + if (cb.readableBytes() < PACKET_MINIMUM_LENGTH) { + throw new PcepParseException("Packet size is less than the minimum length."); + } + + byte version = cb.readByte(); + version = (byte) (version >> PcepMessageVer1.SHIFT_FLAG); + if (version != PACKET_VERSION) { + throw new PcepParseException("Wrong version: Expected=PcepVersion.PCEP_1(1), got=" + version); + } + // fixed value property type == 1 + byte type = cb.readByte(); + if (type != MSG_TYPE.getType()) { + throw new PcepParseException("Wrong type: Expected=PcepType.ERROR(6), got=" + type); + } + int length = cb.readShort(); + if (length < PACKET_MINIMUM_LENGTH) { + throw new PcepParseException( + "Wrong length: Expected to be >= " + PACKET_MINIMUM_LENGTH + ", was: " + length); + } + + //parse <PCErr Message> + parsePCErrMsg(cb); + + // If other than RP or TE or PCEP-ERROR present then it is error. + if (0 < cb.readableBytes()) { + PcepObjectHeader tempObjHeader = PcepObjectHeader.read(cb); + throw new PcepParseException("Unexpected Object found. Object Class : " + tempObjHeader.getObjClass()); + } + + return new PcepErrorMsgVer1(errObjListWithOpen, errInfo); + } + + /** + * Parsing PCErr Message. + * + * @param cb channel buffer. + * @throws PcepParseException if mandatory fields are missing + * output: this.errObjListWithOpen, this.errInfo + */ + public void parsePCErrMsg(ChannelBuffer cb) throws PcepParseException { + //If PCEP-ERROR list is followed by OPEN Object then store into ErrorObjListWithOpen. + // ( <error-obj-list> [<Open>] + //If PCEP-ERROR list is followed by RP or TE Object then store into errInfo. <error> [<error-list>] + //If only PCEP-ERROR list is present then store into ErrorObjListWithOpen. + PcepObjectHeader tempObjHeader; + LinkedList<PcepErrorObject> llErrObjList; + + if (0 >= cb.readableBytes()) { + throw new PcepParseException("PCEP-ERROR message came with empty objects."); + } + + //parse PCEP-ERROR list + llErrObjList = new LinkedList<>(); + tempObjHeader = parseErrorObjectList(llErrObjList, cb); + + //check whether OPEN-OBJECT is present. + if ((tempObjHeader != null) + && (tempObjHeader.getObjClass() == PcepOpenObjectVer1.OPEN_OBJ_CLASS)) { + + if (llErrObjList.isEmpty()) { + throw new PcepParseException("<error-obj-list> should be present if OPEN-OBJECT exists"); + } + + PcepOpenObject pcepOpenObj = PcepOpenObjectVer1.read(cb); + this.errObjListWithOpen = new ErrorObjListWithOpen(llErrObjList, pcepOpenObj); + + } else if ((tempObjHeader != null) //check whether RP or TE Object is present. + && ((tempObjHeader.getObjClass() == PcepRPObjectVer1.RP_OBJ_CLASS) + || (tempObjHeader.getObjClass() == PcepTEObjectVer1.TE_OBJ_CLASS))) { + + this.errInfo = new PcepErrorInfoVer1(null, null, llErrObjList); + this.errInfo.read(cb); + + } else if (!llErrObjList.isEmpty()) { + //If only PCEP-ERROR list is present then store it in errObjListWithOpen. + this.errObjListWithOpen = new ErrorObjListWithOpen(llErrObjList); + } else { + throw new PcepParseException("Empty PCEP-ERROR message."); + } + } + + /** + * Parse error-obj-list. + * + * @param llErrObjList error object list output + * @param cb channel buffer input + * @throws PcepParseException if mandatory fields are missing + * @return error object header + */ + public PcepObjectHeader parseErrorObjectList(LinkedList<PcepErrorObject> llErrObjList, ChannelBuffer cb) + throws PcepParseException { + PcepObjectHeader tempObjHeader = null; + + while (0 < cb.readableBytes()) { + cb.markReaderIndex(); + tempObjHeader = PcepObjectHeader.read(cb); + cb.resetReaderIndex(); + if (tempObjHeader.getObjClass() == PcepErrorObjectVer1.ERROR_OBJ_CLASS) { + llErrObjList.add(PcepErrorObjectVer1.read(cb)); + } else { + break; + } + } + return tempObjHeader; + } + } + + /** + * Builder class for PCEP error message. + */ + public static class Builder implements PcepErrorMsg.Builder { + // Pcep error message fields + + private ErrorObjListWithOpen errObjListWithOpen = null; //optional ( <error-obj-list> [<Open>] ) + private PcepErrorInfo errInfo = null; //optional <error> [<error-list>] + + @Override + public PcepVersion getVersion() { + return PcepVersion.PCEP_1; + } + + @Override + public PcepType getType() { + return PcepType.ERROR; + } + + @Override + public PcepErrorMsg build() { + return new PcepErrorMsgVer1(this.errObjListWithOpen, this.errInfo); + } + + @Override + public ErrorObjListWithOpen getErrorObjListWithOpen() { + return this.errObjListWithOpen; + } + + @Override + public Builder setErrorObjListWithOpen(ErrorObjListWithOpen errObjListWithOpen) { + this.errObjListWithOpen = errObjListWithOpen; + return this; + } + + @Override + public PcepErrorInfo getPcepErrorInfo() { + return this.errInfo; + } + + @Override + public Builder setPcepErrorInfo(PcepErrorInfo errInfo) { + this.errInfo = errInfo; + return this; + } + } + + @Override + public void writeTo(ChannelBuffer cb) throws PcepParseException { + WRITER.write(cb, this); + } + + public static final Writer WRITER = new Writer(); + + /** + * Writer class for writing PCEP error Message to channel buffer. + */ + static class Writer implements PcepMessageWriter<PcepErrorMsgVer1> { + @Override + public void write(ChannelBuffer cb, PcepErrorMsgVer1 message) throws PcepParseException { + int startIndex = cb.writerIndex(); + // first 3 bits set to version + cb.writeByte((byte) (PACKET_VERSION << PcepMessageVer1.SHIFT_FLAG)); + // message type 0xC + cb.writeByte(MSG_TYPE.getType()); + // length is length of variable message, will be updated at the end + // Store the position of message + // length in buffer + int msgLenIndex = cb.writerIndex(); + cb.writeShort(0); + ErrorObjListWithOpen errObjListWithOpen = message.getErrorObjListWithOpen(); + PcepErrorInfo errInfo = message.getPcepErrorInfo(); + + // write ( <error-obj-list> [<Open>] ) if exists. + // otherwise write <error> [<error-list>] + + if ((errObjListWithOpen != null) + && (errObjListWithOpen.isErrorObjListWithOpenPresent())) { + errObjListWithOpen.write(cb); + } else if ((errInfo != null) && (errInfo.isErrorInfoPresent())) { + errInfo.write(cb); + } else { + throw new PcepParseException("Empty PCEP-ERROR message."); + } + // PcepErrorMessage message length field + int length = cb.writerIndex() - startIndex; + cb.setShort(msgLenIndex, (short) length); + } + } + + @Override + public PcepVersion getVersion() { + return PcepVersion.PCEP_1; + } + + @Override + public PcepType getType() { + return MSG_TYPE; + } + + @Override + public ErrorObjListWithOpen getErrorObjListWithOpen() { + return this.errObjListWithOpen; + } + + @Override + public void setErrorObjListWithOpen(ErrorObjListWithOpen errObjListWithOpen) { + this.errObjListWithOpen = errObjListWithOpen; + } + + @Override + public PcepErrorInfo getPcepErrorInfo() { + return this.errInfo; + } + + @Override + public void setPcepErrorInfo(PcepErrorInfo errInfo) { + this.errInfo = errInfo; + } + + /** + * Return list of Error types. + * + * @return error types list + */ + public LinkedList<Integer> getErrorType() { + LinkedList<Integer> llErrorType = new LinkedList<>(); + if ((errObjListWithOpen != null) + && (errObjListWithOpen.isErrorObjListWithOpenPresent())) { + llErrorType = errObjListWithOpen.getErrorType(); + } else if ((errInfo != null) && (errInfo.isErrorInfoPresent())) { + llErrorType = errInfo.getErrorType(); + } + + return llErrorType; + } + + /** + * Return list of Error values. + * + * @return error value list + */ + public LinkedList<Integer> getErrorValue() { + LinkedList<Integer> llErrorValue = new LinkedList<>(); + if ((errObjListWithOpen != null) + && (errObjListWithOpen.isErrorObjListWithOpenPresent())) { + llErrorValue = errObjListWithOpen.getErrorValue(); + } else if ((errInfo != null) && (errInfo.isErrorInfoPresent())) { + llErrorValue = errInfo.getErrorValue(); + } + + return llErrorValue; + } + + @Override + public String toString() { + ToStringHelper toStrHelper = MoreObjects.toStringHelper(getClass()); + + if ((errObjListWithOpen != null) + && (errObjListWithOpen.isErrorObjListWithOpenPresent())) { + toStrHelper.add("ErrorObjectListWithOpen", errObjListWithOpen); + } + if ((errInfo != null) && (errInfo.isErrorInfoPresent())) { + toStrHelper.add("ErrorInfo", errInfo); + } + + return toStrHelper.toString(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepErrorObjectVer1.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepErrorObjectVer1.java new file mode 100644 index 00000000..48a337f4 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepErrorObjectVer1.java @@ -0,0 +1,341 @@ +/* + * 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.PcepErrorObject; +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 Error Object. + */ +public class PcepErrorObjectVer1 implements PcepErrorObject { + + /* + 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 + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Object-Class | OT |Res|P|I| Object Length (bytes) | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Reserved | Flags | Error-Type | Error-value | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | | + // Optional TLVs // + | | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + */ + protected static final Logger log = LoggerFactory.getLogger(PcepErrorObjectVer1.class); + + public static final byte ERROR_OBJ_TYPE = 1; + public static final byte ERROR_OBJ_CLASS = 13; + public static final byte ERROR_OBJECT_VERSION = 1; + //ERROR_OBJ_MINIMUM_LENGTH = CommonHeaderLen(4)+ErrorObjectHeaderLen(4) + public static final short ERROR_OBJ_MINIMUM_LENGTH = 8; + public static final int OBJECT_HEADER_LENGTH = 4; + + public static final PcepObjectHeader DEFAULT_ERROR_OBJECT_HEADER = new PcepObjectHeader(ERROR_OBJ_CLASS, + ERROR_OBJ_TYPE, PcepObjectHeader.REQ_OBJ_OPTIONAL_PROCESS, PcepObjectHeader.RSP_OBJ_PROCESSED, + ERROR_OBJ_MINIMUM_LENGTH); + + private PcepObjectHeader errorObjHeader; + private byte yErrorType; + private byte yErrorValue; + private LinkedList<PcepValueType> llOptionalTlv; // Optional TLV + + /** + * Constructor to initialize variables. + * + * @param errorObjHeader ERROR Object header + * @param yErrorType Error Type + * @param yErrorValue Error Value + * @param llOptionalTlv list of optional TLV + */ + + public PcepErrorObjectVer1(PcepObjectHeader errorObjHeader, byte yErrorType, byte yErrorValue, + LinkedList<PcepValueType> llOptionalTlv) { + this.errorObjHeader = errorObjHeader; + this.yErrorType = yErrorType; + this.yErrorValue = yErrorValue; + this.llOptionalTlv = llOptionalTlv; + } + + /** + * sets Object Header. + * + * @param obj Error-Object header + */ + public void setLspObjHeader(PcepObjectHeader obj) { + this.errorObjHeader = obj; + } + + @Override + public void setErrorType(byte yErrorType) { + this.yErrorType = yErrorType; + } + + @Override + public void setErrorValue(byte yErrorValue) { + this.yErrorValue = yErrorValue; + } + + /** + * returns object header. + * + * @return errorObjHeader Error-Object header + */ + public PcepObjectHeader getErrorObjHeader() { + return this.errorObjHeader; + } + + @Override + public int getErrorType() { + return this.yErrorType; + } + + @Override + public byte getErrorValue() { + return this.yErrorValue; + } + + @Override + public LinkedList<PcepValueType> getOptionalTlv() { + return this.llOptionalTlv; + } + + @Override + public void setOptionalTlv(LinkedList<PcepValueType> llOptionalTlv) { + this.llOptionalTlv = llOptionalTlv; + } + + /** + * Reads from channel buffer and returns object of PcepErrorObject. + * + * @param cb of channel buffer. + * @return object of PCEP-ERROR-OBJECT + */ + public static PcepErrorObject read(ChannelBuffer cb) { + + PcepObjectHeader errorObjHeader; + byte yErrorType; + byte yErrorValue; + LinkedList<PcepValueType> llOptionalTlv; + + errorObjHeader = PcepObjectHeader.read(cb); + + //take only ErrorObject buffer. + ChannelBuffer tempCb = cb.readBytes(errorObjHeader.getObjLen() - OBJECT_HEADER_LENGTH); + tempCb.readByte(); //ignore Reserved + tempCb.readByte(); //ignore Flags + yErrorType = tempCb.readByte(); + yErrorValue = tempCb.readByte(); + + llOptionalTlv = parseOptionalTlv(tempCb); + + return new PcepErrorObjectVer1(errorObjHeader, yErrorType, yErrorValue, llOptionalTlv); + } + + /** + * returns Linked list of optional tlvs. + * + * @param cb channel buffer. + * @return Linked list of optional tlvs + */ + protected static LinkedList<PcepValueType> parseOptionalTlv(ChannelBuffer cb) { + + LinkedList<PcepValueType> llOutOptionalTlv = new LinkedList<>(); + + byte[] yTemp = new byte[cb.readableBytes()]; + cb.readBytes(yTemp); + + return llOutOptionalTlv; + } + + @Override + public int write(ChannelBuffer cb) throws PcepParseException { + + //write Object header + int objStartIndex = cb.writerIndex(); + + int objLenIndex = errorObjHeader.write(cb); + + if (objLenIndex <= 0) { + throw new PcepParseException("While writing Error Object Header."); + } + + //write Reserved + cb.writeByte(0); + //write Flags + cb.writeByte(0); + //write ErrorType and ErrorValue + cb.writeByte(this.yErrorType); + cb.writeByte(this.yErrorValue); + + // Add optional TLV + packOptionalTlv(cb); + + //Update object length now + int length = cb.writerIndex() - objStartIndex; + //will be helpful during print(). + errorObjHeader.setObjLen((short) length); + // As per RFC the length of object should be + // multiples of 4 + int pad = length % 4; + if (pad != 0) { + pad = 4 - pad; + for (int i = 0; i < pad; i++) { + cb.writeByte((byte) 0); + } + length = length + pad; + } + + cb.setShort(objLenIndex, (short) length); + return length; + } + + /** + * Pack the Optional tlvs. + * + * @param cb channel buffer. + * @return writer index. + */ + protected int packOptionalTlv(ChannelBuffer cb) { + + ListIterator<PcepValueType> listIterator = llOptionalTlv.listIterator(); + int startIndex = cb.writerIndex(); + while (listIterator.hasNext()) { + PcepValueType tlv = listIterator.next(); + + if (tlv == null) { + log.debug("TLV is null from OptionalTlv list"); + continue; + } + tlv.write(cb); + } + + return cb.writerIndex() - startIndex; + } + + /** + * Builder class for PCEP error object. + */ + public static class Builder implements PcepErrorObject.Builder { + + private boolean bIsHeaderSet = false; + + private PcepObjectHeader errorObjHeader; + private byte yErrorType; + private byte yErrorValue; + + private boolean bIsPFlagSet = false; + private boolean bPFlag; + + private boolean bIsIFlagSet = false; + private boolean bIFlag; + + private LinkedList<PcepValueType> llOptionalTlv = new LinkedList<>(); + + @Override + public PcepErrorObject build() { + + PcepObjectHeader errorObjHeader = this.bIsHeaderSet ? this.errorObjHeader : DEFAULT_ERROR_OBJECT_HEADER; + + if (bIsPFlagSet) { + errorObjHeader.setPFlag(bPFlag); + } + + if (bIsIFlagSet) { + errorObjHeader.setIFlag(bIFlag); + } + + return new PcepErrorObjectVer1(errorObjHeader, yErrorType, yErrorValue, llOptionalTlv); + } + + @Override + public PcepObjectHeader getErrorObjHeader() { + return this.errorObjHeader; + } + + @Override + public Builder setErrorObjHeader(PcepObjectHeader obj) { + this.errorObjHeader = obj; + this.bIsHeaderSet = true; + return this; + } + + @Override + public int getErrorType() { + return this.yErrorType; + } + + @Override + public Builder setErrorType(byte value) { + this.yErrorType = value; + return this; + } + + @Override + public byte getErrorValue() { + return this.yErrorValue; + } + + @Override + public Builder setErrorValue(byte value) { + this.yErrorValue = value; + return this; + } + + @Override + public Builder setOptionalTlv(LinkedList<PcepValueType> llOptionalTlv) { + this.llOptionalTlv = llOptionalTlv; + return this; + } + + @Override + public LinkedList<PcepValueType> getOptionalTlv() { + return this.llOptionalTlv; + } + + @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("ObjectHeader", errorObjHeader).add("ErrorType", yErrorType) + .add("ErrorValue", yErrorValue).add("OptionalTlv", llOptionalTlv).toString(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepErrorVer1.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepErrorVer1.java new file mode 100644 index 00000000..0ea51410 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepErrorVer1.java @@ -0,0 +1,399 @@ +/* + * 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.PcepError; +import org.onosproject.pcepio.protocol.PcepErrorObject; +import org.onosproject.pcepio.protocol.PcepRPObject; +import org.onosproject.pcepio.protocol.PcepTEObject; +import org.onosproject.pcepio.types.PcepObjectHeader; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.google.common.base.MoreObjects; + +/** + * Provides PcepError list which contains RP or TE objects. + * Reference:PCEP Extension for Transporting TE Data draft-dhodylee-pce-pcep-te-data-extn-02. + */ +public class PcepErrorVer1 implements PcepError { + + /* + <error>::=[<request-id-list> | <te-id-list>] + <error-obj-list> + + <request-id-list>::=<RP>[<request-id-list>] + + <te-id-list>::=<TE>[<te-id-list>] + */ + + protected static final Logger log = LoggerFactory.getLogger(PcepErrorVer1.class); + + private boolean isErroInfoSet; + //PcepErrorObject list + private LinkedList<PcepErrorObject> llErrObjList; + //PcepRPObject list + private LinkedList<PcepRPObject> llRPObjList; + //PcepTEObject list + private LinkedList<PcepTEObject> llTEObjList; + private boolean isTEObjListSet; + + public static final int OBJECT_HEADER_LENGTH = 4; + + /** + * Constructor to initialize variable. + */ + public PcepErrorVer1() { + this.llRPObjList = null; + this.llTEObjList = null; + this.llErrObjList = null; + } + + /** + * Constructor to initialize variable. + * + * @param llRPObjList list of PcepRPObject + * @param llTEObjList list of PcepTEObject + * @param llErrObjListObjList list of PcepErrorObject + */ + public PcepErrorVer1(LinkedList<PcepRPObject> llRPObjList, LinkedList<PcepTEObject> llTEObjList, + LinkedList<PcepErrorObject> llErrObjListObjList) { + this.llRPObjList = llRPObjList; + this.llTEObjList = llTEObjList; + this.llErrObjList = llErrObjListObjList; + } + + /** + * Constructor to initialize PcepError. + * + * @param llErrObjList list of PcepErrorObject + */ + public PcepErrorVer1(LinkedList<PcepErrorObject> llErrObjList) { + this.llRPObjList = null; + this.llTEObjList = null; + this.llErrObjList = llErrObjList; + } + + @Override + public LinkedList<PcepRPObject> getRPObjList() { + return this.llRPObjList; + } + + @Override + public LinkedList<PcepTEObject> getTEObjList() { + return this.llTEObjList; + } + + @Override + public LinkedList<PcepErrorObject> getErrorObjList() { + return this.llErrObjList; + } + + /** + * Parse RP List from the channel buffer. + * + * @param cb of type channel buffer + * @throws PcepParseException if mandatory fields are missing + */ + public void parseRPList(ChannelBuffer cb) throws PcepParseException { + byte yObjClass; + byte yObjType; + + llRPObjList = new LinkedList<>(); + + // caller should verify for RP object + if (cb.readableBytes() < OBJECT_HEADER_LENGTH) { + log.debug("Unable to find RP Object"); + return; + } + + cb.markReaderIndex(); + PcepObjectHeader tempObjHeader = PcepObjectHeader.read(cb); + cb.resetReaderIndex(); + yObjClass = tempObjHeader.getObjClass(); + yObjType = tempObjHeader.getObjType(); + PcepRPObject rpObj; + while ((yObjClass == PcepRPObjectVer1.RP_OBJ_CLASS) && (yObjType == PcepRPObjectVer1.RP_OBJ_TYPE)) { + rpObj = PcepRPObjectVer1.read(cb); + llRPObjList.add(rpObj); + + if (cb.readableBytes() > OBJECT_HEADER_LENGTH) { + cb.markReaderIndex(); + tempObjHeader = PcepObjectHeader.read(cb); + cb.resetReaderIndex(); + yObjClass = tempObjHeader.getObjClass(); + yObjType = tempObjHeader.getObjType(); + } else { + break; + } + } + } + + /** + * Parse TE List from the channel buffer. + * + * @param cb of type channel buffer + * @throws PcepParseException if mandatory fields are missing + */ + public void parseTEList(ChannelBuffer cb) throws PcepParseException { + byte yObjClass; + byte yObjType; + + llTEObjList = new LinkedList<>(); + + // caller should verify for TE object + if (cb.readableBytes() < OBJECT_HEADER_LENGTH) { + log.debug("Unable to find TE Object"); + return; + } + + cb.markReaderIndex(); + PcepObjectHeader tempObjHeader = PcepObjectHeader.read(cb); + cb.resetReaderIndex(); + yObjClass = tempObjHeader.getObjClass(); + yObjType = tempObjHeader.getObjType(); + PcepTEObject teObj; + while ((yObjClass == PcepTEObjectVer1.TE_OBJ_CLASS) && ((yObjType == PcepTEObjectVer1.TE_OBJ_TYPE_NODE_VALUE) + || (yObjType == PcepTEObjectVer1.TE_OBJ_TYPE_LINK_VALUE))) { + teObj = PcepTEObjectVer1.read(cb); + llTEObjList.add(teObj); + + if (cb.readableBytes() > OBJECT_HEADER_LENGTH) { + cb.markReaderIndex(); + tempObjHeader = PcepObjectHeader.read(cb); + cb.resetReaderIndex(); + yObjClass = tempObjHeader.getObjClass(); + yObjType = tempObjHeader.getObjType(); + } else { + break; + } + } + } + + /** + * parseErrObjList from the channel buffer. + * + * @param cb of type channel buffer + * @throws PcepParseException if mandatory fields are missing + */ + public void parseErrObjList(ChannelBuffer cb) throws PcepParseException { + byte yObjClass; + byte yObjType; + boolean bIsErrorObjFound = false; + + llErrObjList = new LinkedList<>(); + + // caller should verify for RP object + if (cb.readableBytes() < OBJECT_HEADER_LENGTH) { + throw new PcepParseException("Unable to find PCEP-ERROR Object"); + } + + cb.markReaderIndex(); + PcepObjectHeader tempObjHeader = PcepObjectHeader.read(cb); + cb.resetReaderIndex(); + yObjClass = tempObjHeader.getObjClass(); + yObjType = tempObjHeader.getObjType(); + PcepErrorObject errorObject; + while ((yObjClass == PcepErrorObjectVer1.ERROR_OBJ_CLASS) && (yObjType == PcepErrorObjectVer1.ERROR_OBJ_TYPE)) { + errorObject = PcepErrorObjectVer1.read(cb); + llErrObjList.add(errorObject); + bIsErrorObjFound = true; + + if (cb.readableBytes() > OBJECT_HEADER_LENGTH) { + cb.markReaderIndex(); + tempObjHeader = PcepObjectHeader.read(cb); + cb.resetReaderIndex(); + yObjClass = tempObjHeader.getObjClass(); + yObjType = tempObjHeader.getObjType(); + } else { + break; + } + } + + if (!bIsErrorObjFound) { + throw new PcepParseException("At least one PCEP-ERROR Object should be present."); + } + } + + /** + * Reads the byte stream of PcepError from channel buffer. + * + * @param cb of type channel buffer + * @return PcepError error part of PCEP-ERROR + * @throws PcepParseException if mandatory fields are missing + */ + public static PcepErrorVer1 read(ChannelBuffer cb) throws PcepParseException { + if (cb.readableBytes() < OBJECT_HEADER_LENGTH) { + throw new PcepParseException("Unknown Object"); + } + + PcepErrorVer1 pcepError = new PcepErrorVer1(); + // check whether any PCEP Error Info is present + cb.markReaderIndex(); + PcepObjectHeader tempObjHeader = PcepObjectHeader.read(cb); + cb.resetReaderIndex(); + byte yObjClass = tempObjHeader.getObjClass(); + + //If RPlist present then store it.RPList and TEList are optional + if (yObjClass == PcepRPObjectVer1.RP_OBJ_CLASS) { + log.debug("RP_LIST"); + pcepError.parseRPList(cb); + yObjClass = checkNextObject(cb); + } else if (yObjClass == PcepTEObjectVer1.TE_OBJ_CLASS) { + log.debug("TE_LIST"); + pcepError.parseTEList(cb); + yObjClass = checkNextObject(cb); + } + + if (yObjClass == PcepErrorObjectVer1.ERROR_OBJ_CLASS) { + log.debug("PCEP-ERROR obj list"); + pcepError.parseErrObjList(cb); + yObjClass = checkNextObject(cb); + } + + return pcepError; + } + + /** + * Checks Next Object. + * + * @param cb of type channel buffer. + * @return object type class. + */ + private static byte checkNextObject(ChannelBuffer cb) { + if (cb.readableBytes() < OBJECT_HEADER_LENGTH) { + return 0; + } + cb.markReaderIndex(); + PcepObjectHeader tempObjHeader = PcepObjectHeader.read(cb); + cb.resetReaderIndex(); + return tempObjHeader.getObjClass(); + } + + /** + * Writes the byte stream of PCEP error to the channel buffer. + * + * @param cb of type channel buffer + * @return object length index + * @throws PcepParseException if mandatory fields are missing + */ + @Override + public int write(ChannelBuffer cb) throws PcepParseException { + int iLenStartIndex = cb.writerIndex(); + + // RPlist is optional + if (this.isErroInfoSet) { + ListIterator<PcepRPObject> rpObjlistIterator = this.llRPObjList.listIterator(); + while (rpObjlistIterator.hasNext()) { + rpObjlistIterator.next().write(cb); + } + } + + // TElist is optional + if (this.isTEObjListSet) { + ListIterator<PcepTEObject> teObjlistIterator = this.llTEObjList.listIterator(); + while (teObjlistIterator.hasNext()) { + teObjlistIterator.next().write(cb); + } + } + //ErrList is mandatory + ListIterator<PcepErrorObject> errlistIterator = this.llErrObjList.listIterator(); + while (errlistIterator.hasNext()) { + errlistIterator.next().write(cb); + } + + return cb.writerIndex() - iLenStartIndex; + } + + /** + * Builder for error part of PCEP-ERROR. + */ + public static class Builder implements PcepError.Builder { + + private LinkedList<PcepRPObject> llRPObjList; + private LinkedList<PcepTEObject> llTEObjList; + private LinkedList<PcepErrorObject> llErrObjList; + + @Override + public PcepError build() { + return new PcepErrorVer1(llRPObjList, llTEObjList, llErrObjList); + } + + @Override + public LinkedList<PcepRPObject> getRPObjList() { + return this.llRPObjList; + } + + @Override + public Builder setRPObjList(LinkedList<PcepRPObject> llRPObjList) { + this.llRPObjList = llRPObjList; + return this; + } + + @Override + public LinkedList<PcepTEObject> getTEObjList() { + return this.llTEObjList; + } + + @Override + public Builder setTEObjList(LinkedList<PcepTEObject> llTEObjList) { + this.llTEObjList = llTEObjList; + return this; + } + + @Override + public LinkedList<PcepErrorObject> getErrorObjList() { + return this.llErrObjList; + } + + @Override + public Builder setErrorObjList(LinkedList<PcepErrorObject> llErrObjList) { + this.llErrObjList = llErrObjList; + return this; + } + + } + + @Override + public void setRPObjList(LinkedList<PcepRPObject> llRPObjList) { + this.llRPObjList = llRPObjList; + } + + @Override + public void setTEObjList(LinkedList<PcepTEObject> llTEObjList) { + this.llTEObjList = llTEObjList; + } + + @Override + public void setErrorObjList(LinkedList<PcepErrorObject> llErrObjList) { + this.llErrObjList = llErrObjList; + } + + @Override + public String toString() { + return MoreObjects.toStringHelper(getClass()) + .omitNullValues() + .add("RpObjectList", llRPObjList) + .add("TeObjectList", llTEObjList) + .add("ErrorObjectList", llErrObjList) + .toString(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepFactoryVer1.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepFactoryVer1.java new file mode 100644 index 00000000..6b5d450a --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepFactoryVer1.java @@ -0,0 +1,226 @@ +/* + * 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 org.onosproject.pcepio.protocol.PcInitiatedLspRequest; +import org.onosproject.pcepio.protocol.PcepAttribute; +import org.onosproject.pcepio.protocol.PcepBandwidthObject; +import org.onosproject.pcepio.protocol.PcepCloseMsg; +import org.onosproject.pcepio.protocol.PcepEndPointsObject; +import org.onosproject.pcepio.protocol.PcepEroObject; +import org.onosproject.pcepio.protocol.PcepErrorInfo; +import org.onosproject.pcepio.protocol.PcepError; +import org.onosproject.pcepio.protocol.PcepErrorMsg; +import org.onosproject.pcepio.protocol.PcepErrorObject; +import org.onosproject.pcepio.protocol.PcepFactory; +import org.onosproject.pcepio.protocol.PcepFecObjectIPv4Adjacency; +import org.onosproject.pcepio.protocol.PcepInitiateMsg; +import org.onosproject.pcepio.protocol.PcepIroObject; +import org.onosproject.pcepio.protocol.PcepKeepaliveMsg; +import org.onosproject.pcepio.protocol.PcepLabelObject; +import org.onosproject.pcepio.protocol.PcepLabelRangeObject; +import org.onosproject.pcepio.protocol.PcepLabelRangeResvMsg; +import org.onosproject.pcepio.protocol.PcepLabelUpdate; +import org.onosproject.pcepio.protocol.PcepLabelUpdateMsg; +import org.onosproject.pcepio.protocol.PcepLspObject; +import org.onosproject.pcepio.protocol.PcepLspaObject; +import org.onosproject.pcepio.protocol.PcepMessage; +import org.onosproject.pcepio.protocol.PcepMessageReader; +import org.onosproject.pcepio.protocol.PcepMetricObject; +import org.onosproject.pcepio.protocol.PcepMsgPath; +import org.onosproject.pcepio.protocol.PcepOpenMsg; +import org.onosproject.pcepio.protocol.PcepOpenObject; +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.protocol.PcepVersion; + +/** + * Provides PCEP Factory and returns builder classes for all objects and messages. + */ +public class PcepFactoryVer1 implements PcepFactory { + + public static final PcepFactoryVer1 INSTANCE = new PcepFactoryVer1(); + + @Override + public PcepOpenMsg.Builder buildOpenMsg() { + return new PcepOpenMsgVer1.Builder(); + } + + @Override + public PcepOpenObject.Builder buildOpenObject() { + return new PcepOpenObjectVer1.Builder(); + } + + @Override + public PcepKeepaliveMsg.Builder buildKeepaliveMsg() { + return new PcepKeepaliveMsgVer1.Builder(); + } + + @Override + public PcepCloseMsg.Builder buildCloseMsg() { + return new PcepCloseMsgVer1.Builder(); + } + + @Override + public PcepUpdateMsg.Builder buildUpdateMsg() { + return new PcepUpdateMsgVer1.Builder(); + } + + @Override + public PcepReportMsg.Builder buildReportMsg() { + return new PcepReportMsgVer1.Builder(); + } + + @Override + public PcepInitiateMsg.Builder buildPcepInitiateMsg() { + return new PcepInitiateMsgVer1.Builder(); + } + + @Override + public PcepLspObject.Builder buildLspObject() { + return new PcepLspObjectVer1.Builder(); + } + + @Override + public PcepMessageReader<PcepMessage> getReader() { + return PcepMessageVer1.READER; + } + + @Override + public PcepVersion getVersion() { + return PcepVersion.PCEP_1; + } + + @Override + public PcepSrpObject.Builder buildSrpObject() { + return new PcepSrpObjectVer1.Builder(); + } + + @Override + public PcepEndPointsObject.Builder buildEndPointsObject() { + return new PcepEndPointsObjectVer1.Builder(); + } + + @Override + public PcepEroObject.Builder buildEroObject() { + return new PcepEroObjectVer1.Builder(); + } + + @Override + public PcepRroObject.Builder buildRroObject() { + return new PcepRroObjectVer1.Builder(); + } + + @Override + public PcepLspaObject.Builder buildLspaObject() { + return new PcepLspaObjectVer1.Builder(); + } + + @Override + public PcepIroObject.Builder buildIroObject() { + return new PcepIroObjectVer1.Builder(); + } + + @Override + public PcepMetricObject.Builder buildMetricObject() { + return new PcepMetricObjectVer1.Builder(); + } + + @Override + public PcepBandwidthObject.Builder buildBandwidthObject() { + return new PcepBandwidthObjectVer1.Builder(); + } + + @Override + public PcepMsgPath.Builder buildPcepMsgPath() { + return new PcepMsgPathVer1.Builder(); + } + + @Override + public PcepStateReport.Builder buildPcepStateReport() { + return new PcepStateReportVer1.Builder(); + } + + @Override + public PcepUpdateRequest.Builder buildPcepUpdateRequest() { + return new PcepUpdateRequestVer1.Builder(); + } + + @Override + public PcInitiatedLspRequest.Builder buildPcInitiatedLspRequest() { + return new PcInitiatedLspRequestVer1.Builder(); + } + + @Override + public PcepAttribute.Builder buildPcepAttribute() { + return new PcepAttributeVer1.Builder(); + } + + @Override + public PcepLabelUpdateMsg.Builder buildPcepLabelUpdateMsg() { + return new PcepLabelUpdateMsgVer1.Builder(); + } + + @Override + public PcepLabelUpdate.Builder buildPcepLabelUpdateObject() { + return new PcepLabelUpdateVer1.Builder(); + } + + @Override + public PcepLabelObject.Builder buildLabelObject() { + return new PcepLabelObjectVer1.Builder(); + } + + @Override + public PcepErrorMsg.Builder buildPcepErrorMsg() { + return new PcepErrorMsgVer1.Builder(); + } + + @Override + public PcepErrorObject.Builder buildPcepErrorObject() { + return new PcepErrorObjectVer1.Builder(); + } + + @Override + public PcepFecObjectIPv4Adjacency.Builder buildFecIpv4Adjacency() { + return new PcepFecObjectIPv4AdjacencyVer1.Builder(); + } + + @Override + public PcepErrorInfo.Builder buildPcepErrorInfo() { + return new PcepErrorInfoVer1.Builder(); + } + + @Override + public PcepError.Builder buildPcepError() { + return new PcepErrorVer1.Builder(); + } + + @Override + public PcepLabelRangeObject.Builder buildPcepLabelRangeObject() { + return new PcepLabelRangeObjectVer1.Builder(); + } + + @Override + public PcepLabelRangeResvMsg.Builder buildPcepLabelRangeResvMsg() { + return new PcepLabelRangeResvMsgVer1.Builder(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepFecObjectIPv4AdjacencyVer1.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepFecObjectIPv4AdjacencyVer1.java new file mode 100644 index 00000000..51c672d3 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepFecObjectIPv4AdjacencyVer1.java @@ -0,0 +1,253 @@ +/* + * 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 org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.pcepio.exceptions.PcepParseException; +import org.onosproject.pcepio.protocol.PcepFecObjectIPv4Adjacency; +import org.onosproject.pcepio.protocol.PcepVersion; +import org.onosproject.pcepio.types.PcepObjectHeader; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.google.common.base.MoreObjects; + +/** + * Provides PCEP fec Object IPv4 Adjacency object. + */ +public class PcepFecObjectIPv4AdjacencyVer1 implements PcepFecObjectIPv4Adjacency { + + /* + * ref : draft-zhao-pce-pcep-extension-for-pce-controller-01 , section : 7.5 + * + 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 + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Local IPv4 address | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Remote IPv4 address | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + + FEC Object-Type is 3 IPv4 Adjacency + */ + protected static final Logger log = LoggerFactory.getLogger(PcepFecObjectIPv4AdjacencyVer1.class); + + public static final byte FEC_OBJ_TYPE = 3; + public static final byte FEC_OBJ_CLASS = 36; //to be defined + public static final byte FEC_OBJECT_VERSION = 1; + public static final short FEC_OBJ_MINIMUM_LENGTH = 12; + public static final int MINIMUM_COMMON_HEADER_LENGTH = 4; + + static final PcepObjectHeader DEFAULT_FEC_OBJECT_HEADER = new PcepObjectHeader(FEC_OBJ_CLASS, FEC_OBJ_TYPE, + PcepObjectHeader.REQ_OBJ_OPTIONAL_PROCESS, PcepObjectHeader.RSP_OBJ_PROCESSED, FEC_OBJ_MINIMUM_LENGTH); + + private PcepObjectHeader fecObjHeader; + private int localIPv4Address; + private int remoteIPv4Address; + + /** + * Constructor to initialize parameters for PCEP fec object . + * + * @param fecObjHeader FEC Object header + * @param localIPv4Address Local IPv4 Address + * @param remoteIPv4Address Remote IPv4 Address + */ + public PcepFecObjectIPv4AdjacencyVer1(PcepObjectHeader fecObjHeader, int localIPv4Address, int remoteIPv4Address) { + this.fecObjHeader = fecObjHeader; + this.localIPv4Address = localIPv4Address; + this.remoteIPv4Address = remoteIPv4Address; + } + + /** + * Sets Object header. + * + * @param obj Pcep fec Object Header + */ + public void setFecIpv4ObjHeader(PcepObjectHeader obj) { + this.fecObjHeader = obj; + } + + @Override + public int getLocalIPv4Address() { + return this.localIPv4Address; + } + + @Override + public void seLocalIPv4Address(int value) { + this.localIPv4Address = value; + } + + @Override + public int getRemoteIPv4Address() { + return this.remoteIPv4Address; + } + + @Override + public void seRemoteIPv4Address(int value) { + this.remoteIPv4Address = value; + } + + /** + * Reads from channel buffer and Returns object of PcepFecObjectIPv4Adjacency. + * + * @param cb of channel buffer. + * @return object of PcepFecObjectIPv4Adjacency + * @throws PcepParseException when fails to read from channel buffer + */ + public static PcepFecObjectIPv4Adjacency read(ChannelBuffer cb) throws PcepParseException { + + PcepObjectHeader fecObjHeader; + int localIPv4Address; + int remoteIPv4Address; + + fecObjHeader = PcepObjectHeader.read(cb); + + //take only FEC IPv4 Adjacency Object buffer. + ChannelBuffer tempCb = cb.readBytes(fecObjHeader.getObjLen() - MINIMUM_COMMON_HEADER_LENGTH); + localIPv4Address = tempCb.readInt(); + remoteIPv4Address = tempCb.readInt(); + + return new PcepFecObjectIPv4AdjacencyVer1(fecObjHeader, localIPv4Address, remoteIPv4Address); + } + + @Override + public int write(ChannelBuffer cb) throws PcepParseException { + + int objStartIndex = cb.writerIndex(); + + //Write common header + int objLenIndex = fecObjHeader.write(cb); + cb.writeInt(localIPv4Address); + cb.writeInt(remoteIPv4Address); + + //Now write FEC IPv4 Adjacency Object Length + cb.setShort(objLenIndex, (short) (cb.writerIndex() - objStartIndex)); + return cb.writerIndex(); + } + + /** + * Builder class for PCEP fec object IPv4 Adjacency. + */ + public static class Builder implements PcepFecObjectIPv4Adjacency.Builder { + private boolean bIsHeaderSet = false; + private boolean bIsLocalIPv4Addressset = false; + private boolean bIsRemoteIPv4Addressset = false; + + private PcepObjectHeader fecObjHeader; + int localIPv4Address; + int remoteIPv4Address; + + private boolean bIsPFlagSet = false; + private boolean bPFlag; + + private boolean bIsIFlagSet = false; + private boolean bIFlag; + + @Override + public PcepFecObjectIPv4Adjacency build() throws PcepParseException { + PcepObjectHeader fecObjHeader = this.bIsHeaderSet ? this.fecObjHeader : DEFAULT_FEC_OBJECT_HEADER; + + if (!this.bIsLocalIPv4Addressset) { + throw new PcepParseException( + "Local IPv4 Address not set while building PcepFecObjectIPv4Adjacency object."); + } + + if (!this.bIsRemoteIPv4Addressset) { + throw new PcepParseException( + " Remote IPv4 Address not set while building PcepFecObjectIPv4Adjacency object."); + } + + if (bIsPFlagSet) { + fecObjHeader.setPFlag(bPFlag); + } + + if (bIsIFlagSet) { + fecObjHeader.setIFlag(bIFlag); + } + return new PcepFecObjectIPv4AdjacencyVer1(fecObjHeader, this.localIPv4Address, this.remoteIPv4Address); + } + + @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 PcepObjectHeader getFecIpv4AdjacencyObjHeader() { + return this.fecObjHeader; + } + + @Override + public Builder setFecIpv4AdjacencyObjHeader(PcepObjectHeader obj) { + this.fecObjHeader = obj; + this.bIsHeaderSet = true; + return this; + } + + @Override + public int getLocalIPv4Address() { + return this.localIPv4Address; + } + + @Override + public Builder seLocalIPv4Address(int value) { + this.localIPv4Address = value; + this.bIsLocalIPv4Addressset = true; + return this; + } + + @Override + public int getRemoteIPv4Address() { + return this.remoteIPv4Address; + } + + @Override + public Builder seRemoteIPv4Address(int value) { + this.remoteIPv4Address = value; + this.bIsRemoteIPv4Addressset = true; + return this; + } + + } + + @Override + public PcepVersion getVersion() { + return PcepVersion.PCEP_1; + } + + @Override + public int getType() { + return FEC_OBJ_TYPE; + } + + @Override + public String toString() { + return MoreObjects.toStringHelper(getClass()) + .add("fecObjHeader", fecObjHeader) + .add("localIPv4Address", localIPv4Address) + .add("remoteIPv4Address", remoteIPv4Address).toString(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepFecObjectIPv4UnnumberedAdjacencyVer1.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepFecObjectIPv4UnnumberedAdjacencyVer1.java new file mode 100644 index 00000000..f2f54cda --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepFecObjectIPv4UnnumberedAdjacencyVer1.java @@ -0,0 +1,334 @@ +/* + * 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 org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.pcepio.exceptions.PcepParseException; +import org.onosproject.pcepio.protocol.PcepFecObjectIPv4UnnumberedAdjacency; +import org.onosproject.pcepio.protocol.PcepVersion; +import org.onosproject.pcepio.types.PcepObjectHeader; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.google.common.base.MoreObjects; + +/** + * Provides Pcep Fec Object IPv4 Unnumbered Adjacency object. + */ +public class PcepFecObjectIPv4UnnumberedAdjacencyVer1 implements PcepFecObjectIPv4UnnumberedAdjacency { + + /* + * ref : draft-zhao-pce-pcep-extension-for-pce-controller-01 , section : 7.5 + * + 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 + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Local Node-ID | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Local Interface ID | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Remote Node-ID | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Remote Interface ID | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + + FEC Object-Type is 5, Unnumbered Adjacency with IPv4 NodeIDs + */ + protected static final Logger log = LoggerFactory.getLogger(PcepFecObjectIPv4UnnumberedAdjacencyVer1.class); + + public static final byte FEC_OBJ_TYPE = 5; + public static final byte FEC_OBJ_CLASS = 63; //to be defined + public static final byte FEC_OBJECT_VERSION = 1; + public static final short FEC_OBJ_MINIMUM_LENGTH = 20; + public static final int MINIMUM_COMMON_HEADER_LENGTH = 4; + + static final PcepObjectHeader DEFAULT_FEC_OBJECT_HEADER = new PcepObjectHeader(FEC_OBJ_CLASS, FEC_OBJ_TYPE, + PcepObjectHeader.REQ_OBJ_OPTIONAL_PROCESS, PcepObjectHeader.RSP_OBJ_PROCESSED, FEC_OBJ_MINIMUM_LENGTH); + + private PcepObjectHeader fecObjHeader; + private int localNodeID; + private int localInterfaceID; + private int remoteNodeID; + private int remoteInterfaceID; + + /** + * Constructor to initialize parameter for PCEP fec object. + * + * @param fecObjHeader fec object header + * @param localNodeID local node ID + * @param localInterfaceID local interface ID + * @param remoteNodeID remote node ID + * @param remoteInterfaceID remote interface ID + */ + public PcepFecObjectIPv4UnnumberedAdjacencyVer1(PcepObjectHeader fecObjHeader, int localNodeID, + int localInterfaceID, int remoteNodeID, int remoteInterfaceID) { + this.fecObjHeader = fecObjHeader; + this.localNodeID = localNodeID; + this.localInterfaceID = localInterfaceID; + this.remoteNodeID = remoteNodeID; + this.remoteInterfaceID = remoteInterfaceID; + } + + /** + * Sets Object Header. + * + * @param obj object header + */ + public void setFecIpv4UnnumberedAdjacencyObjHeader(PcepObjectHeader obj) { + this.fecObjHeader = obj; + } + + @Override + public void setLocalNodeID(int localNodeID) { + this.localNodeID = localNodeID; + } + + /** + * Returns Object Header. + * + * @return fecObjHeader fec object header + */ + public PcepObjectHeader getFecIpv4UnnumberedAdjacencyObjHeader() { + return this.fecObjHeader; + } + + @Override + public int getLocalNodeID() { + return this.localNodeID; + } + + @Override + public int getLocalInterfaceID() { + return this.localInterfaceID; + } + + @Override + public void setLocalInterfaceID(int localInterfaceID) { + this.localInterfaceID = localInterfaceID; + } + + @Override + public int getRemoteNodeID() { + return this.remoteNodeID; + } + + @Override + public void setRemoteNodeID(int remoteNodeID) { + this.remoteNodeID = remoteNodeID; + } + + @Override + public int getRemoteInterfaceID() { + return this.remoteInterfaceID; + } + + @Override + public void setRemoteInterfaceID(int remoteInterfaceID) { + this.remoteInterfaceID = remoteInterfaceID; + } + + /** + * Reads from channel buffer and returns object of PcepFecObjectIPv4UnnumberedAdjacency. + * + * @param cb of channel buffer + * @return object of PcepFecObjectIPv4UnnumberedAdjacency + * @throws PcepParseException when fails to read from channel buffer + */ + public static PcepFecObjectIPv4UnnumberedAdjacency read(ChannelBuffer cb) throws PcepParseException { + + PcepObjectHeader fecObjHeader; + int localNodeID; + int localInterfaceID; + int remoteNodeID; + int remoteInterfaceID; + + fecObjHeader = PcepObjectHeader.read(cb); + + //take only FEC IPv4 Unnumbered Adjacency Object buffer. + ChannelBuffer tempCb = cb.readBytes(fecObjHeader.getObjLen() - MINIMUM_COMMON_HEADER_LENGTH); + localNodeID = tempCb.readInt(); + localInterfaceID = tempCb.readInt(); + remoteNodeID = tempCb.readInt(); + remoteInterfaceID = tempCb.readInt(); + + return new PcepFecObjectIPv4UnnumberedAdjacencyVer1(fecObjHeader, localNodeID, localInterfaceID, remoteNodeID, + remoteInterfaceID); + } + + @Override + public int write(ChannelBuffer cb) throws PcepParseException { + + int objStartIndex = cb.writerIndex(); + + //Write common header + int objLenIndex = fecObjHeader.write(cb); + cb.writeInt(localNodeID); + cb.writeInt(localInterfaceID); + cb.writeInt(remoteNodeID); + cb.writeInt(remoteInterfaceID); + + //Now write FEC IPv4 Unnumbered Adjacency Object Length + cb.setShort(objLenIndex, (short) (cb.writerIndex() - objStartIndex)); + + return cb.writerIndex(); + } + + /** + * Builder class for PCEP Fec object IPv4 unnumbered Adjacency. + */ + public static class Builder implements PcepFecObjectIPv4UnnumberedAdjacency.Builder { + private boolean bIsHeaderSet = false; + private boolean bIsLocalNodeIDset = false; + private boolean bIsLocalInterfaceIDset = false; + private boolean bIsRemoteNodeIDset = false; + private boolean bIsRemoteInterfaceIDset = false; + + private PcepObjectHeader fecObjHeader; + private int localNodeID; + private int localInterfaceID; + private int remoteNodeID; + private int remoteInterfaceID; + + private boolean bIsPFlagSet = false; + private boolean bPFlag; + + private boolean bIsIFlagSet = false; + private boolean bIFlag; + + @Override + public PcepFecObjectIPv4UnnumberedAdjacency build() throws PcepParseException { + PcepObjectHeader fecObjHeader = this.bIsHeaderSet ? this.fecObjHeader : DEFAULT_FEC_OBJECT_HEADER; + + if (!this.bIsLocalNodeIDset) { + throw new PcepParseException( + " Local Node ID not set while building PcepFecObjectIPv4UnnumberedAdjacency object."); + } + if (!this.bIsLocalInterfaceIDset) { + throw new PcepParseException( + " Local Interface ID not set while building PcepFecObjectIPv4UnnumberedAdjacency object."); + } + if (!this.bIsRemoteNodeIDset) { + throw new PcepParseException( + " Remote Node ID not set while building PcepFecObjectIPv4UnnumberedAdjacency object."); + } + if (!this.bIsRemoteInterfaceIDset) { + throw new PcepParseException( + " Remote Interface ID not set while building PcepFecObjectIPv4UnnumberedAdjacency object."); + } + if (bIsPFlagSet) { + fecObjHeader.setPFlag(bPFlag); + } + if (bIsIFlagSet) { + fecObjHeader.setIFlag(bIFlag); + } + return new PcepFecObjectIPv4UnnumberedAdjacencyVer1(fecObjHeader, this.localNodeID, this.localInterfaceID, + this.remoteNodeID, this.remoteInterfaceID); + } + + @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 PcepObjectHeader getFecIpv4UnnumberedAdjacencyObjHeader() { + return this.fecObjHeader; + } + + @Override + public Builder setFecIpv4UnnumberedAdjacencyObjHeader(PcepObjectHeader obj) { + this.fecObjHeader = obj; + this.bIsHeaderSet = true; + return this; + } + + @Override + public int getLocalNodeID() { + return this.localNodeID; + } + + @Override + public Builder setLocalNodeID(int value) { + this.localNodeID = value; + this.bIsLocalNodeIDset = true; + return this; + } + + @Override + public int getLocalInterfaceID() { + return this.localInterfaceID; + } + + @Override + public Builder setLocalInterfaceID(int value) { + this.localInterfaceID = value; + this.bIsLocalInterfaceIDset = true; + return this; + } + + @Override + public int getRemoteNodeID() { + return this.remoteNodeID; + } + + @Override + public Builder setRemoteNodeID(int value) { + this.remoteNodeID = value; + this.bIsRemoteNodeIDset = true; + return this; + } + + @Override + public int getRemoteInterfaceID() { + return this.remoteInterfaceID; + } + + @Override + public Builder setRemoteInterfaceID(int value) { + this.remoteInterfaceID = value; + this.bIsRemoteInterfaceIDset = true; + return this; + } + } + + @Override + public PcepVersion getVersion() { + return PcepVersion.PCEP_1; + } + + @Override + public int getType() { + return FEC_OBJ_TYPE; + } + + @Override + public String toString() { + return MoreObjects.toStringHelper(getClass()) + .add("LocalNodeID: ", localNodeID) + .add("LocalInterfaceID: ", localInterfaceID).add("RemoteNodeID: ", remoteNodeID) + .add("RemoteInterfaceID: ", remoteInterfaceID).toString(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepFecObjectIPv4Ver1.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepFecObjectIPv4Ver1.java new file mode 100644 index 00000000..354547a1 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepFecObjectIPv4Ver1.java @@ -0,0 +1,217 @@ +/* + * 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 org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.pcepio.exceptions.PcepParseException; +import org.onosproject.pcepio.protocol.PcepFecObjectIPv4; +import org.onosproject.pcepio.protocol.PcepVersion; +import org.onosproject.pcepio.types.PcepObjectHeader; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.google.common.base.MoreObjects; + +/** + * Provides Pcep Fec Object IPv4 object. + */ +public class PcepFecObjectIPv4Ver1 implements PcepFecObjectIPv4 { + + /* + * ref : draft-zhao-pce-pcep-extension-for-pce-controller-01 , section : 7.5 + * + 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 + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | IPv4 Node ID | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + + FEC Object-Type is 1 IPv4 Node ID + */ + protected static final Logger log = LoggerFactory.getLogger(PcepFecObjectIPv4Ver1.class); + + public static final byte FEC_OBJ_TYPE = 1; + public static final byte FEC_OBJ_CLASS = 63; //to be defined + public static final byte FEC_OBJECT_VERSION = 1; + public static final short FEC_OBJ_MINIMUM_LENGTH = 8; + public static final int MINIMUM_COMMON_HEADER_LENGTH = 4; + + static final PcepObjectHeader DEFAULT_FEC_OBJECT_HEADER = new PcepObjectHeader(FEC_OBJ_CLASS, FEC_OBJ_TYPE, + PcepObjectHeader.REQ_OBJ_OPTIONAL_PROCESS, PcepObjectHeader.RSP_OBJ_PROCESSED, FEC_OBJ_MINIMUM_LENGTH); + + private PcepObjectHeader fecObjHeader; + private int nodeID; + + /** + * Constructor to initialize parameters for PCEP fec object. + * + * @param fecObjHeader fec object header + * @param nodeID node id + */ + public PcepFecObjectIPv4Ver1(PcepObjectHeader fecObjHeader, int nodeID) { + this.fecObjHeader = fecObjHeader; + this.nodeID = nodeID; + } + + /** + * Sets the Object Header. + * + * @param obj object header + */ + public void setFecIpv4ObjHeader(PcepObjectHeader obj) { + this.fecObjHeader = obj; + } + + @Override + public void setNodeID(int nodeID) { + this.nodeID = nodeID; + } + + /** + * Returns Object Header. + * + * @return fecObjHeader fec object header + */ + public PcepObjectHeader getFecIpv4ObjHeader() { + return this.fecObjHeader; + } + + @Override + public int getNodeID() { + return this.nodeID; + } + + /** + * Reads from channel buffer and returns object of PcepFecObjectIPv4. + * + * @param cb of channel buffer + * @return object of PcepFecObjectIPv4 + * @throws PcepParseException when fails to read from channel buffer + */ + public static PcepFecObjectIPv4 read(ChannelBuffer cb) throws PcepParseException { + + PcepObjectHeader fecObjHeader; + int nodeID; + fecObjHeader = PcepObjectHeader.read(cb); + nodeID = cb.readInt(); + return new PcepFecObjectIPv4Ver1(fecObjHeader, nodeID); + } + + @Override + public int write(ChannelBuffer cb) throws PcepParseException { + + int objStartIndex = cb.writerIndex(); + + //write common header + int objLenIndex = fecObjHeader.write(cb); + cb.writeInt(nodeID); + + //now write FEC IPv4 Object Length + cb.setShort(objLenIndex, (short) (cb.writerIndex() - objStartIndex)); + return cb.writerIndex(); + } + + /** + * Builder class for PCEP fec pobject IPv4. + */ + public static class Builder implements PcepFecObjectIPv4.Builder { + private boolean bIsHeaderSet = false; + private boolean bIsNodeIdset = false; + + private PcepObjectHeader fecObjHeader; + private int nodeID; + + private boolean bIsPFlagSet = false; + private boolean bPFlag; + + private boolean bIsIFlagSet = false; + private boolean bIFlag; + + @Override + public PcepFecObjectIPv4 build() throws PcepParseException { + PcepObjectHeader fecObjHeader = this.bIsHeaderSet ? this.fecObjHeader : DEFAULT_FEC_OBJECT_HEADER; + + if (!this.bIsNodeIdset) { + throw new PcepParseException("NodeID not set while building PcepFecObjectIPv4 object."); + } + if (bIsPFlagSet) { + fecObjHeader.setPFlag(bPFlag); + } + if (bIsIFlagSet) { + fecObjHeader.setIFlag(bIFlag); + } + return new PcepFecObjectIPv4Ver1(fecObjHeader, this.nodeID); + } + + @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 PcepObjectHeader getFecIpv4ObjHeader() { + return this.fecObjHeader; + } + + @Override + public Builder setFecIpv4ObjHeader(PcepObjectHeader obj) { + this.fecObjHeader = obj; + this.bIsHeaderSet = true; + return this; + } + + @Override + public int getNodeID() { + return this.nodeID; + } + + @Override + public Builder setNodeID(int value) { + this.nodeID = value; + this.bIsNodeIdset = true; + return this; + } + + } + + @Override + public PcepVersion getVersion() { + return PcepVersion.PCEP_1; + } + + @Override + public int getType() { + return FEC_OBJ_TYPE; + } + + @Override + public String toString() { + return MoreObjects.toStringHelper(getClass()) + .add("fecObjHeader", fecObjHeader) + .add("nodeID: ", nodeID) + .toString(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepFecObjectIPv6AdjacencyVer1.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepFecObjectIPv6AdjacencyVer1.java new file mode 100644 index 00000000..f8ea7869 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepFecObjectIPv6AdjacencyVer1.java @@ -0,0 +1,249 @@ +/* + * 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 org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.pcepio.exceptions.PcepParseException; +import org.onosproject.pcepio.protocol.PcepFecObjectIPv6Adjacency; +import org.onosproject.pcepio.protocol.PcepVersion; +import org.onosproject.pcepio.types.PcepObjectHeader; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.google.common.base.MoreObjects; + +/** + * Provides Pcep Fec Object IPv6 Adjacency object. + */ +public class PcepFecObjectIPv6AdjacencyVer1 implements PcepFecObjectIPv6Adjacency { + + /* + * ref : draft-zhao-pce-pcep-extension-for-pce-controller-01 , section : 7.5 + * + 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 + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | | + // Local IPv6 address (16 bytes) // + | | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | | + // Remote IPv6 address (16 bytes) // + | | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + + FEC Object-Type is 4 IPv6 Adjacency + */ + protected static final Logger log = LoggerFactory.getLogger(PcepFecObjectIPv6AdjacencyVer1.class); + + public static final byte FEC_OBJ_TYPE = 4; + public static final byte FEC_OBJ_CLASS = 63; //to be defined + public static final byte FEC_OBJECT_VERSION = 1; + public static final short FEC_OBJ_MINIMUM_LENGTH = 36; + public static final int MINIMUM_COMMON_HEADER_LENGTH = 4; + public static final int IPV6_ADDRESS_LENGTH = 16; + + static final PcepObjectHeader DEFAULT_FEC_OBJECT_HEADER = new PcepObjectHeader(FEC_OBJ_CLASS, FEC_OBJ_TYPE, + PcepObjectHeader.REQ_OBJ_OPTIONAL_PROCESS, PcepObjectHeader.RSP_OBJ_PROCESSED, FEC_OBJ_MINIMUM_LENGTH); + + private PcepObjectHeader fecObjHeader; + private byte[] localIPv6Address = new byte[IPV6_ADDRESS_LENGTH]; + private byte[] remoteIPv6Address = new byte[IPV6_ADDRESS_LENGTH]; + + /** + * Constructor to initialize parameters for PCEP fec object. + * + * @param fecObjHeader fec object header + * @param localIPv6Address local IPv6 address + * @param remoteIPv6Address remote IPv6 address + */ + public PcepFecObjectIPv6AdjacencyVer1(PcepObjectHeader fecObjHeader, byte[] localIPv6Address, + byte[] remoteIPv6Address) { + this.fecObjHeader = fecObjHeader; + this.localIPv6Address = localIPv6Address; + this.remoteIPv6Address = remoteIPv6Address; + } + + /** + * Sets Object Header. + * + * @param obj object header + */ + public void setFecIpv4ObjHeader(PcepObjectHeader obj) { + this.fecObjHeader = obj; + } + + @Override + public byte[] getLocalIPv6Address() { + return this.localIPv6Address; + } + + @Override + public void seLocalIPv6Address(byte[] value) { + this.localIPv6Address = value; + } + + @Override + public byte[] getRemoteIPv6Address() { + return this.remoteIPv6Address; + } + + @Override + public void seRemoteIPv6Address(byte[] value) { + this.remoteIPv6Address = value; + } + + /** + * Reads channel buffer and Returns object of PcepFecObjectIPv6Adjacency. + * + * @param cb of channel buffer + * @return object of PcepFecObjectIPv6Adjacency + * @throws PcepParseException when fails tp read from channel buffer + */ + public static PcepFecObjectIPv6Adjacency read(ChannelBuffer cb) throws PcepParseException { + + PcepObjectHeader fecObjHeader; + byte[] localIPv6Address = new byte[IPV6_ADDRESS_LENGTH]; + byte[] remoteIPv6Address = new byte[IPV6_ADDRESS_LENGTH]; + fecObjHeader = PcepObjectHeader.read(cb); + cb.readBytes(localIPv6Address, 0, IPV6_ADDRESS_LENGTH); + cb.readBytes(remoteIPv6Address, 0, IPV6_ADDRESS_LENGTH); + return new PcepFecObjectIPv6AdjacencyVer1(fecObjHeader, localIPv6Address, remoteIPv6Address); + } + + @Override + public int write(ChannelBuffer cb) throws PcepParseException { + + int objStartIndex = cb.writerIndex(); + + //write common header + int objLenIndex = fecObjHeader.write(cb); + cb.writeBytes(localIPv6Address); + cb.writeBytes(remoteIPv6Address); + //now write FEC IPv6 Adjacency Object Length + cb.setShort(objLenIndex, (short) (cb.writerIndex() - objStartIndex)); + return cb.writerIndex(); + } + + /** + * Builder class for PCEP fec object IPv6 Adjacency. + */ + public static class Builder implements PcepFecObjectIPv6Adjacency.Builder { + private boolean bIsHeaderSet = false; + private boolean bIsLocalIPv6Addressset = false; + private boolean bIsRemoteIPv6Addressset = false; + + private PcepObjectHeader fecObjHeader; + byte[] localIPv6Address = new byte[IPV6_ADDRESS_LENGTH]; + byte[] remoteIPv6Address = new byte[IPV6_ADDRESS_LENGTH]; + + private boolean bIsPFlagSet = false; + private boolean bPFlag; + + private boolean bIsIFlagSet = false; + private boolean bIFlag; + + @Override + public PcepFecObjectIPv6Adjacency build() throws PcepParseException { + PcepObjectHeader fecObjHeader = this.bIsHeaderSet ? this.fecObjHeader : DEFAULT_FEC_OBJECT_HEADER; + + if (!this.bIsLocalIPv6Addressset) { + throw new PcepParseException( + "Local IPv6 Address not set while building PcepFecObjectIPv6Adjacency object."); + } + if (!this.bIsRemoteIPv6Addressset) { + throw new PcepParseException( + "Remote IPv6 Address not set while building PcepFecObjectIPv6Adjacency object."); + } + if (bIsPFlagSet) { + fecObjHeader.setPFlag(bPFlag); + } + if (bIsIFlagSet) { + fecObjHeader.setIFlag(bIFlag); + } + return new PcepFecObjectIPv6AdjacencyVer1(fecObjHeader, this.localIPv6Address, this.remoteIPv6Address); + } + + @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 PcepObjectHeader getFecIpv6AdjacencyObjHeader() { + return this.fecObjHeader; + } + + @Override + public Builder setFecIpv6AdjacencyObjHeader(PcepObjectHeader obj) { + this.fecObjHeader = obj; + this.bIsHeaderSet = true; + return this; + } + + @Override + public byte[] getLocalIPv6Address() { + return this.localIPv6Address; + } + + @Override + public Builder setLocalIPv6Address(byte[] value) { + this.localIPv6Address = value; + this.bIsLocalIPv6Addressset = true; + return this; + } + + @Override + public byte[] getRemoteIPv6Address() { + return this.remoteIPv6Address; + } + + @Override + public Builder setRemoteIPv6Address(byte[] value) { + this.remoteIPv6Address = value; + this.bIsRemoteIPv6Addressset = true; + return this; + } + } + + @Override + public PcepVersion getVersion() { + return PcepVersion.PCEP_1; + } + + @Override + public int getType() { + return FEC_OBJ_TYPE; + } + + @Override + public String toString() { + return MoreObjects.toStringHelper(getClass()) + .add("localIPv6Address", localIPv6Address) + .add("remoteIPv6Address: ", remoteIPv6Address) + .toString(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepFecObjectIPv6Ver1.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepFecObjectIPv6Ver1.java new file mode 100644 index 00000000..240a96f7 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepFecObjectIPv6Ver1.java @@ -0,0 +1,220 @@ +/* + * 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 org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.pcepio.exceptions.PcepParseException; +import org.onosproject.pcepio.protocol.PcepFecObjectIPv6; +import org.onosproject.pcepio.protocol.PcepVersion; +import org.onosproject.pcepio.types.PcepObjectHeader; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.google.common.base.MoreObjects; + +/** + * Provides Pcep Fec Object IPv6 object. + */ +public class PcepFecObjectIPv6Ver1 implements PcepFecObjectIPv6 { + + /* + * ref : draft-zhao-pce-pcep-extension-for-pce-controller-01 , section : 7.5 + * + 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 + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | | + // IPv6 Node ID (16 bytes) // + | | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + + FEC Object-Type is 2 IPv6 Node ID + */ + protected static final Logger log = LoggerFactory.getLogger(PcepFecObjectIPv6Ver1.class); + + public static final byte FEC_OBJ_TYPE = 2; + public static final byte FEC_OBJ_CLASS = 63; //to be defined + public static final byte FEC_OBJECT_VERSION = 1; + public static final short FEC_OBJ_MINIMUM_LENGTH = 20; + public static final int MINIMUM_COMMON_HEADER_LENGTH = 4; + public static final int IPV6_ADDRESS_LENGTH = 16; + + static final PcepObjectHeader DEFAULT_FEC_OBJECT_HEADER = new PcepObjectHeader(FEC_OBJ_CLASS, FEC_OBJ_TYPE, + PcepObjectHeader.REQ_OBJ_OPTIONAL_PROCESS, PcepObjectHeader.RSP_OBJ_PROCESSED, FEC_OBJ_MINIMUM_LENGTH); + + private PcepObjectHeader fecObjHeader; + private byte[] nodeID = new byte[IPV6_ADDRESS_LENGTH]; + + /** + * Constructor to initialize parameters for PCEP fec object. + * + * @param fecObjHeader Fec object header + * @param nodeID node ID + */ + public PcepFecObjectIPv6Ver1(PcepObjectHeader fecObjHeader, byte[] nodeID) { + this.fecObjHeader = fecObjHeader; + this.nodeID = nodeID; + } + + /** + * Sets the Object header. + * + * @param obj object header + */ + public void setFecIpv6ObjHeader(PcepObjectHeader obj) { + this.fecObjHeader = obj; + } + + @Override + public void setNodeID(byte[] nodeID) { + this.nodeID = nodeID; + } + + /** + * Returns object header. + * + * @return fec Object Header + */ + public PcepObjectHeader getFecIpv6ObjHeader() { + return this.fecObjHeader; + } + + @Override + public byte[] getNodeID() { + return this.nodeID; + } + + /** + * reads the channel buffer and returns object of PcepFecObjectIPv6. + * + * @param cb of channel buffer. + * @return object of PcepFecObjectIPv6 + * @throws PcepParseException when fails to read from channel buffer + */ + public static PcepFecObjectIPv6 read(ChannelBuffer cb) throws PcepParseException { + + PcepObjectHeader fecObjHeader; + byte[] nodeID = new byte[IPV6_ADDRESS_LENGTH]; + fecObjHeader = PcepObjectHeader.read(cb); + cb.readBytes(nodeID, 0, IPV6_ADDRESS_LENGTH); + return new PcepFecObjectIPv6Ver1(fecObjHeader, nodeID); + } + + @Override + public int write(ChannelBuffer cb) throws PcepParseException { + + int objStartIndex = cb.writerIndex(); + + //write common header + int objLenIndex = fecObjHeader.write(cb); + cb.writeBytes(nodeID); + + //now write FEC IPv4 Object Length + cb.setShort(objLenIndex, (short) (cb.writerIndex() - objStartIndex)); + return cb.writerIndex(); + } + + /** + * Builder class for PCEP fec object IPv6. + */ + public static class Builder implements PcepFecObjectIPv6.Builder { + private boolean bIsHeaderSet = false; + private boolean bIsNodeIdset = false; + + private PcepObjectHeader fecObjHeader; + private byte[] nodeID = new byte[IPV6_ADDRESS_LENGTH]; + + private boolean bIsPFlagSet = false; + private boolean bPFlag; + + private boolean bIsIFlagSet = false; + private boolean bIFlag; + + @Override + public PcepFecObjectIPv6 build() throws PcepParseException { + PcepObjectHeader fecObjHeader = this.bIsHeaderSet ? this.fecObjHeader : DEFAULT_FEC_OBJECT_HEADER; + + if (!this.bIsNodeIdset) { + throw new PcepParseException(" NodeID not set while building PcepFecObjectIPv6 object."); + } + if (bIsPFlagSet) { + fecObjHeader.setPFlag(bPFlag); + } + if (bIsIFlagSet) { + fecObjHeader.setIFlag(bIFlag); + } + return new PcepFecObjectIPv6Ver1(fecObjHeader, this.nodeID); + } + + @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 PcepObjectHeader getFecIpv6ObjHeader() { + return this.fecObjHeader; + } + + @Override + public Builder setFecIpv6ObjHeader(PcepObjectHeader obj) { + this.fecObjHeader = obj; + this.bIsHeaderSet = true; + return this; + } + + @Override + public byte[] getNodeID() { + return this.nodeID; + } + + @Override + public Builder setNodeID(byte[] value) { + this.nodeID = value; + this.bIsNodeIdset = true; + return this; + } + + } + + @Override + public PcepVersion getVersion() { + return PcepVersion.PCEP_1; + } + + @Override + public int getType() { + return FEC_OBJ_TYPE; + } + + @Override + public String toString() { + return MoreObjects.toStringHelper(getClass()) + .add("fecObjHeader", fecObjHeader) + .add("NodeID: ", nodeID) + .toString(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepInitiateMsgVer1.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepInitiateMsgVer1.java new file mode 100644 index 00000000..60d14b07 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepInitiateMsgVer1.java @@ -0,0 +1,332 @@ +/* + * 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.PcInitiatedLspRequest; +import org.onosproject.pcepio.protocol.PcepAttribute; +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.PcepMessageReader; +import org.onosproject.pcepio.protocol.PcepMessageWriter; +import org.onosproject.pcepio.protocol.PcepSrpObject; +import org.onosproject.pcepio.protocol.PcepType; +import org.onosproject.pcepio.protocol.PcepVersion; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.google.common.base.MoreObjects; + +/** + * Provides PCEP initiate message. + */ +class PcepInitiateMsgVer1 implements PcepInitiateMsg { + + protected static final Logger log = LoggerFactory.getLogger(PcepInitiateMsgVer1.class); + + // Ref : PCE initiated tunnel setup draft-ietf-pce-pce-initiated-lsp-03, section 5.1 + /* <PCInitiate Message> ::= <Common Header> + * <PCE-initiated-lsp-list> + * Where: + * <PCE-initiated-lsp-list> ::= <PCE-initiated-lsp-request>[<PCE-initiated-lsp-list>] + * <PCE-initiated-lsp-request> ::= (<PCE-initiated-lsp-instantiation>|<PCE-initiated-lsp-deletion>) + * <PCE-initiated-lsp-instantiation> ::= <SRP> + * <LSP> + * <END-POINTS> + * <ERO> + * [<attribute-list>] + * <PCE-initiated-lsp-deletion> ::= <SRP> + * <LSP> + */ + + static final byte PACKET_VERSION = 1; + /* considering LspDelete Request PcInitiate msg will contain + * common header + * srp object + * lsp object + * so min length for this can be + * PACKET_MINIMUM_LENGTH = CommonHeaderLen(4)+SrpObjectMinLen(12)+LspObjectMinLen(8) + */ + public static final short PACKET_MINIMUM_LENGTH = 24; + public static final short MINIMUM_COMMON_HEADER_LENGTH = 4; + public static final PcepType MSG_TYPE = PcepType.INITIATE; + private LinkedList<PcInitiatedLspRequest> llPcInitiatedLspRequestList; + public static final PcepInitiateMsgVer1.Reader READER = new Reader(); + + /** + * Reader class for reading of Pcep initiate message from channel buffer. + */ + static class Reader implements PcepMessageReader<PcepInitiateMsg> { + + LinkedList<PcInitiatedLspRequest> llPcInitiatedLspRequestList; + + @Override + public PcepInitiateMsg readFrom(ChannelBuffer cb) throws PcepParseException { + + if (cb.readableBytes() < PACKET_MINIMUM_LENGTH) { + return null; + } + + llPcInitiatedLspRequestList = new LinkedList<>(); + + byte version = cb.readByte(); + version = (byte) (version >> PcepMessageVer1.SHIFT_FLAG); + if (version != PACKET_VERSION) { + throw new PcepParseException("Wrong version. Expected=PcepVersion.PCEP_1(1), received=" + version); + } + byte type = cb.readByte(); + if (type != MSG_TYPE.getType()) { + throw new PcepParseException("Wrong type. Expected=PcepType.INITIATE(12), recived=" + type); + } + short length = cb.readShort(); + + if (length < PACKET_MINIMUM_LENGTH) { + throw new PcepParseException("Wrong length. Initiate message length expected to be >= " + + PACKET_MINIMUM_LENGTH + ", but received=" + length); + } + + log.debug("reading PcInitiate message of length " + length); + + // parse Start initiate/deletion list + if (!parsePcInitiatedLspRequestList(cb)) { + throw new PcepParseException("Parsing PCE-initiated-lsp-Request-list failed"); + } + + return new PcepInitiateMsgVer1(llPcInitiatedLspRequestList); + } + + /** + * To parse PcInitiatedLspRequestList from PcInitiate Message. + * + * @param cb of type channel buffer + * @return true if parsing PcInitiatedLspRequestList is success, false otherwise + * @throws PcepParseException while parsing from channel buffer + */ + public boolean parsePcInitiatedLspRequestList(ChannelBuffer cb) throws PcepParseException { + + boolean isDelLspRequest = false; + + if (cb == null) { + throw new PcepParseException("Channel buffer is empty"); + } + + while (0 < cb.readableBytes()) { + PcInitiatedLspRequest pceInitLspReq = new PcInitiatedLspRequestVer1(); + + //store SRP object + PcepSrpObject srpObj; + srpObj = PcepSrpObjectVer1.read(cb); + pceInitLspReq.setSrpObject(srpObj); + isDelLspRequest = srpObj.getRFlag(); + + //store LSP object + PcepLspObject lspObj; + lspObj = PcepLspObjectVer1.read(cb); + pceInitLspReq.setLspObject(lspObj); + + /* if R bit will be set then pcInitiate msg will contain only LSp and SRP objects + * so if R bit is not set then we should read for Ero and EndPoint objects also. + */ + if (!isDelLspRequest) { + + //store EndPoint object + PcepEndPointsObject endPointObj; + endPointObj = PcepEndPointsObjectVer1.read(cb); + pceInitLspReq.setEndPointsObject(endPointObj); + + //store ERO object + PcepEroObject eroObj; + eroObj = PcepEroObjectVer1.read(cb); + pceInitLspReq.setEroObject(eroObj); + + if (cb.readableBytes() > MINIMUM_COMMON_HEADER_LENGTH) { + pceInitLspReq.setPcepAttribute(PcepAttributeVer1.read(cb)); + } + } + llPcInitiatedLspRequestList.add(pceInitLspReq); + } + return true; + } + } + + /** + * Constructor to initialize PcInitiatedLspRequest. + * + * @param llPcInitiatedLspRequestList list of PcInitiatedLspRequest + */ + PcepInitiateMsgVer1(LinkedList<PcInitiatedLspRequest> llPcInitiatedLspRequestList) { + + if (llPcInitiatedLspRequestList == null) { + throw new NullPointerException("PcInitiatedLspRequestList cannot be null."); + } + this.llPcInitiatedLspRequestList = llPcInitiatedLspRequestList; + } + + /** + * Builder class for PCEP initiate message. + */ + static class Builder implements PcepInitiateMsg.Builder { + + // Pcep initiate message fields + LinkedList<PcInitiatedLspRequest> llPcInitiatedLspRequestList; + + @Override + public PcepVersion getVersion() { + return PcepVersion.PCEP_1; + } + + @Override + public PcepType getType() { + return PcepType.INITIATE; + } + + @Override + public PcepInitiateMsg build() { + return new PcepInitiateMsgVer1(this.llPcInitiatedLspRequestList); + } + + @Override + public LinkedList<PcInitiatedLspRequest> getPcInitiatedLspRequestList() { + return this.llPcInitiatedLspRequestList; + } + + @Override + public Builder setPcInitiatedLspRequestList(LinkedList<PcInitiatedLspRequest> ll) { + this.llPcInitiatedLspRequestList = ll; + return this; + } + } + + @Override + public void writeTo(ChannelBuffer cb) throws PcepParseException { + WRITER.write(cb, this); + } + + static final Writer WRITER = new Writer(); + + /** + * Writer class for writing pcep initiate message to channel buffer. + */ + static class Writer implements PcepMessageWriter<PcepInitiateMsgVer1> { + + @Override + public void write(ChannelBuffer cb, PcepInitiateMsgVer1 message) throws PcepParseException { + + boolean isDelLspRequest = false; + int startIndex = cb.writerIndex(); + // first 3 bits set to version + cb.writeByte((byte) (PACKET_VERSION << PcepMessageVer1.SHIFT_FLAG)); + // message type 0xC + cb.writeByte(MSG_TYPE.getType()); + // length is length of variable message, will be updated at the end + // Store the position of message + // length in buffer + int msgLenIndex = cb.writerIndex(); + cb.writeShort(0); + + ListIterator<PcInitiatedLspRequest> listIterator = message.llPcInitiatedLspRequestList.listIterator(); + + while (listIterator.hasNext()) { + + PcInitiatedLspRequest listReq = listIterator.next(); + + //Srp Object is mandatory + PcepSrpObject srpObj = listReq.getSrpObject(); + if (srpObj != null) { + isDelLspRequest = srpObj.getRFlag(); + srpObj.write(cb); + } else { + throw new PcepParseException("SRP Object is mandatory for PcInitiate message."); + } + + //LSP Object is mandatory + PcepLspObject lspObj = listReq.getLspObject(); + if (lspObj != null) { + lspObj.write(cb); + } else { + throw new PcepParseException("LSP Object is mandatory for PcInitiate message."); + } + + /* if R bit will be set then pcInitiate msg will contain only LSp and SRP objects + * so if R bit is not set then we should read for Ero and EndPoint objects also. + */ + + if (!isDelLspRequest) { + + //EndPoints object is mandatory + PcepEndPointsObject endPointObj = listReq.getEndPointsObject(); + if (endPointObj != null) { + endPointObj.write(cb); + } else { + throw new PcepParseException("End points Object is mandatory for PcInitiate message."); + } + + //Ero object is mandatory + PcepEroObject eroObj = listReq.getEroObject(); + if (eroObj != null) { + eroObj.write(cb); + } else { + throw new PcepParseException("ERO Object is mandatory for PcInitiate message."); + } + + //PcepAttribute is optional + PcepAttribute pcepAttribute = listReq.getPcepAttribute(); + if (pcepAttribute != null) { + pcepAttribute.write(cb); + } + } + } + + // PCInitiate message length field + int length = cb.writerIndex() - startIndex; + cb.setShort(msgLenIndex, (short) length); + } + } + + @Override + public PcepVersion getVersion() { + return PcepVersion.PCEP_1; + } + + @Override + public PcepType getType() { + return MSG_TYPE; + } + + @Override + public LinkedList<PcInitiatedLspRequest> getPcInitiatedLspRequestList() { + return this.llPcInitiatedLspRequestList; + } + + @Override + public void setPcInitiatedLspRequestList(LinkedList<PcInitiatedLspRequest> ll) { + this.llPcInitiatedLspRequestList = ll; + } + + @Override + public String toString() { + return MoreObjects.toStringHelper(getClass()) + .add("PcInitiaitedLspRequestList", llPcInitiatedLspRequestList) + .toString(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepInterLayerObjectVer1.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepInterLayerObjectVer1.java new file mode 100644 index 00000000..5130d9e9 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepInterLayerObjectVer1.java @@ -0,0 +1,263 @@ +/* + * 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 org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.pcepio.exceptions.PcepParseException; +import org.onosproject.pcepio.protocol.PcepInterLayerObject; +import org.onosproject.pcepio.types.PcepObjectHeader; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.google.common.base.MoreObjects; + +/** + * Provides PCEP inter layer object. + */ +public class PcepInterLayerObjectVer1 implements PcepInterLayerObject { + + /* + * 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 + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Reserved |N|I| + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + */ + protected static final Logger log = LoggerFactory.getLogger(PcepInterLayerObjectVer1.class); + + public static final byte INTER_LAYER_OBJ_TYPE = 1; + public static final byte INTER_LAYER_OBJ_CLASS = 18; + public static final byte INTER_LAYER_OBJECT_VERSION = 1; + public static final short INTER_LAYER_OBJ_MINIMUM_LENGTH = 8; + public static final boolean DEFAULT_IFLAG = false; + public static final boolean DEFAULT_NFLAG = false; + public static final int OBJECT_HEADER_LENGTH = 4; + public static final int NFLAG_SHIFT_VALUE = 0x02; + public static final int IFLAG_SHIFT_VALUE = 0x01; + + static final PcepObjectHeader DEFAULT_INTER_LAYER_OBJECT_HEADER = new PcepObjectHeader(INTER_LAYER_OBJ_CLASS, + INTER_LAYER_OBJ_TYPE, PcepObjectHeader.REQ_OBJ_OPTIONAL_PROCESS, PcepObjectHeader.RSP_OBJ_PROCESSED, + INTER_LAYER_OBJ_MINIMUM_LENGTH); + + private PcepObjectHeader interLayerObjHeader; + private boolean bNFlag; + private boolean bIFlag; + + /** + * Constructor to initialize all parameters for Pcep Inter Layer Object. + * + * @param interLayerObjHeader inter layer object header + * @param bNFlag N flag + * @param bIFlag I flag + */ + public PcepInterLayerObjectVer1(PcepObjectHeader interLayerObjHeader, boolean bNFlag, boolean bIFlag) { + + this.interLayerObjHeader = interLayerObjHeader; + this.bNFlag = bNFlag; + this.bIFlag = bIFlag; + } + + /** + * Sets Object Header. + * + * @param obj object header + */ + public void setInterLayerObjHeader(PcepObjectHeader obj) { + this.interLayerObjHeader = obj; + } + + @Override + public void setbNFlag(boolean bNFlag) { + this.bNFlag = bNFlag; + } + + @Override + public void setbIFlag(boolean bIFlag) { + this.bIFlag = bIFlag; + } + + /** + * Returns object header. + * + * @return inter Layer Object Header + */ + public PcepObjectHeader getInterLayerObjHeader() { + return this.interLayerObjHeader; + } + + @Override + public boolean getbNFlag() { + return this.bNFlag; + } + + @Override + public boolean getbIFlag() { + return this.bIFlag; + } + + /** + * Reads channel buffer and returns object of PcepInterLayerObject. + * + * @param cb of type channel buffer + * @return object of PcepInterLayerObject + * @throws PcepParseException when fails to read from channel buffer + */ + public static PcepInterLayerObject read(ChannelBuffer cb) throws PcepParseException { + + PcepObjectHeader interLayerObjHeader; + boolean bNFlag; + boolean bIFlag; + + interLayerObjHeader = PcepObjectHeader.read(cb); + + //take only InterLayerObject buffer. + ChannelBuffer tempCb = cb.readBytes(interLayerObjHeader.getObjLen() - OBJECT_HEADER_LENGTH); + + int iTemp = tempCb.readInt(); + bIFlag = ((iTemp & (byte) IFLAG_SHIFT_VALUE) == IFLAG_SHIFT_VALUE); + bNFlag = ((iTemp & (byte) NFLAG_SHIFT_VALUE) == NFLAG_SHIFT_VALUE); + + return new PcepInterLayerObjectVer1(interLayerObjHeader, bNFlag, bIFlag); + } + + @Override + public int write(ChannelBuffer cb) throws PcepParseException { + + //write Object header + int objStartIndex = cb.writerIndex(); + + int objLenIndex = interLayerObjHeader.write(cb); + + if (objLenIndex <= 0) { + throw new PcepParseException(" ObjectLength Index is " + objLenIndex); + } + + int iTemp = 0; + + if (bIFlag) { + iTemp = iTemp | (byte) IFLAG_SHIFT_VALUE; + } + if (bNFlag) { + iTemp = iTemp | (byte) NFLAG_SHIFT_VALUE; + } + + cb.writeInt(iTemp); + + //Update object length now + int length = cb.writerIndex() - objStartIndex; + //will be helpful during print(). + interLayerObjHeader.setObjLen((short) length); + cb.setShort(objLenIndex, (short) length); + + objLenIndex = cb.writerIndex(); + return objLenIndex; + } + + /** + * Builder class for PCEP inter layer object. + */ + public static class Builder implements PcepInterLayerObject.Builder { + + private boolean bIsHeaderSet = false; + private boolean bIsNFlagset = false; + private boolean bIsIFlagset = false; + + private PcepObjectHeader interLayerObjHeader; + private boolean bNFlag; + private boolean bIFlag; + + private boolean bIsPFlagSet = false; + private boolean bPFalg; + + private boolean bIsIFlagSet = false; + private boolean iFlag; + + @Override + public PcepInterLayerObject build() { + PcepObjectHeader interLayerObjHeader = this.bIsHeaderSet ? this.interLayerObjHeader + : DEFAULT_INTER_LAYER_OBJECT_HEADER; + + boolean bNFlag = this.bIsNFlagset ? this.bNFlag : DEFAULT_NFLAG; + boolean bIFlag = this.bIsIFlagset ? this.bIFlag : DEFAULT_IFLAG; + + if (bIsPFlagSet) { + interLayerObjHeader.setPFlag(bPFalg); + } + + if (bIsIFlagSet) { + interLayerObjHeader.setIFlag(iFlag); + } + return new PcepInterLayerObjectVer1(interLayerObjHeader, bNFlag, bIFlag); + } + + @Override + public PcepObjectHeader getInterLayerObjHeader() { + return this.interLayerObjHeader; + } + + @Override + public Builder setInterLayerObjHeader(PcepObjectHeader obj) { + this.interLayerObjHeader = obj; + this.bIsHeaderSet = true; + return this; + } + + @Override + public boolean getbNFlag() { + return this.bNFlag; + } + + @Override + public Builder setbNFlag(boolean value) { + this.bNFlag = value; + this.bIsNFlagset = true; + return this; + } + + @Override + public boolean getbIFlag() { + return this.bIFlag; + } + + @Override + public Builder setbIFlag(boolean value) { + this.bIFlag = value; + this.bIsIFlagset = true; + return this; + } + + @Override + public Builder setPFlag(boolean value) { + this.bPFalg = value; + this.bIsPFlagSet = true; + return this; + } + + @Override + public Builder setIFlag(boolean value) { + this.iFlag = value; + this.bIsIFlagSet = true; + return this; + } + } + + @Override + public String toString() { + return MoreObjects.toStringHelper(getClass()) + .add("IFlag", bIFlag) + .add("NFlag", bNFlag).toString(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepIroObjectVer1.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepIroObjectVer1.java new file mode 100644 index 00000000..2e01bdaa --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepIroObjectVer1.java @@ -0,0 +1,299 @@ +/* + * 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.PcepIroObject; +import org.onosproject.pcepio.types.IPv4SubObject; +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 iro object. + */ +public class PcepIroObjectVer1 implements PcepIroObject { + + /* + 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 + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | | + // (Sub-objects) // + | | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + + The IRO Object format + + Each IPV4 suboject + + 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 + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + |L| Type | Length | IPv4 address (4 bytes) | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | IPv4 address (continued) | Prefix Length | Resvd | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + */ + protected static final Logger log = LoggerFactory.getLogger(PcepIroObjectVer1.class); + + public static final byte IRO_OBJ_TYPE = 1; + public static final byte IRO_OBJ_CLASS = 10; + public static final byte IRO_OBJECT_VERSION = 1; + public static final short IRO_OBJ_MINIMUM_LENGTH = 12; + public static final int OBJECT_HEADER_LENGTH = 4; + public static final int YTYPE_SHIFT_VALUE = 0x7F; + + public static final PcepObjectHeader DEFAULT_IRO_OBJECT_HEADER = new PcepObjectHeader(IRO_OBJ_CLASS, IRO_OBJ_TYPE, + PcepObjectHeader.REQ_OBJ_OPTIONAL_PROCESS, PcepObjectHeader.RSP_OBJ_PROCESSED, IRO_OBJ_MINIMUM_LENGTH); + + private short iroObjType = 0; + private byte yLength; + private byte yPrefixLength; + private byte yResvd; + private PcepObjectHeader iroObjHeader; + private LinkedList<PcepValueType> llSubObjects = new LinkedList<>(); + + /** + * Default constructor. + */ + public PcepIroObjectVer1() { + this.iroObjHeader = null; + this.iroObjType = 0; + this.yLength = 0; + } + + /** + * Constructor to initialize member variables. + * + * @param iroObjHeader IRO object header + * @param llSubObjects list of sub-objects + */ + public PcepIroObjectVer1(PcepObjectHeader iroObjHeader, LinkedList<PcepValueType> llSubObjects) { + this.iroObjHeader = iroObjHeader; + this.llSubObjects = llSubObjects; + } + + /** + * Returns object header. + * + * @return iroObjHeader IRO object header + */ + public PcepObjectHeader getIroObjHeader() { + return this.iroObjHeader; + } + + /** + * Sets IRO Object Header. + * + * @param obj IRO object header + */ + public void setIroObjHeader(PcepObjectHeader obj) { + this.iroObjHeader = obj; + } + + @Override + public LinkedList<PcepValueType> getSubObjects() { + return this.llSubObjects; + } + + @Override + public void setSubObjects(LinkedList<PcepValueType> llSubObjects) { + this.llSubObjects = llSubObjects; + } + + /** + * Reads from channel buffer and return object of PcepIroObject. + * + * @param cb of type channel buffer + * @return object of PcepIroObject + * @throws PcepParseException while parsing from channel buffer + */ + public static PcepIroObject read(ChannelBuffer cb) throws PcepParseException { + + PcepObjectHeader iroObjHeader; + LinkedList<PcepValueType> llSubObjects; + + iroObjHeader = PcepObjectHeader.read(cb); + + //take only IroObject buffer. + ChannelBuffer tempCb = cb.readBytes(iroObjHeader.getObjLen() - OBJECT_HEADER_LENGTH); + llSubObjects = parseSubObjects(tempCb); + return new PcepIroObjectVer1(iroObjHeader, llSubObjects); + } + + /** + * Returns linked list of sub objects. + * + * @param cb of type channel buffer + * @return linked list of sub objects + * @throws PcepParseException while parsing subobjects from channel buffer + */ + protected static LinkedList<PcepValueType> parseSubObjects(ChannelBuffer cb) throws PcepParseException { + + LinkedList<PcepValueType> llSubObjects = new LinkedList<>(); + + while (0 < cb.readableBytes()) { + + //check the Type of the Subobjects. + byte yType = cb.readByte(); + yType = (byte) (yType & (YTYPE_SHIFT_VALUE)); + byte hLength = cb.readByte(); + + PcepValueType subObj; + switch (yType) { + + case IPv4SubObject.TYPE: + subObj = IPv4SubObject.read(cb); + break; + + default: + throw new PcepParseException("Invalid sub object. Type: " + (int) yType); + } + + // Check for the padding + int pad = hLength % 4; + if (0 < pad) { + pad = 4 - pad; + if (pad <= cb.readableBytes()) { + cb.skipBytes(pad); + } + } + llSubObjects.add(subObj); + } + return llSubObjects; + } + + @Override + public int write(ChannelBuffer cb) throws PcepParseException { + //write Object header + int objStartIndex = cb.writerIndex(); + + int objLenIndex = iroObjHeader.write(cb); + + if (objLenIndex <= 0) { + throw new PcepParseException(" ObjectLength is " + objLenIndex); + } + + ListIterator<PcepValueType> listIterator = llSubObjects.listIterator(); + while (listIterator.hasNext()) { + listIterator.next().write(cb); + } + + //Update object length now + int length = cb.writerIndex() - objStartIndex; + //will be helpful during print(). + iroObjHeader.setObjLen((short) length); + // As per RFC the length of object should be + // multiples of 4 + int pad = length % 4; + if (pad != 0) { + pad = 4 - pad; + for (int i = 0; i < pad; i++) { + cb.writeByte((byte) 0); + } + length = length + pad; + } + cb.setShort(objLenIndex, (short) length); + objLenIndex = cb.writerIndex(); + return objLenIndex; + } + + /** + * Builder class for PCEP iro object. + */ + public static class Builder implements PcepIroObject.Builder { + + private boolean bIsHeaderSet = false; + + private PcepObjectHeader iroObjHeader; + LinkedList<PcepValueType> llSubObjects = new LinkedList<>(); + + private boolean bIsPFlagSet = false; + private boolean bPFlag; + + private boolean bIsIFlagSet = false; + private boolean bIFlag; + + @Override + public PcepIroObject build() { + + PcepObjectHeader iroObjHeader = this.bIsHeaderSet ? this.iroObjHeader : DEFAULT_IRO_OBJECT_HEADER; + + if (bIsPFlagSet) { + iroObjHeader.setPFlag(bPFlag); + } + + if (bIsIFlagSet) { + iroObjHeader.setIFlag(bIFlag); + } + + return new PcepIroObjectVer1(iroObjHeader, this.llSubObjects); + } + + @Override + public PcepObjectHeader getIroObjHeader() { + return this.iroObjHeader; + } + + @Override + public Builder setIroObjHeader(PcepObjectHeader obj) { + this.iroObjHeader = obj; + this.bIsHeaderSet = true; + return this; + } + + @Override + public LinkedList<PcepValueType> getSubObjects() { + return this.llSubObjects; + } + + @Override + public Builder setSubObjects(LinkedList<PcepValueType> llSubObjects) { + this.llSubObjects = llSubObjects; + 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("IroObjectHeader", iroObjHeader) + .add("SubObjects", llSubObjects).toString(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepKeepaliveMsgVer1.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepKeepaliveMsgVer1.java new file mode 100644 index 00000000..8b6e9382 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepKeepaliveMsgVer1.java @@ -0,0 +1,154 @@ +/* + * 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 org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.pcepio.exceptions.PcepParseException; +import org.onosproject.pcepio.protocol.PcepKeepaliveMsg; +import org.onosproject.pcepio.protocol.PcepMessageReader; +import org.onosproject.pcepio.protocol.PcepMessageWriter; +import org.onosproject.pcepio.protocol.PcepType; +import org.onosproject.pcepio.protocol.PcepVersion; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.google.common.base.MoreObjects; + +/** + * Provides PCEP keep alive message. + */ +class PcepKeepaliveMsgVer1 implements PcepKeepaliveMsg { + + /* + <Keepalive Message>::= <Common Header> + + 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 + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Ver | Flags | Message-Type | Message-Length | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + */ + + protected static final Logger log = LoggerFactory.getLogger(PcepKeepaliveMsgVer1.class); + // Pcep version: 1 + public static final byte PACKET_VERSION = 1; + public static final int PACKET_MINIMUM_LENGTH = 4; + public static final PcepType MSG_TYPE = PcepType.KEEP_ALIVE; + + public static final PcepKeepaliveMsgVer1.Reader READER = new Reader(); + + /** + * Reader class for reading PCEP keepalive message from channel buffer. + */ + static class Reader implements PcepMessageReader<PcepKeepaliveMsg> { + + @Override + public PcepKeepaliveMsg readFrom(ChannelBuffer cb) throws PcepParseException { + + if (cb.readableBytes() < PACKET_MINIMUM_LENGTH) { + throw new PcepParseException("Packet size is less than the minimum required length."); + } + // fixed value property version == 1 + byte version = cb.readByte(); + version = (byte) (version >> PcepMessageVer1.SHIFT_FLAG); + if (version != PACKET_VERSION) { + throw new PcepParseException("Wrong version: Expected=PcepVersion.KEEP_ALIVE_1(2), got=" + version); + } + // fixed value property type == 2 + byte type = cb.readByte(); + if (type != MSG_TYPE.getType()) { + throw new PcepParseException("Wrong type: Expected=PcepType.KEEP_ALIVE_1(2), got=" + type); + } + short length = cb.readShort(); + if (length < PACKET_MINIMUM_LENGTH) { + throw new PcepParseException("Wrong length: Expected to be >= " + PACKET_MINIMUM_LENGTH + ", was: " + + length); + } + return new PcepKeepaliveMsgVer1(); + } + } + + /** + * Default constructor. + */ + PcepKeepaliveMsgVer1() { + } + + /** + * Builder class for PCEP keepalive message. + */ + static class Builder implements PcepKeepaliveMsg.Builder { + @Override + public PcepVersion getVersion() { + return PcepVersion.PCEP_1; + } + + @Override + public PcepType getType() { + return PcepType.KEEP_ALIVE; + } + + @Override + public PcepKeepaliveMsg build() { + return new PcepKeepaliveMsgVer1(); + } + } + + @Override + public void writeTo(ChannelBuffer cb) { + WRITER.write(cb, this); + } + + static final Writer WRITER = new Writer(); + + /** + * Writer class for writing the PCEP keepalive message to channel buffer. + */ + static class Writer implements PcepMessageWriter<PcepKeepaliveMsgVer1> { + + @Override + public void write(ChannelBuffer cb, PcepKeepaliveMsgVer1 message) { + int startIndex = cb.writerIndex(); + // first 3 bits set to version + cb.writeByte((byte) (PACKET_VERSION << PcepMessageVer1.SHIFT_FLAG)); + // message type + cb.writeByte(MSG_TYPE.getType()); + // length is length of variable message, will be updated at the end + // Store the position of message + // length in buffer + int msgLenIndex = cb.writerIndex(); + cb.writeShort((short) 0); + // update message length field + int length = cb.writerIndex() - startIndex; + cb.setShort(msgLenIndex, (short) length); + } + } + + @Override + public PcepVersion getVersion() { + return PcepVersion.PCEP_1; + } + + @Override + public PcepType getType() { + return MSG_TYPE; + } + + @Override + public String toString() { + return MoreObjects.toStringHelper(getClass()).toString(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepLabelObjectVer1.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepLabelObjectVer1.java new file mode 100644 index 00000000..a4ac87c3 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepLabelObjectVer1.java @@ -0,0 +1,370 @@ +/* + * 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.PcepLabelObject; +import org.onosproject.pcepio.types.NexthopIPv4addressTlv; +import org.onosproject.pcepio.types.NexthopIPv6addressTlv; +import org.onosproject.pcepio.types.NexthopUnnumberedIPv4IDTlv; +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 PcepLabelObjectVer1 implements PcepLabelObject { + + /* + * ref : draft-zhao-pce-pcep-extension-for-pce-controller-01 , section : 7.4. + + 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 + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Reserved | Flags |O| + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Label | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | | + // Optional TLV // + | | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + The LABEL Object format + */ + protected static final Logger log = LoggerFactory.getLogger(PcepLspObjectVer1.class); + + public static final byte LABEL_OBJ_TYPE = 1; + public static final byte LABEL_OBJ_CLASS = 35; //TBD : to be defined + public static final byte LABEL_OBJECT_VERSION = 1; + public static final byte OBJECT_HEADER_LENGTH = 4; + public static final boolean DEFAULT_OFLAG = false; + + // LSP_OBJ_MINIMUM_LENGTH = CommonHeaderLen(4)+ LspObjectHeaderLen(8) + public static final short LABEL_OBJ_MINIMUM_LENGTH = 12; + + public static final int OFLAG_SET = 1; + public static final int OFLAG_RESET = 0; + public static final int MINIMUM_COMMON_HEADER_LENGTH = 4; + + static final PcepObjectHeader DEFAULT_LABEL_OBJECT_HEADER = new PcepObjectHeader(LABEL_OBJ_CLASS, LABEL_OBJ_TYPE, + PcepObjectHeader.REQ_OBJ_OPTIONAL_PROCESS, PcepObjectHeader.RSP_OBJ_PROCESSED, LABEL_OBJ_MINIMUM_LENGTH); + + private PcepObjectHeader labelObjHeader; + private boolean bOFlag; + private int label; + // Optional TLV + private LinkedList<PcepValueType> llOptionalTlv; + + /** + * Constructor to initialize parameters for PCEP label object. + * + * @param labelObjHeader label object header + * @param bOFlag O flag + * @param label label + * @param llOptionalTlv list of optional tlvs + */ + public PcepLabelObjectVer1(PcepObjectHeader labelObjHeader, boolean bOFlag, int label, + LinkedList<PcepValueType> llOptionalTlv) { + this.labelObjHeader = labelObjHeader; + this.bOFlag = bOFlag; + this.label = label; + this.llOptionalTlv = llOptionalTlv; + } + + @Override + public LinkedList<PcepValueType> getOptionalTlv() { + return this.llOptionalTlv; + } + + @Override + public void setOptionalTlv(LinkedList<PcepValueType> llOptionalTlv) { + this.llOptionalTlv = llOptionalTlv; + } + + @Override + public boolean getOFlag() { + return this.bOFlag; + } + + @Override + public void setOFlag(boolean value) { + this.bOFlag = value; + } + + @Override + public int getLabel() { + return this.label; + } + + @Override + public void setLabel(int value) { + this.label = value; + } + + /** + * Reads form channel buffer and returns objects of PcepLabelObject. + * + * @param cb of type channel buffer + * @return objects of PcepLabelObject + * @throws PcepParseException when fails to read from channel buffer + */ + public static PcepLabelObject read(ChannelBuffer cb) throws PcepParseException { + + PcepObjectHeader labelObjHeader; + + boolean bOFlag; + int label; + + // Optional TLV + LinkedList<PcepValueType> llOptionalTlv = new LinkedList<>(); + labelObjHeader = PcepObjectHeader.read(cb); + + //take only LspObject buffer. + ChannelBuffer tempCb = cb.readBytes(labelObjHeader.getObjLen() - OBJECT_HEADER_LENGTH); + + int iTemp = tempCb.readInt(); + bOFlag = (iTemp & (byte) 0x01) == 1; + label = tempCb.readInt(); + + // parse optional TLV + llOptionalTlv = parseOptionalTlv(tempCb); + return new PcepLabelObjectVer1(labelObjHeader, bOFlag, label, llOptionalTlv); + } + + @Override + public int write(ChannelBuffer cb) throws PcepParseException { + + //write Object header + int objStartIndex = cb.writerIndex(); + int objLenIndex = labelObjHeader.write(cb); + + if (objLenIndex <= 0) { + throw new PcepParseException(" ObjectLength Index is " + objLenIndex); + } + + byte oFlag; + + oFlag = (byte) ((bOFlag) ? OFLAG_SET : OFLAG_RESET); + cb.writeInt(oFlag); + cb.writeInt(label); + + // Add optional TLV + packOptionalTlv(cb); + + //Update object length now + int length = cb.writerIndex() - objStartIndex; + + //will be helpful during print(). + labelObjHeader.setObjLen((short) length); + cb.setShort(objLenIndex, (short) length); + return cb.writerIndex(); + } + + /** + * Returns list of optional tlvs. + * + * @param cb of type channel buffer + * @return list of optional tlvs. + * @throws PcepParseException when fails to parse list of optional tlvs + */ + protected static LinkedList<PcepValueType> parseOptionalTlv(ChannelBuffer cb) throws PcepParseException { + + LinkedList<PcepValueType> llOutOptionalTlv = new LinkedList<>(); + + while (MINIMUM_COMMON_HEADER_LENGTH <= cb.readableBytes()) { + + PcepValueType tlv; + short hType = cb.readShort(); + short hLength = cb.readShort(); + int iValue = 0; + + switch (hType) { + + case NexthopIPv4addressTlv.TYPE: + iValue = cb.readInt(); + tlv = new NexthopIPv4addressTlv(iValue); + break; + case NexthopIPv6addressTlv.TYPE: + byte[] ipv6Value = new byte[NexthopIPv6addressTlv.VALUE_LENGTH]; + cb.readBytes(ipv6Value, 0, NexthopIPv6addressTlv.VALUE_LENGTH); + tlv = new NexthopIPv6addressTlv(ipv6Value); + break; + case NexthopUnnumberedIPv4IDTlv.TYPE: + tlv = NexthopUnnumberedIPv4IDTlv.read(cb); + break; + default: + throw new PcepParseException("Unsupported TLV type :" + hType); + } + + // Check for the padding + int pad = hLength % 4; + if (0 < pad) { + pad = 4 - pad; + if (pad <= cb.readableBytes()) { + cb.skipBytes(pad); + } + } + + llOutOptionalTlv.add(tlv); + } + + if (0 < cb.readableBytes()) { + + throw new PcepParseException("Optional Tlv parsing error. Extra bytes received."); + } + return llOutOptionalTlv; + } + + /** + * Returns the writer index. + * + * @param cb of channel buffer. + * @return writer index + */ + protected int packOptionalTlv(ChannelBuffer cb) { + + ListIterator<PcepValueType> listIterator = llOptionalTlv.listIterator(); + + while (listIterator.hasNext()) { + PcepValueType tlv = listIterator.next(); + + if (tlv == null) { + log.debug("tlv is null from OptionalTlv list"); + continue; + } + tlv.write(cb); + } + return cb.writerIndex(); + } + + /** + * Builder class for PCEP label object. + */ + public static class Builder implements PcepLabelObject.Builder { + + private boolean bIsHeaderSet = false; + private boolean bIsOFlagSet = false; + private boolean bIsLabelSet = false; + + private PcepObjectHeader labelObjHeader; + private boolean bOFlag; + private int label; + + LinkedList<PcepValueType> llOptionalTlv = new LinkedList<>(); + + private boolean bIsPFlagSet = false; + private boolean bPFlag; + + private boolean bIsIFlagSet = false; + private boolean bIFlag; + + @Override + public PcepLabelObject build() throws PcepParseException { + PcepObjectHeader labelObjHeader = this.bIsHeaderSet ? this.labelObjHeader : DEFAULT_LABEL_OBJECT_HEADER; + boolean bOFlag = this.bIsOFlagSet ? this.bOFlag : DEFAULT_OFLAG; + + if (!this.bIsLabelSet) { + throw new PcepParseException(" Label NOT Set while building PcepLabelObject."); + } + if (bIsPFlagSet) { + labelObjHeader.setPFlag(bPFlag); + } + if (bIsIFlagSet) { + labelObjHeader.setIFlag(bIFlag); + } + return new PcepLabelObjectVer1(labelObjHeader, bOFlag, this.label, this.llOptionalTlv); + } + + @Override + public PcepObjectHeader getLabelObjHeader() { + return this.labelObjHeader; + } + + @Override + public Builder setLabelObjHeader(PcepObjectHeader obj) { + this.labelObjHeader = obj; + this.bIsHeaderSet = true; + return this; + } + + @Override + public boolean getOFlag() { + return this.bOFlag; + } + + @Override + public Builder setOFlag(boolean value) { + this.bOFlag = value; + this.bIsOFlagSet = true; + return this; + } + + @Override + public int getLabel() { + return this.label; + } + + @Override + public Builder setLabel(int value) { + this.label = value; + this.bIsLabelSet = true; + return this; + } + + @Override + public LinkedList<PcepValueType> getOptionalTlv() { + return this.llOptionalTlv; + } + + @Override + public Builder setOptionalTlv(LinkedList<PcepValueType> 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("OFlag", bOFlag) + .add("label", label) + .add("OptionalTlvList", llOptionalTlv) + .toString(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepLabelRangeObjectVer1.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepLabelRangeObjectVer1.java new file mode 100644 index 00000000..9e4be911 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepLabelRangeObjectVer1.java @@ -0,0 +1,377 @@ +/* + * 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.PcepLabelRangeObject; +import org.onosproject.pcepio.types.PathSetupTypeTlv; +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 range object. + */ +public class PcepLabelRangeObjectVer1 implements PcepLabelRangeObject { + + /* + * ref : draft-zhao-pce-pcep-extension-for-pce-controller-01, section : 7.2 + 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 + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | label type | range size | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | label base | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | | + // Optional TLVs // + | | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + + LABEL-RANGE Object + */ + protected static final Logger log = LoggerFactory.getLogger(PcepLabelRangeObjectVer1.class); + + public static final byte LABEL_RANGE_OBJ_TYPE = 1; + public static final byte LABEL_RANGE_OBJ_CLASS = 60; //to be defined + public static final byte LABEL_RANGE_OBJECT_VERSION = 1; + public static final short LABEL_RANGE_OBJ_MINIMUM_LENGTH = 12; + public static final int MINIMUM_COMMON_HEADER_LENGTH = 4; + //P flag and I flag must be set to 0 + static final PcepObjectHeader DEFAULT_LABELRANGE_OBJECT_HEADER = new PcepObjectHeader(LABEL_RANGE_OBJ_CLASS, + LABEL_RANGE_OBJ_TYPE, PcepObjectHeader.REQ_OBJ_OPTIONAL_PROCESS, PcepObjectHeader.RSP_OBJ_PROCESSED, + LABEL_RANGE_OBJ_MINIMUM_LENGTH); + + private PcepObjectHeader labelRangeObjHeader; + private byte labelType; + private int rangeSize; + private int labelBase; + //Optional TLV + private LinkedList<PcepValueType> llOptionalTlv; + + /** + * Constructor to initialize parameters for PCEP label range object. + * + * @param labelRangeObjHeader label range object header + * @param labelType label type + * @param rangeSize range size + * @param labelBase label base + * @param llOptionalTlv list of optional tlvs + */ + public PcepLabelRangeObjectVer1(PcepObjectHeader labelRangeObjHeader, byte labelType, int rangeSize, int labelBase, + LinkedList<PcepValueType> llOptionalTlv) { + this.labelRangeObjHeader = labelRangeObjHeader; + this.labelType = labelType; + this.rangeSize = rangeSize; + this.llOptionalTlv = llOptionalTlv; + this.labelBase = labelBase; + } + + @Override + public void setLabelRangeObjHeader(PcepObjectHeader obj) { + this.labelRangeObjHeader = obj; + } + + @Override + public void setLabelType(byte labelType) { + this.labelType = labelType; + } + + @Override + public void setRangeSize(int rangeSize) { + this.rangeSize = rangeSize; + } + + @Override + public void setLabelBase(int labelBase) { + this.labelBase = labelBase; + } + + @Override + public PcepObjectHeader getLabelRangeObjHeader() { + return this.labelRangeObjHeader; + } + + @Override + public byte getLabelType() { + return this.labelType; + } + + @Override + public int getRangeSize() { + return this.rangeSize; + } + + @Override + public int getLabelBase() { + return this.labelBase; + } + + /** + * Reads from the channel buffer and returns object of PcepLabelRangeObject. + * + * @param cb of type channel buffer + * @return object of PcepLabelRangeObject + * @throws PcepParseException when fails to read from channel buffer + */ + public static PcepLabelRangeObject read(ChannelBuffer cb) throws PcepParseException { + + PcepObjectHeader labelRangeObjHeader; + byte labelType; + int rangeSize; + int labelBase; + + LinkedList<PcepValueType> llOptionalTlv = new LinkedList<>(); + + labelRangeObjHeader = PcepObjectHeader.read(cb); + + //take only LabelRangeObject buffer. + ChannelBuffer tempCb = cb.readBytes(labelRangeObjHeader.getObjLen() - MINIMUM_COMMON_HEADER_LENGTH); + int temp = 0; + temp = tempCb.readInt(); + rangeSize = temp & 0x00FFFFFF; + labelType = (byte) (temp >> 24); + labelBase = tempCb.readInt(); + llOptionalTlv = parseOptionalTlv(tempCb); + return new PcepLabelRangeObjectVer1(labelRangeObjHeader, labelType, rangeSize, labelBase, llOptionalTlv); + } + + @Override + public int write(ChannelBuffer cb) throws PcepParseException { + + int objStartIndex = cb.writerIndex(); + + //write common header + int objLenIndex = labelRangeObjHeader.write(cb); + int temp = 0; + temp = labelType; + temp = temp << 24; + temp = temp | rangeSize; + cb.writeInt(temp); + + // Add optional TLV + if (!packOptionalTlv(cb)) { + throw new PcepParseException("Error while writing Optional tlv."); + } + + //now write LabelRange Object Length + cb.setShort(objLenIndex, (short) (cb.writerIndex() - objStartIndex)); + return cb.writerIndex() - objStartIndex; + } + + /** + * Returns list of optional tlvs. + * + * @param cb of type channle buffer + * @return list of optional tlvs + * @throws PcepParseException whne fails to parse list of optional tlvs + */ + public static LinkedList<PcepValueType> parseOptionalTlv(ChannelBuffer cb) throws PcepParseException { + + LinkedList<PcepValueType> llOutOptionalTlv = new LinkedList<>(); + + while (MINIMUM_COMMON_HEADER_LENGTH <= cb.readableBytes()) { + + PcepValueType tlv; + int iValue; + short hType = cb.readShort(); + short hLength = cb.readShort(); + + switch (hType) { + + case PathSetupTypeTlv.TYPE: + iValue = cb.readInt(); + tlv = new PathSetupTypeTlv(iValue); + break; + + default: + throw new PcepParseException("Unsupported TLV in LabelRange Object."); + } + + // Check for the padding + int pad = hLength % 4; + if (0 < pad) { + pad = 4 - pad; + if (pad <= cb.readableBytes()) { + cb.skipBytes(pad); + } + } + llOutOptionalTlv.add(tlv); + } + return llOutOptionalTlv; + } + + /** + * Pack optional tlvs. + * + * @param cb of channel buffer + * @return true + */ + protected boolean packOptionalTlv(ChannelBuffer cb) { + + ListIterator<PcepValueType> listIterator = llOptionalTlv.listIterator(); + + while (listIterator.hasNext()) { + PcepValueType tlv = listIterator.next(); + + if (tlv == null) { + log.debug("tlv is null from OptionalTlv list"); + continue; + } + tlv.write(cb); + + // need to take care of padding + int pad = tlv.getLength() % 4; + if (0 != pad) { + pad = 4 - pad; + for (int i = 0; i < pad; ++i) { + cb.writeByte((byte) 0); + } + } + } + return true; + } + + /** + * Builder class for PCEP label range object. + */ + public static class Builder implements PcepLabelRangeObject.Builder { + private boolean bIsHeaderSet = false; + private boolean bIsLabelType = false; + private boolean bIsRangeSize = false; + private boolean bIsLabelBase = false; + + byte labelType; + int rangeSize; + int labelBase; + private boolean bIsPFlagSet = false; + private boolean bPFlag; + + private boolean bIsIFlagSet = false; + private boolean bIFlag; + private PcepObjectHeader labelRangeObjHeader; + + LinkedList<PcepValueType> llOptionalTlv = new LinkedList<>(); + + @Override + public PcepLabelRangeObject build() throws PcepParseException { + PcepObjectHeader labelRangeObjHeader = this.bIsHeaderSet ? this.labelRangeObjHeader + : DEFAULT_LABELRANGE_OBJECT_HEADER; + + if (!this.bIsLabelType) { + throw new PcepParseException("LabelType NOT Set while building label range object."); + } + + if (!this.bIsRangeSize) { + throw new PcepParseException("RangeSize NOT Set while building label range object."); + } + + if (!this.bIsLabelBase) { + throw new PcepParseException("LabelBase NOT Set while building label range object."); + } + + if (bIsPFlagSet) { + labelRangeObjHeader.setPFlag(bPFlag); + } + + if (bIsIFlagSet) { + labelRangeObjHeader.setIFlag(bIFlag); + } + return new PcepLabelRangeObjectVer1(labelRangeObjHeader, this.labelType, this.rangeSize, this.labelBase, + this.llOptionalTlv); + } + + @Override + public PcepObjectHeader getLabelRangeObjHeader() { + return this.labelRangeObjHeader; + } + + @Override + public Builder setLabelRangeObjHeader(PcepObjectHeader obj) { + this.labelRangeObjHeader = obj; + this.bIsHeaderSet = true; + return this; + } + + @Override + public byte getLabelType() { + return this.labelType; + } + + @Override + public Builder setLabelType(byte labelType) { + this.labelType = labelType; + this.bIsLabelType = true; + return this; + } + + @Override + public int getRangeSize() { + return this.rangeSize; + } + + @Override + public Builder setRangeSize(int rangeSize) { + this.rangeSize = rangeSize; + this.bIsRangeSize = true; + return this; + } + + @Override + public int getLabelBase() { + return this.labelBase; + } + + @Override + public Builder setLabelBase(int labelBase) { + this.labelBase = labelBase; + this.bIsLabelBase = true; + 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("LabelType", labelType) + .add("rangeSize", rangeSize) + .add("labelBase", labelBase) + .add("optionalTlvList", llOptionalTlv) + .toString(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepLabelRangeResvMsgVer1.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepLabelRangeResvMsgVer1.java new file mode 100644 index 00000000..6f3648af --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepLabelRangeResvMsgVer1.java @@ -0,0 +1,198 @@ +/* + * 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 org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.pcepio.exceptions.PcepParseException; +import org.onosproject.pcepio.protocol.PcepLabelRange; +import org.onosproject.pcepio.protocol.PcepLabelRangeResvMsg; +import org.onosproject.pcepio.protocol.PcepMessageReader; +import org.onosproject.pcepio.protocol.PcepMessageWriter; +import org.onosproject.pcepio.protocol.PcepType; +import org.onosproject.pcepio.protocol.PcepVersion; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.google.common.base.MoreObjects; + +/** + * Provides PCEP label range reserve message. + */ +class PcepLabelRangeResvMsgVer1 implements PcepLabelRangeResvMsg { + + // Pcep version: 1 + + /* + The format of a PCLRResv message is as follows: + + PCLRResv Message>::= <Common Header> + <label-range> + Where: + + <label-range> ::= <SRP> + <labelrange-list> + + Where + <labelrange-list>::=<LABEL-RANGE>[<labelrange-list>] + */ + protected static final Logger log = LoggerFactory.getLogger(PcepLabelRangeResvMsgVer1.class); + + public static final byte PACKET_VERSION = 1; + // LabelRangeResvMsgMinLength = COMMON-HEADER(4)+SrpObjMinLentgh(12)+LABEL-RANGE-MIN-LENGTH(12) + public static final int PACKET_MINIMUM_LENGTH = 28; + public static final PcepType MSG_TYPE = PcepType.LABEL_RANGE_RESERV; + //<label-range> + PcepLabelRange labelRange; + + public static final PcepLabelRangeResvMsgVer1.Reader READER = new Reader(); + + /** + * Reader reads LabelRangeResv Message from the channel. + */ + static class Reader implements PcepMessageReader<PcepLabelRangeResvMsg> { + + @Override + public PcepLabelRangeResvMsg readFrom(ChannelBuffer cb) throws PcepParseException { + + if (cb.readableBytes() < PACKET_MINIMUM_LENGTH) { + throw new PcepParseException("Channel buffer has less readable bytes than Packet minimum length."); + } + // fixed value property version == 1 + byte version = cb.readByte(); + version = (byte) (version >> PcepMessageVer1.SHIFT_FLAG); + if (version != PACKET_VERSION) { + throw new PcepParseException("Wrong version. Expected=PcepVersion.PCEP_1(1), got=" + version); + } + // fixed value property type == 15 + byte type = cb.readByte(); + if (type != MSG_TYPE.getType()) { + throw new PcepParseException("Wrong type. Expected=PcepType.LABEL_RANGE_RESERV(15), got=" + type); + } + short length = cb.readShort(); + if (length < PACKET_MINIMUM_LENGTH) { + throw new PcepParseException("Wrong length.Expected to be >= " + PACKET_MINIMUM_LENGTH + ", is: " + + length); + } + // parse <label-range> + PcepLabelRange labelRange = PcepLabelRangeVer1.read(cb); + return new PcepLabelRangeResvMsgVer1(labelRange); + } + } + + /** + * Constructor to initialize PCEP label range. + * + * @param labelRange PCEP label range + */ + PcepLabelRangeResvMsgVer1(PcepLabelRange labelRange) { + this.labelRange = labelRange; + } + + /** + * Builder class for PCEP label range reserve message. + */ + static class Builder implements PcepLabelRangeResvMsg.Builder { + + PcepLabelRange labelRange = new PcepLabelRangeVer1(); + + @Override + public PcepVersion getVersion() { + return PcepVersion.PCEP_1; + } + + @Override + public PcepType getType() { + return PcepType.LABEL_RANGE_RESERV; + } + + @Override + public PcepLabelRangeResvMsg build() { + return new PcepLabelRangeResvMsgVer1(this.labelRange); + } + + @Override + public PcepLabelRange getLabelRange() { + return this.labelRange; + } + + @Override + public Builder setLabelRange(PcepLabelRange labelRange) { + this.labelRange = labelRange; + return this; + } + } + + @Override + public void writeTo(ChannelBuffer cb) throws PcepParseException { + WRITER.write(cb, this); + } + + static final Writer WRITER = new Writer(); + + /** + * Writer writes LabelRangeResv Message to the channel. + */ + static class Writer implements PcepMessageWriter<PcepLabelRangeResvMsgVer1> { + + @Override + public void write(ChannelBuffer cb, PcepLabelRangeResvMsgVer1 message) throws PcepParseException { + + int startIndex = cb.writerIndex(); + // first 3 bits set to version + cb.writeByte((byte) (PACKET_VERSION << PcepMessageVer1.SHIFT_FLAG)); + // message type + cb.writeByte(MSG_TYPE.getType()); + // Length will be set after calculating length, but currently set it as 0. + int msgLenIndex = cb.writerIndex(); + + cb.writeShort((short) 0); + //write Label Range + message.labelRange.write(cb); + + // update message length field + int length = cb.writerIndex() - startIndex; + cb.setShort(msgLenIndex, (short) length); + } + } + + @Override + public PcepVersion getVersion() { + return PcepVersion.PCEP_1; + } + + @Override + public PcepType getType() { + return MSG_TYPE; + } + + @Override + public PcepLabelRange getLabelRange() { + return this.labelRange; + } + + @Override + public void setLabelRange(PcepLabelRange lr) { + this.labelRange = lr; + } + + @Override + public String toString() { + return MoreObjects.toStringHelper(getClass()) + .add("labelRange", labelRange) + .toString(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepLabelRangeVer1.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepLabelRangeVer1.java new file mode 100644 index 00000000..411c9604 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepLabelRangeVer1.java @@ -0,0 +1,168 @@ +/* + * 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.PcepLabelRange; +import org.onosproject.pcepio.protocol.PcepLabelRangeObject; +import org.onosproject.pcepio.protocol.PcepSrpObject; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.google.common.base.MoreObjects; + +/** + * Provides PCEP Label Range. + */ +public class PcepLabelRangeVer1 implements PcepLabelRange { + + protected static final Logger log = LoggerFactory.getLogger(PcepLabelRangeVer1.class); + + /* + <label-range> ::= <SRP> + <labelrange-list> + Where + <labelrange-list>::=<LABEL-RANGE>[<labelrange-list>] + */ + + // PCEP SRP Object + private PcepSrpObject srpObject; + //<labelrange-list> of type PcepLabelRangeObject. + private LinkedList<PcepLabelRangeObject> llLabelRangeList; + + /** + * Default Constructor. + */ + public PcepLabelRangeVer1() { + srpObject = null; + llLabelRangeList = null; + } + + /** + * Constructor to initialize objects. + * + * @param srpObj PCEP Srp object. + * @param llLabelRangeList list of PcepLabelRangeObject. + */ + PcepLabelRangeVer1(PcepSrpObject srpObj, LinkedList<PcepLabelRangeObject> llLabelRangeList) { + this.srpObject = srpObj; + this.llLabelRangeList = llLabelRangeList; + } + + @Override + public PcepSrpObject getSrpObject() { + return srpObject; + } + + @Override + public void setSrpObject(PcepSrpObject srpObject) { + this.srpObject = srpObject; + + } + + @Override + public LinkedList<PcepLabelRangeObject> getLabelRangeList() { + return llLabelRangeList; + } + + @Override + public void setLabelRangeList(LinkedList<PcepLabelRangeObject> ll) { + this.llLabelRangeList = ll; + } + + /** + * Reads channel buffer and returns object of PcepLabelRange. + * + * @param cb of type channel buffer. + * @return object of PcepLabelRange + * @throws PcepParseException when fails to read from channel buffer + */ + public static PcepLabelRange read(ChannelBuffer cb) throws PcepParseException { + + //parse and store SRP mandatory object + PcepSrpObject srpObj = null; + srpObj = PcepSrpObjectVer1.read(cb); + if (srpObj == null) { + throw new PcepParseException("Exception while parsing srp object"); + } + + LinkedList<PcepLabelRangeObject> llLabelRangeList = new LinkedList<>(); + boolean bFoundLabelRangeObj = false; + while (0 < cb.readableBytes()) { + //parse and store <labelrange-list> + PcepLabelRangeObject lrObj; + lrObj = PcepLabelRangeObjectVer1.read(cb); + if (lrObj == null) { + throw new PcepParseException("Exception while parsing label range object"); + } else { + llLabelRangeList.add(lrObj); + bFoundLabelRangeObj = true; + } + } + + if (!bFoundLabelRangeObj) { + throw new PcepParseException("At least one LABEL-RANGE MUST be present."); + } + return new PcepLabelRangeVer1(srpObj, llLabelRangeList); + } + + @Override + public int write(ChannelBuffer cb) throws PcepParseException { + //write Object header + int objStartIndex = cb.writerIndex(); + + //write <SRP> + int objLenIndex = srpObject.write(cb); + + if (objLenIndex <= 0) { + throw new PcepParseException("bjectLength is " + objLenIndex); + } + + //write <labelrange-list> + ListIterator<PcepLabelRangeObject> listIterator = llLabelRangeList.listIterator(); + while (listIterator.hasNext()) { + listIterator.next().write(cb); + } + + //Update object length now + int length = cb.writerIndex() - objStartIndex; + // As per RFC the length of object should be + // multiples of 4 + int pad = length % 4; + if (pad != 0) { + pad = 4 - pad; + for (int i = 0; i < pad; i++) { + cb.writeByte((byte) 0); + } + length = length + pad; + } + cb.setShort(objLenIndex, (short) length); + return length; + } + + @Override + public String toString() { + return MoreObjects.toStringHelper(getClass()) + .add("srpObject", srpObject) + .add("LabelRangeList", llLabelRangeList) + .toString(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepLabelUpdateMsgVer1.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepLabelUpdateMsgVer1.java new file mode 100644 index 00000000..89347f42 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepLabelUpdateMsgVer1.java @@ -0,0 +1,239 @@ +/* + * 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.PcepLabelUpdate; +import org.onosproject.pcepio.protocol.PcepLabelUpdateMsg; +import org.onosproject.pcepio.protocol.PcepMessageReader; +import org.onosproject.pcepio.protocol.PcepMessageWriter; +import org.onosproject.pcepio.protocol.PcepType; +import org.onosproject.pcepio.protocol.PcepVersion; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.google.common.base.MoreObjects; + +/** + * Provides PCEP lable update message. + */ +class PcepLabelUpdateMsgVer1 implements PcepLabelUpdateMsg { + + // Pcep version: 1 + + /* + The format of the PCLabelUpd message: + + <PCLabelUpd Message> ::= <Common Header> + <pce-label-update-list> + Where: + + <pce-label-update-list> ::= <pce-label-update> + [<pce-label-update-list>] + <pce-label-update> ::= (<pce-label-download>|<pce-label-map>) + + Where: + <pce-label-download> ::= <SRP> + <LSP> + <label-list> + + <pce-label-map> ::= <SRP> + <LABEL> + <FEC> + + <label-list > ::= <LABEL> + [<label-list>] + + */ + protected static final Logger log = LoggerFactory.getLogger(PcepLabelUpdateMsgVer1.class); + + public static final byte PACKET_VERSION = 1; + + //LabelUpdateMsgMinLength = COMMON-HEADER(4)+SrpObjMinLentgh(12)+LabelObjectMinLength(12)+FECType1Object(8) + public static final int PACKET_MINIMUM_LENGTH = 36; + public static final PcepType MSG_TYPE = PcepType.LABEL_UPDATE; + //pce-label-update-list + private LinkedList<PcepLabelUpdate> llPcLabelUpdateList; + + static final PcepLabelUpdateMsgVer1.Reader READER = new Reader(); + + /** + * Reader reads LabelUpdate Message from the channel. + */ + static class Reader implements PcepMessageReader<PcepLabelUpdateMsg> { + + @Override + public PcepLabelUpdateMsg readFrom(ChannelBuffer cb) throws PcepParseException { + + if (cb.readableBytes() < PACKET_MINIMUM_LENGTH) { + throw new PcepParseException("Readable bytes are less than Packet minimum length."); + } + + // fixed value property version == 1 + byte version = cb.readByte(); + version = (byte) (version >> PcepMessageVer1.SHIFT_FLAG); + if (version != PACKET_VERSION) { + throw new PcepParseException("Wrong version.Expected=PcepVersion.PCEP_1(1), got=" + version); + } + // fixed value property type == 13 + byte type = cb.readByte(); + if (type != MSG_TYPE.getType()) { + throw new PcepParseException("Wrong type. Expected=PcepType.LABEL_UPDATE(13), got=" + type); + } + short length = cb.readShort(); + if (length < PACKET_MINIMUM_LENGTH) { + throw new PcepParseException("Wrong length. Expected to be >= " + PACKET_MINIMUM_LENGTH + ", is: " + + length); + } + // parse <pce-label-download> / <pce-label-map> + LinkedList<PcepLabelUpdate> llPcLabelUpdateList = parsePcLabelUpdateList(cb); + return new PcepLabelUpdateMsgVer1(llPcLabelUpdateList); + } + + /** + * Returns list of PCEP Label Update object. + * + * @param cb of type channel buffer + * @return llPcLabelUpdateList list of PCEP label update object + * @throws PcepParseException when fails to parse list of PCEP label update object + */ + public LinkedList<PcepLabelUpdate> parsePcLabelUpdateList(ChannelBuffer cb) throws PcepParseException { + + LinkedList<PcepLabelUpdate> llPcLabelUpdateList; + llPcLabelUpdateList = new LinkedList<>(); + + while (0 < cb.readableBytes()) { + llPcLabelUpdateList.add(PcepLabelUpdateVer1.read(cb)); + } + return llPcLabelUpdateList; + } + } + + /** + * Constructor to initialize PCEP Label Update List. + * + * @param llPcLabelUpdateList list of PCEP Label Update object + */ + PcepLabelUpdateMsgVer1(LinkedList<PcepLabelUpdate> llPcLabelUpdateList) { + this.llPcLabelUpdateList = llPcLabelUpdateList; + } + + /** + * Builder class for PCEP label update message. + */ + static class Builder implements PcepLabelUpdateMsg.Builder { + + LinkedList<PcepLabelUpdate> llPcLabelUpdateList; + + @Override + public PcepVersion getVersion() { + return PcepVersion.PCEP_1; + } + + @Override + public PcepType getType() { + return PcepType.LABEL_UPDATE; + } + + @Override + public PcepLabelUpdateMsg build() { + return new PcepLabelUpdateMsgVer1(this.llPcLabelUpdateList); + } + + @Override + public LinkedList<PcepLabelUpdate> getPcLabelUpdateList() { + return this.llPcLabelUpdateList; + } + + @Override + public Builder setPcLabelUpdateList(LinkedList<PcepLabelUpdate> ll) { + this.llPcLabelUpdateList = ll; + return this; + } + } + + @Override + public void writeTo(ChannelBuffer cb) throws PcepParseException { + WRITER.write(cb, this); + } + + static final Writer WRITER = new Writer(); + + /** + * Writer writes LabelUpdate Message to the channel. + */ + static class Writer implements PcepMessageWriter<PcepLabelUpdateMsgVer1> { + + @Override + public void write(ChannelBuffer cb, PcepLabelUpdateMsgVer1 message) throws PcepParseException { + + int startIndex = cb.writerIndex(); + + // first 3 bits set to version + cb.writeByte((byte) (PACKET_VERSION << PcepMessageVer1.SHIFT_FLAG)); + + // message type + cb.writeByte(MSG_TYPE.getType()); + + // Length will be set after calculating length, but currently set it as 0. + int msgLenIndex = cb.writerIndex(); + + cb.writeShort((short) 0); + ListIterator<PcepLabelUpdate> listIterator = message.llPcLabelUpdateList.listIterator(); + + while (listIterator.hasNext()) { + PcepLabelUpdate labelUpdate = listIterator.next(); + labelUpdate.write(cb); + } + + // update message length field + int length = cb.writerIndex() - startIndex; + cb.setShort(msgLenIndex, (short) length); + } + } + + @Override + public PcepVersion getVersion() { + return PcepVersion.PCEP_1; + } + + @Override + public PcepType getType() { + return MSG_TYPE; + } + + @Override + public LinkedList<PcepLabelUpdate> getPcLabelUpdateList() { + return this.llPcLabelUpdateList; + } + + @Override + public void setPcLabelUpdateList(LinkedList<PcepLabelUpdate> ll) { + this.llPcLabelUpdateList = ll; + } + + @Override + public String toString() { + return MoreObjects.toStringHelper(getClass()) + .add("PcLabelUpdateList", llPcLabelUpdateList) + .toString(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepLabelUpdateVer1.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepLabelUpdateVer1.java new file mode 100644 index 00000000..a2293d35 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepLabelUpdateVer1.java @@ -0,0 +1,356 @@ +/* + * 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.PcepFecObject; +import org.onosproject.pcepio.protocol.PcepLabelObject; +import org.onosproject.pcepio.protocol.PcepLabelUpdate; +import org.onosproject.pcepio.protocol.PcepLspObject; +import org.onosproject.pcepio.protocol.PcepSrpObject; +import org.onosproject.pcepio.types.PcepLabelDownload; +import org.onosproject.pcepio.types.PcepLabelMap; +import org.onosproject.pcepio.types.PcepObjectHeader; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.google.common.base.MoreObjects; + +/** + * Provides PCEP LABEL update . + * Reference :draft-zhao-pce-pcep-extension-for-pce-controller-01. + */ +public class PcepLabelUpdateVer1 implements PcepLabelUpdate { + + /* + * <pce-label-update> ::= (<pce-label-download>|<pce-label-map>) + + Where: + <pce-label-download> ::= <SRP> + <LSP> + <label-list> + + <pce-label-map> ::= <SRP> + <LABEL> + <FEC> + + <label-list > ::= <LABEL> + [<label-list>] + */ + protected static final Logger log = LoggerFactory.getLogger(PcepLabelUpdateVer1.class); + + //Either PceLabelDownload or PceLabelMap is mandatory. + //label Download + private PcepLabelDownload labelDownload; + private boolean isLabelDownloadSet; + //label Map + private PcepLabelMap labelMap; + private boolean isLabelMapSet; + + /** + * Constructor to reset parameters. + */ + public PcepLabelUpdateVer1() { + this.labelDownload = null; + this.isLabelDownloadSet = false; + this.labelMap = null; + this.isLabelMapSet = false; + } + + /** + * Constructor to initialize PCEP label download. + * + * @param labelDownload PCEP label download + */ + public PcepLabelUpdateVer1(PcepLabelDownload labelDownload) { + this.labelDownload = labelDownload; + this.isLabelDownloadSet = true; + this.labelMap = null; + this.isLabelMapSet = false; + } + + /** + * Constructor to initialize PCEP label map. + * + * @param labelMap PCEP label map + */ + public PcepLabelUpdateVer1(PcepLabelMap labelMap) { + this.labelDownload = null; + this.isLabelDownloadSet = false; + this.labelMap = labelMap; + this.isLabelMapSet = true; + } + + /** + * builder class for PCEP label update. + */ + static class Builder implements PcepLabelUpdate.Builder { + + private PcepLabelDownload labelDownload; + private boolean isLabelDownloadSet; + private PcepLabelMap labelMap; + private boolean isLabelMapSet; + + @Override + public PcepLabelUpdate build() throws PcepParseException { + + if (isLabelDownloadSet) { + return new PcepLabelUpdateVer1(labelDownload); + } + if (isLabelMapSet) { + return new PcepLabelUpdateVer1(labelMap); + } + if (!isLabelDownloadSet && !isLabelMapSet) { + throw new PcepParseException( + "Label Download or Label Map is not set while building PcepLabelUpdate Message"); + } + return new PcepLabelUpdateVer1(); + } + + @Override + public Builder setLabelDownload(PcepLabelDownload labelDownload) { + this.labelDownload = labelDownload; + this.isLabelDownloadSet = true; + return this; + } + + @Override + public PcepLabelDownload getLabelDownload() { + return labelDownload; + } + + @Override + public Builder setLabelMap(PcepLabelMap labelMap) { + this.labelMap = labelMap; + this.isLabelMapSet = true; + return this; + } + + @Override + public PcepLabelMap getLabelMap() { + return labelMap; + } + } + + /** + * Reads PcepLabels from the byte stream received from channel buffer. + * + * @param cb of type channel buffer. + * @return PcepLabelUpdate object. + * @throws PcepParseException when fails to read from channel buffer + */ + public static PcepLabelUpdate read(ChannelBuffer cb) throws PcepParseException { + + PcepLabelUpdateVer1 pceLabelUpdate = new PcepLabelUpdateVer1(); + + PcepSrpObject srpObject; + PcepObjectHeader tempObjHeader; + + //read SRP mandatory Object + srpObject = PcepSrpObjectVer1.read(cb); + + //checking next object + cb.markReaderIndex(); + + tempObjHeader = PcepObjectHeader.read(cb); + cb.resetReaderIndex(); + + if (tempObjHeader.getObjClass() == PcepLspObjectVer1.LSP_OBJ_CLASS) { + + //now it is belong to <pce-label-download> + PcepLabelDownload labelDownload = new PcepLabelDownload(); + + //set SRP + labelDownload.setSrpObject(srpObject); + + //read and set LSP + labelDownload.setLspObject(PcepLspObjectVer1.read(cb)); + + //<label-list> + LinkedList<PcepLabelObject> llLabelList = new LinkedList<>(); + PcepLabelObject labelObject; + + while (0 < cb.readableBytes()) { + + cb.markReaderIndex(); + tempObjHeader = PcepObjectHeader.read(cb); + cb.resetReaderIndex(); + + if (tempObjHeader.getObjClass() != PcepLabelObjectVer1.LABEL_OBJ_CLASS) { + break; + } + labelObject = PcepLabelObjectVer1.read(cb); + llLabelList.add(labelObject); + } + labelDownload.setLabelList(llLabelList); + pceLabelUpdate.setLabelDownload(labelDownload); + } else if (tempObjHeader.getObjClass() == PcepLabelObjectVer1.LABEL_OBJ_CLASS) { + //belong to <pce-label-map> + PcepLabelMap labelMap = new PcepLabelMap(); + + //set SRP Object + labelMap.setSrpObject(srpObject); + + //read and set Label Object + labelMap.setLabelObject(PcepLabelObjectVer1.read(cb)); + + cb.markReaderIndex(); + tempObjHeader = PcepObjectHeader.read(cb); + cb.resetReaderIndex(); + + PcepFecObject fecObject = null; + switch (tempObjHeader.getObjType()) { + case PcepFecObjectIPv4Ver1.FEC_OBJ_TYPE: + fecObject = PcepFecObjectIPv4Ver1.read(cb); + break; + case PcepFecObjectIPv6Ver1.FEC_OBJ_TYPE: + fecObject = PcepFecObjectIPv6Ver1.read(cb); + break; + case PcepFecObjectIPv4AdjacencyVer1.FEC_OBJ_TYPE: + fecObject = PcepFecObjectIPv4AdjacencyVer1.read(cb); + break; + case PcepFecObjectIPv6AdjacencyVer1.FEC_OBJ_TYPE: + fecObject = PcepFecObjectIPv6AdjacencyVer1.read(cb); + break; + case PcepFecObjectIPv4UnnumberedAdjacencyVer1.FEC_OBJ_TYPE: + fecObject = PcepFecObjectIPv4UnnumberedAdjacencyVer1.read(cb); + break; + default: + throw new PcepParseException("Unkown FEC object type " + tempObjHeader.getObjType()); + } + labelMap.setFECObject(fecObject); + pceLabelUpdate.setLabelMap(labelMap); + } else { + throw new PcepParseException( + "Either <pce-label-download> or <pce-label-map> should be present. Received Class: " + + tempObjHeader.getObjClass()); + } + return pceLabelUpdate; + } + + @Override + public void write(ChannelBuffer cb) throws PcepParseException { + + if ((labelDownload != null) && (labelMap != null)) { + throw new PcepParseException("Label Download and Label Map both can't be present."); + } + + if ((labelDownload == null) && (labelMap == null)) { + throw new PcepParseException("Either Label Download or Label Map should be present."); + } + + if (labelDownload != null) { + + PcepLspObject lspObject; + PcepSrpObject srpObject; + PcepLabelObject labelObject; + LinkedList<PcepLabelObject> llLabelList; + + srpObject = labelDownload.getSrpObject(); + if (srpObject == null) { + throw new PcepParseException("SRP Object is mandatory object for Label Download."); + } else { + srpObject.write(cb); + } + + lspObject = labelDownload.getLspObject(); + if (lspObject == null) { + throw new PcepParseException("LSP Object is mandatory object for Label Download."); + } else { + lspObject.write(cb); + } + + llLabelList = labelDownload.getLabelList(); + if (llLabelList == null) { + throw new PcepParseException("Label list is mandatory object for Label Download."); + } else { + ListIterator<PcepLabelObject> listIterator = llLabelList.listIterator(); + while (listIterator.hasNext()) { + labelObject = listIterator.next(); + labelObject.write(cb); + } + } + } + + if (labelMap != null) { + + PcepSrpObject srpObject; + PcepLabelObject labelObject; + PcepFecObject fecObject; + + srpObject = labelMap.getSrpObject(); + if (srpObject == null) { + throw new PcepParseException("SRP Object is mandatory object for Label map."); + } else { + srpObject.write(cb); + } + labelObject = labelMap.getLabelObject(); + if (labelObject == null) { + throw new PcepParseException("label Object is mandatory object for Label map."); + } else { + labelObject.write(cb); + } + fecObject = labelMap.getFECObject(); + if (fecObject == null) { + throw new PcepParseException("fec Object is mandatory object for Label map."); + } else { + fecObject.write(cb); + } + } + } + + @Override + public void setLabelDownload(PcepLabelDownload labelDownload) { + if (this.isLabelMapSet) { + return; + } + this.labelDownload = labelDownload; + this.isLabelDownloadSet = true; + } + + @Override + public PcepLabelDownload getLabelDownload() { + return this.labelDownload; + } + + @Override + public void setLabelMap(PcepLabelMap labelMap) { + if (this.isLabelDownloadSet) { + return; + } + this.labelMap = labelMap; + this.isLabelMapSet = true; + } + + @Override + public PcepLabelMap getLabelMap() { + return this.labelMap; + } + + @Override + public String toString() { + return MoreObjects.toStringHelper(getClass()) + .omitNullValues() + .add("LabelDownload", labelDownload) + .add("LabelMap", labelMap) + .toString(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepLspObjectVer1.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepLspObjectVer1.java new file mode 100644 index 00000000..2b319c12 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepLspObjectVer1.java @@ -0,0 +1,575 @@ +/* + * 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.PcepLspObject; +import org.onosproject.pcepio.types.PcepErrorDetailInfo; +import org.onosproject.pcepio.types.PcepObjectHeader; +import org.onosproject.pcepio.types.PcepValueType; +import org.onosproject.pcepio.types.StatefulIPv4LspIdentidiersTlv; +import org.onosproject.pcepio.types.StatefulLspDbVerTlv; +import org.onosproject.pcepio.types.StatefulLspErrorCodeTlv; +import org.onosproject.pcepio.types.StatefulRsvpErrorSpecTlv; +import org.onosproject.pcepio.types.SymbolicPathNameTlv; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.google.common.base.MoreObjects; + +/** + * Provides PCEP lsp object. + */ +public class PcepLspObjectVer1 implements PcepLspObject { + + /* + message format. + Reference : draft-ietf-pce-stateful-pce-11, section 7.3. + 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 + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Object-Class | OT |Res|P|I| Object Length (bytes) | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | PLSP-ID | Flag | O|A|R|S|D| + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + // TLVs // + | | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + + The LSP Object format + */ + protected static final Logger log = LoggerFactory.getLogger(PcepLspObjectVer1.class); + + public static final byte LSP_OBJ_TYPE = 1; + public static final byte LSP_OBJ_CLASS = 32; + public static final byte LSP_OBJECT_VERSION = 1; + + // LSP_OBJ_MINIMUM_LENGTH = CommonHeaderLen(4)+ LspObjectHeaderLen(4)+TlvAssumedMinLength(8) + public static final short LSP_OBJ_MINIMUM_LENGTH = 16; + + public static final int DEFAULT_PLSPID = 0; + public static final byte DEFAULT_OFLAG = 1; + public static final boolean DEFAULT_AFLAG = false; + public static final boolean DEFAULT_RFLAG = false; + public static final boolean DEFAULT_SFLAG = false; + public static final boolean DEFAULT_DFLAG = false; + public static final int OBJECT_HEADER_LENGTH = 4; + public static final int PLSPID_SHIFT_VALUE = 12; + public static final int OFLAG_SHIFT_VALUE = 4; + public static final int AFLAG_SHIFT_VALUE = 3; + public static final int RFLAG_SHIFT_VALUE = 2; + public static final int SFLAG_SHIFT_VALUE = 1; + public static final int PLSPID_TEMP_SHIFT_VALUE = 0xFFFFF000; + public static final int OFLAG_TEMP_SHIFT_VALUE = 0x70; + public static final int AFLAG_TEMP_SHIFT_VALUE = 0x08; + public static final int RFLAG_TEMP_SHIFT_VALUE = 0x04; + public static final int SFLAG_TEMP_SHIFT_VALUE = 0x02; + public static final int DFLAG_TEMP_SHIFT_VALUE = 0x01; + public static final int BIT_SET = 1; + public static final int BIT_RESET = 0; + public static final int MINIMUM_COMMON_HEADER_LENGTH = 4; + + static final PcepObjectHeader DEFAULT_LSP_OBJECT_HEADER = new PcepObjectHeader(LSP_OBJ_CLASS, LSP_OBJ_TYPE, + PcepObjectHeader.REQ_OBJ_OPTIONAL_PROCESS, PcepObjectHeader.RSP_OBJ_PROCESSED, LSP_OBJ_MINIMUM_LENGTH); + + private PcepObjectHeader lspObjHeader; + private int iPlspId; + // 3-bits + private byte yOFlag; + private boolean bAFlag; + private boolean bRFlag; + private boolean bSFlag; + private boolean bDFlag; + + // Optional TLV + private LinkedList<PcepValueType> llOptionalTlv; + + /** + * Constructor to initialize all the member variables. + * + * @param lspObjHeader lsp object header + * @param iPlspId plsp id + * @param yOFlag O flag + * @param bAFlag A flag + * @param bRFlag R flag + * @param bSFlag S flag + * @param bDFlag D flag + * @param llOptionalTlv list of optional tlv + */ + public PcepLspObjectVer1(PcepObjectHeader lspObjHeader, int iPlspId, byte yOFlag, boolean bAFlag, boolean bRFlag, + boolean bSFlag, boolean bDFlag, LinkedList<PcepValueType> llOptionalTlv) { + + this.lspObjHeader = lspObjHeader; + this.iPlspId = iPlspId; + this.yOFlag = yOFlag; + this.bAFlag = bAFlag; + this.bRFlag = bRFlag; + this.bSFlag = bSFlag; + this.bDFlag = bDFlag; + this.llOptionalTlv = llOptionalTlv; + } + + /** + * Sets lsp Object Header. + * + * @param obj lsp object header + */ + public void setLspObjHeader(PcepObjectHeader obj) { + this.lspObjHeader = obj; + } + + @Override + public void setPlspId(int iPlspId) { + this.iPlspId = iPlspId; + } + + @Override + public void setOFlag(byte yOFlag) { + this.yOFlag = yOFlag; + } + + @Override + public void setAFlag(boolean bAFlag) { + this.bAFlag = bAFlag; + } + + @Override + public void setRFlag(boolean bRFlag) { + this.bRFlag = bRFlag; + } + + @Override + public void setSFlag(boolean bSFlag) { + this.bSFlag = bSFlag; + } + + @Override + public void setDFlag(boolean bDFlag) { + this.bDFlag = bDFlag; + } + + /** + * Returns lsp object header. + * + * @return lspObjHeader + */ + public PcepObjectHeader getLspObjHeader() { + return this.lspObjHeader; + } + + @Override + public int getPlspId() { + return this.iPlspId; + } + + @Override + public byte getOFlag() { + return this.yOFlag; + } + + @Override + public boolean getAFlag() { + return this.bAFlag; + } + + @Override + public boolean getRFlag() { + return this.bRFlag; + } + + @Override + public boolean getSFlag() { + return this.bSFlag; + } + + @Override + public boolean getDFlag() { + return this.bDFlag; + } + + @Override + public LinkedList<PcepValueType> getOptionalTlv() { + return this.llOptionalTlv; + } + + @Override + public void setOptionalTlv(LinkedList<PcepValueType> llOptionalTlv) { + this.llOptionalTlv = llOptionalTlv; + } + + /** + * Parse channel buffer and returns object of PcepLspObject. + * + * @param cb of type channel buffer + * @return object of PcepLspObject + * @throws PcepParseException when lsp object is not present in channel buffer + */ + public static PcepLspObject read(ChannelBuffer cb) throws PcepParseException { + + PcepObjectHeader lspObjHeader; + int iPlspId; + // 3-bits + byte yOFlag; + boolean bAFlag; + boolean bRFlag; + boolean bSFlag; + boolean bDFlag; + + // Optional TLV + LinkedList<PcepValueType> llOptionalTlv = new LinkedList<>(); + + lspObjHeader = PcepObjectHeader.read(cb); + + if (lspObjHeader.getObjClass() != PcepLspObjectVer1.LSP_OBJ_CLASS) { + throw new PcepParseException(PcepErrorDetailInfo.ERROR_TYPE_6, PcepErrorDetailInfo.ERROR_VALUE_8); + } + //take only LspObject buffer. + ChannelBuffer tempCb = cb.readBytes(lspObjHeader.getObjLen() - OBJECT_HEADER_LENGTH); + + Integer iTemp = tempCb.readInt(); + iPlspId = (iTemp & PLSPID_TEMP_SHIFT_VALUE) >> PLSPID_SHIFT_VALUE; + Integer iX = (iTemp & OFLAG_TEMP_SHIFT_VALUE) >> OFLAG_SHIFT_VALUE; + yOFlag = iX.byteValue(); + iX = (iTemp & AFLAG_TEMP_SHIFT_VALUE) >> AFLAG_SHIFT_VALUE; + bAFlag = iX > 0; + iX = (iTemp & RFLAG_TEMP_SHIFT_VALUE) >> RFLAG_SHIFT_VALUE; + bRFlag = iX > 0; + iX = (iTemp & SFLAG_TEMP_SHIFT_VALUE) >> SFLAG_SHIFT_VALUE; + bSFlag = iX > 0; + iX = iTemp & DFLAG_TEMP_SHIFT_VALUE; + bDFlag = iX > 0; + + // parse optional TLV + llOptionalTlv = parseOptionalTlv(tempCb); + + return new PcepLspObjectVer1(lspObjHeader, iPlspId, yOFlag, bAFlag, bRFlag, bSFlag, bDFlag, llOptionalTlv); + } + + @Override + public int write(ChannelBuffer cb) throws PcepParseException { + + //write Object header + int objStartIndex = cb.writerIndex(); + + int objLenIndex = lspObjHeader.write(cb); + + if (objLenIndex <= 0) { + throw new PcepParseException("Failed to write lsp object header. Index " + objLenIndex); + } + + int iTemp = iPlspId << PLSPID_SHIFT_VALUE; + iTemp = iTemp | (yOFlag << OFLAG_SHIFT_VALUE); + byte bFlag; + iTemp = bAFlag ? (iTemp | AFLAG_TEMP_SHIFT_VALUE) : iTemp; + + bFlag = (bRFlag) ? (byte) BIT_SET : BIT_RESET; + iTemp = iTemp | (bFlag << RFLAG_SHIFT_VALUE); + bFlag = (bSFlag) ? (byte) BIT_SET : BIT_RESET; + iTemp = iTemp | (bFlag << SFLAG_SHIFT_VALUE); + bFlag = (bDFlag) ? (byte) BIT_SET : BIT_RESET; + iTemp = iTemp | bFlag; + cb.writeInt(iTemp); + + // Add optional TLV + packOptionalTlv(cb); + + //Update object length now + int length = cb.writerIndex() - objStartIndex; + //will be helpful during print(). + lspObjHeader.setObjLen((short) length); + // As per RFC the length of object should be + // multiples of 4 + + cb.setShort(objLenIndex, (short) length); + + return length; + } + + /** + * Returns Linked list of optional tlvs. + * + * @param cb of channel buffer. + * @return list of optional tlvs + * @throws PcepParseException when unsupported tlv is received + */ + protected static LinkedList<PcepValueType> parseOptionalTlv(ChannelBuffer cb) throws PcepParseException { + + LinkedList<PcepValueType> llOutOptionalTlv; + + llOutOptionalTlv = new LinkedList<>(); + + while (MINIMUM_COMMON_HEADER_LENGTH <= cb.readableBytes()) { + + PcepValueType tlv; + short hType = cb.readShort(); + short hLength = cb.readShort(); + int iValue = 0; + + switch (hType) { + + case StatefulIPv4LspIdentidiersTlv.TYPE: + tlv = StatefulIPv4LspIdentidiersTlv.read(cb); + break; + case StatefulLspErrorCodeTlv.TYPE: + iValue = cb.readInt(); + tlv = new StatefulLspErrorCodeTlv(iValue); + break; + case StatefulRsvpErrorSpecTlv.TYPE: + tlv = StatefulRsvpErrorSpecTlv.read(cb); + break; + case SymbolicPathNameTlv.TYPE: + tlv = SymbolicPathNameTlv.read(cb, hLength); + break; + case StatefulLspDbVerTlv.TYPE: + tlv = StatefulLspDbVerTlv.read(cb); + break; + default: + throw new PcepParseException("Received unsupported TLV type :" + hType); + } + // Check for the padding + int pad = hLength % 4; + if (0 < pad) { + pad = 4 - pad; + if (pad <= cb.readableBytes()) { + cb.skipBytes(pad); + } + } + + llOutOptionalTlv.add(tlv); + } + + if (0 < cb.readableBytes()) { + + throw new PcepParseException("Optional Tlv parsing error. Extra bytes received."); + } + return llOutOptionalTlv; + } + + /** + * returns writer index. + * + * @param cb of type channel buffer + * @return length of bytes written to channel buffer + */ + protected int packOptionalTlv(ChannelBuffer cb) { + + ListIterator<PcepValueType> listIterator = llOptionalTlv.listIterator(); + int startIndex = cb.writerIndex(); + + while (listIterator.hasNext()) { + PcepValueType tlv = listIterator.next(); + + if (tlv == null) { + log.debug("tlv is null from OptionalTlv list"); + continue; + } + + tlv.write(cb); + + // need to take care of padding + int pad = tlv.getLength() % 4; + + if (0 != pad) { + pad = 4 - pad; + for (int i = 0; i < pad; ++i) { + cb.writeByte((byte) 0); + } + } + } + + return cb.writerIndex() - startIndex; + } + + /** + * Builder class for PCEP lsp Object. + */ + public static class Builder implements PcepLspObject.Builder { + + private boolean bIsHeaderSet = false; + private boolean bIsPlspIdSet = false; + private boolean bIsOFlagSet = false; + private boolean bIsRFlagSet = false; + private boolean bIsAFlagSet = false; + private boolean bIsDFlagSet = false; + private boolean bIsSFlagSet = false; + + private PcepObjectHeader lspObjHeader; + private byte yOFlag; + private boolean bAFlag; + private boolean bDFlag; + private boolean bSFlag; + private boolean bRFlag; + LinkedList<PcepValueType> llOptionalTlv = null; + + private int plspId; + + private boolean bIsPFlagSet = false; + private boolean bPFlag; + + private boolean bIsIFlagSet = false; + private boolean bIFlag; + + @Override + public PcepLspObject build() { + PcepObjectHeader lspObjHeader = this.bIsHeaderSet ? this.lspObjHeader : DEFAULT_LSP_OBJECT_HEADER; + + int plspId = this.bIsPlspIdSet ? this.plspId : DEFAULT_PLSPID; + byte yOFlag = this.bIsOFlagSet ? this.yOFlag : DEFAULT_OFLAG; + boolean bAFlag = this.bIsAFlagSet ? this.bAFlag : DEFAULT_AFLAG; + boolean bRFlag = this.bIsRFlagSet ? this.bRFlag : DEFAULT_RFLAG; + boolean bSFlag = this.bIsSFlagSet ? this.bSFlag : DEFAULT_SFLAG; + boolean bDFlag = this.bIsDFlagSet ? this.bDFlag : DEFAULT_DFLAG; + + if (bIsPFlagSet) { + lspObjHeader.setPFlag(bPFlag); + } + + if (bIsIFlagSet) { + lspObjHeader.setIFlag(bIFlag); + } + + return new PcepLspObjectVer1(lspObjHeader, plspId, yOFlag, bAFlag, bRFlag, bSFlag, bDFlag, llOptionalTlv); + } + + @Override + public PcepObjectHeader getLspObjHeader() { + return this.lspObjHeader; + } + + @Override + public Builder setLspObjHeader(PcepObjectHeader obj) { + this.lspObjHeader = obj; + this.bIsHeaderSet = true; + return this; + } + + @Override + public int getPlspId() { + return this.plspId; + } + + @Override + public Builder setPlspId(int value) { + this.plspId = value; + this.bIsPlspIdSet = true; + return this; + } + + @Override + public byte getOFlag() { + return this.yOFlag; + } + + @Override + public Builder setOFlag(byte value) { + this.yOFlag = value; + this.bIsOFlagSet = true; + return this; + } + + @Override + public boolean getAFlag() { + return this.bAFlag; + } + + @Override + public Builder setAFlag(boolean value) { + this.bAFlag = value; + this.bIsAFlagSet = true; + return this; + } + + @Override + public boolean getRFlag() { + return this.bRFlag; + } + + @Override + public Builder setRFlag(boolean value) { + this.bRFlag = value; + this.bIsRFlagSet = true; + return this; + } + + @Override + public boolean getSFlag() { + return this.bSFlag; + } + + @Override + public Builder setSFlag(boolean value) { + this.bSFlag = value; + this.bIsSFlagSet = true; + return this; + } + + @Override + public boolean getDFlag() { + return this.bDFlag; + } + + @Override + public Builder setDFlag(boolean value) { + this.bDFlag = value; + this.bIsDFlagSet = true; + return this; + } + + @Override + public Builder setOptionalTlv(LinkedList<PcepValueType> llOptionalTlv) { + this.llOptionalTlv = llOptionalTlv; + return this; + } + + @Override + public LinkedList<PcepValueType> getOptionalTlv() { + return this.llOptionalTlv; + } + + @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("PlspIDValue", iPlspId) + .add("OFlag", yOFlag) + .add("AFlag", bAFlag) + .add("RFlag", bRFlag) + .add("SFlag", bSFlag) + .add("DFlag", bDFlag) + .add("OptionalTlvList", llOptionalTlv) + .toString(); + } +} 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<PcepValueType> 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<PcepValueType> 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<PcepValueType> getOptionalTlv() { + return this.llOptionalTlv; + } + + @Override + public void setOptionalTlv(LinkedList<PcepValueType> 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<PcepValueType> 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<PcepValueType> parseOptionalTlv(ChannelBuffer cb) throws PcepParseException { + + LinkedList<PcepValueType> 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<PcepValueType> 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<PcepValueType> 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<PcepValueType> getOptionalTlv() { + return this.llOptionalTlv; + } + + @Override + public Builder setOptionalTlv(LinkedList<PcepValueType> 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(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepMessageVer1.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepMessageVer1.java new file mode 100644 index 00000000..2169a673 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepMessageVer1.java @@ -0,0 +1,132 @@ +/* + * 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 org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.pcepio.exceptions.PcepParseException; +import org.onosproject.pcepio.protocol.PcepFactories; +import org.onosproject.pcepio.protocol.PcepMessage; +import org.onosproject.pcepio.protocol.PcepMessageReader; +import org.onosproject.pcepio.types.PcepErrorDetailInfo; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +/** + * Provides PCEP messages. + */ +public abstract class PcepMessageVer1 { + + protected static final Logger log = LoggerFactory.getLogger(PcepFactories.class); + + // version: 1.0 + static final byte WIRE_VERSION = 1; + static final int MINIMUM_LENGTH = 4; + static final int PACKET_VERSION = 1; + static final byte OPEN_MSG_TYPE = 0x1; + static final byte KEEPALIVE_MSG_TYPE = 0x2; + static final byte REPORT_MSG_TYPE = 0xa; + static final byte TE_REPORT_MSG_TYPE = 0xe; + static final byte UPDATE_MSG_TYPE = 0xb; + static final byte INITIATE_MSG_TYPE = 0xc; + static final byte CLOSE_MSG_TYPE = 0x7; + static final byte ERROR_MSG_TYPE = 0x6; + static final byte LABEL_UPDATE_MSG_TYPE = 0xD; + static final byte LABEL_RANGE_RESV_MSG_TYPE = 0xF; + public static final int SHIFT_FLAG = 5; + static final int MINIMUM_COMMON_HEADER_LENGTH = 4; + + public static final PcepMessageVer1.Reader READER = new Reader(); + + /** + * Reader class for reading PCEP messages from channel buffer. + */ + static class Reader implements PcepMessageReader<PcepMessage> { + @Override + public PcepMessage readFrom(ChannelBuffer cb) throws PcepParseException { + + if (cb.readableBytes() < MINIMUM_LENGTH) { + throw new PcepParseException("Packet should have minimum length: " + MINIMUM_LENGTH); + } + + try { + int start = cb.readerIndex(); + // fixed value property version == 1 + byte version = cb.readByte(); + version = (byte) (version >> PcepMessageVer1.SHIFT_FLAG); + if (version != (byte) PACKET_VERSION) { + throw new PcepParseException("Wrong version. Expected=PcepVersion.Message_1(1), got=" + version); + } + + byte type = cb.readByte(); + short length = cb.readShort(); + cb.readerIndex(start); + + switch (type) { + + case OPEN_MSG_TYPE: + log.debug("OPEN MESSAGE is received"); + // message type value 1 means it is open message + return PcepOpenMsgVer1.READER.readFrom(cb.readBytes(length)); + case KEEPALIVE_MSG_TYPE: + log.debug("KEEPALIVE MESSAGE is received"); + // message type value 2 means it is Keepalive message + return PcepKeepaliveMsgVer1.READER.readFrom(cb.readBytes(length)); + case ERROR_MSG_TYPE: + log.debug("ERROR MESSAGE is received"); + // message type value 6 means it is error message + return PcepErrorMsgVer1.READER.readFrom(cb.readBytes(length)); + case REPORT_MSG_TYPE: + log.debug("REPORT MESSAGE is received"); + // message type value 10 means it is Report message + // return + return PcepReportMsgVer1.READER.readFrom(cb.readBytes(length)); + case UPDATE_MSG_TYPE: + log.debug("UPDATE MESSAGE is received"); + //message type value 11 means it is Update message + return PcepUpdateMsgVer1.READER.readFrom(cb.readBytes(length)); + case INITIATE_MSG_TYPE: + log.debug("INITIATE MESSAGE is received"); + //message type value 12 means it is PcInitiate message + return PcepInitiateMsgVer1.READER.readFrom(cb.readBytes(length)); + case CLOSE_MSG_TYPE: + log.debug("CLOSE MESSAGE is received"); + // message type value 7 means it is Close message + return PcepCloseMsgVer1.READER.readFrom(cb.readBytes(length)); + case TE_REPORT_MSG_TYPE: + log.debug("TE REPORT MESSAGE is received"); + // message type value 14 means it is TE REPORT message + // return + return PcepTEReportMsgVer1.READER.readFrom(cb.readBytes(length)); + case LABEL_UPDATE_MSG_TYPE: + log.debug("LABEL UPDATE MESSAGE is received"); + // message type value 13 means it is LABEL UPDATE message + // return + return PcepLabelUpdateMsgVer1.READER.readFrom(cb.readBytes(length)); + case LABEL_RANGE_RESV_MSG_TYPE: + log.debug("LABEL RANGE RESERVE MESSAGE is received"); + // message type value 15 means it is LABEL RANGE RESERVE message + // return + return PcepLabelRangeResvMsgVer1.READER.readFrom(cb.readBytes(length)); + default: + throw new PcepParseException("ERROR: UNKNOWN MESSAGE is received. Msg Type: " + type); + } + } catch (IndexOutOfBoundsException e) { + throw new PcepParseException(PcepErrorDetailInfo.ERROR_TYPE_1, PcepErrorDetailInfo.ERROR_VALUE_1); + } + } + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepMetricObjectVer1.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepMetricObjectVer1.java new file mode 100644 index 00000000..31c27870 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepMetricObjectVer1.java @@ -0,0 +1,376 @@ +/* + * 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 org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.pcepio.exceptions.PcepParseException; +import org.onosproject.pcepio.protocol.PcepMetricObject; +import org.onosproject.pcepio.types.PcepObjectHeader; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.google.common.base.MoreObjects; + +/** + * Provides PCEP metric object. + */ +public class PcepMetricObjectVer1 implements PcepMetricObject { + + /* + METRIC 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 + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Reserved | Flags |C|B| T | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | metric-value | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + */ + + protected static final Logger log = LoggerFactory.getLogger(PcepMetricObjectVer1.class); + + public static final byte METRIC_OBJ_TYPE = 1; + public static final byte METRIC_OBJ_CLASS = 6; + public static final byte METRIC_OBJECT_VERSION = 1; + public static final short METRIC_OBJ_MINIMUM_LENGTH = 12; + public static final int OBJECT_HEADER_LENGTH = 4; + public static final int IFLAG_SHIFT_VALUE = 9; + public static final int BTYPE_SHIFT_VALUE = 8; + public static final int CFLAG_SET = 1; + public static final int CFLAG_RESET = 0; + public static final int BFLAG_SET = 1; + public static final int BFLAG_RESET = 0; + public static final byte CFLAG_CHECK = 0x02; + + static final PcepObjectHeader DEFAULT_METRIC_OBJECT_HEADER = new PcepObjectHeader(METRIC_OBJ_CLASS, + METRIC_OBJ_TYPE, PcepObjectHeader.REQ_OBJ_OPTIONAL_PROCESS, PcepObjectHeader.RSP_OBJ_PROCESSED, + METRIC_OBJ_MINIMUM_LENGTH); + + private PcepObjectHeader metricObjHeader; + private int iMetricVal; + private byte yFlag; // 6-flags + private boolean bCFlag; + private boolean bBFlag; + private byte bType; + + /** + * Default constructor. + */ + public PcepMetricObjectVer1() { + this.metricObjHeader = null; + this.iMetricVal = 0; + this.yFlag = 0; + this.bCFlag = false; + this.bBFlag = false; + this.bType = 0; + + } + + /** + * Constructor to initialize all member variables. + * + * @param metricObjHeader metric object header + * @param iMetricVal metric value + * @param yFlag Y flag + * @param bCFlag C flag + * @param bBFlag B flag + * @param bType Type value + */ + public PcepMetricObjectVer1(PcepObjectHeader metricObjHeader, int iMetricVal, byte yFlag, boolean bCFlag, + boolean bBFlag, byte bType) { + + this.metricObjHeader = metricObjHeader; + this.iMetricVal = iMetricVal; + this.yFlag = yFlag; + this.bCFlag = bCFlag; + this.bBFlag = bBFlag; + this.bType = bType; + + } + + @Override + public void setMetricVal(int value) { + this.iMetricVal = value; + + } + + @Override + public int getMetricVal() { + return this.iMetricVal; + } + + @Override + public byte getYFlag() { + return this.yFlag; + } + + @Override + public void setYFlag(byte value) { + this.yFlag = value; + } + + @Override + public boolean getCFlag() { + return this.bCFlag; + } + + @Override + public void setCFlag(boolean value) { + this.bCFlag = value; + } + + @Override + public boolean getBFlag() { + return this.bBFlag; + } + + @Override + public void setBFlag(boolean value) { + this.bBFlag = value; + } + + @Override + public byte getBType() { + return this.bType; + } + + @Override + public void setBType(byte value) { + this.bType = value; + } + + /** + * Sets metric Object Header. + * + * @param obj metric object header + */ + public void setMetricObjHeader(PcepObjectHeader obj) { + this.metricObjHeader = obj; + } + + /** + * Returns metric Object Header. + * + * @return metricObjHeader + */ + public PcepObjectHeader getMetricObjHeader() { + return this.metricObjHeader; + } + + /** + * Reads from channel buffer and returns object of PcepMetricObject. + * + * @param cb of channel buffer. + * @return object of PcepMetricObject + * @throws PcepParseException when metric object is not present in channel buffer + */ + public static PcepMetricObject read(ChannelBuffer cb) throws PcepParseException { + + log.debug("MetricObject::read"); + PcepObjectHeader metricObjHeader; + int iMetricVal; + byte yFlag; // 6-flags + boolean bCFlag; + boolean bBFlag; + byte bType; + + metricObjHeader = PcepObjectHeader.read(cb); + + if (metricObjHeader.getObjClass() != METRIC_OBJ_CLASS) { + throw new PcepParseException("This object is not a Metric Object. Object Class: " + + metricObjHeader.getObjClass()); + } + + //take only metric buffer. + ChannelBuffer tempCb = cb.readBytes(metricObjHeader.getObjLen() - OBJECT_HEADER_LENGTH); + + tempCb.readShort(); + yFlag = tempCb.readByte(); + bType = tempCb.readByte(); + bCFlag = (yFlag & CFLAG_CHECK) == CFLAG_CHECK; + bBFlag = (yFlag & BFLAG_SET) == BFLAG_SET; + iMetricVal = tempCb.readInt(); + + return new PcepMetricObjectVer1(metricObjHeader, iMetricVal, yFlag, bCFlag, bBFlag, bType); + } + + @Override + public int write(ChannelBuffer cb) throws PcepParseException { + //write Object header + int objStartIndex = cb.writerIndex(); + + int objLenIndex = metricObjHeader.write(cb); + + if (objLenIndex <= 0) { + throw new PcepParseException("Error: ObjectLength is " + objLenIndex); + } + + int iFlag = (bCFlag) ? CFLAG_SET : CFLAG_RESET; + int iTemp = iFlag << IFLAG_SHIFT_VALUE; + iFlag = (bBFlag) ? BFLAG_SET : BFLAG_RESET; + iTemp = iTemp | (iFlag << BTYPE_SHIFT_VALUE); + iTemp = iTemp | bType; + cb.writeInt(iTemp); + cb.writeInt(iMetricVal); + + short hLength = (short) (cb.writerIndex() - objStartIndex); + cb.setShort(objLenIndex, hLength); + //will be helpful during print(). + metricObjHeader.setObjLen(hLength); + return hLength; + } + + /** + * Builder class for PCEP metric object. + */ + public static class Builder implements PcepMetricObject.Builder { + + private boolean bIsHeaderSet = false; + private PcepObjectHeader metricObjHeader; + private int iMetricVal; + private boolean bIsMetricValSet = false; + private byte yFlag; // 6-flags + private boolean bCFlag; + private boolean bBFlag; + private byte bType; + private boolean bIsbTypeSet = false; + + private boolean bIsPFlagSet = false; + private boolean bPFlag; + + private boolean bIsIFlagSet = false; + private boolean bIFlag; + + @Override + public PcepMetricObject build() throws PcepParseException { + + PcepObjectHeader metricObjHeader = this.bIsHeaderSet ? this.metricObjHeader : DEFAULT_METRIC_OBJECT_HEADER; + + if (!this.bIsMetricValSet) { + throw new PcepParseException(" Metric Value NOT Set while building PcepMetricObject."); + } + if (!this.bIsbTypeSet) { + throw new PcepParseException(" Type NOT Set while building PcepMetricObject."); + } + + if (bIsPFlagSet) { + metricObjHeader.setPFlag(bPFlag); + } + + if (bIsIFlagSet) { + metricObjHeader.setIFlag(bIFlag); + } + + return new PcepMetricObjectVer1(metricObjHeader, iMetricVal, yFlag, bCFlag, bBFlag, bType); + } + + @Override + public PcepObjectHeader getMetricObjHeader() { + return this.metricObjHeader; + } + + @Override + public Builder setMetricObjHeader(PcepObjectHeader obj) { + this.metricObjHeader = obj; + this.bIsHeaderSet = true; + return this; + } + + @Override + public int getMetricVal() { + return this.iMetricVal; + } + + @Override + public Builder setMetricVal(int value) { + this.iMetricVal = value; + this.bIsMetricValSet = true; + return this; + } + + @Override + public byte getYFlag() { + return this.yFlag; + } + + @Override + public Builder setYFlag(byte value) { + this.yFlag = value; + return this; + } + + @Override + public boolean getCFlag() { + return this.bCFlag; + } + + @Override + public Builder setCFlag(boolean value) { + this.bCFlag = value; + return this; + } + + @Override + public boolean getBFlag() { + return this.bBFlag; + } + + @Override + public Builder setBFlag(boolean value) { + this.bBFlag = value; + return this; + } + + @Override + public byte getBType() { + return this.bType; + } + + @Override + public Builder setBType(byte value) { + this.bType = value; + this.bIsbTypeSet = true; + 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("MetricValue", iMetricVal) + .add("BFlag", bBFlag) + .add("CFlag", bCFlag) + .add("BType", bType) + .toString(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepMsgPathVer1.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepMsgPathVer1.java new file mode 100644 index 00000000..49c738fc --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepMsgPathVer1.java @@ -0,0 +1,187 @@ +/* + * 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 org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.pcepio.exceptions.PcepParseException; +import org.onosproject.pcepio.protocol.PcepAttribute; +import org.onosproject.pcepio.protocol.PcepEroObject; +import org.onosproject.pcepio.protocol.PcepMsgPath; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.google.common.base.MoreObjects; + +/** + * Provides PCEP Message PAth for update message. + * Reference :PCE extensions for stateful draft-ietf-pce-stateful-pce-10. + */ +public class PcepMsgPathVer1 implements PcepMsgPath { + + /* + * <path> ::= <ERO><attribute-list> + */ + + protected static final Logger log = LoggerFactory.getLogger(PcepMsgPathVer1.class); + //PcepEroObject + private PcepEroObject eroObj; + private boolean isEroObjectSet; + // PcepAttribute + private PcepAttribute attrList; + private boolean isAttributeListSet; + + /** + * constructor to initialize objects. + */ + public PcepMsgPathVer1() { + eroObj = null; + attrList = null; + isEroObjectSet = false; + isAttributeListSet = false; + } + + @Override + public PcepEroObject getEroObject() { + return eroObj; + } + + @Override + public PcepAttribute getPcepAttribute() { + return attrList; + } + + @Override + public void setEroObject(PcepEroObject eroObj) { + this.eroObj = eroObj; + } + + @Override + public void setPcepAttribute(PcepAttribute attrList) { + this.attrList = attrList; + } + + /** + * constructor to initialize member variables. + * + * @param eroObj pcep ero object + * @param attrList pcep attribute + */ + public PcepMsgPathVer1(PcepEroObject eroObj, PcepAttribute attrList) { + this.eroObj = eroObj; + isEroObjectSet = true; + this.attrList = attrList; + if (attrList == null) { + isAttributeListSet = false; + } else { + isAttributeListSet = true; + } + } + + @Override + public PcepMsgPath read(ChannelBuffer cb) throws PcepParseException { + PcepEroObject eroObj; + PcepAttribute attrList; + + eroObj = PcepEroObjectVer1.read(cb); + attrList = PcepAttributeVer1.read(cb); + + return new PcepMsgPathVer1(eroObj, attrList); + } + + @Override + public int write(ChannelBuffer cb) throws PcepParseException { + int iLenStartIndex = cb.writerIndex(); + + //write Object header + if (this.isEroObjectSet) { + this.eroObj.write(cb); + } + if (this.isAttributeListSet) { + attrList.write(cb); + } + + return cb.writerIndex() - iLenStartIndex; + } + + /** + * Builder class for PCEP Message path. + */ + public static class Builder implements PcepMsgPath.Builder { + + private boolean bIsEROObjectSet = false; + private boolean bIsPcepAttributeSet = false; + + //PCEP ERO Object + private PcepEroObject eroObject; + //PCEP Attribute list + private PcepAttribute pcepAttribute; + + @Override + public PcepMsgPath build() throws PcepParseException { + + //PCEP ERO Object + PcepEroObject eroObject = null; + //PCEP Attribute list + PcepAttribute pcepAttribute = null; + + if (!this.bIsEROObjectSet) { + throw new PcepParseException("ERO Object NOT Set while building PcepMsgPath."); + } else { + eroObject = this.eroObject; + } + if (!this.bIsPcepAttributeSet) { + throw new PcepParseException("Pcep Attributes NOT Set while building PcepMsgPath."); + } else { + pcepAttribute = this.pcepAttribute; + } + + return new PcepMsgPathVer1(eroObject, pcepAttribute); + } + + @Override + public PcepEroObject getEroObject() { + return this.eroObject; + } + + @Override + public PcepAttribute getPcepAttribute() { + return this.pcepAttribute; + } + + @Override + public Builder setEroObject(PcepEroObject eroObject) { + this.eroObject = eroObject; + this.bIsEROObjectSet = true; + return this; + } + + @Override + public Builder setPcepAttribute(PcepAttribute pcepAttribute) { + this.pcepAttribute = pcepAttribute; + this.bIsPcepAttributeSet = true; + return this; + } + + } + + @Override + public String toString() { + return MoreObjects.toStringHelper(getClass()) + .add("EroObject", eroObj) + .add("AttributeList", attrList) + .toString(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepOpenMsgVer1.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepOpenMsgVer1.java new file mode 100644 index 00000000..902226e9 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepOpenMsgVer1.java @@ -0,0 +1,204 @@ +/* + * 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 org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.pcepio.exceptions.PcepParseException; +import org.onosproject.pcepio.protocol.PcepMessageReader; +import org.onosproject.pcepio.protocol.PcepMessageWriter; +import org.onosproject.pcepio.protocol.PcepOpenMsg; +import org.onosproject.pcepio.protocol.PcepOpenObject; +import org.onosproject.pcepio.protocol.PcepType; +import org.onosproject.pcepio.protocol.PcepVersion; +import org.onosproject.pcepio.types.PcepErrorDetailInfo; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.google.common.base.MoreObjects; + +/** + * Provides PCEP open message. + */ +public class PcepOpenMsgVer1 implements PcepOpenMsg { + + /* + * <Open Message>::= <Common Header> <OPEN> + 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 + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Ver | Flags | Message-Type | Message-Length | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Object-Class | OT |Res|P|I| Object Length (bytes) | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Ver | Flags | Keepalive | DeadTimer | SID | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | | + // Optional TLVs // + | | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + */ + + protected static final Logger log = LoggerFactory.getLogger(PcepOpenMsgVer1.class); + + public static final byte PACKET_VERSION = 1; + public static final int PACKET_MINIMUM_LENGTH = 12; + public static final PcepType MSG_TYPE = PcepType.OPEN; + private PcepOpenObject pcepOpenObj; + + public static final PcepOpenMsgVer1.Reader READER = new Reader(); + + /** + * Constructor to initialize PcepOpenObject. + * + * @param pcepOpenObj PCEP-OPEN-OBJECT + */ + public PcepOpenMsgVer1(PcepOpenObject pcepOpenObj) { + this.pcepOpenObj = pcepOpenObj; + } + + @Override + public PcepOpenObject getPcepOpenObject() { + return this.pcepOpenObj; + } + + @Override + public void setPcepOpenObject(PcepOpenObject pcepOpenObj) { + this.pcepOpenObj = pcepOpenObj; + } + + @Override + public PcepVersion getVersion() { + return PcepVersion.PCEP_1; + } + + @Override + public PcepType getType() { + return MSG_TYPE; + } + + /** + * Reader class for reading PCEP open message from channel buffer. + */ + public static class Reader implements PcepMessageReader<PcepOpenMsg> { + + @Override + public PcepOpenMsg readFrom(ChannelBuffer cb) throws PcepParseException { + + if (cb.readableBytes() < PACKET_MINIMUM_LENGTH) { + throw new PcepParseException("Packet size is less than the minimum length."); + } + + byte version = cb.readByte(); + version = (byte) (version >> PcepMessageVer1.SHIFT_FLAG); + if (version != PACKET_VERSION) { + log.error("[readFrom] Invalid version: " + version); + throw new PcepParseException(PcepErrorDetailInfo.ERROR_TYPE_1, PcepErrorDetailInfo.ERROR_VALUE_1); + } + // fixed value property type == 1 + byte type = cb.readByte(); + + if (type != MSG_TYPE.getType()) { + log.error("[readFrom] Unexpected type: " + type); + throw new PcepParseException(PcepErrorDetailInfo.ERROR_TYPE_1, PcepErrorDetailInfo.ERROR_VALUE_1); + } + int length = cb.readShort(); + if (length < PACKET_MINIMUM_LENGTH) { + throw new PcepParseException( + "Wrong length: Expected to be >= " + PACKET_MINIMUM_LENGTH + ", was: " + length); + } + return new PcepOpenMsgVer1(PcepOpenObjectVer1.read(cb)); + } + } + + /** + * Builder class for PCEP open message. + */ + static class Builder implements PcepOpenMsg.Builder { + + private PcepOpenObject pcepOpenObj; + + @Override + public PcepOpenMsg build() throws PcepParseException { + if (!(pcepOpenObj instanceof PcepOpenObjectVer1)) { + throw new NullPointerException("PcepOpenObject is null."); + } + return new PcepOpenMsgVer1(pcepOpenObj); + } + + @Override + public PcepVersion getVersion() { + return PcepVersion.PCEP_1; + } + + @Override + public PcepType getType() { + return PcepType.OPEN; + } + + @Override + public PcepOpenObject getPcepOpenObj() { + return this.pcepOpenObj; + } + + @Override + public Builder setPcepOpenObj(PcepOpenObject obj) { + this.pcepOpenObj = obj; + return this; + } + } + + @Override + public void writeTo(ChannelBuffer cb) throws PcepParseException { + WRITER.write(cb, this); + } + + public static final Writer WRITER = new Writer(); + + /** + * Writer class for writing PCEP opne message to channel buffer. + */ + public static class Writer implements PcepMessageWriter<PcepOpenMsgVer1> { + + @Override + public void write(ChannelBuffer cb, PcepOpenMsgVer1 message) throws PcepParseException { + int startIndex = cb.writerIndex(); + // first 3 bits set to version + cb.writeByte((byte) (PACKET_VERSION << PcepMessageVer1.SHIFT_FLAG)); + // message type + cb.writeByte(MSG_TYPE.getType()); + // length is length of variable message, will be updated at the end + // Store the position of message + // length in buffer + + int msgLenIndex = cb.writerIndex(); + cb.writeShort(0); + + message.getPcepOpenObject().write(cb); + + // update message length field + int iLength = cb.writerIndex() - startIndex; + cb.setShort(msgLenIndex, (short) iLength); + } + } + + @Override + public String toString() { + return MoreObjects.toStringHelper(getClass()) + .add("OpenObject", pcepOpenObj) + .toString(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepOpenObjectVer1.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepOpenObjectVer1.java new file mode 100644 index 00000000..d5e58694 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepOpenObjectVer1.java @@ -0,0 +1,491 @@ +/* + * 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.PcepOpenObject; +import org.onosproject.pcepio.protocol.PcepType; +import org.onosproject.pcepio.protocol.PcepVersion; +import org.onosproject.pcepio.types.GmplsCapabilityTlv; +import org.onosproject.pcepio.types.PceccCapabilityTlv; +import org.onosproject.pcepio.types.PcepLabelDbVerTlv; +import org.onosproject.pcepio.types.PcepObjectHeader; +import org.onosproject.pcepio.types.PcepValueType; +import org.onosproject.pcepio.types.StatefulLspDbVerTlv; +import org.onosproject.pcepio.types.StatefulPceCapabilityTlv; +import org.onosproject.pcepio.types.TedCapabilityTlv; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.google.common.base.MoreObjects; + +/** + * Provides PCEP open object. + */ +public class PcepOpenObjectVer1 implements PcepOpenObject { + + /* + message 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 + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Object-Class | OT |Res|P|I| Object Length (bytes) | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Ver | Flags | Keepalive | DeadTimer | SID | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | | + // Optional TLVs // + | | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + + The OPEN Object format + */ + protected static final Logger log = LoggerFactory.getLogger(PcepOpenObjectVer1.class); + + public static final PcepType MSG_TYPE = PcepType.OPEN; + public static final byte OPEN_OBJECT_VERSION = 1; + public static final byte OPEN_OBJ_TYPE = 1; + public static final byte OPEN_OBJ_CLASS = 1; + public static final byte DEFAULT_KEEPALIVE_TIME = 30; + public static final byte DEFAULT_DEAD_TIME = 120; + public static final short OPEN_OBJ_MINIMUM_LENGTH = 8; + public static final int DEFAULT_GMPLS_CAPABILITY_TLV_IVALUE = 0X0; + public static final int DEFAULT_STATEFUL_PCE_CAPABILITY_TLV_IVALUE = 0xf; + public static final int DEFAULT_PCECC_CAPABILITY_TLV_IVALUE = 0x7; + public static final int DEFAULT_PCEP_LABEL_DB_VER_TLV_IVALUE = 0X0; + + public static final PcepObjectHeader DEFAULT_OPEN_HEADER = new PcepObjectHeader(OPEN_OBJ_CLASS, OPEN_OBJ_TYPE, + PcepObjectHeader.REQ_OBJ_OPTIONAL_PROCESS, PcepObjectHeader.RSP_OBJ_PROCESSED, OPEN_OBJ_MINIMUM_LENGTH); + + private PcepObjectHeader openObjHeader; + private byte keepAliveTime; + private byte deadTime; + private byte sessionId; + private LinkedList<PcepValueType> llOptionalTlv; + + /** + * Default constructor. + */ + public PcepOpenObjectVer1() { + this.openObjHeader = null; + this.keepAliveTime = 0; + this.deadTime = 0; + this.sessionId = 0; + this.llOptionalTlv = null; + } + + /** + * Constructor to initialize all member variables. + * + * @param openObjHeader Open Object Header + * @param keepAliveTime Keepalive timer value + * @param deadTime Dead timer value + * @param sessionID session id + * @param llOptionalTlv Optional TLV + */ + public PcepOpenObjectVer1(PcepObjectHeader openObjHeader, byte keepAliveTime, byte deadTime, byte sessionID, + LinkedList<PcepValueType> llOptionalTlv) { + this.openObjHeader = openObjHeader; + this.keepAliveTime = keepAliveTime; + this.deadTime = deadTime; + this.sessionId = sessionID; + this.llOptionalTlv = llOptionalTlv; + } + + @Override + public PcepObjectHeader getOpenObjHeader() { + return this.openObjHeader; + } + + @Override + public void setOpenObjHeader(PcepObjectHeader obj) { + this.openObjHeader = obj; + } + + @Override + public byte getKeepAliveTime() { + return this.keepAliveTime; + } + + @Override + public void setKeepAliveTime(byte value) { + this.keepAliveTime = value; + } + + @Override + public PcepVersion getVersion() { + return PcepVersion.PCEP_1; + } + + @Override + public byte getDeadTime() { + return this.deadTime; + } + + @Override + public void setDeadTime(byte value) { + this.deadTime = value; + } + + @Override + public byte getSessionId() { + return this.sessionId; + } + + @Override + public void setSessionId(byte value) { + this.sessionId = value; + } + + @Override + public LinkedList<PcepValueType> getOptionalTlv() { + return this.llOptionalTlv; + } + + @Override + public void setOptionalTlv(LinkedList<PcepValueType> llOptionalTlv) { + this.llOptionalTlv = llOptionalTlv; + } + + /** + * Reads from channel buffer and returns object of PcepOpenObject. + * + * @param cb of type channel buffer + * @return object of PcepOpenObject + * @throws PcepParseException if mandatory fields are missing + */ + public static PcepOpenObject read(ChannelBuffer cb) throws PcepParseException { + + PcepObjectHeader openObjHeader; + byte version; + byte keepAliveTime; + byte deadTime; + byte sessionID; + LinkedList<PcepValueType> llOptionalTlv; + + openObjHeader = PcepObjectHeader.read(cb); + version = cb.readByte(); + version = (byte) (version >> PcepMessageVer1.SHIFT_FLAG); + if (version != OPEN_OBJECT_VERSION) { + throw new PcepParseException("Wrong version: Expected=PcepVersion.PCEP_1(1), got=" + version); + } + /* Keepalive */ + keepAliveTime = cb.readByte(); + + /* DeadTimer */ + deadTime = cb.readByte(); + + /* SID */ + sessionID = cb.readByte(); + + // Optional TLV + llOptionalTlv = parseOptionalTlv(cb); + + return new PcepOpenObjectVer1(openObjHeader, keepAliveTime, deadTime, sessionID, llOptionalTlv); + } + + /** + * Returns linkedlist of optional tlvs. + * + * @param cb of type channel buffer + * @return llOptionalTlv Optional TLV + * @throws PcepParseException if mandatory fields are missing + */ + protected static LinkedList<PcepValueType> parseOptionalTlv(ChannelBuffer cb) throws PcepParseException { + + LinkedList<PcepValueType> llOptionalTlv; + + llOptionalTlv = new LinkedList<>(); + + while (4 <= cb.readableBytes()) { + PcepValueType tlv; + short hType = cb.readShort(); + short hLength = cb.readShort(); + + switch (hType) { + case GmplsCapabilityTlv.TYPE: + log.debug("GmplsCapabilityTlv"); + if (GmplsCapabilityTlv.LENGTH != hLength) { + throw new PcepParseException("Invalid length received for Gmpls_Capability_Tlv."); + } + int iValue = cb.readInt(); + tlv = new GmplsCapabilityTlv(iValue); + break; + case StatefulPceCapabilityTlv.TYPE: + log.debug("StatefulPceCapabilityTlv"); + if (StatefulPceCapabilityTlv.LENGTH != hLength) { + throw new PcepParseException("Invalid length received for StatefulPceCapabilityTlv."); + } + tlv = StatefulPceCapabilityTlv.read(cb); + break; + case PceccCapabilityTlv.TYPE: + log.debug("PceccCapabilityTlv"); + if (PceccCapabilityTlv.LENGTH != hLength) { + throw new PcepParseException("Invalid length for PceccCapabilityTlv."); + } + iValue = cb.readInt(); + tlv = new PceccCapabilityTlv(iValue); + break; + case StatefulLspDbVerTlv.TYPE: + log.debug("StatefulLspDbVerTlv"); + if (StatefulLspDbVerTlv.LENGTH != hLength) { + throw new PcepParseException("Invalid length received for StatefulLspDbVerTlv."); + } + long lValue = cb.readLong(); + tlv = new StatefulLspDbVerTlv(lValue); + break; + case TedCapabilityTlv.TYPE: + log.debug("TedCapabilityTlv"); + if (TedCapabilityTlv.LENGTH != hLength) { + throw new PcepParseException("Invalid length received for TedCapabilityTlv."); + } + iValue = cb.readInt(); + tlv = new TedCapabilityTlv(iValue); + break; + case PcepLabelDbVerTlv.TYPE: + log.debug("PcepLabelDbVerTlv"); + if (PcepLabelDbVerTlv.LENGTH != hLength) { + throw new PcepParseException("Invalid length received for PcepLabelDbVerTlv."); + } + lValue = cb.readLong(); + tlv = new PcepLabelDbVerTlv(lValue); + break; + default: + log.debug("Unsupported TLV: " + hType); + cb.skipBytes(hLength); + continue; + } + + llOptionalTlv.add(tlv); + } + + if (0 < cb.readableBytes()) { + throw new PcepParseException("Optional Tlv parsing error. Extra bytes received."); + } + + return llOptionalTlv; + } + + @Override + public int write(ChannelBuffer cb) throws PcepParseException { + + int objStartIndex = cb.writerIndex(); + + //write common header + int objLenIndex = openObjHeader.write(cb); + + if (objLenIndex <= 0) { + throw new PcepParseException("Unable to write Open object header."); + } + + cb.writeByte((byte) (OPEN_OBJECT_VERSION << PcepMessageVer1.SHIFT_FLAG)); + cb.writeByte(this.keepAliveTime); + cb.writeByte(this.deadTime); + cb.writeByte(this.sessionId); + + //Pack optional TLV + packOptionalTlv(cb); + + //now write OPEN Object Length + int length = cb.writerIndex() - objStartIndex; + cb.setShort(objLenIndex, (short) length); + //will be helpful during print(). + this.openObjHeader.setObjLen((short) length); + + return length; + } + + /** + * Returns writer index. + * + * @param cb of type channel buffer. + * @return writer index + */ + protected int packOptionalTlv(ChannelBuffer cb) { + int startIndex = cb.writerIndex(); + + LinkedList<PcepValueType> llOptionalTlv = this.llOptionalTlv; + ListIterator<PcepValueType> listIterator = llOptionalTlv.listIterator(); + while (listIterator.hasNext()) { + PcepValueType tlv = listIterator.next(); + if (tlv == null) { + log.debug("TLV is null from OptionalTlv list"); + continue; + } + + tlv.write(cb); + + // need to take care of padding + int pad = tlv.getLength() % 4; + + if (0 != pad) { + pad = 4 - pad; + for (int i = 0; i < pad; ++i) { + cb.writeByte((byte) 0); + } + } + } + return cb.writerIndex() - startIndex; + } + + /** + * Builder class for PCPE open object. + */ + public static class Builder implements PcepOpenObject.Builder { + // Pcep open message fields + private boolean bIsHeaderSet = false; + private PcepObjectHeader openObjHeader; + private boolean bIsKeepAliveTimeSet = false; + private byte keepAliveTime; + private boolean bIsDeadTimeSet = false; + private byte deadTime; + private boolean bIsSessionIDSet = false; + private byte sessionID; + private boolean bIsOptionalTlvSet = false; + private LinkedList<PcepValueType> llOptionalTlv = new LinkedList<>(); + + private boolean bIsPFlagSet = false; + private boolean bPFlag; + + private boolean bIsIFlagSet = false; + private boolean bIFlag; + + @Override + public PcepOpenObject build() throws PcepParseException { + PcepObjectHeader openObjHeader = this.bIsHeaderSet ? this.openObjHeader : DEFAULT_OPEN_HEADER; + byte keepAliveTime = this.bIsKeepAliveTimeSet ? this.keepAliveTime : DEFAULT_KEEPALIVE_TIME; + byte deadTime = this.bIsDeadTimeSet ? this.deadTime : DEFAULT_DEAD_TIME; + + if (!this.bIsSessionIDSet) { + throw new PcepParseException("SessionID is not set (mandatory)"); + } + if (!this.bIsOptionalTlvSet) { + //Add tlv to list + //Add GmplsCapabilityTlv + PcepValueType tlv; + int iValue = DEFAULT_GMPLS_CAPABILITY_TLV_IVALUE; + tlv = new GmplsCapabilityTlv(iValue); + this.llOptionalTlv.add(tlv); + + //Add StatefulPceCapabilityTlv + iValue = DEFAULT_STATEFUL_PCE_CAPABILITY_TLV_IVALUE; + tlv = new StatefulPceCapabilityTlv(iValue); + this.llOptionalTlv.add(tlv); + + } + + if (bIsPFlagSet) { + openObjHeader.setPFlag(bPFlag); + } + + if (bIsIFlagSet) { + openObjHeader.setIFlag(bIFlag); + } + + return new PcepOpenObjectVer1(openObjHeader, keepAliveTime, deadTime, this.sessionID, this.llOptionalTlv); + } + + @Override + public PcepObjectHeader getOpenObjHeader() { + return this.openObjHeader; + } + + @Override + public Builder setOpenObjHeader(PcepObjectHeader obj) { + this.openObjHeader = obj; + this.bIsHeaderSet = true; + return this; + } + + @Override + public byte getKeepAliveTime() { + return this.keepAliveTime; + } + + @Override + public Builder setKeepAliveTime(byte value) { + this.keepAliveTime = value; + this.bIsKeepAliveTimeSet = true; + return this; + } + + @Override + public byte getDeadTime() { + return this.deadTime; + } + + @Override + public Builder setDeadTime(byte value) { + this.deadTime = value; + this.bIsDeadTimeSet = true; + return this; + } + + @Override + public byte getSessionId() { + return this.sessionID; + } + + @Override + public Builder setSessionId(byte value) { + this.sessionID = value; + this.bIsSessionIDSet = true; + return this; + } + + @Override + public Builder setOptionalTlv(LinkedList<PcepValueType> llOptionalTlv) { + this.llOptionalTlv = llOptionalTlv; + this.bIsOptionalTlvSet = true; + return this; + } + + @Override + public LinkedList<PcepValueType> getOptionalTlv() { + return this.llOptionalTlv; + } + + @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("ObjectHeader", openObjHeader) + .add("Keepalive", keepAliveTime) + .add("DeadTimer", deadTime) + .add("SessionId", sessionId) + .add("OptionalTlv", llOptionalTlv) + .toString(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepRPObjectVer1.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepRPObjectVer1.java new file mode 100644 index 00000000..7234a467 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepRPObjectVer1.java @@ -0,0 +1,445 @@ +/* + * 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.PcepRPObject; +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 RP object. + */ +public class PcepRPObjectVer1 implements PcepRPObject { + + /* + * RP Object. + 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 + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Flags |O|B|R| Pri | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Request-ID-number | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | | + // Optional TLVs // + | | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + */ + + protected static final Logger log = LoggerFactory.getLogger(PcepRPObjectVer1.class); + + public static final byte RP_OBJ_TYPE = 1; + public static final byte RP_OBJ_CLASS = 2; + public static final byte RP_OBJECT_VERSION = 1; + public static final short RP_OBJ_MINIMUM_LENGTH = 12; + + public static final int DEFAULT_REQUEST_ID_NUM = 0; + //Signalled , all default values to be checked. + public static final boolean DEFAULT_OFLAG = false; + public static final boolean DEFAULT_BFLAG = false; + public static final boolean DEFAULT_RFLAG = false; + public static final byte DEFAULT_PRIFLAG = 0; + public static final int OBJECT_HEADER_LENGTH = 4; + public static final int OFLAG_SHIFT_VALUE = 5; + public static final int BFLAG_SHIFT_VALUE = 4; + public static final int RFLAG_SHIFT_VALUE = 3; + public static final int OFLAG_TEMP_SHIFT_VALUE = 0x20; + public static final int BFLAG_TEMP_SHIFT_VALUE = 0x10; + public static final int RFLAG_TEMP_SHIFT_VALUE = 0x08; + public static final int PRIFLAG_TEMP_SHIFT_VALUE = 0x07; + public static final int BIT_SET = 1; + public static final int BIT_RESET = 0; + public static final int MINIMUM_COMMON_HEADER_LENGTH = 4; + + public static final PcepObjectHeader DEFAULT_RP_OBJECT_HEADER = new PcepObjectHeader(RP_OBJ_CLASS, RP_OBJ_TYPE, + PcepObjectHeader.REQ_OBJ_OPTIONAL_PROCESS, PcepObjectHeader.RSP_OBJ_PROCESSED, RP_OBJ_MINIMUM_LENGTH); + + private PcepObjectHeader rpObjHeader; + private int iRequestIdNum; + private boolean bOFlag; + private boolean bBFlag; + private boolean bRFlag; + private byte yPriFlag; // 3bytes + private LinkedList<PcepValueType> llOptionalTlv; + + /** + * Constructor to initialize variables. + * + * @param rpObjHeader RP-OBJECT header + * @param iRequestIdNum Request-ID-number + * @param bOFlag O-flag + * @param bBFlag B-flag + * @param bRFlag R-flag + * @param yPriFlag Pri-flag + * @param llOptionalTlv linked list of Optional TLV + */ + public PcepRPObjectVer1(PcepObjectHeader rpObjHeader, int iRequestIdNum, boolean bOFlag, boolean bBFlag, + boolean bRFlag, byte yPriFlag, LinkedList<PcepValueType> llOptionalTlv) { + this.rpObjHeader = rpObjHeader; + this.iRequestIdNum = iRequestIdNum; + this.bOFlag = bOFlag; + this.bBFlag = bBFlag; + this.bRFlag = bRFlag; + this.yPriFlag = yPriFlag; + this.llOptionalTlv = llOptionalTlv; + } + + /** + * Sets RP Object header. + * + * @param obj RP Object header + */ + public void setRPObjHeader(PcepObjectHeader obj) { + this.rpObjHeader = obj; + } + + @Override + public void setRequestIdNum(int iRequestIdNum) { + this.iRequestIdNum = iRequestIdNum; + } + + @Override + public void setOFlag(boolean bOFlag) { + this.bOFlag = bOFlag; + } + + @Override + public void setBFlag(boolean bBFlag) { + this.bBFlag = bBFlag; + } + + @Override + public void setRFlag(boolean bRFlag) { + this.bRFlag = bRFlag; + } + + @Override + public void setPriFlag(byte yPriFlag) { + this.yPriFlag = yPriFlag; + } + + /** + * Returns RP Object header. + * + * @return rpObjHeader + */ + public PcepObjectHeader getRPObjHeader() { + return this.rpObjHeader; + } + + @Override + public int getRequestIdNum() { + return this.iRequestIdNum; + } + + @Override + public boolean getOFlag() { + return this.bOFlag; + } + + @Override + public boolean getBFlag() { + return this.bBFlag; + } + + @Override + public boolean getRFlag() { + return this.bRFlag; + } + + @Override + public byte getPriFlag() { + return this.yPriFlag; + } + + /** + * Reads the channel buffer and returns the object of PcepRPObject. + * + * @param cb of type channel buffer + * @return the object of PcepRPObject + * @throws PcepParseException if mandatory fields are missing + */ + public static PcepRPObject read(ChannelBuffer cb) throws PcepParseException { + log.debug("read"); + PcepObjectHeader rpObjHeader; + int iRequestIdNum; + boolean bOFlag; + boolean bBFlag; + boolean bRFlag; + byte yPriFlag; // 3bytes + LinkedList<PcepValueType> llOptionalTlv = new LinkedList<>(); + + rpObjHeader = PcepObjectHeader.read(cb); + + //take only LspObject buffer. + ChannelBuffer tempCb = cb.readBytes(rpObjHeader.getObjLen() - OBJECT_HEADER_LENGTH); + + int iTemp = tempCb.readInt(); + yPriFlag = (byte) (iTemp & PRIFLAG_TEMP_SHIFT_VALUE); + bOFlag = (iTemp & OFLAG_TEMP_SHIFT_VALUE) == OFLAG_TEMP_SHIFT_VALUE; + bBFlag = (iTemp & BFLAG_TEMP_SHIFT_VALUE) == BFLAG_TEMP_SHIFT_VALUE; + bRFlag = (iTemp & RFLAG_TEMP_SHIFT_VALUE) == RFLAG_TEMP_SHIFT_VALUE; + + iRequestIdNum = tempCb.readInt(); + + // parse optional TLV + llOptionalTlv = parseOptionalTlv(tempCb); + + return new PcepRPObjectVer1(rpObjHeader, iRequestIdNum, bOFlag, bBFlag, bRFlag, yPriFlag, llOptionalTlv); + } + + @Override + public int write(ChannelBuffer cb) throws PcepParseException { + + //write Object header + int objStartIndex = cb.writerIndex(); + + int objLenIndex = rpObjHeader.write(cb); + + if (objLenIndex <= 0) { + throw new PcepParseException("ObjectLength Index is " + objLenIndex); + } + int iTemp; + iTemp = (yPriFlag); + + iTemp = (bOFlag) ? (iTemp | OFLAG_SHIFT_VALUE) : iTemp; + iTemp = (bBFlag) ? (iTemp | BFLAG_SHIFT_VALUE) : iTemp; + iTemp = (bRFlag) ? (iTemp | RFLAG_SHIFT_VALUE) : iTemp; + + cb.writeInt(iTemp); + cb.writeInt(iRequestIdNum); + + // Add optional TLV + packOptionalTlv(cb); + + //Update object length now + int length = cb.writerIndex() - objStartIndex; + + //will be helpful during print(). + rpObjHeader.setObjLen((short) length); + + cb.setShort(objLenIndex, (short) length); + return cb.writerIndex(); + } + + /** + * Returns list of optional tlvs. + * + * @param cb of type channel buffer. + * @return llOutOptionalTlv linked list of Optional TLV + * @throws PcepParseException if mandatory fields are missing + */ + protected static LinkedList<PcepValueType> parseOptionalTlv(ChannelBuffer cb) throws PcepParseException { + + LinkedList<PcepValueType> llOutOptionalTlv = new LinkedList<>(); + //Currently no optional TLvs, will be added based on requirements. + return llOutOptionalTlv; + } + + /** + * Returns optional tlvs. + * + * @param cb of type channel buffer + * @return llOptionalTlv linked list of Optional TLV + */ + protected int packOptionalTlv(ChannelBuffer cb) { + + ListIterator<PcepValueType> listIterator = llOptionalTlv.listIterator(); + while (listIterator.hasNext()) { + listIterator.next().write(cb); + } + + return cb.writerIndex(); + } + + /** + * Builder class for PCEP rp object. + */ + public static class Builder implements PcepRPObject.Builder { + + private boolean bIsHeaderSet = false; + private boolean bIsRequestIdNumSet = false; + private boolean bIsOFlagSet = false; + private boolean bIsRFlagset = false; + private boolean bIsBFlagSet = false; + private boolean bIsPriFlagSet = false; + + private PcepObjectHeader rpObjHeader; + private int requestIdNum; + private boolean bOFlag; + private boolean bBFlag; + private boolean bRFlag; + private byte yPriFlag; + private LinkedList<PcepValueType> llOptionalTlv = new LinkedList<>(); + + private boolean bIsPFlagSet = false; + private boolean bPFlag; + + private boolean bIsIFlagSet = false; + private boolean bIFlag; + + @Override + public PcepRPObject build() { + PcepObjectHeader lspObjHeader = this.bIsHeaderSet ? this.rpObjHeader : DEFAULT_RP_OBJECT_HEADER; + + int requestIdNum = this.bIsRequestIdNumSet ? this.requestIdNum : DEFAULT_REQUEST_ID_NUM; + boolean bOFlag = this.bIsOFlagSet ? this.bOFlag : DEFAULT_OFLAG; + boolean bBFlag = this.bIsBFlagSet ? this.bBFlag : DEFAULT_BFLAG; + boolean bRFlag = this.bIsRFlagset ? this.bRFlag : DEFAULT_RFLAG; + byte yPriFlag = this.bIsPriFlagSet ? this.yPriFlag : DEFAULT_PRIFLAG; + + if (bIsPFlagSet) { + lspObjHeader.setPFlag(bPFlag); + } + + if (bIsIFlagSet) { + lspObjHeader.setIFlag(bIFlag); + } + + return new PcepRPObjectVer1(lspObjHeader, requestIdNum, bOFlag, bBFlag, bRFlag, yPriFlag, llOptionalTlv); + } + + @Override + public PcepObjectHeader getRPObjHeader() { + return this.rpObjHeader; + } + + @Override + public Builder setRPObjHeader(PcepObjectHeader obj) { + this.rpObjHeader = obj; + this.bIsHeaderSet = true; + return this; + } + + @Override + public int getRequestIdNum() { + return this.requestIdNum; + } + + @Override + public Builder setRequestIdNum(int value) { + this.requestIdNum = value; + this.bIsRequestIdNumSet = true; + return this; + } + + @Override + public Builder setOFlag(boolean value) { + this.bOFlag = value; + this.bIsOFlagSet = true; + return this; + } + + @Override + public boolean getBFlag() { + return this.bBFlag; + } + + @Override + public Builder setBFlag(boolean value) { + this.bBFlag = value; + this.bIsBFlagSet = true; + return this; + } + + @Override + public boolean getRFlag() { + return this.bRFlag; + } + + @Override + public Builder setRFlag(boolean value) { + this.bRFlag = value; + this.bIsRFlagset = true; + return this; + } + + @Override + public byte getPriFlag() { + return this.yPriFlag; + } + + @Override + public Builder setPriFlag(byte value) { + this.yPriFlag = value; + this.bIsPriFlagSet = true; + return this; + } + + @Override + public Builder setOptionalTlv(LinkedList<PcepValueType> llOptionalTlv) { + this.llOptionalTlv = llOptionalTlv; + return this; + } + + @Override + public LinkedList<PcepValueType> getOptionalTlv() { + return this.llOptionalTlv; + } + + @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 boolean getOFlag() { + return this.bOFlag; + } + + } + + @Override + public LinkedList<PcepValueType> getOptionalTlv() { + return this.llOptionalTlv; + } + + @Override + public void setOptionalTlv(LinkedList<PcepValueType> llOptionalTlv) { + this.llOptionalTlv = llOptionalTlv; + } + + @Override + public String toString() { + return MoreObjects.toStringHelper(getClass()) + .add("ObjectHeader", rpObjHeader) + .add("OFlag", (bOFlag) ? 1 : 0) + .add("BFlag", (bBFlag) ? 1 : 0) + .add("RFlag", (bRFlag) ? 1 : 0) + .add("PriFlag", yPriFlag) + .add("RequestIdNumber", iRequestIdNum) + .add("OptionalTlv", llOptionalTlv) + .toString(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepReportMsgVer1.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepReportMsgVer1.java new file mode 100644 index 00000000..26e48dbd --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepReportMsgVer1.java @@ -0,0 +1,309 @@ +/* + * 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.PcepLspObject; +import org.onosproject.pcepio.protocol.PcepMessageReader; +import org.onosproject.pcepio.protocol.PcepMessageWriter; +import org.onosproject.pcepio.protocol.PcepReportMsg; +import org.onosproject.pcepio.protocol.PcepSrpObject; +import org.onosproject.pcepio.protocol.PcepStateReport; +import org.onosproject.pcepio.protocol.PcepType; +import org.onosproject.pcepio.protocol.PcepVersion; +import org.onosproject.pcepio.types.PcepObjectHeader; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.google.common.base.MoreObjects; + +/** + * Provides PCEP report message. + */ +class PcepReportMsgVer1 implements PcepReportMsg { + + // Pcep version: 1 + + /* + * The format of the PCRpt message is as follows: + * <PCRpt Message> ::= <Common Header> + * <state-report-list> + *Where: + * <state-report-list> ::= <state-report>[<state-report-list>] + * <state-report> ::= [<SRP>] + * <LSP> + * <path> + * Where: + * <path> ::= <ERO><attribute-list>[<RRO>] + * Where: + * <attribute-list> is defined in [RFC5440] and extended by PCEP extensions. + * where: + * <attribute-list> ::=[<LSPA>] + * [<BANDWIDTH>] + * [<metric-list>] + * [<IRO>] + * <metric-list> ::=<METRIC>[<metric-list>] + */ + protected static final Logger log = LoggerFactory.getLogger(PcepReportMsgVer1.class); + + public static final byte PACKET_VERSION = 1; + //PACKET_MINIMUM_LENGTH = CommonHeaderLen(4)+LspObjMinLen(8)+EroObjMinLen(12) + public static final int PACKET_MINIMUM_LENGTH = 24; + public static final PcepType MSG_TYPE = PcepType.REPORT; + public static final byte REPORT_OBJ_TYPE = 1; + //Optional TLV + private LinkedList<PcepStateReport> llStateReportList; + + public static final PcepReportMsgVer1.Reader READER = new Reader(); + + /** + * Reader class for reading PCEP report message from channel buffer. + */ + static class Reader implements PcepMessageReader<PcepReportMsg> { + + LinkedList<PcepStateReport> llStateReportList; + + @Override + public PcepReportMsg readFrom(ChannelBuffer cb) throws PcepParseException { + + if (cb.readableBytes() < PACKET_MINIMUM_LENGTH) { + throw new PcepParseException("Received packet size " + cb.readableBytes() + + " is less than the expected size: " + PACKET_MINIMUM_LENGTH); + } + llStateReportList = new LinkedList<>(); + byte version = cb.readByte(); + version = (byte) (version >> PcepMessageVer1.SHIFT_FLAG); + + if (version != PACKET_VERSION) { + throw new PcepParseException(" Invalid version: " + version); + } + + byte type = cb.readByte(); + + if (type != MSG_TYPE.getType()) { + throw new PcepParseException("Unexpected type: " + type); + } + + short length = cb.readShort(); + + if (length < PACKET_MINIMUM_LENGTH) { + throw new PcepParseException("Wrong length. Expected to be >= " + PACKET_MINIMUM_LENGTH + ", was: " + + length); + } + // parse state report list + parseStateReportList(cb); + return new PcepReportMsgVer1(llStateReportList); + } + + // Parse State Report list + public void parseStateReportList(ChannelBuffer cb) throws PcepParseException { + + /* + <state-report-list> + Where: + <state-report-list> ::= <state-report>[<state-report-list>] + <state-report> ::= [<SRP>] + <LSP> + <path> + Where: + <path> ::= <ERO><attribute-list>[<RRO>] + Where: + <attribute-list> is defined in [RFC5440] and extended by PCEP extensions. + + */ + + while (0 < cb.readableBytes()) { + + PcepStateReport pcestateReq = new PcepStateReportVer1(); + + /* + * SRP is optional + * Check whether SRP Object is available, if yes store it. + * First read common object header and check the Object Class whether it is SRP or LSP + * If it is LSP then store only LSP. So, SRP is optional. then read path and store. + * If it is SRP then store SRP and then read LSP, path and store them. + */ + + //mark the reader index to reset + cb.markReaderIndex(); + PcepObjectHeader tempObjHeader = PcepObjectHeader.read(cb); + + byte yObjectClass = tempObjHeader.getObjClass(); + byte yObjectType = tempObjHeader.getObjType(); + + //reset reader index + cb.resetReaderIndex(); + //If SRP present then store it. + if ((PcepSrpObjectVer1.SRP_OBJ_CLASS == yObjectClass) + && (PcepSrpObjectVer1.SRP_OBJ_TYPE == yObjectType)) { + PcepSrpObject srpObj; + srpObj = PcepSrpObjectVer1.read(cb); + pcestateReq.setSrpObject(srpObj); + } + + //store LSP object + PcepLspObject lspObj; + lspObj = PcepLspObjectVer1.read(cb); + pcestateReq.setLspObject(lspObj); + + //store path + PcepStateReport.PcepMsgPath msgPath = new PcepStateReportVer1().new PcepMsgPath().read(cb); + pcestateReq.setMsgPath(msgPath); + + llStateReportList.add(pcestateReq); + } + } + } + + /** + * Constructor to initialize State Report List. + * + * @param llStateReportList list of type Pcep state report + */ + PcepReportMsgVer1(LinkedList<PcepStateReport> llStateReportList) { + this.llStateReportList = llStateReportList; + } + + /** + * Builder class for PCEP Report message. + */ + static class Builder implements PcepReportMsg.Builder { + // Pcep report message fields + LinkedList<PcepStateReport> llStateReportList; + + @Override + public PcepVersion getVersion() { + return PcepVersion.PCEP_1; + } + + @Override + public PcepType getType() { + return PcepType.REPORT; + } + + @Override + public PcepReportMsg build() { + return new PcepReportMsgVer1(this.llStateReportList); + } + + @Override + public LinkedList<PcepStateReport> getStateReportList() { + return this.llStateReportList; + } + + @Override + public Builder setStateReportList(LinkedList<PcepStateReport> ll) { + this.llStateReportList = ll; + return this; + } + } + + @Override + public void writeTo(ChannelBuffer cb) throws PcepParseException { + WRITER.write(cb, this); + } + + static final Writer WRITER = new Writer(); + + /** + * Writer class for writing PCEP report message to channel buffer. + */ + static class Writer implements PcepMessageWriter<PcepReportMsgVer1> { + + @Override + public void write(ChannelBuffer cb, PcepReportMsgVer1 message) throws PcepParseException { + + int startIndex = cb.writerIndex(); + + // first 3 bits set to version + cb.writeByte((byte) (PACKET_VERSION << PcepMessageVer1.SHIFT_FLAG)); + + // message type + cb.writeByte(MSG_TYPE.getType()); + + // length is length of variable message, will be updated at the end + // Store the position of message + // length in buffer + int msgLenIndex = cb.writerIndex(); + + cb.writeShort((short) 0); + ListIterator<PcepStateReport> listIterator = message.llStateReportList.listIterator(); + + while (listIterator.hasNext()) { + + PcepStateReport stateRpt = listIterator.next(); + PcepSrpObject srpObj = stateRpt.getSrpObject(); + + //SRP object is optional + if (srpObj != null) { + srpObj.write(cb); + } + + //LSP object is mandatory + PcepLspObject lspObj = stateRpt.getLspObject(); + if (lspObj == null) { + throw new PcepParseException("LSP Object is mandatory object for PcRpt message."); + } else { + lspObj.write(cb); + } + + //path is mandatory + PcepStateReport.PcepMsgPath msgPath = stateRpt.getMsgPath(); + if (msgPath == null) { + throw new PcepParseException("Message path is mandatory object for PcRpt message."); + } else { + msgPath.write(cb); + } + } + + // update message length field + int length = cb.writerIndex() - startIndex; + cb.setShort(msgLenIndex, (short) length); + } + } + + @Override + public PcepVersion getVersion() { + return PcepVersion.PCEP_1; + } + + @Override + public PcepType getType() { + return MSG_TYPE; + } + + @Override + public LinkedList<PcepStateReport> getStateReportList() { + return this.llStateReportList; + } + + @Override + public void setStateReportList(LinkedList<PcepStateReport> ll) { + this.llStateReportList = ll; + } + + @Override + public String toString() { + return MoreObjects.toStringHelper(getClass()) + .add("StateReportList", llStateReportList) + .toString(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepRroObjectVer1.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepRroObjectVer1.java new file mode 100644 index 00000000..4df42e05 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepRroObjectVer1.java @@ -0,0 +1,345 @@ +/* + * 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.PcepRroObject; +import org.onosproject.pcepio.types.IPv4SubObject; +import org.onosproject.pcepio.types.IPv6SubObject; +import org.onosproject.pcepio.types.LabelSubObject; +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 RRO object. + */ +public class PcepRroObjectVer1 implements PcepRroObject { + + /* + * rfc3209 + 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 + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Object-Class | OT |Res|P|I| Object Length (bytes) | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | | + // (Subobjects) // + | | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + + Each subobject has its own Length + field. The length contains the total length of the subobject in + bytes, including the Type and Length fields. The length MUST always + be a multiple of 4, and at least 4. + + An empty RRO with no subobjects is considered illegal. + Three kinds of subobjects are currently defined. + + Subobject 1: IPv4 address + + 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 + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Type | Length | IPv4 address (4 bytes) | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | IPv4 address (continued) | Prefix Length | Flags | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + + Subobject 2: IPv6 address + + 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 + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Type | Length | IPv6 address (16 bytes) | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | IPv6 address (continued) | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | IPv6 address (continued) | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | IPv6 address (continued) | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | IPv6 address (continued) | Prefix Length | Flags | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + + Subobject 3, Label + + 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 + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Type | Length | Flags | C-Type | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Contents of Label Object | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + + */ + protected static final Logger log = LoggerFactory.getLogger(PcepRroObjectVer1.class); + + public static final byte RRO_OBJ_TYPE = 1; + public static final byte RRO_OBJ_CLASS = 8; + public static final byte RRO_OBJECT_VERSION = 1; + public static final short RRO_OBJ_MINIMUM_LENGTH = 12; + public static final int OBJECT_HEADER_LENGTH = 4; + public static final int YTYPE_SHIFT_VALUE = 0x7F; + + static final PcepObjectHeader DEFAULT_RRO_OBJECT_HEADER = new PcepObjectHeader(RRO_OBJ_CLASS, RRO_OBJ_TYPE, + PcepObjectHeader.REQ_OBJ_OPTIONAL_PROCESS, PcepObjectHeader.RSP_OBJ_PROCESSED, RRO_OBJ_MINIMUM_LENGTH); + + private short rroObjType = 0; + private byte length; + private byte prefixLength; + private byte resvd; + PcepObjectHeader rroObjHeader; + private LinkedList<PcepValueType> llSubObjects = new LinkedList<>(); + + /** + * Reset variables. + */ + public PcepRroObjectVer1() { + this.rroObjHeader = null; + this.rroObjType = 0; + this.length = 0; + } + + /** + * constructor to initialize parameters for RRO object. + * + * @param rroObjHeader RRO object header + * @param llSubObjects list of sub objects + */ + public PcepRroObjectVer1(PcepObjectHeader rroObjHeader, LinkedList<PcepValueType> llSubObjects) { + this.rroObjHeader = rroObjHeader; + this.llSubObjects = llSubObjects; + } + + /** + * Returns PCEP RRO Object Header. + * + * @return rroObjHeader RRO Object header + */ + public PcepObjectHeader getRroObjHeader() { + return this.rroObjHeader; + } + + /** + * Sets PCEP RRO Object Header. + * + * @param obj Object header + */ + public void setRroObjHeader(PcepObjectHeader obj) { + this.rroObjHeader = obj; + } + + @Override + public LinkedList<PcepValueType> getSubObjects() { + return this.llSubObjects; + } + + @Override + public void setSubObjects(LinkedList<PcepValueType> llSubObjects) { + this.llSubObjects = llSubObjects; + } + + /** + * Reads the channel buffer and returns object of PcepRroObject. + * + * @param cb of type channel buffer + * @return object of PcepRroObject + * @throws PcepParseException when fails to read from channel buffer + */ + public static PcepRroObject read(ChannelBuffer cb) throws PcepParseException { + + PcepObjectHeader rroObjHeader; + LinkedList<PcepValueType> llSubObjects; + rroObjHeader = PcepObjectHeader.read(cb); + + //take only RroObject buffer. + ChannelBuffer tempCb = cb.readBytes(rroObjHeader.getObjLen() - OBJECT_HEADER_LENGTH); + llSubObjects = parseSubObjects(tempCb); + + return new PcepRroObjectVer1(rroObjHeader, llSubObjects); + } + + /** + * Returns list of sub objects. + * + * @param cb of type channel buffer + * @return list of sub objects + * @throws PcepParseException when fails to parse list of sub objects + */ + protected static LinkedList<PcepValueType> parseSubObjects(ChannelBuffer cb) throws PcepParseException { + + LinkedList<PcepValueType> llSubObjects = new LinkedList<>(); + + while (0 < cb.readableBytes()) { + + //check the Type of the Sub objects + byte yType = cb.readByte(); + yType = (byte) (yType & (YTYPE_SHIFT_VALUE)); + byte hLength = cb.readByte(); + + PcepValueType subObj; + + switch (yType) { + + case IPv4SubObject.TYPE: + subObj = IPv4SubObject.read(cb); + break; + case IPv6SubObject.TYPE: + byte[] ipv6Value = new byte[IPv6SubObject.VALUE_LENGTH]; + cb.readBytes(ipv6Value, 0, IPv6SubObject.VALUE_LENGTH); + subObj = new IPv6SubObject(ipv6Value); + break; + case LabelSubObject.TYPE: + subObj = LabelSubObject.read(cb); + break; + default: + throw new PcepParseException(" Unexpected sub object. Type: " + (int) yType); + } + // Check for the padding + int pad = hLength % 4; + if (0 < pad) { + pad = 4 - pad; + if (pad <= cb.readableBytes()) { + cb.skipBytes(pad); + } + } + llSubObjects.add(subObj); + } + + return llSubObjects; + } + + @Override + public int write(ChannelBuffer cb) throws PcepParseException { + //write Object header + int objStartIndex = cb.writerIndex(); + + int objLenIndex = rroObjHeader.write(cb); + + if (objLenIndex <= 0) { + throw new PcepParseException(" object Length Index" + objLenIndex); + } + + ListIterator<PcepValueType> listIterator = llSubObjects.listIterator(); + + while (listIterator.hasNext()) { + listIterator.next().write(cb); + } + + //Update object length now + int length = cb.writerIndex() - objStartIndex; + cb.setShort(objLenIndex, (short) length); + //will be helpful during print(). + rroObjHeader.setObjLen((short) length); + + //As per RFC the length of object should be multiples of 4 + int pad = length % 4; + + if (0 != pad) { + pad = 4 - pad; + for (int i = 0; i < pad; i++) { + cb.writeByte((byte) 0); + } + length = length + pad; + } + objLenIndex = cb.writerIndex(); + return objLenIndex; + } + + /** + * Builder class for PCEP RRO object. + */ + public static class Builder implements PcepRroObject.Builder { + private boolean bIsHeaderSet = false; + + private PcepObjectHeader rroObjHeader; + LinkedList<PcepValueType> llSubObjects = new LinkedList<>(); + + private boolean bIsPFlagSet = false; + private boolean bPFlag; + + private boolean bIsIFlagSet = false; + private boolean bIFlag; + + @Override + public PcepRroObject build() { + + PcepObjectHeader rroObjHeader = this.bIsHeaderSet ? this.rroObjHeader : DEFAULT_RRO_OBJECT_HEADER; + + if (bIsPFlagSet) { + rroObjHeader.setPFlag(bPFlag); + } + + if (bIsIFlagSet) { + rroObjHeader.setIFlag(bIFlag); + } + return new PcepRroObjectVer1(rroObjHeader, this.llSubObjects); + } + + @Override + public PcepObjectHeader getRroObjHeader() { + return this.rroObjHeader; + } + + @Override + public Builder setRroObjHeader(PcepObjectHeader obj) { + this.rroObjHeader = obj; + this.bIsHeaderSet = true; + return this; + } + + @Override + public LinkedList<PcepValueType> getSubObjects() { + return this.llSubObjects; + } + + @Override + public Builder setSubObjects(LinkedList<PcepValueType> llSubObjects) { + this.llSubObjects = llSubObjects; + 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("SubObjects", llSubObjects) + .toString(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepSrpObjectVer1.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepSrpObjectVer1.java new file mode 100644 index 00000000..9c75b3a6 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepSrpObjectVer1.java @@ -0,0 +1,392 @@ +/* + * 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.PcepSrpObject; +import org.onosproject.pcepio.types.PcepObjectHeader; +import org.onosproject.pcepio.types.PcepValueType; +import org.onosproject.pcepio.types.SymbolicPathNameTlv; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.google.common.base.MoreObjects; + +/** + * Provides PCEP SRP obejct. + */ +public class PcepSrpObjectVer1 implements PcepSrpObject { + + /* + * ref : draft-ietf-pce-stateful-pce-10, section : 7.2 + 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 + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Object-Class | OT |Res|P|I| Object Length (bytes) | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Flags |R| + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | SRP-ID-number | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | | + // Optional TLVs // + | | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + + */ + protected static final Logger log = LoggerFactory.getLogger(PcepSrpObjectVer1.class); + + public static final byte SRP_OBJ_TYPE = 1; + public static final byte SRP_OBJ_CLASS = 33; + public static final byte SRP_OBJECT_VERSION = 1; + public static final short SRP_OBJ_MINIMUM_LENGTH = 12; + public static final int MINIMUM_COMMON_HEADER_LENGTH = 4; + public static final boolean DEFAULT_RFLAG = false; + + static final PcepObjectHeader DEFAULT_SRP_OBJECT_HEADER = new PcepObjectHeader(SRP_OBJ_CLASS, SRP_OBJ_TYPE, + PcepObjectHeader.REQ_OBJ_OPTIONAL_PROCESS, PcepObjectHeader.RSP_OBJ_PROCESSED, SRP_OBJ_MINIMUM_LENGTH); + + private PcepObjectHeader srpObjHeader; + private static int flags; + private boolean bRFlag; + private int srpId; + + //Optional TLV + private LinkedList<PcepValueType> llOptionalTlv; + public static final byte BBIT_SET = 1; + public static final byte BBIT_RESET = 0; + + /** + * Constructor to initialize member variables. + * + * @param srpObjHeader srp object header + * @param bRFlag R flag + * @param srpID srp Id + * @param llOptionalTlv list of optional tlv + */ + public PcepSrpObjectVer1(PcepObjectHeader srpObjHeader, boolean bRFlag, int srpID, + LinkedList<PcepValueType> llOptionalTlv) { + + this.srpObjHeader = srpObjHeader; + this.bRFlag = bRFlag; + this.srpId = srpID; + this.llOptionalTlv = llOptionalTlv; + } + + /** + * sets the SRP object header. + * + * @param obj srp object header + */ + public void setSrpObjHeader(PcepObjectHeader obj) { + this.srpObjHeader = obj; + } + + @Override + public void setSrpID(int srpID) { + this.srpId = srpID; + } + + @Override + public void setRFlag(boolean bRFlag) { + this.bRFlag = bRFlag; + } + + /** + * Returns SRP object header. + * + * @return srpObjHeader + */ + public PcepObjectHeader getSrpObjHeader() { + return this.srpObjHeader; + } + + @Override + public int getSrpID() { + return this.srpId; + } + + @Override + public boolean getRFlag() { + return this.bRFlag; + } + + @Override + public void setOptionalTlv(LinkedList<PcepValueType> llOptionalTlv) { + this.llOptionalTlv = llOptionalTlv; + + } + + @Override + public LinkedList<PcepValueType> getOptionalTlv() { + return this.llOptionalTlv; + } + + /** + * Reads from channel buffer and returns instance of PCEP SRP object. + * + * @param cb of channel buffer. + * @return PCEP SRP object + * @throws PcepParseException when srp object is not received in channel buffer + */ + public static PcepSrpObject read(ChannelBuffer cb) throws PcepParseException { + + log.debug("SrpObject::read"); + PcepObjectHeader srpObjHeader; + boolean bRFlag; + + int srpID; + int flags; + LinkedList<PcepValueType> llOptionalTlv = new LinkedList<>(); + + srpObjHeader = PcepObjectHeader.read(cb); + + if (srpObjHeader.getObjClass() != SRP_OBJ_CLASS) { + throw new PcepParseException("SRP object expected. But received " + srpObjHeader.getObjClass()); + } + + //take only SrpObject buffer. + ChannelBuffer tempCb = cb.readBytes(srpObjHeader.getObjLen() - MINIMUM_COMMON_HEADER_LENGTH); + flags = tempCb.readInt(); + bRFlag = 0 < flags; + srpID = tempCb.readInt(); + + llOptionalTlv = parseOptionalTlv(tempCb); + + return new PcepSrpObjectVer1(srpObjHeader, bRFlag, srpID, llOptionalTlv); + } + + @Override + public int write(ChannelBuffer cb) throws PcepParseException { + + int objStartIndex = cb.writerIndex(); + + //write common header + int objLenIndex = srpObjHeader.write(cb); + + //write Flags + byte bFlag; + + bFlag = (bRFlag) ? BBIT_SET : BBIT_RESET; + + cb.writeInt(bFlag); + + //write SrpId + cb.writeInt(srpId); + + // Add optional TLV + if (!packOptionalTlv(cb)) { + throw new PcepParseException("Failed to write srp tlv to channel buffer."); + } + + //now write SRP Object Length + cb.setShort(objLenIndex, (short) (cb.writerIndex() - objStartIndex)); + + return cb.writerIndex(); + } + + /** + * Parse Optional TLvs from the channel buffer. + * + * @param cb of type channel buffer + * @return list of optional tlvs + * @throws PcepParseException when unsupported tlv is received in srp object + */ + public static LinkedList<PcepValueType> parseOptionalTlv(ChannelBuffer cb) throws PcepParseException { + + LinkedList<PcepValueType> llOutOptionalTlv = new LinkedList<>(); + + while (MINIMUM_COMMON_HEADER_LENGTH <= cb.readableBytes()) { + + PcepValueType tlv; + short hType = cb.readShort(); + short hLength = cb.readShort(); + + switch (hType) { + + case SymbolicPathNameTlv.TYPE: + tlv = SymbolicPathNameTlv.read(cb, hLength); + cb.skipBytes(hLength); + break; + + default: + throw new PcepParseException("Unsupported TLV received in SRP Object."); + } + + // Check for the padding + int pad = hLength % 4; + if (0 < pad) { + pad = 4 - pad; + if (pad <= cb.readableBytes()) { + cb.skipBytes(pad); + } + } + llOutOptionalTlv.add(tlv); + } + + return llOutOptionalTlv; + } + + /** + * Writes optional tlvs to channel buffer. + * + * @param cb of type channel buffer + * @return true if writing optional tlv to channel buffer is success. + */ + protected boolean packOptionalTlv(ChannelBuffer cb) { + + ListIterator<PcepValueType> listIterator = llOptionalTlv.listIterator(); + + while (listIterator.hasNext()) { + PcepValueType tlv = listIterator.next(); + + if (tlv == null) { + log.debug("tlv is null from OptionalTlv list"); + continue; + } + tlv.write(cb); + + // need to take care of padding + int pad = tlv.getLength() % 4; + + if (0 != pad) { + pad = 4 - pad; + for (int i = 0; i < pad; ++i) { + cb.writeByte((byte) 0); + } + } + } + + return true; + } + + /** + * Builder class for PCEP srp Object. + */ + public static class Builder implements PcepSrpObject.Builder { + private boolean bIsHeaderSet = false; + private boolean bIsSrpIdset = false; + private boolean bIsRFlagSet = false; + + private PcepObjectHeader srpObjHeader; + private int srpId; + private boolean bRFlag; + LinkedList<PcepValueType> llOptionalTlv = new LinkedList<>(); + + private boolean bIsPFlagSet = false; + private boolean bPFlag; + + private boolean bIsIFlagSet = false; + private boolean bIFlag; + + @Override + public PcepSrpObject build() throws PcepParseException { + PcepObjectHeader srpObjHeader = this.bIsHeaderSet ? this.srpObjHeader : DEFAULT_SRP_OBJECT_HEADER; + + boolean bRFlag = this.bIsRFlagSet ? this.bRFlag : DEFAULT_RFLAG; + + if (!this.bIsSrpIdset) { + throw new PcepParseException("SrpID not set while building SRP Object."); + } + + if (bIsPFlagSet) { + srpObjHeader.setPFlag(bPFlag); + } + + if (bIsIFlagSet) { + srpObjHeader.setIFlag(bIFlag); + } + + return new PcepSrpObjectVer1(srpObjHeader, bRFlag, this.srpId, this.llOptionalTlv); + } + + @Override + public PcepObjectHeader getSrpObjHeader() { + return this.srpObjHeader; + } + + @Override + public Builder setSrpObjHeader(PcepObjectHeader obj) { + this.srpObjHeader = obj; + this.bIsHeaderSet = true; + return this; + } + + @Override + public int getSrpID() { + return this.srpId; + } + + @Override + public Builder setSrpID(int srpID) { + this.srpId = srpID; + this.bIsSrpIdset = true; + return this; + } + + @Override + public boolean getRFlag() { + return this.bRFlag; + } + + @Override + public Builder setRFlag(boolean bRFlag) { + this.bRFlag = bRFlag; + this.bIsRFlagSet = true; + return this; + } + + @Override + public Builder setOptionalTlv(LinkedList<PcepValueType> llOptionalTlv) { + this.llOptionalTlv = llOptionalTlv; + return this; + } + + @Override + public LinkedList<PcepValueType> getOptionalTlv() { + return this.llOptionalTlv; + } + + @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("RFlag", bRFlag) + .add("SRPID", srpId) + .add("OptionalTlvList", llOptionalTlv) + .toString(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepStateReportVer1.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepStateReportVer1.java new file mode 100644 index 00000000..ce589bc0 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepStateReportVer1.java @@ -0,0 +1,421 @@ +/* + * 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 org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.pcepio.exceptions.PcepParseException; +import org.onosproject.pcepio.protocol.PcepAttribute; +import org.onosproject.pcepio.protocol.PcepBandwidthObject; +import org.onosproject.pcepio.protocol.PcepEroObject; +import org.onosproject.pcepio.protocol.PcepLspObject; +import org.onosproject.pcepio.protocol.PcepRroObject; +import org.onosproject.pcepio.protocol.PcepSrpObject; +import org.onosproject.pcepio.protocol.PcepStateReport; +import org.onosproject.pcepio.types.PcepObjectHeader; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.google.common.base.MoreObjects; +import com.google.common.base.MoreObjects.ToStringHelper; + +/** + * Provide the State Report for the Pcep Report Message. + * Reference :PCE extensions for stateful draft-ietf-pce-stateful-pce-10. + */ +public class PcepStateReportVer1 implements PcepStateReport { + /* + * <state-report> ::= [<SRP>] + <LSP> + <path> + Where: + <path> ::= <ERO><attribute-list>[<RRO>] + */ + + protected static final Logger log = LoggerFactory.getLogger(PcepStateReport.class); + + public static final int OBJECT_HEADER_LENGTH = 4; + + /** + * Provides PCEP Message path for report message. + */ + public class PcepMsgPath implements PcepStateReport.PcepMsgPath { + + /* + * <path> ::= <ERO><attribute-list>[<RRO>] + */ + + //PcepEroObject + private PcepEroObject eroObj; + private boolean isEroObjectSet; + //PcepAttribute List + private PcepAttribute attrList; + private boolean isAttributeListSet; + //PcepRroObject + private PcepRroObject rroObj; + private boolean isRroObjectSet; + private PcepBandwidthObject bandwidth; + private boolean isBandwidthObjectSet; + + /** + * Constructor to reset the parameters. + */ + public PcepMsgPath() { + eroObj = null; + attrList = null; + rroObj = null; + this.isEroObjectSet = false; + this.isAttributeListSet = false; + this.isRroObjectSet = false; + this.isBandwidthObjectSet = false; + } + + /** + * Constructor to initialize the parameters from PCEP Message path. + * + * @param eroObj PCEP ERO Object + * @param attrList PCEP Attribute + * @param rroObj PCEP Rro Object + * @param bandwidth PCEP bandwidth object + */ + public PcepMsgPath(PcepEroObject eroObj, PcepAttribute attrList, PcepRroObject rroObj, + PcepBandwidthObject bandwidth) { + + this.eroObj = eroObj; + this.attrList = attrList; + this.rroObj = rroObj; + this.bandwidth = bandwidth; + if (rroObj == null) { + this.isRroObjectSet = false; + } else { + this.isRroObjectSet = true; + } + if (eroObj == null) { + this.isEroObjectSet = false; + } else { + this.isEroObjectSet = true; + } + if (attrList == null) { + this.isAttributeListSet = false; + } else { + this.isAttributeListSet = true; + } + if (bandwidth == null) { + this.isBandwidthObjectSet = false; + } else { + this.isBandwidthObjectSet = true; + } + } + + /** + * Returns PcepEroObject. + * + * @return eroObj PCEP ERO Object + */ + @Override + public PcepEroObject getEroObject() { + return this.eroObj; + } + + /** + * Returns PCEP Attribute. + * + * @return attrList Attribute list + */ + @Override + public PcepAttribute getPcepAttribute() { + return this.attrList; + } + + /** + * Returns PcepRroObject. + * + * @return rroObj PCEP RRO Object + */ + @Override + public PcepRroObject getRroObject() { + return this.rroObj; + } + + @Override + public PcepBandwidthObject getBandwidthObject() { + return this.bandwidth; + } + + @Override + public void setEroObject(PcepEroObject eroObj) { + this.eroObj = eroObj; + } + + @Override + public void setPcepAttribute(PcepAttribute attrList) { + this.attrList = attrList; + } + + @Override + public void setRroObject(PcepRroObject rroObj) { + this.rroObj = rroObj; + } + + @Override + public void setBandwidthObject(PcepBandwidthObject bandwidth) { + this.bandwidth = bandwidth; + } + + /** + * Reads all the Objects for PCEP Message Path. + * + * @param bb of type channel buffer + * @return PCEP Message path + * @throws PcepParseException when fails to read pcep message path + */ + @Override + public PcepMsgPath read(ChannelBuffer bb) throws PcepParseException { + + PcepEroObject eroObj; + PcepAttribute attrList; + PcepRroObject rroObj = null; + PcepBandwidthObject bandwidth = null; + + eroObj = PcepEroObjectVer1.read(bb); + attrList = PcepAttributeVer1.read(bb); + + boolean bBreakWhile = false; + while (0 < bb.readableBytes()) { + + if (bb.readableBytes() < OBJECT_HEADER_LENGTH) { + break; + } + bb.markReaderIndex(); + PcepObjectHeader tempObjHeader = PcepObjectHeader.read(bb); + bb.resetReaderIndex(); + byte yObjClass = tempObjHeader.getObjClass(); + + switch (yObjClass) { + case PcepRroObjectVer1.RRO_OBJ_CLASS: + rroObj = PcepRroObjectVer1.read(bb); + break; + case PcepInterLayerObjectVer1.INTER_LAYER_OBJ_CLASS: + bb.skipBytes(tempObjHeader.getObjLen()); + break; + case PcepBandwidthObjectVer1.BANDWIDTH_OBJ_CLASS: + bandwidth = PcepBandwidthObjectVer1.read(bb); + break; + default: + //Otherthan above objects handle those objects in caller. + bBreakWhile = true; + break; + } + if (bBreakWhile) { + break; + } + } + return new PcepMsgPath(eroObj, attrList, rroObj, bandwidth); + } + + /** + * Writes all the objects for PCEP message path. + * + * @param bb of type channel buffer. + * @return object length index + * @throws PcepParseException when fails to write to channel buffer + */ + @Override + public int write(ChannelBuffer bb) throws PcepParseException { + int iLenStartIndex = bb.writerIndex(); + + //write Object header + if (this.isEroObjectSet) { + this.eroObj.write(bb); + } else { + throw new PcepParseException("Ero object is not set in path"); + } + + if (this.isAttributeListSet) { + this.attrList.write(bb); + } + + // RRO is optional check and read + if (this.isRroObjectSet) { + this.rroObj.write(bb); + // bandwidth should come along with RRO. + if (this.isBandwidthObjectSet) { + this.bandwidth.write(bb); + } + } + return bb.writerIndex() - iLenStartIndex; + } + + @Override + public String toString() { + ToStringHelper toStrHelper = MoreObjects.toStringHelper(getClass()); + + if (attrList != null) { + toStrHelper.add("AttributeList", attrList); + } + if (rroObj instanceof PcepRroObjectVer1) { + toStrHelper.add("RroObject", rroObj); + } + if (bandwidth instanceof PcepBandwidthObjectVer1) { + toStrHelper.add("bandwidthObject", bandwidth); + } + return toStrHelper.toString(); + } + } + + //SRP Object + private PcepSrpObject srpObject; + //LSP Object + private PcepLspObject lspObject; + //PcepMsgPath + private PcepStateReport.PcepMsgPath msgPath; + + /** + * Constructor to reset objects. + */ + public PcepStateReportVer1() { + this.srpObject = null; + this.lspObject = null; + this.msgPath = null; + } + + public PcepStateReportVer1(PcepSrpObject srpObject, PcepLspObject lspObject, PcepStateReport.PcepMsgPath msgPath) { + this.srpObject = srpObject; + this.lspObject = lspObject; + this.msgPath = msgPath; + } + + @Override + public PcepSrpObject getSrpObject() { + return srpObject; + } + + @Override + public PcepLspObject getLspObject() { + return lspObject; + } + + @Override + public PcepStateReport.PcepMsgPath getMsgPath() { + return msgPath; + } + + @Override + public void setSrpObject(PcepSrpObject srpObj) { + this.srpObject = srpObj; + } + + @Override + public void setLspObject(PcepLspObject lspObject) { + this.lspObject = lspObject; + } + + @Override + public void setMsgPath(PcepStateReport.PcepMsgPath msgPath) { + this.msgPath = msgPath; + } + + /** + * Builder class for PCEP state report. + */ + public static class Builder implements PcepStateReport.Builder { + + private boolean bIsSRPObjectSet = false; + private boolean bIsLSPObjectSet = false; + private boolean bIsPcepMsgPathSet = false; + + //PCEP SRP Object + private PcepSrpObject srpObject; + //PCEP LSP Object + private PcepLspObject lspObject; + //PCEP Attribute list + private PcepStateReport.PcepMsgPath msgPath; + + @Override + public PcepStateReport build() throws PcepParseException { + + //PCEP SRP Object + PcepSrpObject srpObject = null; + //PCEP LSP Object + PcepLspObject lspObject = null; + //PCEP Attribute list + PcepStateReport.PcepMsgPath msgPath = null; + + if (this.bIsSRPObjectSet) { + srpObject = this.srpObject; + } + + if (!this.bIsLSPObjectSet) { + throw new PcepParseException(" LSP Object NOT Set while building PcepStateReport."); + } else { + lspObject = this.lspObject; + } + if (!this.bIsPcepMsgPathSet) { + throw new PcepParseException(" Message Path NOT Set while building PcepStateReport."); + } else { + msgPath = this.msgPath; + } + + return new PcepStateReportVer1(srpObject, lspObject, msgPath); + } + + @Override + public PcepSrpObject getSrpObject() { + return this.srpObject; + } + + @Override + public PcepLspObject getLspObject() { + return this.lspObject; + } + + @Override + public PcepStateReport.PcepMsgPath getMsgPath() { + return this.msgPath; + } + + @Override + public Builder setSrpObject(PcepSrpObject srpobj) { + this.srpObject = srpobj; + this.bIsSRPObjectSet = true; + return this; + } + + @Override + public Builder setLspObject(PcepLspObject lspObject) { + this.lspObject = lspObject; + this.bIsLSPObjectSet = true; + return this; + } + + @Override + public Builder setMsgPath(PcepStateReport.PcepMsgPath msgPath) { + this.msgPath = msgPath; + this.bIsPcepMsgPathSet = true; + return this; + } + } + + @Override + public String toString() { + return MoreObjects.toStringHelper(getClass()) + .omitNullValues() + .add("SrpObject", srpObject) + .add("LspObject", lspObject) + .add("MsgPath", msgPath) + .toString(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepTEObjectVer1.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepTEObjectVer1.java new file mode 100644 index 00000000..b1c69406 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepTEObjectVer1.java @@ -0,0 +1,506 @@ +/* + * 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.PcepTEObject; +import org.onosproject.pcepio.types.LocalTENodeDescriptorsTlv; +import org.onosproject.pcepio.types.PcepObjectHeader; +import org.onosproject.pcepio.types.PcepValueType; +import org.onosproject.pcepio.types.RemoteTENodeDescriptorsTlv; +import org.onosproject.pcepio.types.RoutingUniverseTlv; +import org.onosproject.pcepio.types.TELinkAttributesTlv; +import org.onosproject.pcepio.types.TELinkDescriptorsTlv; +import org.onosproject.pcepio.types.TENodeAttributesTlv; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.google.common.base.MoreObjects; + +/** + * Provides PCEP TE Object. + */ +public class PcepTEObjectVer1 implements PcepTEObject { + /* + * + reference: PCEP Extension for Transporting TE Data draft-dhodylee-pce-pcep-te-data-extn-02. + TE Object-Class is [TBD6]. + + Two Object-Type values are defined for the TE object: + + o TE Node: TE Object-Type is 1. + + o TE Link: TE Object-Type is 2. + + The format of the TE object body is as follows: + + 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 + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Protocol-ID | Flag |R|S| + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | TE-ID | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + // TLVs // + | | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + */ + + protected static final Logger log = LoggerFactory.getLogger(PcepTEObjectVer1.class); + + public static final byte TE_OBJ_TYPE_NODE_VALUE = 1; + public static final byte TE_OBJ_TYPE_LINK_VALUE = 2; + + public static final byte TE_OBJ_CLASS = 101; //TBD6 in RFC. + public static final byte TE_OBJECT_VERSION = 1; + + // TE_OBJ_MINIMUM_LENGTH = TEObjectHeaderLen(4)+ TEObjectLen(8) + public static final short TE_OBJ_MINIMUM_LENGTH = 12; + + // Signaled ,all default values to be checked. + public static final byte DEFAULT_PROTOCOL_ID = 1; //IS-IS Level 1 + public static final boolean DEFAULT_R_FLAG = false; + public static final boolean DEFAULT_S_FLAG = false; + public static final int DEFAULT_TE_ID = 0; + + public static final int OBJECT_HEADER_LENGTH = 4; + public static final int RIGHT_SHIFT_ONE = 1; + public static final int RIGHT_FIRST_FLAG = 0x1; + public static final int FLAG_SET_R_FLAG = 0x2; + public static final int FLAG_SET_S_FLAG = 0x1; + public static final int MINIMUM_COMMON_HEADER_LENGTH = 4; + public static final int MINIMUM_TLV_HEADER_LENGTH = 4; + + public static final PcepObjectHeader DEFAULT_TE_OBJECT_HEADER = new PcepObjectHeader(TE_OBJ_CLASS, + TE_OBJ_TYPE_NODE_VALUE, PcepObjectHeader.REQ_OBJ_OPTIONAL_PROCESS, PcepObjectHeader.RSP_OBJ_PROCESSED, + TE_OBJ_MINIMUM_LENGTH); + + private PcepObjectHeader teObjHeader; + private byte yProtocolId; + // 2-flags + private boolean bRFlag; + private boolean bSFlag; + private int iTEId; + // Optional TLV + private LinkedList<PcepValueType> llOptionalTlv; + + /** + * Constructor to initialize variables. + * + * @param teObjHeader TE Object header + * @param yProtocolId Protocol-ID + * @param bRFlag R-flag + * @param bSFlag S-flag + * @param iTEId TE-ID + * @param llOptionalTlv linked list of Optional TLV + */ + public PcepTEObjectVer1(PcepObjectHeader teObjHeader, byte yProtocolId, boolean bRFlag, boolean bSFlag, int iTEId, + LinkedList<PcepValueType> llOptionalTlv) { + + this.teObjHeader = teObjHeader; + this.yProtocolId = yProtocolId; + this.bRFlag = bRFlag; + this.bSFlag = bSFlag; + this.iTEId = iTEId; + this.llOptionalTlv = llOptionalTlv; + } + + @Override + public PcepObjectHeader getTEObjHeader() { + return this.teObjHeader; + } + + @Override + public void setTEObjHeader(PcepObjectHeader obj) { + this.teObjHeader = obj; + } + + @Override + public byte getProtocolId() { + return this.yProtocolId; + } + + @Override + public void setProtocolId(byte yProtId) { + this.yProtocolId = yProtId; + } + + @Override + public boolean getRFlag() { + return this.bRFlag; + } + + @Override + public void setRFlag(boolean bRFlag) { + this.bRFlag = bRFlag; + } + + @Override + public boolean getSFlag() { + return this.bSFlag; + } + + @Override + public void setSFlag(boolean bSFlag) { + this.bSFlag = bSFlag; + } + + @Override + public int getTEId() { + return this.iTEId; + } + + @Override + public void setTEId(int iTEId) { + this.iTEId = iTEId; + } + + @Override + public LinkedList<PcepValueType> getOptionalTlv() { + return this.llOptionalTlv; + } + + @Override + public void setOptionalTlv(LinkedList<PcepValueType> llOptionalTlv) { + this.llOptionalTlv = llOptionalTlv; + } + + /** + * Reads from the channel buffer and returns Object of PcepTEObject. + * + * @param cb of type channel buffer + * @return Object of PcepTEObject + * @throws PcepParseException if mandatory fields are missing + */ + public static PcepTEObject read(ChannelBuffer cb) throws PcepParseException { + log.debug("read"); + + PcepObjectHeader teObjHeader; + byte yProtocolId; + // 2-flags + boolean bRFlag; + boolean bSFlag; + int iTEId; + LinkedList<PcepValueType> llOptionalTlv; + + teObjHeader = PcepObjectHeader.read(cb); + + //take only TEObject buffer. + ChannelBuffer tempCb = cb.readBytes(teObjHeader.getObjLen() - OBJECT_HEADER_LENGTH); + + yProtocolId = tempCb.readByte(); + //ignore first two bytes of Flags + tempCb.readShort(); + + Integer iTemp = (int) tempCb.readByte(); //read 3rd byte Flag + bSFlag = (iTemp & FLAG_SET_S_FLAG) == FLAG_SET_S_FLAG; + bRFlag = (iTemp & FLAG_SET_R_FLAG) == FLAG_SET_R_FLAG; + + iTEId = tempCb.readInt(); + + // parse optional TLV + llOptionalTlv = parseOptionalTlv(tempCb); + + return new PcepTEObjectVer1(teObjHeader, yProtocolId, bRFlag, bSFlag, iTEId, llOptionalTlv); + } + + @Override + public int write(ChannelBuffer cb) throws PcepParseException { + + //write Object header + int objStartIndex = cb.writerIndex(); + int objLenIndex = teObjHeader.write(cb); + + if (objLenIndex <= 0) { + throw new PcepParseException("ObjectLength Index is " + objLenIndex); + } + + //write Protocol ID + cb.writeByte(this.yProtocolId); + + //write Flag + cb.writeShort(0); + + byte bTemp = 0; + if (bSFlag) { + bTemp = FLAG_SET_S_FLAG; + } + + if (bRFlag) { + bTemp = (byte) (bTemp | FLAG_SET_R_FLAG); + } + cb.writeByte(bTemp); + + //write TEId + cb.writeInt(iTEId); + + // Add optional TLV + packOptionalTlv(cb); + + //Update object length now + int length = cb.writerIndex() - objStartIndex; + + //will be helpful during print(). + teObjHeader.setObjLen((short) length); + + cb.setShort(objLenIndex, (short) length); + + return cb.writerIndex(); + } + + /** + * Returns Linked list of PCEP Value Type. + * + * @param cb of channel buffer + * @return Linked list of PCEP Value Type + * @throws PcepParseException if mandatory fields are missing + */ + protected static LinkedList<PcepValueType> parseOptionalTlv(ChannelBuffer cb) throws PcepParseException { + + LinkedList<PcepValueType> llOutOptionalTlv; + + llOutOptionalTlv = new LinkedList<>(); + + while (MINIMUM_TLV_HEADER_LENGTH <= cb.readableBytes()) { + + PcepValueType tlv; + short hType = cb.readShort(); + short hLength = cb.readShort(); + long lValue = 0; + + switch (hType) { + + case RoutingUniverseTlv.TYPE: + lValue = cb.readLong(); + tlv = new RoutingUniverseTlv(lValue); + break; + case LocalTENodeDescriptorsTlv.TYPE: + tlv = LocalTENodeDescriptorsTlv.read(cb, hLength); + break; + case RemoteTENodeDescriptorsTlv.TYPE: + tlv = RemoteTENodeDescriptorsTlv.read(cb, hLength); + break; + case TELinkDescriptorsTlv.TYPE: + tlv = TELinkDescriptorsTlv.read(cb, hLength); + break; + case TENodeAttributesTlv.TYPE: + tlv = TENodeAttributesTlv.read(cb, hLength); + break; + case TELinkAttributesTlv.TYPE: + tlv = TELinkAttributesTlv.read(cb, hLength); + break; + default: + throw new PcepParseException("Unsupported TLV type :" + hType); + } + + // Check for the padding + int pad = hLength % 4; + if (0 < pad) { + pad = 4 - pad; + if (pad <= cb.readableBytes()) { + cb.skipBytes(pad); + } + } + + llOutOptionalTlv.add(tlv); + } + + if (0 < cb.readableBytes()) { + + throw new PcepParseException("Optional Tlv parsing error. Extra bytes received."); + } + return llOutOptionalTlv; + } + + /** + * Returns the writer index. + * + * @param cb of type channel buffer + * @return the writer index. + */ + protected int packOptionalTlv(ChannelBuffer cb) { + + ListIterator<PcepValueType> listIterator = llOptionalTlv.listIterator(); + + while (listIterator.hasNext()) { + PcepValueType tlv = listIterator.next(); + + if (tlv == null) { + log.debug("TLV is null from OptionalTlv list"); + continue; + } + tlv.write(cb); + + // need to take care of padding + int pad = tlv.getLength() % 4; + + if (0 != pad) { + pad = 4 - pad; + for (int i = 0; i < pad; ++i) { + cb.writeByte((byte) 0); + } + } + } + return cb.writerIndex(); + } + + /** + * Builder class for PCEP te object. + */ + public static class Builder implements PcepTEObject.Builder { + private boolean bIsHeaderSet = false; + private boolean bIsProtocolIdSet = false; + private boolean bIsRFlagSet = false; + private boolean bIsSFlagSet = false; + private boolean bIsTEIdSet = false; + + private PcepObjectHeader teObjHeader; + private byte yProtocolId; + private boolean bRFlag; + private boolean bSFlag; + private int iTEId; + private LinkedList<PcepValueType> llOptionalTlv = new LinkedList<>(); + + private boolean bIsPFlagSet = false; + private boolean bPFlag; + + private boolean bIsIFlagSet = false; + private boolean bIFlag; + + @Override + public PcepTEObject build() { + PcepObjectHeader teObjHeader = this.bIsHeaderSet ? this.teObjHeader : DEFAULT_TE_OBJECT_HEADER; + + byte yProtocolId = this.bIsProtocolIdSet ? this.yProtocolId : DEFAULT_PROTOCOL_ID; + boolean bRFlag = this.bIsRFlagSet ? this.bRFlag : DEFAULT_R_FLAG; + boolean bSFlag = this.bIsSFlagSet ? this.bSFlag : DEFAULT_S_FLAG; + int iTEId = this.bIsTEIdSet ? this.iTEId : DEFAULT_TE_ID; + + if (bIsPFlagSet) { + teObjHeader.setPFlag(bPFlag); + } + + if (bIsIFlagSet) { + teObjHeader.setIFlag(bIFlag); + } + + return new PcepTEObjectVer1(teObjHeader, yProtocolId, bRFlag, bSFlag, iTEId, llOptionalTlv); + + } + + @Override + public PcepObjectHeader getTEObjHeader() { + return this.teObjHeader; + } + + @Override + public Builder setTEObjHeader(PcepObjectHeader obj) { + this.teObjHeader = obj; + this.bIsHeaderSet = true; + return this; + } + + @Override + public byte getProtocolId() { + return this.yProtocolId; + } + + @Override + public Builder setProtocolId(byte yProtId) { + this.yProtocolId = yProtId; + this.bIsProtocolIdSet = true; + return this; + } + + @Override + public boolean getRFlag() { + return this.bRFlag; + } + + @Override + public Builder setRFlag(boolean bRFlag) { + this.bRFlag = bRFlag; + this.bIsRFlagSet = true; + return this; + } + + @Override + public boolean getSFlag() { + return this.bSFlag; + } + + @Override + public Builder setSFlag(boolean bSFlag) { + this.bSFlag = bSFlag; + this.bIsSFlagSet = true; + return this; + } + + @Override + public int getTEId() { + return this.iTEId; + } + + @Override + public Builder setTEId(int iTEId) { + this.iTEId = iTEId; + this.bIsTEIdSet = true; + return this; + } + + @Override + public LinkedList<PcepValueType> getOptionalTlv() { + return this.llOptionalTlv; + } + + @Override + public Builder setOptionalTlv(LinkedList<PcepValueType> 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("ObjectHeader", teObjHeader) + .add("ProtocolId", yProtocolId) + .add("RFlag", (bRFlag) ? 1 : 0) + .add("SFlag", (bSFlag) ? 1 : 0) + .add("TeId", iTEId) + .add("OptionalTlv", llOptionalTlv) + .toString(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepTEReportMsgVer1.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepTEReportMsgVer1.java new file mode 100644 index 00000000..92833080 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepTEReportMsgVer1.java @@ -0,0 +1,225 @@ +/* + * 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.PcepMessageReader; +import org.onosproject.pcepio.protocol.PcepMessageWriter; +import org.onosproject.pcepio.protocol.PcepTEObject; +import org.onosproject.pcepio.protocol.PcepTEReportMsg; +import org.onosproject.pcepio.protocol.PcepType; +import org.onosproject.pcepio.protocol.PcepVersion; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.google.common.base.MoreObjects; + +/** + * Provides PCEP TE Report Message. + */ +class PcepTEReportMsgVer1 implements PcepTEReportMsg { + + /* + * Ref : draft-dhodylee-pce-pcep-te-data-extn-02, section 8.1 + + <TERpt Message> ::= <Common Header> + <te-report-list> + Where: + <te-report-list> ::= <TE>[<te-report-list>] + */ + + private static final Logger log = LoggerFactory.getLogger(PcepTEReportMsgVer1.class); + //PACKET_MINIMUM_LENGTH = CommonHeaderLen(4)+TEObjMinLen(12) + public static final int PACKET_MINIMUM_LENGTH = 16; + public static final PcepType MSG_TYPE = PcepType.TE_REPORT; + // <te-report-list> + private LinkedList<PcepTEObject> teReportList; + + public static final PcepTEReportMsgVer1.Reader READER = new Reader(); + + /** + * Reader class for reading PCPE te report message form channel buffer. + */ + static class Reader implements PcepMessageReader<PcepTEReportMsg> { + + LinkedList<PcepTEObject> teReportList; + + @Override + public PcepTEReportMsg readFrom(ChannelBuffer cb) throws PcepParseException { + + if (cb.readableBytes() < PACKET_MINIMUM_LENGTH) { + return null; + } + + teReportList = new LinkedList<>(); + + byte version = cb.readByte(); + version = (byte) (version >> PcepMessageVer1.SHIFT_FLAG); + if (version != PcepMessageVer1.PACKET_VERSION) { + throw new PcepParseException("Wrong version. Expected=PcepVersion.PCEP_1(1), got=" + version); + } + + byte type = cb.readByte(); + if (type != MSG_TYPE.getType()) { + throw new PcepParseException("Wrong type. Expected=PcepType.TE_REPORT(14), got=" + type); + } + + short length = cb.readShort(); + if (length < PACKET_MINIMUM_LENGTH) { + throw new PcepParseException( + "Wrong length. Expected to be >= " + PACKET_MINIMUM_LENGTH + ", is: " + length); + } + + // Parse state report list + parseTEReportList(cb); + + return new PcepTEReportMsgVer1(teReportList); + } + + /** + * Parse te-report-list. + * + * @param cb input Channel Buffer + * @throws PcepParseException when fails to parse TE Report list. + */ + public void parseTEReportList(ChannelBuffer cb) throws PcepParseException { + // <te-report-list> ::= <TE>[<te-report-list>] + + while (0 < cb.readableBytes()) { + //store TE objectS + if (!teReportList.add(PcepTEObjectVer1.read(cb))) { + throw new PcepParseException("Failed to add TE object to TE report list"); + } + } + } + } + + /** + * Constructor to initialize TE Report List. + * + * @param teReportList list of PCEP TE Object + */ + PcepTEReportMsgVer1(LinkedList<PcepTEObject> teReportList) { + this.teReportList = teReportList; + } + + /** + * Builder class for PCEP te report message. + */ + static class Builder implements PcepTEReportMsg.Builder { + // PCEP TE Report message fields + LinkedList<PcepTEObject> teReportList; + + @Override + public PcepVersion getVersion() { + return PcepVersion.PCEP_1; + } + + @Override + public PcepType getType() { + return PcepType.TE_REPORT; + } + + @Override + public PcepTEReportMsg build() { + return new PcepTEReportMsgVer1(this.teReportList); + } + + @Override + public LinkedList<PcepTEObject> getTEReportList() { + return this.teReportList; + } + + @Override + public Builder setTEReportList(LinkedList<PcepTEObject> ll) { + this.teReportList = ll; + return this; + } + } + + @Override + public void writeTo(ChannelBuffer bb) throws PcepParseException { + WRITER.write(bb, this); + } + + static final Writer WRITER = new Writer(); + + /** + * Writer class for writing PCEP te report message to channel buffer. + */ + static class Writer implements PcepMessageWriter<PcepTEReportMsgVer1> { + + @Override + public void write(ChannelBuffer bb, PcepTEReportMsgVer1 message) throws PcepParseException { + + int startIndex = bb.writerIndex(); + + // first 3 bits set to version + bb.writeByte((byte) (PcepMessageVer1.PACKET_VERSION << PcepMessageVer1.SHIFT_FLAG)); + + // message type + bb.writeByte(MSG_TYPE.getType()); + + // Length of the message will be updated at the end + // First write with 0s + int msgLenIndex = bb.writerIndex(); + bb.writeShort((short) 0); + + ListIterator<PcepTEObject> listIterator = message.teReportList.listIterator(); + + while (listIterator.hasNext()) { + PcepTEObject teObj = listIterator.next(); + teObj.write(bb); + } + + // update message length field + int length = bb.writerIndex() - startIndex; + bb.setShort(msgLenIndex, (short) length); + } + } + + @Override + public PcepVersion getVersion() { + return PcepVersion.PCEP_1; + } + + @Override + public PcepType getType() { + return MSG_TYPE; + } + + @Override + public LinkedList<PcepTEObject> getTEReportList() { + return this.teReportList; + } + + @Override + public void setTEReportList(LinkedList<PcepTEObject> ll) { + this.teReportList = ll; + } + + @Override + public String toString() { + return MoreObjects.toStringHelper(getClass()) + .add("TeReportList", teReportList) + .toString(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepUpdateMsgVer1.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepUpdateMsgVer1.java new file mode 100644 index 00000000..53c66872 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepUpdateMsgVer1.java @@ -0,0 +1,300 @@ +/* + * 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.PcepLspObject; +import org.onosproject.pcepio.protocol.PcepMessageReader; +import org.onosproject.pcepio.protocol.PcepMessageWriter; +import org.onosproject.pcepio.protocol.PcepMsgPath; +import org.onosproject.pcepio.protocol.PcepSrpObject; +import org.onosproject.pcepio.protocol.PcepType; +import org.onosproject.pcepio.protocol.PcepUpdateMsg; +import org.onosproject.pcepio.protocol.PcepUpdateRequest; +import org.onosproject.pcepio.protocol.PcepVersion; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.google.common.base.MoreObjects; + +/** + * Provides PCEP update message. + */ + +class PcepUpdateMsgVer1 implements PcepUpdateMsg { + + // Pcep version: 1 + + /* The format of the PCUpd message is as follows: + * <PCUpd Message> ::= <Common Header> + * <update-request-list> + * Where: + * <update-request-list> ::= <update-request>[<update-request-list>] + * <update-request> ::= <SRP> + * <LSP> + * <path> + * Where: + * <path> ::= <ERO><attribute-list> + * Where: + * <attribute-list> is defined in [RFC5440] and extended by PCEP extensions. + * where: + * <attribute-list> ::=[<LSPA>] + * [<BANDWIDTH>] + * [<metric-list>] + * [<IRO>] + * <metric-list> ::=<METRIC>[<metric-list>] + * + * 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 + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + * | Ver | Flags | Message-Type | Message-Length | + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + * | | + * // UPDATE REQUEST LIST // + * | | + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + * + * Reference:Internet-Draft-PCEP Extensions-for-Stateful-PCE-10 + */ + + protected static final Logger log = LoggerFactory.getLogger(PcepUpdateMsgVer1.class); + + public static final byte PACKET_VERSION = 1; + // UpdateMsgMinLength = SrpObjMinLentgh(12)+LspObjMinLength(8)+EroObjMinLength(12)+ CommonHeaderLength(4) + public static final short PACKET_MINIMUM_LENGTH = 36; + public static final PcepType MSG_TYPE = PcepType.UPDATE; + //Update Request List + private LinkedList<PcepUpdateRequest> llUpdateRequestList; + + public static final PcepUpdateMsgVer1.Reader READER = new Reader(); + + /** + * Reader reads UpdateMessage from the channel. + */ + static class Reader implements PcepMessageReader<PcepUpdateMsg> { + + LinkedList<PcepUpdateRequest> llUpdateRequestList; + + @Override + public PcepUpdateMsg readFrom(ChannelBuffer cb) throws PcepParseException { + + if (cb.readableBytes() < PACKET_MINIMUM_LENGTH) { + throw new PcepParseException("Readable bytes is less than update message minimum length"); + } + + llUpdateRequestList = new LinkedList<>(); + + // fixed value property version == 1 + byte version = cb.readByte(); + version = (byte) (version >> PcepMessageVer1.SHIFT_FLAG); + if (version != PACKET_VERSION) { + throw new PcepParseException("Wrong version. Expected=PcepVersion.PCEP_1(1), got=" + version); + } + // fixed value property type == 11 + byte type = cb.readByte(); + if (type != MSG_TYPE.getType()) { + throw new PcepParseException("Wrong type. Expected=PcepType.UPDATE(11), got=" + type); + } + short length = cb.readShort(); + if (length < PACKET_MINIMUM_LENGTH) { + throw new PcepParseException("Wrong length. Expected to be >= " + PACKET_MINIMUM_LENGTH + ", was: " + + length); + } + + log.debug("reading update message of length " + length); + + // parse Update Request list + if (!parseUpdateRequestList(cb)) { + throw new PcepParseException("parsing Update Request List Failed."); + } + + return new PcepUpdateMsgVer1(llUpdateRequestList); + } + + /** + * Parse update request list. + * + * @param cb of type channel buffer + * @return true after parsing Update Request List + * @throws PcepParseException while parsing update request list from channel buffer + */ + public boolean parseUpdateRequestList(ChannelBuffer cb) throws PcepParseException { + + /* <update-request-list> + * Where: + * <update-request-list> ::= <update-request>[<update-request-list>] + * <update-request> ::= <SRP> + * <LSP> + * <path> + * Where: + * <path> ::= <ERO><attribute-list> + * Where: + * <attribute-list> is defined in [RFC5440] and extended by PCEP extensions. + */ + + while (0 < cb.readableBytes()) { + + PcepUpdateRequest pceUpdateReq = new PcepUpdateRequestVer1(); + + //Read SRP Object and Store it. + PcepSrpObject srpObj; + srpObj = PcepSrpObjectVer1.read(cb); + pceUpdateReq.setSrpObject(srpObj); + + //Read LSP object and Store it. + PcepLspObject lspObj; + lspObj = PcepLspObjectVer1.read(cb); + pceUpdateReq.setLspObject(lspObj); + + // Read Msg Path and store it. + PcepMsgPath msgPath = new PcepMsgPathVer1().read(cb); + pceUpdateReq.setMsgPath(msgPath); + + llUpdateRequestList.add(pceUpdateReq); + } + return true; + } + } + + /** + * Constructor to initialize llUpdateRequestList. + * + * @param llUpdateRequestList list of PcepUpdateRequest. + */ + PcepUpdateMsgVer1(LinkedList<PcepUpdateRequest> llUpdateRequestList) { + this.llUpdateRequestList = llUpdateRequestList; + } + + /** + * Builder class for PCPE update message. + */ + static class Builder implements PcepUpdateMsg.Builder { + + // PCEP report message fields + LinkedList<PcepUpdateRequest> llUpdateRequestList; + + @Override + public PcepVersion getVersion() { + return PcepVersion.PCEP_1; + } + + @Override + public PcepType getType() { + return PcepType.UPDATE; + } + + @Override + public PcepUpdateMsg build() { + return new PcepUpdateMsgVer1(this.llUpdateRequestList); + } + + @Override + public LinkedList<PcepUpdateRequest> getUpdateRequestList() { + return this.llUpdateRequestList; + } + + @Override + public Builder setUpdateRequestList(LinkedList<PcepUpdateRequest> llUpdateRequestList) { + this.llUpdateRequestList = llUpdateRequestList; + return this; + } + + } + + @Override + public void writeTo(ChannelBuffer cb) throws PcepParseException { + WRITER.write(cb, this); + } + + static final Writer WRITER = new Writer(); + + /** + * Writer writes UpdateMessage to the channel buffer. + */ + static class Writer implements PcepMessageWriter<PcepUpdateMsgVer1> { + + @Override + public void write(ChannelBuffer cb, PcepUpdateMsgVer1 message) throws PcepParseException { + + int startIndex = cb.writerIndex(); + // first 3 bits set to version + cb.writeByte((byte) (PACKET_VERSION << PcepMessageVer1.SHIFT_FLAG)); + // message type + cb.writeByte(MSG_TYPE.getType()); + /* length is length of variable message, will be updated at the end + * Store the position of message + * length in buffer + */ + int msgLenIndex = cb.writerIndex(); + + cb.writeShort((short) 0); + ListIterator<PcepUpdateRequest> listIterator = message.llUpdateRequestList.listIterator(); + + while (listIterator.hasNext()) { + + PcepUpdateRequest updateReq = listIterator.next(); + + //SRP object is mandatory + PcepSrpObject srpObj = updateReq.getSrpObject(); + srpObj.write(cb); + + //LSP object is mandatory + PcepLspObject lspObj = updateReq.getLspObject(); + lspObj.write(cb); + + //PATH object is mandatory + PcepMsgPath msgPath = updateReq.getMsgPath(); + msgPath.write(cb); + } + + // update message length field + int length = cb.writerIndex() - startIndex; + cb.setShort(msgLenIndex, (short) length); + } + } + + @Override + public PcepVersion getVersion() { + return PcepVersion.PCEP_1; + } + + @Override + public PcepType getType() { + return MSG_TYPE; + } + + @Override + public LinkedList<PcepUpdateRequest> getUpdateRequestList() { + return this.llUpdateRequestList; + } + + @Override + public void setUpdateRequestList(LinkedList<PcepUpdateRequest> llUpdateRequestList) { + this.llUpdateRequestList = llUpdateRequestList; + } + + @Override + public String toString() { + return MoreObjects.toStringHelper(getClass()) + .add("UpdateRequestList", llUpdateRequestList) + .toString(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepUpdateRequestVer1.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepUpdateRequestVer1.java new file mode 100644 index 00000000..0bcc2907 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepUpdateRequestVer1.java @@ -0,0 +1,199 @@ +/* + * 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 org.onosproject.pcepio.exceptions.PcepParseException; +import org.onosproject.pcepio.protocol.PcepLspObject; +import org.onosproject.pcepio.protocol.PcepMsgPath; +import org.onosproject.pcepio.protocol.PcepSrpObject; +import org.onosproject.pcepio.protocol.PcepUpdateRequest; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.google.common.base.MoreObjects; + +/** + * Provides PCEP Update Request List. + */ +public class PcepUpdateRequestVer1 implements PcepUpdateRequest { + + /* <update-request-list> + * Where: + * <update-request-list> ::= <update-request>[<update-request-list>] + * <update-request> ::= <SRP> + * <LSP> + * <path> + * Where: + * <path> ::= <ERO><attribute-list> + * Where: + * <attribute-list> is defined in [RFC5440] and extended by PCEP extensions. + */ + + protected static final Logger log = LoggerFactory.getLogger(PcepUpdateRequestVer1.class); + + //PCEP SRP Object + private PcepSrpObject srpObject; + //PCEP LSP Object + private PcepLspObject lspObject; + //PCEP Message path + private PcepMsgPath msgPath; + + /** + * Default constructor. + */ + public PcepUpdateRequestVer1() { + srpObject = null; + lspObject = null; + msgPath = null; + } + + /** + * Constructor to initialize all member variables. + * + * @param srpObject srp object + * @param lspObject lsp object + * @param msgPath message path object + */ + public PcepUpdateRequestVer1(PcepSrpObject srpObject, PcepLspObject lspObject, PcepMsgPath msgPath) { + this.srpObject = srpObject; + this.lspObject = lspObject; + this.msgPath = msgPath; + } + + @Override + public PcepSrpObject getSrpObject() { + return srpObject; + } + + @Override + public PcepLspObject getLspObject() { + return lspObject; + } + + @Override + public PcepMsgPath getMsgPath() { + return msgPath; + } + + @Override + public void setSrpObject(PcepSrpObject srpObject) { + this.srpObject = srpObject; + + } + + @Override + public void setLspObject(PcepLspObject lspObject) { + this.lspObject = lspObject; + } + + @Override + public void setMsgPath(PcepMsgPath msgPath) { + this.msgPath = msgPath; + } + + /** + * Builder class for PCEP update request. + */ + public static class Builder implements PcepUpdateRequest.Builder { + + private boolean bIsSRPObjectSet = false; + private boolean bIsLSPObjectSet = false; + private boolean bIsPcepMsgPathSet = false; + + //PCEP SRP Object + private PcepSrpObject srpObject; + //PCEP LSP Object + private PcepLspObject lspObject; + //PCEP Attribute list + private PcepMsgPath msgPath; + + @Override + public PcepUpdateRequest build() throws PcepParseException { + + //PCEP SRP Object + PcepSrpObject srpObject = null; + //PCEP LSP Object + PcepLspObject lspObject = null; + //PCEP Attribute list + PcepMsgPath msgPath = null; + + if (!this.bIsSRPObjectSet) { + throw new PcepParseException(" SRP Object NOT Set while building PcepUpdateRequest."); + } else { + srpObject = this.srpObject; + } + if (!this.bIsLSPObjectSet) { + throw new PcepParseException(" LSP Object NOT Set while building PcepUpdateRequest."); + } else { + lspObject = this.lspObject; + } + if (!this.bIsPcepMsgPathSet) { + throw new PcepParseException(" Msg Path NOT Set while building PcepUpdateRequest."); + } else { + msgPath = this.msgPath; + } + + return new PcepUpdateRequestVer1(srpObject, lspObject, msgPath); + } + + @Override + public PcepSrpObject getSrpObject() { + return this.srpObject; + } + + @Override + public PcepLspObject getLspObject() { + return this.lspObject; + } + + @Override + public PcepMsgPath getMsgPath() { + return this.msgPath; + } + + @Override + public Builder setSrpObject(PcepSrpObject srpobj) { + this.srpObject = srpobj; + this.bIsSRPObjectSet = true; + return this; + + } + + @Override + public Builder setLspObject(PcepLspObject lspObject) { + this.lspObject = lspObject; + this.bIsLSPObjectSet = true; + return this; + } + + @Override + public Builder setMsgPath(PcepMsgPath msgPath) { + this.msgPath = msgPath; + this.bIsPcepMsgPathSet = true; + return this; + } + } + + @Override + public String toString() { + return MoreObjects.toStringHelper(getClass()) + .add("SrpObject", srpObject) + .add("LspObject", lspObject) + .add("MsgPath", msgPath) + .toString(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/package-info.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/package-info.java new file mode 100644 index 00000000..32d49ec9 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/package-info.java @@ -0,0 +1,20 @@ +/* + * 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. + */ + +/** + * Implementation of PCEP messages. + */ +package org.onosproject.pcepio.protocol.ver1; diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/AdministrativeGroupTlv.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/AdministrativeGroupTlv.java new file mode 100644 index 00000000..62ed4e7f --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/AdministrativeGroupTlv.java @@ -0,0 +1,136 @@ +/* + * 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.types; + +import java.util.Objects; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.pcepio.protocol.PcepVersion; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.google.common.base.MoreObjects; + +/** + * Provides Administrative Group Tlv which contains value (32 Bit ). + */ +public class AdministrativeGroupTlv implements PcepValueType { + + /* REFERENCE :[RFC5305]/3.1 + * 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 + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Type=[TDB33] | Length=4 | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | value (32 Bit ) | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + */ + + protected static final Logger log = LoggerFactory.getLogger(AdministrativeGroupTlv.class); + + public static final short TYPE = 3; //TDB33 + public static final short LENGTH = 4; + + private final int rawValue; + + /** + * Constructor to initialize rawValue. + * + * @param rawValue of Administrative-Group-Tlv. + */ + public AdministrativeGroupTlv(int rawValue) { + this.rawValue = rawValue; + } + + /** + * Returns newly created AdministrativeGroupTlv object. + * + * @param raw value. + * @return object of Administrative-Group-Tlv + */ + public static AdministrativeGroupTlv of(final int raw) { + return new AdministrativeGroupTlv(raw); + } + + /** + * Returns raw value. + * + * @return rawValue raw value + */ + public int getInt() { + return rawValue; + } + + @Override + public PcepVersion getVersion() { + return PcepVersion.PCEP_1; + } + + @Override + public short getType() { + return TYPE; + } + + @Override + public short getLength() { + return LENGTH; + } + + @Override + public int hashCode() { + return Objects.hash(rawValue); + } + + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + if (obj instanceof AdministrativeGroupTlv) { + AdministrativeGroupTlv other = (AdministrativeGroupTlv) obj; + return Objects.equals(rawValue, other.rawValue); + } + return false; + } + + @Override + public int write(ChannelBuffer c) { + int iLenStartIndex = c.writerIndex(); + c.writeShort(TYPE); + c.writeShort(LENGTH); + c.writeInt(rawValue); + return c.writerIndex() - iLenStartIndex; + } + + /** + * Reads the channel buffer and returns object of Administrative-Group-Tlv. + * + * @param c input channel buffer + * @return object of Administrative-Group-Tlv + */ + public static AdministrativeGroupTlv read(ChannelBuffer c) { + return AdministrativeGroupTlv.of(c.readInt()); + } + + @Override + public String toString() { + return MoreObjects.toStringHelper(getClass()) + .add("Type", TYPE) + .add("Length", LENGTH) + .add("Value", rawValue) + .toString(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/AutonomousSystemTlv.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/AutonomousSystemTlv.java new file mode 100644 index 00000000..3f213191 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/AutonomousSystemTlv.java @@ -0,0 +1,136 @@ +/* + * 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.types; + +import java.util.Objects; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.pcepio.protocol.PcepVersion; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.google.common.base.MoreObjects; + +/** + * Provides Autonomous-System-Tlv which contains opaque value (32 Bit AS Number). + */ +public class AutonomousSystemTlv implements PcepValueType { + + /* Reference :RFC3209 + * 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 + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Type=[TBD10] | Length=4 | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | opaque value (32 Bit AS Number) | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + */ + + protected static final Logger log = LoggerFactory.getLogger(AutonomousSystemTlv.class); + + public static final short TYPE = 100; //TODD:change this TBD10 + public static final short LENGTH = 4; + + private final int rawValue; + + /** + * Constructor to initialize rawValue. + * + * @param rawValue Autonomous-System-Tlv + */ + public AutonomousSystemTlv(int rawValue) { + this.rawValue = rawValue; + } + + /** + * Returns newly created AutonomousSystemTlv object. + * + * @param raw value of opaque. + * @return object of Autonomous-System-Tlv + */ + public static AutonomousSystemTlv of(final int raw) { + return new AutonomousSystemTlv(raw); + } + + /** + * Returns opaque value. + * + * @return rawValue opaque value. + */ + public int getInt() { + return rawValue; + } + + @Override + public PcepVersion getVersion() { + return PcepVersion.PCEP_1; + } + + @Override + public short getType() { + return TYPE; + } + + @Override + public short getLength() { + return LENGTH; + } + + @Override + public int hashCode() { + return Objects.hash(rawValue); + } + + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + if (obj instanceof AutonomousSystemTlv) { + AutonomousSystemTlv other = (AutonomousSystemTlv) obj; + return Objects.equals(rawValue, other.rawValue); + } + return false; + } + + @Override + public int write(ChannelBuffer c) { + int iLenStartIndex = c.writerIndex(); + c.writeShort(TYPE); + c.writeShort(LENGTH); + c.writeInt(rawValue); + return c.writerIndex() - iLenStartIndex; + } + + /** + * Reads the channel buffer and returns object of AutonomousSystemTlv. + * + * @param c input channel buffer + * @return object of Autonomous-System-Tlv + */ + public static AutonomousSystemTlv read(ChannelBuffer c) { + return AutonomousSystemTlv.of(c.readInt()); + } + + @Override + public String toString() { + return MoreObjects.toStringHelper(getClass()) + .add("TYPE", TYPE) + .add("Length", LENGTH) + .add("value", rawValue) + .toString(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/BGPLSidentifierTlv.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/BGPLSidentifierTlv.java new file mode 100644 index 00000000..4981649f --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/BGPLSidentifierTlv.java @@ -0,0 +1,136 @@ +/* + * 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.types; + +import java.util.Objects; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.pcepio.protocol.PcepVersion; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.google.common.base.MoreObjects; + +/** + * Provides BGP LS identifier which contains opaque value (32 Bit ID). + */ +public class BGPLSidentifierTlv implements PcepValueType { + + /* Reference :draft-ietf-idr-ls-distribution-10 + * 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 + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Type=[TBD11] | Length=4 | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | opaque value (32 Bit ID). | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + */ + + protected static final Logger log = LoggerFactory.getLogger(BGPLSidentifierTlv.class); + + public static final short TYPE = 17; //TODD:change this TBD11 + public static final short LENGTH = 4; + + private final int rawValue; + + /** + * constructor to initialize rawValue. + * + * @param rawValue BGP LS identifier Tlv + */ + public BGPLSidentifierTlv(int rawValue) { + this.rawValue = rawValue; + } + + /** + * Returns newly created BGPLSidentifierTlv object. + * + * @param raw value + * @return object of BGPLSidentifierTlv + */ + public static BGPLSidentifierTlv of(final int raw) { + return new BGPLSidentifierTlv(raw); + } + + /** + * Returns opaque value. + * + * @return rawValue opaque value + */ + public int getInt() { + return rawValue; + } + + @Override + public PcepVersion getVersion() { + return PcepVersion.PCEP_1; + } + + @Override + public short getType() { + return TYPE; + } + + @Override + public short getLength() { + return LENGTH; + } + + @Override + public int hashCode() { + return Objects.hash(rawValue); + } + + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + if (obj instanceof BGPLSidentifierTlv) { + BGPLSidentifierTlv other = (BGPLSidentifierTlv) obj; + return Objects.equals(rawValue, other.rawValue); + } + return false; + } + + @Override + public int write(ChannelBuffer c) { + int iLenStartIndex = c.writerIndex(); + c.writeShort(TYPE); + c.writeShort(LENGTH); + c.writeInt(rawValue); + return c.writerIndex() - iLenStartIndex; + } + + /** + * Reads the channel buffer and returns object of BGPLSidentifierTlv. + * + * @param c input channel buffer + * @return object of BGP LS identifier Tlv + */ + public static BGPLSidentifierTlv read(ChannelBuffer c) { + return BGPLSidentifierTlv.of(c.readInt()); + } + + @Override + public String toString() { + return MoreObjects.toStringHelper(getClass()) + .add("Type", TYPE) + .add("Length", LENGTH) + .add("Value", rawValue) + .toString(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/ErrorObjListWithOpen.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/ErrorObjListWithOpen.java new file mode 100644 index 00000000..40f89f4c --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/ErrorObjListWithOpen.java @@ -0,0 +1,160 @@ +/* + * 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.types; + +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.PcepErrorObject; +import org.onosproject.pcepio.protocol.PcepOpenObject; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.google.common.base.MoreObjects; + +/** + * Provide the error object list with open object. + */ +public class ErrorObjListWithOpen { + //errorObjList is mandatory + private LinkedList<PcepErrorObject> llerrorObjList; + // openObject is optional + private PcepOpenObject openObject; + // flag to check if open object is set or not + private boolean isOpenObjectSet; + protected static final Logger log = LoggerFactory.getLogger(ErrorObjListWithOpen.class); + + /** + * Constructor to initialize Error and OPEN object. + * + * @param errObj ERROR object list + * @param openObj OPEN object + */ + public ErrorObjListWithOpen(LinkedList<PcepErrorObject> errObj, PcepOpenObject openObj) { + this.llerrorObjList = errObj; + this.openObject = openObj; + if (openObj != null) { + isOpenObjectSet = true; + } else { + isOpenObjectSet = false; + } + } + + /** + * Constructor to initialize ERROR Object. + * + * @param errObj ERROR Object list + */ + public ErrorObjListWithOpen(LinkedList<PcepErrorObject> errObj) { + this.llerrorObjList = errObj; + this.openObject = null; + isOpenObjectSet = false; + } + + /** + * Return list of Error Types. + * + * @return error types list + */ + public LinkedList<Integer> getErrorType() { + LinkedList<Integer> errorType = new LinkedList<>(); + if (llerrorObjList != null) { + ListIterator<PcepErrorObject> errObjListIterator = llerrorObjList.listIterator(); + int error; + PcepErrorObject errorObj; + while (errObjListIterator.hasNext()) { + errorObj = errObjListIterator.next(); + error = errorObj.getErrorType(); + errorType.add(error); + } + } + return errorType; + } + + /** + * Return list of Error Values. + * + * @return error values list + */ + public LinkedList<Integer> getErrorValue() { + LinkedList<Integer> errorValue = new LinkedList<>(); + if (llerrorObjList != null) { + ListIterator<PcepErrorObject> errObjListIterator = llerrorObjList.listIterator(); + int error; + PcepErrorObject errorObj; + while (errObjListIterator.hasNext()) { + errorObj = errObjListIterator.next(); + error = errorObj.getErrorValue(); + errorValue.add(error); + } + } + return errorValue; + } + + /** + * Checks whether ERROR Object list is empty or not. + * + * @return true if ERROR Object list is empty otherwise false + */ + public boolean isErrorObjListWithOpenPresent() { + // ( <error-obj-list> [<Open>] + // At least in this case <error-obj-list> should be present. + return !this.llerrorObjList.isEmpty(); + } + + /** + * Write Error Object List and Open Object to channel buffer. + * + * @param cb output channel buffer + * @return length of written Error object list with open + * @throws PcepParseException when mandatory fields are not set + */ + public int write(ChannelBuffer cb) throws PcepParseException { + int iLenStartIndex = cb.writerIndex(); + boolean bIsErrObjListFound = false; + + //<error-obj-list> is mandatory , if not present throw exception. + if (llerrorObjList != null) { + ListIterator<PcepErrorObject> errObjListIterator = llerrorObjList.listIterator(); + while (errObjListIterator.hasNext()) { + errObjListIterator.next().write(cb); + bIsErrObjListFound = true; + } + } + + if (!bIsErrObjListFound) { + throw new PcepParseException("<error-obj-list> is mandatory."); + } + + //Open Object is optional , if present write. + if (openObject != null) { + openObject.write(cb); + } + + return cb.writerIndex() - iLenStartIndex; + } + + @Override + public String toString() { + return MoreObjects.toStringHelper(getClass()) + .omitNullValues() + .add("ErrorObjList", llerrorObjList) + .add("Open", openObject) + .toString(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/GmplsCapabilityTlv.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/GmplsCapabilityTlv.java new file mode 100644 index 00000000..212aa3d3 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/GmplsCapabilityTlv.java @@ -0,0 +1,138 @@ +/* + * 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.types; + +import java.util.Objects; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.pcepio.protocol.PcepVersion; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.google.common.base.MoreObjects; + +/** + * Provides GMPLS Capability Tlv. + */ +public class GmplsCapabilityTlv implements PcepValueType { + + /* + * GMPLS-CAPABILITY TLV format + * reference :draft-ietf-pce-gmpls-pcep-extensions -2.1.1 + 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 + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Type=14 | Length | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Flags | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + */ + protected static final Logger log = LoggerFactory.getLogger(GmplsCapabilityTlv.class); + + public static final short TYPE = 14; + public static final short LENGTH = 4; + + private final int rawValue; + + /** + * Constructor to initialize raw value. + * + * @param rawValue of Gmpls-Capability-Tlv + */ + public GmplsCapabilityTlv(int rawValue) { + this.rawValue = rawValue; + } + + /** + * Returns newly created GmplsCapabilityTlv object. + * + * @param raw Flags value + * @return object of Gmpls-Capability-Tlv + */ + public static GmplsCapabilityTlv of(final int raw) { + return new GmplsCapabilityTlv(raw); + } + + /** + * Returns value of Flags. + * + * @return rawValue Flags + */ + public int getInt() { + return rawValue; + } + + @Override + public PcepVersion getVersion() { + return PcepVersion.PCEP_1; + } + + @Override + public short getType() { + return TYPE; + } + + @Override + public short getLength() { + return LENGTH; + } + + @Override + public int hashCode() { + return Objects.hash(rawValue); + } + + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + if (obj instanceof GmplsCapabilityTlv) { + GmplsCapabilityTlv other = (GmplsCapabilityTlv) obj; + return Objects.equals(rawValue, other.rawValue); + } + return false; + } + + @Override + public int write(ChannelBuffer c) { + int iLenStartIndex = c.writerIndex(); + c.writeShort(TYPE); + c.writeShort(LENGTH); + c.writeInt(rawValue); + return c.writerIndex() - iLenStartIndex; + } + + /** + * Reads the channel buffer and returns object of Gmpls-Capability-Tlv. + * + * @param c input channel buffer + * @return object of Gmpls-Capability-Tlv + */ + public static GmplsCapabilityTlv read(ChannelBuffer c) { + return GmplsCapabilityTlv.of(c.readInt()); + } + + @Override + public String toString() { + return MoreObjects.toStringHelper(getClass()) + .add("Type", TYPE) + .add("Length", LENGTH) + .add("Value", rawValue) + .toString(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/IGPMetricTlv.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/IGPMetricTlv.java new file mode 100644 index 00000000..07cfea7f --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/IGPMetricTlv.java @@ -0,0 +1,150 @@ +/* + * 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.types; + +import java.util.Arrays; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.pcepio.protocol.PcepVersion; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.google.common.base.MoreObjects; +import com.google.common.base.MoreObjects.ToStringHelper; + +/** + * Provides IGP Link Metric . + */ +public class IGPMetricTlv implements PcepValueType { + + /* Reference :[I-D.ietf-idr-ls-distribution] /3.3.2.4 + * 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 + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Type=TDB40 | Length | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + // IGP Link Metric (variable length) // + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + */ + + protected static final Logger log = LoggerFactory.getLogger(IGPMetricTlv.class); + + public static final short TYPE = 1095; //TODO:NEED TO HANDLE TDB40 + private short hLength; + + private final byte[] rawValue; + + /** + * Constructor to initialize raw value. + * + * @param rawValue IGP Link Metric + * @param hLength length + */ + public IGPMetricTlv(byte[] rawValue, short hLength) { + this.rawValue = rawValue; + this.hLength = hLength; + } + + /** + * Returns newly created IGPMetricTlv object. + * + * @param raw value of IGP Link Metric + * @param hLength length + * @return object of IGPMetricTlv + */ + public static IGPMetricTlv of(final byte[] raw, short hLength) { + return new IGPMetricTlv(raw, hLength); + } + + /** + * Returns value of IGP Link Metric. + * + * @return rawValue of IGP Link Metric + */ + public byte[] getValue() { + return rawValue; + } + + @Override + public PcepVersion getVersion() { + return PcepVersion.PCEP_1; + } + + @Override + public short getType() { + return TYPE; + } + + @Override + public short getLength() { + return hLength; + } + + @Override + public int hashCode() { + return Arrays.hashCode(rawValue); + } + + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + if (obj instanceof IGPMetricTlv) { + IGPMetricTlv other = (IGPMetricTlv) obj; + return Arrays.equals(rawValue, other.rawValue); + } + return false; + } + + @Override + public int write(ChannelBuffer c) { + int iLenStartIndex = c.writerIndex(); + c.writeShort(TYPE); + c.writeShort(hLength); + c.writeBytes(rawValue); + return c.writerIndex() - iLenStartIndex; + } + + /** + * Reads the channel buffer and returns object of IGPMetricTlv. + * + * @param c input channel buffer + * @param hLength length + * @return object of IGPMetricTlv + */ + public static PcepValueType read(ChannelBuffer c, short hLength) { + byte[] iIGPMetric = new byte[hLength]; + c.readBytes(iIGPMetric, 0, hLength); + return new IGPMetricTlv(iIGPMetric, hLength); + } + + @Override + public String toString() { + ToStringHelper toStrHelper = MoreObjects.toStringHelper(getClass()); + + toStrHelper.add("Type", TYPE); + toStrHelper.add("Length", hLength); + + StringBuffer result = new StringBuffer(); + for (byte b : rawValue) { + result.append(String.format("%02X ", b)); + } + toStrHelper.add("Value", result); + + return toStrHelper.toString(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/IPv4InterfaceAddressTlv.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/IPv4InterfaceAddressTlv.java new file mode 100644 index 00000000..d1a30157 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/IPv4InterfaceAddressTlv.java @@ -0,0 +1,137 @@ +/* + * 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.types; + +import java.util.Objects; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.pcepio.protocol.PcepVersion; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.google.common.base.MoreObjects; + +/** + * Provides IPv4 Interface Address . + */ +public class IPv4InterfaceAddressTlv implements PcepValueType { + + /* + * reference :[RFC5305]/3.2 + 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 + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Type=6 | Length=4 | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | IPv4 Interface Address | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + */ + + protected static final Logger log = LoggerFactory.getLogger(IPv4InterfaceAddressTlv.class); + + public static final short TYPE = 6; + public static final short LENGTH = 4; + + private final int rawValue; + + /** + * Constructor to initialize rawValue. + * + * @param rawValue of IPv4-Interface-Address. + */ + public IPv4InterfaceAddressTlv(int rawValue) { + this.rawValue = rawValue; + } + + /** + * Returns newly created IPv4InterfaceAddressTlv object. + * + * @param raw value of IPv4-Interface-Address + * @return object of IPv4-Interface-Address-Tlv + */ + public static IPv4InterfaceAddressTlv of(final int raw) { + return new IPv4InterfaceAddressTlv(raw); + } + + /** + * Returns value of IPv4 Interface Address. + * + * @return rawValue IPv4 Interface Address + */ + public int getInt() { + return rawValue; + } + + @Override + public PcepVersion getVersion() { + return PcepVersion.PCEP_1; + } + + @Override + public short getType() { + return TYPE; + } + + @Override + public short getLength() { + return LENGTH; + } + + @Override + public int hashCode() { + return Objects.hash(rawValue); + } + + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + if (obj instanceof IPv4InterfaceAddressTlv) { + IPv4InterfaceAddressTlv other = (IPv4InterfaceAddressTlv) obj; + return Objects.equals(rawValue, other.rawValue); + } + return false; + } + + @Override + public int write(ChannelBuffer c) { + int iLenStartIndex = c.writerIndex(); + c.writeShort(TYPE); + c.writeShort(LENGTH); + c.writeInt(rawValue); + return c.writerIndex() - iLenStartIndex; + } + + /** + * Reads the channel buffer and returns object of IPv4InterfaceAddressTlv. + * + * @param c input channel buffer + * @return object of IPv4-Interface-Address-Tlv + */ + public static IPv4InterfaceAddressTlv read(ChannelBuffer c) { + return IPv4InterfaceAddressTlv.of(c.readInt()); + } + + @Override + public String toString() { + return MoreObjects.toStringHelper(getClass()) + .add("Type", TYPE) + .add("Length", LENGTH) + .add("Value", rawValue) + .toString(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/IPv4NeighborAddressTlv.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/IPv4NeighborAddressTlv.java new file mode 100644 index 00000000..0f98777f --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/IPv4NeighborAddressTlv.java @@ -0,0 +1,137 @@ +/* + * 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.types; + +import java.util.Objects; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.pcepio.protocol.PcepVersion; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.google.common.base.MoreObjects; + +/** + * Provides IPv4 Neighbor Address . + */ +public class IPv4NeighborAddressTlv implements PcepValueType { + + /* Reference :[RFC5305]/3.3 + 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 + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Type=8 | Length=4 | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | IPv4 Neighbor Address | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + */ + + protected static final Logger log = LoggerFactory.getLogger(IPv4NeighborAddressTlv.class); + + public static final short TYPE = 8; + public static final short LENGTH = 4; + + private final int rawValue; + + /** + * Constructor to initialize rawValue. + * + * @param rawValue IPv4-Neighbor-Address-Tlv + */ + public IPv4NeighborAddressTlv(int rawValue) { + log.debug("IPv4NeighborAddressTlv"); + this.rawValue = rawValue; + } + + /** + * Returns newly created IPv4NeighborAddressTlv object. + * + * @param raw value of IPv4-Neighbor-Address + * @return object of IPv4NeighborAddressTlv + */ + public static IPv4NeighborAddressTlv of(final int raw) { + return new IPv4NeighborAddressTlv(raw); + } + + /** + * Returns value of IPv4 Neighbor Address. + * + * @return rawValue IPv4 Neighbor Address + */ + public int getInt() { + return rawValue; + } + + @Override + public PcepVersion getVersion() { + return PcepVersion.PCEP_1; + } + + @Override + public short getType() { + return TYPE; + } + + @Override + public short getLength() { + return LENGTH; + } + + @Override + public int hashCode() { + return Objects.hash(rawValue); + } + + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + if (obj instanceof IPv4NeighborAddressTlv) { + IPv4NeighborAddressTlv other = (IPv4NeighborAddressTlv) obj; + return Objects.equals(rawValue, other.rawValue); + } + return false; + } + + @Override + public int write(ChannelBuffer c) { + int iLenStartIndex = c.writerIndex(); + c.writeShort(TYPE); + c.writeShort(LENGTH); + c.writeInt(rawValue); + return c.writerIndex() - iLenStartIndex; + } + + /** + * Reads the channel buffer and returns object of IPv4-Neighbor-Address-Tlv. + * + * @param c input channel buffer + * @return object of IPv4-Neighbor-Address-Tlv + */ + public static IPv4NeighborAddressTlv read(ChannelBuffer c) { + return IPv4NeighborAddressTlv.of(c.readInt()); + } + + @Override + public String toString() { + return MoreObjects.toStringHelper(getClass()) + .add("Type", TYPE) + .add("Length", LENGTH) + .add("Value", rawValue) + .toString(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/IPv4SubObject.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/IPv4SubObject.java new file mode 100644 index 00000000..031b5db6 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/IPv4SubObject.java @@ -0,0 +1,180 @@ +/* + * 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. + */ + +/** + * @author b00295750 + * + */ +package org.onosproject.pcepio.types; + +import java.util.Objects; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.pcepio.protocol.PcepVersion; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.google.common.base.MoreObjects; + +/** + * Provides IPv4 Sub Object. + */ +public class IPv4SubObject implements PcepValueType { + + /*Reference : RFC 4874:3.1.1 + * 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 + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + |L| Type | Length | IPv4 address (4 bytes) | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | IPv4 address (continued) | Prefix Length | Resvd | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + */ + protected static final Logger log = LoggerFactory.getLogger(IPv4SubObject.class); + + public static final byte TYPE = 0x01; + public static final byte LENGTH = 8; + public static final byte VALUE_LENGTH = 6; + public static final byte OBJ_LENGTH = 8; + public static final byte LBIT = 0; + public static final int SHIFT_LBIT_POSITION = 7; + private int ipAddress; + private byte prefixLen; + private byte resvd; + + /** + * Constructor to initialize ipv4 address. + * + * @param ipAddr ipv4 address + */ + public IPv4SubObject(int ipAddr) { + this.ipAddress = ipAddr; + } + + /** + * constructor to initialize ipAddress, prefixLen and resvd. + * + * @param ipAddress ipv4 address + * @param prefixLen prefix length + * @param resvd reserved flags value + */ + public IPv4SubObject(int ipAddress, byte prefixLen, byte resvd) { + this.ipAddress = ipAddress; + this.prefixLen = prefixLen; + this.resvd = resvd; + } + + /** + * Returns a new instance of IPv4SubObject. + * + * @param ipAddress ipv4 address + * @param prefixLen prefix length + * @param resvd reserved flags value + * @return object of IPv4SubObject + */ + public static IPv4SubObject of(int ipAddress, byte prefixLen, byte resvd) { + return new IPv4SubObject(ipAddress, prefixLen, resvd); + } + + /** + * Returns prefixLen of IPv4 IP address. + * + * @return byte value of rawValue + */ + public byte getPrefixLen() { + return prefixLen; + } + + /** + * Returns value of IPv4 IP address. + * + * @return int value of ipv4 address + */ + public int getIpAddress() { + return ipAddress; + } + + @Override + public PcepVersion getVersion() { + return PcepVersion.PCEP_1; + } + + @Override + public short getType() { + return TYPE; + } + + @Override + public short getLength() { + return LENGTH; + } + + @Override + public int hashCode() { + return Objects.hash(ipAddress, prefixLen, resvd); + } + + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + if (obj instanceof IPv4SubObject) { + IPv4SubObject other = (IPv4SubObject) obj; + return Objects.equals(this.ipAddress, other.ipAddress) && Objects.equals(this.prefixLen, other.prefixLen) + && Objects.equals(this.resvd, other.resvd); + } + return false; + } + + /** + * Reads the channel buffer and returns object of IPv4SubObject. + * + * @param c type of channel buffer + * @return object of IPv4SubObject + */ + public static PcepValueType read(ChannelBuffer c) { + int ipAddess = c.readInt(); + byte prefixLen = c.readByte(); + byte resvd = c.readByte(); + return new IPv4SubObject(ipAddess, prefixLen, resvd); + } + + @Override + public int write(ChannelBuffer c) { + int iLenStartIndex = c.writerIndex(); + byte bValue = LBIT; + bValue = (byte) (bValue << SHIFT_LBIT_POSITION); + bValue = (byte) (bValue | TYPE); + c.writeByte(bValue); + c.writeByte(OBJ_LENGTH); + c.writeInt(ipAddress); + c.writeByte(prefixLen); + c.writeByte(resvd); + + return c.writerIndex() - iLenStartIndex; + } + + @Override + public String toString() { + return MoreObjects.toStringHelper(getClass()) + .add("Type", TYPE) + .add("Length", LENGTH) + .add("IPv4Address", ipAddress) + .add("PrefixLength", prefixLen) + .toString(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/IPv4TERouterIdOfLocalNodeTlv.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/IPv4TERouterIdOfLocalNodeTlv.java new file mode 100644 index 00000000..2abf4cdc --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/IPv4TERouterIdOfLocalNodeTlv.java @@ -0,0 +1,136 @@ +/* + * 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.types; + +import java.util.Objects; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.pcepio.protocol.PcepVersion; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.google.common.base.MoreObjects; + +/** + * Provides IPv4 TE Router Id Of Local Node. + */ +public class IPv4TERouterIdOfLocalNodeTlv implements PcepValueType { + + /* Reference:[RFC5305]/4.3 + * 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 + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Type=[TDB25] | Length=4 | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | IPv4 TE Router Id Of Local Node | + +-+-+-+-+-+-+-+-+-++-+-+-+-+-+-+-+-+-++-+-+-+-+-+-+-+-+-++-+-+-+- + */ + + protected static final Logger log = LoggerFactory.getLogger(IPv4TERouterIdOfLocalNodeTlv.class); + + public static final short TYPE = 134; //TDB25 + public static final short LENGTH = 4; + + private final int rawValue; + + /** + * Constructor to initialize rawValue. + * + * @param rawValue IPv4-TE-RouterId-Of-Local-Node-Tlv + */ + public IPv4TERouterIdOfLocalNodeTlv(int rawValue) { + this.rawValue = rawValue; + } + + /** + * Returns newly created IPv4TERouterIdOfLocalNodeTlv object. + * + * @param raw value of IPv4-TE-RouterId-Of-Local-Node + * @return object of IPv4TERouterIdOfLocalNodeTlv + */ + public static IPv4TERouterIdOfLocalNodeTlv of(final int raw) { + return new IPv4TERouterIdOfLocalNodeTlv(raw); + } + + /** + * Returns value of IPv4 TE Router Id Of Local Node. + * + * @return rawValue IPv4 TE Router Id Of Local Node + */ + public int getInt() { + return rawValue; + } + + @Override + public PcepVersion getVersion() { + return PcepVersion.PCEP_1; + } + + @Override + public short getType() { + return TYPE; + } + + @Override + public short getLength() { + return LENGTH; + } + + @Override + public int hashCode() { + return Objects.hash(rawValue); + } + + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + if (obj instanceof IPv4TERouterIdOfLocalNodeTlv) { + IPv4TERouterIdOfLocalNodeTlv other = (IPv4TERouterIdOfLocalNodeTlv) obj; + return Objects.equals(rawValue, other.rawValue); + } + return false; + } + + @Override + public int write(ChannelBuffer c) { + int iLenStartIndex = c.writerIndex(); + c.writeShort(TYPE); + c.writeShort(LENGTH); + c.writeInt(rawValue); + return c.writerIndex() - iLenStartIndex; + } + + /** + * Reads the channel buffer and returns object of IPv4TERouterIdOfLocalNodeTlv. + * + * @param c input channel buffer + * @return object of IPv4TERouterIdOfLocalNodeTlv + */ + public static IPv4TERouterIdOfLocalNodeTlv read(ChannelBuffer c) { + return IPv4TERouterIdOfLocalNodeTlv.of(c.readInt()); + } + + @Override + public String toString() { + return MoreObjects.toStringHelper(getClass()) + .add("Type", TYPE) + .add("Length", LENGTH) + .add("Value", rawValue) + .toString(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/IPv4TERouterIdOfRemoteNodeTlv.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/IPv4TERouterIdOfRemoteNodeTlv.java new file mode 100644 index 00000000..21e09890 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/IPv4TERouterIdOfRemoteNodeTlv.java @@ -0,0 +1,137 @@ +/* + * 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.types; + +import java.util.Objects; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.pcepio.protocol.PcepVersion; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.google.common.base.MoreObjects; + +/** + * Provides IPv4 TE Router Id Of Remote Node. + */ +public class IPv4TERouterIdOfRemoteNodeTlv implements PcepValueType { + + /* Reference :[RFC5305]/4.3 + * 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 + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Type=[TDB28] | Length=4 | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | IPv4 TE Router Id Of Remote Node | + +-+-+-+-+-+-+-+-+-++-+-+-+-+-+-+-+-+-++-+-+-+-+-+-+-+-+-++-+-+-+- + */ + + protected static final Logger log = LoggerFactory.getLogger(IPv4TERouterIdOfRemoteNodeTlv.class); + + public static final short TYPE = 1340; //TDB28 + public static final short LENGTH = 4; + + private final int rawValue; + + /** + * Constructor to initialize rawValue. + * + * @param rawValue IPv4 TE RouterId Of Remote Node Tlv + */ + public IPv4TERouterIdOfRemoteNodeTlv(int rawValue) { + log.debug("IPv4TERouterIdOfRemoteNodeTlv"); + this.rawValue = rawValue; + } + + /** + * Returns newly created IPv4TERouterIdOfRemoteNodeTlv object. + * + * @param raw IPv4 TE RouterId Of Remote Node + * @return object of IPv4TERouterIdOfRemoteNodeTlv + */ + public static IPv4TERouterIdOfRemoteNodeTlv of(final int raw) { + return new IPv4TERouterIdOfRemoteNodeTlv(raw); + } + + /** + * Returns value of IPv4 TE Router Id Of Remote Node. + * + * @return rawValue IPv4 TE Router Id Of Remote Node + */ + public int getInt() { + return rawValue; + } + + @Override + public PcepVersion getVersion() { + return PcepVersion.PCEP_1; + } + + @Override + public short getType() { + return TYPE; + } + + @Override + public short getLength() { + return LENGTH; + } + + @Override + public int hashCode() { + return Objects.hash(rawValue); + } + + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + if (obj instanceof IPv4TERouterIdOfRemoteNodeTlv) { + IPv4TERouterIdOfRemoteNodeTlv other = (IPv4TERouterIdOfRemoteNodeTlv) obj; + return Objects.equals(rawValue, other.rawValue); + } + return false; + } + + @Override + public int write(ChannelBuffer c) { + int iLenStartIndex = c.writerIndex(); + c.writeShort(TYPE); + c.writeShort(LENGTH); + c.writeInt(rawValue); + return c.writerIndex() - iLenStartIndex; + } + + /** + * Reads the channel buffer and returns object of IPv4TERouterIdOfRemoteNodeTlv. + * + * @param c input channel buffer + * @return object of IPv4TERouterIdOfRemoteNodeTlv + */ + public static IPv4TERouterIdOfRemoteNodeTlv read(ChannelBuffer c) { + return IPv4TERouterIdOfRemoteNodeTlv.of(c.readInt()); + } + + @Override + public String toString() { + return MoreObjects.toStringHelper(getClass()) + .add("Type", TYPE) + .add("Length", LENGTH) + .add("Value", rawValue) + .toString(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/IPv6InterfaceAddressTlv.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/IPv6InterfaceAddressTlv.java new file mode 100644 index 00000000..62a5588d --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/IPv6InterfaceAddressTlv.java @@ -0,0 +1,181 @@ +/* + * 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.types; + +import java.util.Arrays; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.pcepio.protocol.PcepVersion; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.google.common.base.MoreObjects; +import com.google.common.base.MoreObjects.ToStringHelper; + +/** + * Provides IPv6 Interface Address. REFERENCE :[RFC6119]/4.2. + */ +public class IPv6InterfaceAddressTlv implements PcepValueType { + + protected static final Logger log = LoggerFactory.getLogger(IPv6InterfaceAddressTlv.class); + + public static final short TYPE = 12; //TDB18 + public static final short LENGTH = 20; + public static final byte VALUE_LENGTH = 18; + + private static final byte[] NONE_VAL = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; + public static final IPv6InterfaceAddressTlv NONE = new IPv6InterfaceAddressTlv(NONE_VAL); + + private static final byte[] NO_MASK_VAL = {(byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, + (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, + (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF}; + public static final IPv6InterfaceAddressTlv NO_MASK = new IPv6InterfaceAddressTlv(NO_MASK_VAL); + public static final IPv6InterfaceAddressTlv FULL_MASK = NONE; + + private final byte[] rawValue; + + /** + * Constructor to initialize rawValue. + * + * @param rawValue IPv6 Interface Address Tlv + */ + public IPv6InterfaceAddressTlv(byte[] rawValue) { + log.debug("IPv6InterfaceAddressTlv"); + this.rawValue = rawValue; + } + + /** + * Returns newly created IPv6InterfaceAddressTlv object. + * + * @param raw IPv6 Interface Address + * @return object of IPv6InterfaceAddressTlv + */ + public static IPv6InterfaceAddressTlv of(final byte[] raw) { + //check NONE_VAL + boolean bFoundNONE = true; + //value starts from 3rd byte. + for (int i = 2; i < 20; ++i) { + if (NONE_VAL[i] != raw[i]) { + bFoundNONE = false; + } + } + + if (bFoundNONE) { + return NONE; + } + + //check NO_MASK_VAL + boolean bFoundNoMask = true; + //value starts from 3rd byte. + for (int i = 2; i < 20; ++i) { + if (0xFF != raw[i]) { + bFoundNoMask = false; + } + } + if (bFoundNoMask) { + return NO_MASK; + } + + return new IPv6InterfaceAddressTlv(raw); + } + + /** + * Returns value of IPv6 Interface Address. + * + * @return rawValue raw value + */ + public byte[] getBytes() { + return rawValue; + } + + /** + * Returns value of IPv6 Interface Address. + * + * @return rawValue raw value + */ + public byte[] getValue() { + return rawValue; + } + + @Override + public PcepVersion getVersion() { + return PcepVersion.PCEP_1; + } + + @Override + public short getType() { + return TYPE; + } + + @Override + public short getLength() { + return LENGTH; + } + + @Override + public int hashCode() { + return Arrays.hashCode(rawValue); + } + + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + if (obj instanceof IPv6InterfaceAddressTlv) { + IPv6InterfaceAddressTlv other = (IPv6InterfaceAddressTlv) obj; + return Arrays.equals(rawValue, other.rawValue); + } + return false; + } + + @Override + public int write(ChannelBuffer c) { + int iLenStartIndex = c.writerIndex(); + c.writeShort(TYPE); + c.writeShort(LENGTH); + c.writeBytes(rawValue); + return c.writerIndex() - iLenStartIndex; + } + + /** + * Reads the channel buffer and returns object of IPv6InterfaceAddressTlv. + * + * @param c input channel buffer + * @return object of IPv6InterfaceAddressTlv + */ + public static IPv6InterfaceAddressTlv read20Bytes(ChannelBuffer c) { + byte[] yTemp = new byte[20]; + c.readBytes(yTemp, 0, 20); + return IPv6InterfaceAddressTlv.of(yTemp); + } + + @Override + public String toString() { + ToStringHelper toStrHelper = MoreObjects.toStringHelper(getClass()); + + toStrHelper.add("Type", TYPE); + toStrHelper.add("Length", LENGTH); + + StringBuffer result = new StringBuffer(); + for (byte b : rawValue) { + result.append(String.format("%02X ", b)); + } + toStrHelper.add("Value", result); + + return toStrHelper.toString(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/IPv6NeighborAddressTlv.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/IPv6NeighborAddressTlv.java new file mode 100644 index 00000000..fb9b98ac --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/IPv6NeighborAddressTlv.java @@ -0,0 +1,179 @@ +/* + * 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.types; + +import java.util.Arrays; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.pcepio.protocol.PcepVersion; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.google.common.base.MoreObjects; +import com.google.common.base.MoreObjects.ToStringHelper; + +/** + * Provides IPv6 Neighbor Address. Reference :[RFC6119]/4.3. + */ +public class IPv6NeighborAddressTlv implements PcepValueType { + protected static final Logger log = LoggerFactory.getLogger(IPv6NeighborAddressTlv.class); + + public static final short TYPE = 13; // TDB19 + public static final short LENGTH = 20; + public static final byte VALUE_LENGTH = 18; + + private static final byte[] NONE_VAL = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; + public static final IPv6NeighborAddressTlv NONE = new IPv6NeighborAddressTlv(NONE_VAL); + + private static final byte[] NO_MASK_VAL = {(byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, + (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, + (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF}; + public static final IPv6NeighborAddressTlv NO_MASK = new IPv6NeighborAddressTlv(NO_MASK_VAL); + public static final IPv6NeighborAddressTlv FULL_MASK = NONE; + + private final byte[] rawValue; + + /** + * Constructor to initialize rawValue. + * + * @param rawValue IPv6 Neighbor Address Tlv + */ + public IPv6NeighborAddressTlv(byte[] rawValue) { + this.rawValue = rawValue; + } + + /** + * Returns newly created IPv6NeighborAddressTlv object. + * + * @param raw IPv6 Neighbor Address + * @return object of IPv6 Neighbor Address Tlv + */ + public static IPv6NeighborAddressTlv of(final byte[] raw) { + //check NONE_VAL + boolean bFoundNONE = true; + //value starts from 3rd byte. + for (int i = 2; i < 20; ++i) { + if (NONE_VAL[i] != raw[i]) { + bFoundNONE = false; + } + } + + if (bFoundNONE) { + return NONE; + } + + //check NO_MASK_VAL + boolean bFoundNoMask = true; + //value starts from 3rd byte. + for (int i = 2; i < 20; ++i) { + if (0xFF != raw[i]) { + bFoundNoMask = false; + } + } + if (bFoundNoMask) { + return NO_MASK; + } + + return new IPv6NeighborAddressTlv(raw); + } + + /** + * Returns value of IPv6 Neighbor Address. + * + * @return rawValue raw value + */ + public byte[] getBytes() { + return rawValue; + } + + /** + * Returns value of IPv6 Neighbor Address. + * + * @return rawValue raw value + */ + public byte[] getValue() { + return rawValue; + } + + @Override + public PcepVersion getVersion() { + return PcepVersion.PCEP_1; + } + + @Override + public short getType() { + return TYPE; + } + + @Override + public short getLength() { + return LENGTH; + } + + @Override + public int hashCode() { + return Arrays.hashCode(rawValue); + } + + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + if (obj instanceof IPv6NeighborAddressTlv) { + IPv6NeighborAddressTlv other = (IPv6NeighborAddressTlv) obj; + return Arrays.equals(rawValue, other.rawValue); + } + return false; + } + + @Override + public int write(ChannelBuffer c) { + int iStartIndex = c.writerIndex(); + c.writeShort(TYPE); + c.writeShort(LENGTH); + c.writeBytes(rawValue); + return c.writerIndex() - iStartIndex; + } + + /** + * Reads the channel buffer and returns object of IPv6NeighborAddressTlv. + * + * @param c input channel buffer + * @return object of IPv6NeighborAddressTlv + */ + public static IPv6NeighborAddressTlv read20Bytes(ChannelBuffer c) { + byte[] yTemp = new byte[20]; + c.readBytes(yTemp, 0, 20); + return IPv6NeighborAddressTlv.of(yTemp); + } + + @Override + public String toString() { + ToStringHelper toStrHelper = MoreObjects.toStringHelper(getClass()); + + toStrHelper.add("Type", TYPE); + toStrHelper.add("Length", LENGTH); + + StringBuffer result = new StringBuffer(); + for (byte b : rawValue) { + result.append(String.format("%02X ", b)); + } + toStrHelper.add("Value", result); + + return toStrHelper.toString(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/IPv6SubObject.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/IPv6SubObject.java new file mode 100644 index 00000000..b3164f26 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/IPv6SubObject.java @@ -0,0 +1,222 @@ +/* + * 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.types; + +import java.util.Arrays; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.pcepio.protocol.PcepVersion; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.google.common.base.MoreObjects; +import com.google.common.base.MoreObjects.ToStringHelper; + +/** + * Provides IPv6 Sub Object. + */ +public class IPv6SubObject implements PcepValueType { + + /* reference :RFC 4874. + Subobject : IPv6 address + + 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 + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Type | Length | IPv6 address (16 bytes) | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | IPv6 address (continued) | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | IPv6 address (continued) | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | IPv6 address (continued) | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | IPv6 address (continued) | Prefix Length | Flags | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + + Type + + 0x02 IPv6 address + + Length + + The Length contains the total length of the subobject in bytes, + including the Type and Length fields. The Length is always 20. + + IPv6 address + + A 128-bit unicast host address. + + Prefix length + + 128 + + Flags + + 0x01 Local protection available + + Indicates that the link downstream of this node is + protected via a local repair mechanism. This flag can + only be set if the Local protection flag was set in the + SESSION_ATTRIBUTE object of the corresponding Path + message. + + 0x02 Local protection in use + + Indicates that a local repair mechanism is in use to + maintain this tunnel (usually in the face of an outage + of the link it was previously routed over). + */ + protected static final Logger log = LoggerFactory.getLogger(IPv6SubObject.class); + + public static final short TYPE = 0x02; + public static final short LENGTH = 20; + public static final byte VALUE_LENGTH = 18; + + private static final byte[] NONE_VAL = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }; + public static final IPv6SubObject NONE = new IPv6SubObject(NONE_VAL); + + private static final byte[] NO_MASK_VAL = {(byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, + (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, + (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF }; + public static final IPv6SubObject NO_MASK = new IPv6SubObject(NO_MASK_VAL); + public static final IPv6SubObject FULL_MASK = NONE; + + private final byte[] rawValue; + + /** + * constructor to initialize rawValue with ipv6 address. + * + * @param rawValue ipv6 address + */ + public IPv6SubObject(byte[] rawValue) { + this.rawValue = rawValue; + } + + /** + * To create instance of IPv6SubObject. + * + * @param raw byte array of ipv6 address + * @return object of IPv6SubObject + */ + public static IPv6SubObject of(final byte[] raw) { + //check NONE_VAL + boolean bFoundNONE = true; + //value starts from 3rd byte. + for (int i = 2; i < 20; ++i) { + if (NONE_VAL[i] != raw[i]) { + bFoundNONE = false; + } + } + + if (bFoundNONE) { + return NONE; + } + + //check NO_MASK_VAL + boolean bFoundNoMask = true; + //value starts from 3rd byte. + for (int i = 2; i < 20; ++i) { + if (0xFF != raw[i]) { + bFoundNoMask = false; + } + } + if (bFoundNoMask) { + return NO_MASK; + } + + return new IPv6SubObject(raw); + } + + /** + * Returns value of IPv6 Sub Object. + * + * @return byte array of ipv6 address + */ + public byte[] getValue() { + return rawValue; + } + + @Override + public PcepVersion getVersion() { + return PcepVersion.PCEP_1; + } + + @Override + public short getType() { + return TYPE; + } + + @Override + public short getLength() { + return LENGTH; + } + + @Override + public int hashCode() { + return Arrays.hashCode(rawValue); + } + + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + if (obj instanceof IPv6SubObject) { + IPv6SubObject other = (IPv6SubObject) obj; + return Arrays.equals(rawValue, other.rawValue); + } + return false; + } + + @Override + public int write(ChannelBuffer c) { + int iStartIndex = c.writerIndex(); + c.writeShort(TYPE); + c.writeShort(LENGTH); + c.writeBytes(rawValue); + return c.writerIndex() - iStartIndex; + } + + /** + * Reads the channel buffer and returns object of IPv6SubObject. + * + * @param c type of channel buffer + * @return object of IPv6SubObject + */ + public static IPv6SubObject read20Bytes(ChannelBuffer c) { + byte[] yTemp = new byte[20]; + c.readBytes(yTemp, 0, 20); + return IPv6SubObject.of(yTemp); + } + + @Override + public String toString() { + ToStringHelper toStrHelper = MoreObjects.toStringHelper(getClass()); + + toStrHelper.add("Type", TYPE); + toStrHelper.add("Length", LENGTH); + + StringBuffer result = new StringBuffer(); + for (byte b : rawValue) { + result.append(String.format("%02X ", b)); + } + toStrHelper.add("Value", result); + + return toStrHelper.toString(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/IPv6TERouterIdofLocalNodeTlv.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/IPv6TERouterIdofLocalNodeTlv.java new file mode 100644 index 00000000..f10d5e31 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/IPv6TERouterIdofLocalNodeTlv.java @@ -0,0 +1,179 @@ +/* + * 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.types; + +import java.util.Arrays; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.pcepio.protocol.PcepVersion; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.google.common.base.MoreObjects; +import com.google.common.base.MoreObjects.ToStringHelper; + +/** + * Provides IPv6 TE Router Id of Local Node. Reference :[RFC6119]/4.1. + */ +public class IPv6TERouterIdofLocalNodeTlv implements PcepValueType { + protected static final Logger log = LoggerFactory.getLogger(IPv6TERouterIdofLocalNodeTlv.class); + + public static final short TYPE = 140; //TDB26 + public static final short LENGTH = 20; + public static final byte VALUE_LENGTH = 18; + + private static final byte[] NONE_VAL = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }; + public static final IPv6TERouterIdofLocalNodeTlv NONE = new IPv6TERouterIdofLocalNodeTlv(NONE_VAL); + + private static final byte[] NO_MASK_VAL = {(byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, + (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, + (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF }; + public static final IPv6TERouterIdofLocalNodeTlv NO_MASK = new IPv6TERouterIdofLocalNodeTlv(NO_MASK_VAL); + public static final IPv6TERouterIdofLocalNodeTlv FULL_MASK = NONE; + + private final byte[] rawValue; + + /** + * Constructor to initialize rawValue. + * + * @param rawValue IPv6TERouterIdofLocalNodeTlv + */ + public IPv6TERouterIdofLocalNodeTlv(byte[] rawValue) { + this.rawValue = rawValue; + } + + /** + * Returns newly created IPv6TERouterIdofLocalNodeTlv object. + * + * @param raw IPv6 TE Router Id of Local Node + * @return object of IPv6TERouterIdofLocalNodeTlv + */ + public static IPv6TERouterIdofLocalNodeTlv of(final byte[] raw) { + //check NONE_VAL + boolean bFoundNONE = true; + //value starts from 3rd byte. + for (int i = 2; i < 20; ++i) { + if (NONE_VAL[i] != raw[i]) { + bFoundNONE = false; + } + } + + if (bFoundNONE) { + return NONE; + } + + //check NO_MASK_VAL + boolean bFoundNoMask = true; + //value starts from 3rd byte. + for (int i = 2; i < 20; ++i) { + if (0xFF != raw[i]) { + bFoundNoMask = false; + } + } + if (bFoundNoMask) { + return NO_MASK; + } + + return new IPv6TERouterIdofLocalNodeTlv(raw); + } + + /** + * Returns value of IPv6 TE Router Id of Local Node. + * + * @return byte array value of rawValue + */ + public byte[] getBytes() { + return rawValue; + } + + /** + * Returns value of IPv6 TE Router Id of Local Node. + * + * @return byte array value of rawValue + */ + public byte[] getValue() { + return rawValue; + } + + @Override + public PcepVersion getVersion() { + return PcepVersion.PCEP_1; + } + + @Override + public short getType() { + return TYPE; + } + + @Override + public short getLength() { + return LENGTH; + } + + @Override + public int hashCode() { + return Arrays.hashCode(rawValue); + } + + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + if (obj instanceof IPv6TERouterIdofLocalNodeTlv) { + IPv6TERouterIdofLocalNodeTlv other = (IPv6TERouterIdofLocalNodeTlv) obj; + return Arrays.equals(rawValue, other.rawValue); + } + return false; + } + + @Override + public int write(ChannelBuffer c) { + int iStartIndex = c.writerIndex(); + c.writeShort(TYPE); + c.writeShort(LENGTH); + c.writeBytes(rawValue); + return c.writerIndex() - iStartIndex; + } + + /** + * Reads the channel buffer and returns object of IPv6TERouterIdofLocalNodeTlv. + * + * @param c input channel buffer + * @return object of IPv6TERouterIdofLocalNodeTlv + */ + public static IPv6TERouterIdofLocalNodeTlv read20Bytes(ChannelBuffer c) { + byte[] yTemp = new byte[20]; + c.readBytes(yTemp, 0, 20); + return IPv6TERouterIdofLocalNodeTlv.of(yTemp); + } + + @Override + public String toString() { + ToStringHelper toStrHelper = MoreObjects.toStringHelper(getClass()); + + toStrHelper.add("Type", TYPE); + toStrHelper.add("Length", LENGTH); + + StringBuffer result = new StringBuffer(); + for (byte b : rawValue) { + result.append(String.format("%02X ", b)); + } + toStrHelper.add("Value", result); + + return toStrHelper.toString(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/IPv6TERouterIdofRemoteNodeTlv.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/IPv6TERouterIdofRemoteNodeTlv.java new file mode 100644 index 00000000..bf1d475e --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/IPv6TERouterIdofRemoteNodeTlv.java @@ -0,0 +1,171 @@ +/* + * 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.types; + +import java.util.Arrays; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.pcepio.protocol.PcepVersion; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.google.common.base.MoreObjects; +import com.google.common.base.MoreObjects.ToStringHelper; + +/** + * Provides IPv6 TE Router Id of Remote Node. Reference :[RFC6119]/4.1. + */ +public class IPv6TERouterIdofRemoteNodeTlv implements PcepValueType { + protected static final Logger log = LoggerFactory.getLogger(IPv6TERouterIdofRemoteNodeTlv.class); + + public static final short TYPE = 1400; //TDB29 + public static final short LENGTH = 20; + public static final byte VALUE_LENGTH = 18; + + private static final byte[] NONE_VAL = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; + public static final IPv6TERouterIdofRemoteNodeTlv NONE = new IPv6TERouterIdofRemoteNodeTlv(NONE_VAL); + + private static final byte[] NO_MASK_VAL = {(byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, + (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, + (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF}; + public static final IPv6TERouterIdofRemoteNodeTlv NO_MASK = new IPv6TERouterIdofRemoteNodeTlv(NO_MASK_VAL); + public static final IPv6TERouterIdofRemoteNodeTlv FULL_MASK = NONE; + + private final byte[] rawValue; + + /** + * constructor to initialize rawValue. + * + * @param rawValue IPv6TERouterIdofRemoteNodeTlv + */ + public IPv6TERouterIdofRemoteNodeTlv(byte[] rawValue) { + log.debug("IPv6TERouterIdofRemoteNodeTlv"); + this.rawValue = rawValue; + } + + /** + * Returns newly created IPv6TERouterIdofRemoteNodeTlv object. + * + * @param raw IPv6 TE Router Id of RemoteNode + * @return object of IPv6TERouterIdofRemoteNodeTlv + */ + public static IPv6TERouterIdofRemoteNodeTlv of(final byte[] raw) { + //check NONE_VAL + boolean bFoundNONE = true; + //value starts from 3rd byte. + for (int i = 2; i < 20; ++i) { + if (NONE_VAL[i] != raw[i]) { + bFoundNONE = false; + } + } + + if (bFoundNONE) { + return NONE; + } + + //check NO_MASK_VAL + boolean bFoundNoMask = true; + //value starts from 3rd byte. + for (int i = 2; i < 20; ++i) { + if (0xFF != raw[i]) { + bFoundNoMask = false; + } + } + if (bFoundNoMask) { + return NO_MASK; + } + + return new IPv6TERouterIdofRemoteNodeTlv(raw); + } + + /** + * Returns value of IPv6 TE Router Id of Remote Node. + * + * @return byte array value of rawValue + */ + public byte[] getBytes() { + return rawValue; + } + + @Override + public PcepVersion getVersion() { + return PcepVersion.PCEP_1; + } + + @Override + public short getType() { + return TYPE; + } + + @Override + public short getLength() { + return LENGTH; + } + + @Override + public int hashCode() { + return Arrays.hashCode(rawValue); + } + + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + if (obj instanceof IPv6TERouterIdofRemoteNodeTlv) { + IPv6TERouterIdofRemoteNodeTlv other = (IPv6TERouterIdofRemoteNodeTlv) obj; + return Arrays.equals(rawValue, other.rawValue); + } + return false; + } + + @Override + public int write(ChannelBuffer c) { + int iStartIndex = c.writerIndex(); + c.writeShort(TYPE); + c.writeShort(LENGTH); + c.writeBytes(rawValue); + return c.writerIndex() - iStartIndex; + } + + /** + * Reads the channel buffer and returns object of IPv6TERouterIdofRemoteNodeTlv. + * + * @param c input channel buffer + * @return object of IPv6TERouterIdofRemoteNodeTlv + */ + public static IPv6TERouterIdofRemoteNodeTlv read20Bytes(ChannelBuffer c) { + byte[] yTemp = new byte[20]; + c.readBytes(yTemp, 0, 20); + return IPv6TERouterIdofRemoteNodeTlv.of(yTemp); + } + + @Override + public String toString() { + ToStringHelper toStrHelper = MoreObjects.toStringHelper(getClass()); + + toStrHelper.add("Type", TYPE); + toStrHelper.add("Length", LENGTH); + + StringBuffer result = new StringBuffer(); + for (byte b : rawValue) { + result.append(String.format("%02X ", b)); + } + toStrHelper.add("Value", result); + + return toStrHelper.toString(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/ISISAreaIdentifierTlv.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/ISISAreaIdentifierTlv.java new file mode 100644 index 00000000..648dbb66 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/ISISAreaIdentifierTlv.java @@ -0,0 +1,155 @@ +/* + * 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.types; + +import java.util.Objects; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.pcepio.protocol.PcepVersion; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.google.common.base.MoreObjects; +import com.google.common.base.MoreObjects.ToStringHelper; + +/** + * Provides ISIS Area Identifier. + */ +public class ISISAreaIdentifierTlv implements PcepValueType { + + /* Reference :[I-D.ietf-idr- ls-distribution]/3.3.1.2 + * 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 + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Type=[TBD24] | Length | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + // Area Identifier (variable) // + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + */ + + protected static final Logger log = LoggerFactory.getLogger(ISISAreaIdentifierTlv.class); + + public static final short TYPE = 107; //TODO:NEED TO HANDLE TBD24 + private short hLength; + + private final byte[] rawValue; + + /** + * Constructor to initialize rawValue. + * + * @param rawValue ISIS-Area-Identifier + * @param hLength length + */ + public ISISAreaIdentifierTlv(byte[] rawValue, short hLength) { + log.debug("ISISAreaIdentifierTlv"); + this.rawValue = rawValue; + if (0 == hLength) { + this.hLength = (short) rawValue.length; + } else { + this.hLength = hLength; + } + } + + /** + * Returns newly created ISISAreaIdentifierTlv object. + * + * @param raw ISIS-Area-Identifier + * @param hLength length + * @return object of ISISAreaIdentifierTlv + */ + public static ISISAreaIdentifierTlv of(final byte[] raw, short hLength) { + return new ISISAreaIdentifierTlv(raw, hLength); + } + + /** + * Returns value of ISIS-Area-Identifier. + * + * @return byte array of rawValue + */ + public byte[] getValue() { + return rawValue; + } + + @Override + public PcepVersion getVersion() { + return PcepVersion.PCEP_1; + } + + @Override + public short getType() { + return TYPE; + } + + @Override + public short getLength() { + return hLength; + } + + @Override + public int hashCode() { + return Objects.hash(rawValue); + } + + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + if (obj instanceof ISISAreaIdentifierTlv) { + ISISAreaIdentifierTlv other = (ISISAreaIdentifierTlv) obj; + return Objects.equals(hLength, other.hLength) && Objects.equals(rawValue, other.rawValue); + } + return false; + } + + @Override + public int write(ChannelBuffer c) { + int iLenStartIndex = c.writerIndex(); + c.writeShort(TYPE); + c.writeShort(hLength); + c.writeBytes(rawValue); + return c.writerIndex() - iLenStartIndex; + } + + /** + * Reads the channel buffer and returns object of ISISAreaIdentifierTlv. + * + * @param c input channel buffer + * @param hLength length + * @return object of ISISAreaIdentifierTlv + */ + public static PcepValueType read(ChannelBuffer c, short hLength) { + byte[] iISISAreaIdentifier = new byte[hLength]; + c.readBytes(iISISAreaIdentifier, 0, hLength); + return new ISISAreaIdentifierTlv(iISISAreaIdentifier, hLength); + } + + @Override + public String toString() { + ToStringHelper toStrHelper = MoreObjects.toStringHelper(getClass()); + + toStrHelper.add("Type", TYPE); + toStrHelper.add("Length", hLength); + + StringBuffer result = new StringBuffer(); + for (byte b : rawValue) { + result.append(String.format("%02X ", b)); + } + toStrHelper.add("Value", result); + + return toStrHelper.toString(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/LabelSubObject.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/LabelSubObject.java new file mode 100644 index 00000000..5b1c2438 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/LabelSubObject.java @@ -0,0 +1,171 @@ +/* + * 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.types; + +import java.util.Objects; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.pcepio.protocol.PcepVersion; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.google.common.base.MoreObjects; + +/** + * LabelSubObject: Provides a LabelSubObject. + */ +public class LabelSubObject implements PcepValueType { + + /* Reference : RFC 3209 + * LABEL Sub Object + * + 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 + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Type | Length | Flags | C-Type | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Contents of Label Object | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + */ + protected static final Logger log = LoggerFactory.getLogger(LabelSubObject.class); + + public static final short TYPE = 0x03; + public static final short LENGTH = 8; + private final byte flags; + private final byte cType; + private final int contents; + + /** + * constructor to initialize parameters for LabelSubObject. + * + * @param flags flags + * @param cType C-Type + * @param contents Contents of label object + */ + public LabelSubObject(byte flags, byte cType, int contents) { + this.flags = flags; + this.cType = cType; + this.contents = contents; + } + + /** + * Return an object of LabelSubObject. + * + * @param flags flags + * @param cType C-type + * @param contents contents of label objects + * @return object of LabelSubObject + */ + public static LabelSubObject of(byte flags, byte cType, int contents) { + return new LabelSubObject(flags, cType, contents); + } + + /** + * Returns Flags. + * + * @return flags + */ + public byte getFlags() { + return flags; + } + + /** + * Returns cType. + * + * @return cType + */ + public byte getCtype() { + return cType; + } + + /** + * Returns contents. + * + * @return contents + */ + public int getContents() { + return contents; + } + + @Override + public PcepVersion getVersion() { + return PcepVersion.PCEP_1; + } + + @Override + public short getType() { + return TYPE; + } + + @Override + public short getLength() { + return LENGTH; + } + + @Override + public int hashCode() { + return Objects.hash(flags, cType, contents); + } + + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + if (obj instanceof LabelSubObject) { + LabelSubObject other = (LabelSubObject) obj; + return Objects.equals(this.flags, other.flags) && Objects.equals(this.cType, other.cType) + && Objects.equals(this.contents, other.contents); + } + return false; + } + + @Override + public int write(ChannelBuffer c) { + int iStartIndex = c.writerIndex(); + c.writeShort(TYPE); + c.writeShort(LENGTH); + c.writeByte(flags); + c.writeByte(cType); + c.writeByte(contents); + return c.writerIndex() - iStartIndex; + } + + /** + * Reads the channel buffer and returns object of LabelSubObject. + * + * @param c type of channel buffer + * @return object of LabelSubObject + */ + public static PcepValueType read(ChannelBuffer c) { + byte flags = c.readByte(); + byte cType = c.readByte(); + int contents = c.readInt(); + return new LabelSubObject(flags, cType, contents); + } + + @Override + public String toString() { + return MoreObjects.toStringHelper(getClass()) + .add("type", TYPE) + .add("Length", LENGTH) + .add("flags", flags) + .add("C-type", cType) + .add("contents", contents) + .toString(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/LinkLocalRemoteIdentifiersTlv.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/LinkLocalRemoteIdentifiersTlv.java new file mode 100644 index 00000000..5fa0a4c6 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/LinkLocalRemoteIdentifiersTlv.java @@ -0,0 +1,155 @@ +/* + * 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.types; + +import java.util.Objects; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.pcepio.protocol.PcepVersion; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.google.common.base.MoreObjects; + +/** + * Provides Local and remote Link Identifiers. + */ +public class LinkLocalRemoteIdentifiersTlv implements PcepValueType { + + /* Reference :RFC5307 + * 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 + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Type=4 | Length=8 | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Link Local Identifier | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Link Remote Identifier | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + + */ + protected static final Logger log = LoggerFactory.getLogger(LinkLocalRemoteIdentifiersTlv.class); + + public static final short TYPE = 4; + public static final short LENGTH = 8; + private final int iLinkLocalIdentifier; + private final int iLinkRemoteIdentifier; + + /** + * Constructor to initialize iLinkLocalIdentifier , iLinkRemoteIdentifier. + * + * @param iLinkLocalIdentifier Link Local identifier + * @param iLinkRemoteIdentifier Link Remote identifier + */ + public LinkLocalRemoteIdentifiersTlv(int iLinkLocalIdentifier, int iLinkRemoteIdentifier) { + this.iLinkLocalIdentifier = iLinkLocalIdentifier; + this.iLinkRemoteIdentifier = iLinkRemoteIdentifier; + } + + /** + * Retruns an object of Link Local Remote Identifiers Tlv. + * + * @param iLinkLocalIdentifier Link Local identifier + * @param iLinkRemoteIdentifier Link Remote identifier + * @return object of LinkLocalRemoteIdentifiersTlv + */ + public static LinkLocalRemoteIdentifiersTlv of(int iLinkLocalIdentifier, int iLinkRemoteIdentifier) { + return new LinkLocalRemoteIdentifiersTlv(iLinkLocalIdentifier, iLinkRemoteIdentifier); + } + + /** + * Returns Link-Local-Identifier. + * + * @return iLinkLocalIdentifier Link Local Identifier + */ + public int getLinkLocalIdentifier() { + return iLinkLocalIdentifier; + } + + /** + * Returns Link-Remote-Identifier. + * + * @return iLinkRemoteIdentifier Link Remote Identifier. + */ + public int getLinkRemoteIdentifier() { + return iLinkRemoteIdentifier; + } + + @Override + public PcepVersion getVersion() { + return PcepVersion.PCEP_1; + } + + @Override + public short getLength() { + return LENGTH; + } + + @Override + public short getType() { + return TYPE; + } + + @Override + public int hashCode() { + return Objects.hash(iLinkLocalIdentifier, iLinkRemoteIdentifier); + } + + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + if (obj instanceof LinkLocalRemoteIdentifiersTlv) { + LinkLocalRemoteIdentifiersTlv other = (LinkLocalRemoteIdentifiersTlv) obj; + return Objects.equals(iLinkLocalIdentifier, other.iLinkLocalIdentifier) + && Objects.equals(iLinkRemoteIdentifier, other.iLinkRemoteIdentifier); + } + return false; + } + + @Override + public int write(ChannelBuffer c) { + int iStartIndex = c.writerIndex(); + c.writeShort(TYPE); + c.writeShort(LENGTH); + c.writeInt(iLinkLocalIdentifier); + c.writeInt(iLinkRemoteIdentifier); + return c.writerIndex() - iStartIndex; + } + + /** + * Reads the channel buffer and returns object of LinkLocalRemoteIdentifiersTlv. + * + * @param c input channel buffer + * @return object of LinkLocalRemoteIdentifiersTlv + */ + public static PcepValueType read(ChannelBuffer c) { + int iLinkLocalIdentifier = c.readInt(); + int iLinkRemoteIdentifier = c.readInt(); + return new LinkLocalRemoteIdentifiersTlv(iLinkLocalIdentifier, iLinkRemoteIdentifier); + } + + @Override + public String toString() { + return MoreObjects.toStringHelper(getClass()) + .add("Type", TYPE) + .add("Length", LENGTH) + .add("LinkLocalIdentifier", iLinkLocalIdentifier) + .add("LinkRemoteIdentifier", iLinkRemoteIdentifier) + .toString(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/LinkNameTlv.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/LinkNameTlv.java new file mode 100644 index 00000000..aa0f11a7 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/LinkNameTlv.java @@ -0,0 +1,155 @@ +/* + * 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.types; + +import java.util.Objects; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.pcepio.protocol.PcepVersion; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.google.common.base.MoreObjects; +import com.google.common.base.MoreObjects.ToStringHelper; + +/** + * Provides the Link Name. + */ +public class LinkNameTlv implements PcepValueType { + + /* Reference :[I-D.ietf-idr- ls-distribution] /3.3.2.7 + * Link name tlv 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 + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Type=TDB43 | Length | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + // Link Name (variable) // + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + */ + + protected static final Logger log = LoggerFactory.getLogger(LinkNameTlv.class); + + public static final short TYPE = 1098; //TODO:NEED TO HANDLE TDB43 + private short hLength; + + private final byte[] rawValue; + + /** + * Constructor to initialize rawValue. + * + * @param rawValue Link-Name + * @param hLength length + */ + public LinkNameTlv(byte[] rawValue, short hLength) { + this.rawValue = rawValue; + if (0 == hLength) { + this.hLength = (short) rawValue.length; + } else { + this.hLength = hLength; + } + } + + /** + * Returns newly created LinkNameTlv object. + * + * @param raw Link-Name + * @param hLength length + * @return object of LinkNameTlv + */ + public static LinkNameTlv of(final byte[] raw, short hLength) { + return new LinkNameTlv(raw, hLength); + } + + /** + * Returns value of Link-Name. + * + * @return raw value + */ + public byte[] getValue() { + return rawValue; + } + + @Override + public PcepVersion getVersion() { + return PcepVersion.PCEP_1; + } + + @Override + public short getType() { + return TYPE; + } + + @Override + public short getLength() { + return hLength; + } + + @Override + public int hashCode() { + return Objects.hash(rawValue); + } + + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + if (obj instanceof LinkNameTlv) { + LinkNameTlv other = (LinkNameTlv) obj; + return Objects.equals(rawValue, other.rawValue); + } + return false; + } + + @Override + public int write(ChannelBuffer c) { + int iLenStartIndex = c.writerIndex(); + c.writeShort(TYPE); + c.writeShort(hLength); + c.writeBytes(rawValue); + return c.writerIndex() - iLenStartIndex; + } + + /** + * Reads the channel buffer and returns object of LinkNameTlv. + * + * @param c input channel buffer + * @param hLength length + * @return object of LinkNameTlv + */ + public static PcepValueType read(ChannelBuffer c, short hLength) { + byte[] linkName = new byte[hLength]; + c.readBytes(linkName, 0, hLength); + return new LinkNameTlv(linkName, hLength); + } + + @Override + public String toString() { + ToStringHelper toStrHelper = MoreObjects.toStringHelper(getClass()); + + toStrHelper.add("Type", TYPE); + toStrHelper.add("Length", hLength); + + StringBuffer result = new StringBuffer(); + for (byte b : rawValue) { + result.append(String.format("%02X ", b)); + } + toStrHelper.add("Value", result); + + return toStrHelper.toString(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/LinkProtectionTypeTlv.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/LinkProtectionTypeTlv.java new file mode 100644 index 00000000..a802d577 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/LinkProtectionTypeTlv.java @@ -0,0 +1,142 @@ +/* + * 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.types; + +import java.util.Objects; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.pcepio.protocol.PcepVersion; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.google.common.base.MoreObjects; + +/** + * Provide Link Protection Type. + */ + +public class LinkProtectionTypeTlv implements PcepValueType { + + /* Reference :[RFC5307]/1.2 + * 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 + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Type=[TDB38] | Length=2 | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + |Protection Cap | Reserved | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + */ + protected static final Logger log = LoggerFactory.getLogger(LinkProtectionTypeTlv.class); + + public static final short TYPE = 20; //TDB38 + public static final short LENGTH = 2; + private final byte protectionCap; + private final byte reserved; + + /** + * Constructor to initialize protectionCap. + * + * @param protectionCap Protection Cap + */ + public LinkProtectionTypeTlv(byte protectionCap) { + this.protectionCap = protectionCap; + this.reserved = 0; + } + + /** + * Constructor to initialize protectionCap, reserved. + * + * @param protectionCap Protection Cap + * @param reserved Reserved value + */ + public LinkProtectionTypeTlv(byte protectionCap, byte reserved) { + this.protectionCap = protectionCap; + this.reserved = reserved; + } + + /** + * Returns Protection Cap. + * + * @return protectionCap Protection Cap + */ + public byte getProtectionCap() { + return protectionCap; + } + + @Override + public PcepVersion getVersion() { + return PcepVersion.PCEP_1; + } + + @Override + public short getType() { + return TYPE; + } + + @Override + public short getLength() { + return LENGTH; + } + + @Override + public int hashCode() { + return Objects.hash(protectionCap, reserved); + } + + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + if (obj instanceof LinkProtectionTypeTlv) { + LinkProtectionTypeTlv other = (LinkProtectionTypeTlv) obj; + return Objects.equals(protectionCap, other.protectionCap) && Objects.equals(reserved, other.reserved); + } + + return false; + } + + @Override + public int write(ChannelBuffer c) { + int iLenStartIndex = c.writerIndex(); + c.writeShort(TYPE); + c.writeShort(LENGTH); + c.writeByte(protectionCap); + c.writeByte(reserved); + return c.writerIndex() - iLenStartIndex; + } + + /** + * Reads the channel buffer and returns object of LinkProtectionTypeTlv. + * + * @param c input channel buffer + * @return object of LinkProtectionTypeTlv + */ + public static PcepValueType read(ChannelBuffer c) { + byte protectionCap = c.readByte(); + byte reserved = c.readByte(); + return new LinkProtectionTypeTlv(protectionCap, reserved); + } + + @Override + public String toString() { + return MoreObjects.toStringHelper(getClass()) + .add("Type", TYPE) + .add("Length", LENGTH) + .add("ProtectionCap", protectionCap) + .toString(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/LocalTENodeDescriptorsTlv.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/LocalTENodeDescriptorsTlv.java new file mode 100644 index 00000000..b31dac2c --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/LocalTENodeDescriptorsTlv.java @@ -0,0 +1,246 @@ +/* + * 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.types; + +import java.util.Iterator; +import java.util.LinkedList; +import java.util.ListIterator; +import java.util.Objects; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.pcepio.exceptions.PcepParseException; +import org.onosproject.pcepio.protocol.PcepVersion; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.google.common.base.MoreObjects; + +/** + * Provides Local TE Node Descriptors TLV which contains Node Descriptor Sub-TLVs. + */ +public class LocalTENodeDescriptorsTlv implements PcepValueType { + + /* REFERENCE :draft-ietf-idr-ls-distribution-10 + * 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 + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Type=[TBD8] | Length | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | | + // Node Descriptor Sub-TLVs (variable) // + | | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + Note: Length is including header here. Refer Routing Universe TLV. + */ + + protected static final Logger log = LoggerFactory.getLogger(LocalTENodeDescriptorsTlv.class); + + public static final short TYPE = 1637; //TODD:change this TBD8 + public short hLength; + + public static final int TLV_HEADER_LENGTH = 4; + // Node Descriptor Sub-TLVs (variable) + private LinkedList<PcepValueType> llNodeDescriptorSubTLVs; + + /** + * Constructor to initialize llNodeDescriptorSubTLVs. + * + * @param llNodeDescriptorSubTLVs LinkedList of PcepValueType + */ + public LocalTENodeDescriptorsTlv(LinkedList<PcepValueType> llNodeDescriptorSubTLVs) { + this.llNodeDescriptorSubTLVs = llNodeDescriptorSubTLVs; + } + + /** + * Returns a new object of LocalTENodeDescriptorsTLV. + * + * @param llNodeDescriptorSubTLVs linked list of Node Descriptor Sub TLVs + * @return object of LocalTENodeDescriptorsTLV + */ + public static LocalTENodeDescriptorsTlv of(final LinkedList<PcepValueType> llNodeDescriptorSubTLVs) { + return new LocalTENodeDescriptorsTlv(llNodeDescriptorSubTLVs); + } + + /** + * Returns Linked List of tlvs. + * + * @return llNodeDescriptorSubTLVs linked list of Node Descriptor Sub TLV + */ + public LinkedList<PcepValueType> getllNodeDescriptorSubTLVs() { + return llNodeDescriptorSubTLVs; + } + + @Override + public PcepVersion getVersion() { + return PcepVersion.PCEP_1; + } + + @Override + public short getType() { + return TYPE; + } + + @Override + public short getLength() { + return hLength; + } + + @Override + public int hashCode() { + return Objects.hash(llNodeDescriptorSubTLVs.hashCode()); + } + + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + + /* + * Here we have a list of Tlv so to compare each sub tlv between the object + * we have to take a list iterator so one by one we can get each sub tlv object + * and can compare them. + * it may be possible that the size of 2 lists is not equal so we have to first check + * the size, if both are same then we should check for the subtlv objects otherwise + * we should return false. + */ + if (obj instanceof LocalTENodeDescriptorsTlv) { + int countObjSubTlv = 0; + int countOtherSubTlv = 0; + boolean isCommonSubTlv = true; + LocalTENodeDescriptorsTlv other = (LocalTENodeDescriptorsTlv) obj; + Iterator<PcepValueType> objListIterator = ((LocalTENodeDescriptorsTlv) obj).llNodeDescriptorSubTLVs + .iterator(); + countObjSubTlv = ((LocalTENodeDescriptorsTlv) obj).llNodeDescriptorSubTLVs.size(); + countOtherSubTlv = other.llNodeDescriptorSubTLVs.size(); + if (countObjSubTlv != countOtherSubTlv) { + return false; + } else { + while (objListIterator.hasNext() && isCommonSubTlv) { + PcepValueType subTlv = objListIterator.next(); + isCommonSubTlv = Objects.equals(llNodeDescriptorSubTLVs.contains(subTlv), + other.llNodeDescriptorSubTLVs.contains(subTlv)); + } + return isCommonSubTlv; + } + } + return false; + } + + @Override + public int write(ChannelBuffer c) { + int tlvStartIndex = c.writerIndex(); + c.writeShort(TYPE); + int tlvLenIndex = c.writerIndex(); + hLength = 0; + c.writeShort(0); + + ListIterator<PcepValueType> listIterator = llNodeDescriptorSubTLVs.listIterator(); + + while (listIterator.hasNext()) { + PcepValueType tlv = listIterator.next(); + if (tlv == null) { + log.debug("TLV is null from subTlv list"); + continue; + } + tlv.write(c); + + // need to take care of padding + int pad = tlv.getLength() % 4; + + if (0 != pad) { + pad = 4 - pad; + for (int i = 0; i < pad; ++i) { + c.writeByte((byte) 0); + } + } + } + hLength = (short) (c.writerIndex() - tlvStartIndex); + c.setShort(tlvLenIndex, (hLength - TLV_HEADER_LENGTH)); + return c.writerIndex() - tlvStartIndex; + } + + /** + * Reads the channel buffer and returns object of AutonomousSystemTlv. + * + * @param c input channel buffer + * @param hLength length of subtlvs. + * @return object of AutonomousSystemTlv + * @throws PcepParseException if mandatory fields are missing + */ + public static PcepValueType read(ChannelBuffer c, short hLength) throws PcepParseException { + + // Node Descriptor Sub-TLVs (variable) + LinkedList<PcepValueType> llNodeDescriptorSubTLVs = new LinkedList<>(); + + ChannelBuffer tempCb = c.readBytes(hLength); + + while (TLV_HEADER_LENGTH <= tempCb.readableBytes()) { + + PcepValueType tlv; + short hType = tempCb.readShort(); + int iValue = 0; + short length = tempCb.readShort(); + + switch (hType) { + + case AutonomousSystemTlv.TYPE: + iValue = tempCb.readInt(); + tlv = new AutonomousSystemTlv(iValue); + break; + case BGPLSidentifierTlv.TYPE: + iValue = tempCb.readInt(); + tlv = new BGPLSidentifierTlv(iValue); + break; + case OSPFareaIDsubTlv.TYPE: + iValue = tempCb.readInt(); + tlv = new OSPFareaIDsubTlv(iValue); + break; + case RouterIDSubTlv.TYPE: + tlv = RouterIDSubTlv.read(tempCb, length); + break; + + default: + throw new PcepParseException("Unsupported Sub TLV type :" + hType); + } + + // Check for the padding + int pad = length % 4; + if (0 < pad) { + pad = 4 - pad; + if (pad <= tempCb.readableBytes()) { + tempCb.skipBytes(pad); + } + } + + llNodeDescriptorSubTLVs.add(tlv); + } + + if (0 < tempCb.readableBytes()) { + throw new PcepParseException("Sub Tlv parsing error. Extra bytes received."); + } + return new LocalTENodeDescriptorsTlv(llNodeDescriptorSubTLVs); + } + + @Override + public String toString() { + return MoreObjects.toStringHelper(getClass()) + .add("Type", TYPE) + .add("Length", hLength) + .add("NodeDescriptorSubTLVs", llNodeDescriptorSubTLVs) + .toString(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/MPLSProtocolMaskTlv.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/MPLSProtocolMaskTlv.java new file mode 100644 index 00000000..fc0f8771 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/MPLSProtocolMaskTlv.java @@ -0,0 +1,200 @@ +/* + * 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.types; + +import java.util.Objects; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.pcepio.protocol.PcepVersion; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.google.common.base.MoreObjects; + +/** + * Provides MPLS Protocol Mask. + */ +public class MPLSProtocolMaskTlv implements PcepValueType { + + /* Reference :[I-D.ietf-idr-ls-distribution]/3.3.2.2 + * 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 + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Type=TDB39 | Length =1 | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + |L|R| Reserved | + +-+-+-+-+-+-+-+-+ + */ + protected static final Logger log = LoggerFactory.getLogger(MPLSProtocolMaskTlv.class); + + public static final short TYPE = 1094; //TDB39 + public static final short LENGTH = 1; + public static final byte LFLAG_SET = (byte) 0x80; + public static final byte RFLAG_SET = 0x40; + + private final byte rawValue; + private final boolean bLFlag; + private final boolean bRFlag; + private final boolean isRawValueSet; + + /** + * constructor to initialize rawValue. + * + * @param rawValue MPLS Protocol Mask Flag Bits + */ + public MPLSProtocolMaskTlv(byte rawValue) { + this.rawValue = rawValue; + this.isRawValueSet = true; + this.bLFlag = (rawValue & LFLAG_SET) == LFLAG_SET; + this.bRFlag = (rawValue & RFLAG_SET) == RFLAG_SET; + } + + /** + * constructor to initialize different Flags. + * + * @param bLFlag L-flag + * @param bRFlag R-flag + */ + public MPLSProtocolMaskTlv(boolean bLFlag, boolean bRFlag) { + this.bLFlag = bLFlag; + this.bRFlag = bRFlag; + this.rawValue = 0; + isRawValueSet = false; + } + + /** + * Returns newly created MPLSProtocolMaskTlv object. + * + * @param raw MPLS Protocol Mask Tlv + * @return new object of MPLS Protocol Mask Tlv + */ + public static MPLSProtocolMaskTlv of(final byte raw) { + return new MPLSProtocolMaskTlv(raw); + } + + /** + * Returns L-flag. + * + * @return bLFlag L-flag + */ + public boolean getbLFlag() { + return bLFlag; + } + + /** + * Returns R-flag. + * + * @return bRFlag R-flag + */ + public boolean getbRFlag() { + return bRFlag; + } + + /** + * Returns raw value. + * + * @return rawValue raw value + */ + public byte getByte() { + return rawValue; + } + + @Override + public PcepVersion getVersion() { + return PcepVersion.PCEP_1; + } + + @Override + public short getType() { + return TYPE; + } + + @Override + public short getLength() { + return LENGTH; + } + + @Override + public int hashCode() { + if (isRawValueSet) { + return Objects.hash(rawValue); + } else { + return Objects.hash(bLFlag, bRFlag); + } + } + + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + if (obj instanceof MPLSProtocolMaskTlv) { + MPLSProtocolMaskTlv other = (MPLSProtocolMaskTlv) obj; + if (isRawValueSet) { + return Objects.equals(this.rawValue, other.rawValue); + } else { + return Objects.equals(this.bLFlag, other.bLFlag) && Objects.equals(this.bRFlag, other.bRFlag); + } + } + return false; + } + + @Override + public int write(ChannelBuffer c) { + int iLenStartIndex = c.writerIndex(); + c.writeShort(TYPE); + c.writeShort(LENGTH); + if (isRawValueSet) { + c.writeByte(rawValue); + } else { + byte temp = 0; + if (bLFlag) { + temp = (byte) (temp | LFLAG_SET); + } + if (bRFlag) { + temp = (byte) (temp | RFLAG_SET); + } + c.writeByte(temp); + } + return c.writerIndex() - iLenStartIndex; + } + + /** + * Reads the channel buffer and returns object of MPLS Protocol Mask Tlv. + * + * @param c input channel buffer + * @return object of MPLS Protocol Mask Tlv + */ + public static PcepValueType read(ChannelBuffer c) { + byte temp = c.readByte(); + boolean bLFlag; + boolean bRFlag; + + bLFlag = (temp & LFLAG_SET) == LFLAG_SET; + bRFlag = (temp & RFLAG_SET) == RFLAG_SET; + + return new MPLSProtocolMaskTlv(bLFlag, bRFlag); + } + + @Override + public String toString() { + return MoreObjects.toStringHelper(getClass()) + .add("Type", TYPE) + .add("Length", LENGTH) + .add("Value", rawValue) + .toString(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/MaximumLinkBandwidthTlv.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/MaximumLinkBandwidthTlv.java new file mode 100644 index 00000000..db1acf09 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/MaximumLinkBandwidthTlv.java @@ -0,0 +1,137 @@ +/* + * 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.types; + +import java.util.Objects; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.pcepio.protocol.PcepVersion; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.google.common.base.MoreObjects; + +/** + * Provide the Maximum Link Bandwidth. + */ +public class MaximumLinkBandwidthTlv implements PcepValueType { + + /* Reference :[RFC5305]/3.3. + * 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 + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Type=[TDB34] | Length=4 | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Maximum Link Bandwidth | + +-+-+-+-+-+-+-+-+-++-+-+-+-+-+-+-+-+-++-+-+-+-+-+-+-+-+-++-+-+-+- + */ + + protected static final Logger log = LoggerFactory.getLogger(MaximumLinkBandwidthTlv.class); + + public static final short TYPE = 9; //TDB34 + public static final short LENGTH = 4; + + private final int rawValue; + + /** + * Constructor to initialize rawValue. + * + * @param rawValue Maximum-Link-Bandwidth + */ + + public MaximumLinkBandwidthTlv(int rawValue) { + this.rawValue = rawValue; + } + + /** + * Returns newly created MaximumLinkBandwidthTlv object. + * + * @param raw value of Maximum-Link-Bandwidth + * @return object of MaximumLinkBandwidthTlv + */ + public static MaximumLinkBandwidthTlv of(final int raw) { + return new MaximumLinkBandwidthTlv(raw); + } + + /** + * Returns value of Maximum Link Bandwidth. + * + * @return rawValue Maximum Link Bandwidth + */ + public int getInt() { + return rawValue; + } + + @Override + public PcepVersion getVersion() { + return PcepVersion.PCEP_1; + } + + @Override + public short getType() { + return TYPE; + } + + @Override + public short getLength() { + return LENGTH; + } + + @Override + public int hashCode() { + return Objects.hash(rawValue); + } + + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + if (obj instanceof MaximumLinkBandwidthTlv) { + MaximumLinkBandwidthTlv other = (MaximumLinkBandwidthTlv) obj; + return Objects.equals(rawValue, other.rawValue); + } + return false; + } + + @Override + public int write(ChannelBuffer c) { + int iLenStartIndex = c.writerIndex(); + c.writeShort(TYPE); + c.writeShort(LENGTH); + c.writeInt(rawValue); + return c.writerIndex() - iLenStartIndex; + } + + /** + * Reads the channel buffer and returns object of MaximumLinkBandwidthTlv. + * + * @param c input channel buffer + * @return object of MaximumLinkBandwidthTlv + */ + public static MaximumLinkBandwidthTlv read(ChannelBuffer c) { + return MaximumLinkBandwidthTlv.of(c.readInt()); + } + + @Override + public String toString() { + return MoreObjects.toStringHelper(getClass()) + .add("Type", TYPE) + .add("Length", LENGTH) + .add("Value", rawValue) + .toString(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/MaximumReservableLinkBandwidthTlv.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/MaximumReservableLinkBandwidthTlv.java new file mode 100644 index 00000000..01d08cae --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/MaximumReservableLinkBandwidthTlv.java @@ -0,0 +1,136 @@ +/* + * 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.types; + +import java.util.Objects; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.pcepio.protocol.PcepVersion; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.google.common.base.MoreObjects; + +/** + * Provide the Maximum Reservable Link Bandwidth. + */ +public class MaximumReservableLinkBandwidthTlv implements PcepValueType { + + /* Reference :[RFC5305]/3.5. + * 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 + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Type=[TDB35] | Length=4 | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Maximum Reservable Link Bandwidth | + +-+-+-+-+-+-+-+-+-++-+-+-+-+-+-+-+-+-++-+-+-+-+-+-+-+-+-++-+-+-+- + */ + + protected static final Logger log = LoggerFactory.getLogger(MaximumReservableLinkBandwidthTlv.class); + + public static final short TYPE = 10; // TDB35 + public static final short LENGTH = 4; + + private final int rawValue; + + /** + * constructor to initialize rawValue. + * + * @param rawValue MaximumReservableLinkBandwidth + */ + public MaximumReservableLinkBandwidthTlv(int rawValue) { + log.debug("MaximumReservableLinkBandwidthTlv"); + this.rawValue = rawValue; + } + + /** + * Returns newly created MaximumReservableLinkBandwidth object. + * + * @param raw MaximumReservableLinkBandwidth + * @return object of MaximumReservableLinkBandwidthTlv + */ + public static MaximumReservableLinkBandwidthTlv of(final int raw) { + return new MaximumReservableLinkBandwidthTlv(raw); + } + + /** + * Returns value of Maximum Reservable Link Bandwidth. + * @return rawValue Maximum Reservable Link Bandwidth + */ + public int getInt() { + return rawValue; + } + + @Override + public PcepVersion getVersion() { + return PcepVersion.PCEP_1; + } + + @Override + public short getType() { + return TYPE; + } + + @Override + public short getLength() { + return LENGTH; + } + + @Override + public int hashCode() { + return Objects.hash(rawValue); + } + + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + if (obj instanceof MaximumReservableLinkBandwidthTlv) { + MaximumReservableLinkBandwidthTlv other = (MaximumReservableLinkBandwidthTlv) obj; + return Objects.equals(this.rawValue, other.rawValue); + } + return false; + } + + @Override + public int write(ChannelBuffer c) { + int iLenStartIndex = c.writerIndex(); + c.writeShort(TYPE); + c.writeShort(LENGTH); + c.writeInt(rawValue); + return c.writerIndex() - iLenStartIndex; + } + + /** + * Reads the channel buffer and returns object of MaximumReservableLinkBandwidthTlv. + * + * @param c input channel buffer + * @return object of MaximumReservableLinkBandwidthTlv + */ + public static MaximumReservableLinkBandwidthTlv read(ChannelBuffer c) { + return MaximumReservableLinkBandwidthTlv.of(c.readInt()); + } + + @Override + public String toString() { + return MoreObjects.toStringHelper(getClass()) + .add("Type", TYPE) + .add("Length", LENGTH) + .add("Value", rawValue) + .toString(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/NexthopIPv4addressTlv.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/NexthopIPv4addressTlv.java new file mode 100644 index 00000000..6f193384 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/NexthopIPv4addressTlv.java @@ -0,0 +1,143 @@ +/* + * 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.types; + +import java.util.Objects; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.pcepio.protocol.PcepVersion; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.google.common.base.MoreObjects; + +/** + * NexthopIPv6addressTlv provides Ipv4 address of next hop. + */ +public class NexthopIPv4addressTlv implements PcepValueType { + + /* + Reference :draft-zhao-pce-pcep-extension-for-pce-controller-01 + + 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 + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Type=TBD | Length = 8 | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | nexthop IPv4 address | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + + NEXTHOP-IPV4-ADDRESS TLV + + */ + protected static final Logger log = LoggerFactory.getLogger(NexthopIPv4addressTlv.class); + + public static final short TYPE = 2; //to be defined + //Length is header + value + public static final short LENGTH = 8; + public static final short VALUE_LENGTH = 4; + + private final int rawValue; + + /** + * Constructor to initialize next hop IPv4 address. + * + * @param rawValue next hop IPv4 address + */ + public NexthopIPv4addressTlv(int rawValue) { + this.rawValue = rawValue; + } + + /** + * Return next hop IPv4 address tlv. + * + * @param raw of next hop IPv4 address + * @return object of NexthopIPv4addressTlv + */ + public static NexthopIPv4addressTlv of(final int raw) { + return new NexthopIPv4addressTlv(raw); + } + + /** + * Returns next hop IPv4 address. + * + * @return next hop IPv4 address + */ + public int getInt() { + return rawValue; + } + + @Override + public PcepVersion getVersion() { + return PcepVersion.PCEP_1; + } + + @Override + public short getType() { + return TYPE; + } + + @Override + public short getLength() { + return LENGTH; + } + + @Override + public int hashCode() { + return Objects.hash(rawValue); + } + + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + if (obj instanceof NexthopIPv4addressTlv) { + NexthopIPv4addressTlv other = (NexthopIPv4addressTlv) obj; + return Objects.equals(this.rawValue, other.rawValue); + } + return false; + } + + @Override + public int write(ChannelBuffer c) { + int iStartIndex = c.writerIndex(); + c.writeShort(TYPE); + c.writeShort(LENGTH); + c.writeInt(rawValue); + return c.writerIndex() - iStartIndex; + } + + /** + * Reads the channel buffer and returns object of NexthopIPv4addressTlv. + * + * @param c type of channel buffer + * @return object of NexthopIPv4addressTlv + */ + public static NexthopIPv4addressTlv read(ChannelBuffer c) { + return NexthopIPv4addressTlv.of(c.readInt()); + } + + @Override + public String toString() { + return MoreObjects.toStringHelper(getClass()) + .add("Type", TYPE) + .add("Length", LENGTH) + .add("Ipv4Address ", rawValue) + .toString(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/NexthopIPv6addressTlv.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/NexthopIPv6addressTlv.java new file mode 100644 index 00000000..45bf7ac5 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/NexthopIPv6addressTlv.java @@ -0,0 +1,190 @@ +/* + * 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.types; + +import java.util.Objects; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.pcepio.protocol.PcepVersion; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.google.common.base.MoreObjects; +import com.google.common.base.MoreObjects.ToStringHelper; + +/** + * NexthopIPv6addressTlv provides Ipv6 address of next hop. + */ +public class NexthopIPv6addressTlv implements PcepValueType { + + /* + Reference: draft-zhao-pce-pcep-extension-for-pce-controller-01. + + 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 + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Type=TBD | Length = 20 | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | | + // nexthop IPv6 address (16 bytes) // + | | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + + NEXTHOP-IPV6-ADDRESS TLV: + + */ + protected static final Logger log = LoggerFactory.getLogger(NexthopIPv6addressTlv.class); + + public static final short TYPE = 100; //to be defined + //Length is header + value + public static final short LENGTH = 20; + public static final short VALUE_LENGTH = 16; + + private static final byte[] NONE_VAL = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }; + public static final NexthopIPv6addressTlv NONE = new NexthopIPv6addressTlv(NONE_VAL); + + private static final byte[] NO_MASK_VAL = {(byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, + (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, + (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF }; + public static final NexthopIPv6addressTlv NO_MASK = new NexthopIPv6addressTlv(NO_MASK_VAL); + public static final NexthopIPv6addressTlv FULL_MASK = NONE; + + private final byte[] rawValue; + + /** + * Constructor to initialize IP address for next hop IPv6 address tlv. + * + * @param rawValue value of Next hop ipAddress + */ + public NexthopIPv6addressTlv(byte[] rawValue) { + log.debug("NexthopIPv6addressTlv"); + this.rawValue = rawValue; + } + + /** + * Creates next hop IPv6 address tlv. + * + * @param raw value of Next hop ipAddress + * @return object of NexthopIPv6addressTlv + */ + //logic to be checked + public static NexthopIPv6addressTlv of(final byte[] raw) { + //check NONE_VAL + boolean bFoundNONE = true; + //value starts from 3rd byte. + for (int i = 5; i < 20; ++i) { + if (NONE_VAL[i] != raw[i]) { + bFoundNONE = false; + } + } + + if (bFoundNONE) { + return NONE; + } + + //check NO_MASK_VAL + boolean bFoundNoMask = true; + //value starts from 3rd byte. + for (int i = 5; i < 20; ++i) { + if (0xFF != raw[i]) { + bFoundNoMask = false; + } + } + if (bFoundNoMask) { + return NO_MASK; + } + return new NexthopIPv6addressTlv(raw); + } + + /** + * Returns next hop IPv6 address. + * + * @return next hop IPv6 address + */ + public byte[] getBytes() { + return rawValue; + } + + @Override + public PcepVersion getVersion() { + return PcepVersion.PCEP_1; + } + + @Override + public short getType() { + return TYPE; + } + + @Override + public short getLength() { + return LENGTH; + } + + @Override + public int hashCode() { + return Objects.hash(rawValue); + } + + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + if (obj instanceof NexthopIPv6addressTlv) { + NexthopIPv6addressTlv other = (NexthopIPv6addressTlv) obj; + return Objects.equals(this.rawValue, other.rawValue); + } + return false; + } + + @Override + public int write(ChannelBuffer c) { + int iStartIndex = c.writerIndex(); + c.writeShort(TYPE); + c.writeShort(LENGTH); + c.writeBytes(rawValue); + return c.writerIndex() - iStartIndex; + } + + /** + * Reads the channel buffer and returns object of NexthopIPv6addressTlv. + * + * @param c type of channel buffer + * @return object of NexthopIPv6addressTlv + */ + public static NexthopIPv6addressTlv read(ChannelBuffer c) { + byte[] yTemp = new byte[20]; + c.readBytes(yTemp, 0, 20); + return NexthopIPv6addressTlv.of(yTemp); + } + + @Override + public String toString() { + ToStringHelper toStrHelper = MoreObjects.toStringHelper(getClass()); + + toStrHelper.add("Type", TYPE); + toStrHelper.add("Length", LENGTH); + + StringBuffer result = new StringBuffer(); + for (byte b : rawValue) { + result.append(String.format("%02X ", b)); + } + toStrHelper.add("IpAddress", result); + + return toStrHelper.toString(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/NexthopUnnumberedIPv4IDTlv.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/NexthopUnnumberedIPv4IDTlv.java new file mode 100644 index 00000000..fb4ceeff --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/NexthopUnnumberedIPv4IDTlv.java @@ -0,0 +1,163 @@ +/* + * 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.types; + +import java.util.Objects; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.pcepio.protocol.PcepVersion; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.google.common.base.MoreObjects; + +/** + * NexthopUnnumberedIPv4IDTlv provides the next node's ID and Interface ID. + */ +public class NexthopUnnumberedIPv4IDTlv implements PcepValueType { + + /* + Reference : draft-zhao-pce-pcep-extension-for-pce-controller-01. + + 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 + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Type=TBD | Length = 12 | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Node-ID | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Interface ID | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + + NEXTHOP-UNNUMBERED-IPV4-ID TLV + + */ + protected static final Logger log = LoggerFactory.getLogger(NexthopUnnumberedIPv4IDTlv.class); + + public static final short TYPE = 1; //to be defined + //Length is header + value + public static final short LENGTH = 12; + + private final int nodeID; + private final int interfaceID; + + /** + * constructor to initialize nodeID and interfaceID. + * + * @param nodeID node ID + * @param interfaceID interface ID + */ + public NexthopUnnumberedIPv4IDTlv(int nodeID, int interfaceID) { + this.nodeID = nodeID; + this.interfaceID = interfaceID; + } + + /** + * Returns new object of NexthopUnnumberedIPv4IDTlv. + * + * @param nodeID node ID + * @param interfaceID interface ID + * @return NexthopUnnumberedIPv4IDTlv + */ + public static NexthopUnnumberedIPv4IDTlv of(int nodeID, int interfaceID) { + return new NexthopUnnumberedIPv4IDTlv(nodeID, interfaceID); + } + + /** + * Returns Node Id. + * + * @return node ID + */ + public int getNodeID() { + return nodeID; + } + + /** + * Returns Interface Id. + * + * @return interface ID + */ + public int getInterfaceID() { + return interfaceID; + } + + @Override + public PcepVersion getVersion() { + return PcepVersion.PCEP_1; + } + + @Override + public short getType() { + return TYPE; + } + + @Override + public short getLength() { + return LENGTH; + } + + @Override + public int hashCode() { + return Objects.hash(nodeID, interfaceID); + } + + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + if (obj instanceof NexthopUnnumberedIPv4IDTlv) { + NexthopUnnumberedIPv4IDTlv other = (NexthopUnnumberedIPv4IDTlv) obj; + return Objects.equals(this.nodeID, other.nodeID) && Objects.equals(this.interfaceID, other.interfaceID); + } + return false; + } + + @Override + public int write(ChannelBuffer c) { + int iLenStartIndex = c.writerIndex(); + c.writeShort(TYPE); + c.writeShort(LENGTH); + + c.writeInt(nodeID); + c.writeInt(interfaceID); + + return c.writerIndex() - iLenStartIndex; + } + + /** + * Reads the channel buffer and returns object of NexthopUnnumberedIPv4IDTlv. + * + * @param cb type of channel buffer + * @return object of NexthopUnnumberedIPv4IDTlv + */ + public static NexthopUnnumberedIPv4IDTlv read(ChannelBuffer cb) { + int nodeID = cb.readInt(); + int interfaceID = cb.readInt(); + return new NexthopUnnumberedIPv4IDTlv(nodeID, interfaceID); + } + + @Override + public String toString() { + return MoreObjects.toStringHelper(getClass()) + .add("Type", TYPE) + .add("Length", LENGTH) + .add("NodeId", nodeID) + .add("InterfaceId", interfaceID) + .toString(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/NodeFlagBitsTlv.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/NodeFlagBitsTlv.java new file mode 100644 index 00000000..019daa14 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/NodeFlagBitsTlv.java @@ -0,0 +1,233 @@ +/* + * 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.types; + +import java.util.Objects; +import org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.pcepio.protocol.PcepVersion; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.google.common.base.MoreObjects; + +/** + * Provide node Flags bits. + */ +public class NodeFlagBitsTlv implements PcepValueType { + + /* Reference :[I-D.ietf-idr- ls-distribution] /3.3.1.1 + * 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 + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Type=[TBD21] | Length=1 | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + |O|T|E|B| Reserved| + +-+-+-+-+-+-+-+-+-+ + */ + + protected static final Logger log = LoggerFactory.getLogger(NodeFlagBitsTlv.class); + + public static final short TYPE = 14; + public static final short LENGTH = 1; + public static final int SET = 1; + public static final byte OFLAG_SET = (byte) 0x80; + public static final byte TFLAG_SET = 0x40; + public static final byte EFLAG_SET = 0x20; + public static final byte BFLAG_SET = 0x10; + + private final byte rawValue; + private final boolean bOFlag; + private final boolean bTFlag; + private final boolean bEFlag; + private final boolean bBFlag; + private final boolean isRawValueSet; + + /** + * constructor to initialize rawValue. + * + * @param rawValue of Node Flag Bits TLV + */ + public NodeFlagBitsTlv(byte rawValue) { + this.rawValue = rawValue; + isRawValueSet = true; + this.bOFlag = (rawValue & OFLAG_SET) == OFLAG_SET; + this.bTFlag = (rawValue & TFLAG_SET) == TFLAG_SET; + this.bEFlag = (rawValue & EFLAG_SET) == EFLAG_SET; + this.bBFlag = (rawValue & BFLAG_SET) == BFLAG_SET; + } + + /** + * constructor to initialize different Flags. + * + * @param bOFlag O-flag + * @param bTFlag T-flag + * @param bEFlag E-flag + * @param bBFlag B-flag + */ + public NodeFlagBitsTlv(boolean bOFlag, boolean bTFlag, boolean bEFlag, boolean bBFlag) { + this.bOFlag = bOFlag; + this.bTFlag = bTFlag; + this.bEFlag = bEFlag; + this.bBFlag = bBFlag; + this.rawValue = 0; + this.isRawValueSet = false; + } + + /** + * Returns newly created NodeFlagBitsTlv object. + * + * @param raw of Node Flag Bits TLV + * @return new object of NodeFlagBitsTlv + */ + public static NodeFlagBitsTlv of(final byte raw) { + return new NodeFlagBitsTlv(raw); + } + + /** + * Returns raw value of NodeFlagBitsTlv. + * + * @return rawValue raw value + */ + public byte getbyte() { + return rawValue; + } + + /** + * Returns O-flag. + * + * @return bOFlag O-flag + */ + public boolean getOFlag() { + return bOFlag; + } + + /** + * Returns T-flag. + * + * @return bTFlag T-flag + */ + public boolean getTFlag() { + return bTFlag; + } + + /** + * Returns E-flag. + * + * @return bEFlag E-flag + */ + public boolean getEFlag() { + return bEFlag; + } + + /** + * Returns B-flag. + * + * @return bBFlag B-flag + */ + public boolean getBFlag() { + return bBFlag; + } + + @Override + public PcepVersion getVersion() { + return PcepVersion.PCEP_1; + } + + @Override + public short getType() { + return TYPE; + } + + @Override + public short getLength() { + return LENGTH; + } + + @Override + public int hashCode() { + if (isRawValueSet) { + return Objects.hash(rawValue); + } else { + return Objects.hash(bOFlag, bTFlag, bEFlag, bBFlag); + } + } + + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + if (obj instanceof NodeFlagBitsTlv) { + NodeFlagBitsTlv other = (NodeFlagBitsTlv) obj; + if (isRawValueSet) { + return Objects.equals(this.rawValue, other.rawValue); + } else { + return Objects.equals(this.bOFlag, other.bOFlag) && Objects.equals(this.bTFlag, other.bTFlag) + && Objects.equals(this.bEFlag, other.bEFlag) && Objects.equals(this.bBFlag, other.bBFlag); + } + } + return false; + } + + @Override + public int write(ChannelBuffer c) { + int iLenStartIndex = c.writerIndex(); + c.writeShort(TYPE); + c.writeShort(LENGTH); + if (isRawValueSet) { + c.writeByte(rawValue); + } else { + byte temp = 0; + if (bOFlag) { + temp = (byte) (temp | OFLAG_SET); + } + if (bTFlag) { + temp = (byte) (temp | TFLAG_SET); + } + if (bEFlag) { + temp = (byte) (temp | EFLAG_SET); + } + if (bBFlag) { + temp = (byte) (temp | BFLAG_SET); + } + c.writeByte(temp); + } + return c.writerIndex() - iLenStartIndex; + } + + /** + * Reads the channel buffer and returns object of NodeFlagBitsTlv. + * + * @param c input channel buffer + * @return object of NodeFlagBitsTlv + */ + public static PcepValueType read(ChannelBuffer c) { + + return NodeFlagBitsTlv.of(c.readByte()); + } + + @Override + public String toString() { + return MoreObjects.toStringHelper(getClass()) + .add("Type", TYPE) + .add("Length", LENGTH) + .add("OFlag", (bOFlag) ? 1 : 0) + .add("TFlag", (bTFlag) ? 1 : 0) + .add("EFlag", (bEFlag) ? 1 : 0) + .add("BFlag", (bBFlag) ? 1 : 0) + .toString(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/NodeNameTlv.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/NodeNameTlv.java new file mode 100644 index 00000000..e535a358 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/NodeNameTlv.java @@ -0,0 +1,154 @@ +/* + * 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.types; + +import java.util.Objects; +import org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.pcepio.protocol.PcepVersion; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.google.common.base.MoreObjects; +import com.google.common.base.MoreObjects.ToStringHelper; + +/** + * Provide the name for the node. + */ +public class NodeNameTlv implements PcepValueType { + + /* reference :[I-D.ietf-idr-ls-distribution]/3.3.1.3 + * 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 + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Type=[TBD23] | Length | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + // Node Name (variable) // + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + */ + + protected static final Logger log = LoggerFactory.getLogger(NodeNameTlv.class); + + public static final short TYPE = 1007; //TODO:check and change TBD23 + public final short hLength; + + private final byte[] rawValue; + + /** + * constructor to initialize rawValue. + * + * @param rawValue of Node Name + * @param hLength length + */ + public NodeNameTlv(byte[] rawValue, short hLength) { + log.debug("NodeNameTlv"); + this.rawValue = rawValue; + if (0 == hLength) { + this.hLength = (short) rawValue.length; + } else { + this.hLength = hLength; + } + } + + /** + * Returns newly created NodeNameTlv object. + * + * @param raw of NodeName + * @param hLength length + * @return new object of Node Name Tlv + */ + public static NodeNameTlv of(final byte[] raw, short hLength) { + return new NodeNameTlv(raw, hLength); + } + + /** + * Returns RawValue for NodeName. + * + * @return rawValue raw value + */ + public byte[] getValue() { + return rawValue; + } + + @Override + public PcepVersion getVersion() { + return PcepVersion.PCEP_1; + } + + @Override + public short getType() { + return TYPE; + } + + @Override + public short getLength() { + return hLength; + } + + @Override + public int hashCode() { + return Objects.hash(rawValue); + } + + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + if (obj instanceof NodeNameTlv) { + NodeNameTlv other = (NodeNameTlv) obj; + return Objects.equals(this.rawValue, other.rawValue); + } + return false; + } + + @Override + public int write(ChannelBuffer c) { + int iLenStartIndex = c.writerIndex(); + c.writeShort(TYPE); + c.writeShort(hLength); + c.writeBytes(rawValue); + return c.writerIndex() - iLenStartIndex; + } + + /** + * Reads the channel buffer and returns object of NodeNameTlv. + * + * @param c input channel buffer + * @param hLength length + * @return object of Node Name TLV + */ + public static PcepValueType read(ChannelBuffer c, short hLength) { + byte[] iNodeName = new byte[hLength]; + c.readBytes(iNodeName, 0, hLength); + return new NodeNameTlv(iNodeName, hLength); + } + + @Override + public String toString() { + ToStringHelper toStrHelper = MoreObjects.toStringHelper(getClass()); + + toStrHelper.add("Type", TYPE); + toStrHelper.add("Length", hLength); + + StringBuffer result = new StringBuffer(); + for (byte b : rawValue) { + result.append(String.format("%02X ", b)); + } + toStrHelper.add("Value", result); + + return toStrHelper.toString(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/OSPFareaIDsubTlv.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/OSPFareaIDsubTlv.java new file mode 100644 index 00000000..2233ab0d --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/OSPFareaIDsubTlv.java @@ -0,0 +1,135 @@ +/* + * 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.types; + +import java.util.Objects; +import org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.pcepio.protocol.PcepVersion; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.google.common.base.MoreObjects; + +/** + * Provides area ID for OSPF area. + */ +public class OSPFareaIDsubTlv implements PcepValueType { + + /* Reference :draft-ietf-idr-ls-distribution-10. + * 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 + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Type=[TBD12] | Length=4 | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | opaque value (32 Bit AS Number) | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + */ + + protected static final Logger log = LoggerFactory.getLogger(OSPFareaIDsubTlv.class); + + public static final short TYPE = 600; //TODD:change this TBD12 + public static final short LENGTH = 4; + + private final int rawValue; + + /** + * constructor to initialize rawValue. + * + * @param rawValue area ID for OSPF area. + */ + public OSPFareaIDsubTlv(int rawValue) { + this.rawValue = rawValue; + } + + /** + * Returns newly created OSPFareaIDsubTlv object. + * + * @param raw opaque value of AreaID + * @return new object of OSPF area ID sub TLV + */ + public static OSPFareaIDsubTlv of(final int raw) { + return new OSPFareaIDsubTlv(raw); + } + + /** + * Returns RawValue opaque value of AreaID. + * + * @return rawValue Area ID + */ + public int getInt() { + return rawValue; + } + + @Override + public PcepVersion getVersion() { + return PcepVersion.PCEP_1; + } + + @Override + public short getType() { + return TYPE; + } + + @Override + public short getLength() { + return LENGTH; + } + + @Override + public int hashCode() { + return Objects.hash(rawValue); + } + + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + if (obj instanceof OSPFareaIDsubTlv) { + OSPFareaIDsubTlv other = (OSPFareaIDsubTlv) obj; + return Objects.equals(this.rawValue, other.rawValue); + } + return false; + } + + @Override + public int write(ChannelBuffer c) { + int iLenStartIndex = c.writerIndex(); + c.writeShort(TYPE); + c.writeShort(LENGTH); + c.writeInt(rawValue); + return c.writerIndex() - iLenStartIndex; + } + + /** + * Reads the channel buffer and returns object of OSPFAreaIdSubTlv. + * + * @param c input channel buffer + * @return object of OSPFAreaIdSubTlv + */ + public static OSPFareaIDsubTlv read(ChannelBuffer c) { + return OSPFareaIDsubTlv.of(c.readInt()); + } + + @Override + public String toString() { + return MoreObjects.toStringHelper(getClass()) + .add("Type", TYPE) + .add("Length", LENGTH) + .add("Value", rawValue) + .toString(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/OpaqueLinkAttributeTlv.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/OpaqueLinkAttributeTlv.java new file mode 100644 index 00000000..1af332eb --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/OpaqueLinkAttributeTlv.java @@ -0,0 +1,155 @@ +/* + * 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.types; + +import java.util.Objects; +import org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.pcepio.protocol.PcepVersion; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.google.common.base.MoreObjects; +import com.google.common.base.MoreObjects.ToStringHelper; + +/** + * Provides Opaque Link Attribute. + */ +public class OpaqueLinkAttributeTlv implements PcepValueType { + + /* + * TLV format. + * Reference :[I-D.ietf-idr-attributesls-distribution] /3.3.2.6 + 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 + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Type=TBD42 | Length | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + // Opaque link attributes (variable) // + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + */ + + protected static final Logger log = LoggerFactory.getLogger(OpaqueLinkAttributeTlv.class); + + public static final short TYPE = 1097; //TODO:NEED TO HANDLE TDB42 + private final short hLength; + + private final byte[] rawValue; + + /** + * constructor to initialize rawValue. + * + * @param rawValue of Opaque Link Attribute + * @param hLength length + */ + public OpaqueLinkAttributeTlv(byte[] rawValue, short hLength) { + log.debug("OpaqueLinkAttributeTlv"); + this.rawValue = rawValue; + if (0 == hLength) { + this.hLength = (short) rawValue.length; + } else { + this.hLength = hLength; + } + } + + /** + * Returns newly created OpaqueLinkAttributeTlv object. + * + * @param raw of Opaque Link Attribute + * @param hLength length + * @return new object of OpaqueLinkAttributeTlv + */ + public static OpaqueLinkAttributeTlv of(final byte[] raw, short hLength) { + return new OpaqueLinkAttributeTlv(raw, hLength); + } + + /** + * Returns raw value of Opaque Link Attribute Tlv. + * @return rawValue raw value + */ + public byte[] getValue() { + return rawValue; + } + + @Override + public PcepVersion getVersion() { + return PcepVersion.PCEP_1; + } + + @Override + public short getType() { + return TYPE; + } + + @Override + public short getLength() { + return hLength; + } + + @Override + public int hashCode() { + return Objects.hash(rawValue); + } + + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + if (obj instanceof OpaqueLinkAttributeTlv) { + OpaqueLinkAttributeTlv other = (OpaqueLinkAttributeTlv) obj; + return Objects.equals(this.rawValue, other.rawValue); + } + return false; + } + + @Override + public int write(ChannelBuffer c) { + int iLenStartIndex = c.writerIndex(); + c.writeShort(TYPE); + c.writeShort(hLength); + c.writeBytes(rawValue); + return c.writerIndex() - iLenStartIndex; + } + + /** + * Reads the channel buffer and returns object of OpaqueLinkAttributeTlv. + * + * @param c input channel buffer + * @param hLength length + * @return object of Opaque Link Attribute Tlv + */ + public static PcepValueType read(ChannelBuffer c, short hLength) { + byte[] iOpaqueValue = new byte[hLength]; + c.readBytes(iOpaqueValue, 0, hLength); + return new OpaqueLinkAttributeTlv(iOpaqueValue, hLength); + } + + @Override + public String toString() { + ToStringHelper toStrHelper = MoreObjects.toStringHelper(getClass()); + + toStrHelper.add("Type", TYPE); + toStrHelper.add("Length", hLength); + + StringBuffer result = new StringBuffer(); + for (byte b : rawValue) { + result.append(String.format("%02X ", b)); + } + toStrHelper.add("Value", result); + + return toStrHelper.toString(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/OpaqueNodeAttributeTlv.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/OpaqueNodeAttributeTlv.java new file mode 100644 index 00000000..26e8c8bf --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/OpaqueNodeAttributeTlv.java @@ -0,0 +1,154 @@ +/* + * 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.types; + +import java.util.Objects; +import org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.pcepio.protocol.PcepVersion; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.google.common.base.MoreObjects; +import com.google.common.base.MoreObjects.ToStringHelper; + +/** + * Provides Opaque node attributes. + */ +public class OpaqueNodeAttributeTlv implements PcepValueType { + /* + * Reference [I-D.ietf-idr-Properties ls-distribution] /3.3.1.5 + * 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 + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Type=[TBD22] | Length | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + // Opaque node attributes (variable) // + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + */ + + protected static final Logger log = LoggerFactory.getLogger(OpaqueNodeAttributeTlv.class); + + public static final short TYPE = 1001; + private final short hLength; + + private final byte[] rawValue; + + /** + * constructor to initialize rawValue. + * + * @param rawValue Opaque Node Attribute + * @param hLength length + */ + public OpaqueNodeAttributeTlv(byte[] rawValue, short hLength) { + + this.rawValue = rawValue; + if (0 == hLength) { + this.hLength = (short) rawValue.length; + } else { + this.hLength = hLength; + } + } + + /** + * Returns newly created OpaqueNodeAttributeTlv object. + * + * @param raw value of Opaque Node Attribute + * @param hLength length + * @return new object of Opaque Node Attribute Tlv + */ + public static OpaqueNodeAttributeTlv of(final byte[] raw, short hLength) { + return new OpaqueNodeAttributeTlv(raw, hLength); + } + + /** + * Returns raw value of Opaque Node Attribute Tlv. + * + * @return rawValue of Opaque Node Attribute + */ + public byte[] getValue() { + return rawValue; + } + + @Override + public PcepVersion getVersion() { + return PcepVersion.PCEP_1; + } + + @Override + public short getType() { + return TYPE; + } + + @Override + public short getLength() { + return hLength; + } + + @Override + public int hashCode() { + return Objects.hash(rawValue); + } + + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + if (obj instanceof OpaqueNodeAttributeTlv) { + OpaqueNodeAttributeTlv other = (OpaqueNodeAttributeTlv) obj; + return Objects.equals(this.rawValue, other.rawValue); + } + return false; + } + + @Override + public int write(ChannelBuffer c) { + int iLenStartIndex = c.writerIndex(); + c.writeShort(TYPE); + c.writeShort(hLength); + c.writeBytes(rawValue); + return c.writerIndex() - iLenStartIndex; + } + + /** + * Reads the channel buffer and returns object of Opaque Node Attribute Tlv. + * + * @param c input channel buffer + * @param hLength length + * @return object of OpaqueNodeAttributeTlv + */ + public static PcepValueType read(ChannelBuffer c, short hLength) { + byte[] iOpaqueValue = new byte[hLength]; + c.readBytes(iOpaqueValue, 0, hLength); + return new OpaqueNodeAttributeTlv(iOpaqueValue, hLength); + } + + @Override + public String toString() { + ToStringHelper toStrHelper = MoreObjects.toStringHelper(getClass()); + + toStrHelper.add("Type", TYPE); + toStrHelper.add("Length", hLength); + + StringBuffer result = new StringBuffer(); + for (byte b : rawValue) { + result.append(String.format("%02X ", b)); + } + toStrHelper.add("Value", result); + + return toStrHelper.toString(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/PathKeySubObject.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/PathKeySubObject.java new file mode 100644 index 00000000..86ad042a --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/PathKeySubObject.java @@ -0,0 +1,159 @@ +/* + * 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.types; + +import java.util.Objects; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.pcepio.protocol.PcepVersion; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.google.common.base.MoreObjects; + +/** + * Path Key SubObject: When a PCC needs to expand a path-key in order to expand a CPS, it + * issues a Path Computation Request (PCReq) to the PCE identified in + * the PKS in the RSVP-TE ERO that it is processing. The PCC supplies + * the PKS to be expanded in a PATH-KEY SubObject in the PCReq message. + */ +public class PathKeySubObject implements PcepValueType { + + /* + Pathkey subobject(RFC 5520): + 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 + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + |L| Type | Length | Path-Key | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | PCE ID (4 bytes) | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + */ + + protected static final Logger log = LoggerFactory.getLogger(PathKeySubObject.class); + + public static final byte TYPE = 0x40; + public static final byte LENGTH = 8; + private final short pathKey; + private final int pceID; + + /** + * Constructor for Path Key sub Object which initializes pathKey and pceId. + * + * @param pathKey path key provided by PCC + * @param pceID ID for the PCE + */ + public PathKeySubObject(short pathKey, int pceID) { + this.pathKey = pathKey; + this.pceID = pceID; + } + + /** + * Creates Path Key sub Object which initializes pathKey and pceId. + * + * @param pathKey path key provided by PCC + * @param pceID PCE id + * @return new object of type path key sub object + */ + public static PathKeySubObject of(short pathKey, int pceID) { + return new PathKeySubObject(pathKey, pceID); + } + + /** + * Returns Path Key. + * + * @return pathKey + */ + public short getPathKey() { + return pathKey; + } + + /** + * Returns pceID. + * + * @return pceID + */ + public int getPceId() { + return pceID; + } + + @Override + public PcepVersion getVersion() { + return PcepVersion.PCEP_1; + } + + @Override + public short getType() { + return TYPE; + } + + @Override + public short getLength() { + return LENGTH; + } + + @Override + public int hashCode() { + return Objects.hash(pathKey, pceID); + } + + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + if (obj instanceof PathKeySubObject) { + PathKeySubObject other = (PathKeySubObject) obj; + return Objects.equals(this.pathKey, other.pathKey) && Objects.equals(this.pceID, other.pceID); + } + return false; + } + + @Override + public int write(ChannelBuffer c) { + int iLenStartIndex = c.writerIndex(); + c.writeShort(TYPE); + c.writeShort(LENGTH); + + c.writeShort(pathKey); + c.writeInt(pceID); + + return c.writerIndex() - iLenStartIndex; + } + + /** + * Reads the channel buffer and returns new path key sub objects. + * + * @param c of type channel buffer + * @return object of type path key sub object + */ + public static PcepValueType read(ChannelBuffer c) { + Short pathKey = c.readShort(); + int pceID = c.readInt(); + return new PathKeySubObject(pathKey, pceID); + } + + @Override + public String toString() { + return MoreObjects.toStringHelper(getClass()) + .add("Type", TYPE) + .add("Length", LENGTH) + .add("PathKey", pathKey) + .add("PceID", pceID) + .toString(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/PathSetupTypeTlv.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/PathSetupTypeTlv.java new file mode 100644 index 00000000..3e8f9676 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/PathSetupTypeTlv.java @@ -0,0 +1,164 @@ +/* + * 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.types; + +import java.util.Objects; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.pcepio.protocol.PcepVersion; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.google.common.base.MoreObjects; + +/** + * Provides PcepSetup type tlv. + */ +public class PathSetupTypeTlv implements PcepValueType { + + /* + Reference : draft-sivabalan-pce-lsp-setup-type-02. + + 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 + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Type | Length | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Reserved | PST | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + + Figure 1: PATH-SETUP-TYPE TLV + + */ + protected static final Logger log = LoggerFactory.getLogger(PathSetupTypeTlv.class); + + public static final short TYPE = 0; //TODO : need to reassign the value as per RFC + public static final short LENGTH = 4; + + private final byte pst; + private final int rawValue; + private final boolean isRawValueSet; + + /** + * Constructor to initialize parameters for path setup type tlv. + * + * @param rawValue parameter for path setup type tlv + */ + public PathSetupTypeTlv(final int rawValue) { + this.rawValue = rawValue; + this.isRawValueSet = true; + this.pst = (byte) rawValue; + } + + /** + * Constructor to initialize pst. + * + * @param pst PST + */ + public PathSetupTypeTlv(byte pst) { + this.pst = pst; + this.rawValue = 0; + this.isRawValueSet = false; + } + + /** + * Returns Object of path setup type tlv. + * + * @param raw parameter for path setup type tlv + * @return object of PathSetupTypeTlv + */ + public static PathSetupTypeTlv of(final int raw) { + return new PathSetupTypeTlv(raw); + } + + @Override + public PcepVersion getVersion() { + return PcepVersion.PCEP_1; + } + + /** + * Returns parameters for path setup type tlv. + * + * @return parameters for path setup type tlv + */ + public int getInt() { + return rawValue; + } + + /** + * Returns the pst value. + * + * @return pst value + */ + public byte getPst() { + return pst; + } + + @Override + public short getType() { + return TYPE; + } + + @Override + public short getLength() { + return LENGTH; + } + + @Override + public int hashCode() { + return Objects.hash(pst); + } + + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + if (obj instanceof PathSetupTypeTlv) { + PathSetupTypeTlv other = (PathSetupTypeTlv) obj; + return Objects.equals(this.pst, other.pst); + } + return false; + } + + @Override + public int write(ChannelBuffer c) { + int iLenStartIndex = c.writerIndex(); + c.writeShort(TYPE); + c.writeShort(LENGTH); + c.writeInt(pst); + return c.writerIndex() - iLenStartIndex; + } + + /** + * Returns the object of type PathSetupTypeTlv. + * + * @param c is type Channel buffer + * @return object of PathSetupTypeTlv + */ + public static PathSetupTypeTlv read(ChannelBuffer c) { + return PathSetupTypeTlv.of(c.readInt()); + } + + @Override + public String toString() { + return MoreObjects.toStringHelper(getClass()) + .add("Type", TYPE) + .add("Length", LENGTH) + .add("PST", pst) + .toString(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/PceccCapabilityTlv.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/PceccCapabilityTlv.java new file mode 100644 index 00000000..b8ae1e87 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/PceccCapabilityTlv.java @@ -0,0 +1,194 @@ +/* + * 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.types; + +import java.util.Objects; +import org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.pcepio.protocol.PcepVersion; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.google.common.base.MoreObjects; + +/** + * Provides PceccCapabilityTlv. + */ +public class PceccCapabilityTlv implements PcepValueType { + + /* PCECC CAPABILITY TLV + * Reference : draft-zhao-pce-pcep-extension-for-pce-controller-01, section-7.1.1 + + 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 + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Type=32 | Length=4 | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Flags |G|L| + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + + */ + protected static final Logger log = LoggerFactory.getLogger(PceccCapabilityTlv.class); + + public static final short TYPE = 32; + public static final short LENGTH = 4; + public static final int SET = 1; + public static final byte LFLAG_CHECK = 0x01; + public static final byte GFLAG_CHECK = 0x02; + + private final boolean bGFlag; + private final boolean bLFlag; + + private final int rawValue; + private final boolean isRawValueSet; + + /** + * Constructor to initialize raw Value. + * + * @param rawValue raw value + */ + public PceccCapabilityTlv(final int rawValue) { + this.rawValue = rawValue; + this.isRawValueSet = true; + + bLFlag = (rawValue & LFLAG_CHECK) == LFLAG_CHECK; + bGFlag = (rawValue & GFLAG_CHECK) == GFLAG_CHECK; + } + + /** + * Constructor to initialize G-flag L-flag. + * @param bGFlag G-flag + * @param bLFlag L-flag + */ + public PceccCapabilityTlv(boolean bGFlag, boolean bLFlag) { + this.bGFlag = bGFlag; + this.bLFlag = bLFlag; + this.rawValue = 0; + this.isRawValueSet = false; + } + + /** + * Returns newly created PceccCapabilityTlv object. + * + * @param raw value + * @return object of Pcecc Capability Tlv + */ + public static PceccCapabilityTlv of(final int raw) { + return new PceccCapabilityTlv(raw); + } + + @Override + public PcepVersion getVersion() { + return PcepVersion.PCEP_1; + } + + /** + * Returns G-flag. + * @return bGFlag G-flag + */ + public boolean getGFlag() { + return bGFlag; + } + + /** + * Returns L-flag. + * @return bLFlag L-flag + */ + public boolean getLFlag() { + return bLFlag; + } + + /** + * Returns the raw value. + * @return rawValue Flags + */ + public int getInt() { + return rawValue; + } + + @Override + public short getType() { + return TYPE; + } + + @Override + public short getLength() { + return LENGTH; + } + + @Override + public int hashCode() { + if (isRawValueSet) { + return Objects.hash(rawValue); + } else { + return Objects.hash(bLFlag, bGFlag); + } + } + + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + if (obj instanceof PceccCapabilityTlv) { + PceccCapabilityTlv other = (PceccCapabilityTlv) obj; + if (isRawValueSet) { + return Objects.equals(this.rawValue, other.rawValue); + } else { + return Objects.equals(this.bGFlag, other.bGFlag) && Objects.equals(this.bLFlag, other.bLFlag); + } + } + return false; + } + + @Override + public int write(ChannelBuffer c) { + int iLenStartIndex = c.writerIndex(); + int temp = 0; + c.writeShort(TYPE); + c.writeShort(LENGTH); + if (isRawValueSet) { + c.writeInt(rawValue); + } else { + if (bGFlag) { + temp = temp | GFLAG_CHECK; + } + if (bLFlag) { + temp = temp | LFLAG_CHECK; + } + c.writeInt(temp); + } + return c.writerIndex() - iLenStartIndex; + } + + /** + * Reads channel buffer and returns object of PceccCapabilityTlv. + * + * @param c input channel buffer + * @return object of PceccCapabilityTlv + */ + public static PceccCapabilityTlv read(ChannelBuffer c) { + return PceccCapabilityTlv.of(c.readInt()); + } + + @Override + public String toString() { + return MoreObjects.toStringHelper(getClass()) + .add("Type", TYPE) + .add("Length", LENGTH) + .add("Value", rawValue) + .toString(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/PcepErrorDetailInfo.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/PcepErrorDetailInfo.java new file mode 100644 index 00000000..83a62103 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/PcepErrorDetailInfo.java @@ -0,0 +1,83 @@ +/* + * 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.types; + +/** + * Provide the PCEP Error Info Details. + */ +public final class PcepErrorDetailInfo { + + private PcepErrorDetailInfo() { + } + + // Error Types + /** + Error- Meaning Reference:RFC 5440 + Type + 1 PCEP session establishment failure + Error-value=1: reception of an invalid Open message or a non Open message. + Error-value=2: no Open message received before the expiration of the OpenWait timer + Error-value=3: unacceptable and non-negotiable session characteristics + Error-value=4: unacceptable but negotiable session characteristics + Error-value=5: reception of a second Open message with still unacceptable session characteristics + Error-value=6: reception of a PCErr message proposing unacceptable session characteristics + Error-value=7: No Keepalive or PCErr message received before the expiration of the KeepWait timer + Error-value=8: PCEP version not supported + 2 Capability not supported + 3 Unknown Object + Error-value=1: Unrecognized object class + Error-value=2: Unrecognized object Type + 4 Not supported object + Error-value=1: Not supported object class + Error-value=2: Not supported object Type + 5 Policy violation + Error-value=1: C bit of the METRIC object set (request rejected) + Error-value=2: O bit of the RP object cleared (request rejected) + 6 Mandatory Object missing + Error-value=1: RP object missing + Error-value=2: RRO missing for a re-optimization request (R bit of the RP object set) + Error-value=3: END-POINTS object missing + 7 Synchronized path computation request missing + 8 Unknown request reference + 9 Attempt to establish a second PCEP session + 10 Reception of an invalid object + Error-value=1: reception of an object with P flag not set although the P flag must be + set according to this specification. + */ + public static final byte ERROR_TYPE_1 = 1; + public static final byte ERROR_TYPE_2 = 2; + public static final byte ERROR_TYPE_3 = 3; + public static final byte ERROR_TYPE_4 = 4; + public static final byte ERROR_TYPE_5 = 5; + public static final byte ERROR_TYPE_6 = 6; + public static final byte ERROR_TYPE_7 = 7; + public static final byte ERROR_TYPE_8 = 8; + public static final byte ERROR_TYPE_9 = 9; + public static final byte ERROR_TYPE_10 = 10; + + // Error Values + public static final byte ERROR_VALUE_1 = 1; + public static final byte ERROR_VALUE_2 = 2; + public static final byte ERROR_VALUE_3 = 3; + public static final byte ERROR_VALUE_4 = 4; + public static final byte ERROR_VALUE_5 = 5; + public static final byte ERROR_VALUE_6 = 6; + public static final byte ERROR_VALUE_7 = 7; + public static final byte ERROR_VALUE_8 = 8; + public static final byte ERROR_VALUE_9 = 9; + public static final byte ERROR_VALUE_10 = 10; +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/PcepLabelDbVerTlv.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/PcepLabelDbVerTlv.java new file mode 100644 index 00000000..97eedcfd --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/PcepLabelDbVerTlv.java @@ -0,0 +1,137 @@ +/* + * 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.types; + +import java.util.Objects; +import org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.pcepio.protocol.PcepVersion; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.google.common.base.MoreObjects; + +/** + * Provides CEP LABEL DB VERSION TLV which contains LSP State DB Version (32 Bit ). + */ +public class PcepLabelDbVerTlv implements PcepValueType { + + /* PCEP LABEL DB VERSION TLV format + + Reference : draft-ietf-pce-stateful-sync-optimizations-02, section 3.3.1 + 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 + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Type=23 | Length=8 | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | LSP State DB Version | + | | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + + */ + protected static final Logger log = LoggerFactory.getLogger(PcepLabelDbVerTlv.class); + + public static final short TYPE = 34; + public static final short LENGTH = 8; + private final long rawValue; + + /** + * constructor to initialize rawValue. + * + * @param rawValue of Pcep Label Db Version Tlv + */ + public PcepLabelDbVerTlv(final long rawValue) { + log.debug("PcepLabelDbVerTlv"); + this.rawValue = rawValue; + } + + /** + * Returns newly created PcepLabelDbVerTlv object. + * + * @param raw LSP State DB Version + * @return object of PcepLabelDbVerTlv + */ + public static PcepLabelDbVerTlv of(final long raw) { + return new PcepLabelDbVerTlv(raw); + } + + @Override + public PcepVersion getVersion() { + return PcepVersion.PCEP_1; + } + + /** + * Returns LSP State DB Version. + * @return raw value + */ + public long getLong() { + return rawValue; + } + + @Override + public short getLength() { + return LENGTH; + } + + @Override + public short getType() { + return TYPE; + } + + @Override + public int hashCode() { + return Objects.hash(rawValue); + } + + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + if (obj instanceof PcepLabelDbVerTlv) { + PcepLabelDbVerTlv other = (PcepLabelDbVerTlv) obj; + return Objects.equals(this.rawValue, other.rawValue); + } + return false; + } + + @Override + public int write(ChannelBuffer c) { + int iLenStartIndex = c.writerIndex(); + c.writeShort(TYPE); + c.writeShort(LENGTH); + c.writeLong(rawValue); + return c.writerIndex() - iLenStartIndex; + } + + /** + * Reads the channel buffer and returns object of PcepLabelDbVerTlv. + * + * @param c input channel buffer + * @return object of PcepLabelDbVerTlv + */ + public static PcepLabelDbVerTlv read(ChannelBuffer c) { + return PcepLabelDbVerTlv.of(c.readLong()); + } + + @Override + public String toString() { + return MoreObjects.toStringHelper(getClass()) + .add("Type", TYPE) + .add("Length", LENGTH) + .add("Value", rawValue) + .toString(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/PcepLabelDownload.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/PcepLabelDownload.java new file mode 100644 index 00000000..e2ad069c --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/PcepLabelDownload.java @@ -0,0 +1,105 @@ +/* + * 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.types; + +import java.util.LinkedList; + +import org.onosproject.pcepio.protocol.PcepLabelObject; +import org.onosproject.pcepio.protocol.PcepLspObject; +import org.onosproject.pcepio.protocol.PcepSrpObject; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.google.common.base.MoreObjects; + +/** + * Provides Pcep Label. + * REference :draft-zhao-pce-pcep-extension-for-pce-controller-01. + */ +public class PcepLabelDownload { + + protected static final Logger log = LoggerFactory.getLogger(PcepLabelDownload.class); + + //PCEP SPR Object + private PcepSrpObject srpObject; + //PCEP LSP Object + private PcepLspObject lspObject; + //LinkList of Labels + private LinkedList<PcepLabelObject> llLabelList; + + /** + * Returns SRP Object. + * + * @return PCEP SRP Object + */ + public PcepSrpObject getSrpObject() { + return srpObject; + } + + /** + * Sets the Pcep SRP Object. + * + * @param srpobj PCEP SRP Object + */ + public void setSrpObject(PcepSrpObject srpobj) { + this.srpObject = srpobj; + } + + /** + * Returns LSP Object. + * + * @return PCEP LSP Object + */ + public PcepLspObject getLspObject() { + return lspObject; + } + + /** + * Sets the Pcep LSP Object. + * + * @param lspObject PCEP LSP Object + */ + public void setLspObject(PcepLspObject lspObject) { + this.lspObject = lspObject; + } + + /** + * Returns a list of labels. + * + * @return llLabelList list of pcep label objects + */ + public LinkedList<PcepLabelObject> getLabelList() { + return llLabelList; + } + + /** + * set the llLabelList list of type PcepLableObject. + * + * @param llLabelList list of pcep label objects + */ + public void setLabelList(LinkedList<PcepLabelObject> llLabelList) { + this.llLabelList = llLabelList; + } + + @Override + public String toString() { + return MoreObjects.toStringHelper(getClass()) + .add("SrpObject", srpObject) + .add("LspObject", lspObject) + .add("LabelObjectList", llLabelList) + .toString(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/PcepLabelMap.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/PcepLabelMap.java new file mode 100644 index 00000000..2d3a953f --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/PcepLabelMap.java @@ -0,0 +1,103 @@ +/* + * 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.types; + +import org.onosproject.pcepio.protocol.PcepFecObject; +import org.onosproject.pcepio.protocol.PcepLabelObject; +import org.onosproject.pcepio.protocol.PcepSrpObject; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.google.common.base.MoreObjects; + +/** + * Provide PCEP Label Map. + * Reference :draft-zhao-pce-pcep-extension-for-pce-controller-01. + */ +public class PcepLabelMap { + + protected static final Logger log = LoggerFactory.getLogger(PcepLabelMap.class); + //PCEP SRP Object + private PcepSrpObject srpObject; + //PCEP Label Object + private PcepLabelObject labelObject; + //PCEP FEC Object + private PcepFecObject fecObject; + + /** + * Sets Fec Object. + * + * @param fecObject PCEP fec object + */ + public void setFECObject(PcepFecObject fecObject) { + this.fecObject = fecObject; + } + + /** + * Returns the PcepFecObject. + * + * @return PCEP fec object + */ + public PcepFecObject getFECObject() { + return this.fecObject; + } + + /** + * Returns SRP Object. + * + * @return PCEP SRP Object + */ + public PcepSrpObject getSrpObject() { + return srpObject; + } + + /** + * Sets the PCEP Srp Object. + * + * @param srpObject PCEP SRP Object + */ + public void setSrpObject(PcepSrpObject srpObject) { + this.srpObject = srpObject; + } + + /** + * Returns labelObject. + * + * @return PCEP label object + */ + public PcepLabelObject getLabelObject() { + return labelObject; + } + + /** + * Sets the Pcep labelObject. + * + * @param labelObject PCEP label object + */ + public void setLabelObject(PcepLabelObject labelObject) { + this.labelObject = labelObject; + } + + @Override + public String toString() { + return MoreObjects.toStringHelper(getClass()) + .add("SrpObject", srpObject) + .add("LabelObject", labelObject) + .add("FecObject", fecObject) + .toString(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/PcepNaiIpv4Adjacency.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/PcepNaiIpv4Adjacency.java new file mode 100644 index 00000000..1ed0ab14 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/PcepNaiIpv4Adjacency.java @@ -0,0 +1,107 @@ +/* + * 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.types; + +import java.util.Objects; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.pcepio.protocol.PcepNai; + +import com.google.common.base.MoreObjects; + +/** + * Provides Pcep Nai Ipv4 Adjacency. + */ +public class PcepNaiIpv4Adjacency implements PcepNai { + + public static final byte ST_TYPE = 0x03; + private final int localIpv4Addr; + private final int remoteIpv4Addr; + + /** + * Constructor to initialize variables. + * + * @param localIpv4 local ipv4 address + * @param remoteIpv4 remote ipv4 address + */ + public PcepNaiIpv4Adjacency(int localIpv4, int remoteIpv4) { + this.localIpv4Addr = localIpv4; + this.remoteIpv4Addr = remoteIpv4; + } + + /** + * Returns Object of Pcep nai Ipv4 Adjacency. + * + * @param localIpv4Addr local ipv4 address + * @param remoteIpv4Addr remote ipv4 address + * @return Object of Pcep nai Ipv4 Adjacency + */ + public static PcepNaiIpv4Adjacency of(int localIpv4Addr, int remoteIpv4Addr) { + return new PcepNaiIpv4Adjacency(localIpv4Addr, remoteIpv4Addr); + } + + @Override + public byte getType() { + return ST_TYPE; + } + + @Override + public int write(ChannelBuffer bb) { + int iLenStartIndex = bb.writerIndex(); + bb.writeInt(localIpv4Addr); + bb.writeInt(remoteIpv4Addr); + return bb.writerIndex() - iLenStartIndex; + } + + /** + * Reads the channel buffer and returns object of PcepNAIIpv4AdjacencyVer1. + * + * @param cb of channel buffer + * @return object of PcepNAIIpv4Adjacency + */ + public static PcepNaiIpv4Adjacency read(ChannelBuffer cb) { + int localIpv4 = cb.readInt(); + int remoteIpv4 = cb.readInt(); + return new PcepNaiIpv4Adjacency(localIpv4, remoteIpv4); + } + + @Override + public int hashCode() { + return Objects.hash(localIpv4Addr, remoteIpv4Addr); + } + + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + if (obj instanceof PcepNaiIpv4Adjacency) { + PcepNaiIpv4Adjacency other = (PcepNaiIpv4Adjacency) obj; + return Objects.equals(this.localIpv4Addr, other.localIpv4Addr) + && Objects.equals(this.remoteIpv4Addr, other.remoteIpv4Addr); + } + return false; + } + + @Override + public String toString() { + return MoreObjects.toStringHelper(getClass()) + .add("localIPv4Address", localIpv4Addr) + .add("remoteIPv4Address", remoteIpv4Addr) + .toString(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/PcepNaiIpv4NodeId.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/PcepNaiIpv4NodeId.java new file mode 100644 index 00000000..1d4ce5d4 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/PcepNaiIpv4NodeId.java @@ -0,0 +1,99 @@ +/* + * 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.types; + +import java.util.Objects; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.pcepio.protocol.PcepNai; + +import com.google.common.base.MoreObjects; + +/** + * Provides Pcep Nai Ipv4 Node Id. + */ +public class PcepNaiIpv4NodeId implements PcepNai { + + public static final byte ST_TYPE = 0x01; + + private final int ipv4NodeId; + + /** + * Constructor to initialize ipv4NodeId. + * + * @param value ipv4 node id + */ + public PcepNaiIpv4NodeId(int value) { + this.ipv4NodeId = value; + } + + /** + * Returns an object of PcepNaiIpv4NodeId. + * + * @param value ipv4 node id + * @return object of PcepNaiIpv4NodeId + */ + public static PcepNaiIpv4NodeId of(int value) { + return new PcepNaiIpv4NodeId(value); + } + + @Override + public byte getType() { + return ST_TYPE; + } + + @Override + public int write(ChannelBuffer bb) { + int iLenStartIndex = bb.writerIndex(); + bb.writeInt(ipv4NodeId); + return bb.writerIndex() - iLenStartIndex; + } + + /** + * Reads from the channel buffer and returns object of PcepNAIIpv4NodeIdVer1. + * + * @param bb of channel buffer. + * @return object of PcepNAIIpv4NodeIdVer1 + */ + public static PcepNaiIpv4NodeId read(ChannelBuffer bb) { + return new PcepNaiIpv4NodeId(bb.readInt()); + } + + @Override + public int hashCode() { + return Objects.hash(ipv4NodeId); + } + + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + if (obj instanceof PcepNaiIpv4NodeId) { + PcepNaiIpv4NodeId other = (PcepNaiIpv4NodeId) obj; + return Objects.equals(this.ipv4NodeId, other.ipv4NodeId); + } + return false; + } + + @Override + public String toString() { + return MoreObjects.toStringHelper(getClass()) + .add("IPv4NodeId", ipv4NodeId) + .toString(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/PcepNaiIpv6Adjacency.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/PcepNaiIpv6Adjacency.java new file mode 100644 index 00000000..3a177d99 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/PcepNaiIpv6Adjacency.java @@ -0,0 +1,113 @@ +/* + * 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.types; + +import java.util.Objects; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.pcepio.protocol.PcepNai; + +import com.google.common.base.MoreObjects; + +/** + * Provides Pcep Nai Ipv6 Adjacency. + */ +public class PcepNaiIpv6Adjacency implements PcepNai { + + public static final byte ST_TYPE = 0x04; + public static final byte IPV6_LEN = 0x10; + + private final byte[] localIpv6Addr; + private final byte[] remoteIpv6Addr; + + /** + * Constructor to initialize local ipv6 and remote ipv6. + * + * @param localIpv6 local ipv6 address + * @param remoteIpv6 remote ipv6 address + */ + public PcepNaiIpv6Adjacency(byte[] localIpv6, byte[] remoteIpv6) { + this.localIpv6Addr = localIpv6; + this.remoteIpv6Addr = remoteIpv6; + } + + @Override + public byte getType() { + return ST_TYPE; + } + + @Override + public int write(ChannelBuffer bb) { + int iLenStartIndex = bb.writerIndex(); + bb.writeBytes(localIpv6Addr); + bb.writeBytes(remoteIpv6Addr); + return bb.writerIndex() - iLenStartIndex; + } + + /** + * Reads from channel buffer and returns object of PcepNAIIpv6AdjacencyVer1. + * + * @param bb of type channel buffer + * @return object of PcepNAIIpv6AdjacencyVer1 + */ + public static PcepNaiIpv6Adjacency read(ChannelBuffer bb) { + byte[] localIpv6 = new byte[IPV6_LEN]; + bb.readBytes(localIpv6, 0, IPV6_LEN); + byte[] remoteIpv6 = new byte[IPV6_LEN]; + bb.readBytes(remoteIpv6, 0, IPV6_LEN); + return new PcepNaiIpv6Adjacency(localIpv6, remoteIpv6); + } + + @Override + public int hashCode() { + return Objects.hash(localIpv6Addr, remoteIpv6Addr); + } + + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + if (obj instanceof PcepNaiIpv6Adjacency) { + PcepNaiIpv6Adjacency other = (PcepNaiIpv6Adjacency) obj; + return Objects.equals(this.localIpv6Addr, other.localIpv6Addr) + && Objects.equals(this.remoteIpv6Addr, other.remoteIpv6Addr); + } + return false; + } + + /** + * Creates object of PcepNaiIpv6Adjacency with local ipv6 address and remote ipv6 address. + * + * @param localIpv6Addr local ipv6 address + * @param remoteIpv6Addr remote ipv6 address + * @return object of PcepNaiIpv6Adjacency + */ + + public static PcepNaiIpv6Adjacency of(final byte[] localIpv6Addr, final byte[] remoteIpv6Addr) { + return new PcepNaiIpv6Adjacency(localIpv6Addr, remoteIpv6Addr); + } + + @Override + public String toString() { + return MoreObjects.toStringHelper(getClass()) + .add("localIPV6Address", localIpv6Addr) + .add("remoteIPV6Address", remoteIpv6Addr) + .toString(); + } + +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/PcepNaiIpv6NodeId.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/PcepNaiIpv6NodeId.java new file mode 100644 index 00000000..3b7d52fd --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/PcepNaiIpv6NodeId.java @@ -0,0 +1,102 @@ +/* + * 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.types; + +import java.util.Objects; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.pcepio.protocol.PcepNai; + +import com.google.common.base.MoreObjects; + +/** + * Provides Pcep Nai Ipv6 Node Id. + */ +public class PcepNaiIpv6NodeId implements PcepNai { + + public static final byte ST_TYPE = 0x02; + public static final byte IPV6_LEN = 0x10; + + private final byte[] ipv6NodeId; + + /** + * Constructor to initialize ipv6NodeId. + * + * @param value ipv6 node id + */ + public PcepNaiIpv6NodeId(byte[] value) { + this.ipv6NodeId = value; + } + + /** + * Return object of Pcep Nai Ipv6 Node ID. + * + * @param ipv6NodeId Ipv6 node ID. + * @return object of Pcep Nai Ipv6 Node ID. + */ + public static PcepNaiIpv6NodeId of(byte[] ipv6NodeId) { + return new PcepNaiIpv6NodeId(ipv6NodeId); + } + + @Override + public byte getType() { + return ST_TYPE; + } + + @Override + public int write(ChannelBuffer cb) { + int iLenStartIndex = cb.writerIndex(); + cb.writeBytes(ipv6NodeId); + return cb.writerIndex() - iLenStartIndex; + } + + /** + * Reads from the channel buffer and returns object of PcepNAIIpv6NodeId. + * + * @param cb of type channel buffer. + * @return object of PcepNAIIpv6NodeId + */ + public static PcepNaiIpv6NodeId read(ChannelBuffer cb) { + byte[] ipv6NodeId = new byte[IPV6_LEN]; + cb.readBytes(ipv6NodeId, 0, IPV6_LEN); + return new PcepNaiIpv6NodeId(ipv6NodeId); + } + + @Override + public int hashCode() { + return Objects.hash(ipv6NodeId); + } + + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + if (obj instanceof PcepNaiIpv6NodeId) { + PcepNaiIpv6NodeId other = (PcepNaiIpv6NodeId) obj; + return Objects.equals(this.ipv6NodeId, other.ipv6NodeId); + } + return false; + } + + @Override + public String toString() { + return MoreObjects.toStringHelper(getClass()) + .add("IPV6NodeID", ipv6NodeId) + .toString(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/PcepNaiUnnumberedAdjacencyIpv4.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/PcepNaiUnnumberedAdjacencyIpv4.java new file mode 100644 index 00000000..4e8926cf --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/PcepNaiUnnumberedAdjacencyIpv4.java @@ -0,0 +1,131 @@ +/* + * 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.types; + +import java.util.Objects; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.pcepio.protocol.PcepNai; + +import com.google.common.base.MoreObjects; + +/** + * Provides Pcep Nai Unnumbered Adjacency Ipv4. + */ +public class PcepNaiUnnumberedAdjacencyIpv4 implements PcepNai { + /** + * draft-ietf-pce-segment-routing-03 section 5.3.2. + */ + public static final byte ST_TYPE = 0x05; + + private final int localNodeId; + private final int localInterfaceId; + private final int remoteNodeId; + private final int remoteInterfaceId; + + /** + * Constructor to initialize all the member variables. + * + * @param localNodeId local node id + * @param localInterfaceId local interface id + * @param remoteNodeId remote node id + * @param remoteInterfaceId remote interface id + */ + public PcepNaiUnnumberedAdjacencyIpv4(int localNodeId, int localInterfaceId, int remoteNodeId, + int remoteInterfaceId) { + this.localNodeId = localNodeId; + this.localInterfaceId = localInterfaceId; + this.remoteNodeId = remoteNodeId; + this.remoteInterfaceId = remoteInterfaceId; + } + + /** + * Returns PCEP Nai Unnumbered Adjacency Ipv4 object. + * + * @param localNodeId local node id + * @param localInterfaceId local interface if + * @param remoteNodeId remote node id + * @param remoteInterfaceId remote interface id + * @return PCEP Nai Unnumbered Adjacency Ipv4 object + */ + public static PcepNaiUnnumberedAdjacencyIpv4 of(int localNodeId, int localInterfaceId, int remoteNodeId, + int remoteInterfaceId) { + return new PcepNaiUnnumberedAdjacencyIpv4(localNodeId, localInterfaceId, remoteNodeId, remoteInterfaceId); + } + + @Override + public byte getType() { + return ST_TYPE; + } + + @Override + public int write(ChannelBuffer bb) { + int iLenStartIndex = bb.writerIndex(); + bb.writeInt(localNodeId); + bb.writeInt(localInterfaceId); + bb.writeInt(remoteNodeId); + bb.writeInt(remoteInterfaceId); + return bb.writerIndex() - iLenStartIndex; + } + + /** + * Reads from channel buffer and return object of PcepNAIUnnumberedAdjacencyIpv4. + * + * @param bb of type channel buffer + * @return object of PcepNAIUnnumberedAdjacencyIpv4 + */ + public static PcepNaiUnnumberedAdjacencyIpv4 read(ChannelBuffer bb) { + int localNodeId; + int localInterfaceId; + int remoteNodeId; + int remoteInterfaceId; + localNodeId = bb.readInt(); + localInterfaceId = bb.readInt(); + remoteNodeId = bb.readInt(); + remoteInterfaceId = bb.readInt(); + return new PcepNaiUnnumberedAdjacencyIpv4(localNodeId, localInterfaceId, remoteNodeId, remoteInterfaceId); + } + + @Override + public int hashCode() { + return Objects.hash(localNodeId, localInterfaceId, remoteNodeId, remoteInterfaceId); + } + + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + if (obj instanceof PcepNaiUnnumberedAdjacencyIpv4) { + PcepNaiUnnumberedAdjacencyIpv4 other = (PcepNaiUnnumberedAdjacencyIpv4) obj; + return Objects.equals(this.localNodeId, other.localNodeId) + && Objects.equals(this.localInterfaceId, other.localInterfaceId) + && Objects.equals(this.remoteNodeId, other.remoteNodeId) + && Objects.equals(this.remoteInterfaceId, other.remoteInterfaceId); + } + return false; + } + + @Override + public String toString() { + return MoreObjects.toStringHelper(getClass()) + .add("localNodeId", localNodeId) + .add("localInterfaceId", localInterfaceId) + .add("remoteNodeId", remoteNodeId) + .add("remoteInterfaceId", remoteInterfaceId) + .toString(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/PcepObjectHeader.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/PcepObjectHeader.java new file mode 100644 index 00000000..a4af6746 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/PcepObjectHeader.java @@ -0,0 +1,224 @@ +/* + * 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.types; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.google.common.base.MoreObjects; + +/** + * Provides PCEP Object Header which is common for all the objects. + * Reference : RFC 5440. + */ + +public class PcepObjectHeader { + + /* + 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 + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Object-Class | OT |Res|P|I| Object Length (bytes) | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | | + // (Object body) // + | | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + + PCEP Common Object Header + */ + + protected static final Logger log = LoggerFactory.getLogger(PcepObjectHeader.class); + + public static final boolean REQ_OBJ_MUST_PROCESS = true; + public static final boolean REQ_OBJ_OPTIONAL_PROCESS = false; + public static final boolean RSP_OBJ_IGNORED = true; + public static final boolean RSP_OBJ_PROCESSED = false; + public static final int OBJECT_TYPE_SHIFT_VALUE = 4; + public static final byte PFLAG_SET = 0x02; + public static final byte IFLAG_SET = 0x01; + public static final int SET = 1; + private byte objClass; + private byte objType; + private boolean bPFlag; + private boolean bIFlag; + private short objLen; + + /** + * Constructor to initialize all the variables in object header. + * + * @param objClass PCEP Object class + * @param objType PCEP Object type + * @param bPFlag P flag + * @param bIFlag I flag + * @param objLen PCEP object length + */ + + public PcepObjectHeader(byte objClass, byte objType, boolean bPFlag, boolean bIFlag, short objLen) { + this.objClass = objClass; + this.objType = objType; + this.bPFlag = bPFlag; + this.bIFlag = bIFlag; + this.objLen = objLen; + } + + /** + * Sets the Object class. + * + * @param value object class + */ + public void setObjClass(byte value) { + this.objClass = value; + } + + /** + * Sets the Object TYPE. + * + * @param value object type + */ + public void setObjType(byte value) { + this.objType = value; + } + + /** + * Sets the Object P flag. + * + * @param value p flag + */ + public void setPFlag(boolean value) { + this.bPFlag = value; + } + + /** + * Sets the Object I flag. + * + * @param value I flag + */ + public void setIFlag(boolean value) { + this.bIFlag = value; + } + + /** + * Sets the Object Length. + * + * @param value object length + */ + public void setObjLen(short value) { + this.objLen = value; + } + + /** + * Returns Object's P flag. + * + * @return bPFlag P flag + */ + public boolean getPFlag() { + return this.bPFlag; + } + + /** + * Returns Object's i flag. + * + * @return bIFlag I flag + */ + public boolean getIFlag() { + return this.bIFlag; + } + + /** + * Returns Object Length. + * + * @return objLen object length + */ + public short getObjLen() { + return this.objLen; + } + + /** + * Returns Object class. + * + * @return objClass object class + */ + public byte getObjClass() { + return this.objClass; + } + + /** + * Returns Object Type. + * + * @return objType object type + */ + public byte getObjType() { + return this.objType; + } + + /** + * Writes Byte stream of PCEP object header to channel buffer. + * + * @param cb output channel buffer + * @return objLenIndex object length index in channel buffer + */ + public int write(ChannelBuffer cb) { + + cb.writeByte(this.objClass); + byte temp = (byte) (this.objType << OBJECT_TYPE_SHIFT_VALUE); + if (this.bPFlag) { + temp = (byte) (temp | PFLAG_SET); + } + if (this.bIFlag) { + temp = (byte) (temp | IFLAG_SET); + } + cb.writeByte(temp); + int objLenIndex = cb.writerIndex(); + cb.writeShort((short) 0); + return objLenIndex; + } + + /** + * Read from channel buffer and Returns PCEP Objects header. + * + * @param cb of type channel buffer + * @return PCEP Object header + */ + public static PcepObjectHeader read(ChannelBuffer cb) { + + byte objClass; + byte objType; + boolean bPFlag; + boolean bIFlag; + short objLen; + objClass = cb.readByte(); + byte temp = cb.readByte(); + bIFlag = (temp & IFLAG_SET) == IFLAG_SET; + bPFlag = (temp & PFLAG_SET) == PFLAG_SET; + objType = (byte) (temp >> OBJECT_TYPE_SHIFT_VALUE); + objLen = cb.readShort(); + return new PcepObjectHeader(objClass, objType, bPFlag, bIFlag, objLen); + } + + @Override + public String toString() { + return MoreObjects.toStringHelper(getClass()) + .add("ObjectClass", objClass) + .add("ObjectType", objType) + .add("ObjectLength", objLen) + .add("PFlag", (bPFlag) ? 1 : 0) + .add("IFlag", (bIFlag) ? 1 : 0) + .toString(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/PcepRsvpErrorSpec.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/PcepRsvpErrorSpec.java new file mode 100644 index 00000000..8d3c67a7 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/PcepRsvpErrorSpec.java @@ -0,0 +1,46 @@ +/* + * 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.types; + +import org.jboss.netty.buffer.ChannelBuffer; + +/** + * Abstraction of an entity which provides PCPE RSVP error spec. + */ +public interface PcepRsvpErrorSpec extends PcepValueType { + + /** + * To write the object information to channelBuffer. + * + * @param cb of type channel buffer + */ + @Override + int write(ChannelBuffer cb); + + /** + * Returns class number. + * + * @return class number + */ + byte getClassNum(); + + /** + * Returns class type. + * + * @return class type + */ + byte getClassType(); +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/PcepRsvpIpv4ErrorSpec.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/PcepRsvpIpv4ErrorSpec.java new file mode 100644 index 00000000..326b66b7 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/PcepRsvpIpv4ErrorSpec.java @@ -0,0 +1,160 @@ +/* + * 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.types; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.pcepio.protocol.PcepVersion; + +import com.google.common.base.MoreObjects; + +/** + * Provides Pcep Rsvp Ipv4 Error Spec. + */ +public class PcepRsvpIpv4ErrorSpec implements PcepRsvpErrorSpec { + + /* + RSVP error spec object header. + 0 1 2 3 + +-------------+-------------+-------------+-------------+ + | Length (bytes) | Class-Num | C-Type | + +-------------+-------------+-------------+-------------+ + | | + // (Object contents) // + | | + +-------------+-------------+-------------+-------------+ + + Ref : ERROR_SPEC @ RFC2205 + + IPv4 ERROR_SPEC object: Class = 6, C-Type = 1 + +-------------+-------------+-------------+-------------+ + | IPv4 Error Node Address (4 bytes) | + +-------------+-------------+-------------+-------------+ + | Flags | Error Code | Error Value | + +-------------+-------------+-------------+-------------+ + + */ + + PcepRsvpSpecObjHeader objHeader; + public static final byte CLASS_NUM = 0x06; + public static final byte CLASS_TYPE = 0x01; + public static final byte CLASS_LENGTH = 0x0c; + private int ipv4Addr; + private byte flags; + private byte errCode; + private short errValue; + + /** + * Constructor to initialize obj header, ipv4 addr, flags, err code and err value. + * + * @param objHeader rsvp ipv4 error spec object header + * @param ipv4Addr ipv4 address + * @param flags flags value + * @param errCode error code value + * @param errValue error value + */ + public PcepRsvpIpv4ErrorSpec(PcepRsvpSpecObjHeader objHeader, int ipv4Addr, byte flags, byte errCode, + short errValue) { + this.objHeader = objHeader; + this.ipv4Addr = ipv4Addr; + this.flags = flags; + this.errCode = errCode; + this.errValue = errValue; + } + + /** + * Constructor to initialize ipv4 address, flags, err code and err value. + * + * @param ipv4Addr ipv4 address + * @param flags flags value + * @param errCode error code + * @param errValue error value + */ + public PcepRsvpIpv4ErrorSpec(int ipv4Addr, byte flags, byte errCode, short errValue) { + this.objHeader = new PcepRsvpSpecObjHeader(CLASS_LENGTH, CLASS_NUM, CLASS_TYPE); + this.ipv4Addr = ipv4Addr; + this.flags = flags; + this.errCode = errCode; + this.errValue = errValue; + } + + @Override + public int write(ChannelBuffer cb) { + int objLenIndex = objHeader.write(cb); + cb.writeInt(ipv4Addr); + cb.writeByte(flags); + cb.writeByte(errCode); + cb.writeShort(errValue); + short objLen = (short) (cb.writerIndex() - objLenIndex); + cb.setShort(objLenIndex, objLen); + return objLen; + } + + /** + * Reads PCPE RSVP error spec from channel buffer and returns PCEP rsvp IPv4 error spec object. + * + * @param cb channel buffer + * @return PCEP rsvp IPv4 error spec object + */ + public static PcepRsvpErrorSpec read(ChannelBuffer cb) { + PcepRsvpSpecObjHeader objHeader; + int ipv4Addr; + byte flags; + byte errCode; + short errValue; + + objHeader = PcepRsvpSpecObjHeader.read(cb); + ipv4Addr = cb.readInt(); + flags = cb.readByte(); + errCode = cb.readByte(); + errValue = cb.readShort(); + return new PcepRsvpIpv4ErrorSpec(objHeader, ipv4Addr, flags, errCode, errValue); + } + + @Override + public PcepVersion getVersion() { + return PcepVersion.PCEP_1; + } + + @Override + public short getType() { + return StatefulRsvpErrorSpecTlv.TYPE; + } + + @Override + public short getLength() { + return CLASS_LENGTH; + } + + @Override + public byte getClassNum() { + return CLASS_NUM; + } + + @Override + public byte getClassType() { + return CLASS_TYPE; + } + + @Override + public String toString() { + return MoreObjects.toStringHelper(getClass()) + .add("IPv4Address", ipv4Addr) + .add("flags", flags) + .add("errorCode", errCode) + .add("errorValue", errValue) + .toString(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/PcepRsvpIpv6ErrorSpec.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/PcepRsvpIpv6ErrorSpec.java new file mode 100644 index 00000000..4da1ec6d --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/PcepRsvpIpv6ErrorSpec.java @@ -0,0 +1,165 @@ +/* + * 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.types; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.pcepio.protocol.PcepVersion; + +import com.google.common.base.MoreObjects; + +/** + * Provides Pcep Rsvp Ipv6 Error Spec. + */ +public class PcepRsvpIpv6ErrorSpec implements PcepRsvpErrorSpec { + + /* + 0 1 2 3 + +-------------+-------------+-------------+-------------+ + | Length (bytes) | Class-Num | C-Type | + +-------------+-------------+-------------+-------------+ + | | + // (Object contents) // + | | + +-------------+-------------+-------------+-------------+ + + Ref : ERROR_SPEC @ RFC2205 + + IPv6 ERROR_SPEC object: Class = 6, C-Type = 2 + +-------------+-------------+-------------+-------------+ + | | + + + + | | + + IPv6 Error Node Address (16 bytes) + + | | + + + + | | + +-------------+-------------+-------------+-------------+ + | Flags | Error Code | Error Value | + +-------------+-------------+-------------+-------------+ */ + + PcepRsvpSpecObjHeader objHeader; + public static final byte CLASS_NUM = 0x06; + public static final byte CLASS_TYPE = 0x02; + public static final byte CLASS_LENGTH = 0x18; + public static final byte IPV6_LEN = 0x10; + + private byte[] ipv6Addr; + private byte flags; + private byte errCode; + private short errValue; + + /** + * Constructor to initialize obj header, ipv6 addr, flags, err code and err value. + * + * @param objHeader rsvp ipv6 error spec object header + * @param ipv6Addr ipv6 address + * @param flags flags value + * @param errCode error code + * @param errValue error value + */ + public PcepRsvpIpv6ErrorSpec(PcepRsvpSpecObjHeader objHeader, byte[] ipv6Addr, byte flags, byte errCode, + short errValue) { + this.objHeader = objHeader; + this.ipv6Addr = ipv6Addr; + this.flags = flags; + this.errCode = errCode; + this.errValue = errValue; + } + + /** + * Constructor to initialize ipv6 addr, flags, err code and err value. + * + * @param ipv6Addr ipv6 address + * @param flags flags value + * @param errCode error code + * @param errValue error value + */ + public PcepRsvpIpv6ErrorSpec(byte[] ipv6Addr, byte flags, byte errCode, short errValue) { + this.objHeader = new PcepRsvpSpecObjHeader(CLASS_LENGTH, CLASS_NUM, CLASS_TYPE); + this.ipv6Addr = ipv6Addr; + this.flags = flags; + this.errCode = errCode; + this.errValue = errValue; + } + + @Override + public int write(ChannelBuffer cb) { + int objLenIndex = objHeader.write(cb); + cb.writeBytes(ipv6Addr); + cb.writeByte(flags); + cb.writeByte(errCode); + cb.writeShort(errValue); + short objLen = (short) (cb.writerIndex() - objLenIndex); + cb.setShort(objLenIndex, objLen); + return objLen; + } + + /** + * Returns PCEP rsvp IPv6 error spce object. + * + * @param cb channel buffer + * @return PCEP rsvp IPv6 error spce object + */ + public static PcepRsvpErrorSpec read(ChannelBuffer cb) { + PcepRsvpSpecObjHeader objHeader; + byte[] ipv6Addr = new byte[IPV6_LEN]; + byte flags; + byte errCode; + short errValue; + + objHeader = PcepRsvpSpecObjHeader.read(cb); + cb.readBytes(ipv6Addr, 0, IPV6_LEN); + flags = cb.readByte(); + errCode = cb.readByte(); + errValue = cb.readShort(); + return new PcepRsvpIpv6ErrorSpec(objHeader, ipv6Addr, flags, errCode, errValue); + } + + @Override + public PcepVersion getVersion() { + return PcepVersion.PCEP_1; + } + + @Override + public short getType() { + return StatefulRsvpErrorSpecTlv.TYPE; + } + + @Override + public short getLength() { + return CLASS_LENGTH; + } + + @Override + public byte getClassNum() { + return CLASS_NUM; + } + + @Override + public byte getClassType() { + return CLASS_TYPE; + } + + @Override + public String toString() { + return MoreObjects.toStringHelper(getClass()) + .add("IPv6Address", ipv6Addr) + .add("flags", flags) + .add("errorCode", errCode) + .add("errorValue", errValue) + .toString(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/PcepRsvpObjectHeader.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/PcepRsvpObjectHeader.java new file mode 100644 index 00000000..bddcb898 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/PcepRsvpObjectHeader.java @@ -0,0 +1,161 @@ +/* + * 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.types; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.google.common.base.MoreObjects; + +/** + * Provides PcepRsvpObjectHeader. + */ +public class PcepRsvpObjectHeader { + + /* + 0 1 2 3 + +-------------+-------------+-------------+-------------+ + | Length (bytes) | Class-Num | C-Type | + +-------------+-------------+-------------+-------------+ + | | + // (Object contents) // + | | + +-------------+-------------+-------------+-------------+ + + ERROR_SPEC object Header + */ + + protected static final Logger log = LoggerFactory.getLogger(PcepRsvpObjectHeader.class); + + public static final boolean REQ_OBJ_MUST_PROCESS = true; + public static final boolean REQ_OBJ_OPTIONAL_PROCESS = false; + public static final boolean RSP_OBJ_IGNORED = true; + public static final boolean RSP_OBJ_PROCESSED = false; + public static final int OBJECT_TYPE_SHIFT_VALUE = 4; + private byte objClassNum; + private byte objClassType; + private short objLen; + + /** + * Constructor to initialize class num, length and type. + * + * @param objClassNum object class number + * @param objClassType object class type + * @param objLen object length + */ + public PcepRsvpObjectHeader(byte objClassNum, byte objClassType, short objLen) { + this.objClassNum = objClassNum; + this.objClassType = objClassType; + this.objLen = objLen; + } + + /** + * Sets the Class-Num. + * + * @param value object class number + */ + public void setObjClassNum(byte value) { + this.objClassNum = value; + } + + /** + * Sets the Class type. + * + * @param value object class type + */ + public void setObjClassType(byte value) { + this.objClassType = value; + } + + /** + * Sets the Class Length. + * + * @param value object length + */ + public void setObjLen(short value) { + this.objLen = value; + } + + /** + * Returns Object Length. + * + * @return objLen + */ + public short getObjLen() { + return this.objLen; + } + + /** + * Returns Object num. + * + * @return objClassNum + */ + public byte getObjClassNum() { + return this.objClassNum; + } + + /** + * Returns Object type. + * + * @return objClassType + */ + public byte getObjClassType() { + return this.objClassType; + } + + /** + * Writes the byte stream of PcepRsvpObjectHeader to channel buffer. + * + * @param cb of type channel buffer + * @return object length index in channel buffer + */ + public int write(ChannelBuffer cb) { + int iLenStartIndex = cb.writerIndex(); + cb.writeShort((short) 0); + cb.writeByte(this.objClassNum); + cb.writeByte(this.objClassType); + return cb.writerIndex() - iLenStartIndex; + } + + /** + * Reads the PcepRsvpObjectHeader. + * + * @param cb input channel buffer + * @return PcepRsvpObjectHeader + */ + public static PcepRsvpObjectHeader read(ChannelBuffer cb) { + log.debug("read "); + byte objClassNum; + byte objClassType; + short objLen; + objLen = cb.readShort(); + objClassNum = cb.readByte(); + objClassType = cb.readByte(); + + return new PcepRsvpObjectHeader(objClassNum, objClassType, objLen); + } + + @Override + public String toString() { + return MoreObjects.toStringHelper(getClass()) + .add("ObjectClassNum", objClassNum) + .add("ObjectCType", objClassType) + .add("ObjectLength", objLen) + .toString(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/PcepRsvpSpecObjHeader.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/PcepRsvpSpecObjHeader.java new file mode 100644 index 00000000..132ff862 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/PcepRsvpSpecObjHeader.java @@ -0,0 +1,156 @@ +/* + * 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.types; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.google.common.base.MoreObjects; + +/** + * Provides PcepRsvpObjectHeader. + */ +public class PcepRsvpSpecObjHeader { + + /* + 0 1 2 3 + +-------------+-------------+-------------+-------------+ + | Length (bytes) | Class-Num | C-Type | + +-------------+-------------+-------------+-------------+ + | | + // (Object contents) // + | | + +-------------+-------------+-------------+-------------+ + + ERROR_SPEC object Header + */ + + protected static final Logger log = LoggerFactory.getLogger(PcepRsvpSpecObjHeader.class); + + private short objLen; + private byte objClassNum; + private byte objClassType; + + /** + * Constructor to initialize length, class num and type. + * + * @param objLen object length + * @param objClassNum pcep rsvp error spec object class num + * @param objClassType pcep rsvp error spec object class type + */ + public PcepRsvpSpecObjHeader(short objLen, byte objClassNum, byte objClassType) { + this.objLen = objLen; + this.objClassNum = objClassNum; + this.objClassType = objClassType; + } + + /** + * Sets the Class num. + * + * @param value pcep rsvp error spec object class num + */ + public void setObjClassNum(byte value) { + this.objClassNum = value; + } + + /** + * Sets the Class type. + * + * @param value pcep rsvp error spec object class type + */ + public void setObjClassType(byte value) { + this.objClassType = value; + } + + /** + * Sets the Class Length. + * + * @param value pcep rsvp error spec object length + */ + public void setObjLen(short value) { + this.objLen = value; + } + + /** + * Returns Object Length. + * + * @return objLen pcep rsvp error spec object length + */ + public short getObjLen() { + return this.objLen; + } + + /** + * Returns Object num. + * + * @return objClassNum pcep rsvp error spec object class num + */ + public byte getObjClassNum() { + return this.objClassNum; + } + + /** + * Returns Object type. + * + * @return objClassType pcep rsvp error spec object class type + */ + public byte getObjClassType() { + return this.objClassType; + } + + /** + * Writes the byte stream of PcepRsvpObjectHeader to channel buffer. + * + * @param cb of type channel buffer + * @return object length index + */ + public int write(ChannelBuffer cb) { + int objLenIndex = cb.writerIndex(); + objLen = 0; + cb.writeShort(objLen); + cb.writeByte(objClassNum); + cb.writeByte(objClassType); + return objLenIndex; + } + + /** + * Reads the PcepRsvpObjectHeader. + * + * @param cb of type channel buffer + * @return PcepRsvpObjectHeader + */ + public static PcepRsvpSpecObjHeader read(ChannelBuffer cb) { + byte objClassNum; + byte objClassType; + short objLen; + objLen = cb.readShort(); + objClassNum = cb.readByte(); + objClassType = cb.readByte(); + + return new PcepRsvpSpecObjHeader(objLen, objClassNum, objClassType); + } + + @Override + public String toString() { + return MoreObjects.toStringHelper(getClass()) + .add("ObjectClassNum: ", objClassNum) + .add("ObjectCType: ", objClassType) + .add("ObjectLength: ", objLen) + .toString(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/PcepRsvpUserErrorSpec.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/PcepRsvpUserErrorSpec.java new file mode 100644 index 00000000..4a9357de --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/PcepRsvpUserErrorSpec.java @@ -0,0 +1,220 @@ +/* + * 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.types; + +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.PcepVersion; + +import com.google.common.base.MoreObjects; + +/** + * Provides Pcep Rsvp User Error Spec. + */ +public class PcepRsvpUserErrorSpec implements PcepRsvpErrorSpec { + + /* + RSVP error spec object header. + 0 1 2 3 + +-------------+-------------+-------------+-------------+ + | Length (bytes) | Class-Num | C-Type | + +-------------+-------------+-------------+-------------+ + | | + // (Object contents) // + | | + +-------------+-------------+-------------+-------------+ + + Ref : USER_ERROR_SPEC @ RFC5284. + USER_ERROR_SPEC object: Class = 194, C-Type = 1 + + 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 + +---------------+---------------+---------------+---------------+ + | Enterprise Number | + +---------------+---------------+---------------+---------------+ + | Sub Org | Err Desc Len | User Error Value | + +---------------+---------------+---------------+---------------+ + | | + ~ Error Description ~ + | | + +---------------+---------------+---------------+---------------+ + | | + ~ User-Defined Subobjects ~ + | | + +---------------+---------------+---------------+---------------+ + */ + + public static final byte CLASS_NUM = (byte) 0xc2; + public static final byte CLASS_TYPE = 0x01; + + private PcepRsvpSpecObjHeader objHeader; + private int enterpriseNum; + private byte subOrg; + private byte errDescLen; + private short userErrorValue; + private byte[] errDesc; + private LinkedList<PcepValueType> llRsvpUserSpecSubObj; + + /** + * Default constructor. + * + * @param objHeader pcep rsvp spec object header + * @param enterpriseNum enterprise number + * @param subOrg organization identifier value + * @param errDescLen error description length + * @param userErrorValue user error value + * @param errDesc error description + * @param llRsvpUserSpecSubObj list of subobjects + */ + public PcepRsvpUserErrorSpec(PcepRsvpSpecObjHeader objHeader, int enterpriseNum, byte subOrg, byte errDescLen, + short userErrorValue, byte[] errDesc, LinkedList<PcepValueType> llRsvpUserSpecSubObj) { + this.objHeader = objHeader; + this.enterpriseNum = enterpriseNum; + this.subOrg = subOrg; + this.errDescLen = errDescLen; + this.userErrorValue = userErrorValue; + this.errDesc = errDesc; + this.llRsvpUserSpecSubObj = llRsvpUserSpecSubObj; + } + + @Override + public int write(ChannelBuffer cb) { + int objLenIndex = objHeader.write(cb); + cb.writeInt(enterpriseNum); + cb.writeByte(subOrg); + cb.writeByte(errDescLen); + cb.writeShort(userErrorValue); + cb.writeBytes(errDesc); + + if (llRsvpUserSpecSubObj != null) { + + ListIterator<PcepValueType> listIterator = llRsvpUserSpecSubObj.listIterator(); + + while (listIterator.hasNext()) { + PcepValueType tlv = listIterator.next(); + if (tlv == null) { + continue; + } + tlv.write(cb); + // need to take care of padding + int pad = tlv.getLength() % 4; + if (0 != pad) { + pad = 4 - pad; + for (int i = 0; i < pad; ++i) { + cb.writeByte((byte) 0); + } + } + } + } + short objLen = (short) (cb.writerIndex() - objLenIndex); + cb.setShort(objLenIndex, objLen); + return objLen; + } + + /** + * Reads the channel buffer and returns object of PcepRsvpErrorSpec. + * + * @param cb of type channel buffer + * @return object of PcepRsvpErrorSpec + * @throws PcepParseException when expected object is not received + */ + public static PcepRsvpErrorSpec read(ChannelBuffer cb) throws PcepParseException { + PcepRsvpSpecObjHeader objHeader; + int enterpriseNum; + byte subOrg; + byte errDescLen; + short userErrorValue; + byte[] errDesc; + LinkedList<PcepValueType> llRsvpUserSpecSubObj = null; + + objHeader = PcepRsvpSpecObjHeader.read(cb); + + if (objHeader.getObjClassNum() != CLASS_NUM || objHeader.getObjClassType() != CLASS_TYPE) { + throw new PcepParseException("Expected PcepRsvpUserErrorSpec object."); + } + enterpriseNum = cb.readInt(); + subOrg = cb.readByte(); + errDescLen = cb.readByte(); + userErrorValue = cb.readShort(); + errDesc = new byte[errDescLen]; + cb.readBytes(errDesc, 0, errDescLen); + + llRsvpUserSpecSubObj = parseErrSpecSubObj(cb); + + return new PcepRsvpUserErrorSpec(objHeader, enterpriseNum, subOrg, errDescLen, userErrorValue, errDesc, + llRsvpUserSpecSubObj); + } + + private static LinkedList<PcepValueType> parseErrSpecSubObj(ChannelBuffer cb) throws PcepParseException { + LinkedList<PcepValueType> llRsvpUserSpecSubObj = new LinkedList<>(); + while (0 < cb.readableBytes()) { + PcepValueType tlv = null; + short hType = cb.readShort(); + int iValue = 0; + //short hLength = cb.readShort(); + switch (hType) { + case AutonomousSystemTlv.TYPE: + iValue = cb.readInt(); + tlv = new AutonomousSystemTlv(iValue); + break; + default: + throw new PcepParseException("Unsupported Sub TLV type :" + hType); + } + llRsvpUserSpecSubObj.add(tlv); + } + return llRsvpUserSpecSubObj; + } + + @Override + public PcepVersion getVersion() { + return PcepVersion.PCEP_1; + } + + @Override + public short getType() { + return StatefulRsvpErrorSpecTlv.TYPE; + } + + @Override + public short getLength() { + return objHeader.getObjLen(); + } + + @Override + public byte getClassNum() { + return CLASS_NUM; + } + + @Override + public byte getClassType() { + return CLASS_TYPE; + } + + @Override + public String toString() { + return MoreObjects.toStringHelper(getClass()) + .add("enterpriseNumber", enterpriseNum) + .add("subOrganization", subOrg) + .add("errDescLength", errDescLen) + .add("userErrorValue", userErrorValue) + .add("errDesc", errDesc) + .add("RsvpUserSpecSubObject", llRsvpUserSpecSubObj) + .toString(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/PcepValueType.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/PcepValueType.java new file mode 100755 index 00000000..c960e7ac --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/PcepValueType.java @@ -0,0 +1,55 @@ +/* + * 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.types; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.pcepio.protocol.PcepVersion; + +/** + * Abstraction which Provides the PCEP Values of Type, Length ,Version. + */ +public interface PcepValueType { + + /** + * Returns the Version Of PCEP Message. + * + * @return Version of PcepVersion Type. + */ + PcepVersion getVersion(); + + /** + * Returns the Type of PCEP Message. + * + * @return value of type + */ + short getType(); + + /** + * Returns the Length of PCEP Message. + * + * @return value of Length + */ + short getLength(); + + /** + * Writes the byte Stream of PCEP Message to channel buffer. + * + * @param bb of type channel buffer + * @return length of bytes written to channel buffer + */ + int write(ChannelBuffer bb); +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/RemoteTENodeDescriptorsTlv.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/RemoteTENodeDescriptorsTlv.java new file mode 100644 index 00000000..aceb7ea0 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/RemoteTENodeDescriptorsTlv.java @@ -0,0 +1,250 @@ +/* + * 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.types; + +import java.util.Iterator; +import java.util.LinkedList; +import java.util.ListIterator; +import java.util.Objects; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.pcepio.exceptions.PcepParseException; +import org.onosproject.pcepio.protocol.PcepVersion; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.google.common.base.MoreObjects; + +/** + * Provides Remote TE Node Descriptors TLV. + */ +public class RemoteTENodeDescriptorsTlv implements PcepValueType { + + /* Reference :PCEP Extension for Transporting TE Data + draft-dhodylee-pce-pcep-te-data-extn-02 + * + 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 + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Type=[TBD9] | Length | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | | + // Node Descriptor Sub-TLVs (variable) // + | | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + */ + + protected static final Logger log = LoggerFactory.getLogger(RemoteTENodeDescriptorsTlv.class); + + public static final short TYPE = 1003; //TODD:change this TBD9 + public short hLength; + + public static final int TLV_HEADER_LENGTH = 4; + // Node Descriptor Sub-TLVs (variable) + private LinkedList<PcepValueType> llRemoteTENodeDescriptorSubTLVs; + + /** + * Constructor to initialize llRemoteTENodeDescriptorSubTLVs. + * + * @param llRemoteTENodeDescriptorSubTLVs LinkedList of PcepValueType + */ + public RemoteTENodeDescriptorsTlv(LinkedList<PcepValueType> llRemoteTENodeDescriptorSubTLVs) { + this.llRemoteTENodeDescriptorSubTLVs = llRemoteTENodeDescriptorSubTLVs; + } + + /** + * Returns object of Remote TE Node Descriptors TLV. + * + * @param llRemoteTENodeDescriptorSubTLVs LinkedList of PcepValueType + * @return object of RemoteTENodeDescriptorsTLV + */ + public static RemoteTENodeDescriptorsTlv of(final LinkedList<PcepValueType> llRemoteTENodeDescriptorSubTLVs) { + return new RemoteTENodeDescriptorsTlv(llRemoteTENodeDescriptorSubTLVs); + } + + /** + * Returns Remote TE Node Descriptor Sub TLVs. + * + * @return llRemoteTENodeDescriptorSubTLVs + */ + public LinkedList<PcepValueType> getllRemoteTENodeDescriptorSubTLVs() { + return llRemoteTENodeDescriptorSubTLVs; + } + + @Override + public PcepVersion getVersion() { + return PcepVersion.PCEP_1; + } + + @Override + public short getType() { + return TYPE; + } + + @Override + public short getLength() { + return hLength; + } + + @Override + public int hashCode() { + return Objects.hash(llRemoteTENodeDescriptorSubTLVs.hashCode()); + } + + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + /* + * Here we have a list of Tlv so to compare each sub tlv between the object + * we have to take a list iterator so one by one we can get each sub tlv object + * and can compare them. + * it may be possible that the size of 2 lists is not equal so we have to first check + * the size, if both are same then we should check for the subtlv objects otherwise + * we should return false. + */ + if (obj instanceof RemoteTENodeDescriptorsTlv) { + int countObjSubTlv = 0; + int countOtherSubTlv = 0; + boolean isCommonSubTlv = true; + RemoteTENodeDescriptorsTlv other = (RemoteTENodeDescriptorsTlv) obj; + Iterator<PcepValueType> objListIterator = ((RemoteTENodeDescriptorsTlv) obj).llRemoteTENodeDescriptorSubTLVs + .iterator(); + countObjSubTlv = ((RemoteTENodeDescriptorsTlv) obj).llRemoteTENodeDescriptorSubTLVs.size(); + countOtherSubTlv = other.llRemoteTENodeDescriptorSubTLVs.size(); + if (countObjSubTlv != countOtherSubTlv) { + return false; + } else { + while (objListIterator.hasNext() && isCommonSubTlv) { + PcepValueType subTlv = objListIterator.next(); + isCommonSubTlv = Objects.equals(llRemoteTENodeDescriptorSubTLVs.contains(subTlv), + other.llRemoteTENodeDescriptorSubTLVs.contains(subTlv)); + } + return isCommonSubTlv; + } + } + return false; + } + + @Override + public int write(ChannelBuffer c) { + + int tlvStartIndex = c.writerIndex(); + c.writeShort(TYPE); + int tlvLenIndex = c.writerIndex(); + hLength = 0; + c.writeShort(hLength); + + ListIterator<PcepValueType> listIterator = llRemoteTENodeDescriptorSubTLVs.listIterator(); + + while (listIterator.hasNext()) { + PcepValueType tlv = listIterator.next(); + + if (tlv == null) { + log.debug("TLV is null from subTlv list"); + continue; + } + tlv.write(c); + + // need to take care of padding + int pad = tlv.getLength() % 4; + + if (0 != pad) { + pad = 4 - pad; + for (int i = 0; i < pad; ++i) { + c.writeByte((byte) 0); + } + } + } + + hLength = (short) (c.writerIndex() - tlvStartIndex); + c.setShort(tlvLenIndex, (hLength - TLV_HEADER_LENGTH)); + + return c.writerIndex() - tlvStartIndex; + } + + /** + * Reads channel buffer and returns object of Remote TE Node Descriptors TLV. + * + * @param c input channel buffer + * @param length length of buffer + * @return object of RemoteTENodeDescriptorsTLV + * @throws PcepParseException if mandatory fields are missing + */ + public static PcepValueType read(ChannelBuffer c , short length) throws PcepParseException { + + // Node Descriptor Sub-TLVs (variable) + LinkedList<PcepValueType> llRemoteTENodeDescriptorSubTLVs = new LinkedList<>(); + + ChannelBuffer tempCb = c.readBytes(length); + + while (TLV_HEADER_LENGTH <= tempCb.readableBytes()) { + + PcepValueType tlv; + short hType = tempCb.readShort(); + int iValue = 0; + short hLength = tempCb.readShort(); + switch (hType) { + + case AutonomousSystemTlv.TYPE: + iValue = tempCb.readInt(); + tlv = new AutonomousSystemTlv(iValue); + break; + case BGPLSidentifierTlv.TYPE: + iValue = tempCb.readInt(); + tlv = new BGPLSidentifierTlv(iValue); + break; + case OSPFareaIDsubTlv.TYPE: + iValue = tempCb.readInt(); + tlv = new OSPFareaIDsubTlv(iValue); + break; + case RouterIDSubTlv.TYPE: + tlv = RouterIDSubTlv.read(tempCb, hLength); + break; + + default: + throw new PcepParseException("Unsupported Sub TLV type :" + hType); + } + + // Check for the padding + int pad = hLength % 4; + if (0 < pad) { + pad = 4 - pad; + if (pad <= tempCb.readableBytes()) { + tempCb.skipBytes(pad); + } + } + + llRemoteTENodeDescriptorSubTLVs.add(tlv); + } + + if (0 < tempCb.readableBytes()) { + + throw new PcepParseException("Sub Tlv parsing error. Extra bytes received."); + } + return new RemoteTENodeDescriptorsTlv(llRemoteTENodeDescriptorSubTLVs); + } + + @Override + public String toString() { + return MoreObjects.toStringHelper(getClass()) + .add("Type", TYPE) + .add("Length", hLength) + .add("RemoteTeNodeDescriptorSubTLVs", llRemoteTENodeDescriptorSubTLVs) + .toString(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/RouterIDSubTlv.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/RouterIDSubTlv.java new file mode 100644 index 00000000..228d8533 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/RouterIDSubTlv.java @@ -0,0 +1,154 @@ +/* + * 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.types; + +import java.util.Arrays; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.pcepio.protocol.PcepVersion; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.google.common.base.MoreObjects; +import com.google.common.base.MoreObjects.ToStringHelper; + +/** + * Provides router id. + */ +public class RouterIDSubTlv implements PcepValueType { + + /* reference :I-D.ietf-idr-ls-distribution. + * 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 + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Type=[TBD13] | Length | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | opaque value | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + */ + + protected static final Logger log = LoggerFactory.getLogger(RouterIDSubTlv.class); + + public static final short TYPE = 1000; //TODD:change this TBD13 + private final short hLength; + + private final byte[] rawValue; + + /** + * constructor to initialize rawValue. + * + * @param rawValue raw value + * @param hLength length + */ + public RouterIDSubTlv(byte[] rawValue, short hLength) { + this.rawValue = rawValue; + if (0 == hLength) { + this.hLength = (short) rawValue.length; + } else { + this.hLength = hLength; + } + } + + /** + * Returns object of Router ID Sub Tlv. + * + * @param raw value + * @param hLength length + * @return object of Router ID Sub Tlv + */ + public static RouterIDSubTlv of(final byte[] raw, short hLength) { + return new RouterIDSubTlv(raw, hLength); + } + + /** + * Returns raw value. + * + * @return rawValue value + */ + public byte[] getValue() { + return rawValue; + } + + @Override + public PcepVersion getVersion() { + return PcepVersion.PCEP_1; + } + + @Override + public short getType() { + return TYPE; + } + + @Override + public short getLength() { + return hLength; + } + + @Override + public int hashCode() { + return Arrays.hashCode(rawValue); + } + + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + if (obj instanceof RouterIDSubTlv) { + RouterIDSubTlv other = (RouterIDSubTlv) obj; + return Arrays.equals(this.rawValue, other.rawValue); + } + return false; + } + + @Override + public int write(ChannelBuffer c) { + int iLenStartIndex = c.writerIndex(); + c.writeShort(TYPE); + c.writeShort(hLength); + c.writeBytes(rawValue); + return c.writerIndex() - iLenStartIndex; + } + + /** + * Reads channel buffer and returns object of RouterIDSubTlv. + * + * @param c input channel buffer + * @param hLength length + * @return object of RouterIDSubTlv + */ + public static PcepValueType read(ChannelBuffer c, short hLength) { + byte[] iOpaqueValue = new byte[hLength]; + c.readBytes(iOpaqueValue, 0, hLength); + return new RouterIDSubTlv(iOpaqueValue, hLength); + } + + @Override + public String toString() { + ToStringHelper toStrHelper = MoreObjects.toStringHelper(getClass()); + + toStrHelper.add("Type", TYPE); + toStrHelper.add("Length", hLength); + + StringBuffer result = new StringBuffer(); + for (byte b : rawValue) { + result.append(String.format("%02X ", b)); + } + toStrHelper.add("Value", result); + + return toStrHelper.toString(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/RoutingUniverseTlv.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/RoutingUniverseTlv.java new file mode 100644 index 00000000..924a3a32 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/RoutingUniverseTlv.java @@ -0,0 +1,147 @@ +/* + * 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.types; + +import java.util.Objects; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.pcepio.protocol.PcepVersion; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.google.common.base.MoreObjects; + +/** + * Provides RoutingUniverseTLV identifiers. + */ +public class RoutingUniverseTlv implements PcepValueType { + + /* + * Reference : draft-dhodylee-pce-pcep-te-data-extn-02, section 9.2.1. + * 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 + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Type=[TBD7] | Length=8 | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Identifier | + | | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + + * + * + * +------------+---------------------+ + | Identifier | Routing Universe | + +------------+---------------------+ + | 0 | L3 packet topology | + | 1 | L1 optical topology | + +------------+---------------------+ + */ + + protected static final Logger log = LoggerFactory.getLogger(RoutingUniverseTlv.class); + + public static final short TYPE = 14; // TODO:need to change TBD7 + public static final short LENGTH = 8; + + private final long rawValue; + + /** + * Constructor to initialize raw value. + * + * @param rawValue raw value + */ + public RoutingUniverseTlv(long rawValue) { + this.rawValue = rawValue; + } + + /** + * Returns object of RoutingUniverseTLV. + * + * @param raw value + * @return object of RoutingUniverseTLV + */ + public static RoutingUniverseTlv of(final long raw) { + return new RoutingUniverseTlv(raw); + } + + /** + * Returns raw value as Identifier. + * + * @return rawValue Identifier + */ + public long getLong() { + return rawValue; + } + + @Override + public PcepVersion getVersion() { + return PcepVersion.PCEP_1; + } + + @Override + public short getType() { + return TYPE; + } + + @Override + public short getLength() { + return LENGTH; + } + + @Override + public int hashCode() { + return Objects.hash(rawValue); + } + + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + if (obj instanceof RoutingUniverseTlv) { + RoutingUniverseTlv other = (RoutingUniverseTlv) obj; + return Objects.equals(this.rawValue, other.rawValue); + } + return false; + } + + @Override + public int write(ChannelBuffer c) { + int iLenStartIndex = c.writerIndex(); + c.writeShort(TYPE); + c.writeShort(LENGTH); + c.writeLong(rawValue); + return c.writerIndex() - iLenStartIndex; + } + + /** + * Reads from channel buffer and returns object of RoutingUniverseTLV. + * + * @param c input channel buffer + * @return object of RoutingUniverseTLV + */ + public static RoutingUniverseTlv read(ChannelBuffer c) { + return RoutingUniverseTlv.of(c.readLong()); + } + + @Override + public String toString() { + return MoreObjects.toStringHelper(getClass()) + .add("Type", TYPE) + .add("Length", LENGTH) + .add("Value", rawValue) + .toString(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/SharedRiskLinkGroupTlv.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/SharedRiskLinkGroupTlv.java new file mode 100644 index 00000000..e855a526 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/SharedRiskLinkGroupTlv.java @@ -0,0 +1,167 @@ +/* + * 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.types; + +import java.util.Arrays; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.pcepio.protocol.PcepVersion; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.google.common.base.MoreObjects; +import com.google.common.base.MoreObjects.ToStringHelper; + +/** + * Provides SharedRiskLinkGroupTlv. + */ +public class SharedRiskLinkGroupTlv implements PcepValueType { + + /* + * Reference :[I-D.ietf-idr- Group ls-distribution] /3.3.2.5 + * + * 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 + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Type =TDB41 | Length | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Shared Risk Link Group Value | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + // ............ // + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Shared Risk Link Group Value | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + */ + + protected static final Logger log = LoggerFactory.getLogger(SharedRiskLinkGroupTlv.class); + + public static final short TYPE = 1096; //TODO:NEED TO HANDLE TDB41 + + private final short hLength; + + private final int[] srlgValue; + + /** + * Constructor to initialize SRLG value. + * + * @param srlgValue Shared Risk Link Group Value + * @param hLength length + */ + public SharedRiskLinkGroupTlv(int[] srlgValue, short hLength) { + this.srlgValue = srlgValue; + if (0 == hLength) { + this.hLength = (short) ((srlgValue.length) * 4); + } else { + this.hLength = hLength; + } + } + + /** + * Returns object of SharedRiskLinkGroupTlv. + * + * @param raw value + * @param hLength length + * @return object of SharedRiskLinkGroupTlv + */ + public static SharedRiskLinkGroupTlv of(final int[] raw, short hLength) { + return new SharedRiskLinkGroupTlv(raw, hLength); + } + + /** + * Returns SRLG Value. + * + * @return srlgValue + */ + public int[] getValue() { + return srlgValue; + } + + @Override + public PcepVersion getVersion() { + return PcepVersion.PCEP_1; + } + + @Override + public short getType() { + return TYPE; + } + + @Override + public short getLength() { + return hLength; + } + + @Override + public int hashCode() { + return Arrays.hashCode(srlgValue); + } + + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + if (obj instanceof SharedRiskLinkGroupTlv) { + SharedRiskLinkGroupTlv other = (SharedRiskLinkGroupTlv) obj; + return Arrays.equals(this.srlgValue, other.srlgValue); + } + return false; + } + + @Override + public int write(ChannelBuffer c) { + int iLenStartIndex = c.writerIndex(); + c.writeShort(TYPE); + c.writeShort(hLength); + for (int b : srlgValue) { + c.writeInt(b); + } + return c.writerIndex() - iLenStartIndex; + } + + /** + * Reads from channel buffer and returns object of SharedRiskLinkGroupTlv. + * + * @param c input channel buffer + * @param hLength length + * @return object of SharedRiskLinkGroupTlv + */ + public static PcepValueType read(ChannelBuffer c, short hLength) { + int iLength = hLength / 4; + int[] iSharedRiskLinkGroup = new int[iLength]; + for (int i = 0; i < iLength; i++) { + iSharedRiskLinkGroup[i] = c.readInt(); + } + return new SharedRiskLinkGroupTlv(iSharedRiskLinkGroup, hLength); + } + + + @Override + public String toString() { + ToStringHelper toStrHelper = MoreObjects.toStringHelper(getClass()); + + toStrHelper.add("Type", TYPE); + toStrHelper.add("Length", hLength); + + StringBuffer result = new StringBuffer(); + for (int b : srlgValue) { + result.append(String.format("%02X ", b)); + } + toStrHelper.add("Value", result); + + return toStrHelper.toString(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/SrEroSubObject.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/SrEroSubObject.java new file mode 100644 index 00000000..3cbb82c8 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/SrEroSubObject.java @@ -0,0 +1,324 @@ +/* + * 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.types; + +import java.util.Objects; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.pcepio.protocol.PcepNai; +import org.onosproject.pcepio.protocol.PcepVersion; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.google.common.base.MoreObjects; + +/** + * Provides SrEroSubObject. + */ +public class SrEroSubObject implements PcepValueType { + /* + SR-ERO subobject: (draft-ietf-pce-segment-routing-00) + 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 + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + |L| Type | Length | ST | Flags |F|S|C|M| + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | SID | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + // NAI (variable) // + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + + + + NAI + + 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 + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Local IPv4 address | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Remote IPv4 address | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + + NAI for IPv4 Adjacency + + 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 + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + // Local IPv6 address (16 bytes) // + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + // Remote IPv6 address (16 bytes) // + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + + NAI for IPv6 adjacency + + 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 + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Local Node-ID | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Local Interface ID | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Remote Node-ID | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Remote Interface ID | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + + NAI for Unnumbered adjacency with IPv4 Node IDs + + */ + protected static final Logger log = LoggerFactory.getLogger(SrEroSubObject.class); + + public static final short TYPE = 0x60; //TODO : type to be defined + public static final short LENGTH = 12; + public static final short VALUE_LENGTH = 10; + public static final int SET = 1; + public static final byte MFLAG_SET = 0x01; + public static final byte CFLAG_SET = 0x02; + public static final byte SFLAG_SET = 0x04; + public static final byte FFLAG_SET = 0x08; + public static final byte SHIFT_ST = 12; + + private final boolean bFFlag; + private final boolean bSFlag; + private final boolean bCFlag; + private final boolean bMFlag; + private final byte st; + + private final int sID; + private final PcepNai nai; + + /** + * Constructor to initialize member variables. + * + * @param st SID type + * @param bFFlag F flag + * @param bSFlag S flag + * @param bCFlag C flag + * @param bMFlag M flag + * @param sID segment identifier value + * @param nai NAI associated with SID + */ + public SrEroSubObject(byte st, boolean bFFlag, boolean bSFlag, boolean bCFlag, boolean bMFlag, int sID, + PcepNai nai) { + this.st = st; + this.bFFlag = bFFlag; + this.bSFlag = bSFlag; + this.bCFlag = bCFlag; + this.bMFlag = bMFlag; + this.sID = sID; + this.nai = nai; + } + + /** + * Creates object of SrEroSubObject. + * + * @param st SID type + * @param bFFlag F flag + * @param bSFlag S flag + * @param bCFlag C flag + * @param bMFlag M flag + * @param sID segment identifier value + * @param nai NAI associated with SID + * @return object of SrEroSubObject + */ + public static SrEroSubObject of(byte st, boolean bFFlag, boolean bSFlag, boolean bCFlag, boolean bMFlag, int sID, + PcepNai nai) { + return new SrEroSubObject(st, bFFlag, bSFlag, bCFlag, bMFlag, sID, nai); + } + + /** + * Returns SID type. + * @return st sid type + */ + public byte getSt() { + return st; + } + + /** + * Returns bFFlag. + * @return bFFlag + */ + public boolean getFFlag() { + return bFFlag; + } + + /** + * Returns bSFlag. + * @return bSFlag + */ + public boolean getSFlag() { + return bSFlag; + } + + /** + * Returns bCFlag. + * @return bCFlag + */ + public boolean getCFlag() { + return bCFlag; + } + + /** + * Returns bMFlag. + * @return bMFlag + */ + public boolean getMFlag() { + return bMFlag; + } + + /** + * Returns sID. + * @return sID + */ + public int getSID() { + return sID; + } + + /** + * Returns nai. + * @return nai + */ + public PcepNai getNai() { + return nai; + } + + @Override + public PcepVersion getVersion() { + return PcepVersion.PCEP_1; + } + + @Override + public short getType() { + return TYPE; + } + + @Override + public short getLength() { + return LENGTH; + } + + @Override + public int hashCode() { + return Objects.hash(st, bFFlag, bSFlag, bCFlag, bMFlag, sID, nai); + } + + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + if (obj instanceof SrEroSubObject) { + SrEroSubObject other = (SrEroSubObject) obj; + return Objects.equals(this.st, other.st) && Objects.equals(this.bFFlag, other.bFFlag) + && Objects.equals(this.bSFlag, other.bSFlag) && Objects.equals(this.bCFlag, other.bCFlag) + && Objects.equals(this.bMFlag, other.bMFlag) && Objects.equals(this.sID, other.sID) + && Objects.equals(this.nai, other.nai); + } + return false; + } + + @Override + public int write(ChannelBuffer c) { + int iLenStartIndex = c.writerIndex(); + + c.writeShort(TYPE); + c.writeShort(LENGTH); + + short temp = 0; + if (bMFlag) { + temp = (short) (temp | MFLAG_SET); + } + if (bCFlag) { + temp = (short) (temp | CFLAG_SET); + } + if (bSFlag) { + temp = (short) (temp | SFLAG_SET); + } + if (bFFlag) { + temp = (short) (temp | FFLAG_SET); + } + short tempST = (short) (st << SHIFT_ST); + temp = (short) (temp | tempST); + c.writeShort(temp); + c.writeInt(sID); + nai.write(c); + + return c.writerIndex() - iLenStartIndex; + } + + /** + * Reads the channel buffer and returns object of SrEroSubObject. + * @param c of type channel buffer + * @return object of SrEroSubObject + */ + public static PcepValueType read(ChannelBuffer c) { + short temp = c.readShort(); + boolean bMFlag; + boolean bCFlag; + boolean bSFlag; + boolean bFFlag; + byte st; + PcepNai nai = null; + + bMFlag = (temp & MFLAG_SET) == MFLAG_SET; + bCFlag = (temp & CFLAG_SET) == CFLAG_SET; + bSFlag = (temp & SFLAG_SET) == SFLAG_SET; + bFFlag = (temp & FFLAG_SET) == FFLAG_SET; + + st = (byte) (temp >> SHIFT_ST); + + int sID = c.readInt(); + switch (st) { + case 0x01: + nai = PcepNaiIpv4NodeId.read(c); + break; + case 0x02: + nai = PcepNaiIpv6NodeId.read(c); + break; + case 0x03: + nai = PcepNaiIpv4Adjacency.read(c); + break; + case 0x04: + nai = PcepNaiIpv6Adjacency.read(c); + break; + case 0x05: + nai = PcepNaiUnnumberedAdjacencyIpv4.read(c); + break; + default: + nai = null; + break; + } + + return new SrEroSubObject(st, bFFlag, bSFlag, bCFlag, bMFlag, sID, nai); + } + + @Override + public String toString() { + return MoreObjects.toStringHelper(getClass()) + .add("Type", TYPE) + .add("Length", LENGTH) + .add("st", st) + .add("bFflag", bFFlag) + .add("bSFlag", bSFlag) + .add("bCFlag", bCFlag) + .add("bMFlag", bMFlag) + .add("sID", sID) + .add("nAI", nai) + .toString(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/StatefulIPv4LspIdentidiersTlv.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/StatefulIPv4LspIdentidiersTlv.java new file mode 100644 index 00000000..020d31d9 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/StatefulIPv4LspIdentidiersTlv.java @@ -0,0 +1,210 @@ +/* + * 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.types; + +import java.util.Objects; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.pcepio.protocol.PcepVersion; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.google.common.base.MoreObjects; + +/** + * Provides StatefulIPv4LspIdentidiersTlv. + */ +public class StatefulIPv4LspIdentidiersTlv implements PcepValueType { + + /* IPV4-LSP-IDENTIFIERS TLV format + * + * Reference :PCEP Extensions for Stateful PCE draft-ietf-pce-stateful-pce-10 + * + + 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 + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Type=18 | Length=16 | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | IPv4 Tunnel Sender Address | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | LSP ID | Tunnel ID | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Extended Tunnel ID | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | IPv4 Tunnel Endpoint Address | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + + */ + protected static final Logger log = LoggerFactory.getLogger(StatefulIPv4LspIdentidiersTlv.class); + + public static final short TYPE = 18; + public static final short LENGTH = 16; + public static final int VALUE_LENGTH = 16; + private final int ipv4IngressAddress; + private final short lspId; + private final short tunnelId; + private final int extendedTunnelId; + private final int ipv4EgressAddress; + + /** + * Constructor to initialize member variables. + * + * @param ipv4IngressAddress ingress ipv4 address + * @param lspId lsp id + * @param tunnelId tunnel id + * @param extendedTunnelId extended tunnel id + * @param ipv4EgressAddress egress ipv4 address + */ + public StatefulIPv4LspIdentidiersTlv(int ipv4IngressAddress, short lspId, short tunnelId, int extendedTunnelId, + int ipv4EgressAddress) { + + this.ipv4IngressAddress = ipv4IngressAddress; + this.lspId = lspId; + this.tunnelId = tunnelId; + this.extendedTunnelId = extendedTunnelId; + this.ipv4EgressAddress = ipv4EgressAddress; + } + + /** + * Creates object of StatefulIPv4LspIdentidiersTlv. + * + * @param ipv4IngressAddress ingress ipv4 address + * @param lspId lsp id + * @param tunnelId tunnel id + * @param extendedTunnelId extended tunnel id + * @param ipv4EgressAddress egress ipv4 address + * @return object of StatefulIPv4LspIdentidiersTlv + */ + public static StatefulIPv4LspIdentidiersTlv of(int ipv4IngressAddress, short lspId, short tunnelId, + int extendedTunnelId, int ipv4EgressAddress) { + return new StatefulIPv4LspIdentidiersTlv(ipv4IngressAddress, lspId, tunnelId, extendedTunnelId, + ipv4EgressAddress); + } + + /** + * Returns tunnel id. + * + * @return tunnelId + */ + public short getTunnelId() { + return this.tunnelId; + } + + /** + * Returns extendedTunnelId. + * + * @return extendedTunnelId + */ + public int getextendedTunnelId() { + return this.extendedTunnelId; + } + + @Override + public PcepVersion getVersion() { + return PcepVersion.PCEP_1; + } + + /** + * Returns ipv4IngressAddress. + * + * @return ipv4IngressAddress + */ + public int getIpv4IngressAddress() { + return ipv4IngressAddress; + } + + /** + * Returns ipv4EgressAddress. + * + * @return ipv4EgressAddress + */ + public int getIpv4EgressAddress() { + return ipv4EgressAddress; + } + + @Override + public short getType() { + return TYPE; + } + + @Override + public short getLength() { + return LENGTH; + } + + @Override + public int hashCode() { + return Objects.hash(ipv4IngressAddress, lspId, tunnelId, extendedTunnelId, ipv4EgressAddress); + } + + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + if (obj instanceof StatefulIPv4LspIdentidiersTlv) { + StatefulIPv4LspIdentidiersTlv other = (StatefulIPv4LspIdentidiersTlv) obj; + return Objects.equals(this.ipv4IngressAddress, other.ipv4IngressAddress) + && Objects.equals(this.lspId, other.lspId) && Objects.equals(this.tunnelId, other.tunnelId) + && Objects.equals(this.extendedTunnelId, other.extendedTunnelId) + && Objects.equals(this.ipv4EgressAddress, other.ipv4EgressAddress); + } + return false; + } + + @Override + public int write(ChannelBuffer c) { + int iLenStartIndex = c.writerIndex(); + c.writeShort(TYPE); + c.writeShort(LENGTH); + c.writeInt(ipv4IngressAddress); + c.writeShort(lspId); + c.writeShort(tunnelId); + c.writeInt(extendedTunnelId); + c.writeInt(ipv4EgressAddress); + + return c.writerIndex() - iLenStartIndex; + } + + /** + * Reads the channel buffer and returns object of StatefulIPv4LspIdentidiersTlv. + * + * @param c of type channel buffer + * @return object of StatefulIPv4LspIdentidiersTlv + */ + public static PcepValueType read(ChannelBuffer c) { + int ipv4IngressAddress = c.readInt(); + short lspId = c.readShort(); + short tunnelId = c.readShort(); + int extendedTunnelId = c.readInt(); + int ipv4EgressAddress = c.readInt(); + return new StatefulIPv4LspIdentidiersTlv(ipv4IngressAddress, lspId, tunnelId, extendedTunnelId, + ipv4EgressAddress); + } + + @Override + public String toString() { + return MoreObjects.toStringHelper(getClass()) + .add("Type:", TYPE) + .add("Length:", LENGTH) + .add("Ipv4IngressAddress:", ipv4IngressAddress) + .add("LspId:", lspId).add("TunnelId:", tunnelId) + .add("ExtendedTunnelId:", extendedTunnelId) + .add("Ipv4EgressAddress:", ipv4EgressAddress).toString(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/StatefulLspDbVerTlv.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/StatefulLspDbVerTlv.java new file mode 100644 index 00000000..a667dccd --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/StatefulLspDbVerTlv.java @@ -0,0 +1,142 @@ +/* + * 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.types; + +import java.util.Objects; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.pcepio.protocol.PcepVersion; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.google.common.base.MoreObjects; + +/** + * Provides StatefulLspDbVerTlv. + */ +public class StatefulLspDbVerTlv implements PcepValueType { + + /* LSP-DB-VERSION TLV format + * + * Reference : Optimizations of Label Switched Path State Synchronization Procedures + for a Stateful PCE draft-ietf-pce-stateful-sync-optimizations-02 + * + * + + 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 + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Type=23 | Length=8 | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | LSP State DB Version | + | | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + + */ + protected static final Logger log = LoggerFactory.getLogger(StatefulLspDbVerTlv.class); + + public static final short TYPE = 23; + public static final short LENGTH = 8; + private final long rawValue; + + /** + * Constructor to initialize rawValue. + * + * @param rawValue value + */ + public StatefulLspDbVerTlv(final long rawValue) { + this.rawValue = rawValue; + } + + /** + * Returns object of StatefulLspDbVerTlv. + * + * @param raw is LSP State DB Version + * @return object of StatefulLspDbVerTlv + */ + public static StatefulLspDbVerTlv of(final long raw) { + return new StatefulLspDbVerTlv(raw); + } + + @Override + public PcepVersion getVersion() { + return PcepVersion.PCEP_1; + } + + /** + * Returns LSP State DB Version. + * + * @return rawValue value + */ + public long getLong() { + return rawValue; + } + + @Override + public short getLength() { + return LENGTH; + } + + @Override + public short getType() { + return TYPE; + } + + @Override + public int hashCode() { + return Objects.hash(rawValue); + } + + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + if (obj instanceof StatefulLspDbVerTlv) { + StatefulLspDbVerTlv other = (StatefulLspDbVerTlv) obj; + return Objects.equals(this.rawValue, other.rawValue); + } + return false; + } + + @Override + public int write(ChannelBuffer c) { + c.writeShort(TYPE); + c.writeShort(LENGTH); + c.writeLong(rawValue); + return c.writerIndex(); + } + + /** + * Reads the channel buffer and returns object of StatefulLspDbVerTlv. + * + * @param c input channel buffer + * @return object of StatefulLspDbVerTlv + */ + public static StatefulLspDbVerTlv read(ChannelBuffer c) { + return StatefulLspDbVerTlv.of(c.readLong()); + } + + @Override + public String toString() { + return MoreObjects.toStringHelper(getClass()) + .add("Type", TYPE) + .add("Length", LENGTH) + .add("Value", rawValue) + .toString(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/StatefulLspErrorCodeTlv.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/StatefulLspErrorCodeTlv.java new file mode 100644 index 00000000..5d323f6a --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/StatefulLspErrorCodeTlv.java @@ -0,0 +1,142 @@ +/* + * 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.types; + +import java.util.Objects; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.pcepio.protocol.PcepVersion; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.google.common.base.MoreObjects; + +/** + * Provides StatefulLspErrorCodeTlv. + */ +public class StatefulLspErrorCodeTlv implements PcepValueType { + + /* LSP-ERROR-CODE TLV format + * + * Reference :PCEP Extensions for Stateful PCE draft-ietf-pce-stateful-pce-10 + * + + 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 + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Type=20 | Length=4 | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | LSP Error Code | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + + */ + + protected static final Logger log = LoggerFactory.getLogger(StatefulLspErrorCodeTlv.class); + + public static final short TYPE = 20; + public static final short LENGTH = 4; + private final int rawValue; + + /** + * Constructor to initialize raw Value. + * + * @param rawValue lsp error code value + */ + public StatefulLspErrorCodeTlv(int rawValue) { + this.rawValue = rawValue; + } + + /** + * Creates object of StatefulLspErrorCodeTlv. + * + * @param raw lsp error code value + * @return object of StatefulLspErrorCodeTlv + */ + public static StatefulLspErrorCodeTlv of(int raw) { + return new StatefulLspErrorCodeTlv(raw); + } + + @Override + public PcepVersion getVersion() { + return PcepVersion.PCEP_1; + } + + /** + * Returns lsp error code value. + * + * @return lsp error code value + */ + public int getInt() { + return rawValue; + } + + @Override + public short getLength() { + return LENGTH; + } + + @Override + public short getType() { + return TYPE; + } + + @Override + public int hashCode() { + return Objects.hash(rawValue); + } + + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + if (obj instanceof StatefulLspErrorCodeTlv) { + StatefulLspErrorCodeTlv other = (StatefulLspErrorCodeTlv) obj; + return Objects.equals(this.rawValue, other.rawValue); + } + return false; + } + + @Override + public int write(ChannelBuffer c) { + int iLenStartIndex = c.writerIndex(); + c.writeShort(TYPE); + c.writeShort(LENGTH); + c.writeInt(rawValue); + return c.writerIndex() - iLenStartIndex; + } + + /** + * Reads the channel buffer and returns object of StatefulLspErrorCodeTlv. + * + * @param c of type channel buffer + * @return object of StatefulLspErrorCodeTlv + */ + public static StatefulLspErrorCodeTlv read(ChannelBuffer c) { + return StatefulLspErrorCodeTlv.of(c.readInt()); + } + + @Override + public String toString() { + return MoreObjects.toStringHelper(getClass()) + .add("Type", TYPE) + .add("Length", LENGTH) + .add("Value", rawValue) + .toString(); + } + +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/StatefulPceCapabilityTlv.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/StatefulPceCapabilityTlv.java new file mode 100644 index 00000000..84f40e12 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/StatefulPceCapabilityTlv.java @@ -0,0 +1,269 @@ +/* + * 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.types; + +import java.util.Objects; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.pcepio.protocol.PcepVersion; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.google.common.base.MoreObjects; + +/** + * Provides StatefulPceCapabilityTlv. + */ +public class StatefulPceCapabilityTlv implements PcepValueType { + + /* STATEFUL-PCE-CAPABILITY TLV format + * + * Reference :PCEP Extensions for Stateful PCE draft-ietf-pce-stateful-pce-10 + + 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 + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Type=16 | Length=4 | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Flags |D|T|I|S|U| + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + + */ + protected static final Logger log = LoggerFactory.getLogger(StatefulPceCapabilityTlv.class); + + public static final short TYPE = 16; + public static final short LENGTH = 4; + public static final byte UFLAG_SET = 0x01; + public static final byte SFLAG_SET = 0x02; + public static final byte IFLAG_SET = 0x04; + public static final byte TFLAG_SET = 0x08; + public static final byte DFLAG_SET = 0x10; + public static final int SET = 1; + + private final int rawValue; + private final boolean bDFlag; + private final boolean bTFlag; + private final boolean bIFlag; + private final boolean bSFlag; + private final boolean bUFlag; + private final boolean isRawValueSet; + + /** + * Constructor to initialize variables. + * + * @param rawValue Flags + */ + public StatefulPceCapabilityTlv(int rawValue) { + this.rawValue = rawValue; + isRawValueSet = true; + this.bUFlag = (rawValue & UFLAG_SET) == UFLAG_SET; + this.bSFlag = (rawValue & SFLAG_SET) == SFLAG_SET; + this.bIFlag = (rawValue & IFLAG_SET) == IFLAG_SET; + this.bTFlag = (rawValue & TFLAG_SET) == TFLAG_SET; + this.bDFlag = (rawValue & DFLAG_SET) == DFLAG_SET; + } + + /** + * Constructor to initialize variables. + * + * @param bDFlag D-flag + * @param bTFlag T-flag + * @param bIFlag I-flag + * @param bSFlag S-flag + * @param bUFlag U-flag + */ + public StatefulPceCapabilityTlv(boolean bDFlag, boolean bTFlag, boolean bIFlag, boolean bSFlag, boolean bUFlag) { + this.bDFlag = bDFlag; + this.bTFlag = bTFlag; + this.bIFlag = bIFlag; + this.bSFlag = bSFlag; + this.bUFlag = bUFlag; + this.rawValue = 0; + isRawValueSet = false; + } + + /** + * Returns object of StatefulPceCapabilityTlv. + * + * @param raw value Flags + * @return object of StatefulPceCapabilityTlv + */ + public static StatefulPceCapabilityTlv of(final int raw) { + return new StatefulPceCapabilityTlv(raw); + } + + @Override + public PcepVersion getVersion() { + return PcepVersion.PCEP_1; + } + + /** + * Returns D-flag. + * + * @return bDFlag D-flag + */ + public boolean getDFlag() { + return bDFlag; + } + + /** + * Returns T-flag. + * + * @return bTFlag T-flag + */ + public boolean getTFlag() { + return bTFlag; + } + + /** + * Returns I-flag. + * + * @return bIFlag I-flag + */ + public boolean getIFlag() { + return bIFlag; + } + + /** + * Returns S-flag. + * + * @return bSFlag S-flag + */ + public boolean getSFlag() { + return bSFlag; + } + + /** + * Returns U-flag. + * + * @return bUFlag U-flag + */ + public boolean getUFlag() { + return bUFlag; + } + + /** + * Returns raw value Flags. + * + * @return rawValue Flags + */ + public int getInt() { + return rawValue; + } + + @Override + public short getType() { + return TYPE; + } + + @Override + public short getLength() { + return LENGTH; + } + + @Override + public int hashCode() { + if (isRawValueSet) { + return Objects.hash(rawValue); + } else { + return Objects.hash(bDFlag, bTFlag, bIFlag, bSFlag, bUFlag); + } + } + + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + if (obj instanceof StatefulPceCapabilityTlv) { + StatefulPceCapabilityTlv other = (StatefulPceCapabilityTlv) obj; + if (isRawValueSet) { + return Objects.equals(this.rawValue, other.rawValue); + } else { + return Objects.equals(this.bDFlag, other.bDFlag) && Objects.equals(this.bTFlag, other.bTFlag) + && Objects.equals(this.bIFlag, other.bIFlag) && Objects.equals(this.bSFlag, other.bSFlag) + && Objects.equals(this.bUFlag, other.bUFlag); + } + } + return false; + } + + @Override + public int write(ChannelBuffer c) { + int iLenStartIndex = c.writerIndex(); + c.writeShort(TYPE); + c.writeShort(LENGTH); + if (isRawValueSet) { + c.writeInt(rawValue); + } else { + int temp = 0; + if (bUFlag) { + temp = temp | UFLAG_SET; + } + if (bSFlag) { + temp = temp | SFLAG_SET; + } + if (bIFlag) { + temp = temp | IFLAG_SET; + } + if (bTFlag) { + temp = temp | TFLAG_SET; + } + if (bDFlag) { + temp = temp | DFLAG_SET; + } + c.writeInt(temp); + } + return c.writerIndex() - iLenStartIndex; + } + + /** + * Reads from channel buffer and returns object of StatefulPceCapabilityTlv. + * + * @param c input channel buffer + * @return object of StatefulPceCapabilityTlv + */ + public static PcepValueType read(ChannelBuffer c) { + int temp = c.readInt(); + boolean bDFlag; + boolean bTFlag; + boolean bIFlag; + boolean bSFlag; + boolean bUFlag; + + bUFlag = (temp & UFLAG_SET) == UFLAG_SET; + bSFlag = (temp & SFLAG_SET) == SFLAG_SET; + bIFlag = (temp & IFLAG_SET) == IFLAG_SET; + bTFlag = (temp & TFLAG_SET) == TFLAG_SET; + bDFlag = (temp & DFLAG_SET) == DFLAG_SET; + + return new StatefulPceCapabilityTlv(bDFlag, bTFlag, bIFlag, bSFlag, bUFlag); + } + + @Override + public String toString() { + return MoreObjects.toStringHelper(getClass()) + .add("type", TYPE) + .add("Length", LENGTH) + .add("DFlag", bDFlag) + .add("TFlag", bTFlag) + .add("IFlag", bIFlag) + .add("SFlag", bSFlag) + .add("UFlag", bUFlag) + .toString(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/StatefulRsvpErrorSpecTlv.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/StatefulRsvpErrorSpecTlv.java new file mode 100644 index 00000000..9e1a074a --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/StatefulRsvpErrorSpecTlv.java @@ -0,0 +1,216 @@ +/* + * 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.types; + +import java.util.Objects; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.pcepio.exceptions.PcepParseException; +import org.onosproject.pcepio.protocol.PcepVersion; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.google.common.base.MoreObjects; + +/** + * Provides StatefulRsvpErrorSpecTlv. + */ +public class StatefulRsvpErrorSpecTlv implements PcepValueType { + + protected static final Logger log = LoggerFactory.getLogger(StatefulRsvpErrorSpecTlv.class); + + /* RSVP-ERROR-SPEC TLV format + * Reference :PCEP Extensions for Stateful PCE draft-ietf-pce-stateful-pce-10 + * + * + + 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 + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Type=21 | Length (variable) | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | | + + RSVP ERROR_SPEC or USER_ERROR_SPEC Object + + | | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + + 0 1 2 3 + +-------------+-------------+-------------+-------------+ + | Length (bytes) | Class-Num | C-Type | + +-------------+-------------+-------------+-------------+ + | | + // (Object contents) // + | | + +-------------+-------------+-------------+-------------+ + + Ref : ERROR_SPEC @ RFC2205 + + IPv4 ERROR_SPEC object: Class = 6, C-Type = 1 + +-------------+-------------+-------------+-------------+ + | IPv4 Error Node Address (4 bytes) | + +-------------+-------------+-------------+-------------+ + | Flags | Error Code | Error Value | + +-------------+-------------+-------------+-------------+ + + + IPv6 ERROR_SPEC object: Class = 6, C-Type = 2 + +-------------+-------------+-------------+-------------+ + | | + + + + | | + + IPv6 Error Node Address (16 bytes) + + | | + + + + | | + +-------------+-------------+-------------+-------------+ + | Flags | Error Code | Error Value | + +-------------+-------------+-------------+-------------+ + + + Ref : USER_ERROR_SPEC @ RFC5284 + USER_ERROR_SPEC object: Class = 194, C-Type = 1 + 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 + +---------------+---------------+---------------+---------------+ + | Enterprise Number | + +---------------+---------------+---------------+---------------+ + | Sub Org | Err Desc Len | User Error Value | + +---------------+---------------+---------------+---------------+ + | | + ~ Error Description ~ + | | + +---------------+---------------+---------------+---------------+ + | | + ~ User-Defined Subobjects ~ + | | + +---------------+---------------+---------------+---------------+ + + */ + + public static final short TYPE = 21; + public static final int OBJECT_HEADER_LENGTH = 4; + private short hLength; + + private final PcepRsvpErrorSpec rsvpErrSpecObj; + private final boolean isErrSpceObjSet; + + /** + * Constructor to initialize errSpecObj. + * + * @param rsvpErrSpecObj Rsvp error spec object + */ + public StatefulRsvpErrorSpecTlv(PcepRsvpErrorSpec rsvpErrSpecObj) { + this.rsvpErrSpecObj = rsvpErrSpecObj; + this.isErrSpceObjSet = true; + } + + /** + * Returns PcepRsvpErrorSpecObject. + * + * @return rsvpErrSpecObj + */ + public PcepRsvpErrorSpec getPcepRsvpErrorSpec() { + return this.rsvpErrSpecObj; + } + + @Override + public PcepVersion getVersion() { + return PcepVersion.PCEP_1; + } + + @Override + public short getType() { + return TYPE; + } + + @Override + public short getLength() { + return hLength; + } + + /** + * Reads channel buffer and returns object of StatefulRsvpErrorSpecTlv. + * + * @param cb of type channel buffer + * @return object of StatefulRsvpErrorSpecTlv + * @throws PcepParseException while parsing this tlv from channel buffer + */ + public static PcepValueType read(ChannelBuffer cb) throws PcepParseException { + + PcepRsvpErrorSpec rsvpErrSpecObj = null; + PcepRsvpSpecObjHeader rsvpErrSpecObjHeader; + + cb.markReaderIndex(); + rsvpErrSpecObjHeader = PcepRsvpSpecObjHeader.read(cb); + cb.resetReaderIndex(); + + if (PcepRsvpIpv4ErrorSpec.CLASS_NUM == rsvpErrSpecObjHeader.getObjClassNum() + && PcepRsvpIpv4ErrorSpec.CLASS_TYPE == rsvpErrSpecObjHeader.getObjClassType()) { + rsvpErrSpecObj = PcepRsvpIpv4ErrorSpec.read(cb); + } else if (PcepRsvpIpv6ErrorSpec.CLASS_NUM == rsvpErrSpecObjHeader.getObjClassNum() + && PcepRsvpIpv6ErrorSpec.CLASS_TYPE == rsvpErrSpecObjHeader.getObjClassType()) { + rsvpErrSpecObj = PcepRsvpIpv6ErrorSpec.read(cb); + } else if (PcepRsvpUserErrorSpec.CLASS_NUM == rsvpErrSpecObjHeader.getObjClassNum() + && PcepRsvpUserErrorSpec.CLASS_TYPE == rsvpErrSpecObjHeader.getObjClassType()) { + rsvpErrSpecObj = PcepRsvpUserErrorSpec.read(cb); + } + return new StatefulRsvpErrorSpecTlv(rsvpErrSpecObj); + } + + @Override + public int hashCode() { + return Objects.hash(rsvpErrSpecObj.hashCode()); + } + + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + if (obj instanceof StatefulRsvpErrorSpecTlv) { + StatefulRsvpErrorSpecTlv other = (StatefulRsvpErrorSpecTlv) obj; + return Objects.equals(this.rsvpErrSpecObj, other.rsvpErrSpecObj); + } + return false; + } + + @Override + public int write(ChannelBuffer c) { + int iStartIndex = c.writerIndex(); + c.writeShort(TYPE); + int tlvLenIndex = c.writerIndex(); + hLength = 0; + c.writeShort(hLength); + if (isErrSpceObjSet) { + rsvpErrSpecObj.write(c); + } + hLength = (short) (c.writerIndex() - iStartIndex); + c.setShort(tlvLenIndex, (hLength - OBJECT_HEADER_LENGTH)); + + return c.writerIndex() - iStartIndex; + } + + @Override + public String toString() { + return MoreObjects.toStringHelper(getClass()) + .omitNullValues() + .add("Type", TYPE) + .add("Length", hLength) + .add("RSVPErrorSpecObject", rsvpErrSpecObj) + .toString(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/SymbolicPathNameTlv.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/SymbolicPathNameTlv.java new file mode 100644 index 00000000..27cf56a6 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/SymbolicPathNameTlv.java @@ -0,0 +1,159 @@ +/* + * 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.types; + +import java.util.Objects; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.pcepio.protocol.PcepVersion; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.google.common.base.MoreObjects; + +/** + * Provides SymbolicPathNameTlv. + */ +public class SymbolicPathNameTlv implements PcepValueType { + + /* + * SYMBOLIC-PATH-NAME TLV format + * Reference :PCEP Extensions for Stateful PCE draft-ietf-pce-stateful-pce-10 + * + 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 + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Type=17 | Length (variable) | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | | + // Symbolic Path Name // + | | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + */ + protected static final Logger log = LoggerFactory.getLogger(SymbolicPathNameTlv.class); + + public static final short TYPE = 17; + private short hLength; + + private final byte[] rawValue; + + /** + * Constructor to initialize raw Value. + * + * @param rawValue Symbolic path name + */ + public SymbolicPathNameTlv(byte[] rawValue) { + this.rawValue = rawValue; + this.hLength = (short) rawValue.length; + } + + /** + * Constructor to initialize raw Value. + * + * @param rawValue Symbolic path name + * @param hLength length of Symbolic path name + */ + public SymbolicPathNameTlv(byte[] rawValue, short hLength) { + this.rawValue = rawValue; + if (0 == hLength) { + this.hLength = (short) rawValue.length; + } else { + this.hLength = hLength; + } + } + + /** + * Creates an object of SymbolicPathNameTlv. + * + * @param raw Symbolic path name + * @param hLength length of Symbolic path name + * @return object of SymbolicPathNameTlv + */ + public static SymbolicPathNameTlv of(final byte[] raw, short hLength) { + return new SymbolicPathNameTlv(raw, hLength); + } + + /** + * Returns Symbolic path name. + * + * @return Symbolic path name byte array + */ + public byte[] getValue() { + return rawValue; + } + + @Override + public PcepVersion getVersion() { + return PcepVersion.PCEP_1; + } + + @Override + public short getType() { + return TYPE; + } + + @Override + public short getLength() { + return hLength; + } + + @Override + public int hashCode() { + return Objects.hash(rawValue); + } + + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + if (obj instanceof SymbolicPathNameTlv) { + SymbolicPathNameTlv other = (SymbolicPathNameTlv) obj; + return Objects.equals(this.rawValue, other.rawValue); + } + return false; + } + + @Override + public int write(ChannelBuffer c) { + int iLenStartIndex = c.writerIndex(); + c.writeShort(TYPE); + c.writeShort(hLength); + c.writeBytes(rawValue); + return c.writerIndex() - iLenStartIndex; + } + + /** + * Reads channel buffer and returns object of SymbolicPathNameTlv. + * + * @param c of type channel buffer + * @param hLength length of bytes to read + * @return object of SymbolicPathNameTlv + */ + public static SymbolicPathNameTlv read(ChannelBuffer c, short hLength) { + byte[] symbolicPathName = new byte[hLength]; + c.readBytes(symbolicPathName, 0, hLength); + return new SymbolicPathNameTlv(symbolicPathName, hLength); + } + + @Override + public String toString() { + return MoreObjects.toStringHelper(getClass()) + .add("SymbolicPathName ", rawValue) + .toString(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/TEDefaultMetricTlv.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/TEDefaultMetricTlv.java new file mode 100644 index 00000000..4429d223 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/TEDefaultMetricTlv.java @@ -0,0 +1,137 @@ +/* + * 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.types; + +import java.util.Objects; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.pcepio.protocol.PcepVersion; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.google.common.base.MoreObjects; + +/** + * Provides TEDefaultMetricTlv. + */ +public class TEDefaultMetricTlv implements PcepValueType { + + /* + * Reference :| [I-D.ietf-idr- ls-distribution] /3.3.2.3 + * 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 + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Type=TDB37 | Length=4 | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | TE Default Link Metric | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + + */ + protected static final Logger log = LoggerFactory.getLogger(TEDefaultMetricTlv.class); + + public static final short TYPE = 13400; //TDB37 + public static final short LENGTH = 4; + + private final int rawValue; + + /** + * Constructor to initialize rawValue. + * + * @param rawValue TE Default Link Metric + */ + public TEDefaultMetricTlv(int rawValue) { + this.rawValue = rawValue; + } + + /** + * Returns newly created TEDefaultMetricTlv object. + * + * @param raw raw value + * @return object of TEDefaultMetricTlv. + */ + public static TEDefaultMetricTlv of(final int raw) { + return new TEDefaultMetricTlv(raw); + } + + /** + * Returns raw value. + * + * @return rawValue TE Default Link Metric + */ + public int getInt() { + return rawValue; + } + + @Override + public PcepVersion getVersion() { + return PcepVersion.PCEP_1; + } + + @Override + public short getType() { + return TYPE; + } + + @Override + public short getLength() { + return LENGTH; + } + + @Override + public int hashCode() { + return Objects.hash(rawValue); + } + + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + if (obj instanceof TEDefaultMetricTlv) { + TEDefaultMetricTlv other = (TEDefaultMetricTlv) obj; + return Objects.equals(this.rawValue, other.rawValue); + } + return false; + } + + @Override + public int write(ChannelBuffer c) { + int iLenStartIndex = c.writerIndex(); + c.writeShort(TYPE); + c.writeShort(LENGTH); + c.writeInt(rawValue); + return c.writerIndex() - iLenStartIndex; + } + + /** + * Reads channel buffer and returns object of TEDefaultMetricTlv. + * + * @param c input channel buffer + * @return object of TEDefaultMetricTlv + */ + public static TEDefaultMetricTlv read(ChannelBuffer c) { + return TEDefaultMetricTlv.of(c.readInt()); + } + + @Override + public String toString() { + return MoreObjects.toStringHelper(getClass()) + .add("Type", TYPE) + .add("Length", LENGTH) + .add("Value", rawValue) + .toString(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/TELinkAttributesTlv.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/TELinkAttributesTlv.java new file mode 100644 index 00000000..b3b71aef --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/TELinkAttributesTlv.java @@ -0,0 +1,292 @@ +/* + * 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.types; + +import java.util.Iterator; +import java.util.LinkedList; +import java.util.ListIterator; +import java.util.Objects; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.pcepio.exceptions.PcepParseException; +import org.onosproject.pcepio.protocol.PcepVersion; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.google.common.base.MoreObjects; + +/** + * Provides TELinkAttributesTlv. + */ +public class TELinkAttributesTlv implements PcepValueType { + + /* + * Reference :PCEP Extension for Transporting TE Data draft-dhodylee-pce-pcep-te-data-extn-02 + * 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 + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Type=[TBD27] | Length | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | | + // Link Attributes Sub-TLVs (variable) // + | | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + */ + + protected static final Logger log = LoggerFactory.getLogger(TELinkAttributesTlv.class); + + public static final short TYPE = 1897; //TODD:change this TBD27 + public short hLength; + + public static final int TLV_HEADER_LENGTH = 4; + + // LinkDescriptors Sub-TLVs (variable) + private LinkedList<PcepValueType> llLinkAttributesSubTLVs; + + /** + * Constructor to initialize Link Attributes Sub TLVs. + * + * @param llLinkAttributesSubTLVs linked list of PcepValueType + */ + public TELinkAttributesTlv(LinkedList<PcepValueType> llLinkAttributesSubTLVs) { + this.llLinkAttributesSubTLVs = llLinkAttributesSubTLVs; + } + + /** + * Returns object of TE Link Attributes TLV. + * + * @param llLinkAttributesSubTLVs linked list of Link Attribute of Sub TLV + * @return object of TELinkAttributesTlv + */ + public static TELinkAttributesTlv of(final LinkedList<PcepValueType> llLinkAttributesSubTLVs) { + return new TELinkAttributesTlv(llLinkAttributesSubTLVs); + } + + /** + * Returns linked list of Link Attribute of Sub TLV. + * + * @return llLinkAttributesSubTLVs linked list of Link Attribute of Sub TLV + */ + public LinkedList<PcepValueType> getllLinkAttributesSubTLVs() { + return llLinkAttributesSubTLVs; + } + + @Override + public PcepVersion getVersion() { + return PcepVersion.PCEP_1; + } + + @Override + public short getType() { + return TYPE; + } + + @Override + public short getLength() { + return hLength; + } + + @Override + public int hashCode() { + return Objects.hash(llLinkAttributesSubTLVs.hashCode()); + } + + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + /* + * Here we have a list of Tlv so to compare each sub tlv between the object + * we have to take a list iterator so one by one we can get each sub tlv object + * and can compare them. + * it may be possible that the size of 2 lists is not equal so we have to first check + * the size, if both are same then we should check for the subtlv objects otherwise + * we should return false. + */ + if (obj instanceof TELinkAttributesTlv) { + int countObjSubTlv = 0; + int countOtherSubTlv = 0; + boolean isCommonSubTlv = true; + TELinkAttributesTlv other = (TELinkAttributesTlv) obj; + Iterator<PcepValueType> objListIterator = ((TELinkAttributesTlv) obj).llLinkAttributesSubTLVs.iterator(); + countObjSubTlv = ((TELinkAttributesTlv) obj).llLinkAttributesSubTLVs.size(); + countOtherSubTlv = other.llLinkAttributesSubTLVs.size(); + if (countObjSubTlv != countOtherSubTlv) { + return false; + } else { + while (objListIterator.hasNext() && isCommonSubTlv) { + PcepValueType subTlv = objListIterator.next(); + isCommonSubTlv = Objects.equals(llLinkAttributesSubTLVs.contains(subTlv), + other.llLinkAttributesSubTLVs.contains(subTlv)); + } + return isCommonSubTlv; + } + } + return false; + } + + @Override + public int write(ChannelBuffer c) { + int tlvStartIndex = c.writerIndex(); + c.writeShort(TYPE); + int tlvLenIndex = c.writerIndex(); + hLength = 0; + c.writeShort(hLength); + + ListIterator<PcepValueType> listIterator = llLinkAttributesSubTLVs.listIterator(); + + while (listIterator.hasNext()) { + PcepValueType tlv = listIterator.next(); + + if (tlv == null) { + log.debug("TLV is null from subTlv list"); + continue; + } + tlv.write(c); + + // need to take care of padding + int pad = tlv.getLength() % 4; + + if (0 != pad) { + pad = 4 - pad; + for (int i = 0; i < pad; ++i) { + c.writeByte((byte) 0); + } + } + } + + hLength = (short) (c.writerIndex() - tlvStartIndex); + c.setShort(tlvLenIndex, (hLength - TLV_HEADER_LENGTH)); + + return c.writerIndex() - tlvStartIndex; + } + + /** + * Reads channel buffer and returns object of TE Link Attributes TLV. + * + * @param c input channel buffer + * @param hLength length + * @return object of TELinkAttributesTlv + * @throws PcepParseException if mandatory fields are missing + */ + public static PcepValueType read(ChannelBuffer c, short hLength) throws PcepParseException { + + // Node Descriptor Sub-TLVs (variable) + LinkedList<PcepValueType> llLinkAttributesSubTLVs = new LinkedList<>(); + + ChannelBuffer tempCb = c.readBytes(hLength); + + while (TLV_HEADER_LENGTH <= tempCb.readableBytes()) { + + PcepValueType tlv; + short hType = tempCb.readShort(); + int iValue = 0; + short length = tempCb.readShort(); + switch (hType) { + + case IPv4TERouterIdOfLocalNodeTlv.TYPE: + iValue = tempCb.readInt(); + tlv = new IPv4TERouterIdOfLocalNodeTlv(iValue); + break; + case IPv6TERouterIdofLocalNodeTlv.TYPE: + byte[] ipv6LValue = new byte[IPv6TERouterIdofLocalNodeTlv.VALUE_LENGTH]; + tempCb.readBytes(ipv6LValue, 0, IPv6TERouterIdofLocalNodeTlv.VALUE_LENGTH); + tlv = new IPv6TERouterIdofLocalNodeTlv(ipv6LValue); + break; + case IPv4TERouterIdOfRemoteNodeTlv.TYPE: + iValue = tempCb.readInt(); + tlv = new IPv4TERouterIdOfRemoteNodeTlv(iValue); + break; + case IPv6TERouterIdofRemoteNodeTlv.TYPE: + byte[] ipv6RValue = new byte[IPv6TERouterIdofRemoteNodeTlv.VALUE_LENGTH]; + tempCb.readBytes(ipv6RValue, 0, IPv6TERouterIdofRemoteNodeTlv.VALUE_LENGTH); + tlv = new IPv6TERouterIdofRemoteNodeTlv(ipv6RValue); + break; + case LinkLocalRemoteIdentifiersTlv.TYPE: + tlv = LinkLocalRemoteIdentifiersTlv.read(tempCb); + break; + case AdministrativeGroupTlv.TYPE: + iValue = tempCb.readInt(); + tlv = new AdministrativeGroupTlv(iValue); + break; + case MaximumLinkBandwidthTlv.TYPE: + iValue = tempCb.readInt(); + tlv = new MaximumLinkBandwidthTlv(iValue); + break; + case MaximumReservableLinkBandwidthTlv.TYPE: + iValue = tempCb.readInt(); + tlv = new MaximumReservableLinkBandwidthTlv(iValue); + break; + case UnreservedBandwidthTlv.TYPE: + iValue = tempCb.readInt(); + tlv = new UnreservedBandwidthTlv(iValue); + break; + case TEDefaultMetricTlv.TYPE: + iValue = tempCb.readInt(); + tlv = new TEDefaultMetricTlv(iValue); + break; + case LinkProtectionTypeTlv.TYPE: + tlv = LinkProtectionTypeTlv.read(tempCb); + break; + case MPLSProtocolMaskTlv.TYPE: + byte cValue = tempCb.readByte(); + tlv = new MPLSProtocolMaskTlv(cValue); + break; + case IGPMetricTlv.TYPE: + tlv = IGPMetricTlv.read(tempCb, length); + break; + case SharedRiskLinkGroupTlv.TYPE: + tlv = SharedRiskLinkGroupTlv.read(tempCb, length); + break; + case OpaqueLinkAttributeTlv.TYPE: + tlv = OpaqueLinkAttributeTlv.read(tempCb, length); + break; + case LinkNameTlv.TYPE: + tlv = LinkNameTlv.read(tempCb, length); + break; + default: + throw new PcepParseException("Unsupported Sub TLV type :" + hType); + } + + // Check for the padding + int pad = length % 4; + if (0 < pad) { + pad = 4 - pad; + if (pad <= tempCb.readableBytes()) { + tempCb.skipBytes(pad); + } + } + llLinkAttributesSubTLVs.add(tlv); + } + + if (0 < tempCb.readableBytes()) { + + throw new PcepParseException("Sub Tlv parsing error. Extra bytes received."); + } + + return new TELinkAttributesTlv(llLinkAttributesSubTLVs); + } + + @Override + public String toString() { + return MoreObjects.toStringHelper(getClass()) + .add("Type", TYPE) + .add("Length", hLength) + .add("LinkAttributesSubTLVs", llLinkAttributesSubTLVs) + .toString(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/TELinkDescriptorsTlv.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/TELinkDescriptorsTlv.java new file mode 100644 index 00000000..b974cf82 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/TELinkDescriptorsTlv.java @@ -0,0 +1,251 @@ +/* + * 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.types; + +import java.util.Iterator; +import java.util.LinkedList; +import java.util.ListIterator; +import java.util.Objects; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.pcepio.exceptions.PcepParseException; +import org.onosproject.pcepio.protocol.PcepVersion; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.google.common.base.MoreObjects; + +/** + * Provides TE Link Descriptors TLV. + */ +public class TELinkDescriptorsTlv implements PcepValueType { + + /* + * Reference: PCEP Extension for Transporting TE Data draft-dhodylee-pce-pcep-te-data-extn-02 + * 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 + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Type=[TBD14] | Length | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | | + // Link Descriptor Sub-TLVs (variable) // + | | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + + */ + + protected static final Logger log = LoggerFactory.getLogger(TELinkDescriptorsTlv.class); + + public static final short TYPE = 1070; //TODD:change this TBD14 + public short hLength; + + public static final int TLV_HEADER_LENGTH = 4; + + // LinkDescriptors Sub-TLVs (variable) + private LinkedList<PcepValueType> llLinkDescriptorsSubTLVs; + + /** + * Constructor to initialize llLinkDescriptorsSubTLVs. + * + * @param llLinkDescriptorsSubTLVs of PcepValueType + */ + public TELinkDescriptorsTlv(LinkedList<PcepValueType> llLinkDescriptorsSubTLVs) { + this.llLinkDescriptorsSubTLVs = llLinkDescriptorsSubTLVs; + } + + /** + * Returns object of TELinkDescriptorsTLV. + * + * @param llLinkDescriptorsSubTLVs of PcepValueType + * @return object of TELinkDescriptorsTLV + */ + public static TELinkDescriptorsTlv of(final LinkedList<PcepValueType> llLinkDescriptorsSubTLVs) { + return new TELinkDescriptorsTlv(llLinkDescriptorsSubTLVs); + } + + /** + * Returns linked list of Link Attribute of Sub TLV. + * + * @return llLinkDescriptorsSubTLVs linked list of Link Attribute of Sub TLV + */ + public LinkedList<PcepValueType> getllLinkDescriptorsSubTLVs() { + return llLinkDescriptorsSubTLVs; + } + + @Override + public PcepVersion getVersion() { + return PcepVersion.PCEP_1; + } + + @Override + public short getType() { + return TYPE; + } + + @Override + public short getLength() { + return hLength; + } + + @Override + public int hashCode() { + return Objects.hash(llLinkDescriptorsSubTLVs.hashCode()); + } + + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + /* + * Here we have a list of Tlv so to compare each sub tlv between the object + * we have to take a list iterator so one by one we can get each sub tlv object + * and can compare them. + * it may be possible that the size of 2 lists is not equal so we have to first check + * the size, if both are same then we should check for the subtlv objects otherwise + * we should return false. + */ + if (obj instanceof TELinkDescriptorsTlv) { + int countObjSubTlv = 0; + int countOtherSubTlv = 0; + boolean isCommonSubTlv = true; + TELinkDescriptorsTlv other = (TELinkDescriptorsTlv) obj; + Iterator<PcepValueType> objListIterator = ((TELinkDescriptorsTlv) obj).llLinkDescriptorsSubTLVs.iterator(); + countObjSubTlv = ((TELinkDescriptorsTlv) obj).llLinkDescriptorsSubTLVs.size(); + countOtherSubTlv = other.llLinkDescriptorsSubTLVs.size(); + if (countObjSubTlv != countOtherSubTlv) { + return false; + } else { + while (objListIterator.hasNext() && isCommonSubTlv) { + PcepValueType subTlv = objListIterator.next(); + isCommonSubTlv = Objects.equals(llLinkDescriptorsSubTLVs.contains(subTlv), + other.llLinkDescriptorsSubTLVs.contains(subTlv)); + } + return isCommonSubTlv; + } + } + return false; + } + + @Override + public int write(ChannelBuffer c) { + int tlvStartIndex = c.writerIndex(); + c.writeShort(TYPE); + int tlvLenIndex = c.writerIndex(); + hLength = 0; + c.writeShort(hLength); + + ListIterator<PcepValueType> listIterator = llLinkDescriptorsSubTLVs.listIterator(); + + while (listIterator.hasNext()) { + PcepValueType tlv = listIterator.next(); + + tlv.write(c); + + // need to take care of padding + int pad = tlv.getLength() % 4; + + if (0 != pad) { + pad = 4 - pad; + for (int i = 0; i < pad; ++i) { + c.writeByte((byte) 0); + } + } + } + + hLength = (short) (c.writerIndex() - tlvStartIndex); + c.setShort(tlvLenIndex, (hLength - TLV_HEADER_LENGTH)); + + return c.writerIndex() - tlvStartIndex; + } + + /** + * Reads channel buffer and returns object of TELinkDescriptorsTLV. + * + * @param c input channel buffer + * @param length length + * @return object of TELinkDescriptorsTLV + * @throws PcepParseException if mandatory fields are missing + */ + public static PcepValueType read(ChannelBuffer c, short length) throws PcepParseException { + + // Node Descriptor Sub-TLVs (variable) + LinkedList<PcepValueType> llLinkDescriptorsSubTLVs = new LinkedList<>(); + + ChannelBuffer tempCb = c.readBytes(length); + + while (TLV_HEADER_LENGTH <= tempCb.readableBytes()) { + + PcepValueType tlv; + short hType = tempCb.readShort(); + int iValue = 0; + short hLength = tempCb.readShort(); + log.debug("sub Tlv Length" + hLength); + switch (hType) { + + case LinkLocalRemoteIdentifiersTlv.TYPE: + tlv = LinkLocalRemoteIdentifiersTlv.read(tempCb); + break; + case IPv4InterfaceAddressTlv.TYPE: + iValue = tempCb.readInt(); + tlv = new IPv4InterfaceAddressTlv(iValue); + break; + case IPv4NeighborAddressTlv.TYPE: + iValue = tempCb.readInt(); + tlv = new IPv4NeighborAddressTlv(iValue); + break; + case IPv6InterfaceAddressTlv.TYPE: + byte[] ipv6Value = new byte[IPv6InterfaceAddressTlv.VALUE_LENGTH]; + tempCb.readBytes(ipv6Value, 0, IPv6InterfaceAddressTlv.VALUE_LENGTH); + tlv = new IPv6InterfaceAddressTlv(ipv6Value); + break; + case IPv6NeighborAddressTlv.TYPE: + byte[] ipv6NeighborAdd = new byte[IPv6NeighborAddressTlv.VALUE_LENGTH]; + tempCb.readBytes(ipv6NeighborAdd, 0, IPv6NeighborAddressTlv.VALUE_LENGTH); + tlv = new IPv6NeighborAddressTlv(ipv6NeighborAdd); + break; + default: + throw new PcepParseException("Unsupported Sub TLV type:" + hType); + } + + // Check for the padding + int pad = hLength % 4; + if (0 < pad) { + pad = 4 - pad; + if (pad <= tempCb.readableBytes()) { + tempCb.skipBytes(pad); + } + } + llLinkDescriptorsSubTLVs.add(tlv); + + } + + if (0 < tempCb.readableBytes()) { + + throw new PcepParseException("Sub Tlv parsing error. Extra bytes received."); + } + return new TELinkDescriptorsTlv(llLinkDescriptorsSubTLVs); + } + + @Override + public String toString() { + return MoreObjects.toStringHelper(getClass()) + .add("Type", TYPE) + .add("Length", hLength) + .add("LinkDescriptorsSubTLVs", llLinkDescriptorsSubTLVs) + .toString(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/TENodeAttributesTlv.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/TENodeAttributesTlv.java new file mode 100644 index 00000000..f18b75b2 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/TENodeAttributesTlv.java @@ -0,0 +1,250 @@ +/* + * 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.types; + +import java.util.Iterator; +import java.util.LinkedList; +import java.util.ListIterator; +import java.util.Objects; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.pcepio.exceptions.PcepParseException; +import org.onosproject.pcepio.protocol.PcepVersion; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.google.common.base.MoreObjects; + +/** + * Provides TE Node Attributes Tlv. + */ +public class TENodeAttributesTlv implements PcepValueType { + /* + * Reference :PCEP Extension for Transporting TE Data draft-dhodylee-pce-pcep-te-data-extn-02 + * + 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 + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Type=[TBD20] | Length | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | | + // Node Attributes Sub-TLVs (variable) // + | | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + + + */ + + protected static final Logger log = LoggerFactory.getLogger(TENodeAttributesTlv.class); + + public static final short TYPE = 1267; //TODD:change this TBD20 + public short hLength; + + public static final int TLV_HEADER_LENGTH = 4; + // LinkDescriptors Sub-TLVs (variable) + private LinkedList<PcepValueType> llNodeAttributesSubTLVs; + + /** + * Constructor to initialize llNodeAttributesSubTLVs. + * + * @param llNodeAttributesSubTLVs linked list of Node Attributes Sub-TLVs + */ + public TENodeAttributesTlv(LinkedList<PcepValueType> llNodeAttributesSubTLVs) { + this.llNodeAttributesSubTLVs = llNodeAttributesSubTLVs; + } + + /** + * Returns object of TENodeAttributesTlv. + * + * @param llNodeAttributesSubTLVs LinkedList of PcepValueType + * @return object of TENodeAttributesTlv + */ + public static TENodeAttributesTlv of(LinkedList<PcepValueType> llNodeAttributesSubTLVs) { + return new TENodeAttributesTlv(llNodeAttributesSubTLVs); + } + + /** + * Returns Node Attributes Sub-TLVs. + * + * @return llNodeAttributesSubTLVs linked list of Node Attributes Sub-TLVs + */ + public LinkedList<PcepValueType> getllNodeAttributesSubTLVs() { + return llNodeAttributesSubTLVs; + } + + @Override + public PcepVersion getVersion() { + return PcepVersion.PCEP_1; + } + + @Override + public short getType() { + return TYPE; + } + + @Override + public short getLength() { + return hLength; + } + + @Override + public int hashCode() { + return Objects.hash(llNodeAttributesSubTLVs.hashCode()); + } + + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + /* + * Here we have a list of Tlv so to compare each sub tlv between the object + * we have to take a list iterator so one by one we can get each sub tlv object + * and can compare them. + * it may be possible that the size of 2 lists is not equal so we have to first check + * the size, if both are same then we should check for the subtlv objects otherwise + * we should return false. + */ + if (obj instanceof TENodeAttributesTlv) { + int countObjSubTlv = 0; + int countOtherSubTlv = 0; + boolean isCommonSubTlv = true; + TENodeAttributesTlv other = (TENodeAttributesTlv) obj; + Iterator<PcepValueType> objListIterator = ((TENodeAttributesTlv) obj).llNodeAttributesSubTLVs.iterator(); + countObjSubTlv = ((TENodeAttributesTlv) obj).llNodeAttributesSubTLVs.size(); + countOtherSubTlv = other.llNodeAttributesSubTLVs.size(); + if (countObjSubTlv != countOtherSubTlv) { + return false; + } else { + while (objListIterator.hasNext() && isCommonSubTlv) { + PcepValueType subTlv = objListIterator.next(); + isCommonSubTlv = Objects.equals(llNodeAttributesSubTLVs.contains(subTlv), + other.llNodeAttributesSubTLVs.contains(subTlv)); + } + return isCommonSubTlv; + } + } + return false; + } + + @Override + public int write(ChannelBuffer c) { + int tlvStartIndex = c.writerIndex(); + c.writeShort(TYPE); + int tlvLenIndex = c.writerIndex(); + hLength = 0; + c.writeShort(hLength); + + ListIterator<PcepValueType> listIterator = llNodeAttributesSubTLVs.listIterator(); + + while (listIterator.hasNext()) { + PcepValueType tlv = listIterator.next(); + + tlv.write(c); + + // need to take care of padding + int pad = tlv.getLength() % 4; + + if (0 != pad) { + pad = 4 - pad; + for (int i = 0; i < pad; ++i) { + c.writeByte((byte) 0); + } + } + } + + hLength = (short) (c.writerIndex() - tlvStartIndex); + c.setShort(tlvLenIndex, (hLength - TLV_HEADER_LENGTH)); + + return c.writerIndex() - tlvStartIndex; + } + + /** + * Reads the channel buffer and returns object of TENodeAttributesTlv. + * + * @param c input channel buffer + * @param hLength length + * @return object of TENodeAttributesTlv + * @throws PcepParseException if mandatory fields are missing + */ + public static PcepValueType read(ChannelBuffer c, short hLength) throws PcepParseException { + + // Node Descriptor Sub-TLVs (variable) + LinkedList<PcepValueType> llNodeAttributesSubTLVs = new LinkedList<>(); + + ChannelBuffer tempCb = c.readBytes(hLength); + + while (TLV_HEADER_LENGTH <= tempCb.readableBytes()) { + PcepValueType tlv; + short hType = tempCb.readShort(); + int iValue = 0; + short length = tempCb.readShort(); + switch (hType) { + + case NodeFlagBitsTlv.TYPE: + byte cValue = tempCb.readByte(); + tlv = new NodeFlagBitsTlv(cValue); + break; + case OpaqueNodeAttributeTlv.TYPE: + tlv = OpaqueNodeAttributeTlv.read(tempCb, length); + break; + case NodeNameTlv.TYPE: + tlv = NodeNameTlv.read(tempCb, length); + break; + case ISISAreaIdentifierTlv.TYPE: + tlv = ISISAreaIdentifierTlv.read(tempCb, length); + break; + case IPv4TERouterIdOfLocalNodeTlv.TYPE: + iValue = tempCb.readInt(); + tlv = new IPv4TERouterIdOfLocalNodeTlv(iValue); + break; + case IPv6TERouterIdofLocalNodeTlv.TYPE: + byte[] ipv6Value = new byte[IPv6TERouterIdofLocalNodeTlv.VALUE_LENGTH]; + tempCb.readBytes(ipv6Value, 0, IPv6TERouterIdofLocalNodeTlv.VALUE_LENGTH); + tlv = new IPv6TERouterIdofLocalNodeTlv(ipv6Value); + break; + default: + throw new PcepParseException("Unsupported Sub TLV type :" + hType); + } + + // Check for the padding + int pad = length % 4; + if (0 < pad) { + pad = 4 - pad; + if (pad <= tempCb.readableBytes()) { + tempCb.skipBytes(pad); + } + } + + llNodeAttributesSubTLVs.add(tlv); + } + + if (0 < tempCb.readableBytes()) { + + throw new PcepParseException("Sub Tlv parsing error. Extra bytes received."); + } + return new TENodeAttributesTlv(llNodeAttributesSubTLVs); + } + + @Override + public String toString() { + return MoreObjects.toStringHelper(getClass()) + .add("Type", TYPE) + .add("Length", hLength) + .add("NodeAttributesSubTLVs", llNodeAttributesSubTLVs) + .toString(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/TedCapabilityTlv.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/TedCapabilityTlv.java new file mode 100644 index 00000000..189dcadc --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/TedCapabilityTlv.java @@ -0,0 +1,181 @@ +/* + * 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.types; + +import java.util.Objects; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.pcepio.protocol.PcepVersion; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.google.common.base.MoreObjects; + +/** + * Provides TED Capability Tlv. + */ +public class TedCapabilityTlv implements PcepValueType { + + /* + * Reference :PCEP Extension for Transporting TE Data draft-dhodylee-pce-pcep-te-data-extn-02 + * 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 + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Type=[TBD5] | Length=4 | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Flags |R| + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + */ + + protected static final Logger log = LoggerFactory.getLogger(TedCapabilityTlv.class); + + public static final short TYPE = 132; //TODO: need to change this TBD5 + public static final short LENGTH = 4; + public static final int SET = 1; + public static final byte RFLAG_CHECK = 0x01; + + private final boolean bRFlag; + private final int rawValue; + private final boolean isRawValueSet; + + /** + * Constructor to initialize raw Value. + * + * @param rawValue Flags + */ + public TedCapabilityTlv(final int rawValue) { + this.rawValue = rawValue; + this.isRawValueSet = true; + int temp = rawValue; + temp = temp & RFLAG_CHECK; + if (temp == SET) { + this.bRFlag = true; + } else { + this.bRFlag = false; + } + + } + + /** + * Constructor to initialize bRFlag. + * + * @param bRFlag R-flag + */ + public TedCapabilityTlv(boolean bRFlag) { + this.bRFlag = bRFlag; + this.rawValue = 0; + this.isRawValueSet = false; + } + + /** + * Returns R-flag. + * + * @return bRFlag + */ + public boolean getbRFlag() { + return bRFlag; + } + + /** + * Returns an object of TedCapabilityTlv. + * + * @param raw value Flags + * @return object of TedCapabilityTlv + */ + public static TedCapabilityTlv of(final int raw) { + return new TedCapabilityTlv(raw); + } + + @Override + public PcepVersion getVersion() { + return PcepVersion.PCEP_1; + } + + public int getInt() { + return rawValue; + } + + @Override + public short getType() { + return TYPE; + } + + @Override + public short getLength() { + return LENGTH; + } + + @Override + public int hashCode() { + if (isRawValueSet) { + return Objects.hash(rawValue); + } else { + return Objects.hash(bRFlag); + } + } + + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + if (obj instanceof TedCapabilityTlv) { + TedCapabilityTlv other = (TedCapabilityTlv) obj; + if (isRawValueSet) { + return Objects.equals(this.rawValue, other.rawValue); + } else { + return Objects.equals(this.bRFlag, other.bRFlag); + } + } + return false; + } + + @Override + public int write(ChannelBuffer c) { + int iStartIndex = c.writerIndex(); + int temp = 0; + c.writeShort(TYPE); + c.writeShort(LENGTH); + if (isRawValueSet) { + c.writeInt(rawValue); + } else { + if (bRFlag) { + temp = temp | RFLAG_CHECK; + } + c.writeInt(temp); + } + return c.writerIndex() - iStartIndex; + } + + /** + * Reads channel buffer and returns object of TedCapabilityTlv. + * + * @param c input channel buffer + * @return object of TedCapabilityTlv + */ + public static TedCapabilityTlv read(ChannelBuffer c) { + return TedCapabilityTlv.of(c.readInt()); + } + + @Override + public String toString() { + return MoreObjects.toStringHelper(getClass()) + .add("Type", TYPE) + .add("Length", LENGTH) + .add("Value", rawValue) + .toString(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/UnreservedBandwidthTlv.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/UnreservedBandwidthTlv.java new file mode 100644 index 00000000..d44bf824 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/UnreservedBandwidthTlv.java @@ -0,0 +1,136 @@ +/* + * 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.types; + +import java.util.Objects; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.pcepio.protocol.PcepVersion; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.google.common.base.MoreObjects; + +/** + * Provides Unreserved Bandwidth Tlv. + */ +public class UnreservedBandwidthTlv implements PcepValueType { + + /* Reference :[RFC5305]/3.6 + 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 + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Type=[TDB36] | Length=4 | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Unreserved Bandwidth | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + */ + + protected static final Logger log = LoggerFactory.getLogger(UnreservedBandwidthTlv.class); + + public static final short TYPE = 11; //TDB36 + public static final short LENGTH = 4; + + private final int rawValue; + + /** + * Constructor to initialize rawValue. + * + * @param rawValue Unreserved Bandwidth + */ + public UnreservedBandwidthTlv(int rawValue) { + this.rawValue = rawValue; + } + + /** + * Returns newly created UnreservedBandwidthTlv object. + * + * @param raw as Unreserved Bandwidth + * @return object of UnreservedBandwidthTlv + */ + public static UnreservedBandwidthTlv of(final int raw) { + return new UnreservedBandwidthTlv(raw); + } + + /** + * Returns Unreserved Bandwidth. + * + * @return rawValue Unreserved Bandwidth + */ + public int getInt() { + return rawValue; + } + + @Override + public PcepVersion getVersion() { + return PcepVersion.PCEP_1; + } + + @Override + public short getType() { + return TYPE; + } + + @Override + public short getLength() { + return LENGTH; + } + + @Override + public int hashCode() { + return Objects.hash(rawValue); + } + + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + if (obj instanceof UnreservedBandwidthTlv) { + UnreservedBandwidthTlv other = (UnreservedBandwidthTlv) obj; + return Objects.equals(this.rawValue, other.rawValue); + } + return false; + } + + @Override + public int write(ChannelBuffer c) { + int iLenStartIndex = c.writerIndex(); + c.writeShort(TYPE); + c.writeShort(LENGTH); + c.writeInt(rawValue); + return c.writerIndex() - iLenStartIndex; + } + + /** + * Reads byte stream from channel buffer and returns object of UnreservedBandwidthTlv. + * + * @param c input channel buffer + * @return object of UnreservedBandwidthTlv + */ + public static UnreservedBandwidthTlv read(ChannelBuffer c) { + return UnreservedBandwidthTlv.of(c.readInt()); + } + + @Override + public String toString() { + return MoreObjects.toStringHelper(getClass()) + .add("Type", TYPE) + .add("Length", LENGTH) + .add("Value", rawValue) + .toString(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/package-info.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/package-info.java new file mode 100644 index 00000000..12744de1 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/types/package-info.java @@ -0,0 +1,20 @@ +/* + * 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. + */ + +/** + * Implementation of Tlvs and Pcep common objects. + */ +package org.onosproject.pcepio.types; diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/util/HexDump.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/util/HexDump.java new file mode 100644 index 00000000..c39f606b --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/util/HexDump.java @@ -0,0 +1,56 @@ +/* + * 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.util; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +/** + * Provides Hex Dump for debugging. + */ +public final class HexDump { + protected static final Logger log = LoggerFactory.getLogger(HexDump.class); + + private HexDump() { + } + + public static void pcepHexDump(ChannelBuffer buff) { + + log.debug("==================== HEX DUMP ======================"); + try { + byte[] yTemp; + yTemp = buff.array(); + + int iStartIndex = buff.readerIndex(); + int iEndIndex = buff.writerIndex(); + do { + StringBuilder sb = new StringBuilder(); + for (int k = 0; (k < 16) && (iStartIndex < iEndIndex); ++k) { + if (0 == k % 4) { + sb.append(String.format(" ")); //blank after 4 bytes + } + sb.append(String.format("%02X ", yTemp[iStartIndex++])); + } + log.debug(sb.toString()); + } while (iStartIndex < iEndIndex); + } catch (Exception e) { + log.error("[HexDump] Invalid buffer: " + e.toString()); + } + + log.debug("==================================================="); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/util/package-info.java b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/util/package-info.java new file mode 100644 index 00000000..b3756ffe --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/util/package-info.java @@ -0,0 +1,20 @@ +/* + * 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. + */ + +/** + * Provides utility functionality for PCEP messages. + */ +package org.onosproject.pcepio.util; diff --git a/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/protocol/PcepCloseMsgTest.java b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/protocol/PcepCloseMsgTest.java new file mode 100644 index 00000000..33c00ddf --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/protocol/PcepCloseMsgTest.java @@ -0,0 +1,56 @@ +/* + * Copyright 2014-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; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.jboss.netty.buffer.ChannelBuffers; +import org.junit.Test; +import org.onosproject.pcepio.exceptions.PcepParseException; + +import static org.hamcrest.MatcherAssert.assertThat; +import static org.hamcrest.Matchers.instanceOf; +import static org.hamcrest.core.Is.is; + +public class PcepCloseMsgTest { + + /** + * Common header, reason to close. + */ + @Test + public void closeMessageTest1() throws PcepParseException { + + byte[] closeMsg = new byte[] {0x20, 0x07, 0x00, 0x0C, 0x0f, 0x10, 0x00, 0x08, 0x00, 0x00, 0x00, 0x02 }; + + byte[] testCloseMsg = {0 }; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(closeMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message; + + message = reader.readFrom(buffer); + assertThat(message, instanceOf(PcepCloseMsg.class)); + + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testCloseMsg = buf.array(); + + int readLen = buf.writerIndex(); + testCloseMsg = new byte[readLen]; + buf.readBytes(testCloseMsg, 0, readLen); + assertThat(testCloseMsg, is(closeMsg)); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/protocol/PcepErrorMsgTest.java b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/protocol/PcepErrorMsgTest.java new file mode 100644 index 00000000..234cea67 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/protocol/PcepErrorMsgTest.java @@ -0,0 +1,735 @@ +/* + * Copyright 2014-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; + + +import org.jboss.netty.buffer.ChannelBuffer; +import org.jboss.netty.buffer.ChannelBuffers; +import org.junit.Test; +import org.onosproject.pcepio.exceptions.PcepParseException; + +import static org.hamcrest.MatcherAssert.assertThat; +import static org.hamcrest.Matchers.instanceOf; +import static org.hamcrest.core.Is.is; + +/** + * Test cases for PCEP ERROR Message. + */ +public class PcepErrorMsgTest { + + /** + * This test case checks for + * PCEP-ERROR Object, OPEN Object (STATEFUL-PCE-CAPABILITY, GMPLS-CAPABILITY-TLV, + * PCECC-CAPABILITY-TLV, TED Capability TLV) + * in PcepErrorMsg message. + */ + @Test + public void errorMessageTest1() throws PcepParseException { + + byte[] errorMsg = new byte[]{0x20, 0x06, 0x00, 0x34, // common header + 0x0D, 0x10, 0x00, 0x08, // PCERR Object Header + 0x00, 0x00, 0x01, 0x01, 0x01, 0x10, 0x00, 0x28, // OPEN object header + 0x20, 0x05, 0x1E, 0x01, // OPEN object + 0x00, 0x10, 0x00, 0x04, // STATEFUL-PCE-CAPABILITY + 0x00, 0x00, 0x00, 0x05, 0x00, 0x0E, 0x00, 0x04, // GMPLS-CAPABILITY-TLV + 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, // PCECC-CAPABILITY-TLV + 0x00, 0x00, 0x00, 0x03, 0x00, (byte) 0x84, 0x00, 0x04, // TED Capability TLV + 0x00, 0x00, 0x00, 0x00}; + + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(errorMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + byte[] testErrorMsg = {0}; + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + + assertThat(message, instanceOf(PcepErrorMsg.class)); + message.writeTo(buf); + int iReadLen = buf.writerIndex(); + testErrorMsg = new byte[iReadLen]; + buf.readBytes(testErrorMsg, 0, iReadLen); + + assertThat(testErrorMsg, is(errorMsg)); + } + + /** + * This test case checks for + * PCEP-ERROR Object, PCEP-ERROR Object, OPEN Object (STATEFUL-PCE-CAPABILITY, GMPLS-CAPABILITY-TLV, + * PCECC-CAPABILITY-TLV, TED Capability TLV) + * in PcepErrorMsg message. + */ + @Test + public void errorMessageTest2() throws PcepParseException { + + byte[] errorMsg = new byte[]{0x20, 0x06, 0x00, 0x3C, // common header + 0x0D, 0x10, 0x00, 0x08, // PCERR Object Header + 0x00, 0x00, 0x01, 0x01, 0x0D, 0x10, 0x00, 0x08, // PCERR Object Header + 0x00, 0x00, 0x01, 0x03, 0x01, 0x10, 0x00, 0x28, // OPEN object header + 0x20, 0x05, 0x1E, 0x01, // OPEN object + 0x00, 0x10, 0x00, 0x04, // STATEFUL-PCE-CAPABILITY + 0x00, 0x00, 0x00, 0x05, 0x00, 0x0E, 0x00, 0x04, // GMPLS-CAPABILITY-TLV + 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, // PCECC-CAPABILITY-TLV + 0x00, 0x00, 0x00, 0x03, 0x00, (byte) 0x84, 0x00, 0x04, // TED Capability TLV + 0x00, 0x00, 0x00, 0x00}; + + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(errorMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + byte[] testErrorMsg = {0}; + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + assertThat(message, instanceOf(PcepErrorMsg.class)); + message.writeTo(buf); + int iReadLen = buf.writerIndex(); + testErrorMsg = new byte[iReadLen]; + buf.readBytes(testErrorMsg, 0, iReadLen); + + assertThat(testErrorMsg, is(errorMsg)); + } + + /** + * This test case checks for + * PCEP-ERROR Object, PCEP-ERROR Object, OPEN Object (STATEFUL-PCE-CAPABILITY, GMPLS-CAPABILITY-TLV, + * PCECC-CAPABILITY-TLV) + * in PcepErrorMsg message. + */ + @Test + public void errorMessageTest3() throws PcepParseException { + + byte[] errorMsg = new byte[]{0x20, 0x06, 0x00, 0x34, // common header + 0x0D, 0x10, 0x00, 0x08, // PCERR Object Header + 0x00, 0x00, 0x01, 0x01, 0x0D, 0x10, 0x00, 0x08, // PCERR Object Header + 0x00, 0x00, 0x01, 0x03, 0x01, 0x10, 0x00, 0x20, // OPEN object header + 0x20, 0x05, 0x1E, 0x01, // OPEN object + 0x00, 0x10, 0x00, 0x04, // STATEFUL-PCE-CAPABILITY + 0x00, 0x00, 0x00, 0x05, 0x00, 0x0E, 0x00, 0x04, // GMPLS-CAPABILITY-TLV + 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, // PCECC-CAPABILITY-TLV + 0x00, 0x00, 0x00, 0x03}; + + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(errorMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + byte[] testErrorMsg = {0}; + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + assertThat(message, instanceOf(PcepErrorMsg.class)); + message.writeTo(buf); + int iReadLen = buf.writerIndex(); + testErrorMsg = new byte[iReadLen]; + buf.readBytes(testErrorMsg, 0, iReadLen); + + assertThat(testErrorMsg, is(errorMsg)); + } + + /** + * This test case checks for + * PCEP-ERROR Object, PCEP-ERROR Object, OPEN Object (STATEFUL-PCE-CAPABILITY, GMPLS-CAPABILITY-TLV) + * in PcepErrorMsg message. + */ + @Test + public void errorMessageTest4() throws PcepParseException { + + byte[] errorMsg = new byte[]{0x20, 0x06, 0x00, 0x2c, // common header + 0x0D, 0x10, 0x00, 0x08, // PCERR Object Header + 0x00, 0x00, 0x01, 0x01, 0x0D, 0x10, 0x00, 0x08, // PCERR Object Header + 0x00, 0x00, 0x01, 0x03, 0x01, 0x10, 0x00, 0x18, // OPEN object header + 0x20, 0x05, 0x1E, 0x01, // OPEN object + 0x00, 0x10, 0x00, 0x04, // STATEFUL-PCE-CAPABILITY + 0x00, 0x00, 0x00, 0x05, 0x00, 0x0E, 0x00, 0x04, // GMPLS-CAPABILITY-TLV + 0x00, 0x00, 0x00, 0x00}; + + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(errorMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + byte[] testErrorMsg = {0}; + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + assertThat(message, instanceOf(PcepErrorMsg.class)); + message.writeTo(buf); + int iReadLen = buf.writerIndex(); + testErrorMsg = new byte[iReadLen]; + buf.readBytes(testErrorMsg, 0, iReadLen); + + assertThat(testErrorMsg, is(errorMsg)); + } + + /** + * This test case checks for + * PCEP-ERROR Object, PCEP-ERROR Object, OPEN Object (STATEFUL-PCE-CAPABILITY) + * in PcepErrorMsg message. + */ + @Test + public void errorMessageTest5() throws PcepParseException { + + byte[] errorMsg = new byte[]{0x20, 0x06, 0x00, 0x24, // common header + 0x0D, 0x10, 0x00, 0x08, // PCERR Object Header + 0x00, 0x00, 0x01, 0x01, 0x0D, 0x10, 0x00, 0x08, // PCERR Object Header + 0x00, 0x00, 0x01, 0x03, 0x01, 0x10, 0x00, 0x10, // OPEN object header + 0x20, 0x05, 0x1E, 0x01, // OPEN object + 0x00, 0x10, 0x00, 0x04, // STATEFUL-PCE-CAPABILITY + 0x00, 0x00, 0x00, 0x05}; + + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(errorMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + byte[] testErrorMsg = {0}; + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + assertThat(message, instanceOf(PcepErrorMsg.class)); + message.writeTo(buf); + int iReadLen = buf.writerIndex(); + testErrorMsg = new byte[iReadLen]; + buf.readBytes(testErrorMsg, 0, iReadLen); + + assertThat(testErrorMsg, is(errorMsg)); + } + + /** + * This test case checks for + * PCEP-ERROR Object, PCEP-ERROR Object, OPEN Object + * in PcepErrorMsg message. + */ + @Test + public void errorMessageTest6() throws PcepParseException { + + byte[] errorMsg = new byte[]{0x20, 0x06, 0x00, 0x1C, // common header + 0x0D, 0x10, 0x00, 0x08, // PCERR Object Header + 0x00, 0x00, 0x01, 0x01, 0x0D, 0x10, 0x00, 0x08, // PCERR Object Header + 0x00, 0x00, 0x01, 0x03, 0x01, 0x10, 0x00, 0x08, // OPEN object header + 0x20, 0x05, 0x1E, 0x01 // OPEN object + }; + + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(errorMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + byte[] testErrorMsg = {0}; + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + assertThat(message, instanceOf(PcepErrorMsg.class)); + message.writeTo(buf); + int iReadLen = buf.writerIndex(); + testErrorMsg = new byte[iReadLen]; + buf.readBytes(testErrorMsg, 0, iReadLen); + + assertThat(testErrorMsg, is(errorMsg)); + } + + /** + * This test case checks for + * PCEP-ERROR Object, OPEN Object + * in PcepErrorMsg message. + */ + @Test + public void errorMessageTest7() throws PcepParseException { + + byte[] errorMsg = new byte[]{0x20, 0x06, 0x00, 0x14, // common header + 0x0D, 0x10, 0x00, 0x08, // PCERR Object Header + 0x00, 0x00, 0x01, 0x01, 0x01, 0x10, 0x00, 0x08, // OPEN object header + 0x20, 0x05, 0x1E, 0x01 // OPEN object + }; + + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(errorMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + byte[] testErrorMsg = {0}; + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + assertThat(message, instanceOf(PcepErrorMsg.class)); + message.writeTo(buf); + int iReadLen = buf.writerIndex(); + testErrorMsg = new byte[iReadLen]; + buf.readBytes(testErrorMsg, 0, iReadLen); + + assertThat(testErrorMsg, is(errorMsg)); + } + + /** + * This test case checks for + * PCEP-ERROR Object, RP Object, PCEP-ERROR Object + * in PcepErrorMsg message. + */ + @Test + public void errorMessageTest8() throws PcepParseException { + + byte[] errorMsg = new byte[]{0x20, 0x06, 0x00, 0x20, // common header + 0x0D, 0x10, 0x00, 0x08, // PCERR Object Header + 0x00, 0x00, 0x01, 0x01, 0x02, 0x10, 0x00, 0x0C, // RP Object Header + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x0D, 0x10, 0x00, 0x08, // PCERR Object Header + 0x00, 0x00, 0x01, 0x03}; + + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(errorMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + byte[] testErrorMsg = {0}; + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + assertThat(message, instanceOf(PcepErrorMsg.class)); + message.writeTo(buf); + int iReadLen = buf.writerIndex(); + testErrorMsg = new byte[iReadLen]; + buf.readBytes(testErrorMsg, 0, iReadLen); + + assertThat(testErrorMsg, is(errorMsg)); + } + + /** + * This test case checks for + * PCEP-ERROR Object, PCEP-ERROR Object + * in PcepErrorMsg message. + */ + @Test + public void errorMessageTest9() throws PcepParseException { + + byte[] errorMsg = new byte[]{0x20, 0x06, 0x00, 0x14, // common header + 0x0D, 0x10, 0x00, 0x08, // PCEP-ERROR Object Header + 0x00, 0x00, 0x01, 0x01, 0x0D, 0x10, 0x00, 0x08, // PCEP-ERROR Object Header + 0x00, 0x00, 0x01, 0x01}; + + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(errorMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + byte[] testErrorMsg = {0}; + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + assertThat(message, instanceOf(PcepErrorMsg.class)); + message.writeTo(buf); + int iReadLen = buf.writerIndex(); + testErrorMsg = new byte[iReadLen]; + buf.readBytes(testErrorMsg, 0, iReadLen); + + assertThat(testErrorMsg, is(errorMsg)); + } + + /** + * This test case checks for + * PCEP-ERROR Object, PCEP-ERROR Object + * in PcepErrorMsg message. + */ + @Test + public void errorMessageTest10() throws PcepParseException { + + byte[] errorMsg = new byte[]{0x20, 0x06, 0x00, 0x14, // common header + 0x0D, 0x10, 0x00, 0x08, // PCEP-ERROR Object Header + 0x00, 0x00, 0x01, 0x01, 0x0D, 0x10, 0x00, 0x08, // PCEP-ERROR Object Header + 0x00, 0x00, 0x01, 0x01}; + + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(errorMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + byte[] testErrorMsg = {0}; + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + assertThat(message, instanceOf(PcepErrorMsg.class)); + message.writeTo(buf); + int iReadLen = buf.writerIndex(); + testErrorMsg = new byte[iReadLen]; + buf.readBytes(testErrorMsg, 0, iReadLen); + + assertThat(testErrorMsg, is(errorMsg)); + } + + /** + * This test case checks for + * TE Object, PCEP-ERROR Object + * in PcepErrorMsg message. + */ + @Test + public void errorMessageTest11() throws PcepParseException { + + byte[] errorMsg = new byte[]{0x20, 0x06, 0x00, 0x18, // common header + 0x65, 0x13, 0x00, 0x0C, // TE Object Header + 0x01, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x10, // TE-ID + 0x0D, 0x10, 0x00, 0x08, // PCEP-ERROR Object Header + 0x00, 0x00, 0x01, 0x01}; + + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(errorMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + byte[] testErrorMsg = {0}; + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + assertThat(message, instanceOf(PcepErrorMsg.class)); + message.writeTo(buf); + int iReadLen = buf.writerIndex(); + testErrorMsg = new byte[iReadLen]; + buf.readBytes(testErrorMsg, 0, iReadLen); + + assertThat(testErrorMsg, is(errorMsg)); + } + + /** + * This test case checks for + * RP Object, PCEP-ERROR Object + * in PcepErrorMsg message. + */ + @Test + public void errorMessageTest12() throws PcepParseException { + + //RP Object, PCEP-ERROR Object + byte[] errorMsg = new byte[]{0x20, 0x06, 0x00, 0x18, // common header + 0x02, 0x10, 0x00, 0x0C, // RP Object Header + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x0D, 0x10, 0x00, 0x08, // PCEP-ERROR Object Header + 0x00, 0x00, 0x01, 0x01}; + + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(errorMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + byte[] testErrorMsg = {0}; + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + assertThat(message, instanceOf(PcepErrorMsg.class)); + message.writeTo(buf); + int iReadLen = buf.writerIndex(); + testErrorMsg = new byte[iReadLen]; + buf.readBytes(testErrorMsg, 0, iReadLen); + + assertThat(testErrorMsg, is(errorMsg)); + } + + /** + * This test case checks for + * RP Object, RP Object, PCEP-ERROR Object + * in PcepErrorMsg message. + */ + @Test + public void errorMessageTest13() throws PcepParseException { + + byte[] errorMsg = new byte[]{0x20, 0x06, 0x00, 0x24, // common header + 0x02, 0x10, 0x00, 0x0C, // RP Object Header + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x02, 0x10, 0x00, 0x0C, // RP Object Header + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x0D, 0x10, 0x00, 0x08, // PCEP-ERROR Object Header + 0x00, 0x00, 0x01, 0x01}; + + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(errorMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + byte[] testErrorMsg = {0}; + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + assertThat(message, instanceOf(PcepErrorMsg.class)); + message.writeTo(buf); + int iReadLen = buf.writerIndex(); + testErrorMsg = new byte[iReadLen]; + buf.readBytes(testErrorMsg, 0, iReadLen); + + assertThat(testErrorMsg, is(errorMsg)); + } + + /** + * This test case checks for + * TE Object, TE Object, PCEP-ERROR Object + * in PcepErrorMsg message. + */ + @Test + public void errorMessageTest14() throws PcepParseException { + + byte[] errorMsg = new byte[]{0x20, 0x06, 0x00, 0x24, // common header + 0x65, 0x10, 0x00, 0x0C, // TE Object Header + 0x01, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x10, // TE-ID + 0x65, 0x10, 0x00, 0x0C, // TE Object Header + 0x01, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x11, // TE-ID + 0x0D, 0x10, 0x00, 0x08, // PCEP-ERROR Object Header + 0x00, 0x00, 0x01, 0x01}; + + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(errorMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + byte[] testErrorMsg = {0}; + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + assertThat(message, instanceOf(PcepErrorMsg.class)); + message.writeTo(buf); + int iReadLen = buf.writerIndex(); + testErrorMsg = new byte[iReadLen]; + buf.readBytes(testErrorMsg, 0, iReadLen); + + assertThat(testErrorMsg, is(errorMsg)); + } + + /** + * This test case checks for + * PCEP-ERROR Object, TE Object, PCEP-ERROR Object + * in PcepErrorMsg message. + */ + @Test + public void errorMessageTest15() throws PcepParseException { + + byte[] errorMsg = new byte[]{0x20, 0x06, 0x00, 0x20, // common header + 0x0D, 0x10, 0x00, 0x08, // PCERR Object Header + 0x00, 0x00, 0x01, 0x01, 0x65, 0x10, 0x00, 0x0C, // TE Object Header + 0x01, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x10, // TE-ID + 0x0D, 0x10, 0x00, 0x08, // PCEP-ERROR Object Header + 0x00, 0x00, 0x01, 0x03}; + + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(errorMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + byte[] testErrorMsg = {0}; + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + assertThat(message, instanceOf(PcepErrorMsg.class)); + message.writeTo(buf); + int iReadLen = buf.writerIndex(); + testErrorMsg = new byte[iReadLen]; + buf.readBytes(testErrorMsg, 0, iReadLen); + + assertThat(testErrorMsg, is(errorMsg)); + } + + /** + * This test case checks for + * PCEP-ERROR Object, RP Object, RP Object, PCEP-ERROR Object + * in PcepErrorMsg message. + */ + @Test + public void errorMessageTest16() throws PcepParseException { + + byte[] errorMsg = new byte[]{0x20, 0x06, 0x00, 0x2C, // common header + 0x0D, 0x10, 0x00, 0x08, // PCEP-ERROR Object Header + 0x00, 0x00, 0x01, 0x01, 0x02, 0x10, 0x00, 0x0C, // RP Object Header + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x02, 0x10, 0x00, 0x0C, // RP Object Header + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x0D, 0x10, 0x00, 0x08, // PCERR Object Header + 0x00, 0x00, 0x01, 0x03}; + + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(errorMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + byte[] testErrorMsg = {0}; + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + assertThat(message, instanceOf(PcepErrorMsg.class)); + message.writeTo(buf); + int iReadLen = buf.writerIndex(); + testErrorMsg = new byte[iReadLen]; + buf.readBytes(testErrorMsg, 0, iReadLen); + + assertThat(testErrorMsg, is(errorMsg)); + } + + /** + * This test case checks for + * PCEP-ERROR Object, TE Object, TE Object, PCEP-ERROR Object + * in PcepErrorMsg message. + */ + @Test + public void errorMessageTest17() throws PcepParseException { + + byte[] errorMsg = new byte[]{0x20, 0x06, 0x00, 0x2C, // common header + 0x0D, 0x10, 0x00, 0x08, // PCEP-ERROR Object Header + 0x00, 0x00, 0x01, 0x01, 0x65, 0x10, 0x00, 0x0C, // TE Object Header + 0x01, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x10, // TE-ID + 0x65, 0x10, 0x00, 0x0C, // TE Object Header + 0x01, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x11, // TE-ID + 0x0D, 0x10, 0x00, 0x08, // PCEP-ERROR Object Header + 0x00, 0x00, 0x01, 0x03}; + + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(errorMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + byte[] testErrorMsg = {0}; + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + assertThat(message, instanceOf(PcepErrorMsg.class)); + message.writeTo(buf); + int iReadLen = buf.writerIndex(); + testErrorMsg = new byte[iReadLen]; + buf.readBytes(testErrorMsg, 0, iReadLen); + + assertThat(testErrorMsg, is(errorMsg)); + } + + /** + * This test case checks for + * PCEP-ERROR Object, PCEP-ERROR Object, RP Object, RP Object, PCEP-ERROR Object, PCEP-ERROR Object + * in PcepErrorMsg message. + */ + @Test + public void errorMessageTest18() throws PcepParseException { + + byte[] errorMsg = new byte[]{0x20, 0x06, 0x00, 0x3C, // common header + 0x0D, 0x10, 0x00, 0x08, // PCEP-ERROR Object Header + 0x00, 0x00, 0x01, 0x01, 0x0D, 0x10, 0x00, 0x08, // PCEP-ERROR Object Header + 0x00, 0x00, 0x01, 0x03, 0x02, 0x10, 0x00, 0x0C, // RP Object Header + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x02, 0x10, 0x00, 0x0C, // RP Object Header + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x0D, 0x10, 0x00, 0x08, // PCEP-ERROR Object Header + 0x00, 0x00, 0x01, 0x04, 0x0D, 0x10, 0x00, 0x08, // PCEP-ERROR Object Header + 0x00, 0x00, 0x01, 0x06}; + + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(errorMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + byte[] testErrorMsg = {0}; + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + assertThat(message, instanceOf(PcepErrorMsg.class)); + message.writeTo(buf); + int iReadLen = buf.writerIndex(); + testErrorMsg = new byte[iReadLen]; + buf.readBytes(testErrorMsg, 0, iReadLen); + + assertThat(testErrorMsg, is(errorMsg)); + } + + /** + * This test case checks for + * PCEP-ERROR Object, PCEP-ERROR Object, TE Object, TE Object, PCEP-ERROR Object, PCEP-ERROR Object + * in PcepErrorMsg message. + */ + @Test + public void errorMessageTest19() throws PcepParseException { + + byte[] errorMsg = new byte[]{0x20, 0x06, 0x00, 0x3C, // common header + 0x0D, 0x10, 0x00, 0x08, // PCERR Object Header + 0x00, 0x00, 0x01, 0x01, 0x0D, 0x10, 0x00, 0x08, // PCERR Object Header + 0x00, 0x00, 0x01, 0x03, 0x65, 0x10, 0x00, 0x0C, // TE Object Header + 0x01, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x10, // TE-ID + 0x65, 0x10, 0x00, 0x0C, // TE Object Header + 0x01, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x11, // TE-ID + 0x0D, 0x10, 0x00, 0x08, // PCERR Object Header + 0x00, 0x00, 0x01, 0x04, 0x0D, 0x10, 0x00, 0x08, // PCERR Object Header + 0x00, 0x00, 0x01, 0x06}; + + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(errorMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + byte[] testErrorMsg = {0}; + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + assertThat(message, instanceOf(PcepErrorMsg.class)); + message.writeTo(buf); + int iReadLen = buf.writerIndex(); + testErrorMsg = new byte[iReadLen]; + buf.readBytes(testErrorMsg, 0, iReadLen); + + assertThat(testErrorMsg, is(errorMsg)); + } + + /** + * This test case checks for + * PCEP-ERROR Object, RP Object, RP Object, PCEP-ERROR Object, PCEP-ERROR Object, + * TE Object, PCEP-ERROR Object + * in PcepErrorMsg message. + */ + @Test + public void errorMessageTest20() throws PcepParseException { + + byte[] errorMsg = new byte[]{0x20, 0x06, 0x00, 0x48, // common header + 0x0D, 0x10, 0x00, 0x08, // PCEP-ERROR Object Header + 0x00, 0x00, 0x01, 0x01, 0x02, 0x10, 0x00, 0x0C, // RP Object Header + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x02, 0x10, 0x00, 0x0C, // RP Object Header + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x0D, 0x10, 0x00, 0x08, // PCERR Object Header + 0x00, 0x00, 0x01, 0x04, 0x0D, 0x10, 0x00, 0x08, // PCERR Object Header + 0x00, 0x00, 0x01, 0x06, 0x65, 0x10, 0x00, 0x0C, // TE Object Header + 0x01, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x10, // TE-ID + 0x0D, 0x10, 0x00, 0x08, // PCERR Object Header + 0x00, 0x00, 0x01, 0x06}; + + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(errorMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + byte[] testErrorMsg = {0}; + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + assertThat(message, instanceOf(PcepErrorMsg.class)); + + message.writeTo(buf); + int iReadLen = buf.writerIndex(); + testErrorMsg = new byte[iReadLen]; + buf.readBytes(testErrorMsg, 0, iReadLen); + + assertThat(testErrorMsg, is(errorMsg)); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/protocol/PcepInitiateMsgExtTest.java b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/protocol/PcepInitiateMsgExtTest.java new file mode 100644 index 00000000..9341f326 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/protocol/PcepInitiateMsgExtTest.java @@ -0,0 +1,1683 @@ +/* + * Copyright 2014-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; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.jboss.netty.buffer.ChannelBuffers; +import org.junit.Test; +import org.onosproject.pcepio.exceptions.PcepParseException; + +import static org.hamcrest.MatcherAssert.assertThat; +import static org.hamcrest.Matchers.instanceOf; +import static org.hamcrest.core.Is.is; + +public class PcepInitiateMsgExtTest { + + /** + * This test case checks for SRP, LSP (SymbolicPathNameTlv, StatefulIPv4LspIdentidiersTlv, + * SymbolicPathNameTlv, StatefulLspDbVerTlv, StatefulLspErrorCodeTlv, StatefulRsvpErrorSpecTlv), + * END-POINTS, ERO, LSPA, BANDWIDTH, METRIC-LIST objects in PcInitiate message. + */ + @Test + public void initiateMessageTest1() throws PcepParseException { + + /* SRP, LSP (SymbolicPathNameTlv, StatefulIPv4LspIdentidiersTlv, SymbolicPathNameTlv, StatefulLspDbVerTlv, + * StatefulLspErrorCodeTlv, StatefulRsvpErrorSpecTlv), END-POINTS, ERO, LSPA, BANDWIDTH, METRIC-LIST. + */ + byte[] initiateCreationMsg = new byte[]{0x20, 0x0C, 0x00, (byte) 0xA4, + 0x21, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x20, 0x10, 0x00, 0x38, 0x00, 0x00, 0x10, 0x03, + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x00, 0x11, 0x00, 0x04, 0x54, 0x31, 0x32, 0x33, //SymbolicPathNameTlv + 0x00, 0x17, 0x00, 0x08, //StatefulLspDbVerTlv + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, + 0x00, 0x14, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, //StatefulLspErrorCodeTlv + 0x04, 0x12, 0x00, 0x0C, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, //Endpoints Object + 0x07, 0x10, 0x00, 0x14, //ERO object + 0x01, 0x08, 0x0C, 0x01, 0x01, 0x01, 0x00, 0x00, + 0x01, 0x08, 0x0C, 0x01, 0x01, 0x02, 0x00, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, //Bandwidth object + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, //Metric object + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20}; //Metric object + + byte[] testInitiateCreationMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(initiateCreationMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepInitiateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + + message.writeTo(buf); + + testInitiateCreationMsg = buf.array(); + + int iReadLen = buf.writerIndex(); + testInitiateCreationMsg = new byte[iReadLen]; + buf.readBytes(testInitiateCreationMsg, 0, iReadLen); + + assertThat(testInitiateCreationMsg, is(initiateCreationMsg)); + } + + /** + * This test case checks for SRP, LSP (SymbolicPathNameTlv, StatefulIPv4LspIdentidiersTlv, + * SymbolicPathNameTlv, StatefulLspDbVerTlv, StatefulLspErrorCodeTlv, + * StatefulRsvpErrorSpecTlv), END-POINTS, ERO, LSPA, BANDWIDTH, METRIC OBJECT + * objects in PcInitiate message. + */ + @Test + public void initiateMessageTest2() throws PcepParseException { + + /* SRP, LSP (SymbolicPathNameTlv, StatefulIPv4LspIdentidiersTlv, SymbolicPathNameTlv, StatefulLspDbVerTlv, + * StatefulLspErrorCodeTlv, StatefulRsvpErrorSpecTlv), END-POINTS, ERO, LSPA, BANDWIDTH, METRIC OBJECT. + */ + byte[] initiateCreationMsg = new byte[]{0x20, 0x0C, 0x00, (byte) 0xA8, + 0x21, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x20, 0x10, 0x00, 0x48, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x00, 0x11, 0x00, 0x04, 0x54, 0x31, 0x32, 0x33, //SymbolicPathNameTlv + 0x00, 0x17, 0x00, 0x08, //StatefulLspDbVerTlv + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, + 0x00, 0x14, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, //StatefulLspErrorCodeTlv + 0x00, 0x15, 0x00, 0x0c, //StatefulRsvpErrorSpecTlv + 0x00, 0x0c, 0x06, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x00, 0x05, + 0x04, 0x12, 0x00, 0x0C, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, //Endpoints Object + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x0C, 0x01, //ERO object + 0x01, 0x01, 0x00, 0x00, 0x01, 0x08, 0x0C, 0x01, 0x01, 0x02, 0x00, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01}; + + byte[] testInitiateCreationMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(initiateCreationMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepInitiateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + + message.writeTo(buf); + + testInitiateCreationMsg = buf.array(); + + int iReadLen = buf.writerIndex(); + testInitiateCreationMsg = new byte[iReadLen]; + buf.readBytes(testInitiateCreationMsg, 0, iReadLen); + + assertThat(testInitiateCreationMsg, is(initiateCreationMsg)); + } + + /** + * This test case checks for SRP, LSP (StatefulIPv4LspIdentidiersTlv, SymbolicPathNameTlv, + * StatefulLspDbVerTlv, StatefulLspErrorCodeTlv, StatefulRsvpErrorSpecTlv), END-POINTS, + * ERO, LSPA, BANDWIDTH objects in PcInitiate message. + */ + @Test + public void initiateMessageTest3() throws PcepParseException { + + /* SRP, LSP (StatefulIPv4LspIdentidiersTlv, SymbolicPathNameTlv, StatefulLspDbVerTlv, + * StatefulLspErrorCodeTlv, StatefulRsvpErrorSpecTlv), END-POINTS, ERO, LSPA, BANDWIDTH. + */ + byte[] initiateCreationMsg = new byte[]{0x20, 0x0C, 0x00, (byte) 0x8c, + 0x21, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x20, 0x10, 0x00, 0x38, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x00, 0x11, 0x00, 0x04, 0x54, 0x31, 0x32, 0x33, //SymbolicPathNameTlv + 0x00, 0x17, 0x00, 0x08, //StatefulLspDbVerTlv + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, + 0x00, 0x14, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, //StatefulLspErrorCodeTlv + // 0x00, 0x15, 0x00, 0x0c, //StatefulRsvpErrorSpecTlv + //0x00, 0x0c, 0x06, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x00, 0x05, + 0x04, 0x12, 0x00, 0x0C, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, //Endpoints Object + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x0C, 0x01, //ERO object + 0x01, 0x01, 0x00, 0x00, 0x01, 0x08, 0x0C, 0x01, 0x01, 0x02, 0x00, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00}; + + byte[] testInitiateCreationMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(initiateCreationMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepInitiateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + + message.writeTo(buf); + + testInitiateCreationMsg = buf.array(); + + int iReadLen = buf.writerIndex(); + testInitiateCreationMsg = new byte[iReadLen]; + buf.readBytes(testInitiateCreationMsg, 0, iReadLen); + + assertThat(testInitiateCreationMsg, is(initiateCreationMsg)); + } + + /** + * This test case checks for SRP, LSP (SymbolicPathNameTlv, StatefulIPv4LspIdentidiersTlv, + * SymbolicPathNameTlv, StatefulLspDbVerTlv, StatefulLspErrorCodeTlv, StatefulRsvpErrorSpecTlv), + * END-POINTS, ERO, LSPA objects in PcInitiate message. + */ + @Test + public void initiateMessageTest4() throws PcepParseException { + + /* SRP, LSP (SymbolicPathNameTlv, StatefulIPv4LspIdentidiersTlv, SymbolicPathNameTlv, StatefulLspDbVerTlv, + * StatefulLspErrorCodeTlv, StatefulRsvpErrorSpecTlv), END-POINTS, ERO, LSPA. + */ + byte[] initiateCreationMsg = new byte[]{0x20, 0x0C, 0x00, (byte) 0x84, + 0x21, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x20, 0x10, 0x00, 0x38, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x00, 0x11, 0x00, 0x04, 0x54, 0x31, 0x32, 0x33, //SymbolicPathNameTlv + 0x00, 0x17, 0x00, 0x08, //StatefulLspDbVerTlv + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, + 0x00, 0x14, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, //StatefulLspErrorCodeTlv + // 0x00, 0x15, 0x00, 0x0c, //StatefulRsvpErrorSpecTlv + // 0x00, 0x0c, 0x06, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x00, 0x05, + 0x04, 0x12, 0x00, 0x0C, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, //Endpoints Object + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x0C, 0x01, //ERO object + 0x01, 0x01, 0x00, 0x00, 0x01, 0x08, 0x0C, 0x01, 0x01, 0x02, 0x00, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00}; + + byte[] testInitiateCreationMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(initiateCreationMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepInitiateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + + message.writeTo(buf); + + testInitiateCreationMsg = buf.array(); + + int iReadLen = buf.writerIndex(); + testInitiateCreationMsg = new byte[iReadLen]; + buf.readBytes(testInitiateCreationMsg, 0, iReadLen); + + assertThat(testInitiateCreationMsg, is(initiateCreationMsg)); + } + + /** + * This test case checks for SRP, LSP (SymbolicPathNameTlv, StatefulIPv4LspIdentidiersTlv, + * SymbolicPathNameTlv, StatefulLspDbVerTlv, StatefulLspErrorCodeTlv), END-POINTS, ERO, LSPA + * objects in PcInitiate message. + */ + @Test + public void initiateMessageTest5() throws PcepParseException { + + /* SRP, LSP (SymbolicPathNameTlv, StatefulIPv4LspIdentidiersTlv, SymbolicPathNameTlv, StatefulLspDbVerTlv, + * StatefulLspErrorCodeTlv), END-POINTS, ERO, LSPA. + */ + byte[] initiateCreationMsg = new byte[]{0x20, 0x0C, 0x00, (byte) 0x84, + 0x21, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x20, 0x10, 0x00, 0x38, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x00, 0x11, 0x00, 0x04, 0x54, 0x31, 0x32, 0x33, //SymbolicPathNameTlv + 0x00, 0x17, 0x00, 0x08, //StatefulLspDbVerTlv + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, + 0x00, 0x14, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, //StatefulLspErrorCodeTlv + 0x04, 0x12, 0x00, 0x0C, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, //Endpoints Object + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x0C, 0x01, //ERO object + 0x01, 0x01, 0x00, 0x00, 0x01, 0x08, 0x0C, 0x01, 0x01, 0x02, 0x00, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00}; + + byte[] testInitiateCreationMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(initiateCreationMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepInitiateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + + message.writeTo(buf); + + testInitiateCreationMsg = buf.array(); + + int iReadLen = buf.writerIndex(); + testInitiateCreationMsg = new byte[iReadLen]; + buf.readBytes(testInitiateCreationMsg, 0, iReadLen); + + assertThat(testInitiateCreationMsg, is(initiateCreationMsg)); + } + + /** + * This test case checks for SRP, LSP (SymbolicPathNameTlv, StatefulIPv4LspIdentidiersTlv, + * SymbolicPathNameTlv, StatefulLspDbVerTlv, StatefulLspErrorCodeTlv), END-POINTS, ERO, LSPA, + * BANDWIDTH OBJECT objects in PcInitiate message. + */ + @Test + public void initiateMessageTest6() throws PcepParseException { + + /* SRP, LSP (SymbolicPathNameTlv, StatefulIPv4LspIdentidiersTlv, SymbolicPathNameTlv, StatefulLspDbVerTlv, + * StatefulLspErrorCodeTlv), END-POINTS, ERO, LSPA, BANDWIDTH OBJECT. + */ + byte[] initiateCreationMsg = new byte[]{0x20, 0x0C, 0x00, (byte) 0x8c, + 0x21, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x20, 0x10, 0x00, 0x38, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x00, 0x11, 0x00, 0x04, 0x54, 0x31, 0x32, 0x33, //SymbolicPathNameTlv + 0x00, 0x17, 0x00, 0x08, //StatefulLspDbVerTlv + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, + 0x00, 0x14, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, //StatefulLspErrorCodeTlv + 0x04, 0x12, 0x00, 0x0C, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, //Endpoints Object + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x0C, 0x01, //ERO object + 0x01, 0x01, 0x00, 0x00, 0x01, 0x08, 0x0C, 0x01, 0x01, 0x02, 0x00, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00}; + + byte[] testInitiateCreationMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(initiateCreationMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepInitiateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + + message.writeTo(buf); + + testInitiateCreationMsg = buf.array(); + + int iReadLen = buf.writerIndex(); + testInitiateCreationMsg = new byte[iReadLen]; + buf.readBytes(testInitiateCreationMsg, 0, iReadLen); + + assertThat(testInitiateCreationMsg, is(initiateCreationMsg)); + } + + /** + * This test case checks for SRP, LSP (SymbolicPathNameTlv, StatefulIPv4LspIdentidiersTlv, + * SymbolicPathNameTlv, StatefulLspDbVerTlv, StatefulLspErrorCodeTlv), END-POINTS, ERO, + * LSPA, BANDWIDTH, METRIC OBJECT objects in PcInitiate message. + */ + @Test + public void initiateMessageTest7() throws PcepParseException { + + /* SRP, LSP (SymbolicPathNameTlv, StatefulIPv4LspIdentidiersTlv, SymbolicPathNameTlv, StatefulLspDbVerTlv, + * StatefulLspErrorCodeTlv), END-POINTS, ERO, LSPA, BANDWIDTH, METRIC OBJECT. + */ + byte[] initiateCreationMsg = new byte[]{0x20, 0x0C, 0x00, (byte) 0x98, + 0x21, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x20, 0x10, 0x00, 0x38, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x00, 0x11, 0x00, 0x04, 0x54, 0x31, 0x32, 0x33, //SymbolicPathNameTlv + 0x00, 0x17, 0x00, 0x08, //StatefulLspDbVerTlv + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, + 0x00, 0x14, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, //StatefulLspErrorCodeTlv + 0x04, 0x12, 0x00, 0x0C, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, //Endpoints Object + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x0C, 0x01, //ERO object + 0x01, 0x01, 0x00, 0x00, 0x01, 0x08, 0x0C, 0x01, 0x01, 0x02, 0x00, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01}; + + byte[] testInitiateCreationMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(initiateCreationMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepInitiateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + + message.writeTo(buf); + + testInitiateCreationMsg = buf.array(); + + int iReadLen = buf.writerIndex(); + testInitiateCreationMsg = new byte[iReadLen]; + buf.readBytes(testInitiateCreationMsg, 0, iReadLen); + + assertThat(testInitiateCreationMsg, is(initiateCreationMsg)); + } + + /** + * This test case checks for SRP, LSP (SymbolicPathNameTlv, StatefulIPv4LspIdentidiersTlv, + * SymbolicPathNameTlv, StatefulLspDbVerTlv), END-POINTS, ERO, LSPA, BANDWIDTH, METRIC OBJECT + * objects in PcInitiate message. + */ + @Test + public void initiateMessageTest8() throws PcepParseException { + + /* SRP, LSP (SymbolicPathNameTlv, StatefulIPv4LspIdentidiersTlv, SymbolicPathNameTlv, StatefulLspDbVerTlv), + * END-POINTS, ERO, LSPA, BANDWIDTH, METRIC OBJECT. + */ + byte[] initiateCreationMsg = new byte[]{0x20, 0x0C, 0x00, (byte) 0x90, + 0x21, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x20, 0x10, 0x00, 0x30, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x00, 0x11, 0x00, 0x04, 0x54, 0x31, 0x32, 0x33, //SymbolicPathNameTlv + 0x00, 0x17, 0x00, 0x08, //StatefulLspDbVerTlv + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, + 0x04, 0x12, 0x00, 0x0C, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, //Endpoints Object + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x0C, 0x01, //ERO object + 0x01, 0x01, 0x00, 0x00, 0x01, 0x08, 0x0C, 0x01, 0x01, 0x02, 0x00, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01}; + + byte[] testInitiateCreationMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(initiateCreationMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepInitiateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + + message.writeTo(buf); + + testInitiateCreationMsg = buf.array(); + + int iReadLen = buf.writerIndex(); + testInitiateCreationMsg = new byte[iReadLen]; + buf.readBytes(testInitiateCreationMsg, 0, iReadLen); + + assertThat(testInitiateCreationMsg, is(initiateCreationMsg)); + } + + /** + * This test case checks for SRP, LSP (SymbolicPathNameTlv, StatefulIPv4LspIdentidiersTlv, + * SymbolicPathNameTlv, StatefulLspDbVerTlv), END-POINTS, ERO, LSPA, BANDWIDTH OBJECT + * objects in PcInitiate message. + */ + @Test + public void initiateMessageTest9() throws PcepParseException { + + /* SRP, LSP (SymbolicPathNameTlv, StatefulIPv4LspIdentidiersTlv, SymbolicPathNameTlv, StatefulLspDbVerTlv), + * END-POINTS, ERO, LSPA, BANDWIDTH OBJECT. + */ + byte[] initiateCreationMsg = new byte[]{0x20, 0x0C, 0x00, (byte) 0x84, + 0x21, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x20, 0x10, 0x00, 0x30, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x00, 0x11, 0x00, 0x04, 0x54, 0x31, 0x32, 0x33, //SymbolicPathNameTlv + 0x00, 0x17, 0x00, 0x08, //StatefulLspDbVerTlv + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, + 0x04, 0x12, 0x00, 0x0C, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, //Endpoints Object + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x0C, 0x01, //ERO object + 0x01, 0x01, 0x00, 0x00, 0x01, 0x08, 0x0C, 0x01, 0x01, 0x02, 0x00, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00}; //Bandwidth object + + byte[] testInitiateCreationMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(initiateCreationMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepInitiateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + + message.writeTo(buf); + + testInitiateCreationMsg = buf.array(); + + int iReadLen = buf.writerIndex(); + testInitiateCreationMsg = new byte[iReadLen]; + buf.readBytes(testInitiateCreationMsg, 0, iReadLen); + + assertThat(testInitiateCreationMsg, is(initiateCreationMsg)); + } + + /** + * This test case checks for SRP, LSP (SymbolicPathNameTlv, StatefulIPv4LspIdentidiersTlv, + * SymbolicPathNameTlv), END-POINTS, ERO, LSPA OBJECT objects in PcInitiate message. + */ + @Test + public void initiateMessageTest10() throws PcepParseException { + + /* SRP, LSP (SymbolicPathNameTlv, StatefulIPv4LspIdentidiersTlv, SymbolicPathNameTlv), + * END-POINTS, ERO, LSPA OBJECT. + */ + byte[] initiateCreationMsg = new byte[]{0x20, 0x0C, 0x00, (byte) 0x70, + 0x21, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x20, 0x10, 0x00, 0x24, 0x00, 0x00, 0x10, 0x03, + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x00, 0x11, 0x00, 0x04, 0x54, 0x31, 0x32, 0x33, //SymbolicPathNameTlv + 0x04, 0x12, 0x00, 0x0C, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, //Endpoints Object + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x0C, 0x01, //ERO object + 0x01, 0x01, 0x00, 0x00, 0x01, 0x08, 0x0C, 0x01, 0x01, 0x02, 0x00, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00}; + + byte[] testInitiateCreationMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(initiateCreationMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepInitiateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + + message.writeTo(buf); + + testInitiateCreationMsg = buf.array(); + + int iReadLen = buf.writerIndex(); + testInitiateCreationMsg = new byte[iReadLen]; + buf.readBytes(testInitiateCreationMsg, 0, iReadLen); + + assertThat(testInitiateCreationMsg, is(initiateCreationMsg)); + } + + /** + * This test case checks for SRP, LSP (SymbolicPathNameTlv, StatefulIPv4LspIdentidiersTlv, + * SymbolicPathNameTlv, StatefulLspDbVerTlv), END-POINTS, ERO, LSPA OBJECT + * objects in PcInitiate message. + */ + @Test + public void initiateMessageTest11() throws PcepParseException { + + /* SRP, LSP (SymbolicPathNameTlv, StatefulIPv4LspIdentidiersTlv, SymbolicPathNameTlv, StatefulLspDbVerTlv), + * END-POINTS, ERO, LSPA OBJECT. + */ + byte[] initiateCreationMsg = new byte[]{0x20, 0x0C, 0x00, (byte) 0x7C, + 0x21, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x20, 0x10, 0x00, 0x30, 0x00, 0x00, 0x10, 0x03, + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x00, 0x11, 0x00, 0x04, 0x54, 0x31, 0x32, 0x33, //SymbolicPathNameTlv + 0x00, 0x17, 0x00, 0x08, //StatefulLspDbVerTlv + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, + 0x04, 0x12, 0x00, 0x0C, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, //Endpoints Object + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x0C, 0x01, //ERO object + 0x01, 0x01, 0x00, 0x00, 0x01, 0x08, 0x0C, 0x01, 0x01, 0x02, 0x00, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00}; + + byte[] testInitiateCreationMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(initiateCreationMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepInitiateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + + message.writeTo(buf); + + int iReadLen = buf.writerIndex(); + testInitiateCreationMsg = new byte[iReadLen]; + buf.readBytes(testInitiateCreationMsg, 0, iReadLen); + + assertThat(testInitiateCreationMsg, is(initiateCreationMsg)); + } + + /** + * This test case checks for SRP, LSP (SymbolicPathNameTlv, StatefulIPv4LspIdentidiersTlv, + * SymbolicPathNameTlv), END-POINTS, ERO, LSPA, BANDWIDTH OBJECT + * objects in PcInitiate message. + */ + @Test + public void initiateMessageTest12() throws PcepParseException { + + /* SRP, LSP (SymbolicPathNameTlv, StatefulIPv4LspIdentidiersTlv, SymbolicPathNameTlv), + * END-POINTS, ERO, LSPA, BANDWIDTH OBJECT. + */ + byte[] initiateCreationMsg = new byte[]{0x20, 0x0C, 0x00, (byte) 0x78, + 0x21, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x20, 0x10, 0x00, 0x24, 0x00, 0x00, 0x10, 0x03, + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x00, 0x11, 0x00, 0x04, 0x54, 0x31, 0x32, 0x33, //SymbolicPathNameTlv + 0x04, 0x12, 0x00, 0x0C, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, //Endpoints Object + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x0C, 0x01, //ERO object + 0x01, 0x01, 0x00, 0x00, 0x01, 0x08, 0x0C, 0x01, 0x01, 0x02, 0x00, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00}; //Bandwidth object + + byte[] testInitiateCreationMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(initiateCreationMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepInitiateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + + message.writeTo(buf); + + testInitiateCreationMsg = buf.array(); + + int iReadLen = buf.writerIndex(); + testInitiateCreationMsg = new byte[iReadLen]; + buf.readBytes(testInitiateCreationMsg, 0, iReadLen); + + assertThat(testInitiateCreationMsg, is(initiateCreationMsg)); + } + + /** + * This test case checks for SRP, LSP (SymbolicPathNameTlv, StatefulIPv4LspIdentidiersTlv, + * SymbolicPathNameTlv, StatefulLspDbVerTlv), END-POINTS, ERO, LSPA, BANDWIDTH , METRIC OBJECT + * objects in PcInitiate message. + */ + @Test + public void initiateMessageTest13() throws PcepParseException { + + /* SRP, LSP (SymbolicPathNameTlv, StatefulIPv4LspIdentidiersTlv, SymbolicPathNameTlv, StatefulLspDbVerTlv), + * END-POINTS, ERO, LSPA, BANDWIDTH , METRIC OBJECT. + */ + byte[] initiateCreationMsg = new byte[]{0x20, 0x0C, 0x00, (byte) 0x84, + 0x21, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x20, 0x10, 0x00, 0x24, 0x00, 0x00, 0x10, 0x03, + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x00, 0x11, 0x00, 0x04, 0x54, 0x31, 0x32, 0x33, //SymbolicPathNameTlv + 0x04, 0x12, 0x00, 0x0C, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, //Endpoints Object + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x0C, 0x01, //ERO object + 0x01, 0x01, 0x00, 0x00, 0x01, 0x08, 0x0C, 0x01, 0x01, 0x02, 0x00, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, //Bandwidth object + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01}; + + byte[] testInitiateCreationMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(initiateCreationMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepInitiateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + + message.writeTo(buf); + + testInitiateCreationMsg = buf.array(); + + int iReadLen = buf.writerIndex(); + testInitiateCreationMsg = new byte[iReadLen]; + buf.readBytes(testInitiateCreationMsg, 0, iReadLen); + + assertThat(testInitiateCreationMsg, is(initiateCreationMsg)); + } + + /** + * This test case checks for SRP, LSP (SymbolicPathNameTlv, StatefulIPv4LspIdentidiersTlv), + * END-POINTS, ERO, LSPA, BANDWIDTH , METRIC OBJECT objects in PcInitiate message. + */ + @Test + public void initiateMessageTest14() throws PcepParseException { + + /* SRP, LSP (SymbolicPathNameTlv, StatefulIPv4LspIdentidiersTlv), + * END-POINTS, ERO, LSPA, BANDWIDTH , METRIC OBJECT. + */ + byte[] initiateCreationMsg = new byte[]{0x20, 0x0C, 0x00, (byte) 0x7c, + 0x21, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x20, 0x10, 0x00, 0x1c, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x04, 0x12, 0x00, 0x0C, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, //Endpoints Object + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x0C, 0x01, //ERO object + 0x01, 0x01, 0x00, 0x00, 0x01, 0x08, 0x0C, 0x01, 0x01, 0x02, 0x00, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, //Bandwidth object + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01}; + + byte[] testInitiateCreationMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(initiateCreationMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepInitiateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + + message.writeTo(buf); + + testInitiateCreationMsg = buf.array(); + + int iReadLen = buf.writerIndex(); + testInitiateCreationMsg = new byte[iReadLen]; + buf.readBytes(testInitiateCreationMsg, 0, iReadLen); + + assertThat(testInitiateCreationMsg, is(initiateCreationMsg)); + } + + /** + * This test case checks for SRP, LSP (SymbolicPathNameTlv, StatefulIPv4LspIdentidiersTlv), + * END-POINTS, ERO, LSPA, BANDWIDTH OBJECT objects in PcInitiate message. + */ + @Test + public void initiateMessageTest15() throws PcepParseException { + + /* SRP, LSP (SymbolicPathNameTlv, StatefulIPv4LspIdentidiersTlv), + * END-POINTS, ERO, LSPA, BANDWIDTH OBJECT. + */ + byte[] initiateCreationMsg = new byte[]{0x20, 0x0C, 0x00, (byte) 0x70, + 0x21, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x20, 0x10, 0x00, 0x1c, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x04, 0x12, 0x00, 0x0C, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, //Endpoints Object + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x0C, 0x01, //ERO object + 0x01, 0x01, 0x00, 0x00, 0x01, 0x08, 0x0C, 0x01, 0x01, 0x02, 0x00, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00}; //Bandwidth object + + byte[] testInitiateCreationMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(initiateCreationMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepInitiateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + + message.writeTo(buf); + + testInitiateCreationMsg = buf.array(); + + int iReadLen = buf.writerIndex(); + testInitiateCreationMsg = new byte[iReadLen]; + buf.readBytes(testInitiateCreationMsg, 0, iReadLen); + + assertThat(testInitiateCreationMsg, is(initiateCreationMsg)); + } + + /** + * This test case checks for SRP, LSP (SymbolicPathNameTlv, StatefulIPv4LspIdentidiersTlv), + * END-POINTS, ERO, LSPA OBJECT objects in PcInitiate message. + */ + @Test + public void initiateMessageTest16() throws PcepParseException { + + /* SRP, LSP (SymbolicPathNameTlv, StatefulIPv4LspIdentidiersTlv), + * END-POINTS, ERO, LSPA OBJECT. + */ + byte[] initiateCreationMsg = new byte[]{0x20, 0x0C, 0x00, (byte) 0x68, + 0x21, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x20, 0x10, 0x00, 0x1c, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x04, 0x12, 0x00, 0x0C, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, //Endpoints Object + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x0C, 0x01, //ERO object + 0x01, 0x01, 0x00, 0x00, 0x01, 0x08, 0x0C, 0x01, 0x01, 0x02, 0x00, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00}; + + byte[] testInitiateCreationMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(initiateCreationMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepInitiateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + + message.writeTo(buf); + + testInitiateCreationMsg = buf.array(); + + int iReadLen = buf.writerIndex(); + testInitiateCreationMsg = new byte[iReadLen]; + buf.readBytes(testInitiateCreationMsg, 0, iReadLen); + + assertThat(testInitiateCreationMsg, is(initiateCreationMsg)); + } + + /** + * This test case checks for SRP, LSP (StatefulIPv4LspIdentidiersTlv), END-POINTS, ERO, LSPA OBJECT + * objects in PcInitiate message. + */ + @Test + public void initiateMessageTest17() throws PcepParseException { + + /* SRP, LSP (StatefulIPv4LspIdentidiersTlv), END-POINTS, ERO, LSPA OBJECT. + */ + byte[] initiateCreationMsg = new byte[]{0x20, 0x0C, 0x00, (byte) 0x60, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x1c, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x04, 0x12, 0x00, 0x0C, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, //Endpoints Object + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x0C, 0x01, //ERO object + 0x01, 0x01, 0x00, 0x00, 0x01, 0x08, 0x0C, 0x01, 0x01, 0x02, 0x00, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00}; + + byte[] testInitiateCreationMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(initiateCreationMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepInitiateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + + message.writeTo(buf); + + testInitiateCreationMsg = buf.array(); + + int iReadLen = buf.writerIndex(); + testInitiateCreationMsg = new byte[iReadLen]; + buf.readBytes(testInitiateCreationMsg, 0, iReadLen); + + assertThat(testInitiateCreationMsg, is(initiateCreationMsg)); + } + + /** + * This test case checks for SRP, LSP (StatefulIPv4LspIdentidiersTlv), END-POINTS, ERO, LSPA, + * BANDWIDTH OBJECT objects in PcInitiate message. + */ + @Test + public void initiateMessageTest18() throws PcepParseException { + + /* SRP, LSP (StatefulIPv4LspIdentidiersTlv), END-POINTS, ERO, LSPA, BANDWIDTH OBJECT. + */ + byte[] initiateCreationMsg = new byte[]{0x20, 0x0C, 0x00, (byte) 0x68, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x1c, 0x00, 0x00, 0x10, 0x03, + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x04, 0x12, 0x00, 0x0C, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, //Endpoints Object + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x0C, 0x01, //ERO object + 0x01, 0x01, 0x00, 0x00, 0x01, 0x08, 0x0C, 0x01, 0x01, 0x02, 0x00, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00}; //Bandwidth object + + byte[] testInitiateCreationMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(initiateCreationMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepInitiateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + + message.writeTo(buf); + + testInitiateCreationMsg = buf.array(); + + int iReadLen = buf.writerIndex(); + testInitiateCreationMsg = new byte[iReadLen]; + buf.readBytes(testInitiateCreationMsg, 0, iReadLen); + + assertThat(testInitiateCreationMsg, is(initiateCreationMsg)); + } + + /** + * This test case checks for SRP, LSP (StatefulIPv4LspIdentidiersTlv), END-POINTS, ERO, LSPA, + * BANDWIDTH, METRIC OBJECT objects in PcInitiate message. + */ + @Test + public void initiateMessageTest19() throws PcepParseException { + + /* SRP, LSP (StatefulIPv4LspIdentidiersTlv), END-POINTS, ERO, LSPA, BANDWIDTH, METRIC OBJECT. + */ + byte[] initiateCreationMsg = new byte[]{0x20, 0x0C, 0x00, (byte) 0x74, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x1c, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x04, 0x12, 0x00, 0x0C, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, //Endpoints Object + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x0C, 0x01, //ERO object + 0x01, 0x01, 0x00, 0x00, 0x01, 0x08, 0x0C, 0x01, 0x01, 0x02, 0x00, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, //Bandwidth object + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01}; + + byte[] testInitiateCreationMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(initiateCreationMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepInitiateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + + message.writeTo(buf); + + testInitiateCreationMsg = buf.array(); + + int iReadLen = buf.writerIndex(); + testInitiateCreationMsg = new byte[iReadLen]; + buf.readBytes(testInitiateCreationMsg, 0, iReadLen); + + assertThat(testInitiateCreationMsg, is(initiateCreationMsg)); + } + + /** + * This test case checks for SRP, LSP (StatefulIPv4LspIdentidiersTlv), END-POINTS, ERO, LSPA, + * BANDWIDTH, METRIC OBJECT objects in PcInitiate message. + */ + @Test + public void initiateMessageTest20() throws PcepParseException { + + /* SRP, LSP (StatefulIPv4LspIdentidiersTlv), END-POINTS, ERO, LSPA, BANDWIDTH, METRIC OBJECT. + */ + byte[] initiateCreationMsg = new byte[]{0x20, 0x0C, 0x00, (byte) 0x64, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x1c, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x04, 0x12, 0x00, 0x0C, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, //Endpoints Object + 0x07, 0x10, 0x00, 0x04, //ERO object + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, //Bandwidth object + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01}; + + byte[] testInitiateCreationMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(initiateCreationMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepInitiateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + + message.writeTo(buf); + + testInitiateCreationMsg = buf.array(); + + int iReadLen = buf.writerIndex(); + testInitiateCreationMsg = new byte[iReadLen]; + buf.readBytes(testInitiateCreationMsg, 0, iReadLen); + + assertThat(testInitiateCreationMsg, is(initiateCreationMsg)); + } + + /** + * This test case checks for SRP, LSP (StatefulIPv4LspIdentidiersTlv), END-POINTS, ERO, LSPA, + * BANDWIDTH OBJECT objects in PcInitiate message. + */ + @Test + public void initiateMessageTest21() throws PcepParseException { + + /* SRP, LSP (StatefulIPv4LspIdentidiersTlv), END-POINTS, ERO, LSPA, BANDWIDTH OBJECT. + */ + byte[] initiateCreationMsg = new byte[]{0x20, 0x0C, 0x00, (byte) 0x58, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x1c, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x04, 0x12, 0x00, 0x0C, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, //Endpoints Object + 0x07, 0x10, 0x00, 0x04, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00}; //Bandwidth object + + byte[] testInitiateCreationMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(initiateCreationMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepInitiateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + + message.writeTo(buf); + + testInitiateCreationMsg = buf.array(); + + int iReadLen = buf.writerIndex(); + testInitiateCreationMsg = new byte[iReadLen]; + buf.readBytes(testInitiateCreationMsg, 0, iReadLen); + + assertThat(testInitiateCreationMsg, is(initiateCreationMsg)); + } + + /** + * This test case checks for SRP, LSP (StatefulIPv4LspIdentidiersTlv), END-POINTS, ERO, + * LSPA OBJECT objects in PcInitiate message. + */ + @Test + public void initiateMessageTest22() throws PcepParseException { + + /* SRP, LSP (StatefulIPv4LspIdentidiersTlv), END-POINTS, ERO, LSPA OBJECT. + */ + byte[] initiateCreationMsg = new byte[]{0x20, 0x0C, 0x00, (byte) 0x50, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x1c, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x04, 0x12, 0x00, 0x0C, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, //Endpoints Object + 0x07, 0x10, 0x00, 0x04, //ERO object + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00}; + + byte[] testInitiateCreationMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(initiateCreationMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepInitiateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + + message.writeTo(buf); + + testInitiateCreationMsg = buf.array(); + + int iReadLen = buf.writerIndex(); + testInitiateCreationMsg = new byte[iReadLen]; + buf.readBytes(testInitiateCreationMsg, 0, iReadLen); + + assertThat(testInitiateCreationMsg, is(initiateCreationMsg)); + } + + /** + * This test case checks for SRP, LSP (SymbolicPathNameTlv, StatefulIPv4LspIdentidiersTlv), + * END-POINTS, ERO, LSPA OBJECT objects in PcInitiate message. + */ + @Test + public void initiateMessageTest23() throws PcepParseException { + + /* SRP, LSP (SymbolicPathNameTlv, StatefulIPv4LspIdentidiersTlv), END-POINTS, ERO, LSPA OBJECT. + */ + byte[] initiateCreationMsg = new byte[]{0x20, 0x0C, 0x00, (byte) 0x58, + 0x21, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x20, 0x10, 0x00, 0x1c, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x04, 0x12, 0x00, 0x0C, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, //Endpoints Object + 0x07, 0x10, 0x00, 0x04, //ERO object + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00}; + + byte[] testInitiateCreationMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(initiateCreationMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepInitiateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + + message.writeTo(buf); + + testInitiateCreationMsg = buf.array(); + + int iReadLen = buf.writerIndex(); + testInitiateCreationMsg = new byte[iReadLen]; + buf.readBytes(testInitiateCreationMsg, 0, iReadLen); + + assertThat(testInitiateCreationMsg, is(initiateCreationMsg)); + } + + /** + * This test case checks for SRP, LSP (SymbolicPathNameTlv, StatefulIPv4LspIdentidiersTlv), + * END-POINTS, ERO, LSPA BANDWIDTH OBJECT objects in PcInitiate message. + */ + @Test + public void initiateMessageTest25() throws PcepParseException { + + /* SRP, LSP (SymbolicPathNameTlv, StatefulIPv4LspIdentidiersTlv), END-POINTS, ERO, LSPA BANDWIDTH OBJECT. + */ + byte[] initiateCreationMsg = new byte[]{0x20, 0x0C, 0x00, (byte) 0x60, + 0x21, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x20, 0x10, 0x00, 0x1c, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x04, 0x12, 0x00, 0x0C, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, //Endpoints Object + 0x07, 0x10, 0x00, 0x04, //ERO object + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00}; //Bandwidth object + + byte[] testInitiateCreationMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(initiateCreationMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepInitiateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + + message.writeTo(buf); + + testInitiateCreationMsg = buf.array(); + + int iReadLen = buf.writerIndex(); + testInitiateCreationMsg = new byte[iReadLen]; + buf.readBytes(testInitiateCreationMsg, 0, iReadLen); + + assertThat(testInitiateCreationMsg, is(initiateCreationMsg)); + } + + /** + * This test case checks for SRP, LSP (SymbolicPathNameTlv, StatefulIPv4LspIdentidiersTlv), END-POINTS, + * ERO, LSPA, BANDWIDTH, METRIC OBJECT objects in PcInitiate message. + */ + @Test + public void initiateMessageTest26() throws PcepParseException { + + /* SRP, LSP (SymbolicPathNameTlv, StatefulIPv4LspIdentidiersTlv), END-POINTS, + * ERO, LSPA, BANDWIDTH, METRIC OBJECT. + */ + byte[] initiateCreationMsg = new byte[]{0x20, 0x0C, 0x00, (byte) 0x6C, + 0x21, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x20, 0x10, 0x00, 0x1c, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x04, 0x12, 0x00, 0x0C, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, //Endpoints Object + 0x07, 0x10, 0x00, 0x04, //ERO object + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, //Bandwidth object + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01}; //Metric object + + byte[] testInitiateCreationMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(initiateCreationMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepInitiateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + + message.writeTo(buf); + + testInitiateCreationMsg = buf.array(); + + int iReadLen = buf.writerIndex(); + testInitiateCreationMsg = new byte[iReadLen]; + buf.readBytes(testInitiateCreationMsg, 0, iReadLen); + + assertThat(testInitiateCreationMsg, is(initiateCreationMsg)); + } + + /** + * This test case checks for SRP, LSP (SymbolicPathNameTlv, SymbolicPathNameTlv), END-POINTS, ERO, LSPA, + * BANDWIDTH, METRIC OBJECT objects in PcInitiate message. + */ + @Test + public void initiateMessageTest27() throws PcepParseException { + + /* SRP, LSP (SymbolicPathNameTlv, SymbolicPathNameTlv), END-POINTS, ERO, LSPA, BANDWIDTH, METRIC OBJECT. + */ + byte[] initiateCreationMsg = new byte[]{0x20, 0x0C, 0x00, (byte) 0x60, + 0x21, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x20, 0x10, 0x00, 0x10, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x04, 0x12, 0x00, 0x0C, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, //Endpoints Object + 0x07, 0x10, 0x00, 0x04, //ERO object + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, //Bandwidth object + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01}; //Metric object + + byte[] testInitiateCreationMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(initiateCreationMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepInitiateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + + message.writeTo(buf); + + testInitiateCreationMsg = buf.array(); + + int iReadLen = buf.writerIndex(); + testInitiateCreationMsg = new byte[iReadLen]; + buf.readBytes(testInitiateCreationMsg, 0, iReadLen); + + assertThat(testInitiateCreationMsg, is(initiateCreationMsg)); + } + + /** + * This test case checks for SRP, LSP (SymbolicPathNameTlv, SymbolicPathNameTlv), END-POINTS, ERO, + * LSPA, BANDWIDTH OBJECT objects in PcInitiate message. + */ + @Test + public void initiateMessageTest28() throws PcepParseException { + + /* SRP, LSP (SymbolicPathNameTlv, SymbolicPathNameTlv), END-POINTS, ERO, LSPA, BANDWIDTH OBJECT. + */ + byte[] initiateCreationMsg = new byte[]{0x20, 0x0C, 0x00, (byte) 0x54, + 0x21, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x20, 0x10, 0x00, 0x10, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x04, 0x12, 0x00, 0x0C, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, //Endpoints Object + 0x07, 0x10, 0x00, 0x04, //ERO object + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00}; //Bandwidth object + + byte[] testInitiateCreationMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(initiateCreationMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepInitiateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + + message.writeTo(buf); + + testInitiateCreationMsg = buf.array(); + + int iReadLen = buf.writerIndex(); + testInitiateCreationMsg = new byte[iReadLen]; + buf.readBytes(testInitiateCreationMsg, 0, iReadLen); + + assertThat(testInitiateCreationMsg, is(initiateCreationMsg)); + } + + /** + * This test case checks for SRP, LSP (SymbolicPathNameTlv, SymbolicPathNameTlv), + * END-POINTS, ERO, LSPA OBJECT objects in PcInitiate message. + */ + @Test + public void initiateMessageTest29() throws PcepParseException { + + /* SRP, LSP (SymbolicPathNameTlv, SymbolicPathNameTlv), END-POINTS, ERO, LSPA OBJECT. + */ + byte[] initiateCreationMsg = new byte[]{0x20, 0x0C, 0x00, (byte) 0x4C, + 0x21, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x20, 0x10, 0x00, 0x10, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x04, 0x12, 0x00, 0x0C, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, //Endpoints Object + 0x07, 0x10, 0x00, 0x04, //ERO object + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00}; + + byte[] testInitiateCreationMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(initiateCreationMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepInitiateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + + message.writeTo(buf); + + testInitiateCreationMsg = buf.array(); + + int iReadLen = buf.writerIndex(); + testInitiateCreationMsg = new byte[iReadLen]; + buf.readBytes(testInitiateCreationMsg, 0, iReadLen); + + assertThat(testInitiateCreationMsg, is(initiateCreationMsg)); + } + + /** + * This test case checks for SRP, LSP (SymbolicPathNameTlv, SymbolicPathNameTlv), + * END-POINTS, ERO, LSPA OBJECT objects in PcInitiate message. + */ + @Test + public void initiateMessageTest30() throws PcepParseException { + + /* SRP, LSP (SymbolicPathNameTlv, SymbolicPathNameTlv), END-POINTS, ERO, LSPA OBJECT. + */ + byte[] initiateCreationMsg = new byte[]{0x20, 0x0C, 0x00, (byte) 0x5C, + 0x21, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x20, 0x10, 0x00, 0x10, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x04, 0x12, 0x00, 0x0C, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, //Endpoints Object + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x0C, 0x01, //ERO object + 0x01, 0x01, 0x00, 0x00, 0x01, 0x08, 0x0C, 0x01, 0x01, 0x02, 0x00, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00}; + + byte[] testInitiateCreationMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(initiateCreationMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepInitiateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + + message.writeTo(buf); + + testInitiateCreationMsg = buf.array(); + + int iReadLen = buf.writerIndex(); + testInitiateCreationMsg = new byte[iReadLen]; + buf.readBytes(testInitiateCreationMsg, 0, iReadLen); + + assertThat(testInitiateCreationMsg, is(initiateCreationMsg)); + } + + /** + * This test case checks for SRP, LSP (SymbolicPathNameTlv), END-POINTS, ERO, LSPA OBJECT + * objects in PcInitiate message. + */ + @Test + public void initiateMessageTest31() throws PcepParseException { + + /* SRP, LSP (SymbolicPathNameTlv), END-POINTS, ERO, LSPA OBJECT. + */ + byte[] initiateCreationMsg = new byte[]{0x20, 0x0C, 0x00, (byte) 0x54, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x10, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x04, 0x12, 0x00, 0x0C, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, //Endpoints Object + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x0C, 0x01, //ERO object + 0x01, 0x01, 0x00, 0x00, 0x01, 0x08, 0x0C, 0x01, 0x01, 0x02, 0x00, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00}; + + byte[] testInitiateCreationMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(initiateCreationMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepInitiateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + + message.writeTo(buf); + + testInitiateCreationMsg = buf.array(); + + int iReadLen = buf.writerIndex(); + testInitiateCreationMsg = new byte[iReadLen]; + buf.readBytes(testInitiateCreationMsg, 0, iReadLen); + + assertThat(testInitiateCreationMsg, is(initiateCreationMsg)); + } + + /** + * This test case checks for SRP, LSP ( StatefulLspDbVerTlv), END-POINTS, + * ERO, LSPA, BANDWIDTH, METRIC OBJECT objects in PcInitiate message. + */ + @Test + public void initiateMessageTest32() throws PcepParseException { + + /* SRP, LSP ( StatefulLspDbVerTlv), END-POINTS, + * ERO, LSPA, BANDWIDTH, METRIC OBJECT. + */ + byte[] initiateCreationMsg = new byte[]{0x20, 0x0C, 0x00, (byte) 0x64, + 0x21, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x20, 0x10, 0x00, 0x14, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x17, 0x00, 0x08, //StatefulLspDbVerTlv + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, + 0x04, 0x12, 0x00, 0x0C, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, //Endpoints Object + 0x07, 0x10, 0x00, 0x04, //ERO object + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, //Bandwidth object + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01}; //Metric object + + byte[] testInitiateCreationMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(initiateCreationMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepInitiateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + + message.writeTo(buf); + + testInitiateCreationMsg = buf.array(); + + int iReadLen = buf.writerIndex(); + testInitiateCreationMsg = new byte[iReadLen]; + buf.readBytes(testInitiateCreationMsg, 0, iReadLen); + + assertThat(testInitiateCreationMsg, is(initiateCreationMsg)); + } + + /** + * This test case checks for SRP, LSP ( StatefulLspDbVerTlv), END-POINTS, + * ERO, LSPA, BANDWIDTH OBJECT objects in PcInitiate message. + */ + @Test + public void initiateMessageTest33() throws PcepParseException { + + /* SRP, LSP ( StatefulLspDbVerTlv), END-POINTS, + * ERO, LSPA, BANDWIDTH OBJECT. + */ + byte[] initiateCreationMsg = new byte[]{0x20, 0x0C, 0x00, (byte) 0x58, + 0x21, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x20, 0x10, 0x00, 0x14, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x17, 0x00, 0x08, //StatefulLspDbVerTlv + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, + 0x04, 0x12, 0x00, 0x0C, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, //Endpoints Object + 0x07, 0x10, 0x00, 0x04, //ERO object + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00}; //Bandwidth object + + byte[] testInitiateCreationMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(initiateCreationMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepInitiateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + + message.writeTo(buf); + + testInitiateCreationMsg = buf.array(); + + int iReadLen = buf.writerIndex(); + testInitiateCreationMsg = new byte[iReadLen]; + buf.readBytes(testInitiateCreationMsg, 0, iReadLen); + + assertThat(testInitiateCreationMsg, is(initiateCreationMsg)); + } + + /** + * This test case checks for SRP, LSP ( StatefulLspDbVerTlv), END-POINTS, + * ERO, LSPA OBJECT objects in PcInitiate message. + */ + @Test + public void initiateMessageTest34() throws PcepParseException { + + /* SRP, LSP ( StatefulLspDbVerTlv), END-POINTS, + * ERO, LSPA OBJECT. + */ + byte[] initiateCreationMsg = new byte[]{0x20, 0x0C, 0x00, (byte) 0x50, + 0x21, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x20, 0x10, 0x00, 0x14, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x17, 0x00, 0x08, //StatefulLspDbVerTlv + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, + 0x04, 0x12, 0x00, 0x0C, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, //Endpoints Object + 0x07, 0x10, 0x00, 0x04, //ERO object + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00}; + + byte[] testInitiateCreationMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(initiateCreationMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepInitiateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + + message.writeTo(buf); + + testInitiateCreationMsg = buf.array(); + + int iReadLen = buf.writerIndex(); + testInitiateCreationMsg = new byte[iReadLen]; + buf.readBytes(testInitiateCreationMsg, 0, iReadLen); + + assertThat(testInitiateCreationMsg, is(initiateCreationMsg)); + } + + /** + * This test case checks for SRP, LSP ( StatefulLspDbVerTlv), END-POINTS, + * ERO, LSPA OBJECT objects in PcInitiate message. + */ + @Test + public void initiateMessageTest35() throws PcepParseException { + + /* SRP, LSP ( StatefulLspDbVerTlv), END-POINTS, + * ERO, LSPA OBJECT. + */ + byte[] initiateCreationMsg = new byte[]{0x20, 0x0C, 0x00, (byte) 0x60, + 0x21, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x20, 0x10, 0x00, 0x14, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x17, 0x00, 0x08, //StatefulLspDbVerTlv + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, + 0x04, 0x12, 0x00, 0x0C, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, //Endpoints Object + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x0C, 0x01, //ERO object + 0x01, 0x01, 0x00, 0x00, 0x01, 0x08, 0x0C, 0x01, 0x01, 0x02, 0x00, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00}; + + byte[] testInitiateCreationMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(initiateCreationMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepInitiateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + + message.writeTo(buf); + + testInitiateCreationMsg = buf.array(); + + int iReadLen = buf.writerIndex(); + testInitiateCreationMsg = new byte[iReadLen]; + buf.readBytes(testInitiateCreationMsg, 0, iReadLen); + + assertThat(testInitiateCreationMsg, is(initiateCreationMsg)); + } + + /** + * This test case checks for SRP, LSP ( StatefulLspDbVerTlv), END-POINTS, + * ERO, LSPA OBJECT objects in PcInitiate message. + */ + @Test + public void initiateMessageTest36() throws PcepParseException { + + /* SRP, LSP ( StatefulLspDbVerTlv), END-POINTS, + * ERO, LSPA OBJECT. + */ + byte[] initiateCreationMsg = new byte[]{0x20, 0x0C, 0x00, (byte) 0x58, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x14, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x17, 0x00, 0x08, //StatefulLspDbVerTlv + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, + 0x04, 0x12, 0x00, 0x0C, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, //Endpoints Object + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x0C, 0x01, //ERO object + 0x01, 0x01, 0x00, 0x00, 0x01, 0x08, 0x0C, 0x01, 0x01, 0x02, 0x00, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00}; + + byte[] testInitiateCreationMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(initiateCreationMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepInitiateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + + message.writeTo(buf); + + testInitiateCreationMsg = buf.array(); + + int iReadLen = buf.writerIndex(); + testInitiateCreationMsg = new byte[iReadLen]; + buf.readBytes(testInitiateCreationMsg, 0, iReadLen); + + assertThat(testInitiateCreationMsg, is(initiateCreationMsg)); + } +} + diff --git a/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/protocol/PcepInitiateMsgTest.java b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/protocol/PcepInitiateMsgTest.java new file mode 100644 index 00000000..0f8bb7ba --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/protocol/PcepInitiateMsgTest.java @@ -0,0 +1,1331 @@ +/* + * Copyright 2014-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; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.jboss.netty.buffer.ChannelBuffers; +import org.junit.Test; +import org.onosproject.pcepio.exceptions.PcepParseException; + +import static org.hamcrest.MatcherAssert.assertThat; +import static org.hamcrest.Matchers.instanceOf; +import static org.hamcrest.core.Is.is; + +public class PcepInitiateMsgTest { + + /** + * This test case checks for srp, lsp, end-point, ERO objects in PcInitiate message. + */ + @Test + public void initiateMessageTest1() throws PcepParseException { + + /* srp, lsp, end-point, ERO. + */ + byte[] initiateCreationMsg = new byte[]{0x20, 0x0C, 0x00, 0x54, + 0x21, 0x10, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, //SRP object + 0x20, 0x10, 0x00, 0x24, 0x00, 0x00, 0x00, 0x08, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x02, 0x02, 0x02, 0x02, + 0x00, 0x11, 0x00, 0x04, 0x54, 0x31, 0x32, 0x33, //SymbolicPathTlv + 0x04, 0x12, 0x00, 0x0C, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, //Endpoints Object + 0x07, 0x10, 0x00, 0x14, //ERO object + 0x01, 0x08, 0x0C, 0x01, 0x01, 0x01, 0x00, 0x00, + 0x01, 0x08, 0x0C, 0x01, 0x01, 0x02, 0x00, 0x00}; + + byte[] testInitiateCreationMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(initiateCreationMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepInitiateMsg.class)); + + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + + message.writeTo(buf); + + testInitiateCreationMsg = buf.array(); + + int iReadLen = buf.writerIndex(); + testInitiateCreationMsg = new byte[iReadLen]; + buf.readBytes(testInitiateCreationMsg, 0, iReadLen); + + assertThat(testInitiateCreationMsg, is(initiateCreationMsg)); + } + + /** + * This test case checks for srp and lsp objects in PcInitiate message. + */ + @Test + public void initiateMessageTest2() throws PcepParseException { + /* srp, lsp. + */ + byte[] initiateDeletionMsg = new byte[]{0x20, 0x0C, 0x00, 0x34, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x24, 0x00, 0x00, 0x20, 0x10, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + 0x01, 0x01, 0x01, 0x01, 0x00, 0x43, (byte) 0x83, 0x01, + 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, + 0x00, 0x11, 0x00, 0x04, 0x54, 0x31, 0x32, 0x33}; //SymbolicPathTlv + + byte[] testInitiateDeletionMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(initiateDeletionMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepInitiateMsg.class)); + + + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testInitiateDeletionMsg = buf.array(); + + int iReadLen = buf.writerIndex(); + testInitiateDeletionMsg = new byte[iReadLen]; + buf.readBytes(testInitiateDeletionMsg, 0, iReadLen); + + assertThat(testInitiateDeletionMsg, is(initiateDeletionMsg)); + } + + /** + * This test case checks for SRP, LSP (StatefulIPv4LspIdentidiersTlv, SymbolicPathNameTlv, + * StatefulLspErrorCodeTlv, StatefulRsvpErrorSpecTlv), END-POINTS, ERO objects + * in PcInitiate message. + */ + @Test + public void initiateMessageTest3() throws PcepParseException { + + /* SRP, LSP (StatefulIPv4LspIdentidiersTlv, SymbolicPathNameTlv, + * StatefulLspErrorCodeTlv, StatefulRsvpErrorSpecTlv), END-POINTS, ERO. + */ + byte[] initiateCreationMsg = new byte[]{0x20, 0x0C, 0x00, (byte) 0x64, + 0x21, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x20, 0x10, 0x00, 0x2c, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x00, 0x11, 0x00, 0x04, 0x54, 0x31, 0x32, 0x33, //SymbolicPathNameTlv + 0x00, 0x14, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, //StatefulLspErrorCodeTlv + 0x04, 0x12, 0x00, 0x0C, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, //Endpoints Object + 0x07, 0x10, 0x00, 0x14, //ERO object + 0x01, 0x08, 0x0C, 0x01, 0x01, 0x01, 0x00, 0x00, + 0x01, 0x08, 0x0C, 0x01, 0x01, 0x02, 0x00, 0x00}; + + byte[] testInitiateCreationMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(initiateCreationMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepInitiateMsg.class)); + + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + + message.writeTo(buf); + testInitiateCreationMsg = buf.array(); + + int iReadLen = buf.writerIndex(); + testInitiateCreationMsg = new byte[iReadLen]; + buf.readBytes(testInitiateCreationMsg, 0, iReadLen); + + assertThat(testInitiateCreationMsg, is(initiateCreationMsg)); + } + + /** + * This test case checks for SRP, LSP (StatefulIPv4LspIdentidiersTlv, SymbolicPathNameTlv, + * StatefulLspErrorCodeTlv), END-POINT, ERO objects in PcInitiate message. + */ + @Test + public void initiateMessageTest4() throws PcepParseException { + + /* SRP, LSP (StatefulIPv4LspIdentidiersTlv, SymbolicPathNameTlv, + * StatefulLspErrorCodeTlv), END-POINT, ERO. + */ + byte[] initiateCreationMsg = new byte[]{0x20, 0x0C, 0x00, (byte) 0x64, + 0x21, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x20, 0x10, 0x00, 0x2c, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x00, 0x14, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, //StatefulLspErrorCodeTlv + 0x04, 0x12, 0x00, 0x0C, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, //Endpoints Object + 0x07, 0x10, 0x00, 0x14, //ERO object + 0x01, 0x08, 0x0C, 0x01, 0x01, 0x01, 0x00, 0x00, + 0x01, 0x08, 0x0C, 0x01, 0x01, 0x02, 0x00, 0x00}; + + byte[] testInitiateCreationMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(initiateCreationMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepInitiateMsg.class)); + + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testInitiateCreationMsg = buf.array(); + + int iReadLen = buf.writerIndex(); + testInitiateCreationMsg = new byte[iReadLen]; + buf.readBytes(testInitiateCreationMsg, 0, iReadLen); + + assertThat(testInitiateCreationMsg, is(initiateCreationMsg)); + } + + /** + * This test case checks for SRP, LSP (StatefulIPv4LspIdentidiersTlv, SymbolicPathNameTlv), + * END-POINT, ERO objects in PcInitiate message. + */ + @Test + public void initiateMessageTest5() throws PcepParseException { + + /* SRP, LSP (StatefulIPv4LspIdentidiersTlv, SymbolicPathNameTlv), + * END-POINT, ERO. + */ + byte[] initiateCreationMsg = new byte[]{0x20, 0x0C, 0x00, (byte) 0x5c, + 0x21, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x20, 0x10, 0x00, 0x24, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x04, 0x12, 0x00, 0x0C, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, //Endpoints Object + 0x07, 0x10, 0x00, 0x14, //ERO object + 0x01, 0x08, 0x0C, 0x01, 0x01, 0x01, 0x00, 0x00, + 0x01, 0x08, 0x0C, 0x01, 0x01, 0x02, 0x00, 0x00}; + + byte[] testInitiateCreationMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(initiateCreationMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepInitiateMsg.class)); + + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + + message.writeTo(buf); + + testInitiateCreationMsg = buf.array(); + + int iReadLen = buf.writerIndex(); + testInitiateCreationMsg = new byte[iReadLen]; + buf.readBytes(testInitiateCreationMsg, 0, iReadLen); + + assertThat(testInitiateCreationMsg, is(initiateCreationMsg)); + } + + /** + * This test case checks for SRP, LSP (SymbolicPathNameTlv, StatefulIPv4LspIdentidiersTlv, SymbolicPathNameTlv), + * END-POINT, ERO objects in PcInitiate message. + */ + @Test + public void initiateMessageTest6() throws PcepParseException { + + /* SRP, LSP (SymbolicPathNameTlv, StatefulIPv4LspIdentidiersTlv, SymbolicPathNameTlv), + * END-POINT, ERO. + */ + byte[] initiateCreationMsg = new byte[]{0x20, 0x0C, 0x00, (byte) 0x5c, + 0x21, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x20, 0x10, 0x00, 0x24, 0x00, 0x00, 0x10, 0x03, + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x04, 0x12, 0x00, 0x0C, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, //Endpoints Object + 0x07, 0x10, 0x00, 0x14, //ERO object + 0x01, 0x08, 0x0C, 0x01, 0x01, 0x01, 0x00, 0x00, + 0x01, 0x08, 0x0C, 0x01, 0x01, 0x02, 0x00, 0x00}; + + byte[] testInitiateCreationMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(initiateCreationMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepInitiateMsg.class)); + + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + + message.writeTo(buf); + + testInitiateCreationMsg = buf.array(); + + int iReadLen = buf.writerIndex(); + testInitiateCreationMsg = new byte[iReadLen]; + buf.readBytes(testInitiateCreationMsg, 0, iReadLen); + + assertThat(testInitiateCreationMsg, is(initiateCreationMsg)); + } + + /** + * This test case checks for SRP, LSP (SymbolicPathNameTlv, StatefulIPv4LspIdentidiersTlv), + * END-POINT, ERO objects in PcInitiate message. + */ + @Test + public void initiateMessageTest7() throws PcepParseException { + + /* SRP, LSP (SymbolicPathNameTlv, StatefulIPv4LspIdentidiersTlv), + * END-POINT, ERO. + */ + byte[] initiateCreationMsg = new byte[]{0x20, 0x0C, 0x00, (byte) 0x54, + 0x21, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x20, 0x10, 0x00, 0x1c, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x04, 0x12, 0x00, 0x0C, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, //Endpoints Object + 0x07, 0x10, 0x00, 0x14, //ERO object + 0x01, 0x08, 0x0C, 0x01, 0x01, 0x01, 0x00, 0x00, + 0x01, 0x08, 0x0C, 0x01, 0x01, 0x02, 0x00, 0x00}; + + byte[] testInitiateCreationMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(initiateCreationMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepInitiateMsg.class)); + + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + + message.writeTo(buf); + + testInitiateCreationMsg = buf.array(); + + int iReadLen = buf.writerIndex(); + testInitiateCreationMsg = new byte[iReadLen]; + buf.readBytes(testInitiateCreationMsg, 0, iReadLen); + + assertThat(testInitiateCreationMsg, is(initiateCreationMsg)); + } + + /** + * This test case checks for SRP, LSP (StatefulIPv4LspIdentidiersTlv), + * END-POINT, ERO objects in PcInitiate message. + */ + @Test + public void initiateMessageTest8() throws PcepParseException { + + /* SRP, LSP (StatefulIPv4LspIdentidiersTlv), + * END-POINT, ERO. + */ + byte[] initiateCreationMsg = new byte[]{0x20, 0x0C, 0x00, (byte) 0x4c, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x1c, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x04, 0x12, 0x00, 0x0C, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, //Endpoints Object + 0x07, 0x10, 0x00, 0x14, //ERO object + 0x01, 0x08, 0x0C, 0x01, 0x01, 0x01, 0x00, 0x00, + 0x01, 0x08, 0x0C, 0x01, 0x01, 0x02, 0x00, 0x00}; + + byte[] testInitiateCreationMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(initiateCreationMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepInitiateMsg.class)); + + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + + message.writeTo(buf); + + testInitiateCreationMsg = buf.array(); + + int iReadLen = buf.writerIndex(); + testInitiateCreationMsg = new byte[iReadLen]; + buf.readBytes(testInitiateCreationMsg, 0, iReadLen); + + assertThat(testInitiateCreationMsg, is(initiateCreationMsg)); + } + + /** + * This test case checks for SRP, LSP (StatefulIPv4LspIdentidiersTlv), + * END-POINT, ERO objects in PcInitiate message. + */ + @Test + public void initiateMessageTest9() throws PcepParseException { + + /* SRP, LSP (StatefulIPv4LspIdentidiersTlv), + * END-POINT, ERO. + */ + byte[] initiateCreationMsg = new byte[]{0x20, 0x0C, 0x00, (byte) 0x3c, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x1c, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x04, 0x12, 0x00, 0x0C, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, //Endpoints Object + 0x07, 0x10, 0x00, 0x04}; + + byte[] testInitiateCreationMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(initiateCreationMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepInitiateMsg.class)); + + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + + message.writeTo(buf); + + testInitiateCreationMsg = buf.array(); + + int iReadLen = buf.writerIndex(); + testInitiateCreationMsg = new byte[iReadLen]; + buf.readBytes(testInitiateCreationMsg, 0, iReadLen); + + assertThat(testInitiateCreationMsg, is(initiateCreationMsg)); + } + + /** + * This test case checks for SRP, LSP (StatefulIPv4LspIdentidiersTlv, StatefulRsvpErrorSpecTlv) + * objects in PcInitiate message. + */ + @Test + public void initiateMessageTest10() throws PcepParseException { + + /* SRP, LSP (StatefulIPv4LspIdentidiersTlv, StatefulRsvpErrorSpecTlv). + */ + byte[] initiateDeletionMsg = new byte[]{0x20, 0x0C, 0x00, 0x44, + 0x21, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathTlv + 0x20, 0x10, 0x00, 0x2c, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, (byte) 0xb6, 0x02, 0x4e, 0x1f, + (byte) 0xb6, 0x02, 0x4e, 0x20, 0x00, 0x11, 0x00, 0x04, 0x54, 0x31, 0x32, 0x33, //SymbolicPathNameTlv + 0x00, 0x14, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08 //StatefulLspErrorCodeTlv + }; + + byte[] testInitiateDeletionMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(initiateDeletionMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepInitiateMsg.class)); + + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + + message.writeTo(buf); + + testInitiateDeletionMsg = buf.array(); + + int iReadLen = buf.writerIndex(); + testInitiateDeletionMsg = new byte[iReadLen]; + buf.readBytes(testInitiateDeletionMsg, 0, iReadLen); + + assertThat(testInitiateDeletionMsg, is(initiateDeletionMsg)); + } + + /** + * This test case checks for SRP, LSP (StatefulIPv4LspIdentidiersTlv, SymbolicPathNameTlv, + * StatefulLspErrorCodeTlv) objects in PcInitiate message. + */ + @Test + public void initiateMessageTest11() throws PcepParseException { + + /* SRP, LSP (StatefulIPv4LspIdentidiersTlv, SymbolicPathNameTlv, + StatefulLspErrorCodeTlv).*/ + byte[] initiateDeletionMsg = new byte[]{0x20, 0x0C, 0x00, 0x44, + 0x21, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathTlv + 0x20, 0x10, 0x00, 0x2c, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathTlv + 0x00, 0x14, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08}; //StatefulLspErrorCodeTlv + + byte[] testInitiateDeletionMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(initiateDeletionMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepInitiateMsg.class)); + + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + + message.writeTo(buf); + + testInitiateDeletionMsg = buf.array(); + + int iReadLen = buf.writerIndex(); + testInitiateDeletionMsg = new byte[iReadLen]; + buf.readBytes(testInitiateDeletionMsg, 0, iReadLen); + + assertThat(testInitiateDeletionMsg, is(initiateDeletionMsg)); + } + + /** + * This test case checks for SRP, LSP (StatefulIPv4LspIdentidiersTlv, SymbolicPathNameTlv) + * objects in PcInitiate message. + */ + @Test + public void initiateMessageTest12() throws PcepParseException { + + /* SRP, LSP (StatefulIPv4LspIdentidiersTlv, SymbolicPathNameTlv). + */ + byte[] initiateDeletionMsg = new byte[]{0x20, 0x0C, 0x00, 0x3c, + 0x21, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathTlv + 0x20, 0x10, 0x00, 0x24, 0x00, 0x00, 0x10, 0x03, 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00 //SymbolicPathNameTlv + }; + + byte[] testInitiateDeletionMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(initiateDeletionMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepInitiateMsg.class)); + + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + + message.writeTo(buf); + + testInitiateDeletionMsg = buf.array(); + + int iReadLen = buf.writerIndex(); + testInitiateDeletionMsg = new byte[iReadLen]; + buf.readBytes(testInitiateDeletionMsg, 0, iReadLen); + + assertThat(testInitiateDeletionMsg, is(initiateDeletionMsg)); + } + + /** + * This test case checks for SRP, LSP (SymbolicPathNameTlv, StatefulIPv4LspIdentidiersTlv, SymbolicPathNameTlv) + * objects in PcInitiate message. + */ + @Test + public void initiateMessageTest13() throws PcepParseException { + + /* SRP, LSP (SymbolicPathNameTlv, StatefulIPv4LspIdentidiersTlv, SymbolicPathNameTlv). + */ + byte[] initiateDeletionMsg = new byte[]{0x20, 0x0C, 0x00, 0x3c, + 0x21, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathTlv + 0x20, 0x10, 0x00, 0x24, 0x00, 0x00, 0x10, 0x03, 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00}; //SymbolicPathNameTlv + + byte[] testInitiateDeletionMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(initiateDeletionMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepInitiateMsg.class)); + + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + + message.writeTo(buf); + + testInitiateDeletionMsg = buf.array(); + + int iReadLen = buf.writerIndex(); + testInitiateDeletionMsg = new byte[iReadLen]; + buf.readBytes(testInitiateDeletionMsg, 0, iReadLen); + + assertThat(testInitiateDeletionMsg, is(initiateDeletionMsg)); + } + + /** + * This test case checks for SRP, LSP (SymbolicPathNameTlv, StatefulIPv4LspIdentidiersTlv) + * objects in PcInitiate message. + */ + @Test + public void initiateMessageTest14() throws PcepParseException { + + /* SRP, LSP (SymbolicPathNameTlv, StatefulIPv4LspIdentidiersTlv). + */ + byte[] initiateDeletionMsg = new byte[]{0x20, 0x0C, 0x00, 0x34, + 0x21, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathTlv + 0x20, 0x10, 0x00, 0x1c, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20}; + + byte[] testInitiateDeletionMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(initiateDeletionMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepInitiateMsg.class)); + + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + + message.writeTo(buf); + + testInitiateDeletionMsg = buf.array(); + + int iReadLen = buf.writerIndex(); + testInitiateDeletionMsg = new byte[iReadLen]; + buf.readBytes(testInitiateDeletionMsg, 0, iReadLen); + + assertThat(testInitiateDeletionMsg, is(initiateDeletionMsg)); + } + + /** + * This test case checks for SRP, LSP (StatefulIPv4LspIdentidiersTlv) + * objects in PcInitiate message. + */ + @Test + public void initiateMessageTest15() throws PcepParseException { + + /* SRP, LSP (StatefulIPv4LspIdentidiersTlv). + */ + byte[] initiateDeletionMsg = new byte[]{0x20, 0x0C, 0x00, 0x2c, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x1c, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20}; + + byte[] testInitiateDeletionMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(initiateDeletionMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepInitiateMsg.class)); + + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + + message.writeTo(buf); + + testInitiateDeletionMsg = buf.array(); + + int iReadLen = buf.writerIndex(); + testInitiateDeletionMsg = new byte[iReadLen]; + buf.readBytes(testInitiateDeletionMsg, 0, iReadLen); + + assertThat(testInitiateDeletionMsg, is(initiateDeletionMsg)); + } + + /** + * This test case checks for srp,lsp (StatefulIPv4LspIdentidiersTlv),end-point,ero,lspa + * objects in PcInitiate message. + */ + @Test + public void initiateMessageTest16() throws PcepParseException { + + //srp,lsp (StatefulIPv4LspIdentidiersTlv),end-point,ero,lspa + byte[] initiateCreationMsg = new byte[]{0x20, 0x0C, 0x00, (byte) 0x50, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x1c, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x04, 0x12, 0x00, 0x0C, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, //Endpoints Object + 0x07, 0x10, 0x00, 0x04, //ERO object + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; + + byte[] testInitiateCreationMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(initiateCreationMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepInitiateMsg.class)); + + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + + message.writeTo(buf); + + testInitiateCreationMsg = buf.array(); + + int iReadLen = buf.writerIndex(); + testInitiateCreationMsg = new byte[iReadLen]; + buf.readBytes(testInitiateCreationMsg, 0, iReadLen); + + assertThat(testInitiateCreationMsg, is(initiateCreationMsg)); + } + + /** + * This test case checks for srp,lsp (StatefulIPv4LspIdentidiersTlv),end-point,ero,lspa,bandwidth + * objects in PcInitiate message. + */ + @Test + public void initiateMessageTest17() throws PcepParseException { + + //srp,lsp (StatefulIPv4LspIdentidiersTlv),end-point,ero,lspa,bandwidth + byte[] initiateCreationMsg = new byte[]{0x20, 0x0C, 0x00, (byte) 0x58, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x1c, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x04, 0x12, 0x00, 0x0C, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, //Endpoints Object + 0x07, 0x10, 0x00, 0x04, //ERO object + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00}; //Bandwidth object + + byte[] testInitiateCreationMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(initiateCreationMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepInitiateMsg.class)); + + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + + message.writeTo(buf); + testInitiateCreationMsg = buf.array(); + + int iReadLen = buf.writerIndex(); + testInitiateCreationMsg = new byte[iReadLen]; + buf.readBytes(testInitiateCreationMsg, 0, iReadLen); + + assertThat(testInitiateCreationMsg, is(initiateCreationMsg)); + } + + /** + * This test case checks for srp,lsp (StatefulIPv4LspIdentidiersTlv),end-point,ero,lspa,bandwidth,metric-list + * objects in PcInitiate message. + */ + @Test + public void initiateMessageTest18() throws PcepParseException { + //srp,lsp (StatefulIPv4LspIdentidiersTlv),end-point,ero,lspa,bandwidth,metric-list + byte[] initiateCreationMsg = new byte[]{0x20, 0x0C, 0x00, (byte) 0x64, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x1c, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x04, 0x12, 0x00, 0x0C, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, //Endpoints Object + 0x07, 0x10, 0x00, 0x04, //ERO object + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, //Bandwidth object + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20}; //Metric object + + byte[] testInitiateCreationMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(initiateCreationMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepInitiateMsg.class)); + + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + + message.writeTo(buf); + + testInitiateCreationMsg = buf.array(); + + int iReadLen = buf.writerIndex(); + testInitiateCreationMsg = new byte[iReadLen]; + buf.readBytes(testInitiateCreationMsg, 0, iReadLen); + + assertThat(testInitiateCreationMsg, is(initiateCreationMsg)); + } + + /** + * This test case checks for srp,lsp(all tlvs),end-point,ero,lspa,bandwidth,metric-list + * objects in PcInitiate message. + */ + @Test + public void initiateMessageTest19() throws PcepParseException { + //srp,lsp(all tlvs),end-point,ero,lspa,bandwidth,metric-list + byte[] initiateCreationMsg = new byte[]{0x20, 0x0C, 0x00, (byte) 0x74, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x2c, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathTlv + 0x00, 0x14, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, + 0x04, 0x12, 0x00, 0x0C, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, //Endpoints Object + 0x07, 0x10, 0x00, 0x04, //ERO object + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, //Bandwidth object + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20}; //Metric object + + byte[] testInitiateCreationMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(initiateCreationMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepInitiateMsg.class)); + + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + + message.writeTo(buf); + + testInitiateCreationMsg = buf.array(); + + int iReadLen = buf.writerIndex(); + testInitiateCreationMsg = new byte[iReadLen]; + buf.readBytes(testInitiateCreationMsg, 0, iReadLen); + + assertThat(testInitiateCreationMsg, is(initiateCreationMsg)); + } + + /** + * This test case checks for srp,lsp (SymbolicPathNameTlv, StatefulIPv4LspIdentidiersTlv, srp, + * lsp(SymbolicPathNameTlv, StatefulIPv4LspIdentidiersTlv) objects in PcInitiate message. + */ + @Test + public void initiateMessageTest20() throws PcepParseException { + /* srp,lsp (SymbolicPathNameTlv, StatefulIPv4LspIdentidiersTlv, srp, + * lsp(SymbolicPathNameTlv, StatefulIPv4LspIdentidiersTlv). + */ + byte[] initiateDeletionMsg = new byte[]{0x20, 0x0C, 0x00, 0x64, + 0x21, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x20, 0x10, 0x00, 0x1c, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x21, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x20, 0x10, 0x00, 0x1c, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20}; + + byte[] testInitiateDeletionMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(initiateDeletionMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepInitiateMsg.class)); + + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + + message.writeTo(buf); + + testInitiateDeletionMsg = buf.array(); + + int iReadLen = buf.writerIndex(); + testInitiateDeletionMsg = new byte[iReadLen]; + buf.readBytes(testInitiateDeletionMsg, 0, iReadLen); + + assertThat(testInitiateDeletionMsg, is(initiateDeletionMsg)); + } + + /** + * This test case checks for srp,lsp(StatefulIPv4LspIdentidiersTlv),end-point,ero + * objects in PcInitiate message. + */ + @Test + public void initiateMessageTest21() throws PcepParseException { + /*srp,lsp(StatefulIPv4LspIdentidiersTlv),end-point,ero, + * srp,lsp(StatefulIPv4LspIdentidiersTlv),end-point,ero + */ + byte[] initiateCreationMsg = new byte[]{0x20, 0x0C, 0x00, (byte) 0x94, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x1c, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x04, 0x12, 0x00, 0x0C, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, //Endpoints Object + 0x07, 0x10, 0x00, 0x14, //ERO object + 0x01, 0x08, 0x0C, 0x01, 0x01, 0x01, 0x00, 0x00, + 0x01, 0x08, 0x0C, 0x01, 0x01, 0x02, 0x00, 0x00, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x1c, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x04, 0x12, 0x00, 0x0C, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, //Endpoints Object + 0x07, 0x10, 0x00, 0x14, //ERO object + 0x01, 0x08, 0x0C, 0x01, 0x01, 0x01, 0x00, 0x00, + 0x01, 0x08, 0x0C, 0x01, 0x01, 0x02, 0x00, 0x00}; + + byte[] testInitiateCreationMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(initiateCreationMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepInitiateMsg.class)); + + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + + message.writeTo(buf); + + testInitiateCreationMsg = buf.array(); + + int iReadLen = buf.writerIndex(); + testInitiateCreationMsg = new byte[iReadLen]; + buf.readBytes(testInitiateCreationMsg, 0, iReadLen); + + assertThat(testInitiateCreationMsg, is(initiateCreationMsg)); + } + + /** + * This test case checks for srp,lsp(StatefulIPv4LspIdentidiersTlv),end-point,ero,lspa + * objects in PcInitiate message. + */ + @Test + public void initiateMessageTest22() throws PcepParseException { + /*srp,lsp(StatefulIPv4LspIdentidiersTlv),end-point,ero, + * srp,lsp(StatefulIPv4LspIdentidiersTlv),end-point,ero,lspa + */ + byte[] initiateCreationMsg = new byte[]{0x20, 0x0C, 0x00, (byte) 0xA8, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x1c, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x04, 0x12, 0x00, 0x0C, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, //Endpoints Object + 0x07, 0x10, 0x00, 0x14, //ERO object + 0x01, 0x08, 0x0C, 0x01, 0x01, 0x01, 0x00, 0x00, + 0x01, 0x08, 0x0C, 0x01, 0x01, 0x02, 0x00, 0x00, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x1c, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x04, 0x12, 0x00, 0x0C, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, //Endpoints Object + 0x07, 0x10, 0x00, 0x14, //ERO object + 0x01, 0x08, 0x0C, 0x01, 0x01, 0x01, 0x00, 0x00, + 0x01, 0x08, 0x0C, 0x01, 0x01, 0x02, 0x00, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; + + byte[] testInitiateCreationMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(initiateCreationMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepInitiateMsg.class)); + + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + + message.writeTo(buf); + + testInitiateCreationMsg = buf.array(); + + int iReadLen = buf.writerIndex(); + testInitiateCreationMsg = new byte[iReadLen]; + buf.readBytes(testInitiateCreationMsg, 0, iReadLen); + + assertThat(testInitiateCreationMsg, is(initiateCreationMsg)); + } + + /** + * This test case checks for srp,lsp(StatefulIPv4LspIdentidiersTlv),end-point,ero,lspa,bandwidth + * objects in PcInitiate message. + */ + @Test + public void initiateMessageTest23() throws PcepParseException { + /*srp,lsp(StatefulIPv4LspIdentidiersTlv),end-point,ero, + * srp,lsp(StatefulIPv4LspIdentidiersTlv),end-point,ero,lspa,bandwidth + */ + byte[] initiateCreationMsg = new byte[]{0x20, 0x0C, 0x00, (byte) 0xB0, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x1c, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x04, 0x12, 0x00, 0x0C, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, //Endpoints Object + 0x07, 0x10, 0x00, 0x14, //ERO object + 0x01, 0x08, 0x0C, 0x01, 0x01, 0x01, 0x00, 0x00, + 0x01, 0x08, 0x0C, 0x01, 0x01, 0x02, 0x00, 0x00, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x1c, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x04, 0x12, 0x00, 0x0C, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, //Endpoints Object + 0x07, 0x10, 0x00, 0x14, //ERO object + 0x01, 0x08, 0x0C, 0x01, 0x01, 0x01, 0x00, 0x00, + 0x01, 0x08, 0x0C, 0x01, 0x01, 0x02, 0x00, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00}; //Bandwidth object + + byte[] testInitiateCreationMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(initiateCreationMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepInitiateMsg.class)); + + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + + message.writeTo(buf); + + testInitiateCreationMsg = buf.array(); + + int iReadLen = buf.writerIndex(); + testInitiateCreationMsg = new byte[iReadLen]; + buf.readBytes(testInitiateCreationMsg, 0, iReadLen); + + assertThat(testInitiateCreationMsg, is(initiateCreationMsg)); + } + + /** + * This test case checks for srp,lsp(StatefulIPv4LspIdentidiersTlv),end-point,ero,lspa,bandwidth + * objects in PcInitiate message. + */ + @Test + public void initiateMessageTest24() throws PcepParseException { + /*srp,lsp(StatefulIPv4LspIdentidiersTlv),end-point,ero, + * srp,lsp(StatefulIPv4LspIdentidiersTlv),end-point,ero,lspa,bandwidth*/ + byte[] initiateCreationMsg = new byte[]{0x20, 0x0C, 0x00, (byte) 0xBC, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x1c, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x04, 0x12, 0x00, 0x0C, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, //Endpoints Object + 0x07, 0x10, 0x00, 0x14, //ERO object + 0x01, 0x08, 0x0C, 0x01, 0x01, 0x01, 0x00, 0x00, + 0x01, 0x08, 0x0C, 0x01, 0x01, 0x02, 0x00, 0x00, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x1c, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x04, 0x12, 0x00, 0x0C, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, //Endpoints Object + 0x07, 0x10, 0x00, 0x14, //ERO object + 0x01, 0x08, 0x0C, 0x01, 0x01, 0x01, 0x00, 0x00, + 0x01, 0x08, 0x0C, 0x01, 0x01, 0x02, 0x00, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, //Bandwidth object + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20}; //Metric object + + byte[] testInitiateCreationMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(initiateCreationMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepInitiateMsg.class)); + + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + + message.writeTo(buf); + + testInitiateCreationMsg = buf.array(); + + int iReadLen = buf.writerIndex(); + testInitiateCreationMsg = new byte[iReadLen]; + buf.readBytes(testInitiateCreationMsg, 0, iReadLen); + + assertThat(testInitiateCreationMsg, is(initiateCreationMsg)); + } + + /** + * This test case checks for srp,lsp(StatefulIPv4LspIdentidiersTlv),end-point,ero,bandwidth, + * srp,lsp(StatefulIPv4LspIdentidiersTlv), end-point,ero,lspa,bandwidth,metric-list + * objects in PcInitiate message. + */ + @Test + public void initiateMessageTest25() throws PcepParseException { + + /*srp,lsp(StatefulIPv4LspIdentidiersTlv),end-point,ero,bandwidth, + * srp,lsp(StatefulIPv4LspIdentidiersTlv), + * end-point,ero,lspa,bandwidth,metric-list */ + byte[] initiateCreationMsg = new byte[]{0x20, 0x0C, 0x00, (byte) 0xC4, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x1c, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x04, 0x12, 0x00, 0x0C, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, //Endpoints Object + 0x07, 0x10, 0x00, 0x14, //ERO object + 0x01, 0x08, 0x0C, 0x01, 0x01, 0x01, 0x00, 0x00, + 0x01, 0x08, 0x0C, 0x01, 0x01, 0x02, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, //Bandwidth object + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x1c, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x04, 0x12, 0x00, 0x0C, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, //Endpoints Object + 0x07, 0x10, 0x00, 0x14, //ERO object + 0x01, 0x08, 0x0C, 0x01, 0x01, 0x01, 0x00, 0x00, + 0x01, 0x08, 0x0C, 0x01, 0x01, 0x02, 0x00, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, //Bandwidth object + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20}; //Metric object + + byte[] testInitiateCreationMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(initiateCreationMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepInitiateMsg.class)); + + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + + message.writeTo(buf); + + testInitiateCreationMsg = buf.array(); + + int iReadLen = buf.writerIndex(); + testInitiateCreationMsg = new byte[iReadLen]; + buf.readBytes(testInitiateCreationMsg, 0, iReadLen); + + assertThat(testInitiateCreationMsg, is(initiateCreationMsg)); + } + + /** + * This test case checks for srp,lsp(StatefulIPv4LspIdentidiersTlv),end-point,ero,bandwidth,metric-list, + * srp,lsp(StatefulIPv4LspIdentidiersTlv), end-point,ero,lspa,bandwidth,metric-list + * objects in PcInitiate message. + */ + @Test + public void initiateMessageTest26() throws PcepParseException { + + /*srp,lsp(StatefulIPv4LspIdentidiersTlv),end-point,ero,bandwidth,metric-list, + * srp,lsp(StatefulIPv4LspIdentidiersTlv), + * end-point,ero,lspa,bandwidth,metric-list */ + byte[] initiateCreationMsg = new byte[]{0x20, 0x0C, 0x00, (byte) 0xD0, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x1c, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x04, 0x12, 0x00, 0x0C, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, //Endpoints Object + 0x07, 0x10, 0x00, 0x14, //ERO object + 0x01, 0x08, 0x0C, 0x01, 0x01, 0x01, 0x00, 0x00, + 0x01, 0x08, 0x0C, 0x01, 0x01, 0x02, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, //Bandwidth object + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20, //Metric object + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x1c, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x04, 0x12, 0x00, 0x0C, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, //Endpoints Object + 0x07, 0x10, 0x00, 0x14, //ERO object + 0x01, 0x08, 0x0C, 0x01, 0x01, 0x01, 0x00, 0x00, + 0x01, 0x08, 0x0C, 0x01, 0x01, 0x02, 0x00, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, //Bandwidth object + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20}; //Metric object + + byte[] testInitiateCreationMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(initiateCreationMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepInitiateMsg.class)); + + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + + message.writeTo(buf); + + testInitiateCreationMsg = buf.array(); + + int iReadLen = buf.writerIndex(); + testInitiateCreationMsg = new byte[iReadLen]; + buf.readBytes(testInitiateCreationMsg, 0, iReadLen); + + assertThat(testInitiateCreationMsg, is(initiateCreationMsg)); + } + + /** + * This test case checks for srp,lsp(StatefulIPv4LspIdentidiersTlv),end-point,ero,lspa,bandwidth,metric-list, + * srp,lsp(StatefulIPv4LspIdentidiersTlv), end-point,ero,lspa,bandwidth,metric-list + * objects in PcInitiate message. + */ + @Test + public void initiateMessageTest27() throws PcepParseException { + + /*srp,lsp(StatefulIPv4LspIdentidiersTlv),end-point,ero,lspa,bandwidth,metric-list, + * srp,lsp(StatefulIPv4LspIdentidiersTlv), + * end-point,ero,lspa,bandwidth,metric-list */ + byte[] initiateCreationMsg = new byte[]{0x20, 0x0C, 0x00, (byte) 0xE4, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x1c, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x04, 0x12, 0x00, 0x0C, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, //Endpoints Object + 0x07, 0x10, 0x00, 0x14, //ERO object + 0x01, 0x08, 0x0C, 0x01, 0x01, 0x01, 0x00, 0x00, + 0x01, 0x08, 0x0C, 0x01, 0x01, 0x02, 0x00, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, //Bandwidth object + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20, //Metric object + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x1c, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x04, 0x12, 0x00, 0x0C, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, //Endpoints Object + 0x07, 0x10, 0x00, 0x14, //ERO object + 0x01, 0x08, 0x0C, 0x01, 0x01, 0x01, 0x00, 0x00, + 0x01, 0x08, 0x0C, 0x01, 0x01, 0x02, 0x00, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, //Bandwidth object + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20}; //Metric object + + byte[] testInitiateCreationMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(initiateCreationMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepInitiateMsg.class)); + + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + + message.writeTo(buf); + + testInitiateCreationMsg = buf.array(); + + int iReadLen = buf.writerIndex(); + testInitiateCreationMsg = new byte[iReadLen]; + buf.readBytes(testInitiateCreationMsg, 0, iReadLen); + + assertThat(testInitiateCreationMsg, is(initiateCreationMsg)); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/protocol/PcepKeepaliveMsgTest.java b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/protocol/PcepKeepaliveMsgTest.java new file mode 100644 index 00000000..56cf06b4 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/protocol/PcepKeepaliveMsgTest.java @@ -0,0 +1,59 @@ +/* + * Copyright 2014-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; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.jboss.netty.buffer.ChannelBuffers; +import org.junit.Assert; +import org.junit.Test; +import org.onosproject.pcepio.exceptions.PcepParseException; + +import static org.hamcrest.MatcherAssert.assertThat; +import static org.hamcrest.Matchers.instanceOf; +import static org.hamcrest.core.Is.is; + +public class PcepKeepaliveMsgTest { + + /** + * Common header for keep alive message. + */ + @Test + public void keepaliveMessageTest1() throws PcepParseException { + + byte[] keepaliveMsg = new byte[] {0x20, 0x02, 0x00, 0x04 }; + + byte[] testKeepaliveMsg = {0 }; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(keepaliveMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + assertThat(message, instanceOf(PcepKeepaliveMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + + message.writeTo(buf); + + testKeepaliveMsg = buf.array(); + + int iReadLen = buf.writerIndex(); + testKeepaliveMsg = new byte[iReadLen]; + buf.readBytes(testKeepaliveMsg, 0, iReadLen); + + Assert.assertThat(testKeepaliveMsg, is(keepaliveMsg)); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/protocol/PcepLabelUpdateMsgTest.java b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/protocol/PcepLabelUpdateMsgTest.java new file mode 100644 index 00000000..e1947bd7 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/protocol/PcepLabelUpdateMsgTest.java @@ -0,0 +1,402 @@ +/* + * Copyright 2014-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; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.jboss.netty.buffer.ChannelBuffers; +import org.junit.Test; +import org.onosproject.pcepio.exceptions.PcepParseException; + +import static org.hamcrest.MatcherAssert.assertThat; +import static org.hamcrest.Matchers.instanceOf; +import static org.hamcrest.Matchers.is; + +public class PcepLabelUpdateMsgTest { + + /** + * This test case checks for + * <pce-label-download> SRP, LSP, LABEL Object. + * in PcepLabelUpdate message. + */ + @Test + public void labelUpdateMessageTest1() throws PcepParseException { + + byte[] labelUpdate = new byte[]{0x20, 0x0D, 0x00, 0x24, // common header + 0x21, 0x10, 0x00, 0x0C, // SRP Object Header + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x10, + 0x20, 0x10, 0x00, 0x08, // LSP Object Header + 0x00, 0x01, 0x00, 0x00, + 0x23, 0x10, 0x00, 0x0C, // LABEL Object Header + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x66}; + + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(labelUpdate); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + byte[] testLabelUpdateMsg = {0}; + assertThat(message, instanceOf(PcepLabelUpdateMsg.class)); + + + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testLabelUpdateMsg = new byte[readLen]; + buf.readBytes(testLabelUpdateMsg, 0, readLen); + + assertThat(testLabelUpdateMsg, is(labelUpdate)); + } + + /** + * This test case checks for + * <pce-label-download> SRP, LSP, LABEL Object, LABEL Object. + * in PcepLabelUpdate message. + */ + @Test + public void labelUpdateMessageTest2() throws PcepParseException { + + byte[] labelUpdate = new byte[]{0x20, 0x0D, 0x00, 0x30, // common header + 0x21, 0x10, 0x00, 0x0C, // SRP Object Header + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x10, + 0x20, 0x10, 0x00, 0x08, // LSP Object Header + 0x00, 0x01, 0x00, 0x00, + 0x23, 0x10, 0x00, 0x0C, // LABEL Object Header + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x66, + 0x23, 0x10, 0x00, 0x0C, // LABEL Object Header + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x77}; + + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(labelUpdate); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + byte[] testLabelUpdateMsg = {0}; + assertThat(message, instanceOf(PcepLabelUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testLabelUpdateMsg = new byte[readLen]; + buf.readBytes(testLabelUpdateMsg, 0, readLen); + + assertThat(testLabelUpdateMsg, is(labelUpdate)); + } + + /** + * This test case checks for + * <pce-label-map> SRP, LABEL, FEC Object. + * in PcepLabelUpdate message. + */ + @Test + public void labelUpdateMessageTest3() throws PcepParseException { + + byte[] labelUpdate = new byte[]{0x20, 0x0D, 0x00, 0x24, // common header + 0x21, 0x10, 0x00, 0x0C, // SRP Object Header + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x10, + 0x23, 0x10, 0x00, 0x0C, // LABEL Object Header + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x66, + 0x24, 0x10, 0x00, 0x08, // FEC Object Header + 0x0A, 0x0A, 0x0B, 0x0B}; + + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(labelUpdate); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + byte[] testLabelUpdateMsg = {0}; + assertThat(message, instanceOf(PcepLabelUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testLabelUpdateMsg = new byte[readLen]; + buf.readBytes(testLabelUpdateMsg, 0, readLen); + + assertThat(testLabelUpdateMsg, is(labelUpdate)); + } + + /** + * This test case checks for + * <pce-label-download> SRP, LSP, LABEL, LABEL, <pce-label-download> SRP, LSP, LABEL + * in PcepLabelUpdate message. + */ + @Test + public void labelUpdateMessageTest4() throws PcepParseException { + + byte[] labelUpdate = new byte[]{0x20, 0x0D, 0x00, 0x50, // common header + 0x21, 0x10, 0x00, 0x0C, // SRP Object Header + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x10, + 0x20, 0x10, 0x00, 0x08, // LSP Object Header + 0x00, 0x01, 0x00, 0x00, + 0x23, 0x10, 0x00, 0x0C, // LABEL Object Header + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x66, + 0x23, 0x10, 0x00, 0x0C, // LABEL Object Header + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x77, + 0x21, 0x10, 0x00, 0x0C, // SRP Object Header + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x11, + 0x20, 0x10, 0x00, 0x08, // LSP Object Header + 0x00, 0x02, 0x00, 0x00, + 0x23, 0x10, 0x00, 0x0C, // LABEL Object Header + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x44}; + + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(labelUpdate); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + byte[] testLabelUpdateMsg = {0}; + assertThat(message, instanceOf(PcepLabelUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testLabelUpdateMsg = new byte[readLen]; + buf.readBytes(testLabelUpdateMsg, 0, readLen); + + assertThat(testLabelUpdateMsg, is(labelUpdate)); + } + + /** + * This test case checks for + * <pce-label-map> SRP, LABEL, FEC, <pce-label-map> SRP, LABEL, FEC. + * in PcepLabelUpdate message. + */ + @Test + public void labelUpdateMessageTest5() throws PcepParseException { + + byte[] labelUpdate = new byte[]{0x20, 0x0D, 0x00, 0x44, // common header + 0x21, 0x10, 0x00, 0x0C, // SRP Object Header + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x10, + 0x23, 0x10, 0x00, 0x0C, // LABEL Object Header + 0x00, 0x00, 0x00, 0x01, + 0x00, 0x00, 0x00, 0x66, + 0x24, 0x10, 0x00, 0x08, // FEC Object Header + 0x0A, 0x0A, 0x0B, 0x0B, + 0x21, 0x10, 0x00, 0x0C, // SRP Object Header + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x11, + 0x23, 0x10, 0x00, 0x0C, // LABEL Object Header + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x66, + 0x24, 0x10, 0x00, 0x08, // FEC Object Header + 0x0A, 0x0A, 0x0C, 0x0C}; + + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(labelUpdate); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + byte[] testLabelUpdateMsg = {0}; + assertThat(message, instanceOf(PcepLabelUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testLabelUpdateMsg = new byte[readLen]; + buf.readBytes(testLabelUpdateMsg, 0, readLen); + + assertThat(testLabelUpdateMsg, is(labelUpdate)); + } + + /** + * This test case checks for + * <pce-label-download> SRP, LSP, LABEL, LABEL, <pce-label-download> SRP, LABEL, FEC. + * in PcepLabelUpdate message. + */ + @Test + public void labelUpdateMessageTest6() throws PcepParseException { + + byte[] labelUpdate = new byte[]{0x20, 0x0D, 0x00, 0x50, // common header + 0x21, 0x10, 0x00, 0x0C, // SRP Object Header + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x10, + 0x20, 0x10, 0x00, 0x08, // LSP Object Header + 0x00, 0x01, 0x00, 0x00, + 0x23, 0x10, 0x00, 0x0C, // LABEL Object Header + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x66, + 0x23, 0x10, 0x00, 0x0C, // LABEL Object Header + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x77, + 0x21, 0x10, 0x00, 0x0C, // SRP Object Header + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x12, + 0x23, 0x10, 0x00, 0x0C, // LABEL Object Header + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x66, + 0x24, 0x10, 0x00, 0x08, // FEC Object Header + 0x0A, 0x0A, 0x0D, 0x0D}; + + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(labelUpdate); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + byte[] testLabelUpdateMsg = {0}; + assertThat(message, instanceOf(PcepLabelUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testLabelUpdateMsg = new byte[readLen]; + buf.readBytes(testLabelUpdateMsg, 0, readLen); + + assertThat(testLabelUpdateMsg, is(labelUpdate)); + } + + /** + * This test case checks for + * <pce-label-download> SRP, LABEL, FEC, <pce-label-download> SRP, LSP, LABEL, LABEL. + * in PcepLabelUpdate message. + */ + @Test + public void labelUpdateMessageTest7() throws PcepParseException { + + byte[] labelUpdate = new byte[]{0x20, 0x0D, 0x00, 0x50, // common header + 0x21, 0x10, 0x00, 0x0C, // SRP Object Header + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x12, + 0x23, 0x10, 0x00, 0x0C, // LABEL Object Header + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x66, + 0x24, 0x10, 0x00, 0x08, // FEC Object Header + 0x0A, 0x0A, 0x0D, 0x0D, + 0x21, 0x10, 0x00, 0x0C, // SRP Object Header + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x10, + 0x20, 0x10, 0x00, 0x08, // LSP Object Header + 0x00, 0x01, 0x00, 0x00, + 0x23, 0x10, 0x00, 0x0C, // LABEL Object Header + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x66, + 0x23, 0x10, 0x00, 0x0C, // LABEL Object Header + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x77}; + + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(labelUpdate); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + byte[] testLabelUpdateMsg = {0}; + assertThat(message, instanceOf(PcepLabelUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testLabelUpdateMsg = new byte[readLen]; + buf.readBytes(testLabelUpdateMsg, 0, readLen); + + assertThat(testLabelUpdateMsg, is(labelUpdate)); + } + + /** + * This test case checks for + * <pce-label-download> SRP, LABEL, FEC, <pce-label-download> SRP, LSP, LABEL, LABEL. + * <pce-label-download> SRP, LSP, LABEL, LABEL. + * in PcepLabelUpdate message. + */ + @Test + public void labelUpdateMessageTest8() throws PcepParseException { + + byte[] labelUpdate = new byte[]{0x20, 0x0D, 0x00, 0x7C, // common header + 0x21, 0x10, 0x00, 0x0C, // SRP Object Header + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x12, + 0x23, 0x10, 0x00, 0x0C, // LABEL Object Header + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x66, + 0x24, 0x10, 0x00, 0x08, // FEC Object Header + 0x0A, 0x0A, 0x0D, 0x0D, + 0x21, 0x10, 0x00, 0x0C, // SRP Object Header + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x10, + 0x20, 0x10, 0x00, 0x08, // LSP Object Header + 0x00, 0x01, 0x00, 0x00, + 0x23, 0x10, 0x00, 0x0C, // LABEL Object Header + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x66, + 0x23, 0x10, 0x00, 0x0C, // LABEL Object Header + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x77, + 0x21, 0x10, 0x00, 0x0C, // SRP Object Header + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x10, + 0x20, 0x10, 0x00, 0x08, // LSP Object Header + 0x00, 0x01, 0x00, 0x00, + 0x23, 0x10, 0x00, 0x0C, // LABEL Object Header + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x66, + 0x23, 0x10, 0x00, 0x0C, // LABEL Object Header + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x77}; + + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(labelUpdate); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + byte[] testLabelUpdateMsg = {0}; + + assertThat(message, instanceOf(PcepLabelUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testLabelUpdateMsg = new byte[readLen]; + buf.readBytes(testLabelUpdateMsg, 0, readLen); + + assertThat(testLabelUpdateMsg, is(labelUpdate)); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/protocol/PcepOpenMsgTest.java b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/protocol/PcepOpenMsgTest.java new file mode 100644 index 00000000..6e0a0596 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/protocol/PcepOpenMsgTest.java @@ -0,0 +1,558 @@ +/* + * Copyright 2014-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; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.jboss.netty.buffer.ChannelBuffers; +import org.junit.Test; +import org.onosproject.pcepio.exceptions.PcepParseException; + +import static org.hamcrest.MatcherAssert.assertThat; +import static org.hamcrest.Matchers.instanceOf; +import static org.hamcrest.core.Is.is; +/** + * Test cases for PCEP OPEN Message. + */ +public class PcepOpenMsgTest { + + /** + * This test case checks open object with STATEFUL-PCE-CAPABILITY, GMPLS-CAPABILITY-TLV, + * PCECC-CAPABILITY-TLV in Pcep Open message. + */ + @Test + public void openMessageTest1() throws PcepParseException { + + byte[] openMsg = new byte[] {0x20, 0x01, 0x00, 0x24, 0x01, 0x10, 0x00, 0x20, 0x20, 0x1e, 0x78, (byte) 0xbd, + 0x00, 0x10, 0x00, 0x04, 0x00, 0x00, 0x00, 0x0f, //STATEFUL-PCE-CAPABILITY + 0x00, 0x0e, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, //GMPLS-CAPABILITY-TLV + 0x00, 0x20, 0x00, 0x04, 0x00, 0x00, 0x00, 0x07, //PCECC-CAPABILITY-TLV + }; + + byte[] testOpenMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(openMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepOpenMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testOpenMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testOpenMsg = new byte[readLen]; + buf.readBytes(testOpenMsg, 0, readLen); + + assertThat(testOpenMsg, is(openMsg)); + + } + + /** + * This test case checks open object with STATEFUL-PCE-CAPABILITY-TLV in Pcep Open message. + */ + @Test + public void openMessageTest2() throws PcepParseException { + + byte[] openMsg = new byte[] {0x20, 0x01, 0x00, 0x14, // common header + 0x01, 0x10, 0x00, 0x10, // common object header + 0x20, 0x1E, 0x78, 0x01, // OPEN object + 0x00, 0x10, 0x00, 0x04, 0x00, 0x00, 0x00, 0x0f}; // STATEFUL-PCE-CAPABILITY + byte[] testOpenMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(openMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepOpenMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testOpenMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testOpenMsg = new byte[readLen]; + buf.readBytes(testOpenMsg, 0, readLen); + + assertThat(testOpenMsg, is(openMsg)); + + } + + /** + * This test case checks open object with GmplsCapability tlv in Pcep Open message. + */ + @Test + public void openMessageTest3() throws PcepParseException { + + byte[] openMsg = new byte[] {0x20, 0x01, 0x00, 0x14, // common header + 0x01, 0x10, 0x00, 0x10, // common object header + 0x20, 0x1E, 0x78, 0x01, // OPEN object + 0x00, 0x0e, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00}; //GMPLS-CAPABILITY-TLV + + byte[] testOpenMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(openMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepOpenMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testOpenMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testOpenMsg = new byte[readLen]; + buf.readBytes(testOpenMsg, 0, readLen); + + + assertThat(testOpenMsg, is(openMsg)); + + } + + /** + * This test case checks open object with StatefulLspDbVer Tlv in Pcep Open message. + */ + @Test + public void openMessageTest4() throws PcepParseException { + + byte[] openMsg = new byte[] {0x20, 0x01, 0x00, 0x18, + 0x01, 0x10, 0x00, 0x14, 0x20, 0x1e, 0x78, 0x20, + 0x00, 0x17, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02 }; //StatefulLspDbVerTlv + + byte[] testOpenMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(openMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepOpenMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testOpenMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testOpenMsg = new byte[readLen]; + buf.readBytes(testOpenMsg, 0, readLen); + + assertThat(testOpenMsg, is(openMsg)); + + } + + /** + * This test case checks open object with no tlv's in Pcep Open message. + */ + @Test + public void openMessageTest5() throws PcepParseException { + + byte[] openMsg = new byte[] {0x20, 0x01, 0x00, 0x0C, + 0x01, 0x10, 0x00, 0x08, 0x20, 0x1e, 0x78, (byte) 0xbd }; // no Tlvs in open messsage + + byte[] testOpenMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(openMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepOpenMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testOpenMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testOpenMsg = new byte[readLen]; + buf.readBytes(testOpenMsg, 0, readLen); + + assertThat(testOpenMsg, is(openMsg)); + + } + + /** + * This test case checks open object with STATEFUL-PCE-CAPABILITY, GMPLS-CAPABILITY-TLV, PCECC-CAPABILITY-TLV + * with I bit set in Pcep Open message. + */ + @Test + public void openMessageTest6() throws PcepParseException { + + byte[] openMsg = new byte[] {0x20, 0x01, 0x00, 0x24, 0x01, 0x11, 0x00, 0x20, //p bit not set & i bit set + 0x20, 0x1e, 0x78, (byte) 0xbd, + 0x00, 0x10, 0x00, 0x04, 0x00, 0x00, 0x00, 0x0f, // STATEFUL-PCE-CAPABILITY + 0x00, 0x0e, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, //GMPLS-CAPABILITY-TLV + 0x00, 0x20, 0x00, 0x04, 0x00, 0x00, 0x00, 0x07, //PCECC-CAPABILITY-TLV + }; + + byte[] testOpenMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(openMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepOpenMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testOpenMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testOpenMsg = new byte[readLen]; + buf.readBytes(testOpenMsg, 0, readLen); + + assertThat(testOpenMsg, is(openMsg)); + + } + + /** + * This test case checks open object with STATEFUL-PCE-CAPABILITY, GMPLS-CAPABILITY-TLV, PCECC-CAPABILITY-TLV + * with P bit set in Pcep Open message. + */ + @Test + public void openMessageTest7() throws PcepParseException { + + byte[] openMsg = new byte[] {0x20, 0x01, 0x00, 0x24, 0x01, 0x12, 0x00, 0x20, //p bit set & i bit not set + 0x20, 0x1e, 0x78, (byte) 0xbd, + 0x00, 0x10, 0x00, 0x04, 0x00, 0x00, 0x00, 0x0f, //STATEFUL-PCE-CAPABILITY + 0x00, 0x0e, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, //GMPLS-CAPABILITY-TLV + 0x00, 0x20, 0x00, 0x04, 0x00, 0x00, 0x00, 0x07, //PCECC-CAPABILITY-TLV + }; + + byte[] testOpenMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(openMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepOpenMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testOpenMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testOpenMsg = new byte[readLen]; + buf.readBytes(testOpenMsg, 0, readLen); + + assertThat(testOpenMsg, is(openMsg)); + + } + + /** + * This test case checks open object with STATEFUL-PCE-CAPABILITY, GMPLS-CAPABILITY-TLV, PCECC-CAPABILITY-TLV + * with P & I bits set in Pcep Open message. + */ + @Test + public void openMessageTest8() throws PcepParseException { + + /* OPEN OBJECT (STATEFUL-PCE-CAPABILITY, GMPLS-CAPABILITY-TLV, PCECC-CAPABILITY-TLV) + with p bit set & i bit set. + */ + byte[] openMsg = new byte[] {0x20, 0x01, 0x00, 0x24, 0x01, 0x13, 0x00, 0x20, //p bit set & i bit set + 0x20, 0x1e, 0x78, (byte) 0xbd, + 0x00, 0x10, 0x00, 0x04, 0x00, 0x00, 0x00, 0x0f, //STATEFUL-PCE-CAPABILITY + 0x00, 0x0e, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, //GMPLS-CAPABILITY-TLV + 0x00, 0x20, 0x00, 0x04, 0x00, 0x00, 0x00, 0x07, //PCECC-CAPABILITY-TLV + }; + + byte[] testOpenMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(openMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepOpenMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testOpenMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testOpenMsg = new byte[readLen]; + buf.readBytes(testOpenMsg, 0, readLen); + + assertThat(testOpenMsg, is(openMsg)); + + } + + /** + * This test case checks open object with STATEFUL-PCE-CAPABILITY, GMPLS-CAPABILITY-TLV, PCECC-CAPABILITY-TLV + * with P & I bits set and invalid session id in Pcep Open message. + */ + @Test + public void openMessageTest9() throws PcepParseException { + + byte[] openMsg = new byte[] {0x20, 0x01, 0x00, 0x24, 0x01, 0x13, 0x00, 0x20, //p bit set & i bit set + 0x20, 0x1e, 0x78, 0x00, //invalid sessionID + 0x00, 0x10, 0x00, 0x04, 0x00, 0x00, 0x00, 0x0f, //STATEFUL-PCE-CAPABILITY + 0x00, 0x0e, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, //GMPLS-CAPABILITY-TLV + 0x00, 0x20, 0x00, 0x04, 0x00, 0x00, 0x00, 0x07, //PCECC-CAPABILITY-TLV + }; + + byte[] testOpenMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(openMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepOpenMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testOpenMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testOpenMsg = new byte[readLen]; + buf.readBytes(testOpenMsg, 0, readLen); + + + assertThat(testOpenMsg, is(openMsg)); + + } + + /** + * This test case checks open object with STATEFUL-PCE-CAPABILITY, GMPLS-CAPABILITY-TLV + * in Pcep Open message. + */ + @Test + public void openMessageTest10() throws PcepParseException { + + byte[] openMsg = new byte[] {0x20, 0x01, 0x00, 0x1C, // common header + 0x01, 0x10, 0x00, 0x18, // common object header + 0x20, 0x05, 0x1E, 0x01, // OPEN object + 0x00, 0x10, 0x00, 0x04, // STATEFUL-PCE-CAPABILITY + 0x00, 0x00, 0x00, 0x05, + 0x00, 0x0E, 0x00, 0x04, // GMPLS-CAPABILITY-TLV + 0x00, 0x00, 0x00, 0x00}; + + byte[] testOpenMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(openMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepOpenMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testOpenMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testOpenMsg = new byte[readLen]; + buf.readBytes(testOpenMsg, 0, readLen); + + assertThat(testOpenMsg, is(openMsg)); + + } + + /** + * This test case checks open object with STATEFUL-PCE-CAPABILITY, GMPLS-CAPABILITY-TLV, + * PCECC-CAPABILITY-TLV, TED Capability TLV in Pcep Open message. + */ + @Test + public void openMessageTest11() throws PcepParseException { + + byte[] openMsg = new byte[] {0x20, 0x01, 0x00, 0x2C, // common header + 0x01, 0x10, 0x00, 0x28, // common object header + 0x20, 0x05, 0x1E, 0x01, // OPEN object + 0x00, 0x10, 0x00, 0x04, // STATEFUL-PCE-CAPABILITY + 0x00, 0x00, 0x00, 0x05, 0x00, 0x0E, 0x00, 0x04, // GMPLS-CAPABILITY-TLV + 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, // PCECC-CAPABILITY-TLV + 0x00, 0x00, 0x00, 0x03, 0x00, (byte) 0x84, 0x00, 0x04, // TED Capability TLV + 0x00, 0x00, 0x00, 0x00 }; + + byte[] testOpenMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(openMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepOpenMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testOpenMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testOpenMsg = new byte[readLen]; + buf.readBytes(testOpenMsg, 0, readLen); + + assertThat(testOpenMsg, is(openMsg)); + + } + + /** + * This test case checks open object with STATEFUL-PCE-CAPABILITY, GMPLS-CAPABILITY-TLV, + * PCECC-CAPABILITY-TLV in Pcep Open message. + */ + @Test + public void openMessageTest12() throws PcepParseException { + + byte[] openMsg = new byte[] {0x20, 0x01, 0x00, 0x24, // common header + 0x01, 0x10, 0x00, 0x20, // common object header + 0x20, 0x05, 0x1E, 0x01, // OPEN object + 0x00, 0x10, 0x00, 0x04, // STATEFUL-PCE-CAPABILITY + 0x00, 0x00, 0x00, 0x05, 0x00, 0x0E, 0x00, 0x04, // GMPLS-CAPABILITY-TLV + 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, // PCECC-CAPABILITY-TLV + 0x00, 0x00, 0x00, 0x03}; + + byte[] testOpenMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(openMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepOpenMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testOpenMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testOpenMsg = new byte[readLen]; + buf.readBytes(testOpenMsg, 0, readLen); + + assertThat(testOpenMsg, is(openMsg)); + + } + + /** + * This test case checks open object with STATEFUL-PCE-CAPABILITY, GMPLS-CAPABILITY-TLV + * in Pcep Open message. + */ + @Test + public void openMessageTest13() throws PcepParseException { + + byte[] openMsg = new byte[] {0x20, 0x01, 0x00, 0x1c, // common header + 0x01, 0x10, 0x00, 0x18, // common object header + 0x20, 0x05, 0x1E, 0x01, // OPEN object + 0x00, 0x10, 0x00, 0x04, // STATEFUL-PCE-CAPABILITY + 0x00, 0x00, 0x00, 0x05, 0x00, 0x0E, 0x00, 0x04, // GMPLS-CAPABILITY-TLV + 0x00, 0x00, 0x00, 0x00}; + + byte[] testOpenMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(openMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepOpenMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testOpenMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testOpenMsg = new byte[readLen]; + buf.readBytes(testOpenMsg, 0, readLen); + + + assertThat(testOpenMsg, is(openMsg)); + + } + + /** + * This test case checks open object with STATEFUL-PCE-CAPABILITY in Pcep Open message. + */ + @Test + public void openMessageTest14() throws PcepParseException { + + byte[] openMsg = new byte[] {0x20, 0x01, 0x00, 0x14, // common header + 0x01, 0x10, 0x00, 0x10, // common object header + 0x20, 0x05, 0x1E, 0x01, // OPEN object + 0x00, 0x10, 0x00, 0x04, // STATEFUL-PCE-CAPABILITY + 0x00, 0x00, 0x00, 0x05}; + + byte[] testOpenMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(openMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepOpenMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testOpenMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testOpenMsg = new byte[readLen]; + buf.readBytes(testOpenMsg, 0, readLen); + + assertThat(testOpenMsg, is(openMsg)); + + } + + /** + * This test case checks open object with no tlv Pcep Open message. + */ + @Test + public void openMessageTest15() throws PcepParseException { + + byte[] openMsg = new byte[] {0x20, 0x01, 0x00, 0x0c, // common header + 0x01, 0x10, 0x00, 0x08, // common object header + 0x20, 0x05, 0x1E, 0x01 // OPEN object + }; + + byte[] testOpenMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(openMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepOpenMsg.class)); + + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testOpenMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testOpenMsg = new byte[readLen]; + buf.readBytes(testOpenMsg, 0, readLen); + assertThat(testOpenMsg, is(openMsg)); + + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/protocol/PcepReportMsgExtTest.java b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/protocol/PcepReportMsgExtTest.java new file mode 100644 index 00000000..f9921efd --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/protocol/PcepReportMsgExtTest.java @@ -0,0 +1,218 @@ +/* + * Copyright 2014-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; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.jboss.netty.buffer.ChannelBuffers; +import org.junit.Test; +import org.onosproject.pcepio.exceptions.PcepParseException; + +import static org.hamcrest.MatcherAssert.assertThat; +import static org.hamcrest.Matchers.instanceOf; +import static org.hamcrest.core.Is.is; + +public class PcepReportMsgExtTest { + + /** + * This test case checks forSRP Object,LSP Object(symbolic path tlv),ERO Object + * SRP Object,LSP Object(symbolic path tlv,ERO Object,LSPA Object,BandWidth Object,Metric-list,RRO Object + * in PcRpt message. + */ + @Test + public void reportMessageTest39() throws PcepParseException { + + byte[] reportMsg = new byte[] {0x20, 0x0a, 0x00, (byte) 0x98, + 0x21, 0x10, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, //SRP object + 0x20, 0x10, 0x00, 0x10, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //symbolic path tlv + 0x07, 0x10, 0x00, 0x14, //ERO Object + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x04, 0x00, + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x20, 0x04, 0x00, + 0x21, 0x10, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, //SRP object + 0x20, 0x10, 0x00, 0x10, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //symbolic path tlv + 0x07, 0x10, 0x00, 0x14, //ERO object + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x04, 0x00, + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x20, 0x04, 0x00, + 0x08, 0x10, 0x00, 0x34, 0x01, 0x08, 0x11, 0x01, //RRO object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x02, 0x04, 0x00, 0x01, 0x08, 0x06, 0x06, + 0x06, 0x06, 0x04, 0x00, 0x01, 0x08, 0x12, 0x01, + 0x01, 0x02, 0x04, 0x00, 0x01, 0x08, 0x12, 0x01, + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x05, 0x05, 0x05, 0x05, 0x04, 0x00}; + + byte[] testReportMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(reportMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + assertThat(message, instanceOf(PcepReportMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testReportMsg = new byte[readLen]; + buf.readBytes(testReportMsg, 0, readLen); + + assertThat(testReportMsg, is(reportMsg)); + } + + /** + * This test case checks for SRP Object,LSP Object(symbolic path tlv),ERO Object + * SRP Object,LSP Object(symbolic path tlv),ERO Object + * in PcRpt message. + */ + @Test + public void reportMessageTest40() throws PcepParseException { + + byte[] reportMsg = new byte[] {0x20, 0x0a, 0x00, (byte) 0x64, + 0x21, 0x10, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, //SRP object + 0x20, 0x10, 0x00, 0x10, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //symbolic path tlv + 0x07, 0x10, 0x00, 0x14, //ERO object + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x04, 0x00, + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x20, 0x04, 0x00, + 0x21, 0x10, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, //SRP object + 0x20, 0x10, 0x00, 0x10, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //symbolic path tlv + 0x07, 0x10, 0x00, 0x14, //ERO object + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x04, 0x00, + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x20, 0x04, 0x00}; + + byte[] testReportMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(reportMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + assertThat(message, instanceOf(PcepReportMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testReportMsg = new byte[readLen]; + buf.readBytes(testReportMsg, 0, readLen); + + assertThat(testReportMsg, is(reportMsg)); + } + + /** + * This test case checks for SRP Object,LSP Object(symbolic path tlv),ERO Object,LSPA Object + * SRP Object,LSP Object(symbolic path tlv),ERO Object,LSPA Object + * in PcRpt message. + */ + @Test + public void reportMessageTest41() throws PcepParseException { + + byte[] reportMsg = new byte[] {0x20, 0x0a, 0x00, (byte) 0x8c, + 0x21, 0x10, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, //SRP object + 0x20, 0x10, 0x00, 0x10, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //symbolic path tlv + 0x07, 0x10, 0x00, 0x14, //ERO object + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x04, 0x00, + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x20, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x21, 0x10, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, //SRP object + 0x20, 0x10, 0x00, 0x10, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //symbolic path tlv + 0x07, 0x10, 0x00, 0x14, //ERO object + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x04, 0x00, + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x20, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; + + byte[] testReportMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(reportMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + assertThat(message, instanceOf(PcepReportMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testReportMsg = new byte[readLen]; + buf.readBytes(testReportMsg, 0, readLen); + + assertThat(testReportMsg, is(reportMsg)); + } + + /** + * This test case checks for SRP Object,LSP Object(symbolic path tlv),ERO Object,LSPA Object,BandWidth Object, + * Metric-list SRP Object,LSP Object(symbolic path tlv),ERO Object,LSPA Object,BandWidth Object,Metric-list, + * RRO Object + * in PcRpt message. + */ + @Test + public void reportMessageTest42() throws PcepParseException { + + byte[] reportMsg = new byte[] {0x20, 0x0a, 0x00, (byte) 0xE8, + 0x21, 0x10, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, //SRP object + 0x20, 0x10, 0x00, 0x10, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //symbolic path tlv + 0x07, 0x10, 0x00, 0x14, //ERO object + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x04, 0x00, + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x20, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, //Bandwidth object + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20, //Metric object + 0x21, 0x10, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, //SRP object + 0x20, 0x10, 0x00, 0x10, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //symbolic path tlv + 0x07, 0x10, 0x00, 0x14, //ERO object + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x04, 0x00, + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x20, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, //Bandwidth object + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20, //Metric object + 0x08, 0x10, 0x00, 0x34, 0x01, 0x08, 0x11, 0x01, //RRO object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x02, 0x04, 0x00, 0x01, 0x08, 0x06, 0x06, + 0x06, 0x06, 0x04, 0x00, 0x01, 0x08, 0x12, 0x01, + 0x01, 0x02, 0x04, 0x00, 0x01, 0x08, 0x12, 0x01, + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x05, 0x05, 0x05, 0x05, 0x04, 0x00}; + + byte[] testReportMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(reportMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepReportMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testReportMsg = new byte[readLen]; + buf.readBytes(testReportMsg, 0, readLen); + + assertThat(testReportMsg, is(reportMsg)); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/protocol/PcepReportMsgTest.java b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/protocol/PcepReportMsgTest.java new file mode 100644 index 00000000..c9e2bc8b --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/protocol/PcepReportMsgTest.java @@ -0,0 +1,1597 @@ +/* + * Copyright 2014-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; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.jboss.netty.buffer.ChannelBuffers; +import org.junit.Test; +import org.onosproject.pcepio.exceptions.PcepParseException; + +import static org.hamcrest.MatcherAssert.assertThat; +import static org.hamcrest.Matchers.instanceOf; +import static org.hamcrest.core.Is.is; + +public class PcepReportMsgTest { + + /** + * This test case checks for SRP object, LSP object(Symbolic path name tlv), ERO object + * in PcRpt message. + */ + @Test + public void reportMessageTest1() throws PcepParseException { + + byte[] reportMsg = new byte[]{0x20, 0x0a, 0x00, 0x24, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, //SRP Object + 0x20, 0x10, 0x00, 0x10, 0x00, 0x00, 0x10, 0x03, //LSP Object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x07, 0x10, 0x00, 0x04}; //ERO Object + + byte[] testReportMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(reportMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepReportMsg.class)); + + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testReportMsg = new byte[readLen]; + buf.readBytes(testReportMsg, 0, readLen); + + assertThat(testReportMsg, is(reportMsg)); + } + + /** + * This test case checks for SRP Object, LSP Object(StatefulIPv4LspIdentidiersTlv,SymbolicPathNameTlv + * StatefulLspErrorCodeTlv) ERO Object, LSPA Object, Metric-list, IRO object + * in PcRpt message. + */ + @Test + public void reportMessageTest2() throws PcepParseException { + + byte[] reportMsg = new byte[]{0x20, 0x0a, 0x00, (byte) 0x7c, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, //SRP Object + 0x20, 0x10, 0x00, 0x2c, 0x00, 0x00, 0x10, 0x03, //LSP Object // LSP Object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x00, 0x14, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, //StatefulLspErrorCodeTlv + 0x07, 0x10, 0x00, 0x14, //ERO Object + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x04, 0x00, // IPv4SubObjects + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x20, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //LSPA Object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x02, 0x02, 0x00, 0x00, 0x00, 0x00, //Metric Object + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20, //Metric Object + }; + + byte[] testReportMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(reportMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepReportMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testReportMsg = new byte[readLen]; + buf.readBytes(testReportMsg, 0, readLen); + + assertThat(testReportMsg, is(reportMsg)); + } + + /** + * This test case checks for LSP Object(StatefulIPv4LspIdentidiersTlv,SymbolicPathNameTlv,StatefulLspErrorCodeTlv) + * ERO Object, LSPA Object, Metric-list, IRO object + * in PcRpt message. + */ + @Test + public void reportMessageTest3() throws PcepParseException { + + byte[] reportMsg = new byte[]{0x20, 0x0a, 0x00, (byte) 0x70, + 0x20, 0x10, 0x00, 0x2c, 0x00, 0x00, 0x10, 0x03, //LSP Object //LSP Object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x00, 0x14, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, //StatefulLspErrorCodeTlv + 0x07, 0x10, 0x00, 0x14, //ERO Object + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x04, 0x00, //Ipv4SubObjects + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x20, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //LSPA Object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x02, 0x02, 0x00, 0x00, 0x00, 0x00, //Metric Objects + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20, //Metric Object + }; + + byte[] testReportMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(reportMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepReportMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testReportMsg = new byte[readLen]; + buf.readBytes(testReportMsg, 0, readLen); + + assertThat(testReportMsg, is(reportMsg)); + } + + /** + * This test case checks for LSP Object(StatefulIPv4LspIdentidiersTlv,SymbolicPathNameTlv,StatefulLspErrorCodeTlv) + * ERO Object, LSPA Object, Metric-list + * in PcRpt message. + */ + @Test + public void reportMessageTest4() throws PcepParseException { + + byte[] reportMsg = new byte[]{0x20, 0x0a, 0x00, (byte) 0x64, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, //SRP Object + 0x20, 0x10, 0x00, 0x2c, 0x00, 0x00, 0x10, 0x03, //LSP Object //LSP Object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x00, 0x14, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, //StatefulLspErrorCodeTlv + 0x07, 0x10, 0x00, 0x14, //ERO Object + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x04, 0x00, + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x20, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //LSPA Object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; + + byte[] testReportMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(reportMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepReportMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testReportMsg = new byte[readLen]; + buf.readBytes(testReportMsg, 0, readLen); + + assertThat(testReportMsg, is(reportMsg)); + } + + /** + * This test case checks for SRP Object, LSP Object(StatefulIPv4LspIdentidiersTlv,SymbolicPathNameTlv + * StatefulLspErrorCodeTlv) ERO Object, IRO object + * in PcRpt message. + */ + @Test + public void reportMessageTest5() throws PcepParseException { + + byte[] reportMsg = new byte[]{0x20, 0x0a, 0x00, (byte) 0x50, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, //SRP Object + 0x20, 0x10, 0x00, 0x2c, 0x00, 0x00, 0x10, 0x03, //LSP Object //LSP Object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x00, 0x14, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, //StatefulLspErrorCodeTlv + 0x07, 0x10, 0x00, 0x14, //ERO Object + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x04, 0x00, + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x20, 0x04, 0x00}; + + byte[] testReportMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(reportMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepReportMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testReportMsg = new byte[readLen]; + buf.readBytes(testReportMsg, 0, readLen); + + assertThat(testReportMsg, is(reportMsg)); + } + + /** + * This test case checks for SRP Object, LSP Object(StatefulIPv4LspIdentidiersTlv,SymbolicPathNameTlv + * StatefulLspErrorCodeTlv) ERO Object, LSPA Object, Metric-list. + * in PcRpt message. + */ + @Test + public void reportMessageTest6() throws PcepParseException { + + byte[] reportMsg = new byte[]{0x20, 0x0a, 0x00, (byte) 0x6c, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, //SRP Object + 0x20, 0x10, 0x00, 0x2c, 0x00, 0x00, 0x10, 0x03, //LSP Object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x00, 0x14, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, //StatefulLspErrorCodeTlv + 0x07, 0x10, 0x00, 0x04, //ERO Object + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //LSPA Object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x02, 0x02, 0x00, 0x00, 0x00, 0x00, //Metric object + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20, //Metric Object + }; + + byte[] testReportMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(reportMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepReportMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testReportMsg = new byte[readLen]; + buf.readBytes(testReportMsg, 0, readLen); + + assertThat(testReportMsg, is(reportMsg)); + } + + /** + * This test case checks for LSP Object, ERO Object, LSPA Object, Metric-list, IRO object + * in PcRpt message. + */ + @Test + public void reportMessageTest7() throws PcepParseException { + + byte[] reportMsg = new byte[]{0x20, 0x0a, 0x00, (byte) 0x58, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, //SRP Object + 0x20, 0x10, 0x00, 0x08, 0x00, 0x00, 0x10, 0x03, //LSP Object + 0x07, 0x10, 0x00, 0x14, //ERO Object + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x04, 0x00, + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x20, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA Object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x02, 0x02, 0x00, 0x00, 0x00, 0x00, // Metric objects + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20}; + + byte[] testReportMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(reportMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepReportMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testReportMsg = new byte[readLen]; + buf.readBytes(testReportMsg, 0, readLen); + + assertThat(testReportMsg, is(reportMsg)); + } + + /** + * This test case checks for SRP object, LSP object( StatefulIPv4LspIdentidiersTlv, SymbolicPathNameTlv, + * StatefulLspErrorCodeTlv) ERO object, LSPA object, Metric object + * in PcRpt message. + */ + @Test + public void reportMessageTest8() throws PcepParseException { + + byte[] reportMsg = new byte[]{0x20, 0x0a, 0x00, (byte) 0x70, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, //SRP Object + 0x20, 0x10, 0x00, 0x2c, 0x00, 0x00, 0x10, 0x03, //LSP Object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x00, 0x14, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, //StatefulLspErrorCodeTlv + 0x07, 0x10, 0x00, 0x14, //ERO Object + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x04, 0x00, + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x20, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //LSPA Object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20}; //Metric Object + + byte[] testReportMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(reportMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepReportMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testReportMsg = new byte[readLen]; + buf.readBytes(testReportMsg, 0, readLen); + + assertThat(testReportMsg, is(reportMsg)); + } + + /** + * This test case checks for LSP Object(Symbolic path tlv, StatefulIPv4LspIdentidiersTlv, + * StatefulLspErrorCodeTlv ),ERO Object + * in PcRpt message. + */ + @Test + public void reportMessageTest9() throws PcepParseException { + + byte[] reportMsg = new byte[]{0x20, 0x0a, 0x00, (byte) 0x44, + 0x20, 0x10, 0x00, 0x2c, 0x00, 0x00, 0x10, 0x03, //LSP Object //LSP Object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x00, 0x14, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, //StatefulLspErrorCodeTlv + 0x07, 0x10, 0x00, 0x14, //ERO Object + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x04, 0x00, + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x20, 0x04, 0x00}; + + byte[] testReportMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(reportMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepReportMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testReportMsg = new byte[readLen]; + buf.readBytes(testReportMsg, 0, readLen); + + assertThat(testReportMsg, is(reportMsg)); + } + + /** + * This test case checks for SRP Object,LSP Object(StatefulIPv4LspIdentidiersTlv)ERO Object,RRO Object + * in PcRpt message. + */ + @Test + public void reportMessageTest10() throws PcepParseException { + + byte[] reportMsg = new byte[]{0x20, 0x0a, 0x00, (byte) 0x74, + 0x21, 0x10, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, //SRP Object + 0x20, 0x10, 0x00, 0x1c, 0x00, 0x00, 0x10, 0x03, //LSP Object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x07, 0x10, 0x00, 0x14, //ERO Object + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x04, 0x00, + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x20, 0x04, 0x00, + 0x08, 0x10, 0x00, 0x34, 0x01, 0x08, 0x11, 0x01, //RRO Object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x02, 0x04, 0x00, 0x01, 0x08, 0x06, 0x06, + 0x06, 0x06, 0x04, 0x00, 0x01, 0x08, 0x12, 0x01, + 0x01, 0x02, 0x04, 0x00, 0x01, 0x08, 0x12, 0x01, + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x05, 0x05, 0x05, 0x05, 0x04, 0x00}; + + byte[] testReportMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(reportMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepReportMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testReportMsg = new byte[readLen]; + buf.readBytes(testReportMsg, 0, readLen); + + assertThat(testReportMsg, is(reportMsg)); + } + + /** + * This test case checks for SRP Object,LSP Object(SymbolicPathNameTlv)ERO Object,RRO Object + * in PcRpt message. + */ + @Test + public void reportMessageTest11() throws PcepParseException { + + byte[] reportMsg = new byte[]{0x20, 0x0a, 0x00, (byte) 0x68, + 0x21, 0x10, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, //SRP Object + 0x20, 0x10, 0x00, 0x10, 0x00, 0x00, 0x10, 0x03, //LSP Object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x07, 0x10, 0x00, 0x14, //ERO Object + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x04, 0x00, + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x20, 0x04, 0x00, + 0x08, 0x10, 0x00, 0x34, 0x01, 0x08, 0x11, 0x01, //RRO Object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x02, 0x04, 0x00, 0x01, 0x08, 0x06, 0x06, + 0x06, 0x06, 0x04, 0x00, 0x01, 0x08, 0x12, 0x01, + 0x01, 0x02, 0x04, 0x00, 0x01, 0x08, 0x12, 0x01, + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x05, 0x05, 0x05, 0x05, 0x04, 0x00}; + + byte[] testReportMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(reportMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepReportMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testReportMsg = new byte[readLen]; + buf.readBytes(testReportMsg, 0, readLen); + + assertThat(testReportMsg, is(reportMsg)); + } + + /** + * This test case checks for SRP Object,LSP Object, ERO Object,RRO Object + * in PcRpt message. + */ + @Test + public void reportMessageTest12() throws PcepParseException { + + byte[] reportMsg = new byte[]{0x20, 0x0a, 0x00, (byte) 0x60, + 0x21, 0x10, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, //SRP Object + 0x20, 0x10, 0x00, 0x08, 0x00, 0x00, 0x10, 0x03, //LSP Object + 0x07, 0x10, 0x00, 0x14, //ERO Object + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x04, 0x00, + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x04, 0x00, + 0x08, 0x10, 0x00, 0x34, 0x01, 0x08, 0x11, 0x01, //RRO Object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x02, 0x04, 0x00, 0x01, 0x08, 0x06, 0x06, + 0x06, 0x06, 0x04, 0x00, 0x01, 0x08, 0x12, 0x01, + 0x01, 0x02, 0x04, 0x00, 0x01, 0x08, 0x12, 0x01, + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x05, 0x05, 0x05, 0x05, 0x04, 0x00}; + + byte[] testReportMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(reportMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepReportMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testReportMsg = new byte[readLen]; + buf.readBytes(testReportMsg, 0, readLen); + + assertThat(testReportMsg, is(reportMsg)); + } + + /** + * This test case checks for SRP Object,LSP Object(StatefulLspErrorCodeTlv)ERO Object,RRO Object + * in PcRpt message. + */ + @Test + public void reportMessageTest13() throws PcepParseException { + + byte[] reportMsg = new byte[]{0x20, 0x0a, 0x00, (byte) 0x68, + 0x21, 0x10, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, //SRP Object + 0x20, 0x10, 0x00, 0x10, 0x00, 0x00, 0x10, 0x03, //LSP Object + 0x00, 0x14, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, //StatefulLspErrorCodeTlv + 0x07, 0x10, 0x00, 0x14, //ERO Object + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x04, 0x00, + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x20, 0x04, 0x00, + 0x08, 0x10, 0x00, 0x34, 0x01, 0x08, 0x11, 0x01, //RRO Object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x02, 0x04, 0x00, 0x01, 0x08, 0x06, 0x06, + 0x06, 0x06, 0x04, 0x00, 0x01, 0x08, 0x12, 0x01, + 0x01, 0x02, 0x04, 0x00, 0x01, 0x08, 0x12, 0x01, + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x05, 0x05, 0x05, 0x05, 0x04, 0x00}; + + byte[] testReportMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(reportMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepReportMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testReportMsg = new byte[readLen]; + buf.readBytes(testReportMsg, 0, readLen); + + assertThat(testReportMsg, is(reportMsg)); + } + + /** + * This test case checks for SRP Object,LSP Object(StatefulRsvpErrorSpecTlv),ERO Object,RRO Object + * in PcRpt message. + */ + @Test + public void reportMessageTest14() throws PcepParseException { + + byte[] reportMsg = new byte[]{0x20, 0x0a, 0x00, (byte) 0x60, + 0x21, 0x10, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, //SRP Object + 0x20, 0x10, 0x00, 0x08, 0x00, 0x00, 0x10, 0x03, //LSP Object + 0x07, 0x10, 0x00, 0x14, //ERO Object + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x04, 0x00, + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x20, 0x04, 0x00, + 0x08, 0x10, 0x00, 0x34, 0x01, 0x08, 0x11, 0x01, //RRO Object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x02, 0x04, 0x00, 0x01, 0x08, 0x06, 0x06, + 0x06, 0x06, 0x04, 0x00, 0x01, 0x08, 0x12, 0x01, + 0x01, 0x02, 0x04, 0x00, 0x01, 0x08, 0x12, 0x01, + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x05, 0x05, 0x05, 0x05, 0x04, 0x00}; + + byte[] testReportMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(reportMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepReportMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testReportMsg = new byte[readLen]; + buf.readBytes(testReportMsg, 0, readLen); + + assertThat(testReportMsg, is(reportMsg)); + } + + /** + * This test case checks for SRP Object,LSP Object(symbolic path tlv),LSPA Object,ERO Object + * in PcRpt message. + */ + @Test + public void reportMessageTest15() throws PcepParseException { + + byte[] reportMsg = new byte[]{0x20, 0x0a, 0x00, (byte) 0x7C, + 0x21, 0x10, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, //SRP Object + 0x20, 0x10, 0x00, 0x10, 0x00, 0x00, 0x10, 0x03, //LSP Object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x07, 0x10, 0x00, 0x14, //ERO Object + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x04, 0x00, + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x20, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA Object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x08, 0x10, 0x00, 0x34, 0x01, 0x08, 0x11, 0x01, //RRO Object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x02, 0x04, 0x00, 0x01, 0x08, 0x06, 0x06, + 0x06, 0x06, 0x04, 0x00, 0x01, 0x08, 0x12, 0x01, + 0x01, 0x02, 0x04, 0x00, 0x01, 0x08, 0x12, 0x01, + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x05, 0x05, 0x05, 0x05, 0x04, 0x00}; + + byte[] testReportMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(reportMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepReportMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testReportMsg = new byte[readLen]; + buf.readBytes(testReportMsg, 0, readLen); + + assertThat(testReportMsg, is(reportMsg)); + } + + /** + * This test case checks for SRP Object,LSP Object(symbolic path tlv),BandWidth Object,ERO Object + * in PcRpt message. + */ + @Test + public void reportMessageTest16() throws PcepParseException { + + byte[] reportMsg = new byte[]{0x20, 0x0a, 0x00, (byte) 0x70, + 0x21, 0x10, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, //SRP Object + 0x20, 0x10, 0x00, 0x10, 0x00, 0x00, 0x10, 0x03, //LSP Object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x07, 0x10, 0x00, 0x14, //ERO Object + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x04, 0x00, + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x20, 0x04, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, //Bandwidth Object + 0x08, 0x10, 0x00, 0x34, 0x01, 0x08, 0x11, 0x01, //RRO Object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x02, 0x04, 0x00, 0x01, 0x08, 0x06, 0x06, + 0x06, 0x06, 0x04, 0x00, 0x01, 0x08, 0x12, 0x01, + 0x01, 0x02, 0x04, 0x00, 0x01, 0x08, 0x12, 0x01, + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x05, 0x05, 0x05, 0x05, 0x04, 0x00}; + + byte[] testReportMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(reportMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepReportMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testReportMsg = new byte[readLen]; + buf.readBytes(testReportMsg, 0, readLen); + + assertThat(testReportMsg, is(reportMsg)); + } + + /** + * This test case checks for SRP Object,LSP Object,ERO Object,LSPA Object,RRO Object + * in PcRpt message. + */ + @Test + public void reportMessageTest17() throws PcepParseException { + + byte[] reportMsg = new byte[]{0x20, 0x0a, 0x00, (byte) 0x74, + 0x21, 0x10, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, //SRP Object + 0x20, 0x10, 0x00, 0x08, 0x00, 0x00, 0x10, 0x03, //LSP Object + 0x07, 0x10, 0x00, 0x14, //ERO Object + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x04, 0x00, + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x20, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA Object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x08, 0x10, 0x00, 0x34, 0x01, 0x08, 0x11, 0x01, //RRO Object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x02, 0x04, 0x00, 0x01, 0x08, 0x06, 0x06, + 0x06, 0x06, 0x04, 0x00, 0x01, 0x08, 0x12, 0x01, + 0x01, 0x02, 0x04, 0x00, 0x01, 0x08, 0x12, 0x01, + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x05, 0x05, 0x05, 0x05, 0x04, 0x00}; + + byte[] testReportMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(reportMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepReportMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testReportMsg = new byte[readLen]; + buf.readBytes(testReportMsg, 0, readLen); + + assertThat(testReportMsg, is(reportMsg)); + } + + /** + * This test case checks for SRP Object,LSP Object,ERO Object,BandWidth Object,RRO Object + * in PcRpt message. + */ + @Test + public void reportMessageTest18() throws PcepParseException { + + byte[] reportMsg = new byte[]{0x20, 0x0a, 0x00, (byte) 0x68, + 0x21, 0x10, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, //SRP Object + 0x20, 0x10, 0x00, 0x08, 0x00, 0x00, 0x10, 0x03, //LSP Object + 0x07, 0x10, 0x00, 0x14, //ERO Object + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x04, 0x00, + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x20, 0x04, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, //Bandwidth Object + 0x08, 0x10, 0x00, 0x34, 0x01, 0x08, 0x11, 0x01, //RRO Object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x02, 0x04, 0x00, 0x01, 0x08, 0x06, 0x06, + 0x06, 0x06, 0x04, 0x00, 0x01, 0x08, 0x12, 0x01, + 0x01, 0x02, 0x04, 0x00, 0x01, 0x08, 0x12, 0x01, + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x05, 0x05, 0x05, 0x05, 0x04, 0x00}; + + byte[] testReportMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(reportMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepReportMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testReportMsg = new byte[readLen]; + buf.readBytes(testReportMsg, 0, readLen); + + assertThat(testReportMsg, is(reportMsg)); + } + + /** + * This test case checks for SRP Object,LSP Object,ERO Object,Metric-list,RRO Object + * in PcRpt message. + */ + @Test + public void reportMessageTest19() throws PcepParseException { + + byte[] reportMsg = new byte[]{0x20, 0x0a, 0x00, (byte) 0x6C, + 0x21, 0x10, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, //SRP Object + 0x20, 0x10, 0x00, 0x08, 0x00, 0x00, 0x10, 0x03, //LSP Object + 0x07, 0x10, 0x00, 0x14, //ERO Object + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x04, 0x00, + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x20, 0x04, 0x00, + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20, //Metric Object + 0x08, 0x10, 0x00, 0x34, 0x01, 0x08, 0x11, 0x01, //RRO Object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x02, 0x04, 0x00, 0x01, 0x08, 0x06, 0x06, + 0x06, 0x06, 0x04, 0x00, 0x01, 0x08, 0x12, 0x01, + 0x01, 0x02, 0x04, 0x00, 0x01, 0x08, 0x12, 0x01, + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x05, 0x05, 0x05, 0x05, 0x04, 0x00}; + + byte[] testReportMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(reportMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepReportMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testReportMsg = new byte[readLen]; + buf.readBytes(testReportMsg, 0, readLen); + + assertThat(testReportMsg, is(reportMsg)); + } + + /** + * This test case checks for SRP Object,LSP Object,ERO Object,LSPA Object,BandWidth Object,Metric-list,RRO Object + * in PcRpt message. + */ + @Test + public void reportMessageTest20() throws PcepParseException { + + byte[] reportMsg = new byte[]{0x20, 0x0a, 0x00, (byte) 0x88, + 0x21, 0x10, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, //SRP Object + 0x20, 0x10, 0x00, 0x08, 0x00, 0x00, 0x10, 0x03, //LSP Object + 0x07, 0x10, 0x00, 0x14, //ERO Object + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x04, 0x00, + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x20, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, //Bandwidth Object + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20, //Metric Object + 0x08, 0x10, 0x00, 0x34, 0x01, 0x08, 0x11, 0x01, //RRO Object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x02, 0x04, 0x00, 0x01, 0x08, 0x06, 0x06, + 0x06, 0x06, 0x04, 0x00, 0x01, 0x08, 0x12, 0x01, + 0x01, 0x02, 0x04, 0x00, 0x01, 0x08, 0x12, 0x01, + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x05, 0x05, 0x05, 0x05, 0x04, 0x00}; + + byte[] testReportMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(reportMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepReportMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testReportMsg = new byte[readLen]; + buf.readBytes(testReportMsg, 0, readLen); + + assertThat(testReportMsg, is(reportMsg)); + } + + /** + * This test case checks for SRP Object,LSP Object(Symbolic path tlv, StatefulIPv4LspIdentidiersTlv, + * StatefulLspErrorCodeTlv ) ERO Object,LSPA Object,BandWidth Object,Metric-list,RRO Object + * in PcRpt message. + */ + @Test + public void reportMessageTest21() throws PcepParseException { + + byte[] reportMsg = new byte[]{0x20, 0x0a, 0x00, (byte) 0xac, + 0x21, 0x10, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, //SRP Object + 0x20, 0x10, 0x00, 0x2c, 0x00, 0x00, 0x10, 0x03, //LSP Object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x00, 0x14, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, //StatefulLspErrorCodeTlv + 0x07, 0x10, 0x00, 0x14, //ERO Object + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x04, 0x00, + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x20, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, //Bandwidth Object + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20, //Metric Object + 0x08, 0x10, 0x00, 0x34, 0x01, 0x08, 0x11, 0x01, //RRO Object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x02, 0x04, 0x00, 0x01, 0x08, 0x06, 0x06, + 0x06, 0x06, 0x04, 0x00, 0x01, 0x08, 0x12, 0x01, + 0x01, 0x02, 0x04, 0x00, 0x01, 0x08, 0x12, 0x01, + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x05, 0x05, 0x05, 0x05, 0x04, 0x00}; + + byte[] testReportMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(reportMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepReportMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testReportMsg = new byte[readLen]; + buf.readBytes(testReportMsg, 0, readLen); + + assertThat(testReportMsg, is(reportMsg)); + } + + /** + * This test case checks for LSP Object(Symbolic path tlv, StatefulIPv4LspIdentidiersTlv,StatefulLspErrorCodeTlv ) + * ERO Object,LSPA Object,BandWidth Object,Metric-list,RRO Object + * in PcRpt message. + */ + @Test + public void reportMessageTest22() throws PcepParseException { + + byte[] reportMsg = new byte[]{0x20, 0x0a, 0x00, (byte) 0xA0, + 0x20, 0x10, 0x00, 0x2c, 0x00, 0x00, 0x10, 0x03, //LSP Object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x00, 0x14, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, //StatefulLspErrorCodeTlv + 0x07, 0x10, 0x00, 0x14, //ERO Object + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x04, 0x00, + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x20, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, //Bandwidth Object + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20, //Metric Object + 0x08, 0x10, 0x00, 0x34, 0x01, 0x08, 0x11, 0x01, //RRO Object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x02, 0x04, 0x00, 0x01, 0x08, 0x06, 0x06, + 0x06, 0x06, 0x04, 0x00, 0x01, 0x08, 0x12, 0x01, + 0x01, 0x02, 0x04, 0x00, 0x01, 0x08, 0x12, 0x01, + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x05, 0x05, 0x05, 0x05, 0x04, 0x00}; + + byte[] testReportMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(reportMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepReportMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testReportMsg = new byte[readLen]; + buf.readBytes(testReportMsg, 0, readLen); + + assertThat(testReportMsg, is(reportMsg)); + } + + /** + * This test case checks for LSP Object(Symbolic path tlv, StatefulIPv4LspIdentidiersTlv,StatefulLspErrorCodeTlv ) + * ERO Object,BandWidth Object,Metric-list,RRO Object + * in PcRpt message. + */ + @Test + public void reportMessageTest23() throws PcepParseException { + + byte[] reportMsg = new byte[]{0x20, 0x0a, 0x00, (byte) 0x8c, + 0x20, 0x10, 0x00, 0x2c, 0x00, 0x00, 0x10, 0x03, //LSP Object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x00, 0x14, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, //StatefulLspErrorCodeTlv + 0x07, 0x10, 0x00, 0x14, //ERO Object + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x04, 0x00, + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x20, 0x04, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, //Bandwidth Object + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20, //Metric Object + 0x08, 0x10, 0x00, 0x34, 0x01, 0x08, 0x11, 0x01, //RRO Object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x02, 0x04, 0x00, 0x01, 0x08, 0x06, 0x06, + 0x06, 0x06, 0x04, 0x00, 0x01, 0x08, 0x12, 0x01, + 0x01, 0x02, 0x04, 0x00, 0x01, 0x08, 0x12, 0x01, + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x05, 0x05, 0x05, 0x05, 0x04, 0x00}; + + byte[] testReportMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(reportMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepReportMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testReportMsg = new byte[readLen]; + buf.readBytes(testReportMsg, 0, readLen); + + assertThat(testReportMsg, is(reportMsg)); + } + + /** + * This test case checks for LSP Object(Symbolic path tlv, StatefulIPv4LspIdentidiersTlv,StatefulLspErrorCodeTlv ) + * ERO Object,Metric-list,RRO Object + * in PcRpt message. + */ + @Test + public void reportMessageTest24() throws PcepParseException { + + byte[] reportMsg = new byte[]{0x20, 0x0a, 0x00, (byte) 0x84, + 0x20, 0x10, 0x00, 0x2c, 0x00, 0x00, 0x10, 0x03, //LSP Object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x00, 0x14, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, //StatefulLspErrorCodeTlv + 0x07, 0x10, 0x00, 0x14, //ERO Object + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x04, 0x00, + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x20, 0x04, 0x00, + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20, //Metric Object + 0x08, 0x10, 0x00, 0x34, 0x01, 0x08, 0x11, 0x01, //RRO Object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x02, 0x04, 0x00, 0x01, 0x08, 0x06, 0x06, + 0x06, 0x06, 0x04, 0x00, 0x01, 0x08, 0x12, 0x01, + 0x01, 0x02, 0x04, 0x00, 0x01, 0x08, 0x12, 0x01, + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x05, 0x05, 0x05, 0x05, 0x04, 0x00}; + + byte[] testReportMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(reportMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepReportMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testReportMsg = new byte[readLen]; + buf.readBytes(testReportMsg, 0, readLen); + + assertThat(testReportMsg, is(reportMsg)); + } + + /** + * This test case checks for LSP Object(Symbolic path tlv, StatefulIPv4LspIdentidiersTlv,StatefulLspErrorCodeTlv ) + * ERO Object,LSPA Object,RRO Object + * in PcRpt message. + */ + @Test + public void reportMessageTest25() throws PcepParseException { + + byte[] reportMsg = new byte[]{0x20, 0x0a, 0x00, (byte) 0x8c, + 0x20, 0x10, 0x00, 0x2c, 0x00, 0x00, 0x10, 0x03, //LSP Object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x00, 0x14, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, //StatefulLspErrorCodeTlv + 0x07, 0x10, 0x00, 0x14, //ERO Object + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x04, 0x00, + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x20, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, //LSPA Object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x08, 0x10, 0x00, 0x34, 0x01, 0x08, 0x11, 0x01, //RRO Object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x02, 0x04, 0x00, 0x01, 0x08, 0x06, 0x06, + 0x06, 0x06, 0x04, 0x00, 0x01, 0x08, 0x12, 0x01, + 0x01, 0x02, 0x04, 0x00, 0x01, 0x08, 0x12, 0x01, + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x05, 0x05, 0x05, 0x05, 0x04, 0x00}; + + byte[] testReportMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(reportMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepReportMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testReportMsg = new byte[readLen]; + buf.readBytes(testReportMsg, 0, readLen); + + assertThat(testReportMsg, is(reportMsg)); + } + + /** + * This test case checks for LSP Object(Symbolic path tlv, StatefulIPv4LspIdentidiersTlv,StatefulLspErrorCodeTlv ) + * ERO Object,LSPA Object + * in PcRpt message. + */ + @Test + public void reportMessageTest26() throws PcepParseException { + + byte[] reportMsg = new byte[]{0x20, 0x0a, 0x00, (byte) 0x58, + 0x20, 0x10, 0x00, 0x2c, 0x00, 0x00, 0x10, 0x03, //LSP Object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x00, 0x14, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, //StatefulLspErrorCodeTlv + 0x07, 0x10, 0x00, 0x14, //ERO Object + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x04, 0x00, + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x20, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, //LSPA Object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; + + byte[] testReportMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(reportMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepReportMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testReportMsg = new byte[readLen]; + buf.readBytes(testReportMsg, 0, readLen); + + assertThat(testReportMsg, is(reportMsg)); + } + + /** + * This test case checks for LSP Object(Symbolic path tlv, StatefulIPv4LspIdentidiersTlv,StatefulLspErrorCodeTlv) + * ERO Object + * in PcRpt message. + */ + @Test + public void reportMessageTest27() throws PcepParseException { + + byte[] reportMsg = new byte[]{0x20, 0x0a, 0x00, (byte) 0x44, + 0x20, 0x10, 0x00, 0x2c, 0x00, 0x00, 0x10, 0x03, //LSP Object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x00, 0x14, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, //StatefulLspErrorCodeTlv + 0x07, 0x10, 0x00, 0x14, //ERO Object + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x04, 0x00, + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x20, 0x04, 0x00}; + + byte[] testReportMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(reportMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepReportMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testReportMsg = new byte[readLen]; + buf.readBytes(testReportMsg, 0, readLen); + + assertThat(testReportMsg, is(reportMsg)); + } + + /** + * This test case checks for LSP Object(Symbolic path tlv, StatefulIPv4LspIdentidiersTlv,StatefulLspErrorCodeTlv ) + * LSPA Object,BandWidth Object,Metric-list,ERO Object + * in PcRpt message. + */ + @Test + public void reportMessageTest28() throws PcepParseException { + + byte[] reportMsg = new byte[]{0x20, 0x0a, 0x00, (byte) 0x6c, + 0x20, 0x10, 0x00, 0x2c, 0x00, 0x00, 0x10, 0x03, //LSP Object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x00, 0x14, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, //StatefulLspErrorCodeTlv + 0x07, 0x10, 0x00, 0x14, //ERO Object + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x04, 0x00, + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x20, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, //Bandwidth Object + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20}; + + byte[] testReportMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(reportMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepReportMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testReportMsg = new byte[readLen]; + buf.readBytes(testReportMsg, 0, readLen); + + assertThat(testReportMsg, is(reportMsg)); + } + + /** + * This test case checks for SRP Object,LSP Object(symbolic path tlv),ERO Object,Metric-list,RRO Object + * in PcRpt message. + */ + @Test + public void reportMessageTest29() throws PcepParseException { + + byte[] reportMsg = new byte[]{0x20, 0x0a, 0x00, (byte) 0x74, + 0x21, 0x10, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, //SRP Object + 0x20, 0x10, 0x00, 0x10, 0x00, 0x00, 0x10, 0x03, //LSP Object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x07, 0x10, 0x00, 0x14, //ERO Object + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x04, 0x00, + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x20, 0x04, 0x00, + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20, //Metric Object + 0x08, 0x10, 0x00, 0x34, 0x01, 0x08, 0x11, 0x01, //RRO Object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x02, 0x04, 0x00, 0x01, 0x08, 0x06, 0x06, + 0x06, 0x06, 0x04, 0x00, 0x01, 0x08, 0x12, 0x01, + 0x01, 0x02, 0x04, 0x00, 0x01, 0x08, 0x12, 0x01, + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x05, 0x05, 0x05, 0x05, 0x04, 0x00}; + + byte[] testReportMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(reportMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepReportMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testReportMsg = new byte[readLen]; + buf.readBytes(testReportMsg, 0, readLen); + + assertThat(testReportMsg, is(reportMsg)); + } + + /** + * This test case checks for SRP Object,LSP Object(symbolic path tlv),ERO Object,Metric-list,RRO Object + * SRP Object,LSP Object(symbolic path tlv),ERO Object,Metric-list,RRO Object + * in PcRpt message. + */ + @Test + public void reportMessageTest30() throws PcepParseException { + + byte[] reportMsg = new byte[]{0x20, 0x0a, 0x00, (byte) 0xE4, + 0x21, 0x10, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, //SRP Object + 0x20, 0x10, 0x00, 0x10, 0x00, 0x00, 0x10, 0x03, //LSP Object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x07, 0x10, 0x00, 0x14, //ERO Object + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x04, 0x00, + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x20, 0x04, 0x00, + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20, //Metric Object + 0x08, 0x10, 0x00, 0x34, 0x01, 0x08, 0x11, 0x01, //RRO Object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x02, 0x04, 0x00, 0x01, 0x08, 0x06, 0x06, + 0x06, 0x06, 0x04, 0x00, 0x01, 0x08, 0x12, 0x01, + 0x01, 0x02, 0x04, 0x00, 0x01, 0x08, 0x12, 0x01, + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x05, 0x05, 0x05, 0x05, 0x04, 0x00, + 0x21, 0x10, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, //SRP Object + 0x20, 0x10, 0x00, 0x10, 0x00, 0x00, 0x10, 0x03, //LSP Object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x07, 0x10, 0x00, 0x14, //ERO Object + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x04, 0x00, + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x20, 0x04, 0x00, + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20, //Metric Object + 0x08, 0x10, 0x00, 0x34, 0x01, 0x08, 0x11, 0x01, //RRO Object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x02, 0x04, 0x00, 0x01, 0x08, 0x06, 0x06, + 0x06, 0x06, 0x04, 0x00, 0x01, 0x08, 0x12, 0x01, + 0x01, 0x02, 0x04, 0x00, 0x01, 0x08, 0x12, 0x01, + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x05, 0x05, 0x05, 0x05, 0x04, 0x00}; + + byte[] testReportMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(reportMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepReportMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testReportMsg = new byte[readLen]; + buf.readBytes(testReportMsg, 0, readLen); + + assertThat(testReportMsg, is(reportMsg)); + } + + /** + * This test case checks for SRP Object,LSP Object(symbolic path tlv),ERO Object,LSPA Object + * BandWidth Object,Metric-list,RRO Object,SRP Object,LSP Object(symbolic path tlv) + * ERO Object,Metric-list,RRO Object + * in PcRpt message. + */ + @Test + public void reportMessageTest31() throws PcepParseException { + + byte[] reportMsg = new byte[]{0x20, 0x0a, 0x01, 0x00, + 0x21, 0x10, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, //SRP Object + 0x20, 0x10, 0x00, 0x10, 0x00, 0x00, 0x10, 0x03, //LSP Object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x07, 0x10, 0x00, 0x14, //ERO Object + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x04, 0x00, + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x20, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA Object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, //Bandwidth Object + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20, //Metric Object + 0x08, 0x10, 0x00, 0x34, 0x01, 0x08, 0x11, 0x01, //RRO Object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x02, 0x04, 0x00, 0x01, 0x08, 0x06, 0x06, + 0x06, 0x06, 0x04, 0x00, 0x01, 0x08, 0x12, 0x01, + 0x01, 0x02, 0x04, 0x00, 0x01, 0x08, 0x12, 0x01, + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x05, 0x05, 0x05, 0x05, 0x04, 0x00, + 0x21, 0x10, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, //SRP Object + 0x20, 0x10, 0x00, 0x10, 0x00, 0x00, 0x10, 0x03, //LSP Object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x07, 0x10, 0x00, 0x14, //ERO Object + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x04, 0x00, + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x20, 0x04, 0x00, + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20, //Metric Object + 0x08, 0x10, 0x00, 0x34, 0x01, 0x08, 0x11, 0x01, //RRO Object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x02, 0x04, 0x00, 0x01, 0x08, 0x06, 0x06, + 0x06, 0x06, 0x04, 0x00, 0x01, 0x08, 0x12, 0x01, + 0x01, 0x02, 0x04, 0x00, 0x01, 0x08, 0x12, 0x01, + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x05, 0x05, 0x05, 0x05, 0x04, 0x00}; + + byte[] testReportMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(reportMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepReportMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testReportMsg = new byte[readLen]; + buf.readBytes(testReportMsg, 0, readLen); + + assertThat(testReportMsg, is(reportMsg)); + } + + /** + * This test case checks for SRP Object,LSP Object(symbolic path tlv),ERO Object,LSPA Object + * BandWidth Object,Metric-list,RRO Object,SRP Object,LSP Object(symbolic path tlv) + * ERO Object,LSPA Object,Metric-list,RRO Object + * in PcRpt message. + */ + @Test + public void reportMessageTest32() throws PcepParseException { + + byte[] reportMsg = new byte[]{0x20, 0x0a, 0x01, (byte) 0x14, + 0x21, 0x10, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, //SRP Object + 0x20, 0x10, 0x00, 0x10, 0x00, 0x00, 0x10, 0x03, //LSP Object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x07, 0x10, 0x00, 0x14, //ERO Object + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x04, 0x00, + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x20, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA Object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, //Bandwidth Object + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20, //Metric Object + 0x08, 0x10, 0x00, 0x34, 0x01, 0x08, 0x11, 0x01, //RRO Object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x02, 0x04, 0x00, 0x01, 0x08, 0x06, 0x06, + 0x06, 0x06, 0x04, 0x00, 0x01, 0x08, 0x12, 0x01, + 0x01, 0x02, 0x04, 0x00, 0x01, 0x08, 0x12, 0x01, + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x05, 0x05, 0x05, 0x05, 0x04, 0x00, + 0x21, 0x10, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, //SRP Object + 0x20, 0x10, 0x00, 0x10, 0x00, 0x00, 0x10, 0x03, //LSP Object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x07, 0x10, 0x00, 0x14, //ERO Object + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x04, 0x00, + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x20, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA Object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20, //Metric Object + 0x08, 0x10, 0x00, 0x34, 0x01, 0x08, 0x11, 0x01, //RRO Object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x02, 0x04, 0x00, 0x01, 0x08, 0x06, 0x06, + 0x06, 0x06, 0x04, 0x00, 0x01, 0x08, 0x12, 0x01, + 0x01, 0x02, 0x04, 0x00, 0x01, 0x08, 0x12, 0x01, + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x05, 0x05, 0x05, 0x05, 0x04, 0x00}; + + byte[] testReportMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(reportMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepReportMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testReportMsg = new byte[readLen]; + buf.readBytes(testReportMsg, 0, readLen); + + assertThat(testReportMsg, is(reportMsg)); + } + + /** + * This test case checks for SRP Object,LSP Object(symbolic path tlv),ERO Object,LSPA Object + * BandWidth Object,Metric-list,RRO Object,SRP Object,LSP Object(symbolic path tlv) + * ERO Object,LSPA Object,BandWidth Object,Metric-list,RRO Object + * in PcRpt message. + */ + @Test + public void reportMessageTest33() throws PcepParseException { + + byte[] reportMsg = new byte[]{0x20, 0x0a, 0x01, (byte) 0x1c, + 0x21, 0x10, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, //SRP Object + 0x20, 0x10, 0x00, 0x10, 0x00, 0x00, 0x10, 0x03, //LSP Object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x07, 0x10, 0x00, 0x14, //ERO Object + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x04, 0x00, + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x20, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA Object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, //Bandwidth Object + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20, //Metric Object + 0x08, 0x10, 0x00, 0x34, 0x01, 0x08, 0x11, 0x01, //RRO Object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x02, 0x04, 0x00, 0x01, 0x08, 0x06, 0x06, + 0x06, 0x06, 0x04, 0x00, 0x01, 0x08, 0x12, 0x01, + 0x01, 0x02, 0x04, 0x00, 0x01, 0x08, 0x12, 0x01, + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x05, 0x05, 0x05, 0x05, 0x04, 0x00, + 0x21, 0x10, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, //SRP Object + 0x20, 0x10, 0x00, 0x10, 0x00, 0x00, 0x10, 0x03, //LSP Object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x07, 0x10, 0x00, 0x14, //ERO Object + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x04, 0x00, + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x20, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, //Bandwidth Object + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20, //Metric Object + 0x08, 0x10, 0x00, 0x34, 0x01, 0x08, 0x11, 0x01, //RRO Object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x02, 0x04, 0x00, 0x01, 0x08, 0x06, 0x06, + 0x06, 0x06, 0x04, 0x00, 0x01, 0x08, 0x12, 0x01, + 0x01, 0x02, 0x04, 0x00, 0x01, 0x08, 0x12, 0x01, + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x05, 0x05, 0x05, 0x05, 0x04, 0x00}; + + byte[] testReportMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(reportMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepReportMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testReportMsg = new byte[readLen]; + buf.readBytes(testReportMsg, 0, readLen); + + assertThat(testReportMsg, is(reportMsg)); + } + + /** + * This test case checks for SRP Object,LSP Object(symbolic path Tlv),ERO Object,LSPA Object + * BandWidth Object,Metric-list,SRP Object,LSP Object(symbolic path tlv) + * ERO Object,LSPA Object,BandWidth Object,Metric-list + * in PcRpt message. + */ + @Test + public void reportMessageTest34() throws PcepParseException { + + byte[] reportMsg = new byte[]{0x20, 0x0a, 0x00, (byte) 0xB4, + 0x21, 0x10, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, //SRP Object + 0x20, 0x10, 0x00, 0x10, 0x00, 0x00, 0x10, 0x03, //LSP Object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x07, 0x10, 0x00, 0x14, //ERO Object + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x04, 0x00, + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x20, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA Object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, //Bandwidth Object + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20, //Metric Object + 0x21, 0x10, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, //SRP Object + 0x20, 0x10, 0x00, 0x10, 0x00, 0x00, 0x10, 0x04, //LSP Object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x07, 0x10, 0x00, 0x14, //ERO Object + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x04, 0x00, + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x20, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA Object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, //Bandwidth Object + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20}; //Metric Object + + byte[] testReportMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(reportMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepReportMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testReportMsg = new byte[readLen]; + buf.readBytes(testReportMsg, 0, readLen); + + assertThat(testReportMsg, is(reportMsg)); + } + + /** + * This test case checks for SRP Object,LSP Object)Symbolic path tlv),ERO Object,SRP Object + * LSP Object(symbolic path tlv) ERO Object,LSPA Object, BandWidth Object,Metric-list + * in PcRpt message. + */ + @Test + public void reportMessageTest35() throws PcepParseException { + + byte[] reportMsg = new byte[]{0x20, 0x0a, 0x00, (byte) 0x8C, + 0x21, 0x10, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, //SRP Object + 0x20, 0x10, 0x00, 0x10, 0x00, 0x00, 0x10, 0x03, //LSP Object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x07, 0x10, 0x00, 0x14, //ERO Object + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x04, 0x00, + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x20, 0x04, 0x00, + 0x21, 0x10, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, //SRP Object + 0x20, 0x10, 0x00, 0x10, 0x00, 0x00, 0x10, 0x03, //LSP Object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x07, 0x10, 0x00, 0x14, //ERO Object + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x04, 0x00, + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x20, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, //LSPA Object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, //Bandwidth Object + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20}; //Metric Object + + byte[] testReportMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(reportMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepReportMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testReportMsg = new byte[readLen]; + buf.readBytes(testReportMsg, 0, readLen); + + assertThat(testReportMsg, is(reportMsg)); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/protocol/PcepTEReportMsgTest.java b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/protocol/PcepTEReportMsgTest.java new file mode 100644 index 00000000..e401c159 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/protocol/PcepTEReportMsgTest.java @@ -0,0 +1,1596 @@ +/* + * Copyright 2014-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; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.jboss.netty.buffer.ChannelBuffers; +import org.junit.Test; +import org.onosproject.pcepio.exceptions.PcepParseException; + +import static org.hamcrest.MatcherAssert.assertThat; +import static org.hamcrest.Matchers.instanceOf; +import static org.hamcrest.core.Is.is; + +public class PcepTEReportMsgTest { + + /** + * This test case checks for + * TE Object (Routing Universe TLV, Local TE Node Descriptors TLV(AutonomousSystemTlv)). + * in PcTERpt message. + */ + @Test + public void teReportMessageTest1() throws PcepParseException { + + byte[] teReportMsg = new byte[]{0x20, 0x0E, 0x00, 0x28, // common header + 0x0E, 0x10, 0x00, 0x24, // TE Object Header + 0x01, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x10, // TE-ID + 0x00, 0x0E, 0x00, 0x08, // Routing Universe TLV + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, + 0x06, 0x65, 0x00, 0x08, // Local TE Node Descriptors TLV + 0x00, 0x64, 0x00, 0x04, //AutonomousSystem Tlv + 0x00, 0x00, 0x00, 0x11}; + + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(teReportMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + byte[] testReportMsg = {0}; + + assertThat(message, instanceOf(PcepTEReportMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testReportMsg = new byte[readLen]; + buf.readBytes(testReportMsg, 0, readLen); + + assertThat(testReportMsg, is(teReportMsg)); + } + + /** + * This test case checks for + * T E Object (Routing Universe TLV, Local TE Node Descriptors TLV(AutonomousSystemTlv)) with different TE-ID. + * in PcTERpt message. + */ + @Test + public void teReportMessageTest2() throws PcepParseException { + + byte[] teReportMsg = new byte[]{0x20, 0x0E, 0x00, 0x28, // common header + 0x0E, 0x10, 0x00, 0x24, // TE Object Header + 0x01, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x10, // TE-ID + 0x00, 0x0E, 0x00, 0x08, // Routing Universe TLV + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, + 0x06, 0x65, 0x00, 0x08, // Local TE Node Descriptors TLV + 0x00, 0x64, 0x00, 0x04, //AutonomousSystemTlv + 0x00, 0x00, 0x00, 0x11}; + + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(teReportMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + byte[] testReportMsg = {0}; + assertThat(message, instanceOf(PcepTEReportMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testReportMsg = new byte[readLen]; + buf.readBytes(testReportMsg, 0, readLen); + + assertThat(testReportMsg, is(teReportMsg)); + } + + /** + * This test case checks for TE Object (Routing Universe TLV) + * in PcTERpt message. + */ + @Test + public void teReportMessageTest3() throws PcepParseException { + + byte[] teReportMsg = new byte[]{0x20, 0x0E, 0x00, 0x1c, // common header + 0x0E, 0x10, 0x00, 0x18, // TE Object Header + 0x01, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x10, // TE-ID + 0x00, 0x0E, 0x00, 0x08, // Routing Universe TLV + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01}; + + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(teReportMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + byte[] testReportMsg = {0}; + assertThat(message, instanceOf(PcepTEReportMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testReportMsg = new byte[readLen]; + buf.readBytes(testReportMsg, 0, readLen); + + assertThat(testReportMsg, is(teReportMsg)); + } + + /** + * This test case checks for + * TE Object (Routing Universe TLV,Local TE Node Descriptors TLV(AutonomousSystemTlv, BGPLSidentifierTlv. + * OSPFareaIDsubTlv, RouterIDSubTlv)). + * in PcTERpt message. + */ + @Test + public void teReportMessageTest4() throws PcepParseException { + + byte[] teReportMsg = new byte[]{0x20, 0x0E, 0x00, 0x44, // common header + 0x0E, 0x10, 0x00, 0x40, // TE Object Header + 0x01, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x10, // TE-ID + 0x00, 0x0E, 0x00, 0x08, // Routing Universe TLV + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x01, + 0x06, 0x65, 0x00, 0x24, // Local TE Node Descriptors TLV + 0x00, 0x64, 0x00, 0x04, //AutonomousSystemTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x11, 0x00, 0x04, //BGPLSidentifierTlv + 0x00, 0x00, 0x00, 0x11, + 0x02, 0x58, 0x00, 0x04, //OSPFareaIDsubTlv + 0x00, 0x00, 0x00, 0x11, + 0x03, (byte) 0xE8, 0x00, 0x08, //RouterIDSubTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x00, 0x00, 0x11}; + + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(teReportMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + byte[] testReportMsg = {0}; + assertThat(message, instanceOf(PcepTEReportMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testReportMsg = new byte[readLen]; + buf.readBytes(testReportMsg, 0, readLen); + + assertThat(testReportMsg, is(teReportMsg)); + } + + /** + * This test case checks for + * TE Object (Routing Universe TLV,Local TE Node Descriptors TLV(BGPLSidentifierTlv + * OSPFareaIDsubTlv, RouterIDSubTlv)) + * in PcTERpt message. + */ + @Test + public void teReportMessageTest5() throws PcepParseException { + + byte[] teReportMsg = new byte[]{0x20, 0x0E, 0x00, 0x3C, // common header + 0x0E, 0x10, 0x00, 0x38, // TE Object Header + 0x01, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x10, // TE-ID + 0x00, 0x0E, 0x00, 0x08, // Routing Universe TLV + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x01, + 0x06, 0x65, 0x00, 0x1C, // Local TE Node Descriptors TLV + 0x00, 0x11, 0x00, 0x04, //BGPLSidentifierTlv + 0x00, 0x00, 0x00, 0x11, + 0x02, 0x58, 0x00, 0x04, //OSPFareaIDsubTlv + 0x00, 0x00, 0x00, 0x11, + 0x03, (byte) 0xE8, 0x00, 0x08, //RouterIDSubTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x00, 0x00, 0x11}; + + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(teReportMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + byte[] testReportMsg = {0}; + assertThat(message, instanceOf(PcepTEReportMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testReportMsg = new byte[readLen]; + buf.readBytes(testReportMsg, 0, readLen); + + assertThat(testReportMsg, is(teReportMsg)); + } + + /** + * This test case checks for TE Object (Routing Universe TLV,Local TE Node Descriptors TLV(OSPFareaIDsubTlv, + * RouterIDSubTlv)) + * in PcTERpt message. + */ + @Test + public void teReportMessageTest6() throws PcepParseException { + + byte[] teReportMsg = new byte[]{0x20, 0x0E, 0x00, 0x34, // common header + 0x0E, 0x10, 0x00, 0x30, // TE Object Header + 0x01, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x10, // TE-ID + 0x00, 0x0E, 0x00, 0x08, // Routing Universe TLV + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x01, + 0x06, 0x65, 0x00, 0x14, // Local TE Node Descriptors TLV + 0x02, 0x58, 0x00, 0x04, //OSPFareaIDsubTlv + 0x00, 0x00, 0x00, 0x11, + 0x03, (byte) 0xE8, 0x00, 0x08, //RouterIDSubTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x00, 0x00, 0x11}; + + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(teReportMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + byte[] testReportMsg = {0}; + assertThat(message, instanceOf(PcepTEReportMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testReportMsg = new byte[readLen]; + buf.readBytes(testReportMsg, 0, readLen); + + assertThat(testReportMsg, is(teReportMsg)); + } + + /** + * This test case checks for TE Object (Routing Universe TLV,Local TE Node Descriptors TLV(RouterIDSubTlv)). + * in PcTERpt message. + */ + @Test + public void teReportMessageTest7() throws PcepParseException { + + byte[] teReportMsg = new byte[]{0x20, 0x0E, 0x00, 0x2C, // common header + 0x0E, 0x10, 0x00, 0x28, // TE Object Header + 0x01, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x10, // TE-ID + 0x00, 0x0E, 0x00, 0x08, // Routing Universe TLV + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x01, + 0x06, 0x65, 0x00, 0x0C, // Local TE Node Descriptors TLV + 0x03, (byte) 0xE8, 0x00, 0x08, //RouterIDSubTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x00, 0x00, 0x11}; + + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(teReportMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + byte[] testReportMsg = {0}; + assertThat(message, instanceOf(PcepTEReportMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testReportMsg = new byte[readLen]; + buf.readBytes(testReportMsg, 0, readLen); + + assertThat(testReportMsg, is(teReportMsg)); + } + + /** + * This test case checks for TE Object (Routing Universe TLV,Local TE Node Descriptors TLV) + * in PcTERpt message. + */ + @Test + public void teReportMessageTest8() throws PcepParseException { + + byte[] teReportMsg = new byte[]{0x20, 0x0E, 0x00, 0x20, // common header + 0x0E, 0x10, 0x00, 0x1C, // TE Object Header + 0x01, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x10, // TE-ID + 0x00, 0x0E, 0x00, 0x08, // Routing Universe TLV + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x01, + 0x06, 0x65, 0x00, 0x00 // Local TE Node Descriptors TLV + }; + + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(teReportMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + byte[] testReportMsg = {0}; + assertThat(message, instanceOf(PcepTEReportMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testReportMsg = new byte[readLen]; + buf.readBytes(testReportMsg, 0, readLen); + + assertThat(testReportMsg, is(teReportMsg)); + } + + /** + * This test case checks for + * TE Object (Routing Universe TLV,Local TE Node Descriptors TLV(AutonomousSystemTlv, BGPLSidentifierTlv. + * OSPFareaIDsubTlv, RouterIDSubTlv), RemoteTENodeDescriptorsTLV(AutonomousSystemTlv, BGPLSidentifierTlv. + * OSPFareaIDsubTlv, RouterIDSubTlv)). + * in PcTERpt message. + */ + @Test + public void teReportMessageTest9() throws PcepParseException { + + byte[] teReportMsg = new byte[]{0x20, 0x0E, 0x00, 0x6C, // common header + 0x0E, 0x10, 0x00, 0x68, // TE Object Header + 0x01, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x10, // TE-ID + 0x00, 0x0E, 0x00, 0x08, // Routing Universe TLV + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x01, + 0x06, 0x65, 0x00, 0x24, // Local TE Node Descriptors TLV + 0x00, 0x64, 0x00, 0x04, //AutonomousSystemTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x11, 0x00, 0x04, //BGPLSidentifierTlv + 0x00, 0x00, 0x00, 0x11, + 0x02, 0x58, 0x00, 0x04, //OSPFareaIDsubTlv + 0x00, 0x00, 0x00, 0x11, + 0x03, (byte) 0xE8, 0x00, 0x08, //RouterIDSubTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x00, 0x00, 0x11, + 0x03, (byte) 0xEB, 0x00, 0x24, //RemoteTENodeDescriptorsTLV + 0x00, 0x64, 0x00, 0x04, //AutonomousSystemTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x11, 0x00, 0x04, //BGPLSidentifierTlv + 0x00, 0x00, 0x00, 0x11, + 0x02, 0x58, 0x00, 0x04, //OSPFareaIDsubTlv + 0x00, 0x00, 0x00, 0x11, + 0x03, (byte) 0xE8, 0x00, 0x08, //RouterIDSubTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x00, 0x00, 0x11 + }; + + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(teReportMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + byte[] testReportMsg = {0}; + assertThat(message, instanceOf(PcepTEReportMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testReportMsg = new byte[readLen]; + buf.readBytes(testReportMsg, 0, readLen); + + assertThat(testReportMsg, is(teReportMsg)); + } + + /** + * This test case checks for + * TE Object (Routing Universe TLV,Local TE Node Descriptors TLV(AutonomousSystemTlv, BGPLSidentifierTlv + * OSPFareaIDsubTlv, RouterIDSubTlv), RemoteTENodeDescriptorsTLV(BGPLSidentifierTlv + * OSPFareaIDsubTlv, RouterIDSubTlv)) + * in PcTERpt message. + */ + @Test + public void teReportMessageTest10() throws PcepParseException { + + byte[] teReportMsg = new byte[]{0x20, 0x0E, 0x00, 0x64, // common header + 0x0E, 0x10, 0x00, 0x60, // TE Object Header + 0x01, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x10, // TE-ID + 0x00, 0x0E, 0x00, 0x08, // Routing Universe TLV + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x01, + 0x06, 0x65, 0x00, 0x24, // Local TE Node Descriptors TLV + 0x00, 0x64, 0x00, 0x04, //AutonomousSystemTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x11, 0x00, 0x04, //BGPLSidentifierTlv + 0x00, 0x00, 0x00, 0x11, + 0x02, 0x58, 0x00, 0x04, //OSPFareaIDsubTlv + 0x00, 0x00, 0x00, 0x11, + 0x03, (byte) 0xE8, 0x00, 0x08, //RouterIDSubTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x00, 0x00, 0x11, + 0x03, (byte) 0xEB, 0x00, 0x1C, //RemoteTENodeDescriptorsTLV + 0x00, 0x11, 0x00, 0x04, //BGPLSidentifierTlv + 0x00, 0x00, 0x00, 0x11, + 0x02, 0x58, 0x00, 0x04, //OSPFareaIDsubTlv + 0x00, 0x00, 0x00, 0x11, + 0x03, (byte) 0xE8, 0x00, 0x08, //RouterIDSubTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x00, 0x00, 0x11 + }; + + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(teReportMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + byte[] testReportMsg = {0}; + assertThat(message, instanceOf(PcepTEReportMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testReportMsg = new byte[readLen]; + buf.readBytes(testReportMsg, 0, readLen); + + assertThat(testReportMsg, is(teReportMsg)); + } + + /** + * This test case checks for + * TE Object (Routing Universe TLV,Local TE Node Descriptors TLV(AutonomousSystemTlv, BGPLSidentifierTlv + * OSPFareaIDsubTlv, RouterIDSubTlv), RemoteTENodeDescriptorsTLV(OSPFareaIDsubTlv, RouterIDSubTlv)) + * in PcTERpt message. + */ + @Test + public void teReportMessageTest11() throws PcepParseException { + + byte[] teReportMsg = new byte[]{0x20, 0x0E, 0x00, 0x5C, // common header + 0x0E, 0x10, 0x00, 0x58, // TE Object Header + 0x01, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x10, // TE-ID + 0x00, 0x0E, 0x00, 0x08, // Routing Universe TLV + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x01, + 0x06, 0x65, 0x00, 0x24, // Local TE Node Descriptors TLV + 0x00, 0x64, 0x00, 0x04, //AutonomousSystemTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x11, 0x00, 0x04, //BGPLSidentifierTlv + 0x00, 0x00, 0x00, 0x11, + 0x02, 0x58, 0x00, 0x04, //OSPFareaIDsubTlv + 0x00, 0x00, 0x00, 0x11, + 0x03, (byte) 0xE8, 0x00, 0x08, //RouterIDSubTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x00, 0x00, 0x11, + 0x03, (byte) 0xEB, 0x00, 0x14, //RemoteTENodeDescriptorsTLV + 0x02, 0x58, 0x00, 0x04, //OSPFareaIDsubTlv + 0x00, 0x00, 0x00, 0x11, + 0x03, (byte) 0xE8, 0x00, 0x08, //RouterIDSubTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x00, 0x00, 0x11 + }; + + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(teReportMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + byte[] testReportMsg = {0}; + assertThat(message, instanceOf(PcepTEReportMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testReportMsg = new byte[readLen]; + buf.readBytes(testReportMsg, 0, readLen); + + assertThat(testReportMsg, is(teReportMsg)); + } + + /** + * This test case checks for + * TE Object (Routing Universe TLV,Local TE Node Descriptors TLV(AutonomousSystemTlv, BGPLSidentifierTlv + * OSPFareaIDsubTlv, RouterIDSubTlv), RemoteTENodeDescriptorsTLV(RouterIDSubTlv)) + * in PcTERpt message. + */ + @Test + public void teReportMessageTest12() throws PcepParseException { + + byte[] teReportMsg = new byte[]{0x20, 0x0E, 0x00, 0x54, // common header + 0x0E, 0x10, 0x00, 0x50, // TE Object Header + 0x01, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x10, // TE-ID + 0x00, 0x0E, 0x00, 0x08, // Routing Universe TLV + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x01, + 0x06, 0x65, 0x00, 0x24, // Local TE Node Descriptors TLV + 0x00, 0x64, 0x00, 0x04, //AutonomousSystemTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x11, 0x00, 0x04, //BGPLSidentifierTlv + 0x00, 0x00, 0x00, 0x11, + 0x02, 0x58, 0x00, 0x04, //OSPFareaIDsubTlv + 0x00, 0x00, 0x00, 0x11, + 0x03, (byte) 0xE8, 0x00, 0x08, //RouterIDSubTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x00, 0x00, 0x11, + 0x03, (byte) 0xEB, 0x00, 0x0c, //RemoteTENodeDescriptorsTLV + 0x03, (byte) 0xE8, 0x00, 0x08, //RouterIDSubTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x00, 0x00, 0x11 + }; + + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(teReportMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + byte[] testReportMsg = {0}; + assertThat(message, instanceOf(PcepTEReportMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testReportMsg = new byte[readLen]; + buf.readBytes(testReportMsg, 0, readLen); + + assertThat(testReportMsg, is(teReportMsg)); + } + + /** + * This test case checks for + * TE Object (Routing Universe TLV,Local TE Node Descriptors TLV(AutonomousSystemTlv, BGPLSidentifierTlv + * OSPFareaIDsubTlv, RouterIDSubTlv), RemoteTENodeDescriptorsTLV) + * in PcTERpt message. + */ + @Test + public void teReportMessageTest13() throws PcepParseException { + + byte[] teReportMsg = new byte[]{0x20, 0x0E, 0x00, 0x48, // common header + 0x0E, 0x10, 0x00, 0x44, // TE Object Header + 0x01, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x10, // TE-ID + 0x00, 0x0E, 0x00, 0x08, // Routing Universe TLV + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x01, + 0x06, 0x65, 0x00, 0x24, // Local TE Node Descriptors TLV + 0x00, 0x64, 0x00, 0x04, //AutonomousSystemTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x11, 0x00, 0x04, //BGPLSidentifierTlv + 0x00, 0x00, 0x00, 0x11, + 0x02, 0x58, 0x00, 0x04, //OSPFareaIDsubTlv + 0x00, 0x00, 0x00, 0x11, + 0x03, (byte) 0xE8, 0x00, 0x08, //RouterIDSubTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x00, 0x00, 0x11, + 0x03, (byte) 0xEB, 0x00, 0x00, //RemoteTENodeDescriptorsTLV + }; + + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(teReportMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + byte[] testReportMsg = {0}; + assertThat(message, instanceOf(PcepTEReportMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testReportMsg = new byte[readLen]; + buf.readBytes(testReportMsg, 0, readLen); + + assertThat(testReportMsg, is(teReportMsg)); + } + + /** + * This test case checks for + * TE Object (Routing Universe TLV,Local TE Node Descriptors TLV(AutonomousSystemTlv, BGPLSidentifierTlv + * OSPFareaIDsubTlv, RouterIDSubTlv), RemoteTENodeDescriptorsTLV(AutonomousSystemTlv, BGPLSidentifierTlv + * OSPFareaIDsubTlv, RouterIDSubTlv), TELinkDescriptorsTLV(LinkLocalRemoteIdentifiersTlv + * IPv4InterfaceAddressTlv, IPv4NeighborAddressTlv)) + * in PcTERpt message. + */ + @Test + public void teReportMessageTest14() throws PcepParseException { + + byte[] teReportMsg = new byte[]{0x20, 0x0E, 0x00, (byte) 0x8C, // common header + 0x0E, 0x10, 0x00, (byte) 0x88, // TE Object Header + 0x01, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x10, // TE-ID + 0x00, 0x0E, 0x00, 0x08, // Routing Universe TLV + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x01, + 0x06, 0x65, 0x00, 0x24, // Local TE Node Descriptors TLV + 0x00, 0x64, 0x00, 0x04, //AutonomousSystemTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x11, 0x00, 0x04, //BGPLSidentifierTlv + 0x00, 0x00, 0x00, 0x11, + 0x02, 0x58, 0x00, 0x04, //OSPFareaIDsubTlv + 0x00, 0x00, 0x00, 0x11, + 0x03, (byte) 0xE8, 0x00, 0x08, //RouterIDSubTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x00, 0x00, 0x11, + 0x03, (byte) 0xEB, 0x00, 0x24, //RemoteTENodeDescriptorsTLV + 0x00, 0x64, 0x00, 0x04, //AutonomousSystemTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x11, 0x00, 0x04, //BGPLSidentifierTlv + 0x00, 0x00, 0x00, 0x11, + 0x02, 0x58, 0x00, 0x04, //OSPFareaIDsubTlv + 0x00, 0x00, 0x00, 0x11, + 0x03, (byte) 0xE8, 0x00, 0x08, //RouterIDSubTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x00, 0x00, 0x11, + 0x04, 0x2E, 0x00, 0x1C, //TELinkDescriptorsTLV + 0x00, 0x04, 0x00, 0x08, //LinkLocalRemoteIdentifiersTlv + 0x01, 0x11, 0x00, 0x09, + 0x01, 0x21, 0x00, 0x09, + 0x00, 0x06, 0x00, 0x04, //IPv4InterfaceAddressTlv + 0x01, 0x01, 0x01, 0x01, + 0x00, 0x08, 0x00, 0x04, //IPv4NeighborAddressTlv + 0x01, 0x011, 0x01, 0x10 + }; + + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(teReportMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + byte[] testReportMsg = {0}; + assertThat(message, instanceOf(PcepTEReportMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testReportMsg = new byte[readLen]; + buf.readBytes(testReportMsg, 0, readLen); + + assertThat(testReportMsg, is(teReportMsg)); + } + + /** + * This test case checks for + * TE Object (Routing Universe TLV,Local TE Node Descriptors TLV(AutonomousSystemTlv, BGPLSidentifierTlv + * OSPFareaIDsubTlv, RouterIDSubTlv), RemoteTENodeDescriptorsTLV(AutonomousSystemTlv, BGPLSidentifierTlv + * OSPFareaIDsubTlv, RouterIDSubTlv), TELinkDescriptorsTLV( + * IPv4InterfaceAddressTlv, IPv4NeighborAddressTlv)) + * in PcTERpt message. + */ + @Test + public void teReportMessageTest15() throws PcepParseException { + + byte[] teReportMsg = new byte[]{0x20, 0x0E, 0x00, (byte) 0x80, // common header + 0x0E, 0x10, 0x00, (byte) 0x7C, // TE Object Header + 0x01, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x10, // TE-ID + 0x00, 0x0E, 0x00, 0x08, // Routing Universe TLV + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x01, + 0x06, 0x65, 0x00, 0x24, // Local TE Node Descriptors TLV + 0x00, 0x64, 0x00, 0x04, //AutonomousSystemTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x11, 0x00, 0x04, //BGPLSidentifierTlv + 0x00, 0x00, 0x00, 0x11, + 0x02, 0x58, 0x00, 0x04, //OSPFareaIDsubTlv + 0x00, 0x00, 0x00, 0x11, + 0x03, (byte) 0xE8, 0x00, 0x08, //RouterIDSubTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x00, 0x00, 0x11, + 0x03, (byte) 0xEB, 0x00, 0x24, //RemoteTENodeDescriptorsTLV + 0x00, 0x64, 0x00, 0x04, //AutonomousSystemTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x11, 0x00, 0x04, //BGPLSidentifierTlv + 0x00, 0x00, 0x00, 0x11, + 0x02, 0x58, 0x00, 0x04, //OSPFareaIDsubTlv + 0x00, 0x00, 0x00, 0x11, + 0x03, (byte) 0xE8, 0x00, 0x08, //RouterIDSubTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x00, 0x00, 0x11, + 0x04, 0x2E, 0x00, 0x10, //TELinkDescriptorsTLV + 0x00, 0x06, 0x00, 0x04, //IPv4InterfaceAddressTlv + 0x01, 0x01, 0x01, 0x01, + 0x00, 0x08, 0x00, 0x04, //IPv4NeighborAddressTlv + 0x01, 0x011, 0x01, 0x10 + }; + + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(teReportMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + byte[] testReportMsg = {0}; + assertThat(message, instanceOf(PcepTEReportMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testReportMsg = new byte[readLen]; + buf.readBytes(testReportMsg, 0, readLen); + + assertThat(testReportMsg, is(teReportMsg)); + } + + /** + * This test case checks for + * TE Object (Routing Universe TLV,Local TE Node Descriptors TLV(AutonomousSystemTlv, BGPLSidentifierTlv + * OSPFareaIDsubTlv, RouterIDSubTlv), RemoteTENodeDescriptorsTLV(AutonomousSystemTlv, BGPLSidentifierTlv + * OSPFareaIDsubTlv, RouterIDSubTlv), TELinkDescriptorsTLV(IPv4NeighborAddressTlv)) + * in PcTERpt message. + */ + @Test + public void teReportMessageTest16() throws PcepParseException { + + byte[] teReportMsg = new byte[]{0x20, 0x0E, 0x00, (byte) 0x78, // common header + 0x0E, 0x10, 0x00, (byte) 0x74, // TE Object Header + 0x01, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x10, // TE-ID + 0x00, 0x0E, 0x00, 0x08, // Routing Universe TLV + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x01, + 0x06, 0x65, 0x00, 0x24, // Local TE Node Descriptors TLV + 0x00, 0x64, 0x00, 0x04, //AutonomousSystemTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x11, 0x00, 0x04, //BGPLSidentifierTlv + 0x00, 0x00, 0x00, 0x11, + 0x02, 0x58, 0x00, 0x04, //OSPFareaIDsubTlv + 0x00, 0x00, 0x00, 0x11, + 0x03, (byte) 0xE8, 0x00, 0x08, //RouterIDSubTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x00, 0x00, 0x11, + 0x03, (byte) 0xEB, 0x00, 0x24, //RemoteTENodeDescriptorsTLV + 0x00, 0x64, 0x00, 0x04, //AutonomousSystemTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x11, 0x00, 0x04, //BGPLSidentifierTlv + 0x00, 0x00, 0x00, 0x11, + 0x02, 0x58, 0x00, 0x04, //OSPFareaIDsubTlv + 0x00, 0x00, 0x00, 0x11, + 0x03, (byte) 0xE8, 0x00, 0x08, //RouterIDSubTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x00, 0x00, 0x11, + 0x04, 0x2E, 0x00, 0x08, //TELinkDescriptorsTLV + 0x00, 0x08, 0x00, 0x04, //IPv4NeighborAddressTlv + 0x01, 0x011, 0x01, 0x10 + }; + + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(teReportMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + byte[] testReportMsg = {0}; + assertThat(message, instanceOf(PcepTEReportMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testReportMsg = new byte[readLen]; + buf.readBytes(testReportMsg, 0, readLen); + + assertThat(testReportMsg, is(teReportMsg)); + } + + /** + * This test case checks for + * TE Object (Routing Universe TLV,Local TE Node Descriptors TLV(AutonomousSystemTlv, BGPLSidentifierTlv + * OSPFareaIDsubTlv, RouterIDSubTlv), RemoteTENodeDescriptorsTLV(AutonomousSystemTlv, BGPLSidentifierTlv + * OSPFareaIDsubTlv, RouterIDSubTlv), TELinkDescriptorsTLV) + * in PcTERpt message. + */ + @Test + public void teReportMessageTest17() throws PcepParseException { + + byte[] teReportMsg = new byte[]{0x20, 0x0E, 0x00, (byte) 0x70, // common header + 0x0E, 0x10, 0x00, (byte) 0x6C, // TE Object Header + 0x01, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x10, // TE-ID + 0x00, 0x0E, 0x00, 0x08, // Routing Universe TLV + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x01, + 0x06, 0x65, 0x00, 0x24, // Local TE Node Descriptors TLV + 0x00, 0x64, 0x00, 0x04, //AutonomousSystemTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x11, 0x00, 0x04, //BGPLSidentifierTlv + 0x00, 0x00, 0x00, 0x11, + 0x02, 0x58, 0x00, 0x04, //OSPFareaIDsubTlv + 0x00, 0x00, 0x00, 0x11, + 0x03, (byte) 0xE8, 0x00, 0x08, //RouterIDSubTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x00, 0x00, 0x11, + 0x03, (byte) 0xEB, 0x00, 0x24, //RemoteTENodeDescriptorsTLV + 0x00, 0x64, 0x00, 0x04, //AutonomousSystemTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x11, 0x00, 0x04, //BGPLSidentifierTlv + 0x00, 0x00, 0x00, 0x11, + 0x02, 0x58, 0x00, 0x04, //OSPFareaIDsubTlv + 0x00, 0x00, 0x00, 0x11, + 0x03, (byte) 0xE8, 0x00, 0x08, //RouterIDSubTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x00, 0x00, 0x11, + 0x04, 0x2E, 0x00, 0x00, //TELinkDescriptorsTLV + }; + + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(teReportMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + byte[] testReportMsg = {0}; + assertThat(message, instanceOf(PcepTEReportMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testReportMsg = new byte[readLen]; + buf.readBytes(testReportMsg, 0, readLen); + + assertThat(testReportMsg, is(teReportMsg)); + } + + /** + * This test case checks for + * TE Object (Routing Universe TLV,Local TE Node Descriptors TLV(AutonomousSystemTlv, BGPLSidentifierTlv + * OSPFareaIDsubTlv, RouterIDSubTlv), RemoteTENodeDescriptorsTLV(AutonomousSystemTlv, BGPLSidentifierTlv + * OSPFareaIDsubTlv, RouterIDSubTlv), TELinkDescriptorsTLV(LinkLocalRemoteIdentifiersTlv + * IPv4InterfaceAddressTlv, IPv4NeighborAddressTlv)) + * in PcTERpt message. + */ + @Test + public void teReportMessageTest18() throws PcepParseException { + + byte[] teReportMsg = new byte[]{0x20, 0x0E, 0x00, (byte) 0xC0, // common header + 0x0E, 0x10, 0x00, (byte) 0xbC, // TE Object Header + 0x01, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x10, // TE-ID + 0x00, 0x0E, 0x00, 0x08, // Routing Universe TLV + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x01, + 0x06, 0x65, 0x00, 0x24, // Local TE Node Descriptors TLV + 0x00, 0x64, 0x00, 0x04, //AutonomousSystemTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x11, 0x00, 0x04, //BGPLSidentifierTlv + 0x00, 0x00, 0x00, 0x11, + 0x02, 0x58, 0x00, 0x04, //OSPFareaIDsubTlv + 0x00, 0x00, 0x00, 0x11, + 0x03, (byte) 0xE8, 0x00, 0x08, //RouterIDSubTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x00, 0x00, 0x11, + 0x03, (byte) 0xEB, 0x00, 0x24, //RemoteTENodeDescriptorsTLV + 0x00, 0x64, 0x00, 0x04, //AutonomousSystemTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x11, 0x00, 0x04, //BGPLSidentifierTlv + 0x00, 0x00, 0x00, 0x11, + 0x02, 0x58, 0x00, 0x04, //OSPFareaIDsubTlv + 0x00, 0x00, 0x00, 0x11, + 0x03, (byte) 0xE8, 0x00, 0x08, //RouterIDSubTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x00, 0x00, 0x11, + 0x04, 0x2E, 0x00, 0x1C, //TELinkDescriptorsTLV + 0x00, 0x04, 0x00, 0x08, //LinkLocalRemoteIdentifiersTlv + 0x01, 0x11, 0x00, 0x09, + 0x01, 0x21, 0x00, 0x09, + 0x00, 0x06, 0x00, 0x04, //IPv4InterfaceAddressTlv + 0x01, 0x01, 0x01, 0x01, + 0x00, 0x08, 0x00, 0x04, //IPv4NeighborAddressTlv + 0x01, 0x011, 0x01, 0x10, + 0x04, (byte) 0xF3, 0x00, 0x30, //TENodeAttributesTlv + 0x00, 0x0E, 0x00, 0x01, //NodeFlagBitsTlv + (byte) 0x90, 0x00, 0x00, 0x00, + 0x03, (byte) 0xE9, 0x00, 0x04, //OpaqueNodeAttributeTlv + 0x01, 0x011, 0x01, 0x10, + 0x03, (byte) 0xEF, 0x00, 0x08, //NodeNameTlv + 0x08, 0x00, 0x01, 0x09, + 0x08, 0x00, 0x01, 0x09, + 0x00, 0x6B, 0x00, 0x08, //ISISAreaIdentifierTlv + 0x20, 0x01, 0x22, 0x01, + 0x20, 0x01, 0x22, 0x01, + 0x00, (byte) 0x86, 0x00, 0x04, //IPv4TERouterIdOfLocalNodeTlv + 0x00, 0x01, 0x01, 0x02 + }; + + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(teReportMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + byte[] testReportMsg = {0}; + assertThat(message, instanceOf(PcepTEReportMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testReportMsg = new byte[readLen]; + buf.readBytes(testReportMsg, 0, readLen); + + assertThat(testReportMsg, is(teReportMsg)); + } + + /** + * This test case checks for + * TE Object (Routing Universe TLV,Local TE Node Descriptors TLV(AutonomousSystemTlv, BGPLSidentifierTlv + * OSPFareaIDsubTlv, RouterIDSubTlv), RemoteTENodeDescriptorsTLV(AutonomousSystemTlv, BGPLSidentifierTlv + * OSPFareaIDsubTlv, RouterIDSubTlv), TELinkDescriptorsTLV(LinkLocalRemoteIdentifiersTlv + * IPv4InterfaceAddressTlv, IPv4NeighborAddressTlv), TENodeAttributesTlv(NodeFlagBitsTlv + * OpaqueNodeAttributeTlv, NodeNameTlv, ISISAreaIdentifierTlv, IPv4TERouterIdOfLocalNodeTlv)) + * in PcTERpt message. + */ + @Test + public void teReportMessageTest19() throws PcepParseException { + + byte[] teReportMsg = new byte[]{0x20, 0x0E, 0x00, (byte) 0xC0, // common header + 0x0E, 0x10, 0x00, (byte) 0xBC, // TE Object Header + 0x01, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x10, // TE-ID + 0x00, 0x0E, 0x00, 0x08, // Routing Universe TLV + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x01, + 0x06, 0x65, 0x00, 0x24, // Local TE Node Descriptors TLV + 0x00, 0x64, 0x00, 0x04, //AutonomousSystemTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x11, 0x00, 0x04, //BGPLSidentifierTlv + 0x00, 0x00, 0x00, 0x11, + 0x02, 0x58, 0x00, 0x04, //OSPFareaIDsubTlv + 0x00, 0x00, 0x00, 0x11, + 0x03, (byte) 0xE8, 0x00, 0x08, //RouterIDSubTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x00, 0x00, 0x11, + 0x03, (byte) 0xEB, 0x00, 0x24, //RemoteTENodeDescriptorsTLV + 0x00, 0x64, 0x00, 0x04, //AutonomousSystemTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x11, 0x00, 0x04, //BGPLSidentifierTlv + 0x00, 0x00, 0x00, 0x11, + 0x02, 0x58, 0x00, 0x04, //OSPFareaIDsubTlv + 0x00, 0x00, 0x00, 0x11, + 0x03, (byte) 0xE8, 0x00, 0x08, //RouterIDSubTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x00, 0x00, 0x11, + 0x04, 0x2E, 0x00, 0x1C, //TELinkDescriptorsTLV + 0x00, 0x04, 0x00, 0x08, //LinkLocalRemoteIdentifiersTlv + 0x01, 0x11, 0x00, 0x09, + 0x01, 0x21, 0x00, 0x09, + 0x00, 0x06, 0x00, 0x04, //IPv4InterfaceAddressTlv + 0x01, 0x01, 0x01, 0x01, + 0x00, 0x08, 0x00, 0x04, //IPv4NeighborAddressTlv + 0x01, 0x011, 0x01, 0x10, + 0x04, (byte) 0xF3, 0x00, 0x30, //TENodeAttributesTlv + 0x00, 0x0E, 0x00, 0x01, //NodeFlagBitsTlv + (byte) 0x90, 0x00, 0x00, 0x00, + 0x03, (byte) 0xE9, 0x00, 0x04, //OpaqueNodeAttributeTlv + 0x01, 0x011, 0x01, 0x10, + 0x03, (byte) 0xEF, 0x00, 0x08, //NodeNameTlv + 0x08, 0x00, 0x01, 0x09, + 0x08, 0x00, 0x01, 0x09, + 0x00, 0x6B, 0x00, 0x08, //ISISAreaIdentifierTlv + 0x20, 0x01, 0x22, 0x01, + 0x20, 0x01, 0x22, 0x01, + 0x00, (byte) 0x86, 0x00, 0x04, //IPv4TERouterIdOfLocalNodeTlv + 0x00, 0x01, 0x01, 0x02 + }; + + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(teReportMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + byte[] testReportMsg = {0}; + assertThat(message, instanceOf(PcepTEReportMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testReportMsg = new byte[readLen]; + buf.readBytes(testReportMsg, 0, readLen); + + assertThat(testReportMsg, is(teReportMsg)); + } + + /** + * This test case checks for + * TE Object (Routing Universe TLV,Local TE Node Descriptors TLV(AutonomousSystemTlv, BGPLSidentifierTlv + * OSPFareaIDsubTlv, RouterIDSubTlv), RemoteTENodeDescriptorsTLV(AutonomousSystemTlv, BGPLSidentifierTlv + * OSPFareaIDsubTlv, RouterIDSubTlv), TELinkDescriptorsTLV(LinkLocalRemoteIdentifiersTlv + * IPv4InterfaceAddressTlv, IPv4NeighborAddressTlv), TENodeAttributesTlv(OpaqueNodeAttributeTlv + * NodeNameTlv, ISISAreaIdentifierTlv, IPv4TERouterIdOfLocalNodeTlv)) + * in PcTERpt message. + */ + @Test + public void teReportMessageTest20() throws PcepParseException { + + byte[] teReportMsg = new byte[]{0x20, 0x0E, 0x00, (byte) 0xB8, // common header + 0x0E, 0x10, 0x00, (byte) 0xB4, // TE Object Header + 0x01, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x10, // TE-ID + 0x00, 0x0E, 0x00, 0x08, // Routing Universe TLV + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x01, + 0x06, 0x65, 0x00, 0x24, // Local TE Node Descriptors TLV + 0x00, 0x64, 0x00, 0x04, //AutonomousSystemTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x11, 0x00, 0x04, //BGPLSidentifierTlv + 0x00, 0x00, 0x00, 0x11, + 0x02, 0x58, 0x00, 0x04, //OSPFareaIDsubTlv + 0x00, 0x00, 0x00, 0x11, + 0x03, (byte) 0xE8, 0x00, 0x08, //RouterIDSubTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x00, 0x00, 0x11, + 0x03, (byte) 0xEB, 0x00, 0x24, //RemoteTENodeDescriptorsTLV + 0x00, 0x64, 0x00, 0x04, //AutonomousSystemTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x11, 0x00, 0x04, //BGPLSidentifierTlv + 0x00, 0x00, 0x00, 0x11, + 0x02, 0x58, 0x00, 0x04, //OSPFareaIDsubTlv + 0x00, 0x00, 0x00, 0x11, + 0x03, (byte) 0xE8, 0x00, 0x08, //RouterIDSubTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x00, 0x00, 0x11, + 0x04, 0x2E, 0x00, 0x1C, //TELinkDescriptorsTLV + 0x00, 0x04, 0x00, 0x08, //LinkLocalRemoteIdentifiersTlv + 0x01, 0x11, 0x00, 0x09, + 0x01, 0x21, 0x00, 0x09, + 0x00, 0x06, 0x00, 0x04, //IPv4InterfaceAddressTlv + 0x01, 0x01, 0x01, 0x01, + 0x00, 0x08, 0x00, 0x04, //IPv4NeighborAddressTlv + 0x01, 0x011, 0x01, 0x10, + 0x04, (byte) 0xF3, 0x00, 0x28, //TENodeAttributesTlv + 0x03, (byte) 0xE9, 0x00, 0x04, //OpaqueNodeAttributeTlv + 0x01, 0x011, 0x01, 0x10, + 0x03, (byte) 0xEF, 0x00, 0x08, //NodeNameTlv + 0x08, 0x00, 0x01, 0x09, + 0x08, 0x00, 0x01, 0x09, + 0x00, 0x6B, 0x00, 0x08, //ISISAreaIdentifierTlv + 0x20, 0x01, 0x22, 0x01, + 0x20, 0x01, 0x22, 0x01, + 0x00, (byte) 0x86, 0x00, 0x04, //IPv4TERouterIdOfLocalNodeTlv + 0x00, 0x01, 0x01, 0x02 + }; + + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(teReportMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + byte[] testReportMsg = {0}; + assertThat(message, instanceOf(PcepTEReportMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testReportMsg = new byte[readLen]; + buf.readBytes(testReportMsg, 0, readLen); + + assertThat(testReportMsg, is(teReportMsg)); + } + + /** + * This test case checks for + * TE Object (Routing Universe TLV,Local TE Node Descriptors TLV(AutonomousSystemTlv, BGPLSidentifierTlv + * OSPFareaIDsubTlv, RouterIDSubTlv), RemoteTENodeDescriptorsTLV(AutonomousSystemTlv, BGPLSidentifierTlv + * OSPFareaIDsubTlv, RouterIDSubTlv), TELinkDescriptorsTLV(LinkLocalRemoteIdentifiersTlv. + * IPv4InterfaceAddressTlv, IPv4NeighborAddressTlv), TENodeAttributesTlv(OpaqueNodeAttributeTlv + * ISISAreaIdentifierTlv, IPv4TERouterIdOfLocalNodeTlv)) + * in PcTERpt message. + */ + @Test + public void teReportMessageTest21() throws PcepParseException { + + byte[] teReportMsg = new byte[]{0x20, 0x0E, 0x00, (byte) 0xAC, // common header + 0x0E, 0x10, 0x00, (byte) 0xA8, // TE Object Header + 0x01, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x10, // TE-ID + 0x00, 0x0E, 0x00, 0x08, // Routing Universe TLV + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x01, + 0x06, 0x65, 0x00, 0x24, // Local TE Node Descriptors TLV + 0x00, 0x64, 0x00, 0x04, //AutonomousSystemTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x11, 0x00, 0x04, //BGPLSidentifierTlv + 0x00, 0x00, 0x00, 0x11, + 0x02, 0x58, 0x00, 0x04, //OSPFareaIDsubTlv + 0x00, 0x00, 0x00, 0x11, + 0x03, (byte) 0xE8, 0x00, 0x08, //RouterIDSubTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x00, 0x00, 0x11, + 0x03, (byte) 0xEB, 0x00, 0x24, //RemoteTENodeDescriptorsTLV + 0x00, 0x64, 0x00, 0x04, //AutonomousSystemTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x11, 0x00, 0x04, //BGPLSidentifierTlv + 0x00, 0x00, 0x00, 0x11, + 0x02, 0x58, 0x00, 0x04, //OSPFareaIDsubTlv + 0x00, 0x00, 0x00, 0x11, + 0x03, (byte) 0xE8, 0x00, 0x08, //RouterIDSubTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x00, 0x00, 0x11, + 0x04, 0x2E, 0x00, 0x1C, //TELinkDescriptorsTLV + 0x00, 0x04, 0x00, 0x08, //LinkLocalRemoteIdentifiersTlv + 0x01, 0x11, 0x00, 0x09, + 0x01, 0x21, 0x00, 0x09, + 0x00, 0x06, 0x00, 0x04, //IPv4InterfaceAddressTlv + 0x01, 0x01, 0x01, 0x01, + 0x00, 0x08, 0x00, 0x04, //IPv4NeighborAddressTlv + 0x01, 0x011, 0x01, 0x10, + 0x04, (byte) 0xF3, 0x00, 0x1C, //TENodeAttributesTlv + 0x03, (byte) 0xE9, 0x00, 0x04, //OpaqueNodeAttributeTlv + 0x01, 0x011, 0x01, 0x10, + 0x00, 0x6B, 0x00, 0x08, //ISISAreaIdentifierTlv + 0x20, 0x01, 0x22, 0x01, + 0x20, 0x01, 0x22, 0x01, + 0x00, (byte) 0x86, 0x00, 0x04, //IPv4TERouterIdOfLocalNodeTlv + 0x00, 0x01, 0x01, 0x02 + }; + + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(teReportMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + byte[] testReportMsg = {0}; + assertThat(message, instanceOf(PcepTEReportMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testReportMsg = new byte[readLen]; + buf.readBytes(testReportMsg, 0, readLen); + + assertThat(testReportMsg, is(teReportMsg)); + } + + /** + * This test case checks for + * TE Object (Routing Universe TLV,Local TE Node Descriptors TLV(AutonomousSystemTlv, BGPLSidentifierTlv. + * OSPFareaIDsubTlv, RouterIDSubTlv), RemoteTENodeDescriptorsTLV(AutonomousSystemTlv, BGPLSidentifierTlv. + * OSPFareaIDsubTlv, RouterIDSubTlv), TELinkDescriptorsTLV(LinkLocalRemoteIdentifiersTlv. + * IPv4InterfaceAddressTlv, IPv4NeighborAddressTlv), TENodeAttributesTlv(NodeFlagBitsTlv. + * OpaqueNodeAttributeTlv, NodeNameTlv, ISISAreaIdentifierTlv, IPv4TERouterIdOfLocalNodeTlv). + * TELinkAttributesTlv(IPv4TERouterIdOfRemoteNodeTlv, IPv6TERouterIdofRemoteNodeTlv, AdministrativeGroupTlv. + * MaximumLinkBandwidthTlv, MaximumReservableLinkBandwidthTlv, UnreservedBandwidthTlv, TEDefaultMetricTlv. + * LinkProtectionTypeTlv, MPLSProtocolMaskTlv, IGPMetricTlv:, SharedRiskLinkGroupTlv. + * OpaqueLinkAttributeTlv, LinkNameTlv)). + * in PcTERpt message. + */ + @Test + public void teReportMessageTest22() throws PcepParseException { + + byte[] teReportMsg = new byte[]{0x20, 0x0E, 0x01, (byte) 0x120, // common header + 0x0E, 0x10, 0x01, (byte) 0x1C, // TE Object Header + 0x01, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x10, // TE-ID + 0x00, 0x0E, 0x00, 0x08, // Routing Universe TLV + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x01, + 0x06, 0x65, 0x00, 0x24, // Local TE Node Descriptors TLV + 0x00, 0x64, 0x00, 0x04, //AutonomousSystemTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x11, 0x00, 0x04, //BGPLSidentifierTlv + 0x00, 0x00, 0x00, 0x11, + 0x02, 0x58, 0x00, 0x04, //OSPFareaIDsubTlv + 0x00, 0x00, 0x00, 0x11, + 0x03, (byte) 0xE8, 0x00, 0x08, //RouterIDSubTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x00, 0x00, 0x11, + 0x03, (byte) 0xEB, 0x00, 0x24, //RemoteTENodeDescriptorsTLV + 0x00, 0x64, 0x00, 0x04, //AutonomousSystemTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x11, 0x00, 0x04, //BGPLSidentifierTlv + 0x00, 0x00, 0x00, 0x11, + 0x02, 0x58, 0x00, 0x04, //OSPFareaIDsubTlv + 0x00, 0x00, 0x00, 0x11, + 0x03, (byte) 0xE8, 0x00, 0x08, //RouterIDSubTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x00, 0x00, 0x11, + 0x04, 0x2E, 0x00, 0x1C, //TELinkDescriptorsTLV + 0x00, 0x04, 0x00, 0x08, //LinkLocalRemoteIdentifiersTlv + 0x01, 0x11, 0x00, 0x09, + 0x01, 0x21, 0x00, 0x09, + 0x00, 0x06, 0x00, 0x04, //IPv4InterfaceAddressTlv + 0x01, 0x01, 0x01, 0x01, + 0x00, 0x08, 0x00, 0x04, //IPv4NeighborAddressTlv + 0x01, 0x011, 0x01, 0x10, + 0x04, (byte) 0xF3, 0x00, 0x28, //TENodeAttributesTlv + 0x03, (byte) 0xE9, 0x00, 0x04, //OpaqueNodeAttributeTlv + 0x01, 0x011, 0x01, 0x10, + 0x03, (byte) 0xEF, 0x00, 0x08, //NodeNameTlv + 0x08, 0x00, 0x01, 0x09, + 0x08, 0x00, 0x01, 0x09, + 0x00, 0x6B, 0x00, 0x08, //ISISAreaIdentifierTlv + 0x20, 0x01, 0x22, 0x01, + 0x20, 0x01, 0x22, 0x01, + 0x00, (byte) 0x86, 0x00, 0x04, //IPv4TERouterIdOfLocalNodeTlv + 0x00, 0x01, 0x01, 0x02, + 0x07, 0x69, 0x00, 0x64, //TELinkAttributesTlv + 0x05, 0x3C, 0x00, 0x04, //IPv4TERouterIdOfRemoteNodeTlv + 0x00, 0x07, 0x08, 0x00, + 0x00, 0x03, 0x00, 0x04, //AdministrativeGroupTlv + 0x00, 0x09, 0x08, 0x00, + 0x00, 0x09, 0x00, 0x04, //MaximumLinkBandwidthTlv + 0x00, 0x09, 0x00, 0x00, + 0x00, 0x0a, 0x00, 0x04, //MaximumReservableLinkBandwidthTlv + 0x00, 0x10, 0x00, 0x00, + 0x00, 0x0b, 0x00, 0x04, //UnreservedBandwidthTlv + 0x00, 0x00, (byte) 0x90, 0x00, + 0x34, 0x58, 0x00, 0x04, //TEDefaultMetricTlv + 0x00, (byte) 0x99, 0x09, 0x00, + 0x00, 0x14, 0x00, 0x02, //LinkProtectionTypeTlv + 0x09, 0x00, 0x00, 0x00, + 0x04, 0x46, 0x00, 0x01, //MPLSProtocolMaskTlv + (byte) 0x80, 0x00, 0x00, 0x00, + 0x04, 0x47, 0x00, 0x03, //IGPMetricTlv + 0x09, (byte) 0x89, 0x07, 0x00, + 0x04, 0x48, 0x00, 0x08, //SharedRiskLinkGroupTlv + 0x04, 0x47, 0x00, 0x03, + 0x04, 0x47, 0x00, 0x03, //OpaqueLinkAttributeTlv + 0x04, 0x49, 0x00, 0x04, + 0x04, 0x47, 0x00, 0x03, + 0x04, 0x4A, 0x00, 0x04, //LinkNameTlv + 0x04, 0x47, 0x00, 0x03 + }; + + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(teReportMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + byte[] testReportMsg = {0}; + assertThat(message, instanceOf(PcepTEReportMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testReportMsg = new byte[readLen]; + buf.readBytes(testReportMsg, 0, readLen); + + assertThat(testReportMsg, is(teReportMsg)); + } + + /** + * This test case checks for + * TE Object (Routing Universe TLV,Local TE Node Descriptors TLV(AutonomousSystemTlv, BGPLSidentifierTlv + * OSPFareaIDsubTlv, RouterIDSubTlv), RemoteTENodeDescriptorsTLV(AutonomousSystemTlv, BGPLSidentifierTlv + * OSPFareaIDsubTlv, RouterIDSubTlv), TELinkDescriptorsTLV(LinkLocalRemoteIdentifiersTlv + * IPv4InterfaceAddressTlv, IPv4NeighborAddressTlv), TENodeAttributesTlv(NodeFlagBitsTlv + * OpaqueNodeAttributeTlv, NodeNameTlv, ISISAreaIdentifierTlv, IPv4TERouterIdOfLocalNodeTlv) + * TELinkAttributesTlv(IPv4TERouterIdOfRemoteNodeTlv, IPv6TERouterIdofRemoteNodeTlv, AdministrativeGroupTlv + * MaximumLinkBandwidthTlv, MaximumReservableLinkBandwidthTlv, UnreservedBandwidthTlv, TEDefaultMetricTlv + * LinkProtectionTypeTlv, MPLSProtocolMaskTlv, IGPMetricTlv:, SharedRiskLinkGroupTlv + * OpaqueLinkAttributeTlv)) + * in PcTERpt message. + */ + @Test + public void teReportMessageTest23() throws PcepParseException { + + byte[] teReportMsg = new byte[]{0x20, 0x0E, 0x01, (byte) 0x118, // common header + 0x0E, 0x10, 0x01, (byte) 0x14, // TE Object Header + 0x01, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x10, // TE-ID + 0x00, 0x0E, 0x00, 0x08, // Routing Universe TLV + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x01, + 0x06, 0x65, 0x00, 0x24, // Local TE Node Descriptors TLV + 0x00, 0x64, 0x00, 0x04, //AutonomousSystemTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x11, 0x00, 0x04, //BGPLSidentifierTlv + 0x00, 0x00, 0x00, 0x11, + 0x02, 0x58, 0x00, 0x04, //OSPFareaIDsubTlv + 0x00, 0x00, 0x00, 0x11, + 0x03, (byte) 0xE8, 0x00, 0x08, //RouterIDSubTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x00, 0x00, 0x11, + 0x03, (byte) 0xEB, 0x00, 0x24, //RemoteTENodeDescriptorsTLV + 0x00, 0x64, 0x00, 0x04, //AutonomousSystemTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x11, 0x00, 0x04, //BGPLSidentifierTlv + 0x00, 0x00, 0x00, 0x11, + 0x02, 0x58, 0x00, 0x04, //OSPFareaIDsubTlv + 0x00, 0x00, 0x00, 0x11, + 0x03, (byte) 0xE8, 0x00, 0x08, //RouterIDSubTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x00, 0x00, 0x11, + 0x04, 0x2E, 0x00, 0x1C, //TELinkDescriptorsTLV + 0x00, 0x04, 0x00, 0x08, //LinkLocalRemoteIdentifiersTlv + 0x01, 0x11, 0x00, 0x09, + 0x01, 0x21, 0x00, 0x09, + 0x00, 0x06, 0x00, 0x04, //IPv4InterfaceAddressTlv + 0x01, 0x01, 0x01, 0x01, + 0x00, 0x08, 0x00, 0x04, //IPv4NeighborAddressTlv + 0x01, 0x011, 0x01, 0x10, + 0x04, (byte) 0xF3, 0x00, 0x28, //TENodeAttributesTlv + 0x03, (byte) 0xE9, 0x00, 0x04, //OpaqueNodeAttributeTlv + 0x01, 0x011, 0x01, 0x10, + 0x03, (byte) 0xEF, 0x00, 0x08, //NodeNameTlv + 0x08, 0x00, 0x01, 0x09, + 0x08, 0x00, 0x01, 0x09, + 0x00, 0x6B, 0x00, 0x08, //ISISAreaIdentifierTlv + 0x20, 0x01, 0x22, 0x01, + 0x20, 0x01, 0x22, 0x01, + 0x00, (byte) 0x86, 0x00, 0x04, //IPv4TERouterIdOfLocalNodeTlv + 0x00, 0x01, 0x01, 0x02, + 0x07, 0x69, 0x00, 0x5C, //TELinkAttributesTlv + 0x05, 0x3C, 0x00, 0x04, //IPv4TERouterIdOfRemoteNodeTlv + 0x00, 0x07, 0x08, 0x00, + 0x00, 0x03, 0x00, 0x04, //AdministrativeGroupTlv + 0x00, 0x09, 0x08, 0x00, + 0x00, 0x09, 0x00, 0x04, //MaximumLinkBandwidthTlv + 0x00, 0x09, 0x00, 0x00, + 0x00, 0x0a, 0x00, 0x04, //MaximumReservableLinkBandwidthTlv + 0x00, 0x10, 0x00, 0x00, + 0x00, 0x0b, 0x00, 0x04, //UnreservedBandwidthTlv + 0x00, 0x00, (byte) 0x90, 0x00, + 0x34, 0x58, 0x00, 0x04, //TEDefaultMetricTlv + 0x00, (byte) 0x99, 0x09, 0x00, + 0x00, 0x14, 0x00, 0x02, //LinkProtectionTypeTlv + 0x09, 0x00, 0x00, 0x00, + 0x04, 0x46, 0x00, 0x01, //MPLSProtocolMaskTlv + (byte) 0x80, 0x00, 0x00, 0x00, + 0x04, 0x47, 0x00, 0x03, //IGPMetricTlv + 0x09, (byte) 0x89, 0x07, 0x00, + 0x04, 0x48, 0x00, 0x08, //SharedRiskLinkGroupTlv + 0x04, 0x47, 0x00, 0x03, + 0x04, 0x47, 0x00, 0x03, //OpaqueLinkAttributeTlv + 0x04, 0x49, 0x00, 0x04, + 0x04, 0x47, 0x00, 0x03 + }; + + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(teReportMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + byte[] testReportMsg = {0}; + assertThat(message, instanceOf(PcepTEReportMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testReportMsg = new byte[readLen]; + buf.readBytes(testReportMsg, 0, readLen); + + assertThat(testReportMsg, is(teReportMsg)); + } + + /** + * This test case checks for + * TE Object (Routing Universe TLV,Local TE Node Descriptors TLV(AutonomousSystemTlv, BGPLSidentifierTlv + * OSPFareaIDsubTlv, RouterIDSubTlv), RemoteTENodeDescriptorsTLV(AutonomousSystemTlv, BGPLSidentifierTlv + * OSPFareaIDsubTlv, RouterIDSubTlv), TELinkDescriptorsTLV(LinkLocalRemoteIdentifiersTlv + * IPv4InterfaceAddressTlv, IPv4NeighborAddressTlv), TENodeAttributesTlv(NodeFlagBitsTlv + * OpaqueNodeAttributeTlv, NodeNameTlv, ISISAreaIdentifierTlv, IPv4TERouterIdOfLocalNodeTlv) + * TELinkAttributesTlv(IPv4TERouterIdOfRemoteNodeTlv, IPv6TERouterIdofRemoteNodeTlv, AdministrativeGroupTlv + * MaximumLinkBandwidthTlv, MaximumReservableLinkBandwidthTlv, UnreservedBandwidthTlv, TEDefaultMetricTlv + * LinkProtectionTypeTlv, MPLSProtocolMaskTlv, IGPMetricTlv:, SharedRiskLinkGroupTlv)) + * in PcTERpt message. + */ + @Test + public void teReportMessageTest24() throws PcepParseException { + + byte[] teReportMsg = new byte[]{0x20, 0x0E, 0x01, (byte) 0x110, // common header + 0x0E, 0x10, 0x01, (byte) 0x0C, // TE Object Header + 0x01, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x10, // TE-ID + 0x00, 0x0E, 0x00, 0x08, // Routing Universe TLV + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x01, + 0x06, 0x65, 0x00, 0x24, // Local TE Node Descriptors TLV + 0x00, 0x64, 0x00, 0x04, //AutonomousSystemTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x11, 0x00, 0x04, //BGPLSidentifierTlv + 0x00, 0x00, 0x00, 0x11, + 0x02, 0x58, 0x00, 0x04, //OSPFareaIDsubTlv + 0x00, 0x00, 0x00, 0x11, + 0x03, (byte) 0xE8, 0x00, 0x08, //RouterIDSubTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x00, 0x00, 0x11, + 0x03, (byte) 0xEB, 0x00, 0x24, //RemoteTENodeDescriptorsTLV + 0x00, 0x64, 0x00, 0x04, //AutonomousSystemTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x11, 0x00, 0x04, //BGPLSidentifierTlv + 0x00, 0x00, 0x00, 0x11, + 0x02, 0x58, 0x00, 0x04, //OSPFareaIDsubTlv + 0x00, 0x00, 0x00, 0x11, + 0x03, (byte) 0xE8, 0x00, 0x08, //RouterIDSubTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x00, 0x00, 0x11, + 0x04, 0x2E, 0x00, 0x1C, //TELinkDescriptorsTLV + 0x00, 0x04, 0x00, 0x08, //LinkLocalRemoteIdentifiersTlv + 0x01, 0x11, 0x00, 0x09, + 0x01, 0x21, 0x00, 0x09, + 0x00, 0x06, 0x00, 0x04, //IPv4InterfaceAddressTlv + 0x01, 0x01, 0x01, 0x01, + 0x00, 0x08, 0x00, 0x04, //IPv4NeighborAddressTlv + 0x01, 0x011, 0x01, 0x10, + 0x04, (byte) 0xF3, 0x00, 0x28, //TENodeAttributesTlv + 0x03, (byte) 0xE9, 0x00, 0x04, //OpaqueNodeAttributeTlv + 0x01, 0x011, 0x01, 0x10, + 0x03, (byte) 0xEF, 0x00, 0x08, //NodeNameTlv + 0x08, 0x00, 0x01, 0x09, + 0x08, 0x00, 0x01, 0x09, + 0x00, 0x6B, 0x00, 0x08, //ISISAreaIdentifierTlv + 0x20, 0x01, 0x22, 0x01, + 0x20, 0x01, 0x22, 0x01, + 0x00, (byte) 0x86, 0x00, 0x04, //IPv4TERouterIdOfLocalNodeTlv + 0x00, 0x01, 0x01, 0x02, + 0x07, 0x69, 0x00, 0x54, //TELinkAttributesTlv + 0x05, 0x3C, 0x00, 0x04, //IPv4TERouterIdOfRemoteNodeTlv + 0x00, 0x07, 0x08, 0x00, + 0x00, 0x03, 0x00, 0x04, //AdministrativeGroupTlv + 0x00, 0x09, 0x08, 0x00, + 0x00, 0x09, 0x00, 0x04, //MaximumLinkBandwidthTlv + 0x00, 0x09, 0x00, 0x00, + 0x00, 0x0a, 0x00, 0x04, //MaximumReservableLinkBandwidthTlv + 0x00, 0x10, 0x00, 0x00, + 0x00, 0x0b, 0x00, 0x04, //UnreservedBandwidthTlv + 0x00, 0x00, (byte) 0x90, 0x00, + 0x34, 0x58, 0x00, 0x04, //TEDefaultMetricTlv + 0x00, (byte) 0x99, 0x09, 0x00, + 0x00, 0x14, 0x00, 0x02, //LinkProtectionTypeTlv + 0x09, 0x00, 0x00, 0x00, + 0x04, 0x46, 0x00, 0x01, //MPLSProtocolMaskTlv + (byte) 0x80, 0x00, 0x00, 0x00, + 0x04, 0x47, 0x00, 0x03, //IGPMetricTlv + 0x09, (byte) 0x89, 0x07, 0x00, + 0x04, 0x48, 0x00, 0x08, //SharedRiskLinkGroupTlv + 0x04, 0x47, 0x00, 0x03, + 0x04, 0x47, 0x00, 0x03 + }; + + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(teReportMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + byte[] testReportMsg = {0}; + assertThat(message, instanceOf(PcepTEReportMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testReportMsg = new byte[readLen]; + buf.readBytes(testReportMsg, 0, readLen); + + assertThat(testReportMsg, is(teReportMsg)); + } + + /** + * This test case checks for + * TE Object (Routing Universe TLV,Local TE Node Descriptors TLV(AutonomousSystemTlv, BGPLSidentifierTlv + * OSPFareaIDsubTlv, RouterIDSubTlv), RemoteTENodeDescriptorsTLV(AutonomousSystemTlv, BGPLSidentifierTlv + * OSPFareaIDsubTlv, RouterIDSubTlv), TELinkDescriptorsTLV(LinkLocalRemoteIdentifiersTlv + * IPv4InterfaceAddressTlv, IPv4NeighborAddressTlv), TENodeAttributesTlv(NodeFlagBitsTlv + * OpaqueNodeAttributeTlv, NodeNameTlv, ISISAreaIdentifierTlv, IPv4TERouterIdOfLocalNodeTlv) + * TELinkAttributesTlv(IPv4TERouterIdOfRemoteNodeTlv, IPv6TERouterIdofRemoteNodeTlv, AdministrativeGroupTlv + * MaximumLinkBandwidthTlv, MaximumReservableLinkBandwidthTlv, UnreservedBandwidthTlv, TEDefaultMetricTlv + * LinkProtectionTypeTlv, MPLSProtocolMaskTlv, IGPMetricTlv)) + * in PcTERpt message. + */ + @Test + public void teReportMessageTest25() throws PcepParseException { + + byte[] teReportMsg = new byte[]{0x20, 0x0E, 0x01, (byte) 0x104, // common header + 0x0E, 0x10, 0x01, 0x00, // TE Object Header + 0x01, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x10, // TE-ID + 0x00, 0x0E, 0x00, 0x08, // Routing Universe TLV + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x01, + 0x06, 0x65, 0x00, 0x24, // Local TE Node Descriptors TLV + 0x00, 0x64, 0x00, 0x04, //AutonomousSystemTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x11, 0x00, 0x04, //BGPLSidentifierTlv + 0x00, 0x00, 0x00, 0x11, + 0x02, 0x58, 0x00, 0x04, //OSPFareaIDsubTlv + 0x00, 0x00, 0x00, 0x11, + 0x03, (byte) 0xE8, 0x00, 0x08, //RouterIDSubTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x00, 0x00, 0x11, + 0x03, (byte) 0xEB, 0x00, 0x24, //RemoteTENodeDescriptorsTLV + 0x00, 0x64, 0x00, 0x04, //AutonomousSystemTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x11, 0x00, 0x04, //BGPLSidentifierTlv + 0x00, 0x00, 0x00, 0x11, + 0x02, 0x58, 0x00, 0x04, //OSPFareaIDsubTlv + 0x00, 0x00, 0x00, 0x11, + 0x03, (byte) 0xE8, 0x00, 0x08, //RouterIDSubTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x00, 0x00, 0x11, + 0x04, 0x2E, 0x00, 0x1C, //TELinkDescriptorsTLV + 0x00, 0x04, 0x00, 0x08, //LinkLocalRemoteIdentifiersTlv + 0x01, 0x11, 0x00, 0x09, + 0x01, 0x21, 0x00, 0x09, + 0x00, 0x06, 0x00, 0x04, //IPv4InterfaceAddressTlv + 0x01, 0x01, 0x01, 0x01, + 0x00, 0x08, 0x00, 0x04, //IPv4NeighborAddressTlv + 0x01, 0x011, 0x01, 0x10, + 0x04, (byte) 0xF3, 0x00, 0x28, //TENodeAttributesTlv + 0x03, (byte) 0xE9, 0x00, 0x04, //OpaqueNodeAttributeTlv + 0x01, 0x011, 0x01, 0x10, + 0x03, (byte) 0xEF, 0x00, 0x08, //NodeNameTlv + 0x08, 0x00, 0x01, 0x09, + 0x08, 0x00, 0x01, 0x09, + 0x00, 0x6B, 0x00, 0x08, //ISISAreaIdentifierTlv + 0x20, 0x01, 0x22, 0x01, + 0x20, 0x01, 0x22, 0x01, + 0x00, (byte) 0x86, 0x00, 0x04, //IPv4TERouterIdOfLocalNodeTlv + 0x00, 0x01, 0x01, 0x02, + 0x07, 0x69, 0x00, 0x48, //TELinkAttributesTlv + 0x05, 0x3C, 0x00, 0x04, //IPv4TERouterIdOfRemoteNodeTlv + 0x00, 0x07, 0x08, 0x00, + 0x00, 0x03, 0x00, 0x04, //AdministrativeGroupTlv + 0x00, 0x09, 0x08, 0x00, + 0x00, 0x09, 0x00, 0x04, //MaximumLinkBandwidthTlv + 0x00, 0x09, 0x00, 0x00, + 0x00, 0x0a, 0x00, 0x04, //MaximumReservableLinkBandwidthTlv + 0x00, 0x10, 0x00, 0x00, + 0x00, 0x0b, 0x00, 0x04, //UnreservedBandwidthTlv + 0x00, 0x00, (byte) 0x90, 0x00, + 0x34, 0x58, 0x00, 0x04, //TEDefaultMetricTlv + 0x00, (byte) 0x99, 0x09, 0x00, + 0x00, 0x14, 0x00, 0x02, //LinkProtectionTypeTlv + 0x09, 0x00, 0x00, 0x00, + 0x04, 0x46, 0x00, 0x01, //MPLSProtocolMaskTlv + (byte) 0x80, 0x00, 0x00, 0x00, + 0x04, 0x47, 0x00, 0x03, //IGPMetricTlv + 0x09, (byte) 0x89, 0x07, 0x00 + }; + + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(teReportMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + byte[] testReportMsg = {0}; + + assertThat(message, instanceOf(PcepTEReportMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testReportMsg = new byte[readLen]; + buf.readBytes(testReportMsg, 0, readLen); + + assertThat(testReportMsg, is(teReportMsg)); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/protocol/PcepUpdateMsgExtTest.java b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/protocol/PcepUpdateMsgExtTest.java new file mode 100644 index 00000000..40234a69 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/protocol/PcepUpdateMsgExtTest.java @@ -0,0 +1,1269 @@ +/* + * Copyright 2014-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; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.jboss.netty.buffer.ChannelBuffers; +import org.junit.Test; +import org.onosproject.pcepio.exceptions.PcepParseException; + +import static org.hamcrest.MatcherAssert.assertThat; +import static org.hamcrest.Matchers.instanceOf; +import static org.hamcrest.core.Is.is; + +/** + * Test cases for PCEP update message. + */ +public class PcepUpdateMsgExtTest { + + /** + * This test case is for SRP object(symbolic path tlv), LSP object(StatefulLspDbVerTlv), ERO object, + * Metric object in PcepUpdate message. + */ + @Test + public void pcepUpdateMsgTest1() throws PcepParseException { + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x8c, + 0x21, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x20, 0x10, 0x00, 0x38, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x00, 0x17, 0x00, 0x08, //StatefulLspDbVerTlv + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, + 0x00, 0x14, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, //StatefulLspErrorCodeTlv + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x11, 0x01, //ERO Object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x01, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, //Bandwidth object + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20 }; //metric object + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + + assertThat(testupdateMsg, is(updateMsg)); + } + + /** + * This test case is for SRP object, LSP object(StatefulIPv4LspIdentidiersTlv), ERO object, + * LSPA, Bandwidth object in PcepUpdate message. + */ + @Test + public void pcepUpdateMsgTest2() throws PcepParseException { + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x68, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x1C, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x11, 0x01, //ERO Object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x01, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSP object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, //Bandwidth object + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20 }; //metric object + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + + assertThat(testupdateMsg, is(updateMsg)); + } + + /** + * This test case is for SRP object, LSP object, ERO object, LSPA, bandwidth object + * Metric object in PcepUpdate message. + */ + @Test + public void pcepUpdateMsgTest3() throws PcepParseException { + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x54, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x08, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x11, 0x01, //ERO Object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x01, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, //Bandwidth object + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20 }; //Metric object + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + + assertThat(testupdateMsg, is(updateMsg)); + } + + /** + * This test case is for SRP object, LSP object(StatefulLspErrorCodeTlv), ERO object,bandwidth object + * Metric object in PcepUpdate message. + */ + @Test + public void pcepUpdateMsgTest4() throws PcepParseException { + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x5c, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x10, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x14, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, //StatefulLspErrorCodeTlv + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x11, 0x01, //ERO Object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x01, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, //Bandwidth object + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20 }; //Metric object + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + + assertThat(testupdateMsg, is(updateMsg)); + } + + /** + * This test case is for SRP object, LSP object(StatefulLspDbVerTlv), ERO object,bandwidth object + * Metric object in PcepUpdate message. + */ + @Test + public void pcepUpdateMsgTest5() throws PcepParseException { + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x60, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x14, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x17, 0x00, 0x08, //StatefulLspDbVerTlv + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x11, 0x01, //ERO Object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x01, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, //Bandwidth object + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20 }; //Metric object + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + + assertThat(testupdateMsg, is(updateMsg)); + } + + /** + * This test case is for SRP object, LSP object(SymbolicPathNameTlv), ERO object, LSPA, bandwidth object + * Metric object in PcepUpdate message. + */ + @Test + public void pcepUpdateMsgTest6() throws PcepParseException { + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x5c, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x10, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x11, 0x01, //ERO Object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x01, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, //Bandwidth object + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20 }; //Metric object + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + + assertThat(testupdateMsg, is(updateMsg)); + } + + /** + * This test case is for SRP object(SymbolicPathNameTlv), LSP object(SymbolicPathNameTlv), ERO object, + * bandwidth object Metric object in PcepUpdate message. + */ + @Test + public void pcepUpdateMsgTest7() throws PcepParseException { + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x64, + 0x21, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x20, 0x10, 0x00, 0x10, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x11, 0x01, //ERO Object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x01, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, //Bandwidth object + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20 }; //Metric object + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + + assertThat(testupdateMsg, is(updateMsg)); + } + + /** + * This test case is for SRP object, LSP object(StatefulIPv4LspIdentidiersTlv), ERO object,LSPA + * bandwidth object in PcepUpdate message. + */ + @Test + public void pcepUpdateMsgTest8() throws PcepParseException { + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x5c, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x1C, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x11, 0x01, //ERO Object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x01, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00 }; //Bandwidth object + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + + assertThat(testupdateMsg, is(updateMsg)); + } + + /** + * This test case is for SRP object, LSP object(StatefulRsvpErrorSpecTlv), ERO object,LSPA + * bandwidth object in PcepUpdate message. + */ + @Test + public void pcepUpdateMsgTest9() throws PcepParseException { + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x58, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x18, 0x00, 0x00, 0x10, 0x03, + 0x00, 0x15, 0x00, 0x0c, //StatefulRsvpErrorSpecTlv + 0x00, 0x0c, 0x06, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x00, 0x05, + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x11, 0x01, //ERO Object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x01, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00 }; //Bandwidth object + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + + assertThat(testupdateMsg, is(updateMsg)); + } + + /** + * This test case is for SRP object, LSP object(StatefulRsvpErrorSpecTlv), ERO object,LSPA + * bandwidth object in PcepUpdate message. + */ + @Test + public void pcepUpdateMsgTest10() throws PcepParseException { + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x50, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x10, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x14, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, //StatefulLspErrorCodeTlv + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x11, 0x01, //ERO Object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x01, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPa object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00 }; //Bandwidth object + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + + assertThat(testupdateMsg, is(updateMsg)); + } + + /** + * This test case is for SRP object, LSP object(StatefulLspDbVerTlv), ERO object,LSPA + * bandwidth object in PcepUpdate message. + */ + @Test + public void pcepUpdateMsgTest11() throws PcepParseException { + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x54, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x14, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x17, 0x00, 0x08, //StatefulLspDbVerTlv + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x11, 0x01, //ERO Object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x01, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00}; //Bandwidth object + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + + assertThat(testupdateMsg, is(updateMsg)); + } + + /** + * This test case is for SRP object, LSP object(SymbolicPathNameTlv), ERO object,LSPA + * bandwidth object in PcepUpdate message. + */ + @Test + public void pcepUpdateMsgTest12() throws PcepParseException { + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x50, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x10, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x11, 0x01, //ERO Object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x01, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00 }; //Bandwidth object + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + + assertThat(testupdateMsg, is(updateMsg)); + } + + /** + * This test case is for SRP object(SymbolicPathNameTlv), LSP object(SymbolicPathNameTlv), ERO object,LSPA + * bandwidth object in PcepUpdate message. + */ + @Test + public void pcepUpdateMsgTest13() throws PcepParseException { + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x58, + 0x21, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x20, 0x10, 0x00, 0x10, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x11, 0x01, //ERO Object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x01, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00 }; //Bandwidth object + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + + assertThat(testupdateMsg, is(updateMsg)); + } + + /** + * This test case is for SRP object, LSP object(StatefulIPv4LspIdentidiersTlv), ERO object,LSPA + * metric object in PcepUpdate message. + */ + @Test + public void pcepUpdateMsgTest14() throws PcepParseException { + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x60, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x1C, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x11, 0x01, //ERO Object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x01, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20 }; //Metric object + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + + assertThat(testupdateMsg, is(updateMsg)); + } + + /** + * This test case is for SRP object, LSP object, ERO object,LSPA + * metric object in PcepUpdate message. + */ + @Test + public void pcepUpdateMsgTest15() throws PcepParseException { + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x4c, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x08, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x11, 0x01, //ERO Object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x01, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //lspa object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20 }; //Metric object + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + + assertThat(testupdateMsg, is(updateMsg)); + } + + /** + * This test case is for SRP object, LSP object(StatefulLspErrorCodeTlv), ERO object,LSPA + * metric object in PcepUpdate message. + */ + @Test + public void pcepUpdateMsgTest16() throws PcepParseException { + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x54, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x10, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x14, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, //StatefulLspErrorCodeTlv + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x11, 0x01, //ERO Object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x01, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20 }; //Metric object + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + + assertThat(testupdateMsg, is(updateMsg)); + } + + /** + * This test case is for SRP object, LSP object(StatefulLspDbVerTlv), ERO object,LSPA + * metric object in PcepUpdate message. + */ + @Test + public void pcepUpdateMsgTest17() throws PcepParseException { + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x58, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x14, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x17, 0x00, 0x08, //StatefulLspDbVerTlv + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x11, 0x01, //ERO Object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x01, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20 }; //Metric object + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + + assertThat(testupdateMsg, is(updateMsg)); + } + + /** + * This test case is for SRP object, LSP object(SymbolicPathNameTlv), ERO object,LSPA + * metric object in PcepUpdate message. + */ + @Test + public void pcepUpdateMsgTest18() throws PcepParseException { + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x54, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x10, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x11, 0x01, //ERO Object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x01, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20 }; //Metric object + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + + assertThat(testupdateMsg, is(updateMsg)); + } + + /** + * This test case is for SRP object(SymbolicPathNameTlv), LSP object(SymbolicPathNameTlv), ERO object, + * metric object in PcepUpdate message. + */ + @Test + public void pcepUpdateMsgTest19() throws PcepParseException { + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x5c, + 0x21, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x20, 0x10, 0x00, 0x10, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x11, 0x01, //ERO Object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x01, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20 }; //Metric object + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + + assertThat(testupdateMsg, is(updateMsg)); + } + + /** + * This test case is for SRP object, LSP object(StatefulIPv4LspIdentidiersTlv), ERO object, + * Bandwidth , metric object in PcepUpdate message. + */ + @Test + public void pcepUpdateMsgTest20() throws PcepParseException { + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x54, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x1C, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x11, 0x01, //ERO Object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x01, 0x04, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, //Bandwidth object + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20 }; //Metric object + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + + assertThat(testupdateMsg, is(updateMsg)); + } + + /** + * This test case is for SRP object, LSP object, ERO object, + * Bandwidth , metric object in PcepUpdate message. + */ + @Test + public void pcepUpdateMsgTest21() throws PcepParseException { + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x40, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x08, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x11, 0x01, //ERO Object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x01, 0x04, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, //Bandwidth object + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20 }; //Metric object + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + + assertThat(testupdateMsg, is(updateMsg)); + } + + /** + * This test case is for SRP object, LSP object(StatefulLspErrorCodeTlv), ERO object, + * Bandwidth , metric object in PcepUpdate message. + */ + @Test + public void pcepUpdateMsgTest22() throws PcepParseException { + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x48, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x10, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x14, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, //StatefulLspErrorCodeTlv + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x11, 0x01, //ERO Object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x01, 0x04, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, //Bandwidth object + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20 }; //Metric object + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + + assertThat(testupdateMsg, is(updateMsg)); + } + + /** + * This test case is for SRP object, LSP object(StatefulLspDbVerTlv), ERO object, + * Bandwidth , metric object in PcepUpdate message. + */ + @Test + public void pcepUpdateMsgTest23() throws PcepParseException { + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x4c, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x14, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x17, 0x00, 0x08, //StatefulLspDbVerTlv + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x11, 0x01, //ERO Object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x01, 0x04, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, //Bandwidth object + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20 }; //Metric object + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + + assertThat(testupdateMsg, is(updateMsg)); + } + + /** + * This test case is for SRP object, LSP object(SymbolicPathNameTlv), ERO object, + * Bandwidth , metric object in PcepUpdate message. + */ + @Test + public void pcepUpdateMsgTest24() throws PcepParseException { + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x48, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x10, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x11, 0x01, //ERO Object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x01, 0x04, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, //Bandwidth object + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20 }; //Metric object + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + + assertThat(testupdateMsg, is(updateMsg)); + } + + /** + * This test case is for SRP object(SymbolicPathNameTlv), LSP object(SymbolicPathNameTlv), ERO object, + * Bandwidth , metric object in PcepUpdate message. + */ + @Test + public void pcepUpdateMsgTest25() throws PcepParseException { + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x50, + 0x21, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x20, 0x10, 0x00, 0x10, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x11, 0x01, //ERO Object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x01, 0x04, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, //Bandwidth object + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20 }; //Metric object + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + + assertThat(testupdateMsg, is(updateMsg)); + } + + /** + * This test case is for SRP object, LSP object(StatefulIPv4LspIdentidiersTlv), ERO object, + * LSPA object in PcepUpdate message. + */ + @Test + public void pcepUpdateMsgTest26() throws PcepParseException { + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x54, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x1C, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x11, 0x01, //ERO Object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x01, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00 }; + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + + assertThat(testupdateMsg, is(updateMsg)); + } + + /** + * This test case is for SRP object, LSP object, ERO object, + * bandwidth object in PcepUpdate message. + */ + @Test + public void pcepUpdateMsgTest27() throws PcepParseException { + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x34, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x08, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x11, 0x01, //ERO Object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x01, 0x04, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00 }; //Bandwidth object + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + + assertThat(testupdateMsg, is(updateMsg)); + } + + /** + * This test case is for SRP object, LSP object(StatefulLspErrorCodeTlv), ERO object, + * metric object in PcepUpdate message. + */ + @Test + public void pcepUpdateMsgTest28() throws PcepParseException { + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x40, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x10, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x14, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, //StatefulLspErrorCodeTlv + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x11, 0x01, //ERO Object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x01, 0x04, 0x00, + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20 }; //Metric object + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + + assertThat(testupdateMsg, is(updateMsg)); + } + + /** + * This test case is for SRP object(SymbolicPathNameTlv), LSP object(StatefulLspErrorCodeTlv), ERO object, + * lspa object in PcepUpdate message. + */ + @Test + public void pcepUpdateMsgTest29() throws PcepParseException { + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x54, + 0x21, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x20, 0x10, 0x00, 0x14, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x17, 0x00, 0x08, //StatefulLspDbVerTlv + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x11, 0x01, //ERO Object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x01, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00 }; + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + + assertThat(testupdateMsg, is(updateMsg)); + } + + /** + * This test case is for SRP object(SymbolicPathNameTlv), LSP object(StatefulLspErrorCodeTlv), ERO object, + * bandwidth object in PcepUpdate message. + */ + @Test + public void pcepUpdateMsgTest30() throws PcepParseException { + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x48, + 0x21, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x20, 0x10, 0x00, 0x14, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x17, 0x00, 0x08, //StatefulLspDbVerTlv + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x11, 0x01, //ERO Object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x01, 0x04, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00 }; //Bandwidth object + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + + assertThat(testupdateMsg, is(updateMsg)); + } + + /** + * This test case is for SRP object(SymbolicPathNameTlv), LSP object(StatefulLspErrorCodeTlv), ERO object, + * metric object in PcepUpdate message. + */ + @Test + public void pcepUpdateMsgTest31() throws PcepParseException { + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x4c, + 0x21, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x20, 0x10, 0x00, 0x14, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x17, 0x00, 0x08, //StatefulLspDbVerTlv + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x11, 0x01, //ERO Object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x01, 0x04, 0x00, + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20 }; //Metric object + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + + assertThat(testupdateMsg, is(updateMsg)); + } + + /** + * This test case is for SRP object(symbolic path tlv), LSP object(StatefulLspDbVerTlv), ERO object, + * Metric object in PcepUpdate message. + */ + @Test + public void pcepUpdateMsgTest32() throws PcepParseException { + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x64, + 0x21, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x20, 0x10, 0x00, 0x14, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x17, 0x00, 0x08, //StatefulLspDbVerTlv + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x11, 0x01, //ERO Object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x01, 0x04, 0x00, + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20, //Metric object + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20, //Metric object + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20 }; //Metric object + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + + assertThat(testupdateMsg, is(updateMsg)); + } +} + diff --git a/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/protocol/PcepUpdateMsgTest.java b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/protocol/PcepUpdateMsgTest.java new file mode 100644 index 00000000..1db30641 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/protocol/PcepUpdateMsgTest.java @@ -0,0 +1,1423 @@ +/* + * Copyright 2014-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; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.jboss.netty.buffer.ChannelBuffers; +import org.junit.Test; +import org.onosproject.pcepio.exceptions.PcepParseException; + +import static org.hamcrest.MatcherAssert.assertThat; +import static org.hamcrest.Matchers.instanceOf; +import static org.hamcrest.core.Is.is; + +public class PcepUpdateMsgTest { + /** + * This test case checks for SRP, LSP (StatefulIPv4LspIdentidiersTlv), ERO in PcUpd message. + */ + @Test + public void pcepUpdateMsgTest1() throws PcepParseException { + + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x30, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x1C, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, (byte) 0xb6, 0x02, 0x4e, 0x1f, //StatefulIPv4LspIdentidiersTlv + 0x00, 0x01, (byte) 0x80, 0x01, (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x07, 0x10, 0x00, 0x04 }; //ERO object + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + + assertThat(testupdateMsg, is(updateMsg)); + } + + /** + * This test case checks for SRP(SymbolicPathNameTlv), LSP (StatefulIPv4LspIdentidiersTlv, + * SymbolicPathNameTlv, StatefulLspErrorCodeTlv), ERO, LSPA, Metric-list in PcUpd message. + */ + @Test + public void pcepUpdateMsgTest2() throws PcepParseException { + + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x94, + 0x21, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x20, 0x10, 0x00, 0x2c, 0x00, 0x00, 0x10, 0x03, //LSP object // lsp object + 0x00, 0x12, 0x00, 0x10, (byte) 0xb6, 0x02, 0x4e, 0x1f, //StatefulIPv4LspIdentidiersTlv + 0x00, 0x01, (byte) 0x80, 0x01, (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x00, 0x14, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, //StatefulLspErrorCodeTlv + 0x07, 0x10, 0x00, 0x24, 0x01, 0x08, 0x11, 0x01, //ERO object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x02, 0x04, 0x00, 0x01, 0x08, 0x12, 0x01, + 0x01, 0x02, 0x04, 0x00, 0x01, 0x08, 0x12, 0x01, 0x01, 0x01, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20 }; //Metric object + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + + assertThat(testupdateMsg, is(updateMsg)); + } + + /** + * This test case checks for SRP, LSP (SymbolicPathNameTlv, StatefulIPv4LspIdentidiersTlv), + * ERO objects in PcUpd message. + */ + @Test + public void pcepUpdateMsgTest3() throws PcepParseException { + + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x38, + 0x21, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x20, 0x10, 0x00, 0x1C, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x07, 0x10, 0x00, 0x04 }; //ERO object + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + + assertThat(testupdateMsg, is(updateMsg)); + } + + /** + * This test case checks for SRP, LSP (SymbolicPathNameTlv, StatefulIPv4LspIdentidiersTlv, + * SymbolicPathNameTlv), ERO objects in PcUpd message. + */ + @Test + public void pcepUpdateMsgTest4() throws PcepParseException { + + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x40, + 0x21, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x20, 0x10, 0x00, 0x24, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x07, 0x10, 0x00, 0x04 }; //ERO object + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + + assertThat(testupdateMsg, is(updateMsg)); + } + + /** + * This test case checks for SRP, LSP (SymbolicPathNameTlv, StatefulIPv4LspIdentidiersTlv, + * SymbolicPathNameTlv), ERO objects in PcUpd message. + */ + @Test + public void pcepUpdateMsgTest5() throws PcepParseException { + + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x40, + 0x21, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x20, 0x10, 0x00, 0x24, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x07, 0x10, 0x00, 0x04 }; //ERO object + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + + assertThat(testupdateMsg, is(updateMsg)); + } + + /** + * This test case checks for SRP, LSP (SymbolicPathNameTlv, StatefulIPv4LspIdentidiersTlv, SymbolicPathNameTlv, + * StatefulLspErrorCodeTlv), ERO objects in PcUpd message. + */ + @Test + public void pcepUpdateMsgTest6() throws PcepParseException { + + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x48, + 0x21, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x20, 0x10, 0x00, 0x2c, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x00, 0x14, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, //StatefulLspErrorCodeTlv + 0x07, 0x10, 0x00, 0x04 }; + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + + assertThat(testupdateMsg, is(updateMsg)); + + } + + /** + * This test case checks for SRP, LSP (StatefulIPv4LspIdentidiersTlv, SymbolicPathNameTlv, + * StatefulLspErrorCodeTlv), ERO objects in PcUpd message. + */ + @Test + public void pcepUpdateMsgTest7() throws PcepParseException { + + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x48, + 0x21, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x20, 0x10, 0x00, 0x2c, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x00, 0x14, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, //StatefulLspErrorCodeTlv + 0x07, 0x10, 0x00, 0x04}; //ERO object + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + assertThat(testupdateMsg, is(updateMsg)); + } + + /** + * This test case checks for SRP, LSP (StatefulIPv4LspIdentidiersTlv, SymbolicPathNameTlv, + * StatefulLspErrorCodeTlv), ERO (IPv4SubObject) objects in PcUpd message. + */ + @Test + public void pcepUpdateMsgTest8() throws PcepParseException { + + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x50, + 0x21, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x20, 0x10, 0x00, 0x2c, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x00, 0x14, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, //StatefulLspErrorCodeTlv + 0x07, 0x10, 0x00, 0x0c, 0x01, 0x08, 0x11, 0x01, //ERO object + 0x01, 0x01, 0x04, 0x00 }; + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + + assertThat(testupdateMsg, is(updateMsg)); + } + + /** + * This test case checks for SRP, LSP (StatefulIPv4LspIdentidiersTlv, SymbolicPathNameTlv, + * StatefulLspErrorCodeTlv), ERO (IPv4SubObject, IPv4SubObject) objects in PcUpd message. + */ + @Test + public void pcepUpdateMsgTest9() throws PcepParseException { + + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x58, + 0x21, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x20, 0x10, 0x00, 0x2c, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x00, 0x14, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, //StatefulLspErrorCodeTlv + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x11, 0x01, //ERO object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x01, 0x04, 0x00 }; + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + + assertThat(testupdateMsg, is(updateMsg)); + } + + /** + * This test case checks for SRP, LSP (StatefulIPv4LspIdentidiersTlv, SymbolicPathNameTlv, + * StatefulLspErrorCodeTlv), ERO (IPv4SubObject, IPv4SubObject), LSPA objects in PcUpd message. + */ + @Test + public void pcepUpdateMsgTest10() throws PcepParseException { + + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x6c, + 0x21, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x20, 0x10, 0x00, 0x2c, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x00, 0x14, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, //StatefulLspErrorCodeTlv + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x11, 0x01, //ERO object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x01, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00 }; + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + + assertThat(testupdateMsg, is(updateMsg)); + } + + /** + * This test case checks for SRP, LSP (StatefulIPv4LspIdentidiersTlv, SymbolicPathNameTlv, + * StatefulLspErrorCodeTlv), ERO (IPv4SubObject, IPv4SubObject),LSPA, Metric objects in PcUpd message. + */ + @Test + public void pcepUpdateMsgTest11() throws PcepParseException { + + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x78, + 0x21, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x20, 0x10, 0x00, 0x2c, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x00, 0x14, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, //StatefulLspErrorCodeTlv + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x11, 0x01, //ERO object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x01, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20 }; //Metric object + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + + assertThat(testupdateMsg, is(updateMsg)); + } + + /** + * This test case checks for SRP, LSP (StatefulIPv4LspIdentidiersTlv, SymbolicPathNameTlv, + * StatefulLspErrorCodeTlv), ERO (IPv4SubObject, IPv4SubObject),LSPA, metric objects in PcUpd message. + */ + @Test + public void pcepUpdateMsgTest12() throws PcepParseException { + + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x70, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x2c, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x00, 0x14, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, //StatefulLspErrorCodeTlv + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x11, 0x01, //ERO object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x01, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20 }; //Metric object + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + + assertThat(testupdateMsg, is(updateMsg)); + } + + /** + * This test case checks for SRP, LSP (StatefulIPv4LspIdentidiersTlv, SymbolicPathNameTlv, + * StatefulLspErrorCodeTlv), ERO (IPv4SubObject, IPv4SubObject),LSPA, metric objects in PcUpd message. + */ + @Test + public void pcepUpdateMsgTest13() throws PcepParseException { + + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x70, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x2c, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x00, 0x14, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, //StatefulLspErrorCodeTlv + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x11, 0x01, //ERO object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x01, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20 }; //Metric object + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + + assertThat(testupdateMsg, is(updateMsg)); + } + + /** + * This test case checks for SRP, LSP (StatefulIPv4LspIdentidiersTlv, SymbolicPathNameTlv), + * ERO (IPv4SubObject, IPv4SubObject),LSPA, metric Object objects in PcUpd message. + */ + @Test + public void pcepUpdateMsgTest14() throws PcepParseException { + + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x68, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x24, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x11, 0x01, //ERO object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x01, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20 }; //Metric object + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + + assertThat(testupdateMsg, is(updateMsg)); + } + + /** + * This test case checks for SRP, LSP (StatefulIPv4LspIdentidiersTlv, SymbolicPathNameTlv), + * ERO (IPv4SubObject, IPv4SubObject),LSPA, metric objects in PcUpd message. + */ + @Test + public void pcepUpdateMsgTest15() throws PcepParseException { + + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x68, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x24, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x11, 0x01, //ERO object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x01, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20 }; //Metric object + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + + assertThat(testupdateMsg, is(updateMsg)); + } + + /** + * This test case checks for SRP, LSP (StatefulIPv4LspIdentidiersTlv), + * ERO (IPv4SubObject, IPv4SubObject),LSPA, metric objects in PcUpd message. + */ + @Test + public void pcepUpdateMsgTest16() throws PcepParseException { + + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x60, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x1C, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x11, 0x01, //ERO object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x01, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20 }; //Metric object + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + + assertThat(testupdateMsg, is(updateMsg)); + } + + /** + * This test case checks for SRP, LSP (StatefulIPv4LspIdentidiersTlv), + * ERO (IPv4SubObject, IPv4SubObject),LSPA objects in PcUpd message. + */ + @Test + public void pcepUpdateMsgTest17() throws PcepParseException { + + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x54, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x1c, 0x00, 0x00, 0x10, 0x05, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x11, 0x01, //ERO object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x01, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00 }; + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + + assertThat(testupdateMsg, is(updateMsg)); + } + + /** + * This test case checks for SRP, LSP (StatefulIPv4LspIdentidiersTlv), + * ERO (IPv4SubObject, IPv4SubObject),Metric objects in PcUpd message. + */ + @Test + public void pcepUpdateMsgTest18() throws PcepParseException { + + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x4c, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x1C, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x11, 0x01, //ERO object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x01, 0x04, 0x00, + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20 }; //Metric object + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + + assertThat(testupdateMsg, is(updateMsg)); + } + + /** + * This test case checks for SRP, LSP (StatefulIPv4LspIdentidiersTlv), + * ERO (IPv4SubObject, IPv4SubObject),Metric-list objects in PcUpd message. + */ + @Test + public void pcepUpdateMsgTest19() throws PcepParseException { + + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x58, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x1C, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x11, 0x01, //ERO object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x01, 0x04, 0x00, + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20, //Metric object + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01 }; //Metric object + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + + assertThat(testupdateMsg, is(updateMsg)); + } + + /** + * This test case checks for SRP, LSP (SymbolicPathNameTlv, StatefulIPv4LspIdentidiersTlv, SymbolicPathNameTlv, + * StatefulLspErrorCodeTlv),ERO (IPv4SubObject, IPv4SubObject),LSPA, Bandwidth, Metric objects in PcUpd message. + */ + @Test + public void pcepUpdateMsgTest20() throws PcepParseException { + + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x80, + 0x21, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x20, 0x10, 0x00, 0x2c, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x00, 0x14, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, //StatefulLspErrorCodeTlv + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x11, 0x01, //ERO object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x01, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, //Bandwidth object + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20 }; //Metric object + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + + assertThat(testupdateMsg, is(updateMsg)); + } + + /** + * This test case checks for SRP, LSP (StatefulIPv4LspIdentidiersTlv), + * ERO (IPv4SubObject, IPv4SubObject), Bandwidth objects in PcUpd message. + */ + @Test + public void pcepUpdateMsgTest21() throws PcepParseException { + + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x48, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x1C, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x11, 0x01, //ERO object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x01, 0x04, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00 }; //Bandwidth object + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + + assertThat(testupdateMsg, is(updateMsg)); + } + + /** + * This test case checks for SRP, LSP (StatefulIPv4LspIdentidiersTlv), + * ERO (IPv4SubObject, IPv4SubObject), LSPA, Bandwidth objects in PcUpd message. + */ + @Test + public void pcepUpdateMsgTest22() throws PcepParseException { + + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x5C, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x1C, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x11, 0x01, //ERO object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x01, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00 }; //Bandwidth object + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + + assertThat(testupdateMsg, is(updateMsg)); + } + + /** + * This test case checks for SRP, LSP (StatefulIPv4LspIdentidiersTlv), + * ERO (IPv4SubObject, IPv4SubObject), LSPA, Bandwidth, Metric objects in PcUpd message. + */ + @Test + public void pcepUpdateMsgTest23() throws PcepParseException { + + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x68, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x1C, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x11, 0x01, //ERO object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x01, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, //Bandwidth object + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20 }; //Metric object + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + + assertThat(testupdateMsg, is(updateMsg)); + } + + /** + * This test case checks for SRP, LSP (StatefulIPv4LspIdentidiersTlv, SymbolicPathNameTlv) + * ERO (IPv4SubObject, IPv4SubObject), LSPA, Bandwidth, Metric objects in PcUpd message. + */ + @Test + public void pcepUpdateMsgTest24() throws PcepParseException { + + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x70, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x24, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x11, 0x01, //ERO object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x01, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, //Bandwidth object + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20 }; //Metric object + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + + assertThat(testupdateMsg, is(updateMsg)); + } + + /** + * This test case checks for SRP, LSP (StatefulIPv4LspIdentidiersTlv, SymbolicPathNameTlv) + * ERO (IPv4SubObject, IPv4SubObject), LSPA, Bandwidth, Metric objects in PcUpd message. + */ + @Test + public void pcepUpdateMsgTest25() throws PcepParseException { + + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x70, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x24, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x11, 0x01, //ERO object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x01, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, //Bandwidth object + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20 }; //Metric object + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + + assertThat(testupdateMsg, is(updateMsg)); + } + + /** + * This test case checks for SRP, LSP (StatefulIPv4LspIdentidiersTlv, SymbolicPathNameTlv, + * StatefulLspErrorCodeTlv) ERO (IPv4SubObject, IPv4SubObject), LSPA, Bandwidth, + * Metric objects in PcUpd message. + */ + @Test + public void pcepUpdateMsgTest26() throws PcepParseException { + + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x78, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x2c, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x00, 0x14, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, //StatefulLspErrorCodeTlv + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x11, 0x01, //ERO object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x01, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, //Bandwidth object + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20 }; //Metric object + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + + assertThat(testupdateMsg, is(updateMsg)); + } + + /** + * This test case checks for SRP, LSP (StatefulIPv4LspIdentidiersTlv, SymbolicPathNameTlv, + * StatefulLspErrorCodeTlv) ERO (IPv4SubObject, IPv4SubObject), LSPA, Bandwidth, + * Metric objects in PcUpd message. + */ + @Test + public void pcepUpdateMsgTest27() throws PcepParseException { + + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x78, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x2c, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x00, 0x14, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, //StatefulLspErrorCodeTlv + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x11, 0x01, //ERO object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x01, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, //Bandwidth object + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20 }; //Metric object + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + + assertThat(testupdateMsg, is(updateMsg)); + } + + /** + * This test case checks for SRP, LSP (SymbolicPathNameTlv, StatefulIPv4LspIdentidiersTlv, + * SymbolicPathNameTlv, StatefulLspErrorCodeTlv), ERO (IPv4SubObject, IPv4SubObject), + * LSPA, Bandwidth, Metric objects in PcUpd message. + */ + @Test + public void pcepUpdateMsgTest28() throws PcepParseException { + + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x80, + 0x21, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x20, 0x10, 0x00, 0x2c, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x00, 0x14, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, //StatefulLspErrorCodeTlv + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x11, 0x01, //ERO object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x01, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, //Bandwidth object + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20 }; //Metric object + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + + assertThat(testupdateMsg, is(updateMsg)); + } + + /** + * This test case checks for SRP, LSP (StatefulIPv4LspIdentidiersTlv), + * ERO (IPv4SubObject, IPv4SubObject), LSPA, Bandwidth, Metric objects in PcUpd message. + */ + @Test + public void pcepUpdateMsgTest29() throws PcepParseException { + + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x68, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x1C, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x11, 0x01, //ERO object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x01, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, //Bandwidth object + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20 }; //Metric object + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + + assertThat(testupdateMsg, is(updateMsg)); + } + + /** + * This test case checks for SRP, LSP, + * ERO (IPv4SubObject, IPv4SubObject), LSPA, Bandwidth, Metric objects in PcUpd message. + */ + @Test + public void pcepUpdateMsgTest30() throws PcepParseException { + + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x54, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x08, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x11, 0x01, //ERO object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x01, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, //Bandwidth object + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20}; //Metric object + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + + assertThat(testupdateMsg, is(updateMsg)); + } + + /** + * This test case checks for SRP, LSP (StatefulLspErrorCodeTlv), + * ERO (IPv4SubObject, IPv4SubObject), LSPA, Bandwidth, Metric objects in PcUpd message. + */ + @Test + public void pcepUpdateMsgTest31() throws PcepParseException { + + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x5c, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x10, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x14, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, //StatefulLspErrorCodeTlv + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x11, 0x01, //ERO object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x01, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, //Bandwidth object + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20 }; //Metric object + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + + assertThat(testupdateMsg, is(updateMsg)); + } + + /** + * This test case checks for SRP, LSP, + * ERO (IPv4SubObject, IPv4SubObject), LSPA, Bandwidth, Metric objects in PcUpd message. + */ + @Test + public void pcepUpdateMsgTest32() throws PcepParseException { + + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x54, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x8, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x11, 0x01, //ERO object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x01, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, //Bandwidth object + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20 }; //Metric object + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + + assertThat(testupdateMsg, is(updateMsg)); + } + + /** + * This test case checks for SRP, LSP (SymbolicPathNameTlv), + * ERO (IPv4SubObject, IPv4SubObject), LSPA, Bandwidth, Metric objects in PcUpd message. + */ + @Test + public void pcepUpdateMsgTest33() throws PcepParseException { + + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x5c, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x10, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x11, 0x01, //ERO object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x01, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, //Bandwidth object + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20 }; //Metric object + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + + assertThat(testupdateMsg, is(updateMsg)); + } + + /** + * This test case checks for SRP, LSP (SymbolicPathNameTlv, SymbolicPathNameTlv), + * ERO (IPv4SubObject, IPv4SubObject), LSPA, Bandwidth, Metric objects in PcUpd message. + */ + @Test + public void pcepUpdateMsgTest34() throws PcepParseException { + + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x64, + 0x21, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x20, 0x10, 0x00, 0x10, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x11, 0x01, //ERO object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x01, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, //Bandwidth object + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20 }; //Metric object + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + + assertThat(testupdateMsg, is(updateMsg)); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/AdministrativeGroupTlvTest.java b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/AdministrativeGroupTlvTest.java new file mode 100644 index 00000000..41e88445 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/AdministrativeGroupTlvTest.java @@ -0,0 +1,36 @@ +/* + * 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.types; + +import com.google.common.testing.EqualsTester; +import org.junit.Test; + +/** + * Test of the AdministrativeGroupTlv. + */ +public class AdministrativeGroupTlvTest { + private final AdministrativeGroupTlv tlv1 = AdministrativeGroupTlv.of(1); + private final AdministrativeGroupTlv sameAsTlv1 = AdministrativeGroupTlv.of(1); + private final AdministrativeGroupTlv tlv2 = AdministrativeGroupTlv.of(2); + + @Test + public void basics() { + new EqualsTester() + .addEqualityGroup(tlv1, sameAsTlv1) + .addEqualityGroup(tlv2) + .testEquals(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/AutonomousSystemTlvTest.java b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/AutonomousSystemTlvTest.java new file mode 100644 index 00000000..904a71ef --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/AutonomousSystemTlvTest.java @@ -0,0 +1,36 @@ +/* + * 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.types; + +import com.google.common.testing.EqualsTester; +import org.junit.Test; + +/** + * Test of the AutonomousSystemTlv. + */ +public class AutonomousSystemTlvTest { + private final AutonomousSystemTlv tlv1 = AutonomousSystemTlv.of(1); + private final AutonomousSystemTlv sameAsTlv1 = AutonomousSystemTlv.of(1); + private final AutonomousSystemTlv tlv2 = AutonomousSystemTlv.of(2); + + @Test + public void basics() { + new EqualsTester() + .addEqualityGroup(tlv1, sameAsTlv1) + .addEqualityGroup(tlv2) + .testEquals(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/BGPLSidentifierTlvTest.java b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/BGPLSidentifierTlvTest.java new file mode 100644 index 00000000..7ac6cea4 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/BGPLSidentifierTlvTest.java @@ -0,0 +1,36 @@ +/* + * 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.types; + +import com.google.common.testing.EqualsTester; +import org.junit.Test; + +/** + * Test of the BGPLSidentifierTlv. + */ +public class BGPLSidentifierTlvTest { + private final BGPLSidentifierTlv tlv1 = BGPLSidentifierTlv.of(1); + private final BGPLSidentifierTlv sameAsTlv1 = BGPLSidentifierTlv.of(1); + private final BGPLSidentifierTlv tlv2 = BGPLSidentifierTlv.of(2); + + @Test + public void basics() { + new EqualsTester() + .addEqualityGroup(tlv1, sameAsTlv1) + .addEqualityGroup(tlv2) + .testEquals(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/GmplsCapabilityTlvTest.java b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/GmplsCapabilityTlvTest.java new file mode 100644 index 00000000..7972712f --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/GmplsCapabilityTlvTest.java @@ -0,0 +1,36 @@ +/* + * 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.types; + +import com.google.common.testing.EqualsTester; +import org.junit.Test; + +/** + * Test of the GmplsCapabilityTlv. + */ +public class GmplsCapabilityTlvTest { + private final GmplsCapabilityTlv tlv1 = GmplsCapabilityTlv.of(1); + private final GmplsCapabilityTlv sameAsTlv1 = GmplsCapabilityTlv.of(1); + private final GmplsCapabilityTlv tlv2 = GmplsCapabilityTlv.of(2); + + @Test + public void basics() { + new EqualsTester() + .addEqualityGroup(tlv1, sameAsTlv1) + .addEqualityGroup(tlv2) + .testEquals(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/IGPMetricTlvTest.java b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/IGPMetricTlvTest.java new file mode 100644 index 00000000..2715a4d7 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/IGPMetricTlvTest.java @@ -0,0 +1,38 @@ +/* + * 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.types; + +import com.google.common.testing.EqualsTester; +import org.junit.Test; + +/** + * Test of the IGPMetricTlv. + */ +public class IGPMetricTlvTest { + private final byte[] b1 = new byte[] {0x01, 0x02}; + private final byte[] b2 = new byte[] {0x01, 0x03}; + private final IGPMetricTlv tlv1 = IGPMetricTlv.of(b1, (short) 2); + private final IGPMetricTlv sameAsTlv1 = IGPMetricTlv.of(b1, (short) 2); + private final IGPMetricTlv tlv2 = IGPMetricTlv.of(b2, (short) 2); + + @Test + public void basics() { + new EqualsTester() + .addEqualityGroup(tlv1, sameAsTlv1) + .addEqualityGroup(tlv2) + .testEquals(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/IPv4InterfaceAddressTlvTest.java b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/IPv4InterfaceAddressTlvTest.java new file mode 100644 index 00000000..eb3a16a8 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/IPv4InterfaceAddressTlvTest.java @@ -0,0 +1,37 @@ +/* + * 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.types; + +import com.google.common.testing.EqualsTester; +import org.junit.Test; + +/** + * Test of the IPv4InterfaceAddressTlv. + */ +public class IPv4InterfaceAddressTlvTest { + + private final IPv4InterfaceAddressTlv tlv1 = IPv4InterfaceAddressTlv.of(2); + private final IPv4InterfaceAddressTlv sameAsTlv1 = IPv4InterfaceAddressTlv.of(2); + private final IPv4InterfaceAddressTlv tlv2 = IPv4InterfaceAddressTlv.of(3); + + @Test + public void basics() { + new EqualsTester() + .addEqualityGroup(tlv1, sameAsTlv1) + .addEqualityGroup(tlv2) + .testEquals(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/IPv4NeighborAddressTlvTest.java b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/IPv4NeighborAddressTlvTest.java new file mode 100644 index 00000000..5f10b4c1 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/IPv4NeighborAddressTlvTest.java @@ -0,0 +1,37 @@ +/* + * 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.types; + +import com.google.common.testing.EqualsTester; +import org.junit.Test; + +/** + * Test of the IPv4NeighborAddressTlv. + */ +public class IPv4NeighborAddressTlvTest { + + private final IPv4NeighborAddressTlv tlv1 = IPv4NeighborAddressTlv.of(2); + private final IPv4NeighborAddressTlv sameAsTlv1 = IPv4NeighborAddressTlv.of(2); + private final IPv4NeighborAddressTlv tlv2 = IPv4NeighborAddressTlv.of(3); + + @Test + public void basics() { + new EqualsTester() + .addEqualityGroup(tlv1, sameAsTlv1) + .addEqualityGroup(tlv2) + .testEquals(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/IPv4SubObjectTest.java b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/IPv4SubObjectTest.java new file mode 100644 index 00000000..10f54015 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/IPv4SubObjectTest.java @@ -0,0 +1,37 @@ +/* + * 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.types; + +import com.google.common.testing.EqualsTester; +import org.junit.Test; + +/** + * Test of the IPv4SubObject. + */ +public class IPv4SubObjectTest { + + private final IPv4SubObject subObj1 = IPv4SubObject.of(2, (byte) 16, (byte) 0); + private final IPv4SubObject sameAsSubObj1 = IPv4SubObject.of(2, (byte) 16, (byte) 0); + private final IPv4SubObject subObj2 = IPv4SubObject.of(3, (byte) 16, (byte) 0); + + @Test + public void basics() { + new EqualsTester() + .addEqualityGroup(subObj1, sameAsSubObj1) + .addEqualityGroup(subObj2) + .testEquals(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/IPv4TERouterIdOfLocalNodeTlvTest.java b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/IPv4TERouterIdOfLocalNodeTlvTest.java new file mode 100644 index 00000000..3880ca7f --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/IPv4TERouterIdOfLocalNodeTlvTest.java @@ -0,0 +1,37 @@ +/* + * 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.types; + +import com.google.common.testing.EqualsTester; +import org.junit.Test; + +/** + * Test of the IPv4TERouterIdOfLocalNodeTlv. + */ +public class IPv4TERouterIdOfLocalNodeTlvTest { + + private final IPv4TERouterIdOfLocalNodeTlv tlv1 = IPv4TERouterIdOfLocalNodeTlv.of(2); + private final IPv4TERouterIdOfLocalNodeTlv sameAsTlv1 = IPv4TERouterIdOfLocalNodeTlv.of(2); + private final IPv4TERouterIdOfLocalNodeTlv tlv2 = IPv4TERouterIdOfLocalNodeTlv.of(3); + + @Test + public void basics() { + new EqualsTester() + .addEqualityGroup(tlv1, sameAsTlv1) + .addEqualityGroup(tlv2) + .testEquals(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/IPv4TERouterIdOfRemoteNodeTlvTest.java b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/IPv4TERouterIdOfRemoteNodeTlvTest.java new file mode 100644 index 00000000..f40ede04 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/IPv4TERouterIdOfRemoteNodeTlvTest.java @@ -0,0 +1,37 @@ +/* + * 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.types; + +import com.google.common.testing.EqualsTester; +import org.junit.Test; + +/** + * Test of the IPv4TERouterIdOfRemoteNodeTlv. + */ +public class IPv4TERouterIdOfRemoteNodeTlvTest { + + private final IPv4TERouterIdOfRemoteNodeTlv tlv1 = IPv4TERouterIdOfRemoteNodeTlv.of(2); + private final IPv4TERouterIdOfRemoteNodeTlv sameAsTlv1 = IPv4TERouterIdOfRemoteNodeTlv.of(2); + private final IPv4TERouterIdOfRemoteNodeTlv tlv2 = IPv4TERouterIdOfRemoteNodeTlv.of(3); + + @Test + public void basics() { + new EqualsTester() + .addEqualityGroup(tlv1, sameAsTlv1) + .addEqualityGroup(tlv2) + .testEquals(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/IPv6InterfaceAddressTlvTest.java b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/IPv6InterfaceAddressTlvTest.java new file mode 100644 index 00000000..0f8e37c2 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/IPv6InterfaceAddressTlvTest.java @@ -0,0 +1,42 @@ +/* + * 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.types; + +import com.google.common.testing.EqualsTester; +import org.junit.Test; + +/** + * Test of the IPv6InterfaceAddressTlv. + */ +public class IPv6InterfaceAddressTlvTest { + + private final byte[] b1 = new byte[] {(byte) 0xFE, (byte) 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x02, + (byte) 0xB3, (byte) 0xFF, (byte) 0xFE, 0x1E, (byte) 0x83, 0x29, 0x00, 0x02, 0x00, 0x00}; + private final byte[] b2 = new byte[] {(byte) 0xFE, (byte) 0x80, 0x0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x02, + (byte) 0xB3, (byte) 0xFF, (byte) 0xFE, 0x1E, (byte) 0x83, 0x30, 0x00, 0x02, 0x00, 0x01}; + + private final IPv6InterfaceAddressTlv tlv1 = IPv6InterfaceAddressTlv.of(b1); + private final IPv6InterfaceAddressTlv sameAsTlv1 = IPv6InterfaceAddressTlv.of(b1); + private final IPv6InterfaceAddressTlv tlv2 = IPv6InterfaceAddressTlv.of(b2); + + @Test + public void basics() { + new EqualsTester() + .addEqualityGroup(tlv1, sameAsTlv1) + .addEqualityGroup(tlv2) + .testEquals(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/IPv6NeighborAddressTlvTest.java b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/IPv6NeighborAddressTlvTest.java new file mode 100644 index 00000000..57ad7695 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/IPv6NeighborAddressTlvTest.java @@ -0,0 +1,42 @@ +/* + * 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.types; + +import com.google.common.testing.EqualsTester; +import org.junit.Test; + +/** + * Test of the IPv6NeighborAddressTlv. + */ +public class IPv6NeighborAddressTlvTest { + + private final byte[] b1 = new byte[] {(byte) 0xFE, (byte) 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x02, + (byte) 0xB3, (byte) 0xFF, (byte) 0xFE, 0x1E, (byte) 0x83, 0x29, 0x00, 0x02, 0x00, 0x00}; + private final byte[] b2 = new byte[] {(byte) 0xFE, (byte) 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x02, + (byte) 0xB3, (byte) 0xFF, (byte) 0xFE, 0x1E, (byte) 0x83, 0x30, 0x00, 0x02, 0x00, 0x01}; + + private final IPv6NeighborAddressTlv tlv1 = IPv6NeighborAddressTlv.of(b1); + private final IPv6NeighborAddressTlv sameAsTlv1 = IPv6NeighborAddressTlv.of(b1); + private final IPv6NeighborAddressTlv tlv2 = IPv6NeighborAddressTlv.of(b2); + + @Test + public void basics() { + new EqualsTester() + .addEqualityGroup(tlv1, sameAsTlv1) + .addEqualityGroup(tlv2) + .testEquals(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/IPv6SubObjectTest.java b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/IPv6SubObjectTest.java new file mode 100644 index 00000000..f23b11d8 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/IPv6SubObjectTest.java @@ -0,0 +1,39 @@ +/* + * 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.types; + +import com.google.common.testing.EqualsTester; +import org.junit.Test; + +/** + * Test of the IPv6SubObject. + */ +public class IPv6SubObjectTest { + + private final byte[] b1 = new byte[] {(byte) 0xFE, (byte) 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x02, + (byte) 0xB3, (byte) 0xFF, (byte) 0xFE, 0x1E, (byte) 0x83, 0x29, 0x00, 0x02, 0x00, 0x00}; + private final byte[] b2 = new byte[] {(byte) 0xFE, (byte) 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x02, + (byte) 0xB3, (byte) 0xFF, (byte) 0xFE, 0x1E, (byte) 0x83, 0x30, 0x00, 0x02, 0x00, 0x00 }; + + private final IPv6SubObject subObj1 = IPv6SubObject.of(b1); + private final IPv6SubObject sameAsSubObj1 = IPv6SubObject.of(b1); + private final IPv6SubObject subObj2 = IPv6SubObject.of(b2); + + @Test + public void basics() { + new EqualsTester().addEqualityGroup(subObj1, sameAsSubObj1).addEqualityGroup(subObj2).testEquals(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/IPv6TERouterIdofLocalNodeTlvTest.java b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/IPv6TERouterIdofLocalNodeTlvTest.java new file mode 100644 index 00000000..6516ed3d --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/IPv6TERouterIdofLocalNodeTlvTest.java @@ -0,0 +1,42 @@ +/* + * 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.types; + +import com.google.common.testing.EqualsTester; +import org.junit.Test; + +/** + * Test of the IPv6TERouterIdofLocalNodeTlv. + */ +public class IPv6TERouterIdofLocalNodeTlvTest { + + private final byte[] b1 = new byte[] {(byte) 0xFE, (byte) 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x02, + (byte) 0xB3, (byte) 0xFF, (byte) 0xFE, 0x1E, (byte) 0x83, 0x29, 0x00, 0x02, 0x00, 0x00}; + private final byte[] b2 = new byte[] {(byte) 0xFE, (byte) 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x02, + (byte) 0xB3, (byte) 0xFF, (byte) 0xFE, 0x1E, (byte) 0x83, 0x30, 0x00, 0x02, 0x00, 0x00 }; + + private final IPv6TERouterIdofLocalNodeTlv tlv1 = IPv6TERouterIdofLocalNodeTlv.of(b1); + private final IPv6TERouterIdofLocalNodeTlv sameAsTlv1 = IPv6TERouterIdofLocalNodeTlv.of(b1); + private final IPv6TERouterIdofLocalNodeTlv tlv2 = IPv6TERouterIdofLocalNodeTlv.of(b2); + + @Test + public void basics() { + new EqualsTester() + .addEqualityGroup(tlv1, sameAsTlv1) + .addEqualityGroup(tlv2) + .testEquals(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/IPv6TERouterIdofRemoteNodeTlvTest.java b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/IPv6TERouterIdofRemoteNodeTlvTest.java new file mode 100644 index 00000000..f3828609 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/IPv6TERouterIdofRemoteNodeTlvTest.java @@ -0,0 +1,42 @@ +/* + * 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.types; + +import com.google.common.testing.EqualsTester; +import org.junit.Test; + +/** + * Test of the IPv6TERouterIdofRemoteNodeTlv. + */ +public class IPv6TERouterIdofRemoteNodeTlvTest { + + private final byte[] b1 = new byte[] {(byte) 0xFE, (byte) 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x02, + (byte) 0xB3, (byte) 0xFF, (byte) 0xFE, 0x1E, (byte) 0x83, 0x29, 0x00, 0x02, 0x00, 0x00}; + private final byte[] b2 = new byte[] {(byte) 0xFE, (byte) 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x02, + (byte) 0xB3, (byte) 0xFF, (byte) 0xFE, 0x1E, (byte) 0x83, 0x30, 0x00, 0x02, 0x00, 0x00 }; + + private final IPv6TERouterIdofRemoteNodeTlv tlv1 = IPv6TERouterIdofRemoteNodeTlv.of(b1); + private final IPv6TERouterIdofRemoteNodeTlv sameAsTlv1 = IPv6TERouterIdofRemoteNodeTlv.of(b1); + private final IPv6TERouterIdofRemoteNodeTlv tlv2 = IPv6TERouterIdofRemoteNodeTlv.of(b2); + + @Test + public void basics() { + new EqualsTester() + .addEqualityGroup(tlv1, sameAsTlv1) + .addEqualityGroup(tlv2) + .testEquals(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/ISISAreaIdentifierTlvTest.java b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/ISISAreaIdentifierTlvTest.java new file mode 100644 index 00000000..17584ac1 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/ISISAreaIdentifierTlvTest.java @@ -0,0 +1,40 @@ +/* + * 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.types; + +import com.google.common.testing.EqualsTester; +import org.junit.Test; + +/** + * Test of the ISISAreaIdentifierTlv. + */ +public class ISISAreaIdentifierTlvTest { + + private final byte[] b1 = new byte[] {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 }; + private final byte[] b2 = new byte[] {2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2 }; + + private final ISISAreaIdentifierTlv tlv1 = ISISAreaIdentifierTlv.of(b1, (short) 20); + private final ISISAreaIdentifierTlv sameAsTlv1 = ISISAreaIdentifierTlv.of(b1, (short) 20); + private final ISISAreaIdentifierTlv tlv2 = ISISAreaIdentifierTlv.of(b2, (short) 20); + + @Test + public void basics() { + new EqualsTester() + .addEqualityGroup(tlv1, sameAsTlv1) + .addEqualityGroup(tlv2) + .testEquals(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/LabelSubObjectTest.java b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/LabelSubObjectTest.java new file mode 100644 index 00000000..511d0a20 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/LabelSubObjectTest.java @@ -0,0 +1,37 @@ +/* + * 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.types; + +import com.google.common.testing.EqualsTester; +import org.junit.Test; + +/** + * Test of the LabelSubObject. + */ +public class LabelSubObjectTest { + + private final LabelSubObject subObj1 = LabelSubObject.of((byte) 0, (byte) 1, 20); + private final LabelSubObject sameAsSubObj1 = LabelSubObject.of((byte) 0, (byte) 1, 20); + private final LabelSubObject subObj2 = LabelSubObject.of((byte) 0, (byte) 1, 30); + + @Test + public void basics() { + new EqualsTester() + .addEqualityGroup(subObj1, sameAsSubObj1) + .addEqualityGroup(subObj2) + .testEquals(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/LinkLocalRemoteIdentifiersTlvTest.java b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/LinkLocalRemoteIdentifiersTlvTest.java new file mode 100644 index 00000000..e25bda02 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/LinkLocalRemoteIdentifiersTlvTest.java @@ -0,0 +1,37 @@ +/* + * 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.types; + +import com.google.common.testing.EqualsTester; +import org.junit.Test; + +/** + * Test of the LinkLocalRemoteIdentifiersTlv. + */ +public class LinkLocalRemoteIdentifiersTlvTest { + + private final LinkLocalRemoteIdentifiersTlv tlv1 = LinkLocalRemoteIdentifiersTlv.of(10, 20); + private final LinkLocalRemoteIdentifiersTlv sameAsTlv1 = LinkLocalRemoteIdentifiersTlv.of(10, 20); + private final LinkLocalRemoteIdentifiersTlv tlv2 = LinkLocalRemoteIdentifiersTlv.of(20, 30); + + @Test + public void basics() { + new EqualsTester() + .addEqualityGroup(tlv1, sameAsTlv1) + .addEqualityGroup(tlv2) + .testEquals(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/LinkNameTlvTest.java b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/LinkNameTlvTest.java new file mode 100644 index 00000000..7d9dcb26 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/LinkNameTlvTest.java @@ -0,0 +1,39 @@ +/* + * 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.types; + +import com.google.common.testing.EqualsTester; +import org.junit.Test; + +/** + * Equality test for LinkNameTlv. + */ +public class LinkNameTlvTest { + private final byte[] rawValue1 = new byte[] {0x01, 0x00}; + private final byte[] rawValue2 = new byte[] {0x02, 0x00}; + + private final LinkNameTlv tlv1 = new LinkNameTlv(rawValue1, (short) rawValue1.length); + private final LinkNameTlv sameAsTlv1 = LinkNameTlv.of(tlv1.getValue(), tlv1.getLength()); + private final LinkNameTlv tlv2 = new LinkNameTlv(rawValue2, (short) 0); + + @Test + public void basics() { + new EqualsTester() + .addEqualityGroup(tlv1, sameAsTlv1) + .addEqualityGroup(tlv2) + .testEquals(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/LinkProtectionTypeTlvTest.java b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/LinkProtectionTypeTlvTest.java new file mode 100644 index 00000000..61928f22 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/LinkProtectionTypeTlvTest.java @@ -0,0 +1,39 @@ +/* + * 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.types; + +import com.google.common.testing.EqualsTester; +import org.junit.Test; + +/** + * Test of the LinkProtectionTypeTlv. + */ +public class LinkProtectionTypeTlvTest { + private final byte rawValue1 = 0x0A; + private final byte rawValue2 = 0x0B; + + private final LinkProtectionTypeTlv tlv1 = new LinkProtectionTypeTlv(rawValue1); + private final LinkProtectionTypeTlv sameAsTlv1 = new LinkProtectionTypeTlv(rawValue1); + private final LinkProtectionTypeTlv tlv2 = new LinkProtectionTypeTlv(rawValue2, (byte) 0); + + @Test + public void basics() { + new EqualsTester() + .addEqualityGroup(tlv1, sameAsTlv1) + .addEqualityGroup(tlv2) + .testEquals(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/LocalTENodeDescriptorsTlvTest.java b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/LocalTENodeDescriptorsTlvTest.java new file mode 100644 index 00000000..e8b6abcc --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/LocalTENodeDescriptorsTlvTest.java @@ -0,0 +1,50 @@ +/* + * 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.types; + +import com.google.common.testing.EqualsTester; +import org.junit.Test; + +import java.util.LinkedList; + +/** + * Test of the LocalTENodeDescriptorsTlv. + */ +public class LocalTENodeDescriptorsTlvTest { + + private final AutonomousSystemTlv baAutoSysTlvRawValue1 = new AutonomousSystemTlv(1); + private final BGPLSidentifierTlv baBgplsIdRawValue1 = new BGPLSidentifierTlv(1); + + private final AutonomousSystemTlv baAutoSysTlvRawValue2 = new AutonomousSystemTlv(2); + private final BGPLSidentifierTlv baBgplsIdRawValue2 = new BGPLSidentifierTlv(2); + + private final LinkedList<PcepValueType> llNodeDescriptorSubTLVs1 = new LinkedList<PcepValueType>(); + private final boolean a = llNodeDescriptorSubTLVs1.add(baAutoSysTlvRawValue1); + private final boolean b = llNodeDescriptorSubTLVs1.add(baBgplsIdRawValue1); + + private final LinkedList<PcepValueType> llNodeDescriptorSubTLVs2 = new LinkedList<PcepValueType>(); + private final boolean c = llNodeDescriptorSubTLVs2.add(baAutoSysTlvRawValue2); + private final boolean d = llNodeDescriptorSubTLVs2.add(baBgplsIdRawValue2); + + private final LocalTENodeDescriptorsTlv tlv1 = LocalTENodeDescriptorsTlv.of(llNodeDescriptorSubTLVs1); + private final LocalTENodeDescriptorsTlv sameAstlv1 = LocalTENodeDescriptorsTlv.of(llNodeDescriptorSubTLVs1); + private final LocalTENodeDescriptorsTlv tlv2 = LocalTENodeDescriptorsTlv.of(llNodeDescriptorSubTLVs2); + + @Test + public void basics() { + new EqualsTester().addEqualityGroup(tlv1, sameAstlv1).addEqualityGroup(tlv2).testEquals(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/MPLSProtocolMaskTlvTest.java b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/MPLSProtocolMaskTlvTest.java new file mode 100644 index 00000000..5e79e284 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/MPLSProtocolMaskTlvTest.java @@ -0,0 +1,39 @@ +/* + * 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.types; + +import com.google.common.testing.EqualsTester; +import org.junit.Test; + +/** + * Test of the MPLSProtocolMaskTlv. + */ +public class MPLSProtocolMaskTlvTest { + private final byte rawValue1 = 0x0A; + private final byte rawValue2 = 0x0B; + + private final MPLSProtocolMaskTlv tlv1 = new MPLSProtocolMaskTlv(rawValue1); + private final MPLSProtocolMaskTlv sameAsTlv1 = new MPLSProtocolMaskTlv(rawValue1); + private final MPLSProtocolMaskTlv tlv2 = MPLSProtocolMaskTlv.of(rawValue2); + + @Test + public void basics() { + new EqualsTester() + .addEqualityGroup(tlv1, sameAsTlv1) + .addEqualityGroup(tlv2) + .testEquals(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/MaximumLinkBandwidthTlvTest.java b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/MaximumLinkBandwidthTlvTest.java new file mode 100644 index 00000000..4e022b82 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/MaximumLinkBandwidthTlvTest.java @@ -0,0 +1,39 @@ +/* + * 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.types; + +import com.google.common.testing.EqualsTester; +import org.junit.Test; + +/** + * Test of the MaximumLinkBandwidthTlv. + */ +public class MaximumLinkBandwidthTlvTest { + private final int rawValue1 = 0x0A; + private final int rawValue2 = 0x0B; + + private final MaximumLinkBandwidthTlv tlv1 = new MaximumLinkBandwidthTlv(rawValue1); + private final MaximumLinkBandwidthTlv sameAsTlv1 = new MaximumLinkBandwidthTlv(rawValue1); + private final MaximumLinkBandwidthTlv tlv2 = MaximumLinkBandwidthTlv.of(rawValue2); + + @Test + public void basics() { + new EqualsTester() + .addEqualityGroup(tlv1, sameAsTlv1) + .addEqualityGroup(tlv2) + .testEquals(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/MaximumReservableLinkBandwidthTlvTest.java b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/MaximumReservableLinkBandwidthTlvTest.java new file mode 100644 index 00000000..7b370359 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/MaximumReservableLinkBandwidthTlvTest.java @@ -0,0 +1,39 @@ +/* + * 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.types; + +import com.google.common.testing.EqualsTester; +import org.junit.Test; + +/** + * Test of the MaximumReservableLinkBandwidthTlv. + */ +public class MaximumReservableLinkBandwidthTlvTest { + private final int rawValue1 = 0x0A; + private final int rawValue2 = 0x0B; + + private final MaximumReservableLinkBandwidthTlv tlv1 = new MaximumReservableLinkBandwidthTlv(rawValue1); + private final MaximumReservableLinkBandwidthTlv sameAsTlv1 = new MaximumReservableLinkBandwidthTlv(rawValue1); + private final MaximumReservableLinkBandwidthTlv tlv2 = MaximumReservableLinkBandwidthTlv.of(rawValue2); + + @Test + public void basics() { + new EqualsTester() + .addEqualityGroup(tlv1, sameAsTlv1) + .addEqualityGroup(tlv2) + .testEquals(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/NexthopIPv4addressTlvTest.java b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/NexthopIPv4addressTlvTest.java new file mode 100644 index 00000000..39c699bc --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/NexthopIPv4addressTlvTest.java @@ -0,0 +1,37 @@ +/* + * 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.types; + +import com.google.common.testing.EqualsTester; +import org.junit.Test; + +/** + * Equality test for NexthopIPv4addressTlv. + */ +public class NexthopIPv4addressTlvTest { + + private final NexthopIPv4addressTlv tlv1 = new NexthopIPv4addressTlv(0x0A); + private final NexthopIPv4addressTlv sameAsTlv1 = new NexthopIPv4addressTlv(0x0A); + private final NexthopIPv4addressTlv tlv2 = NexthopIPv4addressTlv.of(0x0B); + + @Test + public void basics() { + new EqualsTester() + .addEqualityGroup(tlv1, sameAsTlv1) + .addEqualityGroup(tlv2) + .testEquals(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/NexthopIPv6addressTlvTest.java b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/NexthopIPv6addressTlvTest.java new file mode 100644 index 00000000..4621336e --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/NexthopIPv6addressTlvTest.java @@ -0,0 +1,41 @@ +/* + * 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.types; + +import com.google.common.testing.EqualsTester; +import org.junit.Test; + +/** + * Equality test for NexthopIPv6addressTlv. + */ +public class NexthopIPv6addressTlvTest { + + private final byte[] b1 = new byte[] {(byte) 0xFE, (byte) 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x02, + (byte) 0xB3, (byte) 0xFF, (byte) 0xFE, 0x1E, (byte) 0x83, 0x29, 0x00, 0x02, 0x00, 0x00 }; + private final byte[] b2 = new byte[] {(byte) 0xFE, (byte) 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x02, + (byte) 0xB3, (byte) 0xFF, (byte) 0xFE, 0x1E, (byte) 0x83, 0x30, 0x00, 0x02, 0x00, 0x00 }; + + private final NexthopIPv6addressTlv tlv1 = NexthopIPv6addressTlv.of(b1); + private final NexthopIPv6addressTlv sameAsTlv1 = NexthopIPv6addressTlv.of(b1); + private final NexthopIPv6addressTlv tlv2 = NexthopIPv6addressTlv.of(b2); + + @Test + public void basics() { + new EqualsTester().addEqualityGroup(tlv1, sameAsTlv1).addEqualityGroup(tlv2).testEquals(); + } + +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/NexthopUnnumberedIPv4IDTlvTest.java b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/NexthopUnnumberedIPv4IDTlvTest.java new file mode 100644 index 00000000..906c6526 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/NexthopUnnumberedIPv4IDTlvTest.java @@ -0,0 +1,37 @@ +/* + * 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.types; + +import com.google.common.testing.EqualsTester; +import org.junit.Test; + +/** + * Equality test for NexthopUnnumberedIPv4IDTlv. + */ +public class NexthopUnnumberedIPv4IDTlvTest { + + private final NexthopUnnumberedIPv4IDTlv tlv1 = new NexthopUnnumberedIPv4IDTlv(0x0A, 0x0A); + private final NexthopUnnumberedIPv4IDTlv sameAsTlv1 = new NexthopUnnumberedIPv4IDTlv(0x0A, 0x0A); + private final NexthopUnnumberedIPv4IDTlv tlv2 = NexthopUnnumberedIPv4IDTlv.of(0x0B, 0x0B); + + @Test + public void basics() { + new EqualsTester() + .addEqualityGroup(tlv1, sameAsTlv1) + .addEqualityGroup(tlv2) + .testEquals(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/NodeFlagBitsTlvTest.java b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/NodeFlagBitsTlvTest.java new file mode 100644 index 00000000..fb90fedb --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/NodeFlagBitsTlvTest.java @@ -0,0 +1,39 @@ +/* + * 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.types; + +import com.google.common.testing.EqualsTester; +import org.junit.Test; + +/** + * Test of the NodeFlagBitsTlv. + */ +public class NodeFlagBitsTlvTest { + private final byte rawValue1 = 0x0A; + private final byte rawValue2 = 0x0B; + + private final NodeFlagBitsTlv tlv1 = new NodeFlagBitsTlv(rawValue1); + private final NodeFlagBitsTlv sameAsTlv1 = new NodeFlagBitsTlv(rawValue1); + private final NodeFlagBitsTlv tlv2 = NodeFlagBitsTlv.of(rawValue2); + + @Test + public void basics() { + new EqualsTester() + .addEqualityGroup(tlv1, sameAsTlv1) + .addEqualityGroup(tlv2) + .testEquals(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/NodeNameTlvTest.java b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/NodeNameTlvTest.java new file mode 100644 index 00000000..d6d53d6f --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/NodeNameTlvTest.java @@ -0,0 +1,39 @@ +/* + * 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.types; + +import com.google.common.testing.EqualsTester; +import org.junit.Test; + +/** + * Test of the NodeNameTlv. + */ +public class NodeNameTlvTest { + private final byte[] rawValue1 = new byte[] {0x01, 0x02}; + private final byte[] rawValue2 = new byte[] {0x14, 0x15}; + + private final NodeNameTlv tlv1 = new NodeNameTlv(rawValue1, (short) rawValue1.length); + private final NodeNameTlv sameAsTlv1 = NodeNameTlv.of(tlv1.getValue(), tlv1.getLength()); + private final NodeNameTlv tlv2 = new NodeNameTlv(rawValue2, (short) 0); + + @Test + public void basics() { + new EqualsTester() + .addEqualityGroup(tlv1, sameAsTlv1) + .addEqualityGroup(tlv2) + .testEquals(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/OSPFareaIDsubTlvTest.java b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/OSPFareaIDsubTlvTest.java new file mode 100644 index 00000000..3f741ed6 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/OSPFareaIDsubTlvTest.java @@ -0,0 +1,36 @@ +/* + * 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.types; + +import com.google.common.testing.EqualsTester; +import org.junit.Test; + +/** + * Test of the OSPFareaIDsubTlv. + */ +public class OSPFareaIDsubTlvTest { + private final int rawValue1 = 0x0A; + + private final OSPFareaIDsubTlv tlv1 = new OSPFareaIDsubTlv(rawValue1); + private final OSPFareaIDsubTlv tlv2 = OSPFareaIDsubTlv.of(tlv1.getInt()); + + @Test + public void basics() { + new EqualsTester() + .addEqualityGroup(tlv1, tlv2) + .testEquals(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/OpaqueLinkAttributeTlvTest.java b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/OpaqueLinkAttributeTlvTest.java new file mode 100644 index 00000000..f437fb57 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/OpaqueLinkAttributeTlvTest.java @@ -0,0 +1,39 @@ +/* + * 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.types; + +import com.google.common.testing.EqualsTester; +import org.junit.Test; + +/** + * Test of the OpaqueLinkAttributeTlv. + */ +public class OpaqueLinkAttributeTlvTest { + private final byte[] rawValue1 = new byte[] {0x01, 0x02}; + private final byte[] rawValue2 = new byte[] {0x14, 0x15}; + + private final OpaqueLinkAttributeTlv tlv1 = new OpaqueLinkAttributeTlv(rawValue1, (short) rawValue1.length); + private final OpaqueLinkAttributeTlv sameAsTlv1 = OpaqueLinkAttributeTlv.of(tlv1.getValue(), tlv1.getLength()); + private final OpaqueLinkAttributeTlv tlv2 = new OpaqueLinkAttributeTlv(rawValue2, (short) 0); + + @Test + public void basics() { + new EqualsTester() + .addEqualityGroup(tlv1, sameAsTlv1) + .addEqualityGroup(tlv2) + .testEquals(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/PathKeySubObjectTest.java b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/PathKeySubObjectTest.java new file mode 100644 index 00000000..64cda54e --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/PathKeySubObjectTest.java @@ -0,0 +1,37 @@ +/* + * 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.types; + +import com.google.common.testing.EqualsTester; +import org.junit.Test; + +/** + * Test of the PathKeySubObject. + */ +public class PathKeySubObjectTest { + + private final PathKeySubObject tlv1 = new PathKeySubObject((short) 0x0A, 0x0A); + private final PathKeySubObject sameAsTlv1 = PathKeySubObject.of((short) 0x0A, 0x0A); + private final PathKeySubObject tlv2 = new PathKeySubObject((short) 0x0B, 0x0B); + + @Test + public void basics() { + new EqualsTester() + .addEqualityGroup(tlv1, sameAsTlv1) + .addEqualityGroup(tlv2) + .testEquals(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/PathSetupTypeTlvTest.java b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/PathSetupTypeTlvTest.java new file mode 100644 index 00000000..d82c943e --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/PathSetupTypeTlvTest.java @@ -0,0 +1,34 @@ +/* + * 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.types; + +import com.google.common.testing.EqualsTester; +import org.junit.Test; + +/** + * Test of the PathSetupTypeTlv. + */ +public class PathSetupTypeTlvTest { + + private final PathSetupTypeTlv tlv1 = PathSetupTypeTlv.of(0x0A); + private final PathSetupTypeTlv sameAsTlv1 = PathSetupTypeTlv.of(0x0A); + private final PathSetupTypeTlv tlv2 = PathSetupTypeTlv.of(0x0B); + + @Test + public void basics() { + new EqualsTester().addEqualityGroup(tlv1, sameAsTlv1).addEqualityGroup(tlv2).testEquals(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/PceccCapabilityTlvTest.java b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/PceccCapabilityTlvTest.java new file mode 100644 index 00000000..30892b18 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/PceccCapabilityTlvTest.java @@ -0,0 +1,39 @@ +/* + * 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.types; + +import com.google.common.testing.EqualsTester; +import org.junit.Test; + +/** + * Test of the PceccCapabilityTlv. + */ +public class PceccCapabilityTlvTest { + private final int rawValue1 = 0x0A; + private final int rawValue2 = 0x0B; + + private final PceccCapabilityTlv tlv1 = new PceccCapabilityTlv(rawValue1); + private final PceccCapabilityTlv sameAsTlv1 = new PceccCapabilityTlv(rawValue1); + private final PceccCapabilityTlv tlv2 = PceccCapabilityTlv.of(rawValue2); + + @Test + public void basics() { + new EqualsTester() + .addEqualityGroup(tlv1, sameAsTlv1) + .addEqualityGroup(tlv2) + .testEquals(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/PcepNaiIpv4AdjacencyTest.java b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/PcepNaiIpv4AdjacencyTest.java new file mode 100644 index 00000000..3ebc9a1e --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/PcepNaiIpv4AdjacencyTest.java @@ -0,0 +1,36 @@ +/* + * 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.types; + +import com.google.common.testing.EqualsTester; +import org.junit.Test; + +/** + * Equality test for PcepNaiIpv4Adjacency. + */ +public class PcepNaiIpv4AdjacencyTest { + + private final PcepNaiIpv4Adjacency obj1 = PcepNaiIpv4Adjacency.of(2, 16); + private final PcepNaiIpv4Adjacency sameAsObj1 = PcepNaiIpv4Adjacency.of(2, 16); + private final PcepNaiIpv4Adjacency obj2 = PcepNaiIpv4Adjacency.of(3, 16); + + @Test + public void basics() { + new EqualsTester().addEqualityGroup(obj1, sameAsObj1).addEqualityGroup(obj2).testEquals(); + } + +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/PcepNaiIpv4NodeIdTest.java b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/PcepNaiIpv4NodeIdTest.java new file mode 100644 index 00000000..5ea5edd6 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/PcepNaiIpv4NodeIdTest.java @@ -0,0 +1,34 @@ +/* + * 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.types; + +import com.google.common.testing.EqualsTester; +import org.junit.Test; + +public class PcepNaiIpv4NodeIdTest { + + private final PcepNaiIpv4NodeId tlv1 = PcepNaiIpv4NodeId.of(1); + private final PcepNaiIpv4NodeId tlv2 = PcepNaiIpv4NodeId.of(1); + private final PcepNaiIpv4NodeId tlv3 = PcepNaiIpv4NodeId.of(3); + + @Test + public void basics() { + new EqualsTester() + .addEqualityGroup(tlv1, tlv2) + .addEqualityGroup(tlv3) + .testEquals(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/PcepNaiIpv6AdjacencyTest.java b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/PcepNaiIpv6AdjacencyTest.java new file mode 100644 index 00000000..52c40f94 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/PcepNaiIpv6AdjacencyTest.java @@ -0,0 +1,37 @@ +/* + * 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.types; + +import com.google.common.testing.EqualsTester; +import org.junit.Test; + +public class PcepNaiIpv6AdjacencyTest { + private final byte[] localIpv6Addr1 = {(byte) 0x01010101 }; + private final byte[] remoteIpv6Addr1 = {(byte) 0x02020202 }; + private final byte[] localIpv6Addr2 = {(byte) 0x01010101 }; + private final byte[] remoteIpv6Addr2 = {(byte) 0x02020202 }; + private final byte[] localIpv6Addr3 = {(byte) 0x05050505 }; + private final byte[] remoteIpv6Addr3 = {(byte) 0x06060606 }; + + private final PcepNaiIpv6Adjacency tlv1 = PcepNaiIpv6Adjacency.of(localIpv6Addr1, remoteIpv6Addr1); + private final PcepNaiIpv6Adjacency tlv2 = PcepNaiIpv6Adjacency.of(localIpv6Addr1, remoteIpv6Addr1); + private final PcepNaiIpv6Adjacency tlv3 = PcepNaiIpv6Adjacency.of(localIpv6Addr3, remoteIpv6Addr3); + + @Test + public void basics() { + new EqualsTester().addEqualityGroup(tlv1, tlv2).addEqualityGroup(tlv3).testEquals(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/PcepNaiIpv6NodeIdTest.java b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/PcepNaiIpv6NodeIdTest.java new file mode 100644 index 00000000..29771a0f --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/PcepNaiIpv6NodeIdTest.java @@ -0,0 +1,43 @@ +/* + * 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.types; + +import com.google.common.testing.EqualsTester; +import org.junit.Test; + +/** + * Equality test for PcepNaiIpv6NodeId. + */ +public class PcepNaiIpv6NodeIdTest { + + private final byte[] b1 = new byte[] {(byte) 0xFE, (byte) 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x02, + (byte) 0xB3, (byte) 0xFF, (byte) 0xFE, 0x1E, (byte) 0x83, 0x29, 0x00, 0x02, + 0x00, 0x00 }; + private final byte[] b2 = new byte[] {(byte) 0xFE, (byte) 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x02, + (byte) 0xB3, (byte) 0xFF, (byte) 0xFE, 0x1E, (byte) 0x83, 0x30, 0x00, 0x02, + 0x00, 0x00 }; + + private final PcepNaiIpv6NodeId tlv1 = PcepNaiIpv6NodeId.of(b1); + private final PcepNaiIpv6NodeId sameAsTlv1 = PcepNaiIpv6NodeId.of(b1); + private final PcepNaiIpv6NodeId tlv2 = PcepNaiIpv6NodeId.of(b2); + + @Test + public void basics() { + new EqualsTester().addEqualityGroup(tlv1, sameAsTlv1).addEqualityGroup(tlv2).testEquals(); + } + +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/PcepNaiUnnumberedAdjacencyIpv4Test.java b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/PcepNaiUnnumberedAdjacencyIpv4Test.java new file mode 100644 index 00000000..60ae22fd --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/PcepNaiUnnumberedAdjacencyIpv4Test.java @@ -0,0 +1,49 @@ +/* + * 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.types; + +import com.google.common.testing.EqualsTester; +import org.junit.Test; + +public class PcepNaiUnnumberedAdjacencyIpv4Test { + + private final int localNodeId1 = 1; + private final int localInterfaceId1 = 1; + private final int remoteNodeId1 = 1; + private final int remoteInterfaceId1 = 1; + private final PcepNaiUnnumberedAdjacencyIpv4 tlv1 = PcepNaiUnnumberedAdjacencyIpv4.of(localNodeId1, + localInterfaceId1, remoteNodeId1, remoteInterfaceId1); + + private final int localNodeId2 = 1; + private final int localInterfaceId2 = 1; + private final int remoteNodeId2 = 1; + private final int remoteInterfaceId2 = 1; + private final PcepNaiUnnumberedAdjacencyIpv4 tlv2 = PcepNaiUnnumberedAdjacencyIpv4.of(localNodeId2, + localInterfaceId2, remoteNodeId2, remoteInterfaceId2); + + private final int localNodeId3 = 2; + private final int localInterfaceId3 = 2; + private final int remoteNodeId3 = 2; + private final int remoteInterfaceId3 = 2; + + private final PcepNaiUnnumberedAdjacencyIpv4 tlv3 = PcepNaiUnnumberedAdjacencyIpv4.of(localNodeId3, + localInterfaceId3, remoteNodeId3, remoteInterfaceId3); + + @Test + public void basics() { + new EqualsTester().addEqualityGroup(tlv1, tlv2).addEqualityGroup(tlv3).testEquals(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/RemoteTENodeDescriptorsTlvTest.java b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/RemoteTENodeDescriptorsTlvTest.java new file mode 100644 index 00000000..112e4a4e --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/RemoteTENodeDescriptorsTlvTest.java @@ -0,0 +1,52 @@ +/* + * 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.types; + +import com.google.common.testing.EqualsTester; +import org.junit.Test; + +import java.util.LinkedList; + +/** + * Test case for Remote TE Node Descriptors tlv. + */ +public class RemoteTENodeDescriptorsTlvTest { + + private final AutonomousSystemTlv autonomousSystemTlv1 = new AutonomousSystemTlv(10); + private final BGPLSidentifierTlv bGPLSidentifierTlv1 = new BGPLSidentifierTlv(20); + + private final AutonomousSystemTlv autonomousSystemTlv2 = new AutonomousSystemTlv(20); + private final BGPLSidentifierTlv bGPLSidentifierTlv2 = new BGPLSidentifierTlv(30); + + private final LinkedList<PcepValueType> llRemoteTENodeDescriptorSubTLV1 = new LinkedList<>(); + private final boolean a = llRemoteTENodeDescriptorSubTLV1.add(autonomousSystemTlv1); + private final boolean b = llRemoteTENodeDescriptorSubTLV1.add(bGPLSidentifierTlv1); + + private final LinkedList<PcepValueType> llRemoteTENodeDescriptorSubTLV2 = new LinkedList<>(); + private final boolean c = llRemoteTENodeDescriptorSubTLV2.add(autonomousSystemTlv2); + private final boolean d = llRemoteTENodeDescriptorSubTLV2.add(bGPLSidentifierTlv2); + + private final RemoteTENodeDescriptorsTlv tlv1 = RemoteTENodeDescriptorsTlv.of(llRemoteTENodeDescriptorSubTLV1); + private final RemoteTENodeDescriptorsTlv sameAsTlv1 = + RemoteTENodeDescriptorsTlv.of(llRemoteTENodeDescriptorSubTLV1); + private final RemoteTENodeDescriptorsTlv tlv2 = RemoteTENodeDescriptorsTlv.of(llRemoteTENodeDescriptorSubTLV2); + + @Test + public void basics() { + new EqualsTester().addEqualityGroup(tlv1, sameAsTlv1).addEqualityGroup(tlv2).testEquals(); + } + +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/RouterIDSubTlvTest.java b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/RouterIDSubTlvTest.java new file mode 100644 index 00000000..2f9e18a9 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/RouterIDSubTlvTest.java @@ -0,0 +1,42 @@ +/* + * 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.types; + +import com.google.common.testing.EqualsTester; +import org.junit.Test; + +/** + * Test case for Router ID Sub tlv. + */ +public class RouterIDSubTlvTest { + + private final byte[] value1 = {1, 2 }; + private final Short length1 = 2; + private final RouterIDSubTlv tlv1 = RouterIDSubTlv.of(value1, length1); + + private final Short length2 = 2; + private final RouterIDSubTlv tlv2 = RouterIDSubTlv.of(value1, length2); + + private final byte[] value3 = {1, 2, 3 }; + private final Short length3 = 3; + private final RouterIDSubTlv tlv3 = RouterIDSubTlv.of(value3, length3); + + @Test + public void basics() { + new EqualsTester().addEqualityGroup(tlv1, tlv2).addEqualityGroup(tlv3).testEquals(); + } + +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/RoutingUniverseTlvTest.java b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/RoutingUniverseTlvTest.java new file mode 100644 index 00000000..18aa2851 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/RoutingUniverseTlvTest.java @@ -0,0 +1,35 @@ +/* + * 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.types; + +import com.google.common.testing.EqualsTester; +import org.junit.Test; + +/** + * Equality test for RoutingUniverseTlv. + */ +public class RoutingUniverseTlvTest { + + private final RoutingUniverseTlv tlv1 = RoutingUniverseTlv.of(2); + private final RoutingUniverseTlv tlv2 = RoutingUniverseTlv.of(2); + private final RoutingUniverseTlv tlv3 = RoutingUniverseTlv.of(3); + + @Test + public void basics() { + new EqualsTester().addEqualityGroup(tlv1, tlv2).addEqualityGroup(tlv3).testEquals(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/SharedRiskLinkGroupTlvTest.java b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/SharedRiskLinkGroupTlvTest.java new file mode 100644 index 00000000..7c8ec570 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/SharedRiskLinkGroupTlvTest.java @@ -0,0 +1,41 @@ +/* + * 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.types; + +import com.google.common.testing.EqualsTester; +import org.junit.Test; + +/** + * Test case for Shared Risk Link Group tlv. + */ +public class SharedRiskLinkGroupTlvTest { + + private final int[] raw = {1 }; + private final Short hLength = 2; + private final SharedRiskLinkGroupTlv tlv1 = SharedRiskLinkGroupTlv.of(raw, hLength); + + private final SharedRiskLinkGroupTlv sameAsTlv1 = SharedRiskLinkGroupTlv.of(raw, hLength); + + private final int[] raw2 = {2 }; + private final Short hLength2 = 3; + private final SharedRiskLinkGroupTlv tlv2 = SharedRiskLinkGroupTlv.of(raw2, hLength2); + + @Test + public void basics() { + new EqualsTester().addEqualityGroup(tlv1, sameAsTlv1).addEqualityGroup(tlv2).testEquals(); + } + +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/SrEroSubObjectTest.java b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/SrEroSubObjectTest.java new file mode 100644 index 00000000..d91569b9 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/SrEroSubObjectTest.java @@ -0,0 +1,59 @@ +/* + * 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.types; + +import com.google.common.testing.EqualsTester; +import org.junit.Test; +import org.onosproject.pcepio.protocol.PcepNai; + +public class SrEroSubObjectTest { + + private final boolean bFFlag = false; + private final boolean bSFlag = false; + private final boolean bCFlag = false; + private final boolean bMFlag = false; + private final byte st = 1; + private final int sID = 1; + private final PcepNai nai = null; + + private final SrEroSubObject tlv1 = SrEroSubObject.of(st, bFFlag, bSFlag, bCFlag, bMFlag, sID, nai); + + private final boolean bFFlag1 = false; + private final boolean bSFlag1 = false; + private final boolean bCFlag1 = false; + private final boolean bMFlag1 = false; + private final byte st1 = 1; + private final int sID1 = 1; + private final PcepNai nai1 = null; + + private final SrEroSubObject tlv2 = SrEroSubObject.of(st1, bFFlag1, bSFlag1, bCFlag1, bMFlag1, sID1, nai1); + + private final boolean bFFlag2 = true; + private final boolean bSFlag2 = true; + private final boolean bCFlag2 = true; + private final boolean bMFlag2 = true; + private final byte st2 = 2; + private final int sID2 = 2; + private final PcepNai nai2 = null; + + private final SrEroSubObject tlv3 = SrEroSubObject.of(st2, bFFlag2, bSFlag2, bCFlag2, bMFlag2, sID2, nai2); + + @Test + public void basics() { + new EqualsTester().addEqualityGroup(tlv1, tlv2).addEqualityGroup(tlv3).testEquals(); + } + +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/StatefulIPv4LspIdentidiersTlvTest.java b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/StatefulIPv4LspIdentidiersTlvTest.java new file mode 100644 index 00000000..d1798fa3 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/StatefulIPv4LspIdentidiersTlvTest.java @@ -0,0 +1,55 @@ +/* + * 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.types; + +import com.google.common.testing.EqualsTester; +import org.junit.Test; + +public class StatefulIPv4LspIdentidiersTlvTest { + + private final int ipv4IngressAddress = 1; + private final short lspId = 1; + private final short tunnelId = 1; + private final int extendedTunnelId = 1; + private final int ipv4EgressAddress = 1; + + private final StatefulIPv4LspIdentidiersTlv tlv1 = StatefulIPv4LspIdentidiersTlv.of(ipv4IngressAddress, lspId, + tunnelId, extendedTunnelId, ipv4EgressAddress); + + private final int ipv4IngressAddress1 = 1; + private final short lspId1 = 1; + private final short tunnelId1 = 1; + private final int extendedTunnelId1 = 1; + private final int ipv4EgressAddress1 = 1; + + private final StatefulIPv4LspIdentidiersTlv tlv2 = StatefulIPv4LspIdentidiersTlv.of(ipv4IngressAddress1, lspId1, + tunnelId1, extendedTunnelId1, ipv4EgressAddress1); + + private final int ipv4IngressAddress2 = 2; + private final short lspId2 = 2; + private final short tunnelId2 = 2; + private final int extendedTunnelId2 = 2; + private final int ipv4EgressAddress2 = 2; + + private final StatefulIPv4LspIdentidiersTlv tlv3 = StatefulIPv4LspIdentidiersTlv.of(ipv4IngressAddress2, lspId2, + tunnelId2, extendedTunnelId2, ipv4EgressAddress2); + + @Test + public void basics() { + new EqualsTester().addEqualityGroup(tlv1, tlv2).addEqualityGroup(tlv3).testEquals(); + + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/StatefulLspDbVerTlvTest.java b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/StatefulLspDbVerTlvTest.java new file mode 100644 index 00000000..7076bc9e --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/StatefulLspDbVerTlvTest.java @@ -0,0 +1,35 @@ +/* + * 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.types; + +import com.google.common.testing.EqualsTester; +import org.junit.Test; + +/** + * Test case for Stateful Lsp Db Ver tlv. + */ +public class StatefulLspDbVerTlvTest { + + private final StatefulLspDbVerTlv tlv1 = StatefulLspDbVerTlv.of(1); + private final StatefulLspDbVerTlv tlv2 = StatefulLspDbVerTlv.of(1); + private final StatefulLspDbVerTlv tlv3 = StatefulLspDbVerTlv.of(2); + + @Test + public void basics() { + new EqualsTester().addEqualityGroup(tlv1, tlv2).addEqualityGroup(tlv3).testEquals(); + } + +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/StatefulLspErrorCodeTlvTest.java b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/StatefulLspErrorCodeTlvTest.java new file mode 100644 index 00000000..039108ae --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/StatefulLspErrorCodeTlvTest.java @@ -0,0 +1,31 @@ +/* + * 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.types; + +import com.google.common.testing.EqualsTester; +import org.junit.Test; + +public class StatefulLspErrorCodeTlvTest { + + private final StatefulLspErrorCodeTlv tlv1 = StatefulLspErrorCodeTlv.of(1); + private final StatefulLspErrorCodeTlv tlv2 = StatefulLspErrorCodeTlv.of(1); + private final StatefulLspErrorCodeTlv tlv3 = StatefulLspErrorCodeTlv.of(2); + + @Test + public void basics() { + new EqualsTester().addEqualityGroup(tlv1, tlv2).addEqualityGroup(tlv3).testEquals(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/StatefulPceCapabilityTlvTest.java b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/StatefulPceCapabilityTlvTest.java new file mode 100644 index 00000000..8637024c --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/StatefulPceCapabilityTlvTest.java @@ -0,0 +1,34 @@ +/* + * 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.types; + +import com.google.common.testing.EqualsTester; +import org.junit.Test; + +/** + * Test case for Stateful Pce Capability tlv. + */ +public class StatefulPceCapabilityTlvTest { + + private final StatefulPceCapabilityTlv tlv1 = StatefulPceCapabilityTlv.of(1); + private final StatefulPceCapabilityTlv tlv2 = StatefulPceCapabilityTlv.of(1); + private final StatefulPceCapabilityTlv tlv3 = StatefulPceCapabilityTlv.of(2); + + @Test + public void basics() { + new EqualsTester().addEqualityGroup(tlv1, tlv2).addEqualityGroup(tlv3).testEquals(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/SymbolicPathNameTlvTest.java b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/SymbolicPathNameTlvTest.java new file mode 100644 index 00000000..8d458f4e --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/SymbolicPathNameTlvTest.java @@ -0,0 +1,43 @@ +/* + * 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.types; + +import com.google.common.testing.EqualsTester; +import org.junit.Test; + +/** + * Test case for Symbolic path tlv. + */ +public class SymbolicPathNameTlvTest { + + private final byte[] value1 = {0x41 }; + private final Short length1 = 2; + private final SymbolicPathNameTlv tlv1 = SymbolicPathNameTlv.of(value1, length1); + + private final byte[] value2 = {0x41 }; + private final Short length2 = 2; + private final SymbolicPathNameTlv tlv2 = SymbolicPathNameTlv.of(value1, length2); + + private final byte[] value3 = {0x41, 0x43 }; + private final Short length3 = 3; + private final SymbolicPathNameTlv tlv3 = SymbolicPathNameTlv.of(value3, length3); + + @Test + public void basics() { + new EqualsTester().addEqualityGroup(tlv1, tlv2).addEqualityGroup(tlv3).testEquals(); + } + +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/TEDefaultMetricTlvTest.java b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/TEDefaultMetricTlvTest.java new file mode 100644 index 00000000..c46b0af1 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/TEDefaultMetricTlvTest.java @@ -0,0 +1,34 @@ +/* + * 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.types; + +import com.google.common.testing.EqualsTester; +import org.junit.Test; + +/** + * Test case for TE Default Metric tlv. + */ +public class TEDefaultMetricTlvTest { + + private final TEDefaultMetricTlv tlv1 = TEDefaultMetricTlv.of(1); + private final TEDefaultMetricTlv tlv2 = TEDefaultMetricTlv.of(1); + private final TEDefaultMetricTlv tlv3 = TEDefaultMetricTlv.of(2); + + @Test + public void basics() { + new EqualsTester().addEqualityGroup(tlv1, tlv2).addEqualityGroup(tlv3).testEquals(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/TELinkAttributesTlvTest.java b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/TELinkAttributesTlvTest.java new file mode 100644 index 00000000..8504a87c --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/TELinkAttributesTlvTest.java @@ -0,0 +1,54 @@ +/* + * 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.types; + +import com.google.common.testing.EqualsTester; +import org.junit.Test; + +import java.util.LinkedList; + +/** + * Test case for TE Link Attribute Tlv. + */ +public class TELinkAttributesTlvTest { + + private final AdministrativeGroupTlv administrativeGroupTlv1 = new AdministrativeGroupTlv(10); + private final MaximumReservableLinkBandwidthTlv maximumReservableLinkBandwidthTlv1 = + new MaximumReservableLinkBandwidthTlv(20); + + private final AdministrativeGroupTlv administrativeGroupTlv2 = new AdministrativeGroupTlv(20); + private final MaximumReservableLinkBandwidthTlv maximumReservableLinkBandwidthTlv2 = + new MaximumReservableLinkBandwidthTlv(30); + + private final LinkedList<PcepValueType> llLinkAttributesSubTLV1 = new LinkedList<>(); + private final boolean a = llLinkAttributesSubTLV1.add(administrativeGroupTlv1); + private final boolean b = llLinkAttributesSubTLV1.add(maximumReservableLinkBandwidthTlv1); + + private final LinkedList<PcepValueType> llLinkAttributesSubTLV2 = new LinkedList<>(); + + private final boolean c = llLinkAttributesSubTLV2.add(administrativeGroupTlv2); + private final boolean d = llLinkAttributesSubTLV2.add(maximumReservableLinkBandwidthTlv2); + + private final TELinkAttributesTlv tlv1 = TELinkAttributesTlv.of(llLinkAttributesSubTLV1); + private final TELinkAttributesTlv sameAsTlv1 = TELinkAttributesTlv.of(llLinkAttributesSubTLV1); + private final TELinkAttributesTlv tlv2 = TELinkAttributesTlv.of(llLinkAttributesSubTLV2); + + @Test + public void basics() { + new EqualsTester().addEqualityGroup(tlv1, sameAsTlv1).addEqualityGroup(tlv2).testEquals(); + } + +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/TELinkDescriptorsTlvTest.java b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/TELinkDescriptorsTlvTest.java new file mode 100644 index 00000000..4e942097 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/TELinkDescriptorsTlvTest.java @@ -0,0 +1,52 @@ +/* + * 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.types; + +import com.google.common.testing.EqualsTester; +import org.junit.Test; + +import java.util.LinkedList; + +/** + * Test case for TE link descriptors Tlv. + */ +public class TELinkDescriptorsTlvTest { + private final LinkLocalRemoteIdentifiersTlv linkLocalRemoteIdentifiersTlv1 = new + LinkLocalRemoteIdentifiersTlv(10, 10); + private final IPv4InterfaceAddressTlv iPv4InterfaceAddressTlv1 = new IPv4InterfaceAddressTlv(0x01010101); + + private final LinkLocalRemoteIdentifiersTlv linkLocalRemoteIdentifiersTlv2 = new + LinkLocalRemoteIdentifiersTlv(20, 20); + private final IPv4InterfaceAddressTlv iPv4InterfaceAddressTlv2 = new IPv4InterfaceAddressTlv(0x02020202); + + private final LinkedList<PcepValueType> llLinkDescriptorsSubTLVs1 = new LinkedList<>(); + private final boolean a = llLinkDescriptorsSubTLVs1.add(linkLocalRemoteIdentifiersTlv1); + private final boolean b = llLinkDescriptorsSubTLVs1.add(iPv4InterfaceAddressTlv1); + + private final LinkedList<PcepValueType> llLinkDescriptorsSubTLVs2 = new LinkedList<>(); + private final boolean c = llLinkDescriptorsSubTLVs2.add(linkLocalRemoteIdentifiersTlv2); + private final boolean d = llLinkDescriptorsSubTLVs2.add(iPv4InterfaceAddressTlv2); + + private final TELinkDescriptorsTlv tlv1 = TELinkDescriptorsTlv.of(llLinkDescriptorsSubTLVs1); + private final TELinkDescriptorsTlv sameAstlv1 = TELinkDescriptorsTlv.of(llLinkDescriptorsSubTLVs1); + private final TELinkDescriptorsTlv tlv2 = TELinkDescriptorsTlv.of(llLinkDescriptorsSubTLVs2); + + @Test + public void basics() { + new EqualsTester().addEqualityGroup(tlv1, sameAstlv1).addEqualityGroup(tlv2).testEquals(); + } + +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/TENodeAttributesTlvTest.java b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/TENodeAttributesTlvTest.java new file mode 100644 index 00000000..28cf27d4 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/TENodeAttributesTlvTest.java @@ -0,0 +1,54 @@ +/* + * 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.types; + +import com.google.common.testing.EqualsTester; +import org.junit.Test; + +import java.util.LinkedList; + +/** + * Test case for TE Node Attribute tlv. + */ +public class TENodeAttributesTlvTest { + + private final NodeFlagBitsTlv nodeFlagBitsTlv1 = new NodeFlagBitsTlv((byte) 10); + private final IPv4TERouterIdOfLocalNodeTlv iPv4TERouterIdOfLocalNodeTlv1 = new + IPv4TERouterIdOfLocalNodeTlv(0x01010101); + + private final NodeFlagBitsTlv nodeFlagBitsTlv2 = new NodeFlagBitsTlv((byte) 20); + private final IPv4TERouterIdOfLocalNodeTlv iPv4TERouterIdOfLocalNodeTlv2 = new + IPv4TERouterIdOfLocalNodeTlv(0x02020202); + + private final LinkedList<PcepValueType> llNodeAttributesSubTLV1 = new LinkedList<>(); + private final boolean a = llNodeAttributesSubTLV1.add(nodeFlagBitsTlv1); + private final boolean b = llNodeAttributesSubTLV1.add(iPv4TERouterIdOfLocalNodeTlv1); + + private final LinkedList<PcepValueType> llNodeAttributesSubTLV2 = new LinkedList<>(); + + private final boolean c = llNodeAttributesSubTLV2.add(nodeFlagBitsTlv2); + private final boolean d = llNodeAttributesSubTLV2.add(iPv4TERouterIdOfLocalNodeTlv2); + + private final TENodeAttributesTlv tlv1 = TENodeAttributesTlv.of(llNodeAttributesSubTLV1); + private final TENodeAttributesTlv sameAsTlv1 = TENodeAttributesTlv.of(llNodeAttributesSubTLV1); + private final TENodeAttributesTlv tlv2 = TENodeAttributesTlv.of(llNodeAttributesSubTLV2); + + @Test + public void basics() { + new EqualsTester().addEqualityGroup(tlv1, sameAsTlv1).addEqualityGroup(tlv2).testEquals(); + } + +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/TedCapabilityTlvTest.java b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/TedCapabilityTlvTest.java new file mode 100644 index 00000000..18677ca3 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/TedCapabilityTlvTest.java @@ -0,0 +1,34 @@ +/* + * 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.types; + +import com.google.common.testing.EqualsTester; +import org.junit.Test; + +/** + * Test case for TED Capability tlv. + */ +public class TedCapabilityTlvTest { + + private final TedCapabilityTlv tlv1 = TedCapabilityTlv.of(1); + private final TedCapabilityTlv tlv2 = TedCapabilityTlv.of(1); + private final TedCapabilityTlv tlv3 = TedCapabilityTlv.of(2); + + @Test + public void basics() { + new EqualsTester().addEqualityGroup(tlv1, tlv2).addEqualityGroup(tlv3).testEquals(); + } +} diff --git a/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/UnreservedBandwidthTlvTest.java b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/UnreservedBandwidthTlvTest.java new file mode 100644 index 00000000..a50fd9f4 --- /dev/null +++ b/framework/src/onos/protocols/pcep/pcepio/src/test/java/org/onosproject/pcepio/types/UnreservedBandwidthTlvTest.java @@ -0,0 +1,36 @@ +/* + * 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.types; + +import com.google.common.testing.EqualsTester; +import org.junit.Test; + +/** + * Unit Test case for Unreserved Bandwidth Tlv. + */ +public class UnreservedBandwidthTlvTest { + + // Objects of unreserved bandwidth tlv + private final UnreservedBandwidthTlv tlv1 = UnreservedBandwidthTlv.of(100); + private final UnreservedBandwidthTlv tlv2 = UnreservedBandwidthTlv.of(100); + private final UnreservedBandwidthTlv tlv3 = UnreservedBandwidthTlv.of(200); + + @Test + public void basics() { + new EqualsTester().addEqualityGroup(tlv1, tlv2).addEqualityGroup(tlv3).testEquals(); + } + +} diff --git a/framework/src/onos/protocols/pcep/pom.xml b/framework/src/onos/protocols/pcep/pom.xml new file mode 100755 index 00000000..c8e4222d --- /dev/null +++ b/framework/src/onos/protocols/pcep/pom.xml @@ -0,0 +1,60 @@ +<?xml version="1.0" encoding="UTF-8"?> +<!-- + ~ Copyright 2014 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. + --> +<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/maven-v4_0_0.xsd"> + <modelVersion>4.0.0</modelVersion> + + <parent> + <groupId>org.onosproject</groupId> + <artifactId>onos-protocols</artifactId> + <version>1.4.0-SNAPSHOT</version> + <relativePath>../pom.xml</relativePath> + </parent> + + <artifactId>onos-pcep-controller</artifactId> + <packaging>pom</packaging> + + <description>ONOS Pcep Protocol subsystem</description> + + <modules> + <module>api</module> + <module>ctl</module> + <module>pcepio</module> + </modules> + + <dependencies> + <dependency> + <groupId>org.onosproject</groupId> + <artifactId>onlab-misc</artifactId> + </dependency> + <dependency> + <groupId>org.onosproject</groupId> + <artifactId>onlab-junit</artifactId> + </dependency> + </dependencies> + + <build> + <plugins> + <plugin> + <groupId>org.apache.felix</groupId> + <artifactId>maven-bundle-plugin</artifactId> + </plugin> + </plugins> + </build> + +</project> |