VOL-3818: Initial version of OLT Topology discovery app; used to find active links between OLT NNI and Leaf switch ports.
Change-Id: I058b603d028446e8176821d85a25af8963e28924
diff --git a/.gitreview b/.gitreview
new file mode 100644
index 0000000..d19a6a4
--- /dev/null
+++ b/.gitreview
@@ -0,0 +1,5 @@
+[gerrit]
+host=gerrit.opencord.org
+port=29418
+project=olttopology.git
+defaultremote=origin
diff --git a/LICENSE.txt b/LICENSE.txt
new file mode 100644
index 0000000..d9d9d30
--- /dev/null
+++ b/LICENSE.txt
@@ -0,0 +1,202 @@
+
+ Apache License
+ Version 2.0, January 2004
+ http://www.apache.org/licenses/
+
+ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+ 1. Definitions.
+
+ "License" shall mean the terms and conditions for use, reproduction,
+ and distribution as defined by Sections 1 through 9 of this document.
+
+ "Licensor" shall mean the copyright owner or entity authorized by
+ the copyright owner that is granting the License.
+
+ "Legal Entity" shall mean the union of the acting entity and all
+ other entities that control, are controlled by, or are under common
+ control with that entity. For the purposes of this definition,
+ "control" means (i) the power, direct or indirect, to cause the
+ direction or management of such entity, whether by contract or
+ otherwise, or (ii) ownership of fifty percent (50%) or more of the
+ outstanding shares, or (iii) beneficial ownership of such entity.
+
+ "You" (or "Your") shall mean an individual or Legal Entity
+ exercising permissions granted by this License.
+
+ "Source" form shall mean the preferred form for making modifications,
+ including but not limited to software source code, documentation
+ source, and configuration files.
+
+ "Object" form shall mean any form resulting from mechanical
+ transformation or translation of a Source form, including but
+ not limited to compiled object code, generated documentation,
+ and conversions to other media types.
+
+ "Work" shall mean the work of authorship, whether in Source or
+ Object form, made available under the License, as indicated by a
+ copyright notice that is included in or attached to the work
+ (an example is provided in the Appendix below).
+
+ "Derivative Works" shall mean any work, whether in Source or Object
+ form, that is based on (or derived from) the Work and for which the
+ editorial revisions, annotations, elaborations, or other modifications
+ represent, as a whole, an original work of authorship. For the purposes
+ of this License, Derivative Works shall not include works that remain
+ separable from, or merely link (or bind by name) to the interfaces of,
+ the Work and Derivative Works thereof.
+
+ "Contribution" shall mean any work of authorship, including
+ the original version of the Work and any modifications or additions
+ to that Work or Derivative Works thereof, that is intentionally
+ submitted to Licensor for inclusion in the Work by the copyright owner
+ or by an individual or Legal Entity authorized to submit on behalf of
+ the copyright owner. For the purposes of this definition, "submitted"
+ means any form of electronic, verbal, or written communication sent
+ to the Licensor or its representatives, including but not limited to
+ communication on electronic mailing lists, source code control systems,
+ and issue tracking systems that are managed by, or on behalf of, the
+ Licensor for the purpose of discussing and improving the Work, but
+ excluding communication that is conspicuously marked or otherwise
+ designated in writing by the copyright owner as "Not a Contribution."
+
+ "Contributor" shall mean Licensor and any individual or Legal Entity
+ on behalf of whom a Contribution has been received by Licensor and
+ subsequently incorporated within the Work.
+
+ 2. Grant of Copyright License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ copyright license to reproduce, prepare Derivative Works of,
+ publicly display, publicly perform, sublicense, and distribute the
+ Work and such Derivative Works in Source or Object form.
+
+ 3. Grant of Patent License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ (except as stated in this section) patent license to make, have made,
+ use, offer to sell, sell, import, and otherwise transfer the Work,
+ where such license applies only to those patent claims licensable
+ by such Contributor that are necessarily infringed by their
+ Contribution(s) alone or by combination of their Contribution(s)
+ with the Work to which such Contribution(s) was submitted. If You
+ institute patent litigation against any entity (including a
+ cross-claim or counterclaim in a lawsuit) alleging that the Work
+ or a Contribution incorporated within the Work constitutes direct
+ or contributory patent infringement, then any patent licenses
+ granted to You under this License for that Work shall terminate
+ as of the date such litigation is filed.
+
+ 4. Redistribution. You may reproduce and distribute copies of the
+ Work or Derivative Works thereof in any medium, with or without
+ modifications, and in Source or Object form, provided that You
+ meet the following conditions:
+
+ (a) You must give any other recipients of the Work or
+ Derivative Works a copy of this License; and
+
+ (b) You must cause any modified files to carry prominent notices
+ stating that You changed the files; and
+
+ (c) You must retain, in the Source form of any Derivative Works
+ that You distribute, all copyright, patent, trademark, and
+ attribution notices from the Source form of the Work,
+ excluding those notices that do not pertain to any part of
+ the Derivative Works; and
+
+ (d) If the Work includes a "NOTICE" text file as part of its
+ distribution, then any Derivative Works that You distribute must
+ include a readable copy of the attribution notices contained
+ within such NOTICE file, excluding those notices that do not
+ pertain to any part of the Derivative Works, in at least one
+ of the following places: within a NOTICE text file distributed
+ as part of the Derivative Works; within the Source form or
+ documentation, if provided along with the Derivative Works; or,
+ within a display generated by the Derivative Works, if and
+ wherever such third-party notices normally appear. The contents
+ of the NOTICE file are for informational purposes only and
+ do not modify the License. You may add Your own attribution
+ notices within Derivative Works that You distribute, alongside
+ or as an addendum to the NOTICE text from the Work, provided
+ that such additional attribution notices cannot be construed
+ as modifying the License.
+
+ You may add Your own copyright statement to Your modifications and
+ may provide additional or different license terms and conditions
+ for use, reproduction, or distribution of Your modifications, or
+ for any such Derivative Works as a whole, provided Your use,
+ reproduction, and distribution of the Work otherwise complies with
+ the conditions stated in this License.
+
+ 5. Submission of Contributions. Unless You explicitly state otherwise,
+ any Contribution intentionally submitted for inclusion in the Work
+ by You to the Licensor shall be under the terms and conditions of
+ this License, without any additional terms or conditions.
+ Notwithstanding the above, nothing herein shall supersede or modify
+ the terms of any separate license agreement you may have executed
+ with Licensor regarding such Contributions.
+
+ 6. Trademarks. This License does not grant permission to use the trade
+ names, trademarks, service marks, or product names of the Licensor,
+ except as required for reasonable and customary use in describing the
+ origin of the Work and reproducing the content of the NOTICE file.
+
+ 7. Disclaimer of Warranty. Unless required by applicable law or
+ agreed to in writing, Licensor provides the Work (and each
+ Contributor provides its Contributions) on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ implied, including, without limitation, any warranties or conditions
+ of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+ PARTICULAR PURPOSE. You are solely responsible for determining the
+ appropriateness of using or redistributing the Work and assume any
+ risks associated with Your exercise of permissions under this License.
+
+ 8. Limitation of Liability. In no event and under no legal theory,
+ whether in tort (including negligence), contract, or otherwise,
+ unless required by applicable law (such as deliberate and grossly
+ negligent acts) or agreed to in writing, shall any Contributor be
+ liable to You for damages, including any direct, indirect, special,
+ incidental, or consequential damages of any character arising as a
+ result of this License or out of the use or inability to use the
+ Work (including but not limited to damages for loss of goodwill,
+ work stoppage, computer failure or malfunction, or any and all
+ other commercial damages or losses), even if such Contributor
+ has been advised of the possibility of such damages.
+
+ 9. Accepting Warranty or Additional Liability. While redistributing
+ the Work or Derivative Works thereof, You may choose to offer,
+ and charge a fee for, acceptance of support, warranty, indemnity,
+ or other liability obligations and/or rights consistent with this
+ License. However, in accepting such obligations, You may act only
+ on Your own behalf and on Your sole responsibility, not on behalf
+ of any other Contributor, and only if You agree to indemnify,
+ defend, and hold each Contributor harmless for any liability
+ incurred by, or claims asserted against, such Contributor by reason
+ of your accepting any such warranty or additional liability.
+
+ END OF TERMS AND CONDITIONS
+
+ APPENDIX: How to apply the Apache License to your work.
+
+ To apply the Apache License to your work, attach the following
+ boilerplate notice, with the fields enclosed by brackets "[]"
+ replaced with your own identifying information. (Don't include
+ the brackets!) The text should be enclosed in the appropriate
+ comment syntax for the file format. We also recommend that a
+ file or class name and description of purpose be included on the
+ same "printed page" as the copyright notice for easier
+ identification within third-party archives.
+
+ Copyright 2016 Open Networking Foundation
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..6463183
--- /dev/null
+++ b/README.md
@@ -0,0 +1,9 @@
+ONOS OLT topology Application
+=====================================
+
+Build
+-----
+
+Let's build all the code
+
+ mvn clean install
diff --git a/api/pom.xml b/api/pom.xml
new file mode 100644
index 0000000..7f7bd54
--- /dev/null
+++ b/api/pom.xml
@@ -0,0 +1,45 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+ ~ Copyright 2016-present Open Networking Foundation
+ ~
+ ~ Licensed under the Apache License, Version 2.0 (the "License");
+ ~ you may not use this file except in compliance with the License.
+ ~ You may obtain a copy of the License at
+ ~
+ ~ http://www.apache.org/licenses/LICENSE-2.0
+ ~
+ ~ Unless required by applicable law or agreed to in writing, software
+ ~ distributed under the License is distributed on an "AS IS" BASIS,
+ ~ WITHOUT 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:xsi="http://www.w3.org/2001/XMLSchema-instance"
+ xmlns="http://maven.apache.org/POM/4.0.0"
+ xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+ <modelVersion>4.0.0</modelVersion>
+
+ <parent>
+ <artifactId>olttopology</artifactId>
+ <groupId>org.opencord</groupId>
+ <version>1.0.1</version>
+ <relativePath>../pom.xml</relativePath>
+ </parent>
+
+ <artifactId>olttopology-api</artifactId>
+ <packaging>bundle</packaging>
+
+ <url>http://opencord.org</url>
+
+ <description>OLT application API</description>
+
+ <build>
+ <plugins>
+ <plugin>
+ <groupId>org.apache.felix</groupId>
+ <artifactId>maven-bundle-plugin</artifactId>
+ <extensions>true</extensions>
+ </plugin>
+ </plugins>
+ </build>
+</project>
diff --git a/api/src/main/java/org/opencord/olttopology/OltNeighborInfo.java b/api/src/main/java/org/opencord/olttopology/OltNeighborInfo.java
new file mode 100755
index 0000000..acc27dc
--- /dev/null
+++ b/api/src/main/java/org/opencord/olttopology/OltNeighborInfo.java
@@ -0,0 +1,159 @@
+/*
+ * Copyright 2017-present Open Networking Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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.opencord.olttopology;
+
+import org.onlab.packet.LLDPTLV;
+
+import org.onosproject.net.Port;
+
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.List;
+import java.util.Objects;
+
+/**
+ * Information about an OLT's neighbor. An instance of this class stores
+ * information about an OLT and it's neighbour. The information contains
+ * which port of the OLT is connected to which port of the neighbor
+ */
+public class OltNeighborInfo {
+
+ private String neighborName;
+ private String neighborPort;
+ private String oltName;
+ private Port oltPort;
+
+ // Serial number of the OLT
+ private String oltSerialNo;
+
+ // The management IP address of the neighbor
+ private String mgmtAddr;
+
+ // The time when this entry was last updated
+ private Date lastUpdated;
+
+ // List of other optional TLVs that would have been received from the
+ // neighbor in the last LLDP message
+ private List<LLDPTLV> otherOptionalTlvs;
+
+ public OltNeighborInfo(String neighborName, String neighborPort,
+ String oltName, Port oltPort, String oltSerialNo) {
+ this.neighborName = neighborName;
+ this.neighborPort = neighborPort;
+ this.oltName = oltName;
+ this.oltPort = oltPort;
+ this.oltSerialNo = oltSerialNo;
+ otherOptionalTlvs = new ArrayList<>();
+ updateTimeStamp();
+ }
+
+ public String neighborName() {
+ return neighborName;
+ }
+
+ public String neighborPort() {
+ return neighborPort;
+ }
+
+ public String oltName() {
+ return oltName;
+ }
+
+ public Port oltPort() {
+ return oltPort;
+ }
+
+ public String oltSerialNo() {
+ return oltSerialNo;
+ }
+
+ public Date getLastUpdated() {
+ return lastUpdated;
+ }
+
+ public void updateTimeStamp() {
+ lastUpdated = new Date();
+ }
+
+ public String mgmtAddr() {
+ return mgmtAddr;
+ }
+
+ public void setMgmtAddress(String neighborManagementAddress) {
+ mgmtAddr = neighborManagementAddress;
+ }
+
+ public void addOtherOptionalLldpTlvs(LLDPTLV lldptlv) {
+ otherOptionalTlvs.add(lldptlv);
+ }
+
+ public List<LLDPTLV> getOtherOptionalTlvs() {
+ return otherOptionalTlvs;
+ }
+
+ @Override
+ public boolean equals(Object o) {
+ if (this == o) {
+ return true;
+ }
+ if (o == null || getClass() != o.getClass()) {
+ return false;
+ }
+ OltNeighborInfo that = (OltNeighborInfo) o;
+ return Objects.equals(neighborName, that.neighborName) &&
+ Objects.equals(neighborPort, that.neighborPort) &&
+ Objects.equals(oltName, that.oltName) &&
+ Objects.equals(oltPort, that.oltPort) &&
+ Objects.equals(oltSerialNo, that.oltSerialNo) &&
+ Objects.equals(mgmtAddr, that.mgmtAddr) &&
+ Objects.equals(lastUpdated, that.lastUpdated);
+ }
+
+ @Override
+ public int hashCode() {
+ return Objects.hash(neighborName, neighborPort, oltName,
+ oltPort, oltSerialNo, mgmtAddr, lastUpdated);
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see java.lang.Object#toString()
+ */
+ @Override
+ public String toString() {
+ final StringBuilder buf = new StringBuilder();
+ buf.append('[');
+ buf.append("neighborName:");
+ buf.append(this.neighborName);
+ buf.append(",neighborPort:");
+ buf.append(this.neighborPort);
+ buf.append(",oltName:");
+ buf.append(this.oltName);
+ buf.append(",oltPort:");
+ buf.append((this.oltPort.annotations().value("portName").isEmpty()) ? "" :
+ this.oltPort.annotations().value("portName"));
+ buf.append(",oltSerialNo:");
+ buf.append(this.oltSerialNo);
+ buf.append(",neighbor_mgmt_address:");
+ buf.append(this.mgmtAddr);
+ buf.append(",lastUpdated:");
+ buf.append(this.lastUpdated);
+ buf.append(']');
+ return buf.toString();
+ }
+}
diff --git a/api/src/main/java/org/opencord/olttopology/OltTopologyInformationService.java b/api/src/main/java/org/opencord/olttopology/OltTopologyInformationService.java
new file mode 100644
index 0000000..9ce5a0d
--- /dev/null
+++ b/api/src/main/java/org/opencord/olttopology/OltTopologyInformationService.java
@@ -0,0 +1,43 @@
+/*
+ * Copyright 2016-present Open Networking Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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.opencord.olttopology;
+
+
+import org.onosproject.net.ConnectPoint;
+
+import java.util.Map;
+
+/**
+ * Service for configuring the OLT topology collection and for
+ * viewing the topology information.
+ */
+public interface OltTopologyInformationService {
+
+ /**
+ * Get a collection of OLT ports and their neighbors.
+ *
+ * @return OLT Connect points and it's neighbors
+ */
+ Map<ConnectPoint, OltNeighborInfo> getNeighbours();
+
+ /**
+ * Provision Timer for sending LLDP packets to OLT NNI Ports.
+ *
+ * @param timer Periodicity in minutes for sending out LLDP packet to OLT NNI ports.
+ */
+ void lldpPeriodicity(int timer);
+}
diff --git a/api/src/main/java/org/opencord/olttopology/package-info.java b/api/src/main/java/org/opencord/olttopology/package-info.java
new file mode 100644
index 0000000..31900e1
--- /dev/null
+++ b/api/src/main/java/org/opencord/olttopology/package-info.java
@@ -0,0 +1,20 @@
+/*
+ * Copyright 2016-present Open Networking Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * OltTopology application api.
+ */
+package org.opencord.olttopology;
diff --git a/app/app.xml b/app/app.xml
new file mode 100644
index 0000000..5356a65
--- /dev/null
+++ b/app/app.xml
@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+ ~ Copyright 2016-present Open Networking Foundation
+ ~
+ ~ Licensed under the Apache License, Version 2.0 (the "License");
+ ~ you may not use this file except in compliance with the License.
+ ~ You may obtain a copy of the License at
+ ~
+ ~ http://www.apache.org/licenses/LICENSE-2.0
+ ~
+ ~ Unless required by applicable law or agreed to in writing, software
+ ~ distributed under the License is distributed on an "AS IS" BASIS,
+ ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ ~ See the License for the specific language governing permissions and
+ ~ limitations under the License.
+ -->
+<app name="org.opencord.olttopology" origin="ON.Lab" version="${project.version}"
+ category="Topology" url="http://onosproject.org" title="Optical Line Terminal Topology App"
+ featuresRepo="mvn:${project.groupId}/${project.artifactId}/${project.version}/xml/features"
+ features="${project.artifactId}" apps="org.opencord.sadis">
+ <description>${project.description}</description>
+ <artifact>mvn:${project.groupId}/${project.artifactId}/${project.version}</artifact>
+ <artifact>mvn:${project.groupId}/olttopology-api/${project.version}</artifact>
+</app>
diff --git a/app/features.xml b/app/features.xml
new file mode 100644
index 0000000..592e5ef
--- /dev/null
+++ b/app/features.xml
@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<!--
+ ~ Copyright 2016-present Open Networking Foundation
+ ~
+ ~ Licensed under the Apache License, Version 2.0 (the "License");
+ ~ you may not use this file except in compliance with the License.
+ ~ You may obtain a copy of the License at
+ ~
+ ~ http://www.apache.org/licenses/LICENSE-2.0
+ ~
+ ~ Unless required by applicable law or agreed to in writing, software
+ ~ distributed under the License is distributed on an "AS IS" BASIS,
+ ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ ~ See the License for the specific language governing permissions and
+ ~ limitations under the License.
+ -->
+<features xmlns="http://karaf.apache.org/xmlns/features/v1.2.0" name="${project.artifactId}-${project.version}">
+ <feature name="${project.artifactId}" version="${project.version}"
+ description="${project.description}">
+ <feature>onos-api</feature>
+ <bundle>mvn:${project.groupId}/olttopology-api/${project.version}</bundle>
+ <bundle>mvn:${project.groupId}/${project.artifactId}/${project.version}</bundle>
+ </feature>
+</features>
diff --git a/app/pom.xml b/app/pom.xml
new file mode 100644
index 0000000..4ae3c3d
--- /dev/null
+++ b/app/pom.xml
@@ -0,0 +1,125 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+ ~ Copyright 2016-present Open Networking Foundation
+ ~
+ ~ Licensed under the Apache License, Version 2.0 (the "License");
+ ~ you may not use this file except in compliance with the License.
+ ~ You may obtain a copy of the License at
+ ~
+ ~ http://www.apache.org/licenses/LICENSE-2.0
+ ~
+ ~ Unless required by applicable law or agreed to in writing, software
+ ~ distributed under the License is distributed on an "AS IS" BASIS,
+ ~ WITHOUT 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:xsi="http://www.w3.org/2001/XMLSchema-instance"
+ xmlns="http://maven.apache.org/POM/4.0.0"
+ xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+ <parent>
+ <groupId>org.opencord</groupId>
+ <artifactId>olttopology</artifactId>
+ <version>1.0.1</version>
+ <relativePath>../pom.xml</relativePath>
+ </parent>
+ <modelVersion>4.0.0</modelVersion>
+
+ <artifactId>olttopology-app</artifactId>
+
+ <packaging>bundle</packaging>
+ <description>OLT application for CORD</description>
+
+ <properties>
+ <web.context>/onos/olttopology</web.context>
+ <api.version>1.0.0</api.version>
+ <api.title>ONOS OLT TOPOLOGY REST API</api.title>
+ <api.description>
+ APIs for interacting with the CORD OLT application.
+ </api.description>
+ <api.package>org.opencord.olttopology.rest</api.package>
+ <olttopology.api.version>1.0.1</olttopology.api.version>
+ <sadis.api.version>5.0.0</sadis.api.version>
+ </properties>
+
+ <dependencies>
+ <dependency>
+ <groupId>org.opencord</groupId>
+ <artifactId>olttopology-api</artifactId>
+ <version>${olttopology.api.version}</version>
+ </dependency>
+
+
+ <dependency>
+ <groupId>org.opencord</groupId>
+ <artifactId>sadis-api</artifactId>
+ <version>${sadis.api.version}</version>
+ </dependency>
+
+ <dependency>
+ <groupId>org.onosproject</groupId>
+ <artifactId>onos-cli</artifactId>
+ <version>${onos.version}</version>
+ </dependency>
+
+ <dependency>
+ <groupId>org.onosproject</groupId>
+ <artifactId>onos-core-serializers</artifactId>
+ <version>${onos.version}</version>
+ <scope>provided</scope>
+ </dependency>
+
+ <dependency>
+ <groupId>org.apache.karaf.shell</groupId>
+ <artifactId>org.apache.karaf.shell.console</artifactId>
+ <scope>provided</scope>
+ </dependency>
+
+ <dependency>
+ <groupId>org.apache.karaf.shell</groupId>
+ <artifactId>org.apache.karaf.shell.core</artifactId>
+ <scope>provided</scope>
+ </dependency>
+
+ <dependency>
+ <groupId>javax.ws.rs</groupId>
+ <artifactId>javax.ws.rs-api</artifactId>
+ <scope>provided</scope>
+ </dependency>
+ </dependencies>
+
+ <build>
+ <plugins>
+ <plugin>
+ <groupId>org.onosproject</groupId>
+ <artifactId>onos-maven-plugin</artifactId>
+ </plugin>
+ <plugin>
+ <groupId>org.apache.felix</groupId>
+ <artifactId>maven-bundle-plugin</artifactId>
+ <extensions>true</extensions>
+ <configuration>
+ <instructions>
+ <_wab>src/main/webapp/</_wab>
+ <Include-Resource>
+ WEB-INF/classes/apidoc/swagger.json=target/swagger.json
+ </Include-Resource>
+ <Bundle-SymbolicName>
+ ${project.groupId}.${project.artifactId}
+ </Bundle-SymbolicName>
+ <Import-Package>
+ *,org.glassfish.jersey.servlet
+ </Import-Package>
+ <Web-ContextPath>${web.context}</Web-ContextPath>
+ <Karaf-Commands>org.opencord.olttopology.cli</Karaf-Commands>
+ </instructions>
+ </configuration>
+ </plugin>
+
+ <plugin>
+ <groupId>org.apache.maven.plugins</groupId>
+ <artifactId>maven-surefire-plugin</artifactId>
+ </plugin>
+ </plugins>
+ </build>
+</project>
diff --git a/app/src/main/java/org/opencord/olttopology/cli/OltTopologyGetCommand.java b/app/src/main/java/org/opencord/olttopology/cli/OltTopologyGetCommand.java
new file mode 100644
index 0000000..7acbac8
--- /dev/null
+++ b/app/src/main/java/org/opencord/olttopology/cli/OltTopologyGetCommand.java
@@ -0,0 +1,48 @@
+/*
+ * Copyright 2017-present Open Networking Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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.opencord.olttopology.cli;
+
+import org.apache.karaf.shell.api.action.Command;
+import org.apache.karaf.shell.api.action.lifecycle.Service;
+import org.onosproject.cli.AbstractShellCommand;
+import org.onosproject.net.ConnectPoint;
+import org.opencord.olttopology.OltNeighborInfo;
+import org.opencord.olttopology.OltTopologyInformationService;
+
+import java.util.Map;
+
+/**
+ * OLT Topology CLI Command.
+ * <p>
+ * Shows the current topology in the CLI.
+ */
+@Service
+@Command(scope = "onos", name = "olt-topology", description = "OLT Topology CLI command")
+public class OltTopologyGetCommand extends AbstractShellCommand {
+
+ private static final String FORMAT = "%s";
+
+ private OltTopologyInformationService oltTopoSer = get(OltTopologyInformationService.class);
+
+ @Override
+ protected void doExecute() {
+ oltTopoSer.getNeighbours().entrySet().forEach(this::display);
+ }
+
+ private void display(Map.Entry<ConnectPoint, OltNeighborInfo> neighbor) {
+ print(FORMAT, neighbor.getValue());
+ }
+}
\ No newline at end of file
diff --git a/app/src/main/java/org/opencord/olttopology/cli/package-info.java b/app/src/main/java/org/opencord/olttopology/cli/package-info.java
new file mode 100644
index 0000000..2e664a7
--- /dev/null
+++ b/app/src/main/java/org/opencord/olttopology/cli/package-info.java
@@ -0,0 +1,20 @@
+/*
+ * Copyright 2016-present Open Networking Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * OLT application handling PMC OLT hardware.
+ */
+package org.opencord.olttopology.cli;
diff --git a/app/src/main/java/org/opencord/olttopology/impl/OltTopology.java b/app/src/main/java/org/opencord/olttopology/impl/OltTopology.java
new file mode 100644
index 0000000..a0bf497
--- /dev/null
+++ b/app/src/main/java/org/opencord/olttopology/impl/OltTopology.java
@@ -0,0 +1,770 @@
+/*
+ * Copyright 2018-present Open Networking Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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.opencord.olttopology.impl;
+
+import static java.util.concurrent.Executors.newSingleThreadExecutor;
+import static org.onlab.util.Tools.groupedThreads;
+
+import org.apache.commons.lang.ArrayUtils;
+import org.onlab.packet.EthType;
+import org.onlab.packet.Ethernet;
+import org.onlab.packet.Ip4Address;
+import org.onlab.packet.LLDP;
+import org.onlab.packet.LLDPTLV;
+import org.onlab.packet.MacAddress;
+import org.onlab.util.KryoNamespace;
+import org.onosproject.cfg.ComponentConfigService;
+import org.onosproject.codec.CodecService;
+import org.onosproject.core.ApplicationId;
+import org.onosproject.core.CoreService;
+import org.onosproject.mastership.MastershipService;
+import org.onosproject.net.ConnectPoint;
+import org.onosproject.net.Device;
+import org.onosproject.net.DeviceId;
+import org.onosproject.net.Port;
+import org.onosproject.net.device.DeviceEvent;
+import org.onosproject.net.device.DeviceListener;
+import org.onosproject.net.device.DeviceService;
+import org.onosproject.net.flow.DefaultTrafficTreatment;
+import org.onosproject.net.flow.TrafficTreatment;
+import org.onosproject.net.flowobjective.FlowObjectiveService;
+import org.onosproject.net.packet.DefaultOutboundPacket;
+import org.onosproject.net.packet.InboundPacket;
+import org.onosproject.net.packet.OutboundPacket;
+import org.onosproject.net.packet.PacketContext;
+import org.onosproject.net.packet.PacketProcessor;
+import org.onosproject.net.packet.PacketService;
+import org.onosproject.store.serializers.KryoNamespaces;
+import org.onosproject.store.service.EventuallyConsistentMap;
+import org.onosproject.store.service.StorageService;
+import org.onosproject.store.service.WallClockTimestamp;
+import org.opencord.olttopology.OltNeighborInfo;
+import org.opencord.olttopology.OltTopologyInformationService;
+import org.opencord.sadis.BaseInformationService;
+import org.opencord.sadis.SadisService;
+import org.opencord.sadis.SubscriberAndDeviceInformation;
+import org.osgi.service.component.ComponentContext;
+import org.osgi.service.component.annotations.Activate;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.Deactivate;
+import org.osgi.service.component.annotations.Modified;
+import org.osgi.service.component.annotations.Reference;
+import org.osgi.service.component.annotations.ReferenceCardinality;
+import org.slf4j.Logger;
+
+import java.nio.ByteBuffer;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Dictionary;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.Properties;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.ScheduledFuture;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.ExecutorService;
+import java.util.stream.Collectors;
+
+import static org.onlab.util.Tools.get;
+import static org.opencord.olttopology.impl.OsgiPropertyConstants.DEFAULT_CHASSIS_ID;
+import static org.opencord.olttopology.impl.OsgiPropertyConstants.DEFAULT_CHASSIS_ID_DEFAULT;
+import static org.opencord.olttopology.impl.OsgiPropertyConstants.DEFAULT_DEST_MAC_ADDRESS;
+import static org.opencord.olttopology.impl.OsgiPropertyConstants.DEFAULT_DEST_MAC_ADDRESS_DEFAULT;
+import static org.opencord.olttopology.impl.OsgiPropertyConstants.DEFAULT_TTL_IN_SECS;
+import static org.opencord.olttopology.impl.OsgiPropertyConstants.DEFAULT_TTL_IN_SECS_DEFAULT;
+import static org.opencord.olttopology.impl.OsgiPropertyConstants.DEFAULT_LLDP_SEND_PERIODICITY;
+import static org.opencord.olttopology.impl.OsgiPropertyConstants.LLDP_SEND_PERIODICITY_STR;
+
+import static org.slf4j.LoggerFactory.getLogger;
+
+/**
+ * Application to keep track of the topology of OLT devices.
+ */
+@Component(immediate = true,
+ property = {
+ DEFAULT_DEST_MAC_ADDRESS + ":String=" + DEFAULT_DEST_MAC_ADDRESS_DEFAULT,
+ DEFAULT_TTL_IN_SECS + ":Integer=" + DEFAULT_TTL_IN_SECS_DEFAULT,
+ DEFAULT_CHASSIS_ID + ":Integer=" + DEFAULT_CHASSIS_ID_DEFAULT,
+ LLDP_SEND_PERIODICITY_STR + ":Integer=" + DEFAULT_LLDP_SEND_PERIODICITY
+ }
+)
+public class OltTopology implements OltTopologyInformationService {
+ // Subtype value for IPv4 as per the LLDP specs
+ public static final byte IP_ADDR_SUB_TYPE = 0x1;
+ // 5 below is address subtype + IP4 address len
+ public static final byte IP_ADDR_STRING_LEN = 0x5;
+ // Value of interface sub type as per the LLDP specs
+ public static final byte INTERFACE_SUB_TYPE = 0x1;
+ // Value of interface number set in the management address
+ // field of LLDP packets being sent out
+ public static final int INTERFACE_NUM = 0;
+ // Value of the OID set in the management address field of
+ // LLDP packets being sent out
+ public static final byte OID_STRING = 0x0;
+ // Value of SystemName TLV as per the LLDP specs
+ public static final byte SYSTEMNAME_TLV_TYPE = 0x5;
+ // Value of Management Address TLV as per the LLDP specs
+ public static final byte MANAGEMENT_ADDR_TLV_TYPE = 0x8;
+ // Value of Port TLV sub type as per the LLDP specs
+ public static final byte PORT_TLV_SUB_TYPE = 5;
+ private static final String APP_NAME = "org.opencord.olttopology";
+ // Name for the consistent map where the neighbor information is stored
+ private static final String NEIGHBORS = "olt-neighbors";
+ private final Logger log = getLogger(getClass());
+ // deviceListener to be able to receive events about the OLT devices
+ private final DeviceListener deviceListener = new InternalDeviceListener();
+ // Service to execute periodic sending of LLDP packets
+ private final ScheduledExecutorService scheduledExecutorService =
+ Executors.newSingleThreadScheduledExecutor();
+ // our application-specific event handler for processing LLDP messages
+ // received from the OLT devices
+ private final ReactivePacketProcessor processor = new ReactivePacketProcessor();
+ // Map for storing information about the OLTs, is map of OLT deviceId to
+ // uplink port of the OLT
+ private final Map<DeviceId, Port> oltPortMap = new ConcurrentHashMap<>();
+ // cfg variable to set the parameters dynamically.
+ protected String destMacAddress = DEFAULT_DEST_MAC_ADDRESS_DEFAULT;
+ // References to the various services that this app uses
+ @Reference(cardinality = ReferenceCardinality.MANDATORY)
+ protected MastershipService mastershipService;
+ @Reference(cardinality = ReferenceCardinality.MANDATORY)
+ protected DeviceService deviceService;
+ @Reference(cardinality = ReferenceCardinality.MANDATORY)
+ protected CoreService coreService;
+ @Reference(cardinality = ReferenceCardinality.MANDATORY)
+ protected ComponentConfigService componentConfigService;
+ @Reference(cardinality = ReferenceCardinality.MANDATORY)
+ protected PacketService packetService;
+ @Reference(cardinality = ReferenceCardinality.MANDATORY)
+ protected StorageService storageService;
+ @Reference(cardinality = ReferenceCardinality.MANDATORY)
+ protected CodecService codecService;
+ @Reference(cardinality = ReferenceCardinality.MANDATORY)
+ protected SadisService sadisService;
+ @Reference(cardinality = ReferenceCardinality.MANDATORY)
+ protected FlowObjectiveService flowObjectiveService;
+ protected BaseInformationService<SubscriberAndDeviceInformation> subsService;
+ private short ttlInSecs = DEFAULT_TTL_IN_SECS_DEFAULT;
+ private int chassisId = DEFAULT_CHASSIS_ID_DEFAULT;
+ private int lldpSendPeriodicity = DEFAULT_LLDP_SEND_PERIODICITY;
+ private ApplicationId appId;
+ // Map for storing information about the neighbor connected to an OLT port
+ private EventuallyConsistentMap<ConnectPoint, OltNeighborInfo> neighbors;
+ private ScheduledFuture<?> futureTask;
+
+ protected ExecutorService packetProcessorExecutor;
+ protected ExecutorService eventExecutor;
+
+ private static boolean isNniPort(Port port) {
+ if (port.annotations().keys().contains("portName")) {
+ return port.annotations().value("portName").contains("nni-");
+ }
+ return false;
+ }
+
+ @Activate
+ public void activate(ComponentContext context) {
+ modified(context);
+ appId = coreService.registerApplication(APP_NAME);
+ componentConfigService.registerProperties(getClass());
+ codecService.registerCodec(OltNeighborInfo.class, new OltTopologyInformationCodec());
+
+ subsService = sadisService.getSubscriberInfoService();
+
+ // look for all provisioned devices in Sadis and put them in oltData
+ deviceService.getDevices().forEach(this::createAndProcessDevice);
+
+ // The NEIGHBORS map should be available across ONOS instance failures,
+ // create it using the storage service.
+ KryoNamespace serializer = KryoNamespace.newBuilder()
+ .register(KryoNamespaces.API)
+ .register(OltNeighborInfo.class)
+ .register(ConnectPoint.class)
+ .register(java.util.Date.class)
+ .register(org.onosproject.net.Port.class)
+ .register(org.onlab.packet.LLDPOrganizationalTLV.class)
+ .build();
+
+ neighbors = storageService.<ConnectPoint, OltNeighborInfo>eventuallyConsistentMapBuilder()
+ .withName(NEIGHBORS)
+ .withSerializer(serializer)
+ .withTimestampProvider((k, v) -> new WallClockTimestamp())
+ .build();
+
+ deviceService.addListener(deviceListener);
+
+ // register our event handler
+ packetService.addProcessor(processor, PacketProcessor.director(2));
+ futureTask = scheduledExecutorService.scheduleAtFixedRate(this::oltTopologyTimerTask, 0, lldpSendPeriodicity,
+ TimeUnit.MINUTES);
+ packetProcessorExecutor = newSingleThreadExecutor(groupedThreads("onos/olttopology", "packet-%d", log));
+ eventExecutor = newSingleThreadExecutor(groupedThreads("onos/olttopology", "events-%d", log));
+
+ log.info("Started with Application ID {}", appId.id());
+ }
+
+ @Deactivate
+ public void deactivate() {
+ futureTask.cancel(true);
+ scheduledExecutorService.shutdownNow();
+ packetService.removeProcessor(processor);
+ deviceService.removeListener(deviceListener);
+ codecService.unregisterCodec(OltNeighborInfo.class);
+ componentConfigService.unregisterProperties(getClass(), false);
+ packetProcessorExecutor.shutdown();
+ eventExecutor.shutdown();
+ log.info("Stopped");
+ }
+
+ @Modified
+ public void modified(ComponentContext context) {
+ Dictionary<?, ?> properties = context != null ? context.getProperties() : new Properties();
+ try {
+ String destMac = get(properties, DEFAULT_DEST_MAC_ADDRESS);
+ destMacAddress = Objects.isNull(destMac) ? DEFAULT_DEST_MAC_ADDRESS_DEFAULT : destMac;
+ String ttlInsecsStr = get(properties, DEFAULT_TTL_IN_SECS);
+ ttlInSecs = Short.parseShort(ttlInsecsStr.trim());
+
+ String chassisIdStr = get(properties, DEFAULT_CHASSIS_ID);
+ chassisId = Integer.parseInt(chassisIdStr.trim());
+
+ String lldpPeriodicity = get(properties, LLDP_SEND_PERIODICITY_STR);
+ int newLldpSendPeriodicity = Integer.parseInt(lldpPeriodicity);
+
+ if (newLldpSendPeriodicity <= 0) {
+ log.error("lldpSendPeriodicity should be a positive integer");
+ } else if (newLldpSendPeriodicity != lldpSendPeriodicity) {
+ lldpSendPeriodicity = newLldpSendPeriodicity;
+ lldpPeriodicity(newLldpSendPeriodicity);
+ }
+
+ log.debug("OLT properties: destMacAddress: {}, ttlInSecs: {}, chassisId: {}, lldpSendPeriodicity{}",
+ destMacAddress, ttlInSecs, chassisId, lldpSendPeriodicity);
+ } catch (Exception e) {
+ log.error("Error while modifying the properties", e);
+ }
+ }
+
+ @Override
+ public Map<ConnectPoint, OltNeighborInfo> getNeighbours() {
+ return neighbors.entrySet().stream().collect(Collectors.toMap(Entry::getKey, Entry::getValue));
+ }
+
+ /**
+ * Sets periodicity in minutes for sending out LLDP packet to OLT NNI Ports.
+ *
+ * @param timer Value in minutes.
+ */
+ @Override
+ public void lldpPeriodicity(int timer) {
+ if (timer > 0) {
+ if (futureTask != null) {
+ futureTask.cancel(true);
+ }
+
+ futureTask = scheduledExecutorService.scheduleAtFixedRate(this::oltTopologyTimerTask, 0,
+ timer,
+ TimeUnit.MINUTES);
+ log.info("LLDP Packet out Periodicity updated to {} minutes", timer);
+ }
+ }
+
+ /**
+ * Creates entry in the oltData map.
+ * provision LLDP flow on enabled NNI ports if device is present in Sadis config
+ *
+ * @param dev Device to look for
+ */
+ private void createAndProcessDevice(Device dev) {
+ SubscriberAndDeviceInformation deviceInfo = subsService.get(dev.serialNumber());
+ log.debug("CreateAndProcessDevice: deviceInfo {}", deviceInfo);
+
+ if (deviceInfo != null) {
+ // TODO FIXME, this works only with one NNI
+ Optional<Port> optPort = deviceService.getPorts(dev.id())
+ .stream().filter(OltTopology::isNniPort).findFirst();
+ if (optPort.isPresent()) {
+ Port port = optPort.get();
+ oltPortMap.put(dev.id(), port);
+ return;
+ }
+ }
+ log.warn("CreateAndProcessDevice: failed to update the oltdata for device {}", dev);
+ }
+
+ /**
+ * Updates OltData Map with new AccessDeviceData if it is already present in OltMap,
+ * Provisions LLDP flow on enabled NNI port if it is present in Sadis config
+ * Only one NNI port is supported as of now.
+ *
+ * @param dev Device to look for
+ * @param uplink Uplink port number
+ * @return true if updated else false
+ */
+ private boolean updateOltData(Device dev, Port uplink) {
+ // check if this device is provisioned in Sadis
+ SubscriberAndDeviceInformation deviceInfo = subsService.get(dev.serialNumber());
+ log.debug("updateAccessDevice: deviceInfo {}", deviceInfo);
+
+ if (deviceInfo != null) {
+ oltPortMap.replace(dev.id(), uplink);
+ log.debug("updateAccessDevice: Stored did {} uplink {}", dev.id(), uplink);
+ return true;
+ }
+ return false;
+ }
+
+ /**
+ * Sends LLDP Packet to OLT NNI Port.
+ *
+ * @param devId Access Device data for OLT
+ * @param nniPort NNI port info of OLT
+ */
+ private void sendLldpPackets(DeviceId devId, Port nniPort) {
+ if (!mastershipService.isLocalMaster(devId)) {
+ return;
+ }
+
+ // Get NNI Port name to be filled in LLDP packet port TLV.
+ String portName = (nniPort.annotations().value("portName").isEmpty()) ? "" :
+ nniPort.annotations().value("portName");
+
+ // Get System Name value from device name.
+ Device d = deviceService.getDevice(devId);
+ String[] systemName = d.id().uri().toString().split(":", 2);
+
+ MacAddress destMac = MacAddress.valueOf(destMacAddress);
+ MacAddress srcMac = createMacFromDevId(d.id());
+
+ SubscriberAndDeviceInformation deviceInfo = subsService.get(d.serialNumber());
+
+ // Initialized deviceIP address, to be sent in Management Address TLV.
+ Ip4Address devIpAddr = Ip4Address.valueOf("0.0.0.0");
+
+ // Get OLT device IP address from deviceInfo, to be filled in management address TLV.
+ if (deviceInfo != null) {
+ devIpAddr = deviceInfo.ipAddress();
+ log.debug("sendLldpPackets: did {} nniPort {} devIP {}", d.id(), nniPort, devIpAddr);
+ } else {
+ log.warn("device {} not found in Sadis NOT sending LLDP packet", d.id());
+ return;
+ }
+
+ //Created LLDP packet.
+ Ethernet packet = createLldpPacket(destMac, srcMac, chassisId,
+ portName, ttlInSecs, systemName[1], devIpAddr
+ .toString());
+
+ // Create the connect point to send the packet to and emit
+ ConnectPoint toSendTo = new ConnectPoint(d.id(), nniPort.number());
+
+ //Sends LLDP packet to connect point(NNI port).
+ TrafficTreatment t = DefaultTrafficTreatment.builder()
+ .setOutput(toSendTo.port()).build();
+ OutboundPacket o = new DefaultOutboundPacket(
+ toSendTo.deviceId(), t,
+ ByteBuffer.wrap(packet.serialize()));
+ if (log.isTraceEnabled()) {
+ log.trace("Sending LLDP packet {} at {}",
+ packet, toSendTo);
+ }
+
+ packetService.emit(o);
+ }
+
+ /**
+ * Creates MAC address for LLDP packet from OLT device ID string.
+ *
+ * @param id Device ID of OLT
+ * @return Mac address
+ */
+ private MacAddress createMacFromDevId(DeviceId id) {
+ String strId = id.toString();
+ String macStr = strId.substring(7);
+ String formattedMac = macStr.replaceAll("(.{2})", "$1" + ":");
+ formattedMac = formattedMac.substring(0, formattedMac.length() - 1);
+
+ return MacAddress.valueOf(formattedMac);
+ }
+
+ /**
+ * Creates LLDP packet to be sent out of OLT.
+ *
+ * @param destMac Destination LLDP Mac address
+ * @param srcMac Source Mac of OLT device
+ * @param chassisId Chassis ID TLV value
+ * @param port NNI port information
+ * @param ttl TTL value in sec
+ * @param systemName System name TLV value
+ * @param mgmtAddr Management Address TLV value
+ * @return LLDP ethernet packet
+ */
+ private Ethernet createLldpPacket(MacAddress destMac, MacAddress srcMac,
+ int chassisId, String port, short ttl,
+ String systemName, String mgmtAddr) {
+
+ Ethernet ethPkt = new Ethernet();
+ ethPkt.setEtherType(Ethernet.TYPE_LLDP);
+ ethPkt.setDestinationMACAddress(destMac);
+ ethPkt.setSourceMACAddress(srcMac);
+
+ LLDP lldpPkt = new LLDP();
+
+ setChassisId(lldpPkt, chassisId);
+ setPortId(lldpPkt, port);
+ setTtl(lldpPkt, ttl);
+
+ List<LLDPTLV> optionalTlv = new ArrayList<>();
+ optionalTlv.add(createSystemNameTlv(systemName));
+ optionalTlv.add(createMgmtAddressTlv(mgmtAddr));
+
+ lldpPkt.setOptionalTLVList(optionalTlv);
+
+ ethPkt.setPayload(lldpPkt);
+ return ethPkt;
+ }
+
+ /**
+ * Sets Chassis ID TLV for LLDP packet.
+ *
+ * @param lldpPkt LLDP packet reference
+ * @param chassisId Chassid ID tlv value
+ */
+ private void setChassisId(LLDP lldpPkt, final int chassisId) {
+ final byte chassisTlvSubtype = 1;
+
+ byte[] chassis = ArrayUtils.addAll(new byte[]{chassisTlvSubtype},
+ ByteBuffer.allocate(String.valueOf(chassisId).length())
+ .put(String.valueOf(chassisId).getBytes()).array());
+
+ LLDPTLV chassisTlv = new LLDPTLV();
+ lldpPkt.setChassisId(chassisTlv.setLength((byte) chassis.length)
+ .setType(LLDP.CHASSIS_TLV_TYPE)
+ .setValue(chassis));
+ }
+
+ /**
+ * Sets Port ID tlv for LLDP packet.
+ *
+ * @param lldpPkt LLDP packet reference
+ * @param ifaceName Port Name TLV value
+ */
+ private void setPortId(LLDP lldpPkt, final String ifaceName) {
+
+ byte[] port = ArrayUtils.addAll(new byte[]{PORT_TLV_SUB_TYPE},
+ ifaceName.getBytes());
+
+ LLDPTLV portTlv = new LLDPTLV();
+ lldpPkt.setPortId(portTlv.setLength((byte) port.length)
+ .setType(LLDP.PORT_TLV_TYPE)
+ .setValue(port));
+ }
+
+ /**
+ * Sets TTL tlv for LLDP packet.
+ *
+ * @param lldpPkt LLDP Packet reference
+ * @param timeInSecs TTL tlv value in sec
+ */
+ private void setTtl(LLDP lldpPkt, final short timeInSecs) {
+ byte[] time = ByteBuffer.allocate(2).putShort(timeInSecs).array();
+
+ LLDPTLV ttlTlv = new LLDPTLV();
+
+ lldpPkt.setTtl(ttlTlv.setType(LLDP.TTL_TLV_TYPE)
+ .setLength((short) time.length)
+ .setValue(time));
+ }
+
+ /**
+ * Creates System name TLV for LLDP packet.
+ *
+ * @param systemName System name tlv value
+ * @return systemName TLV
+ */
+ private LLDPTLV createSystemNameTlv(String systemName) {
+ byte[] bytes = systemName.getBytes();
+
+ LLDPTLV sysNameTlv = new LLDPTLV();
+
+ return sysNameTlv.setType(SYSTEMNAME_TLV_TYPE)
+ .setLength((byte) bytes.length)
+ .setValue(bytes);
+ }
+
+ /**
+ * Sets Management address TLV for LLDP packet.
+ *
+ * @param mgmtAddress Management address tlv value
+ * @return Management address TLV
+ */
+ private LLDPTLV createMgmtAddressTlv(String mgmtAddress) {
+
+ Ip4Address ipAddr = Ip4Address.valueOf(mgmtAddress);
+
+ byte[] addrStr = ArrayUtils.addAll(new byte[]{IP_ADDR_SUB_TYPE},
+ ipAddr.toOctets());
+
+ byte[] ipAddrBytes = ArrayUtils.addAll(new byte[]{IP_ADDR_STRING_LEN},
+ addrStr);
+
+ byte[] bytesInterfacetype = ArrayUtils.addAll(ipAddrBytes,
+ ByteBuffer.allocate(1).put(INTERFACE_SUB_TYPE).array());
+ byte[] bytesInterfaceNumber = ArrayUtils.addAll(bytesInterfacetype,
+ ByteBuffer.allocate(4).putInt(INTERFACE_NUM).array());
+ byte[] finalMgmtAddrBytes = ArrayUtils.addAll(bytesInterfaceNumber,
+ ByteBuffer.allocate(1).put(OID_STRING).array());
+
+ LLDPTLV mgmtAddrTlv = new LLDPTLV();
+ return mgmtAddrTlv.setType(MANAGEMENT_ADDR_TLV_TYPE)
+ .setLength((byte) finalMgmtAddrBytes.length)
+ .setValue(finalMgmtAddrBytes);
+ }
+
+ /**
+ * Processes incoming LLDP packets from NNI ports.
+ *
+ * @param pkt Inbound packet received at ONOS from OLT NNI port
+ */
+ private void handleLldpPacket(InboundPacket pkt) {
+
+ Ethernet packet = pkt.parsed();
+
+ if (packet == null) {
+ log.warn("Packet is null");
+ return;
+ }
+
+ log.debug("Got a packet {}", packet);
+
+ // Check if Ethernet type is LLDP.
+ if (packet.getEtherType() == Ethernet.TYPE_LLDP) {
+ // Get payload of Packet.
+ LLDP lldpPacket = (LLDP) packet.getPayload();
+
+ // Fetch all optional TLVs from Packet.
+ List<LLDPTLV> optionalTLVs = lldpPacket.getOptionalTLVList();
+
+ // Look for the system name and neighbor
+ // management IP address TLVs.
+ String systemName = null;
+ String neighMgmtAddr = "";
+ if (optionalTLVs != null) {
+ for (LLDPTLV tlv : optionalTLVs) {
+ // Fetching system name TLV.
+ if (tlv.getType() == SYSTEMNAME_TLV_TYPE) {
+ systemName = new String(tlv.getValue());
+ } else if (tlv.getType() == MANAGEMENT_ADDR_TLV_TYPE) {
+ /* Fetching 4 Octets from MANAGEMENT Address TLV to get IP address. */
+ byte[] neighMgmtIpBytes = Arrays.copyOfRange(tlv.getValue(), 2, 6);
+ Ip4Address neighMgmtIpaddress = Ip4Address.valueOf(neighMgmtIpBytes);
+ neighMgmtAddr = neighMgmtIpaddress.toString();
+ }
+ }
+ }
+
+ if (systemName == null) {
+ // We expect the system name to be sent by the neighbor, in absence
+ // we don't store the information
+ return;
+ }
+
+ int portIdTlvLen = lldpPacket.getPortId().getLength();
+
+ String portName = new String(lldpPacket.getPortId().getValue())
+ .substring(1, portIdTlvLen);
+
+ // The OLT name stored in the topology information is the device uri
+ // excluding the "of:" part
+ DeviceId devId = pkt.receivedFrom().deviceId();
+ String deviceUri = devId.uri().toString();
+ String[] oltName = deviceUri.split(":", 2);
+ Port oltNni = deviceService.getPort(pkt.receivedFrom());
+
+ String devSerial = deviceService.getDevice(devId).serialNumber();
+
+ // Creating object of OltNeighborInfo with all info required.
+ OltNeighborInfo newNeighbor = new OltNeighborInfo(systemName,
+ portName,
+ oltName[1],
+ oltNni,
+ devSerial);
+ newNeighbor.setMgmtAddress(neighMgmtAddr);
+
+ // Store all the other optional in the neighbour information
+ // this is for future use
+ for (LLDPTLV tlv : optionalTLVs) {
+ if (tlv.getType() != SYSTEMNAME_TLV_TYPE && tlv.getType() != MANAGEMENT_ADDR_TLV_TYPE) {
+ newNeighbor.addOtherOptionalLldpTlvs(tlv);
+ }
+ }
+
+ /*
+ Checking if Neighbor information is already present.
+ If Yes, then update current information, else
+ adding new information.
+ */
+ OltNeighborInfo curNeighbor = neighbors.get(pkt.receivedFrom());
+ if (newNeighbor.equals(curNeighbor)) {
+ curNeighbor.updateTimeStamp();
+ neighbors.put(pkt.receivedFrom(), curNeighbor);
+ } else {
+ // received first time on this connect point or old was purged
+ neighbors.put(pkt.receivedFrom(), newNeighbor);
+ }
+ }
+ }
+
+ /**
+ * Removes Entry for device from Olt topology table.
+ *
+ * @param devIdToRm Device ID to be removed
+ */
+ void removeNeighborsOfDevice(DeviceId devIdToRm) {
+ for (Map.Entry<ConnectPoint, OltNeighborInfo> neighEntry : neighbors.entrySet()) {
+ if (neighEntry.getKey().deviceId().toString().contains(devIdToRm.toString())) {
+ neighbors.remove(neighEntry.getKey());
+ }
+ }
+ }
+
+ /**
+ * oltTopologyTimerTask method to send LLDP packets periodically to the neighbours.
+ */
+ public void oltTopologyTimerTask() {
+ oltPortMap.forEach((key, p) -> {
+ //Port p = deviceService.getPort(key, value);
+ if (p != null && p.isEnabled()) {
+ sendLldpPackets(key, p);
+ }
+ });
+ }
+
+ private class InternalDeviceListener implements DeviceListener {
+ /**
+ * Device Listener Event, will be called if Device is added or state is changed or Updated.
+ *
+ * @param event Device event
+ */
+ @Override
+ public void event(DeviceEvent event) {
+ eventExecutor.execute(() -> {
+ DeviceId devId = event.subject().id();
+ /* Checking DEVICE_REMOVED and DEVICE_AVAILABILITY_CHANGED events before
+ Mastership check as with these events mastership check will always give false.
+ */
+ if (event.type().equals(DeviceEvent.Type.DEVICE_REMOVED)) {
+ removeNeighborsOfDevice(devId);
+ return;
+ } else if (event.type().equals(DeviceEvent.Type.DEVICE_AVAILABILITY_CHANGED)) {
+ if (!deviceService.isAvailable(devId)) {
+ removeNeighborsOfDevice(devId);
+ return;
+ }
+ }
+
+ if (!mastershipService.isLocalMaster(devId)) {
+ return;
+ }
+
+ switch (event.type()) {
+ case DEVICE_ADDED:
+ if (!oltPortMap.containsKey(devId)) {
+ createAndProcessDevice(deviceService.getDevice(devId));
+ }
+ break;
+ case PORT_ADDED:
+ /*
+ If NNI port is detected, update it in the map.
+ */
+ /* TODO: put null check for the annotations return*/
+ if (isNniPort(event.port())) {
+ if (oltPortMap.containsKey(devId)) {
+ if (!updateOltData(deviceService.getDevice(devId), event.port())) {
+ return;
+ }
+ } else {
+ return;
+ }
+ }
+
+ if (Objects.nonNull(oltPortMap.get(devId)) &&
+ oltPortMap.get(devId).equals(event.port()) &&
+ event.port().isEnabled()) {
+ sendLldpPackets(devId, event.port());
+ }
+ break;
+ case PORT_REMOVED:
+ // Remove from neighbor map and LLDP flow if NNI port is removed.
+ if (Objects.nonNull(oltPortMap.get(devId)) &&
+ oltPortMap.get(devId).equals(event.port())) {
+ // the uplink port has been removed; remove the connect
+ // point from the neighbors
+ neighbors.remove(new ConnectPoint(devId, event.port().number()));
+ }
+ break;
+ case PORT_UPDATED:
+ // if Port is enabled, provision LLDP flow and send LLDP packet to NNI Port.
+ if (!oltPortMap.get(devId).equals(event.port())) {
+ break;
+ }
+ if (event.port().isEnabled()) {
+ sendLldpPackets(devId, event.port());
+ } else {
+ neighbors.remove(new ConnectPoint(devId, event.port().number()));
+ }
+ break;
+
+ default:
+ log.debug("event {} not handle for the device {}", event.type(), devId);
+ break;
+ }
+ });
+ }
+ }
+
+ /*
+ * Class to do the processing of the LLDP packets received from the Packet Service.
+ */
+ private class ReactivePacketProcessor implements PacketProcessor {
+ @Override
+ public void process(PacketContext context) {
+ packetProcessorExecutor.execute(() -> {
+ DeviceId devId = context.inPacket().receivedFrom().deviceId();
+ if (!mastershipService.isLocalMaster(devId)) {
+ return;
+ }
+ // Extract the original Ethernet frame from the packet information
+ InboundPacket pkt = context.inPacket();
+ Ethernet ethPkt = pkt.parsed();
+
+ if (ethPkt == null) {
+ log.warn("ethPkt null while processing context: {}", context);
+ return;
+ }
+
+ if (EthType.EtherType.lookup(ethPkt.getEtherType()) == EthType.EtherType.LLDP) {
+ handleLldpPacket(context.inPacket());
+ }
+ });
+ }
+ }
+}
\ No newline at end of file
diff --git a/app/src/main/java/org/opencord/olttopology/impl/OltTopologyInformationCodec.java b/app/src/main/java/org/opencord/olttopology/impl/OltTopologyInformationCodec.java
new file mode 100644
index 0000000..bd45bed
--- /dev/null
+++ b/app/src/main/java/org/opencord/olttopology/impl/OltTopologyInformationCodec.java
@@ -0,0 +1,82 @@
+/*
+ * Copyright 2017-present Open Networking Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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.opencord.olttopology.impl;
+
+import com.fasterxml.jackson.databind.node.ArrayNode;
+import com.fasterxml.jackson.databind.node.ObjectNode;
+import org.onlab.packet.LLDPTLV;
+import org.onosproject.codec.CodecContext;
+import org.onosproject.codec.JsonCodec;
+import org.opencord.olttopology.OltNeighborInfo;
+
+import java.util.Date;
+import java.util.List;
+
+/*
+Codec for JSON encoding of OLT topology information.
+ */
+public class OltTopologyInformationCodec extends JsonCodec<OltNeighborInfo> {
+ /**
+ * Encoder for the information in Json format.
+ *
+ * @param en : The topology information to be encoded
+ * @param context : The context to which the Json data needs to be added
+ * @return Json Object Node
+ */
+ @Override
+ public ObjectNode encode(OltNeighborInfo en, CodecContext context) {
+ final ObjectNode result = context.mapper().createObjectNode()
+ .put("oltName", (en.oltName() == null) ? "" : en.oltName())
+ .put("oltPort", (en.oltPort().annotations().value("portName").isEmpty()) ? "" :
+ en.oltPort().annotations().value("portName"))
+ .put("oltSerialNo", (en.oltSerialNo() == null) ? "" : en.oltSerialNo())
+ .put("neighborName", (en.neighborName() == null) ? "" : en.neighborName())
+ .put("neighborPort", (en.neighborPort() == null) ? "" : en.neighborPort())
+ .put("neighborManagementAddress", (en.mgmtAddr() == null) ? "" : en.mgmtAddr());
+
+ if (en.getOtherOptionalTlvs() != null) {
+ ArrayNode optionalTlvNodes = result.putArray("optionalTlvs");
+
+ List<LLDPTLV> optionalTlvsList = en.getOtherOptionalTlvs();
+ for (LLDPTLV tlv : optionalTlvsList) {
+ ObjectNode optionalTlvNode = context.mapper().createObjectNode();
+ optionalTlvNode.put("type", tlv.getType());
+ optionalTlvNode.put("value", "0x" + byteArrayInHex(tlv.getValue()));
+ optionalTlvNodes.add(optionalTlvNode);
+ }
+ }
+
+ Date currentTime = new Date();
+ long lastUpdatedValue = currentTime.getTime() - en.getLastUpdated().getTime();
+ long lastUpdatedSecondsValue = lastUpdatedValue / 1000;
+ result.put("last_updated", Long.toString(lastUpdatedSecondsValue));
+ return result;
+ }
+
+ /**
+ * Utility function to convert byte array to Hex String.
+ *
+ * @param bytes : The byte arrary to be converted
+ * @return Hex string representation of the byte array
+ */
+ private String byteArrayInHex(byte[] bytes) {
+ String s = "";
+ for (byte b : bytes) {
+ s += String.format("%02x", b);
+ }
+ return s;
+ }
+}
diff --git a/app/src/main/java/org/opencord/olttopology/impl/OsgiPropertyConstants.java b/app/src/main/java/org/opencord/olttopology/impl/OsgiPropertyConstants.java
new file mode 100644
index 0000000..c05d219
--- /dev/null
+++ b/app/src/main/java/org/opencord/olttopology/impl/OsgiPropertyConstants.java
@@ -0,0 +1,38 @@
+/*
+ * Copyright 2019-present Open Networking Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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.opencord.olttopology.impl;
+
+/**
+ * Constants for default values of configurable properties.
+ */
+public final class OsgiPropertyConstants {
+ public static final String DEFAULT_DEST_MAC_ADDRESS = "destMacAddress";
+ // Destination Mac address where LLDP packet has to be sent.
+ public static final String DEFAULT_DEST_MAC_ADDRESS_DEFAULT = "01:80:c2:00:00:00";
+ public static final String DEFAULT_TTL_IN_SECS = "ttlInSecs";
+ // Default Time To Live value to be used in the LLDP packets sent out
+ public static final int DEFAULT_TTL_IN_SECS_DEFAULT = 120;
+ public static final String DEFAULT_CHASSIS_ID = "chassisId";
+ // Default ChassisId to be used in the LLDP packets sent out
+ public static final int DEFAULT_CHASSIS_ID_DEFAULT = 0;
+ // Default periodicity (in minutes) of sending the LLDP messages through OLT NNI Ports
+ public static final int DEFAULT_LLDP_SEND_PERIODICITY = 15;
+ public static final String LLDP_SEND_PERIODICITY_STR = "lldpSendPeriodicity";
+
+ private OsgiPropertyConstants() {
+ }
+}
diff --git a/app/src/main/java/org/opencord/olttopology/impl/package-info.java b/app/src/main/java/org/opencord/olttopology/impl/package-info.java
new file mode 100644
index 0000000..7104a76
--- /dev/null
+++ b/app/src/main/java/org/opencord/olttopology/impl/package-info.java
@@ -0,0 +1,20 @@
+/*
+ * Copyright 2016-present Open Networking Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * OLT Topology application for finding the topology of OLTs.
+ */
+package org.opencord.olttopology.impl;
diff --git a/app/src/main/java/org/opencord/olttopology/rest/OltTopologyWebResource.java b/app/src/main/java/org/opencord/olttopology/rest/OltTopologyWebResource.java
new file mode 100644
index 0000000..bbd8f79
--- /dev/null
+++ b/app/src/main/java/org/opencord/olttopology/rest/OltTopologyWebResource.java
@@ -0,0 +1,44 @@
+/*
+ * Copyright 2017-present Open Networking Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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.opencord.olttopology.rest;
+import org.onosproject.rest.AbstractWebResource;
+import org.opencord.olttopology.OltNeighborInfo;
+import org.opencord.olttopology.OltTopologyInformationService;
+import javax.ws.rs.GET;
+import javax.ws.rs.Path;
+import javax.ws.rs.Produces;
+import javax.ws.rs.core.MediaType;
+import javax.ws.rs.core.Response;
+/**
+ * OltTopology Information Service web resource.
+ */
+@Path("oltTopologyApp")
+public class OltTopologyWebResource extends AbstractWebResource {
+ private final OltTopologyInformationService service = get(OltTopologyInformationService.class);
+ /**
+ * Shows the information about the connectivity between the
+ * ports of the OLT and ports of the leaf switch.
+ *
+ * @return 200 OK
+ */
+ @GET
+ @Path("show")
+ @Produces(MediaType.APPLICATION_JSON)
+ public Response getOltTopology() {
+ Iterable<OltNeighborInfo> neighbourInfos = service.getNeighbours().values();
+ return ok(encodeArray(OltNeighborInfo.class, "entries", neighbourInfos).toString()).build();
+ }
+}
\ No newline at end of file
diff --git a/app/src/main/java/org/opencord/olttopology/rest/package-info.java b/app/src/main/java/org/opencord/olttopology/rest/package-info.java
new file mode 100644
index 0000000..684d60d
--- /dev/null
+++ b/app/src/main/java/org/opencord/olttopology/rest/package-info.java
@@ -0,0 +1,20 @@
+/*
+ * Copyright 2016-present Open Networking Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * REST APIs for the OltTopology application.
+ */
+package org.opencord.olttopology.rest;
diff --git a/app/src/main/webapp/WEB-INF/web.xml b/app/src/main/webapp/WEB-INF/web.xml
new file mode 100644
index 0000000..359683e
--- /dev/null
+++ b/app/src/main/webapp/WEB-INF/web.xml
@@ -0,0 +1,57 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+ ~ Copyright 2016-present Open Networking Foundation
+ ~
+ ~ Licensed under the Apache License, Version 2.0 (the "License");
+ ~ you may not use this file except in compliance with the License.
+ ~ You may obtain a copy of the License at
+ ~
+ ~ http://www.apache.org/licenses/LICENSE-2.0
+ ~
+ ~ Unless required by applicable law or agreed to in writing, software
+ ~ distributed under the License is distributed on an "AS IS" BASIS,
+ ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ ~ See the License for the specific language governing permissions and
+ ~ limitations under the License.
+ -->
+<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+ xmlns="http://java.sun.com/xml/ns/javaee"
+ xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
+ xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
+ id="ONOS" version="2.5">
+ <display-name>OLT TOPOLOGY REST API v1.0</display-name>
+ <security-constraint>
+ <web-resource-collection>
+ <web-resource-name>Secured</web-resource-name>
+ <url-pattern>/*</url-pattern>
+ </web-resource-collection>
+ <auth-constraint>
+ <role-name>admin</role-name>
+ <role-name>viewer</role-name>
+ </auth-constraint>
+ </security-constraint>
+ <security-role>
+ <role-name>admin</role-name>
+ <role-name>viewer</role-name>
+ </security-role>
+ <login-config>
+ <auth-method>BASIC</auth-method>
+ <realm-name>karaf</realm-name>
+ </login-config>
+ <servlet>
+ <servlet-name>JAX-RS Service</servlet-name>
+ <servlet-class>org.glassfish.jersey.servlet.ServletContainer</servlet-class>
+ <init-param>
+ <param-name>jersey.config.server.provider.classnames</param-name>
+ <param-value>
+ org.opencord.olttopology.rest.OltTopologyWebResource
+ </param-value>
+ </init-param>
+ <load-on-startup>1</load-on-startup>
+ </servlet>
+
+ <servlet-mapping>
+ <servlet-name>JAX-RS Service</servlet-name>
+ <url-pattern>/*</url-pattern>
+ </servlet-mapping>
+</web-app>
diff --git a/app/src/test/java/org/opencord/olttopology/impl/OltTopologyTest.java b/app/src/test/java/org/opencord/olttopology/impl/OltTopologyTest.java
new file mode 100644
index 0000000..27eeec7
--- /dev/null
+++ b/app/src/test/java/org/opencord/olttopology/impl/OltTopologyTest.java
@@ -0,0 +1,706 @@
+/*
+ * Copyright 2018-present Open Networking Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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.opencord.olttopology.impl;
+
+import com.google.common.collect.Lists;
+import com.google.common.collect.Sets;
+import org.apache.commons.lang.ArrayUtils;
+import org.easymock.EasyMock;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.onlab.osgi.ComponentContextAdapter;
+import org.onlab.packet.ChassisId;
+import org.onlab.packet.Ethernet;
+import org.onlab.packet.Ip4Address;
+import org.onlab.packet.LLDP;
+import org.onlab.packet.LLDPTLV;
+import org.onlab.packet.MacAddress;
+import org.onlab.packet.VlanId;
+import org.onosproject.cfg.ComponentConfigService;
+import org.onosproject.codec.CodecService;
+import org.onosproject.core.ApplicationId;
+import org.onosproject.core.CoreServiceAdapter;
+import org.onosproject.mastership.MastershipServiceAdapter;
+import org.onosproject.net.AnnotationKeys;
+import org.onosproject.net.Annotations;
+import org.onosproject.net.ConnectPoint;
+import org.onosproject.net.DefaultAnnotations;
+import org.onosproject.net.DefaultDevice;
+import org.onosproject.net.Device;
+import org.onosproject.net.DeviceId;
+import org.onosproject.net.Element;
+import org.onosproject.net.Port;
+import org.onosproject.net.PortNumber;
+import org.onosproject.net.config.NetworkConfigListener;
+import org.onosproject.net.device.DeviceEvent;
+import org.onosproject.net.device.DeviceListener;
+import org.onosproject.net.device.DeviceServiceAdapter;
+import org.onosproject.net.provider.ProviderId;
+import org.onosproject.store.service.TestStorageService;
+import org.opencord.sadis.BaseInformationService;
+import org.opencord.sadis.SadisService;
+import org.opencord.sadis.SubscriberAndDeviceInformation;
+import org.opencord.sadis.UniTagInformation;
+import org.slf4j.Logger;
+
+import java.nio.ByteBuffer;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.is;
+import static org.hamcrest.core.IsNull.notNullValue;
+import static org.onosproject.net.intent.TestTools.assertAfter;
+import static org.opencord.olttopology.impl.OltTopology.SYSTEMNAME_TLV_TYPE;
+import static org.slf4j.LoggerFactory.getLogger;
+
+/**
+ * Tests OLT topology app.
+ */
+public class OltTopologyTest extends OltTopologyTestBase {
+ private static final VlanId CLIENT_C_TAG = VlanId.vlanId((short) 999);
+ private static final VlanId CLIENT_S_TAG = VlanId.vlanId((short) 111);
+ private static final String CLIENT_NAS_PORT_ID = "PON 1/1";
+ private static final String CLIENT_CIRCUIT_ID = "CIR-PON 1/1";
+ private static final String OLT_DEV_ID = "of:0000c6b1cd40dc93";
+ private static final MacAddress OLT_MAC_ADDRESS = MacAddress.valueOf("01:02:03:04:05:06");
+ private static final DeviceId DEVICE_ID_1 = DeviceId.deviceId(OLT_DEV_ID);
+ private static final String SCHEME_NAME = "olttopology";
+ private static final DefaultAnnotations DEVICE_ANNOTATIONS = DefaultAnnotations.builder()
+ .set(AnnotationKeys.PROTOCOL, SCHEME_NAME.toUpperCase()).build();
+ private final Logger log = getLogger(getClass());
+ ComponentConfigService mockConfigService =
+ EasyMock.createMock(ComponentConfigService.class);
+ CodecService mockCodecService =
+ EasyMock.createMock(CodecService.class);
+ private OltTopology oltTopology;
+ private NetworkConfigListener configListener;
+ private DeviceListener deviceListener;
+
+ @Before
+ public void setUp() {
+ oltTopology = new OltTopology();
+ oltTopology.mastershipService = new MockMastershipService();
+ oltTopology.deviceService = new MockDeviceService();
+ oltTopology.coreService = new MockCoreService();
+ oltTopology.componentConfigService = mockConfigService;
+ oltTopology.packetService = new MockPacketService();
+ oltTopology.flowObjectiveService = new MockFlowObjectiveService();
+ oltTopology.storageService = new TestStorageService();
+ oltTopology.codecService = mockCodecService;
+ oltTopology.subsService = new MockSubService();
+ oltTopology.sadisService = new MockSadisService();
+ oltTopology.subsService.get(OLT_DEV_ID).setUplinkPort(1);
+ oltTopology.activate(new ComponentContextAdapter());
+ }
+
+ @After
+ public void tearDown() {
+ oltTopology.deactivate();
+
+ }
+
+ private DeviceEvent deviceEvent(DeviceEvent.Type type, DeviceId did, Port port) {
+ return new DeviceEvent(type, oltTopology.deviceService.getDevice(did), port);
+
+ }
+
+ /**
+ * Fetches the sent packet at the given index. The requested packet
+ * must be the last packet on the list.
+ *
+ * @param index index into sent packets array
+ * @return packet
+ */
+ private Ethernet fetchPacket(int index) {
+ for (int iteration = 0; iteration < 20; iteration++) {
+ if (savedPackets.size() > index) {
+ return (Ethernet) savedPackets.get(index);
+ } else {
+ try {
+ Thread.sleep(250);
+ } catch (Exception ex) {
+ return null;
+ }
+ }
+ }
+ return null;
+ }
+
+ /**
+ * Testing Port Added Scenario.
+ * Note: Need to See second packet as first will be sent when MockPort is called
+ *
+ */
+ @Test
+ public void testPortAdded() {
+ Device d = oltTopology.deviceService.getDevice(DEVICE_ID_1);
+ Port port = new MockPort();
+ DeviceEvent portAdd = deviceEvent(DeviceEvent.Type.PORT_ADDED, DEVICE_ID_1, port);
+ deviceListener.event(portAdd);
+ Ethernet responsePacket = fetchPacket(1);
+ assertThat(responsePacket, notNullValue());
+ checkLldpPacket(responsePacket);
+ }
+
+ /**
+ * Testing Port Delete Scenario.
+ *
+ */
+ @Test
+ public void testPortDeleted() {
+ Device d = oltTopology.deviceService.getDevice(DEVICE_ID_1);
+ Port port = new MockPort();
+ DeviceEvent portAdd = deviceEvent(DeviceEvent.Type.PORT_ADDED, DEVICE_ID_1, port);
+ deviceListener.event(portAdd);
+ Ethernet responsePacket = fetchPacket(1);
+ assertThat(responsePacket, notNullValue());
+ checkLldpPacket(responsePacket);
+ DeviceEvent portRem = deviceEvent(DeviceEvent.Type.PORT_REMOVED, DEVICE_ID_1, port);
+ deviceListener.event(portRem);
+ }
+
+ /**
+ * Tests LLDP packet in scenario.
+ *
+ */
+ @Test
+ public void testHandlePacket() {
+ Device d = oltTopology.deviceService.getDevice(DEVICE_ID_1);
+ Port port = new MockPort();
+ DeviceEvent portAdd = deviceEvent(DeviceEvent.Type.PORT_ADDED, DEVICE_ID_1, port);
+ deviceListener.event(portAdd);
+ MacAddress destMac = MacAddress.valueOf(OsgiPropertyConstants.DEFAULT_DEST_MAC_ADDRESS_DEFAULT);
+ MacAddress srcMac = MacAddress.valueOf("c6:b1:cd:40:dc:93");
+ String serialNumber = "switch-1";
+ final short ttlInSec = 120;
+ final short chasisId = 0;
+ String portName = "p0";
+ Ip4Address devIpAddr = Ip4Address.valueOf("192.168.1.1");
+ Ethernet packet = createLldpPacket(destMac, srcMac, chasisId, portName,
+ ttlInSec, serialNumber, devIpAddr.toString());
+
+ ConnectPoint cp = new ConnectPoint(d.id(), port.number());
+ sendInboundPacket(packet, cp);
+
+ assertAfter(ASSERTION_DELAY, ASSERTION_LENGTH, () -> {
+ validateNeighborList(oltTopology.getNeighbours());
+ });
+ }
+
+ /**
+ * Tests Packet out timer functionality.
+ *
+ * @throws Exception
+ */
+ @Test
+ public void testOltTopologyTimerTask() throws Exception {
+ Device d = oltTopology.deviceService.getDevice(DEVICE_ID_1);
+ Port port = new MockPort();
+ DeviceEvent portAdd = deviceEvent(DeviceEvent.Type.PORT_ADDED, DEVICE_ID_1, port);
+ deviceListener.event(portAdd);
+ oltTopology.lldpPeriodicity(2);
+ Thread.sleep(2000);
+ Ethernet responsePacket = fetchPacket(1);
+ assertThat(responsePacket, notNullValue());
+ checkLldpPacket(responsePacket);
+ }
+
+ /**
+ * Testing Device Delete Scenario with Packet Out.
+ *
+ */
+ @Test
+ public void testDeviceDeleted() {
+ log.info("oltTopology {}", oltTopology);
+ Device d = oltTopology.deviceService.getDevice(DEVICE_ID_1);
+ Port port = new MockPort();
+ DeviceEvent portAdd = deviceEvent(DeviceEvent.Type.PORT_ADDED, DEVICE_ID_1, port);
+ deviceListener.event(portAdd);
+ Ethernet responsePacket = fetchPacket(1);
+ assertThat(responsePacket, notNullValue());
+ checkLldpPacket(responsePacket);
+ DeviceEvent portRem = deviceEvent(DeviceEvent.Type.DEVICE_REMOVED, DEVICE_ID_1, port);
+ deviceListener.event(portRem);
+ }
+
+ /**
+ * Testing Port Delete Scenario After Packet Handle for Packet in.
+ *
+ */
+ @Test
+ public void testPortDelAfterHandlePacket() {
+ Device d = oltTopology.deviceService.getDevice(DEVICE_ID_1);
+ Port port = new MockPort();
+ DeviceEvent portAdd = deviceEvent(DeviceEvent.Type.PORT_ADDED, DEVICE_ID_1, port);
+ deviceListener.event(portAdd);
+ MacAddress destMac = MacAddress.valueOf(OsgiPropertyConstants.DEFAULT_DEST_MAC_ADDRESS_DEFAULT);
+ MacAddress srcMac = MacAddress.valueOf("c6:b1:cd:40:dc:93");
+ String serialNumber = "switch-1";
+ final short ttlInSec = 120;
+ final short chasisId = 0;
+ String portName = "p0";
+ Ip4Address devIpAddr = Ip4Address.valueOf("192.168.1.1");
+ Ethernet packet = createLldpPacket(destMac, srcMac, chasisId, portName,
+ ttlInSec, serialNumber, devIpAddr.toString());
+
+ ConnectPoint cp = new ConnectPoint(d.id(), port.number());
+ sendInboundPacket(packet, cp);
+ // Need to have a delay before the validation as the packet processing now happens in a different thread
+ assertAfter(ASSERTION_DELAY, ASSERTION_LENGTH, () -> {
+ validateNeighborList(oltTopology.getNeighbours());
+ });
+ DeviceEvent portRem = deviceEvent(DeviceEvent.Type.PORT_REMOVED, DEVICE_ID_1, port);
+ deviceListener.event(portRem);
+ assertAfter(ASSERTION_DELAY, ASSERTION_LENGTH, () -> {
+ assertThat(oltTopology.getNeighbours().size(), is(0));
+ });
+ }
+
+ /**
+ * Testing Device Delete Scenario After Packet Handle for Packet in.
+ *
+ */
+ @Test
+ public void testDeviceDelAfterHandlePacket() {
+ Device d = oltTopology.deviceService.getDevice(DEVICE_ID_1);
+ Port port = new MockPort();
+ DeviceEvent portAdd = deviceEvent(DeviceEvent.Type.PORT_ADDED, DEVICE_ID_1, port);
+ deviceListener.event(portAdd);
+ MacAddress destMac = MacAddress.valueOf(OsgiPropertyConstants.DEFAULT_DEST_MAC_ADDRESS_DEFAULT);
+ MacAddress srcMac = MacAddress.valueOf("c6:b1:cd:40:dc:93");
+ String serialNumber = "switch-1";
+ final short ttlInSec = 120;
+ final short chasisId = 0;
+ String portName = "p0";
+ Ip4Address devIpAddr = Ip4Address.valueOf("192.168.1.1");
+ Ethernet packet = createLldpPacket(destMac, srcMac, chasisId, portName,
+ ttlInSec, serialNumber, devIpAddr.toString());
+
+ ConnectPoint cp = new ConnectPoint(d.id(), port.number());
+ sendInboundPacket(packet, cp);
+ assertAfter(ASSERTION_DELAY, ASSERTION_LENGTH, () -> {
+ validateNeighborList(oltTopology.getNeighbours());
+ assertThat(oltTopology.getNeighbours().size(), is(1));
+ });
+ DeviceEvent portRem = deviceEvent(DeviceEvent.Type.DEVICE_REMOVED, DEVICE_ID_1, port);
+ deviceListener.event(portRem);
+ assertAfter(ASSERTION_DELAY, ASSERTION_LENGTH, () -> {
+ assertThat(oltTopology.getNeighbours().size(), is(0));
+ });
+ }
+
+ /**
+ * Creates dummy packet for LLDP packet to test Packet in scenario.
+ *
+ * @param destMac Destination Mac address of LLDP packet
+ * @param srcMac Source mac address of LLDP packet
+ * @param chassisId Chassis ID tlv value
+ * @param port port Id tlv value
+ * @param ttl TTL tlv value
+ * @param systemName System name tlv value
+ * @param mgmtAddr Management Address tlv value
+ * @return LLDP ethernet packet
+ */
+ private Ethernet createLldpPacket(MacAddress destMac, MacAddress srcMac,
+ int chassisId, String port, short ttl,
+ String systemName, String mgmtAddr) {
+ Ethernet ethPkt = new Ethernet();
+ ethPkt.setEtherType(Ethernet.TYPE_LLDP);
+ ethPkt.setDestinationMACAddress(destMac);
+ ethPkt.setSourceMACAddress(srcMac);
+
+ LLDP lldpPkt = new LLDP();
+
+ setChassisId(lldpPkt, chassisId);
+ setPortId(lldpPkt, port);
+ setTtl(lldpPkt, ttl);
+
+ List<LLDPTLV> optionalTlv = new ArrayList<>();
+ optionalTlv.add(createSystemNameTlv(systemName));
+ optionalTlv.add(createMgmtAddressTlv(mgmtAddr));
+
+ lldpPkt.setOptionalTLVList(optionalTlv);
+
+ ethPkt.setPayload(lldpPkt);
+ return ethPkt;
+ }
+
+ /**
+ * Sets Chassis ID TLV for LLDP packet.
+ *
+ * @param lldpPkt LLDP packet reference
+ * @param chassisId Chassid ID tlv value
+ */
+ private void setChassisId(LLDP lldpPkt, final int chassisId) {
+ final byte chassisTlvSubtype = 1;
+
+ byte[] chassis = ArrayUtils.addAll(new byte[]{chassisTlvSubtype},
+ ByteBuffer.allocate(String.valueOf(chassisId).length())
+ .put(String.valueOf(chassisId).getBytes()).array());
+
+ LLDPTLV chassisTlv = new LLDPTLV();
+ lldpPkt.setChassisId(chassisTlv.setLength((byte) chassis.length)
+ .setType(LLDP.CHASSIS_TLV_TYPE)
+ .setValue(chassis));
+ }
+
+ /**
+ * Sets Port ID tlv for LLDP packet.
+ *
+ * @param lldpPkt LLDP packet reference
+ * @param ifaceName Port Name TLV value
+ */
+ public void setPortId(LLDP lldpPkt, final String ifaceName) {
+ final byte portTlvSubtype = 5;
+
+ byte[] port = ArrayUtils.addAll(new byte[]{portTlvSubtype},
+ ifaceName.getBytes());
+
+ LLDPTLV portTlv = new LLDPTLV();
+ lldpPkt.setPortId(portTlv.setLength((byte) port.length)
+ .setType(LLDP.PORT_TLV_TYPE)
+ .setValue(port));
+ }
+
+ /**
+ * Sets TTL tlv for LLDP packet.
+ *
+ * @param lldpPkt LLDP Packet reference
+ * @param timeInSecs TTL tlv value in sec
+ */
+ public void setTtl(LLDP lldpPkt, final short timeInSecs) {
+ byte[] time = ByteBuffer.allocate(2).putShort(timeInSecs).array();
+ LLDPTLV ttlTlv = new LLDPTLV();
+ lldpPkt.setTtl(ttlTlv.setType(LLDP.TTL_TLV_TYPE)
+ .setLength((short) time.length)
+ .setValue(time));
+ }
+
+ /**
+ * Sets System name tlv for LLDP packet.
+ *
+ * @param systemName System name tlv value
+ * @return systemName tlv
+ */
+ public LLDPTLV createSystemNameTlv(String systemName) {
+ byte[] bytes = systemName.getBytes();
+ LLDPTLV sysNameTlv = new LLDPTLV();
+ return sysNameTlv.setType(SYSTEMNAME_TLV_TYPE)
+ .setLength((byte) bytes.length)
+ .setValue(bytes);
+ }
+
+ /**
+ * Sets Management address tlv for LLDP packet.
+ *
+ * @param mgmtAddress Management address tlv value
+ * @return Management address tlv
+ */
+ public LLDPTLV createMgmtAddressTlv(String mgmtAddress) {
+ final byte mgmtAddressTlvType = 0x8;
+ final byte ipAddressSubType = 0x1; // IPv4
+ // 5 below is address subtype + IP4 address len
+ final byte ipAddrStrLen = 0x5;
+ final byte interfaceSubtype = 0x1;
+ final int interfaceNum = 0;
+ final byte oidString = 0x0;
+ Ip4Address ipAddr = Ip4Address.valueOf(mgmtAddress);
+
+ byte[] addrStr = ArrayUtils.addAll(new byte[]{ipAddressSubType},
+ ipAddr.toOctets());
+
+ byte[] ipAddrBytes = ArrayUtils.addAll(new byte[]{ipAddrStrLen},
+ addrStr);
+ byte[] bytesInterfacetype = ArrayUtils.addAll(ipAddrBytes,
+ ByteBuffer.allocate(1).put(interfaceSubtype).array());
+ byte[] bytesInterfaceNumber = ArrayUtils.addAll(bytesInterfacetype,
+ ByteBuffer.allocate(4).putInt(interfaceNum).array());
+ byte[] finalMgmtAddrBytes = ArrayUtils.addAll(bytesInterfaceNumber,
+ ByteBuffer.allocate(1).put(oidString).array());
+
+ LLDPTLV mgmtAddrTlv = new LLDPTLV();
+ return mgmtAddrTlv.setType(mgmtAddressTlvType)
+ .setLength((byte) finalMgmtAddrBytes.length)
+ .setValue(finalMgmtAddrBytes);
+ }
+
+ /*
+ Mocks application id.
+ */
+ private static final class MockApplicationId implements ApplicationId {
+
+ private final short id;
+ private final String name;
+
+ public MockApplicationId(short id, String name) {
+ this.id = id;
+ this.name = name;
+ }
+
+ @Override
+ public short id() {
+ return id;
+ }
+
+ @Override
+ public String name() {
+ return name;
+ }
+ }
+
+ /*
+ Mocks Core service adapter.
+ */
+ private static final class MockCoreService extends CoreServiceAdapter {
+
+ private List<ApplicationId> idList = new ArrayList<>();
+ private Map<String, ApplicationId> idMap = new HashMap<>();
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see
+ * org.onosproject.core.CoreServiceAdapter#getAppId(java.lang.Short)
+ */
+ @Override
+ public ApplicationId getAppId(Short id) {
+ if (id >= idList.size()) {
+ return null;
+ }
+ return idList.get(id);
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see
+ * org.onosproject.core.CoreServiceAdapter#getAppId(java.lang.String)
+ */
+ @Override
+ public ApplicationId getAppId(String name) {
+ return idMap.get(name);
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see
+ * org.onosproject.core.CoreServiceAdapter#registerApplication(java.lang
+ * .String)
+ */
+ @Override
+ public ApplicationId registerApplication(String name) {
+ ApplicationId appId = idMap.get(name);
+ if (appId == null) {
+ appId = new MockApplicationId((short) idList.size(), name);
+ idList.add(appId);
+ idMap.put(name, appId);
+ }
+ return appId;
+ }
+
+ }
+
+ private static class MockMastershipService extends MastershipServiceAdapter {
+ @Override
+ public boolean isLocalMaster(DeviceId d) {
+ return true;
+ }
+ }
+
+ private static class MockDevice extends DefaultDevice {
+
+ /*
+ Mocks OLT device.
+ */
+ public MockDevice(ProviderId providerId, DeviceId id, Type type,
+ String manufacturer, String hwVersion, String swVersion,
+ String serialNumber, ChassisId chassisId, Annotations... annotations) {
+ super(providerId, id, type, manufacturer, hwVersion, swVersion, serialNumber,
+ chassisId, annotations);
+ }
+ }
+
+ private static class MockSadisService implements SadisService {
+
+ @Override
+ public MockSubService getSubscriberInfoService() {
+ return new MockSubService();
+ }
+
+ @Override
+ public MockSubService getBandwidthProfileService() {
+ return new MockSubService();
+ }
+
+ }
+
+ /*
+ Mocks SubscriberAndDeviceInformationService(SADIS) information.
+ */
+ private static class MockSubService implements BaseInformationService {
+ MockSubscriberAndDeviceInformation device =
+ new MockSubscriberAndDeviceInformation(OLT_DEV_ID, VlanId.NONE, VlanId.NONE, null, null,
+ OLT_MAC_ADDRESS, Ip4Address.valueOf("10.10.10.10"));
+ MockSubscriberAndDeviceInformation sub =
+ new MockSubscriberAndDeviceInformation(CLIENT_NAS_PORT_ID, CLIENT_C_TAG,
+ CLIENT_S_TAG, CLIENT_NAS_PORT_ID, CLIENT_CIRCUIT_ID, null, null);
+
+ @Override
+ public SubscriberAndDeviceInformation get(String id) {
+ if (id.equals(OLT_DEV_ID)) {
+ return device;
+ } else {
+ return sub;
+ }
+ }
+
+ @Override
+ public void invalidateAll() {
+ }
+
+ public void invalidateId(String id) {
+ }
+
+ public SubscriberAndDeviceInformation getfromCache(String id) {
+ return null;
+ }
+ }
+
+ /*
+ Mocks SubscriberAndDeviceInformation.
+ */
+ private static class MockSubscriberAndDeviceInformation extends SubscriberAndDeviceInformation {
+
+ MockSubscriberAndDeviceInformation(String id, VlanId ctag,
+ VlanId stag, String nasPortId,
+ String circuitId, MacAddress hardId,
+ Ip4Address ipAddress) {
+ UniTagInformation uniTagInformation = new UniTagInformation.Builder()
+ .setPonCTag(ctag)
+ .setPonSTag(stag)
+ .build();
+ List<UniTagInformation> uniTagInformationList = Lists.newArrayList(uniTagInformation);
+ this.setUniTagList(uniTagInformationList);
+ // this.setCTag(ctag);
+ this.setHardwareIdentifier(hardId);
+ this.setId(id);
+ this.setIPAddress(ipAddress);
+// this.setSTag(stag);
+ this.setNasPortId(nasPortId);
+ this.setCircuitId(circuitId);
+ }
+ }
+
+ private static class MockPort implements Port {
+
+ @Override
+ public boolean isEnabled() {
+ return true;
+ }
+
+ public long portSpeed() {
+ return 1000;
+ }
+
+ public Element element() {
+ return null;
+ }
+
+ public PortNumber number() {
+ return PortNumber.portNumber(1);
+ }
+
+ public Annotations annotations() {
+ return new MockAnnotations();
+ }
+
+ public Type type() {
+ return Port.Type.FIBER;
+ }
+
+ private static class MockAnnotations implements Annotations {
+
+ @Override
+ public String value(String val) {
+ return "nni-";
+ }
+
+ public Set<String> keys() {
+ return Sets.newHashSet("portName");
+ }
+ }
+ }
+
+ /*
+ Mocks Device Service Adapter.
+ */
+ private class MockDeviceService extends DeviceServiceAdapter {
+
+ private ProviderId providerId = new ProviderId("of", "foo");
+ private final Device device1 = new MockDevice(providerId, DEVICE_ID_1, Device.Type.SWITCH,
+ "foo.inc", "0", "0", OLT_DEV_ID, new ChassisId(),
+ DEVICE_ANNOTATIONS);
+
+ @Override
+ public Device getDevice(DeviceId devId) {
+ return device1;
+
+ }
+
+ @Override
+ public Iterable<Device> getDevices() {
+ List<Device> devices = new ArrayList<>();
+ devices.add(device1);
+ return devices;
+ }
+
+ @Override
+ public Port getPort(ConnectPoint cp) {
+ return new MockPort();
+ }
+
+ @Override
+ public Port getPort(DeviceId deviceId, PortNumber portNumber) {
+ return new MockPort();
+ }
+
+ @Override
+ public List<Port> getPorts(DeviceId deviceId) {
+ return Lists.newArrayList(new MockPort());
+ }
+
+ @Override
+ public boolean isAvailable(DeviceId d) {
+ return true;
+ }
+
+ @Override
+ public void addListener(DeviceListener listener) {
+ deviceListener = listener;
+ }
+
+ @Override
+ public void removeListener(DeviceListener listener) {
+
+ }
+ }
+}
diff --git a/app/src/test/java/org/opencord/olttopology/impl/OltTopologyTestBase.java b/app/src/test/java/org/opencord/olttopology/impl/OltTopologyTestBase.java
new file mode 100644
index 0000000..6dbfc5c
--- /dev/null
+++ b/app/src/test/java/org/opencord/olttopology/impl/OltTopologyTestBase.java
@@ -0,0 +1,241 @@
+/*
+ * Copyright 2018-present Open Networking Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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.opencord.olttopology.impl;
+
+import org.apache.commons.lang.ArrayUtils;
+import org.onlab.packet.BasePacket;
+import org.onlab.packet.Ethernet;
+import org.onlab.packet.EthType;
+import org.onlab.packet.Ip4Address;
+import org.onlab.packet.LLDP;
+import org.onlab.packet.LLDPTLV;
+import org.onlab.packet.MacAddress;
+
+
+import org.onosproject.net.ConnectPoint;
+import org.onosproject.net.DeviceId;
+import org.onosproject.net.flow.criteria.Criterion;
+import org.onosproject.net.flow.criteria.EthTypeCriterion;
+import org.onosproject.net.flowobjective.FilteringObjective;
+import org.onosproject.net.flowobjective.FlowObjectiveServiceAdapter;
+import org.onosproject.net.packet.DefaultInboundPacket;
+import org.onosproject.net.packet.InboundPacket;
+import org.onosproject.net.packet.OutboundPacket;
+import org.onosproject.net.packet.DefaultPacketContext;
+import org.onosproject.net.packet.PacketContext;
+import org.onosproject.net.packet.PacketProcessor;
+import org.onosproject.net.packet.PacketServiceAdapter;
+
+import static org.hamcrest.Matchers.is;
+import static org.hamcrest.Matchers.instanceOf;
+import static org.hamcrest.Matchers.notNullValue;
+
+import org.opencord.olttopology.OltNeighborInfo;
+import org.slf4j.Logger;
+
+import static org.junit.Assert.assertThat;
+
+import java.nio.ByteBuffer;
+import java.util.Collection;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+
+import static org.junit.Assert.fail;
+
+
+import static org.slf4j.LoggerFactory.getLogger;
+
+/*
+Olt topology test base class.
+ */
+public class OltTopologyTestBase {
+ private final Logger log = getLogger(getClass());
+
+ //Time in ms to wait before checking packets
+ static final int ASSERTION_DELAY = 250;
+ //Duration in ms of the assertion for packets
+ static final int ASSERTION_LENGTH = 250;
+
+ private static final String EXPECTED_IP = "10.10.10.10";
+ private static final String EXPECTED_OLT_DEV_ID = "of:0000c6b1cd40dc93";
+ private static final DeviceId EXPECTED_DEVICE_ID_1 = DeviceId.deviceId(EXPECTED_OLT_DEV_ID);
+
+
+
+ List<BasePacket> savedPackets = new LinkedList<>();
+ PacketProcessor packetProcessor;
+ MacAddress srcMac = MacAddress.valueOf("c6:b1:cd:40:dc:93");
+ MacAddress dstMac = MacAddress.valueOf(OsgiPropertyConstants.DEFAULT_DEST_MAC_ADDRESS_DEFAULT);
+
+
+ /**
+ * Saves the given packet onto the saved packets list.
+ *
+ * @param packet packet to save
+ */
+ void savePacket(BasePacket packet) {
+ savedPackets.add(packet);
+ }
+
+ /**
+ * Sends packet to Packer process to test Handle packet functionality.
+ * @param packet LLDP ethernet packet
+ * @param cp Device connect point info
+ */
+ void sendInboundPacket(Ethernet packet, ConnectPoint cp) {
+ final ByteBuffer byteBuffer = ByteBuffer.wrap(packet.serialize());
+ InboundPacket inPacket = new DefaultInboundPacket(cp, packet, byteBuffer);
+ PacketContext context = new TestPacketContext(127L, inPacket, null, false);
+ packetProcessor.process(context);
+ }
+
+ /**
+ * Validates LLDP packet out functionality.
+ * @param responsePacket LLDP packet
+ */
+ void checkLldpPacket(Ethernet responsePacket) {
+ assertThat(responsePacket.getSourceMAC(), is(srcMac));
+ assertThat(responsePacket.getDestinationMAC(), is(dstMac));
+ assertThat(responsePacket.getPayload(), instanceOf(LLDP.class));
+ assertThat(responsePacket.getEtherType(), is(Ethernet.TYPE_LLDP));
+ LLDP lldp = (LLDP) responsePacket.getPayload();
+ assertThat(lldp, notNullValue());
+ assertThat(lldp.getPortId(), notNullValue());
+ String portName = "nni-";
+ byte[] port = ArrayUtils.addAll(new byte[] {5}, portName.getBytes());
+ assertThat(lldp.getPortId().getValue(), is(port));
+ assertThat(lldp.getChassisId(), notNullValue());
+ int chassisId = 0;
+ byte[] chassis = ArrayUtils.addAll(new byte[] {1},
+ ByteBuffer.allocate(String.valueOf(chassisId).length())
+ .put(String.valueOf(chassisId).getBytes()).array());
+ assertThat(lldp.getChassisId().getValue(), is(chassis));
+ assertThat(lldp.getTtl().getValue(), notNullValue());
+ short ttl = 120;
+ byte[] time = ByteBuffer.allocate(2).putShort(ttl).array();
+ assertThat(lldp.getTtl().getValue(), is(time));
+ assertThat(lldp.getOptionalTLVList(), notNullValue());
+ List<LLDPTLV> optionalTlvs = lldp.getOptionalTLVList();
+ for (LLDPTLV tlv: optionalTlvs) {
+ if (tlv.getType() == OltTopology.SYSTEMNAME_TLV_TYPE) {
+ assertThat(tlv.getValue(), notNullValue());
+ String[] systemName = EXPECTED_DEVICE_ID_1.toString().split(":", 2);
+ byte[] deviceId = systemName[1].getBytes();
+ assertThat(tlv.getValue(), is(deviceId));
+ } else if (tlv.getType() == OltTopology.MANAGEMENT_ADDR_TLV_TYPE) {
+ assertThat(tlv.getValue(), notNullValue());
+ final byte ipAddressSubType = 0x1; // IPv4
+ // 5 below is address subtype + IP4 address len
+ final byte ipAddrStrLen = 0x5;
+ final byte interfaceSubtype = 0x1;
+ final int interfaceNum = 0;
+ final byte oidString = 0x0;
+ Ip4Address ipAddr = Ip4Address.valueOf(EXPECTED_IP);
+
+ byte[] addrStr = ArrayUtils.addAll(new byte[] {ipAddressSubType},
+ ipAddr.toOctets());
+
+ byte[] ipAddrBytes = ArrayUtils.addAll(new byte[] {ipAddrStrLen},
+ addrStr);
+ byte[] bytesInterfacetype = ArrayUtils.addAll(ipAddrBytes,
+ ByteBuffer.allocate(1).put(interfaceSubtype).array());
+ byte[] bytesInterfaceNumber = ArrayUtils.addAll(bytesInterfacetype,
+ ByteBuffer.allocate(4).putInt(interfaceNum).array());
+ byte[] finalMgmtAddrBytes = ArrayUtils.addAll(bytesInterfaceNumber,
+ ByteBuffer.allocate(1).put(oidString).array());
+ assertThat(tlv.getValue(), is(finalMgmtAddrBytes));
+
+ }
+ }
+ }
+
+ /**
+ * Validates Neightbour list table.
+ * @param neighborList Neighbour list table created using inbound LLDP packets.
+ */
+ void validateNeighborList(Map<ConnectPoint, OltNeighborInfo> neighborList) {
+ assertThat(neighborList, notNullValue());
+ assertThat(neighborList.size(), is(1));
+ for (Map.Entry<ConnectPoint, OltNeighborInfo> entry: neighborList.entrySet()) {
+ assertThat(entry.getValue().mgmtAddr(), is("192.168.1.1"));
+ assertThat(entry.getValue().neighborName(), is("switch-1"));
+ assertThat(entry.getValue().neighborPort(), is("p0"));
+ assertThat(entry.getValue().oltName(), is("0000c6b1cd40dc93"));
+ assertThat(entry.getValue().oltPort().annotations().value("portName"), is("nni-"));
+ }
+ }
+ /**
+ * Keeps a reference to the PacketProcessor and saves the OutboundPackets.
+ */
+ class MockPacketService extends PacketServiceAdapter {
+
+ @Override
+ public void addProcessor(PacketProcessor processor, int priority) {
+ packetProcessor = processor;
+ }
+
+ @Override
+ public void emit(OutboundPacket packet) {
+ try {
+ Ethernet eth = Ethernet.deserializer().deserialize(packet.data().array(),
+ 0, packet.data().array().length);
+ savePacket(eth);
+ } catch (Exception e) {
+ fail(e.getMessage());
+ }
+ }
+ }
+ /**
+ * Mock Flow Objective Service.
+ */
+ public static class MockFlowObjectiveService extends FlowObjectiveServiceAdapter {
+
+ @Override
+ public void filter(DeviceId deviceId, FilteringObjective filter) {
+ assertThat(deviceId, notNullValue());
+ assertThat(filter, notNullValue());
+ EthTypeCriterion ethType = (EthTypeCriterion)
+ filterForCriterion(filter.conditions(), Criterion.Type.ETH_TYPE);
+ assertThat(ethType, notNullValue());
+ assertThat(ethType.ethType(), is(EthType.EtherType.LLDP.ethType()));
+ assertThat(filter.key().type(), is(Criterion.Type.IN_PORT));
+
+ }
+ private Criterion filterForCriterion(Collection<Criterion> criteria, Criterion.Type type) {
+ return criteria.stream()
+ .filter(c -> c.type().equals(type))
+ .limit(1)
+ .findFirst().orElse(null);
+ }
+
+ }
+ /**
+ * Mocks the DefaultPacketContext.
+ */
+ static final class TestPacketContext extends DefaultPacketContext {
+
+ private TestPacketContext(long time, InboundPacket inPkt,
+ OutboundPacket outPkt, boolean block) {
+ super(time, inPkt, outPkt, block);
+ }
+
+ @Override
+ public void send() {
+ // We don't send anything out.
+ }
+ }
+}
diff --git a/app/src/test/java/org/opencord/olttopology/impl/package-info.java b/app/src/test/java/org/opencord/olttopology/impl/package-info.java
new file mode 100755
index 0000000..7104a76
--- /dev/null
+++ b/app/src/test/java/org/opencord/olttopology/impl/package-info.java
@@ -0,0 +1,20 @@
+/*
+ * Copyright 2016-present Open Networking Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * OLT Topology application for finding the topology of OLTs.
+ */
+package org.opencord.olttopology.impl;
diff --git a/pom.xml b/pom.xml
new file mode 100644
index 0000000..080af98
--- /dev/null
+++ b/pom.xml
@@ -0,0 +1,153 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+ ~ Copyright 2015-present Open Networking Foundation
+ ~
+ ~ Licensed under the Apache License, Version 2.0 (the "License");
+ ~ you may not use this file except in compliance with the License.
+ ~ You may obtain a copy of the License at
+ ~
+ ~ http://www.apache.org/licenses/LICENSE-2.0
+ ~
+ ~ Unless required by applicable law or agreed to in writing, software
+ ~ distributed under the License is distributed on an "AS IS" BASIS,
+ ~ WITHOUT 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:xsi="http://www.w3.org/2001/XMLSchema-instance"
+ xmlns="http://maven.apache.org/POM/4.0.0"
+ xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+ <modelVersion>4.0.0</modelVersion>
+
+ <parent>
+ <groupId>org.onosproject</groupId>
+ <artifactId>onos-dependencies</artifactId>
+ <version>2.2.7</version>
+ <relativePath></relativePath>
+ </parent>
+
+ <groupId>org.opencord</groupId>
+ <artifactId>olttopology</artifactId>
+ <version>1.0.1</version>
+ <packaging>pom</packaging>
+
+ <properties>
+ <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+ <onos.version>2.2.7</onos.version>
+ <onos.app.name>org.opencord.olttopology</onos.app.name>
+ <onos.app.title>OLT Access Management</onos.app.title>
+ <onos.app.origin>OpenCord</onos.app.origin>
+ <onos.app.category>default</onos.app.category>
+ <onos.app.url>http://opencord.org</onos.app.url>
+ <onos.app.readme>CORD OLT Access management application</onos.app.readme>
+ </properties>
+
+ <modules>
+ <module>api</module>
+ <module>app</module>
+ </modules>
+
+ <dependencies>
+ <dependency>
+ <groupId>org.onosproject</groupId>
+ <artifactId>onos-api</artifactId>
+ <version>${onos.version}</version>
+ </dependency>
+
+ <dependency>
+ <groupId>org.onosproject</groupId>
+ <artifactId>onlab-misc</artifactId>
+ <version>${onos.version}</version>
+ </dependency>
+
+ <dependency>
+ <groupId>org.onosproject</groupId>
+ <artifactId>onlab-osgi</artifactId>
+ <version>${onos.version}</version>
+ </dependency>
+
+ <dependency>
+ <groupId>org.onosproject</groupId>
+ <artifactId>onos-cli</artifactId>
+ <version>${onos.version}</version>
+ </dependency>
+
+ <dependency>
+ <groupId>org.onosproject</groupId>
+ <artifactId>onos-api</artifactId>
+ <version>${onos.version}</version>
+ <scope>test</scope>
+ <classifier>tests</classifier>
+ </dependency>
+ <dependency>
+ <groupId>org.onosproject</groupId>
+ <artifactId>onlab-osgi</artifactId>
+ <version>${onos.version}</version>
+ <classifier>tests</classifier>
+ <scope>test</scope>
+ </dependency>
+
+ <dependency>
+ <groupId>org.onosproject</groupId>
+ <artifactId>onos-core-common</artifactId>
+ <version>${onos.version}</version>
+ </dependency>
+
+ </dependencies>
+
+ <repositories>
+ <repository>
+ <id>central</id>
+ <name>Central Repository</name>
+ <url>https://repo.maven.apache.org/maven2</url>
+ <layout>default</layout>
+ <snapshots>
+ <enabled>false</enabled>
+ </snapshots>
+ <releases>
+ <enabled>true</enabled>
+ <updatePolicy>always</updatePolicy>
+ <checksumPolicy>fail</checksumPolicy>
+ </releases>
+ </repository>
+
+ <repository>
+ <id>snapshots</id>
+ <url>https://oss.sonatype.org/content/repositories/snapshots</url>
+ <snapshots>
+ <enabled>true</enabled>
+ <updatePolicy>always</updatePolicy>
+ <checksumPolicy>fail</checksumPolicy>
+ </snapshots>
+ </repository>
+ </repositories>
+
+ <build>
+ <plugins>
+ <plugin>
+ <groupId>org.apache.maven.plugins</groupId>
+ <artifactId>maven-source-plugin</artifactId>
+ </plugin>
+ <!-- SpotBugs Static Analysis -->
+ <plugin>
+ <groupId>com.github.spotbugs</groupId>
+ <artifactId>spotbugs-maven-plugin</artifactId>
+ <version>4.0.4</version>
+ <configuration>
+ <effort>Max</effort>
+ <threshold>Low</threshold>
+ <failOnError>false</failOnError>
+ <includeFilterFile>${session.executionRootDirectory}/spotbugs-security-include.xml</includeFilterFile>
+ <excludeFilterFile>${session.executionRootDirectory}/spotbugs-security-exclude.xml</excludeFilterFile>
+ <plugins>
+ <plugin>
+ <groupId>com.h3xstream.findsecbugs</groupId>
+ <artifactId>findsecbugs-plugin</artifactId>
+ <version>1.10.1</version>
+ </plugin>
+ </plugins>
+ </configuration>
+ </plugin>
+ </plugins>
+ </build>
+</project>
\ No newline at end of file
diff --git a/spotbugs-security-exclude.xml b/spotbugs-security-exclude.xml
new file mode 100644
index 0000000..4aa0021
--- /dev/null
+++ b/spotbugs-security-exclude.xml
@@ -0,0 +1,17 @@
+<!--
+ ~ Copyright 2020-present Open Networking Foundation
+ ~
+ ~ Licensed under the Apache License, Version 2.0 (the "License");
+ ~ you may not use this file except in compliance with the License.
+ ~ You may obtain a copy of the License at
+ ~
+ ~ http://www.apache.org/licenses/LICENSE-2.0
+ ~
+ ~ Unless required by applicable law or agreed to in writing, software
+ ~ distributed under the License is distributed on an "AS IS" BASIS,
+ ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ ~ See the License for the specific language governing permissions and
+ ~ limitations under the License.
+ -->
+<FindBugsFilter>
+</FindBugsFilter>
\ No newline at end of file
diff --git a/spotbugs-security-include.xml b/spotbugs-security-include.xml
new file mode 100644
index 0000000..b3b408f
--- /dev/null
+++ b/spotbugs-security-include.xml
@@ -0,0 +1,20 @@
+<!--
+ ~ Copyright 2020-present Open Networking Foundation
+ ~
+ ~ Licensed under the Apache License, Version 2.0 (the "License");
+ ~ you may not use this file except in compliance with the License.
+ ~ You may obtain a copy of the License at
+ ~
+ ~ http://www.apache.org/licenses/LICENSE-2.0
+ ~
+ ~ Unless required by applicable law or agreed to in writing, software
+ ~ distributed under the License is distributed on an "AS IS" BASIS,
+ ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ ~ See the License for the specific language governing permissions and
+ ~ limitations under the License.
+ -->
+<FindBugsFilter>
+ <Match>
+ <Bug category="SECURITY"/>
+ </Match>
+</FindBugsFilter>
\ No newline at end of file