ISIS protocol manual merge from 1.6 due to cherry pick merge conflict

Change-Id: I6c3abf6a83ddaeba76293dc7864fcec88e9b4e7e

@@ -16,9 +16,11 @@
 package org.onosproject.isis.controller;
 package org.onosproject.isis.controller;
 
 
 import com.fasterxml.jackson.databind.JsonNode;
 import com.fasterxml.jackson.databind.JsonNode;
+import org.onosproject.isis.controller.topology.IsisLinkListener;
 import org.onosproject.isis.controller.topology.IsisRouterListener;
 import org.onosproject.isis.controller.topology.IsisRouterListener;
 
 
 import java.util.List;
 import java.util.List;
+import java.util.Set;
 
 
 /**
 /**
  * Representation of an ISIS controller.
  * Representation of an ISIS controller.
@@ -52,4 +54,32 @@ public interface IsisController {
      * @return list of process instances
      * @return list of process instances
      */
      */
     List<IsisProcess> allConfiguredProcesses();
     List<IsisProcess> allConfiguredProcesses();
+
+    /**
+     * Registers a listener for ISIS message events.
+     *
+     * @param listener the listener to notify
+     */
+    void addLinkListener(IsisLinkListener listener);
+
+    /**
+     * Unregisters a link listener.
+     *
+     * @param listener the listener to unregister
+     */
+    void removeLinkListener(IsisLinkListener listener);
+
+    /**
+     * Gets the list of listeners registered for router events.
+     *
+     * @return list of listeners
+     */
+    Set<IsisRouterListener> listener();
+
+    /**
+     * Gets the list of listeners registered for link events.
+     *
+     * @return list of listeners
+     */
+    Set<IsisLinkListener> linkListener();
 }
 }
\ No newline at end of file

@@ -318,4 +318,4 @@ public interface IsisInterface {
      * Removes all the neighbors.
      * Removes all the neighbors.
      */
      */
     void removeNeighbors();
     void removeNeighbors();
-}
+}
\ No newline at end of file

@@ -122,4 +122,11 @@ public interface IsisLsdb {
      * @param l2LspSeqNo link state sequence number
      * @param l2LspSeqNo link state sequence number
      */
      */
     void setL2LspSeqNo(int l2LspSeqNo);
     void setL2LspSeqNo(int l2LspSeqNo);
+    /**
+     * Removes topology information when neighbor down.
+     *
+     * @param neighbor ISIS neighbor instance
+     * @param isisInterface ISIS interface instance
+     */
+    void removeTopology(IsisNeighbor neighbor, IsisInterface isisInterface);
 }
 }
\ No newline at end of file

@@ -69,4 +69,4 @@ public interface IsisLsdbAge {
      * @param lspWrapper LSP wrapper instance
      * @param lspWrapper LSP wrapper instance
      */
      */
     void removeLspFromBin(LspWrapper lspWrapper);
     void removeLspFromBin(LspWrapper lspWrapper);
-}
+}
\ No newline at end of file

@@ -44,4 +44,4 @@ public interface IsisLspBin {
      * @param lspWrapper LSP wrapper instance
      * @param lspWrapper LSP wrapper instance
      */
      */
     void removeIsisLsp(String lspKey, LspWrapper lspWrapper);
     void removeIsisLsp(String lspKey, LspWrapper lspWrapper);
-}
+}
\ No newline at end of file

@@ -43,7 +43,6 @@ public enum IsisNetworkType {
 
 
     private int value;
     private int value;
 
 
-
     /**
     /**
      * Creates an instance of ISIS network type.
      * Creates an instance of ISIS network type.
      *
      *

@@ -124,4 +124,4 @@ public interface LspWrapper {
      * @param lspProcessing "refreshLsp" or "maxageLsp" based on LSP to process
      * @param lspProcessing "refreshLsp" or "maxageLsp" based on LSP to process
      */
      */
     void setLspProcessing(String lspProcessing);
     void setLspProcessing(String lspProcessing);
-}
+}
\ No newline at end of file

+/*
+ * Copyright 2016 Open Networking Laboratory
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.onosproject.isis.controller.topology;
+
+import org.onlab.packet.Ip4Address;
+
+/**
+ * Representation of an ISIS device information.
+ */
+public interface DeviceInformation {
+
+    /**
+     * Gets system id.
+     *
+     * @return system id
+     */
+    String systemId();
+
+    /**
+     * Sets system id.
+     *
+     * @param systemId system id
+     */
+    void setSystemId(String systemId);
+
+    /**
+     * Gets interface ids.
+     *
+     * @return interface ids
+     */
+    Ip4Address interfaceId();
+
+    /**
+     * Sets interface id.
+     *
+     * @param interfaceId interface id
+     */
+    void setInterfaceId(Ip4Address interfaceId);
+
+    /**
+     * Gets area id.
+     *
+     * @return area id
+     */
+    String areaId();
+
+    /**
+     * Sets area id.
+     *
+     * @param areaId area id
+     */
+    void setAreaId(String areaId);
+
+    /**
+     * Gets device information is already created or not.
+     *
+     * @return true if device information is already created else false
+     */
+    boolean isAlreadyCreated();
+
+    /**
+     * Sets device information is already created or not.
+     *
+     * @param alreadyCreated true if device information is already created else false
+     */
+    void setAlreadyCreated(boolean alreadyCreated);
+
+    /**
+     * Gets device is dis or not.
+     *
+     * @return true if device is dis else false
+     */
+    boolean isDis();
+
+    /**
+     * Sets device is dis or not.
+     *
+     * @param dis true if device is dr else false
+     */
+    void setDis(boolean dis);
+
+    /**
+     * Gets neighbor id.
+     *
+     * @return neighbor id
+     */
+    String neighborId();
+
+    /**
+     * Sets neighbor id.
+     *
+     * @param neighborId neighbor id
+     */
+    void setNeighborId(String neighborId);
+}
\ No newline at end of file

+/*
+ * Copyright 2016-present Open Networking Laboratory
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onosproject.isis.controller.topology;
+
+/**
+ * Representation of an ISIS agent.
+ * It is responsible for keeping track of the current set of routers
+ * connected to the system.
+ */
+public interface IsisAgent {
+    /**
+     * Adds a router that has just connected to the system.
+     *
+     * @param isisRouter the router id to add
+     * @return true if added, false otherwise
+     */
+    boolean addConnectedRouter(IsisRouter isisRouter);
+
+    /**
+     * Removes the router which got disconnected from the system.
+     *
+     * @param isisRouter the router id to remove
+     */
+    void removeConnectedRouter(IsisRouter isisRouter);
+
+    /**
+     * Notifies that got a packet of link from network and need do processing.
+     *
+     * @param isisLink  link instance
+     */
+    void addLink(IsisLink isisLink);
+
+    /**
+     * Notifies that got a packet of link from network and need do processing.
+     *
+     * @param isisLink  link instance
+     */
+    void deleteLink(IsisLink isisLink);
+}
\ No newline at end of file

@@ -15,9 +15,7 @@
  */
  */
 package org.onosproject.isis.controller.topology;
 package org.onosproject.isis.controller.topology;
 
 
-import org.onlab.packet.IpAddress;
-
-import java.util.List;
+import org.onlab.packet.Ip4Address;
 
 
 /**
 /**
  * Abstraction of an ISIS Link.
  * Abstraction of an ISIS Link.
@@ -25,58 +23,72 @@ import java.util.List;
 public interface IsisLink {
 public interface IsisLink {
 
 
     /**
     /**
-     * Returns IP address of the Router.
+     * Returns the remote system ID.
      *
      *
-     * @return IP address of router
+     * @return remote system ID
      */
      */
-    IpAddress remoteRouterId();
+    String remoteSystemId();
 
 
     /**
     /**
-     * Returns the area ID for this device.
+     * Returns the local system ID.
      *
      *
-     * @return the area ID
+     * @return local system ID
      */
      */
-    int areaIdOfInterface();
+    String localSystemId();
 
 
     /**
     /**
      * Returns IP address of the interface.
      * Returns IP address of the interface.
      *
      *
      * @return IP address of the interface
      * @return IP address of the interface
      */
      */
-    IpAddress interfaceIp();
+    Ip4Address interfaceIp();
+
+    /**
+     * Returns IP address of the neighbor.
+     *
+     * @return IP address of the neighbor
+     */
+    Ip4Address neighborIp();
 
 
     /**
     /**
-     * Returns the list of link TED details.
+     * Returns the link TED details.
      *
      *
-     * @return linkTed list of link TED
+     * @return linkTed link TED
      */
      */
-    List<IsisLinkTed> linkTed();
+    IsisLinkTed linkTed();
 
 
     /**
     /**
-     * Sets IP address of the router.
+     * Sets remote system ID.
      *
      *
-     * @param routerIp router's IP address
+     * @param remoteSystemId remote system ID
      */
      */
-    void setRouterIp(IpAddress routerIp);
+    void setRemoteSystemId(String remoteSystemId);
 
 
     /**
     /**
-     * Sets the area ID for this device.
+     * Sets local system ID.
      *
      *
-     * @param areaIdOfInterface area ID
+     * @param localSystemId remote system ID
      */
      */
-    void setAreaIdOfInterface(int areaIdOfInterface);
+    void setLocalSystemId(String localSystemId);
 
 
     /**
     /**
      * Sets IP address of the interface.
      * Sets IP address of the interface.
      *
      *
      * @param interfaceIp IP address of the interface
      * @param interfaceIp IP address of the interface
      */
      */
-    void setInterfaceIp(IpAddress interfaceIp);
+    void setInterfaceIp(Ip4Address interfaceIp);
+
+    /**
+     * Sets IP address of the neighbor.
+     *
+     * @param neighborIp IP address of the neighbor
+     */
+    void setNeighborIp(Ip4Address neighborIp);
 
 
     /**
     /**
-     * Sets the list of link TED.
+     * Sets the link TED information.
      *
      *
-     * @param linkTed list of link TED
+     * @param linkTed link TED
      */
      */
-    void setLinkTed(List<IsisLinkTed> linkTed);
+    void setLinkTed(IsisLinkTed linkTed);
 }
 }

@@ -23,16 +23,14 @@ public interface IsisLinkListener {
     /**
     /**
      * Notifies that we got a link from network.
      * Notifies that we got a link from network.
      *
      *
-     * @param isisRouter  router instance
-     * @param isisLinkTed link TED information of router
+     * @param isisLink link instance
      */
      */
-    void addLink(IsisRouter isisRouter, IsisLinkTed isisLinkTed);
+    void addLink(IsisLink isisLink);
 
 
     /**
     /**
      * Notifies that a link got removed from network.
      * Notifies that a link got removed from network.
      *
      *
-     * @param isisRouter router instance
-     * @param isisLinkTed isis link ted infromation
+     * @param isisLink link instance
      */
      */
-    void deleteLink(IsisRouter isisRouter, IsisLinkTed isisLinkTed);
+    void deleteLink(IsisLink isisLink);
 }
 }
\ No newline at end of file

@@ -16,7 +16,6 @@
 package org.onosproject.isis.controller.topology;
 package org.onosproject.isis.controller.topology;
 
 
 import org.onlab.packet.Ip4Address;
 import org.onlab.packet.Ip4Address;
-import org.onlab.packet.Ip6Address;
 import org.onlab.util.Bandwidth;
 import org.onlab.util.Bandwidth;
 
 
 import java.util.List;
 import java.util.List;
@@ -27,114 +26,100 @@ import java.util.List;
 public interface IsisLinkTed {
 public interface IsisLinkTed {
 
 
     /**
     /**
-     * Provides maximum bandwidth can be used on the link.
+     * Gets the administrative group.
      *
      *
-     * @return maximum bandwidth
+     * @return administrative group
      */
      */
-    Bandwidth maximumLink();
+    int administrativeGroup();
 
 
     /**
     /**
-     * Sets maximum band width.
+     * Sets the administrative group.
      *
      *
-     * @param bandwidth maximum bandwidth
+     * @param administrativeGroup administrative group
      */
      */
-    void setMaximumLink(Bandwidth bandwidth);
+    void setAdministrativeGroup(int administrativeGroup);
 
 
     /**
     /**
-     * Amount of bandwidth reservable on the link.
+     * Provides the IPv4 interface address.
      *
      *
-     * @return unreserved bandwidth
-     */
-    List<Bandwidth> maxUnResBandwidth();
-
-    /**
-     * Sets max bandwidth that is not reserved on the link.
-     *
-     * @param bandwidth max bandwidth that is not reserved on the link
-     */
-    void setMaxUnResBandwidth(Bandwidth bandwidth);
-
-    /**
-     * Provides max bandwidth that can be reserved on the link.
-     *
-     * @return max bandwidth reserved
+     * @return IPv4 interface address
      */
      */
-    Bandwidth maxReserved();
+    Ip4Address ipv4InterfaceAddress();
 
 
     /**
     /**
-     * Sets max bandwidth that can be reserved on the link.
+     * Sets the IPv4 interface address.
      *
      *
-     * @param bandwidth max bandwidth that can be reserved on the link
+     * @param interfaceAddress IPv4 interface address
      */
      */
-    void setMaxReserved(Bandwidth bandwidth);
+    void setIpv4InterfaceAddress(Ip4Address interfaceAddress);
 
 
     /**
     /**
-     * Provides Traffic Engineering metric for the link.
+     * Provides the IPv4 neighbor address.
      *
      *
-     * @return Traffic Engineering metric
+     * @return IPv4 neighbor address
      */
      */
-    int teMetric();
+    Ip4Address ipv4NeighborAddress();
 
 
     /**
     /**
-     * Sets Traffic Engineering metric for the link.
+     * Sets the IPv4 neighbor address.
      *
      *
-     * @param teMetric Traffic Engineering metric for the link
+     * @param neighborAddress IPv4 neighbor address
      */
      */
-    void setTeMetric(int teMetric);
+    void setIpv4NeighborAddress(Ip4Address neighborAddress);
 
 
     /**
     /**
-     * Provides IPv4 router-Id of local node.
+     * Gets the maximum link bandwidth.
      *
      *
-     * @return IPv4 router-Id of local node
+     * @return maximum link bandwidth
      */
      */
-    List<Ip4Address> ipv4LocRouterId();
+    Bandwidth maximumLinkBandwidth();
 
 
     /**
     /**
-     * Sets IPv4 router-Id of local node.
+     * Sets the maximum link bandwidth.
      *
      *
-     * @param routerIds IPv4 router-Id of local node
+     * @param bandwidth maximum link bandwidth
      */
      */
-    void setIpv4LocRouterId(List<Ip4Address> routerIds);
+    void setMaximumLinkBandwidth(Bandwidth bandwidth);
 
 
     /**
     /**
-     * Provides IPv6 router-Id of local node.
+     * Provides max bandwidth that can be reservable on the link.
      *
      *
-     * @return IPv6 router-Id of local node
+     * @return max bandwidth reservable
      */
      */
-    List<Ip6Address> ipv6LocRouterId();
+    Bandwidth maximumReservableLinkBandwidth();
 
 
     /**
     /**
-     * Sets IPv6 router-Id of local node.
+     * Sets max bandwidth that can be reservable on the link.
      *
      *
-     * @param routerIds IPv6 router-Id of local node
+     * @param bandwidth max bandwidth that can be reservable on the link
      */
      */
-    void setIpv6LocRouterId(List<Ip6Address> routerIds);
+    void setMaximumReservableLinkBandwidth(Bandwidth bandwidth);
 
 
     /**
     /**
-     * Provides IPv4 router-Id of remote node.
+     * Amount of bandwidth unreserved on the link.
      *
      *
-     * @return IPv4 router-Id of remote node
+     * @return unreserved bandwidth
      */
      */
-    List<Ip4Address> ipv4RemRouterId();
+    List<Bandwidth> unreservedBandwidth();
 
 
     /**
     /**
-     * Sets IPv4 router-Id of remote node.
+     * Sets the bandwidth unreserved on the link.
      *
      *
-     * @param routerIds IPv4 router-Id of remote node
+     * @param bandwidth bandwidth unreserved
      */
      */
-    void setIpv4RemRouterId(List<Ip4Address> routerIds);
+    void setUnreservedBandwidth(List<Bandwidth> bandwidth);
 
 
     /**
     /**
-     * Provides IPv6 router-Id of remote node.
+     * Provides Traffic Engineering metric for the link.
      *
      *
-     * @return IPv6 router-Id of remote node
+     * @return Traffic Engineering Default metric
      */
      */
-    List<Ip6Address> ipv6RemRouterId();
+    long teDefaultMetric();
 
 
     /**
     /**
-     * Sets IPv6 router-Id of remote node.
+     * Sets Traffic Engineering metric for the link.
      *
      *
-     * @param routerIds IPv6 router-Id of remote node
+     * @param teMetric Traffic Engineering Default metric for the link
      */
      */
-    void setIpv6RemRouterId(List<Ip6Address> routerIds);
+    void setTeDefaultMetric(long teMetric);
 }
 }
\ No newline at end of file

@@ -23,11 +23,11 @@ import org.onlab.packet.Ip4Address;
 public interface IsisRouter {
 public interface IsisRouter {
 
 
     /**
     /**
-     * Returns IP address of the router.
+     * Returns system ID for the router.
      *
      *
-     * @return IP address of the router
+     * @return system ID of the router
      */
      */
-    Ip4Address routerIp();
+    String systemId();
 
 
     /**
     /**
      * Returns IP address of the interface.
      * Returns IP address of the interface.
@@ -37,9 +37,44 @@ public interface IsisRouter {
     Ip4Address interfaceId();
     Ip4Address interfaceId();
 
 
     /**
     /**
-     * Sets IP address of the Router.
+     * Gets IP address of the interface.
      *
      *
-     * @param routerIp IP address of the router
+     * @param interfaceId IP address of the interface
      */
      */
-    void setRouterIp(Ip4Address routerIp);
+    void setInterfaceId(Ip4Address interfaceId);
+
+    /**
+     * Sets system ID of the Router.
+     *
+     * @param systemId system ID of the router
+     */
+    void setSystemId(String systemId);
+
+    /**
+     * Gets neighbours ID.
+     *
+     * @return neighbour ID
+     */
+    Ip4Address neighborRouterId();
+
+    /**
+     * Sets the neighbour Id.
+     *
+     * @param neighbourId neighbour Id
+     */
+    void setNeighborRouterId(Ip4Address neighbourId);
+
+    /**
+     * Gets if the router id DIS or not.
+     *
+     * @return true if the router is DIS else false
+     */
+    boolean isDis();
+
+    /**
+     * Sets if the router id DIS or not.
+     *
+     * @param dis true if the router is DIS else false
+     */
+    void setDis(boolean dis);
 }
 }

+/*
+ * Copyright 2016 Open Networking Laboratory
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onosproject.isis.controller.topology;
+
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.util.Objects;
+
+import static com.google.common.base.Preconditions.checkArgument;
+
+/**
+ * Represents an ISIS router id.
+ */
+public class IsisRouterId {
+
+    private static final String SCHEME = "l3";
+    private static final long UNKNOWN = 0;
+    private final String ipAddress;
+
+    /**
+     * Creates an instance of ISIS router id.
+     *
+     * @param ipAddress IP address of the router
+     */
+    public IsisRouterId(String ipAddress) {
+        this.ipAddress = ipAddress;
+    }
+
+    /**
+     * Creates an instance from ip address.
+     *
+     * @param ipAddress IP address
+     * @return ISIS router id instance
+     */
+    public static IsisRouterId isisRouterId(String ipAddress) {
+        return new IsisRouterId(ipAddress);
+    }
+
+    /**
+     * Creates ISIS router id instance from the URI.
+     *
+     * @param uri device URI
+     * @return ISIS router id instance
+     */
+    public static IsisRouterId isisRouterId(URI uri) {
+        checkArgument(uri.getScheme().equals(SCHEME), "Unsupported URI scheme");
+        return new IsisRouterId(uri.getSchemeSpecificPart());
+    }
+
+    /**
+     * Returns device URI from the given router id.
+     *
+     * @param isisRouterId router id instance
+     * @return device URI
+     */
+    public static URI uri(IsisRouterId isisRouterId) {
+        return uri(isisRouterId.ipAddress());
+    }
+
+    /**
+     * Returns device URI from the given IP address.
+     *
+     * @param ipAddress device IP address
+     * @return device URI
+     */
+    public static URI uri(String ipAddress) {
+        try {
+            return new URI(SCHEME, ipAddress, null);
+        } catch (URISyntaxException e) {
+            return null;
+        }
+    }
+
+    /**
+     * Returns the IP address.
+     *
+     * @return IP address
+     */
+    public String ipAddress() {
+        return ipAddress;
+    }
+
+    @Override
+    public String toString() {
+        return ipAddress;
+    }
+
+    @Override
+    public boolean equals(Object other) {
+        if (!(other instanceof IsisRouterId)) {
+            return false;
+        }
+
+        IsisRouterId otherIsisRouterId = (IsisRouterId) other;
+        return Objects.equals(ipAddress, otherIsisRouterId.ipAddress);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(ipAddress);
+    }
+}
\ No newline at end of file

@@ -34,11 +34,4 @@ public interface IsisRouterListener {
      * @param isisRouter ISIS router instance
      * @param isisRouter ISIS router instance
      */
      */
     void routerRemoved(IsisRouter isisRouter);
     void routerRemoved(IsisRouter isisRouter);
-
-    /**
-     * Notifies that the router has changed in some way.
-     *
-     * @param isisRouter ISIS router instance
-     */
-    void routerChanged(IsisRouter isisRouter);
 }
 }
\ No newline at end of file

+/*
+ * Copyright 2016 Open Networking Laboratory
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.onosproject.isis.controller.topology;
+
+import org.onlab.packet.Ip4Address;
+
+/**
+ * Representation of an ISIS link information.
+ */
+public interface LinkInformation {
+
+    /**
+     * Gets link id.
+     *
+     * @return link id
+     */
+    String linkId();
+
+    /**
+     * Sets link id.
+     *
+     * @param linkId link id
+     */
+    void setLinkId(String linkId);
+
+    /**
+     * Gets whether link information is already created or not.
+     *
+     * @return true if link information is already created else false
+     */
+    boolean isAlreadyCreated();
+
+    /**
+     * Sets link information is already created or not.
+     *
+     * @param alreadyCreated true if link information is already created else false
+     */
+    void setAlreadyCreated(boolean alreadyCreated);
+
+
+    /**
+     * Returns link destination ID.
+     *
+     * @return link destination ID
+     */
+    String linkDestinationId();
+
+    /**
+     * Sets link destination id.
+     *
+     * @param linkDestinationId link destination id
+     */
+    void setLinkDestinationId(String linkDestinationId);
+
+    /**
+     * Gets link source id.
+     *
+     * @return link source id
+     */
+    String linkSourceId();
+
+    /**
+     * Sets link source id.
+     *
+     * @param linkSourceId link source id
+     */
+    void setLinkSourceId(String linkSourceId);
+
+    /**
+     * Gets interface ip address.
+     *
+     * @return interface ip address
+     */
+    Ip4Address interfaceIp();
+
+    /**
+     * Sets interface ip address.
+     *
+     * @param interfaceIp interface ip address
+     */
+    void setInterfaceIp(Ip4Address interfaceIp);
+
+    /**
+     * Gets neighbor ip address.
+     *
+     * @return neighbor ip address
+     */
+    Ip4Address neighborIp();
+
+    /**
+     * Sets neighbor ip address.
+     *
+     * @param neighborIp neighbor ip address
+     */
+    void setNeighborIp(Ip4Address neighborIp);
+}
\ No newline at end of file

+/*
+ * Copyright 2016 Open Networking Laboratory
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.onosproject.isis.controller.topology;
+
+import java.util.Map;
+
+/**
+ * Represents IP topology for ISIS device and link details.
+ */
+public interface TopologyForDeviceAndLink {
+
+    /**
+     * Gets the device information.
+     *
+     * @return device information
+     */
+    Map<String, DeviceInformation> deviceInformationMap();
+
+    /**
+     * Sets the device information.
+     *
+     * @param key                  system ID of the device as key
+     * @param deviceInformationMap device information instance
+     */
+    void setDeviceInformationMap(String key, DeviceInformation deviceInformationMap);
+
+    /**
+     * Gets the link information.
+     *
+     * @return link information
+     */
+    Map<String, LinkInformation> linkInformationMap();
+
+    /**
+     * Sets link information.
+     *
+     * @param key                system ID of the device as key
+     * @param linkInformationMap link information instance
+     */
+    void setLinkInformationMap(String key, LinkInformation linkInformationMap);
+
+    /**
+     * Removes link information.
+     *
+     * @param key key used to remove from map
+     */
+    void removeLinkInformationMap(String key);
+
+    /**
+     * Removes device information.
+     *
+     * @param key key used to remove from map
+     */
+    void removeDeviceInformationMap(String key);
+
+    /**
+     * Removes links from linkInformationMap.
+     *
+     * @param linkId ID
+     */
+    void removeLinks(String linkId);
+
+    /**
+     * Gets deviceInformation as map.
+     *
+     * @return deviceInformationMap to delete from core
+     */
+    Map<String, DeviceInformation> deviceInformationMapToDelete();
+
+    /**
+     * Sets deviceInformation as map.
+     *
+     * @param key                          key used to add in map
+     * @param deviceInformationMapToDelete device information to delete from map
+     */
+    void setDeviceInformationMapToDelete(String key, DeviceInformation deviceInformationMapToDelete);
+
+    /**
+     * Removes Device Information from deviceInformationMapToDelete.
+     *
+     * @param key key to remove from map
+     */
+    void removeDeviceInformationMapFromDeleteMap(String key);
+
+    /**
+     * Gets deviceInformation as map for Point-To-Point.
+     *
+     * @return deviceInformationMap
+     */
+    Map<String, DeviceInformation> deviceInformationMapForPointToPoint();
+
+    /**
+     * Sets deviceInformation as map for Point-To-Point..
+     *
+     * @param key                  key to add to map
+     * @param deviceInformationMap device information map
+     */
+    void setDeviceInformationMapForPointToPoint(String key, DeviceInformation deviceInformationMap);
+
+    /**
+     * Gets linkInformation as map for PointToPoint.
+     *
+     * @return linkInformationMap
+     */
+    Map<String, LinkInformation> linkInformationMapForPointToPoint();
+
+    /**
+     * Sets linkInformation as map for PointToPoint.
+     *
+     * @param key                key to add link information to map
+     * @param linkInformationMap link information to add
+     */
+    void setLinkInformationMapForPointToPoint(String key, LinkInformation linkInformationMap);
+}
\ No newline at end of file

@@ -30,6 +30,9 @@ import org.onosproject.isis.controller.IsisInterface;
 import org.onosproject.isis.controller.IsisNetworkType;
 import org.onosproject.isis.controller.IsisNetworkType;
 import org.onosproject.isis.controller.IsisProcess;
 import org.onosproject.isis.controller.IsisProcess;
 import org.onosproject.isis.controller.IsisRouterType;
 import org.onosproject.isis.controller.IsisRouterType;
+import org.onosproject.isis.controller.topology.IsisAgent;
+import org.onosproject.isis.controller.topology.IsisLink;
+import org.onosproject.isis.controller.topology.IsisRouter;
 import org.onosproject.isis.io.util.IsisConstants;
 import org.onosproject.isis.io.util.IsisConstants;
 import org.slf4j.Logger;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.slf4j.LoggerFactory;
@@ -43,6 +46,7 @@ import java.util.Enumeration;
 import java.util.List;
 import java.util.List;
 import java.util.concurrent.Executors;
 import java.util.concurrent.Executors;
 import java.util.concurrent.ScheduledExecutorService;
 import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.ScheduledFuture;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.TimeUnit;
 
 
 import static org.onlab.util.Tools.groupedThreads;
 import static org.onlab.util.Tools.groupedThreads;
@@ -64,15 +68,29 @@ public class Controller {
     private ScheduledExecutorService connectExecutor = null;
     private ScheduledExecutorService connectExecutor = null;
     private int connectRetryCounter = 0;
     private int connectRetryCounter = 0;
     private int connectRetryTime;
     private int connectRetryTime;
+    private ScheduledFuture future = null;
+    private IsisAgent agent;
 
 
     /**
     /**
      * Deactivates ISIS controller.
      * Deactivates ISIS controller.
      */
      */
     public void isisDeactivate() {
     public void isisDeactivate() {
+        disconnectExecutor();
+        processes = null;
         peerExecFactory.shutdown();
         peerExecFactory.shutdown();
     }
     }
 
 
     /**
     /**
+     * Sets ISIS agent.
+     *
+     * @param agent ISIS agent instance
+     */
+    public void setAgent(IsisAgent agent) {
+        this.agent = agent;
+    }
+
+
+    /**
      * Updates the processes configuration.
      * Updates the processes configuration.
      *
      *
      * @param jsonNode json node instance
      * @param jsonNode json node instance
@@ -134,17 +152,17 @@ public class Controller {
         peerBootstrap.setOption("keepAlive", true);
         peerBootstrap.setOption("keepAlive", true);
         peerBootstrap.setOption("receiveBufferSize", Controller.BUFFER_SIZE);
         peerBootstrap.setOption("receiveBufferSize", Controller.BUFFER_SIZE);
         peerBootstrap.setOption("receiveBufferSizePredictorFactory",
         peerBootstrap.setOption("receiveBufferSizePredictorFactory",
-                                new FixedReceiveBufferSizePredictorFactory(
-                                        Controller.BUFFER_SIZE));
+                new FixedReceiveBufferSizePredictorFactory(
+                        Controller.BUFFER_SIZE));
         peerBootstrap.setOption("receiveBufferSizePredictor",
         peerBootstrap.setOption("receiveBufferSizePredictor",
-                                new AdaptiveReceiveBufferSizePredictor(64, 1024, 65536));
+                new AdaptiveReceiveBufferSizePredictor(64, 1024, 65536));
         peerBootstrap.setOption("child.keepAlive", true);
         peerBootstrap.setOption("child.keepAlive", true);
         peerBootstrap.setOption("child.tcpNoDelay", true);
         peerBootstrap.setOption("child.tcpNoDelay", true);
         peerBootstrap.setOption("child.sendBufferSize", Controller.BUFFER_SIZE);
         peerBootstrap.setOption("child.sendBufferSize", Controller.BUFFER_SIZE);
         peerBootstrap.setOption("child.receiveBufferSize", Controller.BUFFER_SIZE);
         peerBootstrap.setOption("child.receiveBufferSize", Controller.BUFFER_SIZE);
         peerBootstrap.setOption("child.receiveBufferSizePredictorFactory",
         peerBootstrap.setOption("child.receiveBufferSizePredictorFactory",
-                                new FixedReceiveBufferSizePredictorFactory(
-                                        Controller.BUFFER_SIZE));
+                new FixedReceiveBufferSizePredictorFactory(
+                        Controller.BUFFER_SIZE));
         peerBootstrap.setOption("child.reuseAddress", true);
         peerBootstrap.setOption("child.reuseAddress", true);
 
 
         isisChannelHandler = new IsisChannelHandler(this, processes);
         isisChannelHandler = new IsisChannelHandler(this, processes);
@@ -236,8 +254,8 @@ public class Controller {
                     continue;
                     continue;
                 }
                 }
                 isisInterface.setIntermediateSystemName(jsonNode1
                 isisInterface.setIntermediateSystemName(jsonNode1
-                                                                .path(IsisConstants.INTERMEDIATESYSTEMNAME)
-                                                                .asText());
+                        .path(IsisConstants.INTERMEDIATESYSTEMNAME)
+                        .asText());
                 String systemId = jsonNode1.path(IsisConstants.SYSTEMID).asText();
                 String systemId = jsonNode1.path(IsisConstants.SYSTEMID).asText();
                 if (isValidSystemId(systemId)) {
                 if (isValidSystemId(systemId)) {
                     isisInterface.setSystemId(systemId);
                     isisInterface.setSystemId(systemId);
@@ -462,7 +480,8 @@ public class Controller {
      */
      */
     public void disconnectExecutor() {
     public void disconnectExecutor() {
         if (connectExecutor != null) {
         if (connectExecutor != null) {
-            connectExecutor.shutdown();
+            future.cancel(true);
+            connectExecutor.shutdownNow();
             connectExecutor = null;
             connectExecutor = null;
         }
         }
     }
     }
@@ -480,10 +499,55 @@ public class Controller {
      * @param retryDelay retry delay
      * @param retryDelay retry delay
      */
      */
     private void scheduleConnectionRetry(long retryDelay) {
     private void scheduleConnectionRetry(long retryDelay) {
-        if (this.connectExecutor == null) {
-            this.connectExecutor = Executors.newSingleThreadScheduledExecutor();
+        if (connectExecutor == null) {
+            connectExecutor = Executors.newSingleThreadScheduledExecutor();
         }
         }
-        this.connectExecutor.schedule(new ConnectionRetry(), retryDelay, TimeUnit.MINUTES);
+        future = connectExecutor.schedule(new ConnectionRetry(), retryDelay, TimeUnit.MINUTES);
+    }
+
+    /**
+     * Adds device details.
+     *
+     * @param isisRouter ISIS router instance
+     */
+    public void addDeviceDetails(IsisRouter isisRouter) {
+        agent.addConnectedRouter(isisRouter);
+    }
+
+    /**
+     * Removes device details.
+     *
+     * @param isisRouter Isis router instance
+     */
+    public void removeDeviceDetails(IsisRouter isisRouter) {
+        agent.removeConnectedRouter(isisRouter);
+    }
+
+    /**
+     * Adds link details.
+     *
+     * @param isisLink ISIS link instance
+     */
+    public void addLinkDetails(IsisLink isisLink) {
+        agent.addLink(isisLink);
+    }
+
+    /**
+     * Removes link details.
+     *
+     * @param isisLink ISIS link instance
+     */
+    public void removeLinkDetails(IsisLink isisLink) {
+        agent.deleteLink(isisLink);
+    }
+
+    /**
+     * Returns the isisAgent instance.
+     *
+     * @return agent
+     */
+    public IsisAgent agent() {
+        return this.agent;
     }
     }
 
 
     /**
     /**
@@ -503,7 +567,7 @@ public class Controller {
                         if (!future.isSuccess()) {
                         if (!future.isSuccess()) {
                             connectRetryCounter++;
                             connectRetryCounter++;
                             log.error("Connection failed, ConnectRetryCounter {} remote host {}", connectRetryCounter,
                             log.error("Connection failed, ConnectRetryCounter {} remote host {}", connectRetryCounter,
-                                      IsisConstants.SHOST);
+                                    IsisConstants.SHOST);
                             /*
                             /*
                              * Reconnect to peer on failure is exponential till 4 mins, later on retry after every 4
                              * Reconnect to peer on failure is exponential till 4 mins, later on retry after every 4
                              * mins.
                              * mins.
@@ -517,7 +581,7 @@ public class Controller {
                             isisChannelHandler.sentConfigPacket(configPacket);
                             isisChannelHandler.sentConfigPacket(configPacket);
                             connectRetryCounter++;
                             connectRetryCounter++;
                             log.info("Connected to remote host {}, Connect Counter {}", IsisConstants.SHOST,
                             log.info("Connected to remote host {}, Connect Counter {}", IsisConstants.SHOST,
-                                     connectRetryCounter);
+                                    connectRetryCounter);
                             disconnectExecutor();
                             disconnectExecutor();
 
 
                             return;
                             return;

@@ -16,6 +16,7 @@
 package org.onosproject.isis.controller.impl;
 package org.onosproject.isis.controller.impl;
 
 
 import com.fasterxml.jackson.databind.JsonNode;
 import com.fasterxml.jackson.databind.JsonNode;
+import com.google.common.collect.Sets;
 import org.apache.felix.scr.annotations.Activate;
 import org.apache.felix.scr.annotations.Activate;
 import org.apache.felix.scr.annotations.Component;
 import org.apache.felix.scr.annotations.Component;
 import org.apache.felix.scr.annotations.Deactivate;
 import org.apache.felix.scr.annotations.Deactivate;
@@ -24,12 +25,18 @@ import org.apache.felix.scr.annotations.ReferenceCardinality;
 import org.apache.felix.scr.annotations.Service;
 import org.apache.felix.scr.annotations.Service;
 import org.onosproject.isis.controller.IsisController;
 import org.onosproject.isis.controller.IsisController;
 import org.onosproject.isis.controller.IsisProcess;
 import org.onosproject.isis.controller.IsisProcess;
+import org.onosproject.isis.controller.topology.IsisAgent;
+import org.onosproject.isis.controller.topology.IsisLink;
+import org.onosproject.isis.controller.topology.IsisLinkListener;
+import org.onosproject.isis.controller.topology.IsisRouter;
 import org.onosproject.isis.controller.topology.IsisRouterListener;
 import org.onosproject.isis.controller.topology.IsisRouterListener;
 import org.onosproject.net.driver.DriverService;
 import org.onosproject.net.driver.DriverService;
 import org.slf4j.Logger;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.slf4j.LoggerFactory;
 
 
+import java.util.HashSet;
 import java.util.List;
 import java.util.List;
+import java.util.Set;
 
 
 /**
 /**
  * Represents ISIS controller implementation.
  * Represents ISIS controller implementation.
@@ -42,10 +49,14 @@ public class DefaultIsisController implements IsisController {
     private final Controller controller = new Controller();
     private final Controller controller = new Controller();
     @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
     @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
     protected DriverService driverService;
     protected DriverService driverService;
+    protected Set<IsisRouterListener> isisRouterListener = new HashSet<>();
+    protected Set<IsisLinkListener> isisLinkListener = Sets.newHashSet();
+    protected IsisAgent agent = new InternalDeviceConfig();
 
 
     @Activate
     @Activate
     public void activate() {
     public void activate() {
         log.debug("ISISControllerImpl activate");
         log.debug("ISISControllerImpl activate");
+        controller.setAgent(agent);
     }
     }
 
 
     @Deactivate
     @Deactivate
@@ -55,6 +66,38 @@ public class DefaultIsisController implements IsisController {
     }
     }
 
 
     @Override
     @Override
+    public void addRouterListener(IsisRouterListener listener) {
+        if (!isisRouterListener.contains(listener)) {
+            this.isisRouterListener.add(listener);
+        }
+    }
+
+    @Override
+    public void removeRouterListener(IsisRouterListener listener) {
+        this.isisRouterListener.remove(listener);
+    }
+
+    @Override
+    public void addLinkListener(IsisLinkListener listener) {
+        isisLinkListener.add(listener);
+    }
+
+    @Override
+    public void removeLinkListener(IsisLinkListener listener) {
+        isisLinkListener.remove(listener);
+    }
+
+    @Override
+    public Set<IsisRouterListener> listener() {
+        return isisRouterListener;
+    }
+
+    @Override
+    public Set<IsisLinkListener> linkListener() {
+        return isisLinkListener;
+    }
+
+    @Override
     public List<IsisProcess> allConfiguredProcesses() {
     public List<IsisProcess> allConfiguredProcesses() {
         List<IsisProcess> processes = controller.getAllConfiguredProcesses();
         List<IsisProcess> processes = controller.getAllConfiguredProcesses();
         return processes;
         return processes;
@@ -70,13 +113,37 @@ public class DefaultIsisController implements IsisController {
         }
         }
     }
     }
 
 
-    @Override
-    public void addRouterListener(IsisRouterListener isisRouterListener) {
-        log.debug("IsisControllerImpl::addRouterListener...");
-    }
+    /**
+     * Notifier for internal ISIS device and link changes.
+     */
+    private class InternalDeviceConfig implements IsisAgent {
+        @Override
+        public boolean addConnectedRouter(IsisRouter isisRouter) {
+            for (IsisRouterListener l : listener()) {
+                l.routerAdded(isisRouter);
+            }
+            return true;
+        }
 
 
-    @Override
-    public void removeRouterListener(IsisRouterListener isisRouterListener) {
-        log.debug("IsisControllerImpl::removeRouterListener...");
+        @Override
+        public void removeConnectedRouter(IsisRouter isisRouter) {
+            for (IsisRouterListener l : listener()) {
+                l.routerRemoved(isisRouter);
+            }
+        }
+
+        @Override
+        public void addLink(IsisLink isisLink) {
+            for (IsisLinkListener l : linkListener()) {
+                l.addLink(isisLink);
+            }
+        }
+
+        @Override
+        public void deleteLink(IsisLink isisLink) {
+            for (IsisLinkListener l : linkListener()) {
+                l.deleteLink(isisLink);
+            }
+        }
     }
     }
 }
 }
\ No newline at end of file

@@ -356,6 +356,8 @@ public class DefaultIsisNeighbor implements IsisNeighbor {
         stopInactivityTimeCheck();
         stopInactivityTimeCheck();
         stopHoldingTimeCheck();
         stopHoldingTimeCheck();
         isisInterface.removeNeighbor(this);
         isisInterface.removeNeighbor(this);
+
+        isisInterface.isisLsdb().removeTopology(this, isisInterface);
     }
     }
 
 
     /**
     /**

@@ -68,6 +68,16 @@ public class IsisChannelHandler extends IdleStateAwareChannelHandler {
     public IsisChannelHandler(Controller controller, List<IsisProcess> processes) {
     public IsisChannelHandler(Controller controller, List<IsisProcess> processes) {
         this.controller = controller;
         this.controller = controller;
         this.processes = processes;
         this.processes = processes;
+        ((DefaultIsisLsdb) isisLsdb).setController(this.controller);
+        ((DefaultIsisLsdb) isisLsdb).setIsisInterface(isisInterfaceList());
+    }
+
+    private List<IsisInterface> isisInterfaceList() {
+        List<IsisInterface> isisInterfaceList = new ArrayList<>();
+        for (Integer key : isisInterfaceMap.keySet()) {
+            isisInterfaceList.add(isisInterfaceMap.get(key));
+        }
+        return isisInterfaceList;
     }
     }
 
 
     /**
     /**
@@ -178,30 +188,25 @@ public class IsisChannelHandler extends IdleStateAwareChannelHandler {
 
 
     @Override
     @Override
     public void exceptionCaught(ChannelHandlerContext ctx, ExceptionEvent e) throws Exception {
     public void exceptionCaught(ChannelHandlerContext ctx, ExceptionEvent e) throws Exception {
-        log.info("[exceptionCaught]: " + e.toString());
         if (e.getCause() instanceof ReadTimeoutException) {
         if (e.getCause() instanceof ReadTimeoutException) {
-            log.error("Disconnecting device {} due to read timeout", e.getChannel().getRemoteAddress());
+            log.debug("Disconnecting device {} due to read timeout", e.getChannel().getRemoteAddress());
             return;
             return;
         } else if (e.getCause() instanceof ClosedChannelException) {
         } else if (e.getCause() instanceof ClosedChannelException) {
             log.debug("Channel for ISIS {} already closed", e.getChannel().getRemoteAddress());
             log.debug("Channel for ISIS {} already closed", e.getChannel().getRemoteAddress());
         } else if (e.getCause() instanceof IOException) {
         } else if (e.getCause() instanceof IOException) {
-            log.error("Disconnecting ISIS {} due to IO Error: {}", e.getChannel().getRemoteAddress(),
+            log.debug("Disconnecting ISIS {} due to IO Error: {}", e.getChannel().getRemoteAddress(),
                       e.getCause().getMessage());
                       e.getCause().getMessage());
-            if (log.isDebugEnabled()) {
-                log.debug("StackTrace for previous Exception: {}", e.getCause());
-            }
         } else if (e.getCause() instanceof IsisParseException) {
         } else if (e.getCause() instanceof IsisParseException) {
             IsisParseException errMsg = (IsisParseException) e.getCause();
             IsisParseException errMsg = (IsisParseException) e.getCause();
             byte errorCode = errMsg.errorCode();
             byte errorCode = errMsg.errorCode();
             byte errorSubCode = errMsg.errorSubCode();
             byte errorSubCode = errMsg.errorSubCode();
-            log.error("Error while parsing message from ISIS {}, ErrorCode {}",
+            log.debug("Error while parsing message from ISIS {}, ErrorCode {}",
                       e.getChannel().getRemoteAddress(), errorCode);
                       e.getChannel().getRemoteAddress(), errorCode);
         } else if (e.getCause() instanceof RejectedExecutionException) {
         } else if (e.getCause() instanceof RejectedExecutionException) {
-            log.warn("Could not process message: queue full");
+            log.debug("Could not process message: queue full");
         } else {
         } else {
-            log.error("Error while processing message from ISIS {}, {}",
+            log.debug("Error while processing message from ISIS {}, {}",
                       e.getChannel().getRemoteAddress(), e.getCause().getMessage());
                       e.getChannel().getRemoteAddress(), e.getCause().getMessage());
-            e.getCause().printStackTrace();
         }
         }
     }
     }
 
 
@@ -274,7 +279,7 @@ public class IsisChannelHandler extends IdleStateAwareChannelHandler {
      * @param configPacket interface configuration
      * @param configPacket interface configuration
      */
      */
     public void sentConfigPacket(byte[] configPacket) {
     public void sentConfigPacket(byte[] configPacket) {
-        if (channel != null) {
+        if (channel != null && channel.isConnected() && channel.isOpen()) {
             channel.write(configPacket);
             channel.write(configPacket);
             log.debug("IsisChannelHandler sentConfigPacket packet sent..!!!");
             log.debug("IsisChannelHandler sentConfigPacket packet sent..!!!");
         } else {
         } else {

+/*
+* Copyright 2016-present Open Networking Laboratory
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*     http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+package org.onosproject.isis.controller.impl;
+
+import org.onlab.packet.Ip4Address;
+import org.onlab.util.Bandwidth;
+import org.onosproject.isis.controller.IsisNetworkType;
+import org.onosproject.isis.controller.LspWrapper;
+import org.onosproject.isis.controller.impl.topology.DefaultIsisLink;
+import org.onosproject.isis.controller.impl.topology.DefaultIsisLinkInformation;
+import org.onosproject.isis.controller.impl.topology.DefaultIsisLinkTed;
+import org.onosproject.isis.controller.impl.topology.DefaultIsisRouter;
+import org.onosproject.isis.controller.impl.topology.TopologyForDeviceAndLinkImpl;
+import org.onosproject.isis.controller.topology.IsisLink;
+import org.onosproject.isis.controller.topology.IsisLinkTed;
+import org.onosproject.isis.controller.topology.IsisRouter;
+import org.onosproject.isis.controller.topology.LinkInformation;
+import org.onosproject.isis.io.isispacket.pdu.LsPdu;
+import org.onosproject.isis.io.isispacket.tlv.IsExtendedReachability;
+import org.onosproject.isis.io.isispacket.tlv.IsisTlv;
+import org.onosproject.isis.io.isispacket.tlv.NeighborForExtendedIs;
+import org.onosproject.isis.io.isispacket.tlv.subtlv.AdministrativeGroup;
+import org.onosproject.isis.io.isispacket.tlv.subtlv.InterfaceIpAddress;
+import org.onosproject.isis.io.isispacket.tlv.subtlv.MaximumBandwidth;
+import org.onosproject.isis.io.isispacket.tlv.subtlv.MaximumReservableBandwidth;
+import org.onosproject.isis.io.isispacket.tlv.subtlv.NeighborIpAddress;
+import org.onosproject.isis.io.isispacket.tlv.subtlv.TrafficEngineeringMetric;
+import org.onosproject.isis.io.isispacket.tlv.subtlv.TrafficEngineeringSubTlv;
+import org.onosproject.isis.io.isispacket.tlv.subtlv.UnreservedBandwidth;
+import org.onosproject.isis.io.util.IsisConstants;
+import org.onosproject.isis.io.util.IsisUtil;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.BlockingQueue;
+
+/**
+ * Representation of LSP event consumer.
+ */
+public class LspEventConsumer implements Runnable {
+    private static final Logger log = LoggerFactory.getLogger(LspEventConsumer.class);
+    private BlockingQueue queue = null;
+    private Controller controller = null;
+    private TopologyForDeviceAndLinkImpl deviceAndLink = new TopologyForDeviceAndLinkImpl();
+    private Map<String, IsisRouter> isisRouterDetails = new LinkedHashMap<>();
+
+    /**
+     * Creates an instance of this.
+     *
+     * @param queue      blocking queue instance
+     * @param controller controller instance
+     */
+    public LspEventConsumer(BlockingQueue queue, Controller controller) {
+        this.queue = queue;
+        this.controller = controller;
+    }
+
+    @Override
+    public void run() {
+        try {
+            while (true) {
+                if (!queue.isEmpty()) {
+                    LspWrapper wrapper = (LspWrapper) queue.take();
+                    LsPdu lsPdu = (LsPdu) wrapper.lsPdu();
+                    if (wrapper.lspProcessing().equals(IsisConstants.LSPREMOVED)) {
+                        callTopologyToRemoveInfo(lsPdu);
+                    } else if (wrapper.lspProcessing().equals(IsisConstants.LSPADDED)) {
+                        callTopologyToSendInfo(lsPdu, wrapper.isisInterface().networkType(),
+                                               wrapper.isisInterface().systemId() + ".00");
+                    }
+                }
+            }
+        } catch (Exception e) {
+            log.debug("Error::LspsForProvider::{}", e.getMessage());
+        }
+    }
+
+    /**
+     * Sends topology information to core.
+     *
+     * @param lsPdu           ls pdu instance
+     * @param isisNetworkType ISIS network type
+     * @param ownSystemId own system ID
+     */
+    private void callTopologyToSendInfo(LsPdu lsPdu, IsisNetworkType isisNetworkType,
+                                        String ownSystemId) {
+        if ((lsPdu.lspId().equals(ownSystemId + "-00"))) {
+            return;
+        }
+        sendDeviceInfo(createDeviceInfo(lsPdu));
+
+        for (IsisTlv isisTlv : lsPdu.tlvs()) {
+            if (isisTlv instanceof IsExtendedReachability) {
+                IsExtendedReachability isExtendedReachability = (IsExtendedReachability) isisTlv;
+                List<NeighborForExtendedIs> neighbours = isExtendedReachability.neighbours();
+                for (NeighborForExtendedIs teTlv : neighbours) {
+                    String neighbor = teTlv.neighborId();
+                    IsisRouter isisRouter = isisRouterDetails.get(neighbor);
+                    if (isisRouter != null) {
+                        IsisRouter sourceRouter = isisRouterDetails.get(IsisUtil.removeTailingZeros(lsPdu.lspId()));
+                        IsisRouter destinationRouter = isisRouter;
+                        if (sourceRouter.isDis()) {
+                            LinkInformation linkInformation = createLinkInfo(sourceRouter.systemId(),
+                                                                             destinationRouter.systemId(),
+                                                                             sourceRouter.interfaceId(),
+                                                                             destinationRouter.interfaceId(), lsPdu);
+                            controller.addLinkDetails(createIsisLink(linkInformation, lsPdu));
+                        } else if (destinationRouter.isDis()) {
+                            LinkInformation linkInformation1 = createLinkInfo(destinationRouter.systemId(),
+                                                                              sourceRouter.systemId(),
+                                                                              destinationRouter.interfaceId(),
+                                                                              sourceRouter.interfaceId(), lsPdu);
+                            controller.addLinkDetails(createIsisLink(linkInformation1, lsPdu));
+                        } else {
+                            LinkInformation linkInformation = createLinkInfo(sourceRouter.systemId(),
+                                                                             destinationRouter.systemId(),
+                                                                             sourceRouter.interfaceId(),
+                                                                             destinationRouter.interfaceId(), lsPdu);
+                            controller.addLinkDetails(createIsisLink(linkInformation, lsPdu));
+                            LinkInformation linkInformation1 = createLinkInfo(destinationRouter.systemId(),
+                                                                              sourceRouter.systemId(),
+                                                                              destinationRouter.interfaceId(),
+                                                                              sourceRouter.interfaceId(), lsPdu);
+                            controller.addLinkDetails(createIsisLink(linkInformation1, lsPdu));
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    /**
+     * Removes topology information from core.
+     *
+     * @param lsPdu ls pdu instance
+     */
+    private void callTopologyToRemoveInfo(LsPdu lsPdu) {
+        String routerId = IsisUtil.removeTailingZeros(lsPdu.lspId());
+        IsisRouter isisRouter = isisRouterDetails.get(routerId);
+        removeDeviceInfo(isisRouter);
+        removeLinkInfo(lsPdu);
+    }
+
+    /**
+     * Sends the device information to topology provider.
+     *
+     * @param isisRouter ISIS router instance
+     */
+    private void sendDeviceInfo(IsisRouter isisRouter) {
+        if (isisRouter.systemId() != null) {
+            controller.addDeviceDetails(isisRouter);
+        }
+    }
+
+    /**
+     * Creates Device instance.
+     *
+     * @param lsPdu ISIS LSPDU instance
+     * @return isisRouter isisRouter instance
+     */
+    public IsisRouter createDeviceInfo(LsPdu lsPdu) {
+        IsisRouter isisRouter = createIsisRouter(lsPdu);
+        if (isisRouter.systemId() != null) {
+            isisRouterDetails.put(isisRouter.systemId(), isisRouter);
+        }
+        return isisRouter;
+    }
+
+    /**
+     * Creates ISIS router instance.
+     *
+     * @param lsPdu lsp instance
+     * @return isisRouter instance
+     */
+    private IsisRouter createIsisRouter(LsPdu lsPdu) {
+        IsisRouter isisRouter = new DefaultIsisRouter();
+        if (IsisUtil.checkIsDis(lsPdu.lspId())) {
+            isisRouter.setDis(true);
+        } else {
+            isisRouter.setDis(false);
+        }
+        isisRouter.setSystemId(IsisUtil.removeTailingZeros(lsPdu.lspId()));
+        for (IsisTlv isisTlv : lsPdu.tlvs()) {
+            if (isisTlv instanceof IsExtendedReachability) {
+                IsExtendedReachability isExtendedReachability = (IsExtendedReachability) isisTlv;
+                List<NeighborForExtendedIs> neighbours = isExtendedReachability.neighbours();
+                for (NeighborForExtendedIs teTlv : neighbours) {
+                    List<TrafficEngineeringSubTlv> teSubTlvs = teTlv.teSubTlv();
+                    for (TrafficEngineeringSubTlv teSubTlv : teSubTlvs) {
+                        if (teSubTlv instanceof InterfaceIpAddress) {
+                            InterfaceIpAddress localIpAddress = (InterfaceIpAddress) teSubTlv;
+                            isisRouter.setInterfaceId(localIpAddress.localInterfaceIPAddress());
+                        } else if (teSubTlv instanceof NeighborIpAddress) {
+                            NeighborIpAddress neighborIpAddress = (NeighborIpAddress) teSubTlv;
+                            isisRouter.setNeighborRouterId(neighborIpAddress.neighborIPAddress());
+                        }
+
+                    }
+                }
+            }
+        }
+        if (isisRouter.interfaceId() == null) {
+            isisRouter.setInterfaceId(IsisConstants.DEFAULTIP);
+        }
+        if (isisRouter.neighborRouterId() == null) {
+            isisRouter.setNeighborRouterId(IsisConstants.DEFAULTIP);
+        }
+        return isisRouter;
+    }
+
+    /**
+     * Creates link information.
+     *
+     * @param localSystemId  local system ID
+     * @param remoteSystemId remote system ID
+     * @return link information
+     * @param interfaceIp interface address
+     * @param neighborIp neighbor address
+     * @param lsPdu link state PDU instance
+     * @return link information instance
+     */
+    public LinkInformation createLinkInfo(String localSystemId, String remoteSystemId,
+                                          Ip4Address interfaceIp, Ip4Address neighborIp,
+                                          LsPdu lsPdu) {
+
+        String linkId = "link:" + localSystemId + "-" + remoteSystemId;
+        LinkInformation linkInformation = new DefaultIsisLinkInformation();
+        linkInformation.setInterfaceIp(interfaceIp);
+        linkInformation.setNeighborIp(neighborIp);
+        linkInformation.setLinkId(linkId);
+        linkInformation.setAlreadyCreated(false);
+        linkInformation.setLinkDestinationId(remoteSystemId);
+        linkInformation.setLinkSourceId(localSystemId);
+
+        return linkInformation;
+    }
+
+    /**
+     * Removes the device information from topology provider.
+     *
+     * @param isisRouter ISIS router instance
+     */
+    private void removeDeviceInfo(IsisRouter isisRouter) {
+        if (isisRouter.systemId() != null) {
+            controller.removeDeviceDetails(isisRouter);
+        }
+        isisRouterDetails.remove(isisRouter.systemId());
+    }
+
+
+    /**
+     * Removes the link information from topology provider.
+     *
+     * @param lsPdu ls pdu instance
+     */
+    private void removeLinkInfo(LsPdu lsPdu) {
+        Map<String, LinkInformation> linkInformationList = deviceAndLink.removeLinkInfo(lsPdu.lspId());
+        for (String key : linkInformationList.keySet()) {
+            LinkInformation linkInformation = linkInformationList.get(key);
+            controller.removeLinkDetails(createIsisLink(linkInformation, lsPdu));
+        }
+    }
+
+    /**
+     * Creates ISIS link instance.
+     *
+     * @param linkInformation link information instance
+     * @return isisLink instance
+     */
+    private IsisLink createIsisLink(LinkInformation linkInformation, LsPdu lsPdu) {
+        IsisLink isisLink = new DefaultIsisLink();
+        isisLink.setLocalSystemId(linkInformation.linkSourceId());
+        isisLink.setRemoteSystemId(linkInformation.linkDestinationId());
+        isisLink.setInterfaceIp(linkInformation.interfaceIp());
+        isisLink.setNeighborIp(linkInformation.neighborIp());
+        isisLink.setLinkTed(createIsisLinkTedInfo(lsPdu));
+        return isisLink;
+    }
+
+    /**
+     * Creates the ISIS link TED information.
+     *
+     * @param lsPdu link state PDU
+     * @return isisLinkTed
+     */
+    public IsisLinkTed createIsisLinkTedInfo(LsPdu lsPdu) {
+        IsisLinkTed isisLinkTed = new DefaultIsisLinkTed();
+        for (IsisTlv isisTlv : lsPdu.tlvs()) {
+            if (isisTlv instanceof IsExtendedReachability) {
+                IsExtendedReachability isExtendedReachability = (IsExtendedReachability) isisTlv;
+                List<NeighborForExtendedIs> neighbours = isExtendedReachability.neighbours();
+                for (NeighborForExtendedIs teTlv : neighbours) {
+                    List<TrafficEngineeringSubTlv> teSubTlvs = teTlv.teSubTlv();
+                    for (TrafficEngineeringSubTlv teSubTlv : teSubTlvs) {
+                        if (teSubTlv instanceof AdministrativeGroup) {
+                            AdministrativeGroup ag = (AdministrativeGroup) teSubTlv;
+                            isisLinkTed.setAdministrativeGroup(ag.administrativeGroup());
+                        }
+                        if (teSubTlv instanceof InterfaceIpAddress) {
+                            InterfaceIpAddress localIpAddress = (InterfaceIpAddress) teSubTlv;
+                            isisLinkTed.setIpv4InterfaceAddress(localIpAddress.localInterfaceIPAddress());
+                        }
+                        if (teSubTlv instanceof NeighborIpAddress) {
+                            NeighborIpAddress neighborIpAddress = (NeighborIpAddress) teSubTlv;
+                            isisLinkTed.setIpv4NeighborAddress(neighborIpAddress.neighborIPAddress());
+                        }
+                        if (teSubTlv instanceof TrafficEngineeringMetric) {
+                            TrafficEngineeringMetric teM = (TrafficEngineeringMetric) teSubTlv;
+                            isisLinkTed.setTeDefaultMetric(teM.getTrafficEngineeringMetricValue());
+                        }
+                        if (teSubTlv instanceof MaximumBandwidth) {
+                            MaximumBandwidth maxLinkBandwidth = (MaximumBandwidth) teSubTlv;
+                            isisLinkTed.setMaximumLinkBandwidth(
+                                    Bandwidth.bps(maxLinkBandwidth.getMaximumBandwidthValue()));
+                        }
+                        if (teSubTlv instanceof MaximumReservableBandwidth) {
+                            MaximumReservableBandwidth maxReservableBw = (MaximumReservableBandwidth) teSubTlv;
+                            isisLinkTed.setMaximumReservableLinkBandwidth(
+                                    Bandwidth.bps(maxReservableBw.getMaximumBandwidthValue()));
+                        }
+                        if (teSubTlv instanceof UnreservedBandwidth) {
+                            UnreservedBandwidth unReservedBandwidth = (UnreservedBandwidth) teSubTlv;
+                            List<Bandwidth> bandwidthList = new ArrayList<>();
+                            List<Float> unReservedBandwidthList = unReservedBandwidth.unReservedBandwidthValue();
+                            for (Float unReservedBandwidthFloatValue : unReservedBandwidthList) {
+                                Bandwidth bandwidth = Bandwidth.bps(unReservedBandwidthFloatValue);
+                                bandwidthList.add(bandwidth);
+                            }
+                            isisLinkTed.setUnreservedBandwidth(bandwidthList);
+                        }
+                    }
+                }
+            }
+        }
+        return isisLinkTed;
+    }
+}
\ No newline at end of file

@@ -21,17 +21,24 @@ import org.onosproject.isis.controller.IsisLsdb;
 import org.onosproject.isis.controller.IsisLsdbAge;
 import org.onosproject.isis.controller.IsisLsdbAge;
 import org.onosproject.isis.controller.IsisLspBin;
 import org.onosproject.isis.controller.IsisLspBin;
 import org.onosproject.isis.controller.IsisMessage;
 import org.onosproject.isis.controller.IsisMessage;
+import org.onosproject.isis.controller.IsisNeighbor;
 import org.onosproject.isis.controller.IsisPduType;
 import org.onosproject.isis.controller.IsisPduType;
+import org.onosproject.isis.controller.IsisRouterType;
 import org.onosproject.isis.controller.LspWrapper;
 import org.onosproject.isis.controller.LspWrapper;
+import org.onosproject.isis.controller.impl.Controller;
+import org.onosproject.isis.controller.impl.LspEventConsumer;
 import org.onosproject.isis.io.isispacket.pdu.LsPdu;
 import org.onosproject.isis.io.isispacket.pdu.LsPdu;
 import org.onosproject.isis.io.util.IsisConstants;
 import org.onosproject.isis.io.util.IsisConstants;
 import org.onosproject.isis.io.util.IsisUtil;
 import org.onosproject.isis.io.util.IsisUtil;
 import org.slf4j.Logger;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.slf4j.LoggerFactory;
 
 
+import java.util.ArrayList;
 import java.util.Iterator;
 import java.util.Iterator;
 import java.util.List;
 import java.util.List;
 import java.util.Map;
 import java.util.Map;
+import java.util.concurrent.ArrayBlockingQueue;
+import java.util.concurrent.BlockingQueue;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.CopyOnWriteArrayList;
 import java.util.concurrent.CopyOnWriteArrayList;
 
 
@@ -43,10 +50,14 @@ public class DefaultIsisLsdb implements IsisLsdb {
     private Map<String, LspWrapper> isisL1Db = new ConcurrentHashMap<>();
     private Map<String, LspWrapper> isisL1Db = new ConcurrentHashMap<>();
     private Map<String, LspWrapper> isisL2Db = new ConcurrentHashMap<>();
     private Map<String, LspWrapper> isisL2Db = new ConcurrentHashMap<>();
     private IsisLsdbAge lsdbAge = null;
     private IsisLsdbAge lsdbAge = null;
+    private Controller controller = null;
+    private List<IsisInterface> isisInterfaceList = new ArrayList<>();
 
 
 
 
     private int l1LspSeqNo = IsisConstants.STARTLSSEQUENCENUM;
     private int l1LspSeqNo = IsisConstants.STARTLSSEQUENCENUM;
     private int l2LspSeqNo = IsisConstants.STARTLSSEQUENCENUM;
     private int l2LspSeqNo = IsisConstants.STARTLSSEQUENCENUM;
+    private LspEventConsumer queueConsumer = null;
+    private BlockingQueue<LspWrapper> lspForProviderQueue = new ArrayBlockingQueue<>(1024);
 
 
     /**
     /**
      * Creates an instance of ISIS LSDB.
      * Creates an instance of ISIS LSDB.
@@ -56,10 +67,30 @@ public class DefaultIsisLsdb implements IsisLsdb {
     }
     }
 
 
     /**
     /**
+     * Sets the controller instance.
+     *
+     * @param controller controller instance
+     */
+    public void setController(Controller controller) {
+        this.controller = controller;
+    }
+
+    /**
+     * Sets the list of IsisInterface instance.
+     *
+     * @param isisInterfaceList isisInterface instance
+     */
+    public void setIsisInterface(List<IsisInterface> isisInterfaceList) {
+        this.isisInterfaceList = isisInterfaceList;
+    }
+
+    /**
      * Initializes the link state database.
      * Initializes the link state database.
      */
      */
     public void initializeDb() {
     public void initializeDb() {
         lsdbAge.startDbAging();
         lsdbAge.startDbAging();
+        queueConsumer = new LspEventConsumer(lspForProviderQueue, controller);
+        new Thread(queueConsumer).start();
     }
     }
 
 
     /**
     /**
@@ -96,7 +127,6 @@ public class DefaultIsisLsdb implements IsisLsdb {
         return lspKey.toString();
         return lspKey.toString();
     }
     }
 
 
-
     /**
     /**
      * Returns the neighbor L1 database information.
      * Returns the neighbor L1 database information.
      *
      *
@@ -215,7 +245,7 @@ public class DefaultIsisLsdb implements IsisLsdb {
             byte[] lspBytes = lspdu.asBytes();
             byte[] lspBytes = lspdu.asBytes();
             lspdu.setPduLength(lspBytes.length);
             lspdu.setPduLength(lspBytes.length);
             lspBytes = IsisUtil.addChecksum(lspBytes, IsisConstants.CHECKSUMPOSITION,
             lspBytes = IsisUtil.addChecksum(lspBytes, IsisConstants.CHECKSUMPOSITION,
-                                            IsisConstants.CHECKSUMPOSITION + 1);
+                    IsisConstants.CHECKSUMPOSITION + 1);
             byte[] checkSum = {lspBytes[IsisConstants.CHECKSUMPOSITION], lspBytes[IsisConstants.CHECKSUMPOSITION + 1]};
             byte[] checkSum = {lspBytes[IsisConstants.CHECKSUMPOSITION], lspBytes[IsisConstants.CHECKSUMPOSITION + 1]};
             lspdu.setCheckSum(ChannelBuffers.copiedBuffer(checkSum).readUnsignedShort());
             lspdu.setCheckSum(ChannelBuffers.copiedBuffer(checkSum).readUnsignedShort());
         }
         }
@@ -236,6 +266,14 @@ public class DefaultIsisLsdb implements IsisLsdb {
         addLsp(lspWrapper, lspdu.lspId());
         addLsp(lspWrapper, lspdu.lspId());
 
 
         log.debug("Added LSp In LSDB: {}", lspWrapper);
         log.debug("Added LSp In LSDB: {}", lspWrapper);
+        try {
+            if (!lspWrapper.isSelfOriginated()) {
+                lspWrapper.setLspProcessing(IsisConstants.LSPADDED);
+                lspForProviderQueue.put(lspWrapper);
+            }
+        } catch (Exception e) {
+            log.debug("Added LSp In Blocking queue: {}", lspWrapper);
+        }
         return true;
         return true;
     }
     }
 
 
@@ -273,9 +311,10 @@ public class DefaultIsisLsdb implements IsisLsdb {
             lspBin.addIsisLsp(key, lspWrapper);
             lspBin.addIsisLsp(key, lspWrapper);
             lsdbAge.addLspBin(binNumber, lspBin);
             lsdbAge.addLspBin(binNumber, lspBin);
             log.debug("Added Type {} LSP to LSDB and LSABin[{}], Remaining life time of LSA {}",
             log.debug("Added Type {} LSP to LSDB and LSABin[{}], Remaining life time of LSA {}",
-                      lspWrapper.lsPdu().isisPduType(),
-                      binNumber, lspWrapper.remainingLifetime());
+                    lspWrapper.lsPdu().isisPduType(),
+                    binNumber, lspWrapper.remainingLifetime());
         }
         }
+
         return false;
         return false;
     }
     }
 
 
@@ -337,6 +376,7 @@ public class DefaultIsisLsdb implements IsisLsdb {
     public void deleteLsp(IsisMessage lspMessage) {
     public void deleteLsp(IsisMessage lspMessage) {
         LsPdu lsp = (LsPdu) lspMessage;
         LsPdu lsp = (LsPdu) lspMessage;
         String lspKey = lsp.lspId();
         String lspKey = lsp.lspId();
+        LspWrapper lspWrapper = findLsp(lspMessage.isisPduType(), lspKey);
         switch (lsp.isisPduType()) {
         switch (lsp.isisPduType()) {
             case L1LSPDU:
             case L1LSPDU:
                 isisL1Db.remove(lspKey);
                 isisL1Db.remove(lspKey);
@@ -348,5 +388,47 @@ public class DefaultIsisLsdb implements IsisLsdb {
                 log.debug("Unknown LSP type to remove..!!!");
                 log.debug("Unknown LSP type to remove..!!!");
                 break;
                 break;
         }
         }
+
+        try {
+            lspWrapper.setLspProcessing(IsisConstants.LSPREMOVED);
+            lspForProviderQueue.put(lspWrapper);
+        } catch (Exception e) {
+            log.debug("Added LSp In Blocking queue: {}", lspWrapper);
+        }
+    }
+
+    /**
+     * Removes topology information when neighbor down.
+     *
+     * @param neighbor      ISIS neighbor instance
+     * @param isisInterface ISIS interface instance
+     */
+    public void removeTopology(IsisNeighbor neighbor, IsisInterface isisInterface) {
+        String lspKey = neighbor.neighborSystemId() + ".00-00";
+        LspWrapper lspWrapper = null;
+        switch (IsisRouterType.get(isisInterface.reservedPacketCircuitType())) {
+            case L1:
+                lspWrapper = findLsp(IsisPduType.L1LSPDU, lspKey);
+                break;
+            case L2:
+                lspWrapper = findLsp(IsisPduType.L2LSPDU, lspKey);
+                break;
+            case L1L2:
+                lspWrapper = findLsp(IsisPduType.L1LSPDU, lspKey);
+                if (lspWrapper == null) {
+                    lspWrapper = findLsp(IsisPduType.L2LSPDU, lspKey);
+                }
+                break;
+            default:
+                log.debug("Unknown type");
+        }
+        try {
+            if (lspWrapper != null) {
+                lspWrapper.setLspProcessing(IsisConstants.LSPREMOVED);
+                lspForProviderQueue.put(lspWrapper);
+            }
+        } catch (Exception e) {
+            log.debug("Added LSp In Blocking queue: {}", lspWrapper);
+        }
     }
     }
 }
 }
\ No newline at end of file

@@ -231,7 +231,6 @@ public class DefaultIsisLsdbAge implements IsisLsdbAge {
         }
         }
     }
     }
 
 
-
     /**
     /**
      * Runnable task which runs every second and calls aging process.
      * Runnable task which runs every second and calls aging process.
      */
      */

@@ -58,12 +58,12 @@ public class IsisLspQueueConsumer implements Runnable {
                     switch (lspProcessing) {
                     switch (lspProcessing) {
                         case IsisConstants.REFRESHLSP:
                         case IsisConstants.REFRESHLSP:
                             log.debug("LSPQueueConsumer: Message - " + IsisConstants.REFRESHLSP +
                             log.debug("LSPQueueConsumer: Message - " + IsisConstants.REFRESHLSP +
-                                              " consumed.");
+                                    " consumed.");
                             processRefreshLsp(wrapper);
                             processRefreshLsp(wrapper);
                             break;
                             break;
                         case IsisConstants.MAXAGELSP:
                         case IsisConstants.MAXAGELSP:
                             log.debug("LSPQueueConsumer: Message - " + IsisConstants.MAXAGELSP +
                             log.debug("LSPQueueConsumer: Message - " + IsisConstants.MAXAGELSP +
-                                              " consumed.");
+                                    " consumed.");
                             processMaxAgeLsa(wrapper);
                             processMaxAgeLsa(wrapper);
                             break;
                             break;
                         default:
                         default:
@@ -72,7 +72,6 @@ public class IsisLspQueueConsumer implements Runnable {
                     }
                     }
                 }
                 }
             }
             }
-
         } catch (Exception e) {
         } catch (Exception e) {
             log.debug("Error::LSPQueueConsumer::{}", e.getMessage());
             log.debug("Error::LSPQueueConsumer::{}", e.getMessage());
         }
         }
@@ -94,19 +93,18 @@ public class IsisLspQueueConsumer implements Runnable {
                 lsPdu.setRemainingLifeTime(IsisConstants.LSPMAXAGE);
                 lsPdu.setRemainingLifeTime(IsisConstants.LSPMAXAGE);
                 byte[] lspBytes = lsPdu.asBytes();
                 byte[] lspBytes = lsPdu.asBytes();
                 lspBytes = IsisUtil.addLengthAndMarkItInReserved(lspBytes, IsisConstants.LENGTHPOSITION,
                 lspBytes = IsisUtil.addLengthAndMarkItInReserved(lspBytes, IsisConstants.LENGTHPOSITION,
-                                                                 IsisConstants.LENGTHPOSITION + 1,
-                                                                 IsisConstants.RESERVEDPOSITION);
+                        IsisConstants.LENGTHPOSITION + 1,
+                        IsisConstants.RESERVEDPOSITION);
                 lspBytes = IsisUtil.addChecksum(lspBytes, IsisConstants.CHECKSUMPOSITION,
                 lspBytes = IsisUtil.addChecksum(lspBytes, IsisConstants.CHECKSUMPOSITION,
-                                                IsisConstants.CHECKSUMPOSITION + 1);
+                        IsisConstants.CHECKSUMPOSITION + 1);
                 //write to the channel
                 //write to the channel
                 channel.write(IsisUtil.framePacket(lspBytes, isisInterface.interfaceIndex()));
                 channel.write(IsisUtil.framePacket(lspBytes, isisInterface.interfaceIndex()));
                 // Updating the database with resetting remaining life time to default.
                 // Updating the database with resetting remaining life time to default.
                 IsisLsdb isisDb = isisInterface.isisLsdb();
                 IsisLsdb isisDb = isisInterface.isisLsdb();
                 isisDb.addLsp(lsPdu, true, isisInterface);
                 isisDb.addLsp(lsPdu, true, isisInterface);
                 log.debug("LSPQueueConsumer: processRefreshLsp - Flooded SelfOriginated LSP {}",
                 log.debug("LSPQueueConsumer: processRefreshLsp - Flooded SelfOriginated LSP {}",
-                          wrapper.lsPdu());
+                        wrapper.lsPdu());
             }
             }
-
         }
         }
     }
     }
 
 
@@ -124,7 +122,7 @@ public class IsisLspQueueConsumer implements Runnable {
             IsisLsdb isisDb = isisInterface.isisLsdb();
             IsisLsdb isisDb = isisInterface.isisLsdb();
             isisDb.deleteLsp(lsPdu);
             isisDb.deleteLsp(lsPdu);
             log.debug("LSPQueueConsumer: processMaxAgeLsp - Removed-Max Age LSP {}",
             log.debug("LSPQueueConsumer: processMaxAgeLsp - Removed-Max Age LSP {}",
-                      wrapper.lsPdu());
+                    wrapper.lsPdu());
         }
         }
     }
     }
 }
 }
\ No newline at end of file

+/*
+ * Copyright 2015 Open Networking Laboratory
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onosproject.isis.controller.impl.topology;
+
+import com.google.common.base.MoreObjects;
+import com.google.common.base.Objects;
+import org.onlab.packet.Ip4Address;
+import org.onosproject.isis.controller.topology.IsisLink;
+import org.onosproject.isis.controller.topology.IsisLinkTed;
+
+/**
+ * Representation of an ISIS Link.
+ */
+public class DefaultIsisLink implements IsisLink {
+
+    private String remoteSystemId;
+    private String localSystemId;
+    private Ip4Address interfaceIp;
+    private Ip4Address neighborIp;
+    private IsisLinkTed linkTed;
+
+    @Override
+    public String remoteSystemId() {
+        return this.remoteSystemId;
+    }
+
+    @Override
+    public String localSystemId() {
+        return this.localSystemId;
+    }
+
+    @Override
+    public Ip4Address interfaceIp() {
+        return this.interfaceIp;
+    }
+
+    @Override
+    public Ip4Address neighborIp() {
+        return this.neighborIp;
+    }
+
+    @Override
+    public IsisLinkTed linkTed() {
+        return this.linkTed;
+    }
+
+    @Override
+    public void setRemoteSystemId(String remoteSystemId) {
+        this.remoteSystemId = remoteSystemId;
+    }
+
+    @Override
+    public void setLocalSystemId(String localSystemId) {
+        this.localSystemId = localSystemId;
+    }
+
+    @Override
+    public void setInterfaceIp(Ip4Address interfaceIp) {
+        this.interfaceIp = interfaceIp;
+    }
+
+    @Override
+    public void setNeighborIp(Ip4Address neighborIp) {
+        this.neighborIp = neighborIp;
+    }
+
+    @Override
+    public void setLinkTed(IsisLinkTed linkTed) {
+        this.linkTed = linkTed;
+    }
+
+    @Override
+    public String toString() {
+        return MoreObjects.toStringHelper(getClass())
+                .omitNullValues()
+                .add("remoteSystemId", remoteSystemId)
+                .add("localSystemId", localSystemId)
+                .add("interfaceIp", interfaceIp)
+                .add("neighborIp", neighborIp)
+                .add("linkTed", linkTed)
+                .toString();
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (o == null || getClass() != o.getClass()) {
+            return false;
+        }
+        DefaultIsisLink that = (DefaultIsisLink) o;
+        return Objects.equal(remoteSystemId, that.remoteSystemId) &&
+                Objects.equal(localSystemId, that.localSystemId) &&
+                Objects.equal(interfaceIp, that.interfaceIp) &&
+                Objects.equal(neighborIp, that.neighborIp) &&
+                Objects.equal(linkTed, that.linkTed);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hashCode(remoteSystemId, localSystemId, interfaceIp, neighborIp, linkTed);
+    }
+}
\ No newline at end of file

+/*
+ * Copyright 2016-present Open Networking Laboratory
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.onosproject.isis.controller.impl.topology;
+
+import com.google.common.base.MoreObjects;
+import com.google.common.base.Objects;
+import org.onlab.packet.Ip4Address;
+import org.onosproject.isis.controller.topology.LinkInformation;
+
+/**
+ * Representation of an ISIS link information..
+ */
+public class DefaultIsisLinkInformation implements LinkInformation {
+
+    String linkId;
+    String linkSourceId;
+    String linkDestinationId;
+    Ip4Address interfaceIp;
+    Ip4Address neighborIp;
+    boolean alreadyCreated;
+
+    /**
+     * Gets link id.
+     *
+     * @return link id
+     */
+    public String linkId() {
+        return linkId;
+    }
+
+    /**
+     * Sets link id.DefaultIsisDeviceInformation.
+     *
+     * @param linkId link id
+     */
+    public void setLinkId(String linkId) {
+        this.linkId = linkId;
+    }
+
+    /**
+     * Gets is already created or not.
+     *
+     * @return true if already created else false
+     */
+    public boolean isAlreadyCreated() {
+        return alreadyCreated;
+    }
+
+    /**
+     * Sets is already created or not.
+     *
+     * @param alreadyCreated true or false
+     */
+    public void setAlreadyCreated(boolean alreadyCreated) {
+        this.alreadyCreated = alreadyCreated;
+    }
+
+    /**
+     * Gets link destination id.
+     *
+     * @return link destination id
+     */
+    public String linkDestinationId() {
+        return linkDestinationId;
+    }
+
+    /**
+     * Sets link destination id.
+     *
+     * @param linkDestinationId link destination id
+     */
+    public void setLinkDestinationId(String linkDestinationId) {
+        this.linkDestinationId = linkDestinationId;
+    }
+
+    /**
+     * Gets link source id.
+     *
+     * @return link source id
+     */
+    public String linkSourceId() {
+        return linkSourceId;
+    }
+
+    /**
+     * Sets link source id.
+     *
+     * @param linkSourceId link source id
+     */
+    public void setLinkSourceId(String linkSourceId) {
+        this.linkSourceId = linkSourceId;
+    }
+
+    /**
+     * Gets interface IP address.
+     *
+     * @return interface IP address
+     */
+    public Ip4Address interfaceIp() {
+        return interfaceIp;
+    }
+
+    /**
+     * Sets interface IP address.
+     *
+     * @param interfaceIp interface IP address
+     */
+    public void setInterfaceIp(Ip4Address interfaceIp) {
+        this.interfaceIp = interfaceIp;
+    }
+
+    @Override
+    public Ip4Address neighborIp() {
+        return this.neighborIp;
+    }
+
+    @Override
+    public void setNeighborIp(Ip4Address neighborIp) {
+        this.neighborIp = neighborIp;
+    }
+
+    @Override
+    public String toString() {
+        return MoreObjects.toStringHelper(getClass())
+                .omitNullValues()
+                .add("linkId", linkId)
+                .add("linkSourceId", linkSourceId)
+                .add("linkDestinationId", linkDestinationId)
+                .add("interfaceIp", interfaceIp)
+                .toString();
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (o == null || getClass() != o.getClass()) {
+            return false;
+        }
+        DefaultIsisLinkInformation that = (DefaultIsisLinkInformation) o;
+        return Objects.equal(linkId, that.linkId) &&
+                Objects.equal(linkSourceId, that.linkSourceId) &&
+                Objects.equal(linkDestinationId, that.linkDestinationId) &&
+                Objects.equal(interfaceIp, that.interfaceIp);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hashCode(linkId, linkSourceId, linkDestinationId,
+                interfaceIp);
+    }
+}
\ No newline at end of file

+/*
+ * Copyright 2016 Open Networking Laboratory
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.onosproject.isis.controller.impl.topology;
+
+import com.google.common.base.MoreObjects;
+import com.google.common.base.Objects;
+import org.onlab.packet.Ip4Address;
+import org.onlab.util.Bandwidth;
+import org.onosproject.isis.controller.topology.IsisLinkTed;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Representation of an ISIS device information.
+ */
+public class DefaultIsisLinkTed implements IsisLinkTed {
+    private int administrativeGroup;
+    private Ip4Address ipv4InterfaceAddress;
+    private Ip4Address ipv4NeighborAddress;
+    private Bandwidth maximumLinkBandwidth;
+    private Bandwidth maximumReservableLinkBandwidth;
+    private List<Bandwidth> unreservedBandwidth = new ArrayList<>();
+    private long teDefaultMetric;
+
+    @Override
+    public int administrativeGroup() {
+        return administrativeGroup;
+    }
+
+    @Override
+    public void setAdministrativeGroup(int administrativeGroup) {
+        this.administrativeGroup = administrativeGroup;
+    }
+
+    @Override
+    public Ip4Address ipv4InterfaceAddress() {
+        return ipv4InterfaceAddress;
+    }
+
+    @Override
+    public void setIpv4InterfaceAddress(Ip4Address interfaceAddress) {
+        this.ipv4InterfaceAddress = interfaceAddress;
+    }
+
+    @Override
+    public Ip4Address ipv4NeighborAddress() {
+        return ipv4NeighborAddress;
+    }
+
+    @Override
+    public void setIpv4NeighborAddress(Ip4Address neighborAddress) {
+        this.ipv4NeighborAddress = neighborAddress;
+    }
+
+    @Override
+    public Bandwidth maximumLinkBandwidth() {
+        return maximumLinkBandwidth;
+    }
+
+    @Override
+    public void setMaximumLinkBandwidth(Bandwidth bandwidth) {
+        this.maximumLinkBandwidth = bandwidth;
+    }
+
+    @Override
+    public Bandwidth maximumReservableLinkBandwidth() {
+        return maximumReservableLinkBandwidth;
+    }
+
+    @Override
+    public void setMaximumReservableLinkBandwidth(Bandwidth bandwidth) {
+        this.maximumReservableLinkBandwidth = bandwidth;
+    }
+
+    @Override
+    public List<Bandwidth> unreservedBandwidth() {
+        return this.unreservedBandwidth;
+    }
+
+    @Override
+    public void setUnreservedBandwidth(List<Bandwidth> bandwidth) {
+        this.unreservedBandwidth.addAll(bandwidth);
+    }
+
+    @Override
+    public long teDefaultMetric() {
+        return teDefaultMetric;
+    }
+
+    @Override
+    public void setTeDefaultMetric(long teMetric) {
+        this.teDefaultMetric = teMetric;
+    }
+
+    @Override
+    public String toString() {
+        return MoreObjects.toStringHelper(getClass())
+                .omitNullValues()
+                .add("administrativeGroup", administrativeGroup)
+                .add("ipv4InterfaceAddress", ipv4InterfaceAddress)
+                .add("ipv4NeighborAddress", ipv4NeighborAddress)
+                .add("maximumLinkBandwidth", maximumLinkBandwidth)
+                .add("maximumReservableLinkBandwidth", maximumReservableLinkBandwidth)
+                .add("teDefaultMetric", teDefaultMetric)
+                .toString();
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (o == null || getClass() != o.getClass()) {
+            return false;
+        }
+        DefaultIsisLinkTed that = (DefaultIsisLinkTed) o;
+        return Objects.equal(administrativeGroup, that.administrativeGroup) &&
+                Objects.equal(ipv4InterfaceAddress, that.ipv4InterfaceAddress) &&
+                Objects.equal(ipv4NeighborAddress, that.ipv4NeighborAddress) &&
+                Objects.equal(maximumLinkBandwidth, that.maximumLinkBandwidth) &&
+                Objects.equal(maximumReservableLinkBandwidth,
+                              that.maximumReservableLinkBandwidth) &&
+                Objects.equal(teDefaultMetric, that.teDefaultMetric);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hashCode(administrativeGroup, ipv4InterfaceAddress,
+                                ipv4NeighborAddress, maximumLinkBandwidth, teDefaultMetric);
+    }
+}
\ No newline at end of file

+/*
+ * Copyright 2015 Open Networking Laboratory
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onosproject.isis.controller.impl.topology;
+
+import com.google.common.base.MoreObjects;
+import com.google.common.base.Objects;
+import org.onlab.packet.Ip4Address;
+import org.onosproject.isis.controller.topology.IsisRouter;
+
+/**
+ * Representation of an ISIS Router.
+ */
+public class DefaultIsisRouter implements IsisRouter {
+
+    private String systemId;
+    private Ip4Address neighborRouterId;
+    private Ip4Address interfaceId;
+    private boolean isDis;
+
+    /**
+     * Gets the system ID.
+     *
+     * @return systemId system ID
+     */
+    public String systemId() {
+        return systemId;
+    }
+
+    /**
+     * Sets IP address of the Router.
+     */
+    public void setSystemId(String systemId) {
+        this.systemId = systemId;
+    }
+
+    /**
+     * Gets IP address of the interface.
+     *
+     * @return IP address of the interface
+     */
+    public Ip4Address interfaceId() {
+        return interfaceId;
+    }
+
+    /**
+     * Gets IP address of the interface.
+     *
+     * @param interfaceId IP address of the interface
+     */
+    public void setInterfaceId(Ip4Address interfaceId) {
+        this.interfaceId = interfaceId;
+    }
+
+    /**
+     * Gets neighbor's Router id.
+     *
+     * @return neighbor's Router id
+     */
+    public Ip4Address neighborRouterId() {
+        return neighborRouterId;
+    }
+
+    /**
+     * Sets neighbor's Router id.
+     *
+     * @param advertisingRouterId neighbor's Router id
+     */
+    public void setNeighborRouterId(Ip4Address advertisingRouterId) {
+        this.neighborRouterId = advertisingRouterId;
+    }
+
+    /**
+     * Gets if DR or not.
+     *
+     * @return true if DR else false
+     */
+    public boolean isDis() {
+        return isDis;
+    }
+
+    /**
+     * Sets dis or not.
+     *
+     * @param dis true if DIS else false
+     */
+    public void setDis(boolean dis) {
+        isDis = dis;
+    }
+
+    @Override
+    public String toString() {
+        return MoreObjects.toStringHelper(getClass())
+                .omitNullValues()
+                .add("systemId", systemId)
+                .add("neighborRouterId", neighborRouterId)
+                .add("interfaceId", interfaceId)
+                .toString();
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (o == null || getClass() != o.getClass()) {
+            return false;
+        }
+        DefaultIsisRouter that = (DefaultIsisRouter) o;
+        return Objects.equal(systemId, that.systemId) &&
+                Objects.equal(neighborRouterId, that.neighborRouterId) &&
+                Objects.equal(interfaceId, that.interfaceId);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hashCode(systemId, neighborRouterId, interfaceId);
+    }
+}
\ No newline at end of file

+/*
+* Copyright 2016 Open Networking Laboratory
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*     http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+package org.onosproject.isis.controller.impl.topology;
+
+import org.onlab.util.Bandwidth;
+import org.onosproject.isis.controller.topology.DeviceInformation;
+import org.onosproject.isis.controller.topology.IsisRouter;
+import org.onosproject.isis.controller.topology.LinkInformation;
+import org.onosproject.isis.controller.topology.TopologyForDeviceAndLink;
+import org.onosproject.isis.controller.topology.IsisLinkTed;
+import org.onosproject.isis.io.isispacket.pdu.LsPdu;
+import org.onosproject.isis.io.isispacket.tlv.IsExtendedReachability;
+import org.onosproject.isis.io.isispacket.tlv.IsisTlv;
+import org.onosproject.isis.io.isispacket.tlv.NeighborForExtendedIs;
+
+import org.onosproject.isis.io.isispacket.tlv.subtlv.TrafficEngineeringSubTlv;
+import org.onosproject.isis.io.isispacket.tlv.subtlv.InterfaceIpAddress;
+import org.onosproject.isis.io.isispacket.tlv.subtlv.NeighborIpAddress;
+import org.onosproject.isis.io.isispacket.tlv.subtlv.AdministrativeGroup;
+import org.onosproject.isis.io.isispacket.tlv.subtlv.TrafficEngineeringMetric;
+import org.onosproject.isis.io.isispacket.tlv.subtlv.UnreservedBandwidth;
+import org.onosproject.isis.io.isispacket.tlv.subtlv.MaximumReservableBandwidth;
+import org.onosproject.isis.io.isispacket.tlv.subtlv.MaximumBandwidth;
+import org.onosproject.isis.io.util.IsisConstants;
+import org.onosproject.isis.io.util.IsisUtil;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Represents device and link topology information.
+ */
+public class TopologyForDeviceAndLinkImpl implements TopologyForDeviceAndLink {
+
+    private static final Logger log = LoggerFactory.getLogger(TopologyForDeviceAndLinkImpl.class);
+    private Map<String, DeviceInformation> deviceInformationMap = new LinkedHashMap<>();
+    private Map<String, IsisRouter> isisRouterDetails = new LinkedHashMap<>();
+    private Map<String, DeviceInformation> deviceInformationMapForPointToPoint = new LinkedHashMap<>();
+    private Map<String, DeviceInformation> deviceInformationMapToDelete = new LinkedHashMap<>();
+    private Map<String, LinkInformation> addedLinkInformationMap = new LinkedHashMap<>();
+
+    /**
+     * Gets device information.
+     *
+     * @return device information
+     */
+    public Map<String, DeviceInformation> deviceInformationMap() {
+        return deviceInformationMap;
+    }
+
+    /**
+     * Gets ISIS router list information.
+     *
+     * @return router information
+     */
+    public Map<String, IsisRouter> isisDeviceList() {
+        return isisRouterDetails;
+    }
+
+    /**
+     * Sets device information.
+     *
+     * @param key                  key used to add in map
+     * @param deviceInformationMap device information instance
+     */
+    public void setDeviceInformationMap(String key, DeviceInformation deviceInformationMap) {
+        if (deviceInformationMap != null) {
+            this.deviceInformationMap.put(key, deviceInformationMap);
+        }
+
+    }
+
+    /**
+     * Gets deviceInformation as map for Point-To-Point.
+     *
+     * @return deviceInformationMap
+     */
+    public Map<String, DeviceInformation> deviceInformationMapForPointToPoint() {
+        return deviceInformationMapForPointToPoint;
+    }
+
+    /**
+     * Sets deviceInformation as map for Point-To-Point..
+     *
+     * @param key                  key used to add in map
+     * @param deviceInformationMap device information instance
+     */
+    public void setDeviceInformationMapForPointToPoint(String key, DeviceInformation deviceInformationMap) {
+        if (deviceInformationMap != null) {
+            this.deviceInformationMapForPointToPoint.put(key, deviceInformationMap);
+        }
+
+    }
+
+    /**
+     * Gets deviceInformation as map.
+     *
+     * @return deviceInformationMap to delete from core
+     */
+    public Map<String, DeviceInformation> deviceInformationMapToDelete() {
+        return deviceInformationMapToDelete;
+    }
+
+    /**
+     * Sets device information for removal.
+     *
+     * @param key                          ket used to add in map
+     * @param deviceInformationMapToDelete map from device information to remove
+     */
+    public void setDeviceInformationMapToDelete(String key, DeviceInformation deviceInformationMapToDelete) {
+        if (deviceInformationMapToDelete != null) {
+            this.deviceInformationMapToDelete.put(key, deviceInformationMapToDelete);
+        }
+    }
+
+    /**
+     * Removes Device Information.
+     *
+     * @param key ket used to remove from map
+     */
+    public void removeDeviceInformationMapFromDeleteMap(String key) {
+        removeDeviceInformationMap(key);
+        if (this.deviceInformationMapToDelete.containsKey(key)) {
+            this.deviceInformationMapToDelete.remove(key);
+        }
+    }
+
+    /**
+     * Gets Device Information.
+     *
+     * @param key system id as key to store in map
+     * @return Device Information
+     */
+    public DeviceInformation deviceInformation(String key) {
+        DeviceInformation deviceInformation = this.deviceInformationMap.get(key);
+        return deviceInformation;
+    }
+
+    /**
+     * Removes Device Information from map.
+     *
+     * @param key key used to remove from map
+     */
+    public void removeDeviceInformationMap(String key) {
+        if (this.deviceInformationMap.containsKey(key)) {
+            this.deviceInformationMap.remove(key);
+        }
+    }
+
+    @Override
+    public void removeLinks(String linkId) {
+        this.addedLinkInformationMap.remove(linkId);
+    }
+
+    /**
+     * Gets link information as map.
+     *
+     * @return link information as map
+     */
+    public Map<String, LinkInformation> linkInformationMap() {
+        return addedLinkInformationMap;
+    }
+
+    private LinkInformation getLinkInformation(String key) {
+        LinkInformation linkInformation = this.addedLinkInformationMap.get(key);
+        return linkInformation;
+    }
+
+    /**
+     * Sets link information in map.
+     *
+     * @param key                key used to add in map
+     * @param linkInformationMap link information instance
+     */
+    public void setLinkInformationMap(String key, LinkInformation linkInformationMap) {
+        if (!this.addedLinkInformationMap.containsKey(key)) {
+            this.addedLinkInformationMap.put(key, linkInformationMap);
+        }
+    }
+
+    /**
+     * Gets linkInformation as map for PointToPoint.
+     *
+     * @return linkInformationMap
+     */
+    public Map<String, LinkInformation> linkInformationMapForPointToPoint() {
+        return addedLinkInformationMap;
+    }
+
+    /**
+     * Sets linkInformation as map for PointToPoint.
+     *
+     * @param key                key used to add in map
+     * @param linkInformationMap link information instance
+     */
+    public void setLinkInformationMapForPointToPoint(String key, LinkInformation linkInformationMap) {
+        if (!this.addedLinkInformationMap.containsKey(key)) {
+            this.addedLinkInformationMap.put(key, linkInformationMap);
+        }
+    }
+
+    /**
+     * Removes Link Information from linkInformationMap.
+     *
+     * @param key key used to remove in map
+     */
+    public void removeLinkInformationMap(String key) {
+        if (this.addedLinkInformationMap.containsKey(key)) {
+            this.addedLinkInformationMap.remove(key);
+        }
+    }
+
+    /**
+     * Returns the ISIS router instance.
+     *
+     * @param systemId system ID to get router details
+     * @return ISIS router instance
+     */
+    public IsisRouter isisRouter(String systemId) {
+        String routerId = IsisUtil.removeTailingZeros(systemId);
+        IsisRouter isisRouter = isisRouterDetails.get(routerId);
+        if (isisRouter != null) {
+            return isisRouter;
+        } else {
+            log.debug("IsisRouter is not available");
+            IsisRouter isisRouterCheck = new DefaultIsisRouter();
+            isisRouterCheck.setSystemId(routerId);
+            return isisRouterCheck;
+        }
+    }
+
+    /**
+     * Removes the ISIS router instance from map.
+     *
+     * @param systemId system ID to remove router details
+     */
+    public void removeRouter(String systemId) {
+        String routerId = IsisUtil.removeTailingZeros(systemId);
+        isisRouterDetails.remove(systemId);
+    }
+
+    /**
+     * Creates Device instance.
+     *
+     * @param lsPdu ISIS LSPDU instance
+     * @return isisRouter isisRouter instance
+     */
+    public IsisRouter createDeviceInfo(LsPdu lsPdu) {
+        IsisRouter isisRouter = createIsisRouter(lsPdu);
+
+        if (isisRouter.systemId() != null) {
+            if (isisRouter.interfaceId() == null && isisRouter.neighborRouterId() == null) {
+                isisRouter.setInterfaceId(IsisConstants.DEFAULTIP);
+                isisRouter.setNeighborRouterId(IsisConstants.DEFAULTIP);
+                isisRouterDetails.put(isisRouter.systemId(), isisRouter);
+            }
+        }
+        return isisRouter;
+    }/*
+
+    *//**
+     * Removes Device and Link instance.
+     *
+     * @param lsPdu ISIS LSPDU instance
+     * @return isisRouter isisRouter instance
+     *//*
+    public IsisRouter removeDeviceAndLinkInfo(LsPdu lsPdu) {
+        IsisRouter isisRouter = createIsisRouter(lsPdu);
+        return isisRouter;
+    }*/
+
+    /**
+     * Creates link information.
+     *
+     * @param lsPdu       ls pdu instance
+     * @param ownSystemId system ID
+     * @return link information
+     */
+    public Map<String, LinkInformation> createLinkInfo(LsPdu lsPdu, String ownSystemId) {
+        for (IsisTlv isisTlv : lsPdu.tlvs()) {
+            if (isisTlv instanceof IsExtendedReachability) {
+                IsExtendedReachability isExtendedReachability = (IsExtendedReachability) isisTlv;
+                List<NeighborForExtendedIs> neighborForExtendedIsList = isExtendedReachability.neighbours();
+                for (NeighborForExtendedIs neighbor : neighborForExtendedIsList) {
+                    String neighbourId = neighbor.neighborId();
+                    String routerId = IsisUtil.removeTailingZeros(lsPdu.lspId());
+                    if (!(neighbourId.equals(ownSystemId))) {
+                        IsisRouter isisRouter = isisRouterDetails.get(neighbourId);
+                        if (isisRouter != null) {
+                            String linkId = "link:" + routerId + "-" + neighbourId;
+                            addedLinkInformationMap.put(linkId, createLinkInformation(lsPdu, linkId,
+                                    routerId, neighbourId));
+                        } else {
+                            createIsisRouterDummy(neighbourId);
+                            String linkId = "link:" + routerId + "-" + neighbourId;
+                            LinkInformation linkInformation = createLinkInformation(lsPdu, linkId,
+                                    routerId, neighbourId);
+                            linkInformation.setAlreadyCreated(true);
+                            addedLinkInformationMap.put(linkId, linkInformation);
+                        }
+                    }
+
+                }
+            }
+        }
+        return addedLinkInformationMap;
+    }
+
+    /**
+     * Removes link information.
+     *
+     * @param systemId system ID to remove link information
+     * @return updated link information
+     */
+    public Map<String, LinkInformation> removeLinkInfo(String systemId) {
+        String routerId = IsisUtil.removeTailingZeros(systemId);
+        Map<String, LinkInformation> removeLinkInformationMap = new LinkedHashMap<>();
+        for (String key : addedLinkInformationMap.keySet()) {
+            if (key.contains(routerId)) {
+                removeLinkInformationMap.put(key, addedLinkInformationMap.get(key));
+            }
+        }
+        return removeLinkInformationMap;
+    }
+
+    /**
+     * Creates link information.
+     *
+     * @param lsPdu       link state pdu
+     * @param linkId      link id
+     * @param localRouter local router system id
+     * @param neighborId  destination router system id
+     * @return linkInformation instance
+     */
+    private LinkInformation createLinkInformation(LsPdu lsPdu, String linkId, String localRouter, String neighborId) {
+        LinkInformation linkInformation = new DefaultIsisLinkInformation();
+        IsisRouter isisRouter = isisRouterDetails.get(neighborId);
+        for (IsisTlv isisTlv : lsPdu.tlvs()) {
+            if (isisTlv instanceof IsExtendedReachability) {
+                IsExtendedReachability isExtendedReachability = (IsExtendedReachability) isisTlv;
+                List<NeighborForExtendedIs> neighbours = isExtendedReachability.neighbours();
+                for (NeighborForExtendedIs teTlv : neighbours) {
+                    List<TrafficEngineeringSubTlv> teSubTlvs = teTlv.teSubTlv();
+                    for (TrafficEngineeringSubTlv teSubTlv : teSubTlvs) {
+                        if (teSubTlv instanceof InterfaceIpAddress) {
+                            InterfaceIpAddress localIpAddress = (InterfaceIpAddress) teSubTlv;
+                            linkInformation.setInterfaceIp(localIpAddress.localInterfaceIPAddress());
+                        } else if (teSubTlv instanceof NeighborIpAddress) {
+                            NeighborIpAddress neighborIpAddress = (NeighborIpAddress) teSubTlv;
+                            linkInformation.setNeighborIp(neighborIpAddress.neighborIPAddress());
+                        }
+
+                    }
+                }
+            }
+        }
+        linkInformation.setLinkId(linkId);
+        linkInformation.setAlreadyCreated(false);
+        linkInformation.setLinkDestinationId(neighborId);
+        linkInformation.setLinkSourceId(localRouter);
+        return linkInformation;
+    }
+
+    /**
+     * Creates ISIS router instance.
+     *
+     * @param lsPdu lsp instance
+     * @return isisRouter instance
+     */
+    private IsisRouter createIsisRouter(LsPdu lsPdu) {
+        IsisRouter isisRouter = new DefaultIsisRouter();
+        if (IsisUtil.checkIsDis(lsPdu.lspId())) {
+            isisRouter.setDis(true);
+        } else {
+            isisRouter.setDis(false);
+        }
+        isisRouter.setSystemId(IsisUtil.removeTailingZeros(lsPdu.lspId()));
+        for (IsisTlv isisTlv : lsPdu.tlvs()) {
+            if (isisTlv instanceof IsExtendedReachability) {
+                IsExtendedReachability isExtendedReachability = (IsExtendedReachability) isisTlv;
+                List<NeighborForExtendedIs> neighbours = isExtendedReachability.neighbours();
+                for (NeighborForExtendedIs teTlv : neighbours) {
+                    List<TrafficEngineeringSubTlv> teSubTlvs = teTlv.teSubTlv();
+                    for (TrafficEngineeringSubTlv teSubTlv : teSubTlvs) {
+                        if (teSubTlv instanceof InterfaceIpAddress) {
+                            InterfaceIpAddress localIpAddress = (InterfaceIpAddress) teSubTlv;
+                            isisRouter.setInterfaceId(localIpAddress.localInterfaceIPAddress());
+                        } else if (teSubTlv instanceof NeighborIpAddress) {
+                            NeighborIpAddress neighborIpAddress = (NeighborIpAddress) teSubTlv;
+                            isisRouter.setNeighborRouterId(neighborIpAddress.neighborIPAddress());
+                        }
+
+                    }
+                }
+            }
+        }
+        return isisRouter;
+    }
+
+    /**
+     * Creates ISIS router instance.
+     *
+     * @param systemId system ID
+     * @return isisRouter instance
+     */
+    private IsisRouter createIsisRouterDummy(String systemId) {
+        IsisRouter isisRouter = new DefaultIsisRouter();
+        isisRouter.setSystemId(systemId);
+        isisRouter.setDis(false);
+        isisRouter.setInterfaceId(IsisConstants.DEFAULTIP);
+        isisRouter.setNeighborRouterId(IsisConstants.DEFAULTIP);
+
+        return isisRouter;
+    }
+
+    /**
+     * Creates the ISIS link TED information.
+     *
+     * @param lsPdu link state PDU
+     * @return isisLinkTed
+     */
+    public IsisLinkTed createIsisLinkTedInfo(LsPdu lsPdu) {
+        IsisLinkTed isisLinkTed = new DefaultIsisLinkTed();
+        for (IsisTlv isisTlv : lsPdu.tlvs()) {
+            if (isisTlv instanceof IsExtendedReachability) {
+                IsExtendedReachability isExtendedReachability = (IsExtendedReachability) isisTlv;
+                List<NeighborForExtendedIs> neighbours = isExtendedReachability.neighbours();
+                for (NeighborForExtendedIs teTlv : neighbours) {
+                    List<TrafficEngineeringSubTlv> teSubTlvs = teTlv.teSubTlv();
+                    for (TrafficEngineeringSubTlv teSubTlv : teSubTlvs) {
+                        if (teSubTlv instanceof AdministrativeGroup) {
+                            AdministrativeGroup ag = (AdministrativeGroup) teSubTlv;
+                            isisLinkTed.setAdministrativeGroup(ag.administrativeGroup());
+                        }
+                        if (teSubTlv instanceof InterfaceIpAddress) {
+                            InterfaceIpAddress localIpAddress = (InterfaceIpAddress) teSubTlv;
+                            isisLinkTed.setIpv4InterfaceAddress(localIpAddress.localInterfaceIPAddress());
+                        }
+                        if (teSubTlv instanceof NeighborIpAddress) {
+                            NeighborIpAddress neighborIpAddress = (NeighborIpAddress) teSubTlv;
+                            isisLinkTed.setIpv4NeighborAddress(neighborIpAddress.neighborIPAddress());
+                        }
+                        if (teSubTlv instanceof TrafficEngineeringMetric) {
+                            TrafficEngineeringMetric teM = (TrafficEngineeringMetric) teSubTlv;
+                            isisLinkTed.setTeDefaultMetric(teM.getTrafficEngineeringMetricValue());
+                        }
+                        if (teSubTlv instanceof MaximumBandwidth) {
+                            MaximumBandwidth maxLinkBandwidth = (MaximumBandwidth) teSubTlv;
+                            isisLinkTed.setMaximumLinkBandwidth(
+                                    Bandwidth.bps(maxLinkBandwidth.getMaximumBandwidthValue()));
+                        }
+                        if (teSubTlv instanceof MaximumReservableBandwidth) {
+                            MaximumReservableBandwidth maxReservableBw = (MaximumReservableBandwidth) teSubTlv;
+                            isisLinkTed.setMaximumReservableLinkBandwidth(
+                                    Bandwidth.bps(maxReservableBw.getMaximumBandwidthValue()));
+                        }
+                        if (teSubTlv instanceof UnreservedBandwidth) {
+                            UnreservedBandwidth unReservedBandwidth = (UnreservedBandwidth) teSubTlv;
+                            List<Bandwidth> bandwidthList = new ArrayList<>();
+                            List<Float> unReservedBandwidthList = unReservedBandwidth.unReservedBandwidthValue();
+                            for (Float unReservedBandwidthFloatValue : unReservedBandwidthList) {
+                                Bandwidth bandwidth = Bandwidth.bps(unReservedBandwidthFloatValue);
+                                bandwidthList.add(bandwidth);
+                            }
+                            isisLinkTed.setUnreservedBandwidth(bandwidthList);
+                        }
+                    }
+                }
+            }
+        }
+        return isisLinkTed;
+    }
+}
\ No newline at end of file

+/*
+ * Copyright 2016-present Open Networking Laboratory
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * Implementation of the ISIS controller topology.
+ */
+package org.onosproject.isis.controller.impl.topology;
\ No newline at end of file

@@ -90,7 +90,6 @@ public class LsPdu extends IsisHeader {
 
 
     /**
     /**
      * Creates an instance of Link State packet.
      * Creates an instance of Link State packet.
-     * Parameterized constructor which populate
      *
      *
      * @param isisHeader isis header details
      * @param isisHeader isis header details
      */
      */
@@ -99,6 +98,15 @@ public class LsPdu extends IsisHeader {
     }
     }
 
 
     /**
     /**
+     * Returns the ISIS tlvs.
+     *
+     * @return tlvs
+     */
+    public List<IsisTlv> tlvs() {
+        return this.variableLengths;
+    }
+
+    /**
      * Adds the isis tlv to the list for the link state PDU.
      * Adds the isis tlv to the list for the link state PDU.
      *
      *
      * @param isisTlv isis tlv
      * @param isisTlv isis tlv

@@ -52,6 +52,15 @@ public class IpExtendedReachabilityTlv extends TlvHeader implements IsisTlv {
     }
     }
 
 
     /**
     /**
+     * Returns list of traffic engineering sub tlvs.
+     *
+     * @return trafEnginSubTlv
+     */
+    public List<TrafficEngineeringSubTlv> teTlvs() {
+        return this.trafEnginSubTlv;
+    }
+
+    /**
      * Returns the prefix of IP external reachability TLV.
      * Returns the prefix of IP external reachability TLV.
      *
      *
      * @return prefix
      * @return prefix

@@ -41,6 +41,15 @@ public class IsExtendedReachability extends TlvHeader implements IsisTlv {
     }
     }
 
 
     /**
     /**
+     * Returns neighbor list.
+     *
+     * @return neighbor list
+     */
+    public List<NeighborForExtendedIs> neighbours() {
+        return neighbors;
+    }
+
+    /**
      * Adds the neighbor for extended IS instance to IS extended reachability TLV.
      * Adds the neighbor for extended IS instance to IS extended reachability TLV.
      *
      *
      * @param neighbor neighbor for extended IS instance
      * @param neighbor neighbor for extended IS instance

@@ -46,6 +46,15 @@ public class NeighborForExtendedIs {
     }
     }
 
 
     /**
     /**
+     * Returns list of sub tlvs.
+     *
+     * @return teSubTlv list of sub tlvs
+     */
+    public List<TrafficEngineeringSubTlv> teSubTlv() {
+        return teSubTlv;
+    }
+
+    /**
      * Sets neighbor ID.
      * Sets neighbor ID.
      *
      *
      * @param neighborId neighbor ID
      * @param neighborId neighbor ID

 /*
 /*
- * Copyright 2016-present Open Networking Laboratory
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
+* Copyright 2016-present Open Networking Laboratory
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*     http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
 package org.onosproject.isis.io.isispacket.tlv.subtlv;
 package org.onosproject.isis.io.isispacket.tlv.subtlv;
 
 
 import com.google.common.base.MoreObjects;
 import com.google.common.base.MoreObjects;
@@ -32,8 +32,8 @@ import java.util.List;
  */
  */
 public class InterfaceIpAddress extends TlvHeader implements TrafficEngineeringSubTlv {
 public class InterfaceIpAddress extends TlvHeader implements TrafficEngineeringSubTlv {
     private static final Logger log =
     private static final Logger log =
-            LoggerFactory.getLogger(InterfaceIpAddress.class);
-    private List<Ip4Address> localInterfaceIPAddress = new ArrayList<>();
+            LoggerFactory.getLogger(NeighborIpAddress.class);
+    private Ip4Address localInterfaceIPAddress;
 
 
     /**
     /**
      * Creates an instance of local interface ip address.
      * Creates an instance of local interface ip address.
@@ -50,16 +50,16 @@ public class InterfaceIpAddress extends TlvHeader implements TrafficEngineeringS
      *
      *
      * @param localAddress ip address
      * @param localAddress ip address
      */
      */
-    public void addLocalInterfaceIPAddress(Ip4Address localAddress) {
-        localInterfaceIPAddress.add(localAddress);
+    public void setIpAddress(Ip4Address localAddress) {
+        this.localInterfaceIPAddress = localAddress;
     }
     }
 
 
     /**
     /**
-     * Returns local interface ip address.
+     * Gets local interface ip address.
      *
      *
      * @return localAddress ip address
      * @return localAddress ip address
      */
      */
-    public List<Ip4Address> getLocalInterfaceIPAddress() {
+    public Ip4Address localInterfaceIPAddress() {
         return localInterfaceIPAddress;
         return localInterfaceIPAddress;
     }
     }
 
 
@@ -72,17 +72,19 @@ public class InterfaceIpAddress extends TlvHeader implements TrafficEngineeringS
         while (channelBuffer.readableBytes() >= IsisUtil.FOUR_BYTES) {
         while (channelBuffer.readableBytes() >= IsisUtil.FOUR_BYTES) {
             byte[] tempByteArray = new byte[IsisUtil.FOUR_BYTES];
             byte[] tempByteArray = new byte[IsisUtil.FOUR_BYTES];
             channelBuffer.readBytes(tempByteArray, 0, IsisUtil.FOUR_BYTES);
             channelBuffer.readBytes(tempByteArray, 0, IsisUtil.FOUR_BYTES);
-            this.addLocalInterfaceIPAddress(Ip4Address.valueOf(tempByteArray));
+            this.setIpAddress(Ip4Address.valueOf(tempByteArray));
+
         }
         }
     }
     }
 
 
     /**
     /**
-     * Returns local interface ip address as byte array.
+     * Gets local interface ip address as byte array.
      *
      *
      * @return local interface ip address as byte array
      * @return local interface ip address as byte array
      */
      */
     public byte[] asBytes() {
     public byte[] asBytes() {
         byte[] linkSubType = null;
         byte[] linkSubType = null;
+
         byte[] linkSubTlvHeader = tlvHeaderAsByteArray();
         byte[] linkSubTlvHeader = tlvHeaderAsByteArray();
         byte[] linkSubTlvBody = tlvBodyAsBytes();
         byte[] linkSubTlvBody = tlvBodyAsBytes();
         linkSubType = Bytes.concat(linkSubTlvHeader, linkSubTlvBody);
         linkSubType = Bytes.concat(linkSubTlvHeader, linkSubTlvBody);
@@ -91,15 +93,16 @@ public class InterfaceIpAddress extends TlvHeader implements TrafficEngineeringS
     }
     }
 
 
     /**
     /**
-     * Returns byte array of local interface ip address.
+     * Gets byte array of local interface ip address.
      *
      *
      * @return byte array of local interface ip address
      * @return byte array of local interface ip address
      */
      */
     public byte[] tlvBodyAsBytes() {
     public byte[] tlvBodyAsBytes() {
+
         List<Byte> linkSubTypeBody = new ArrayList<>();
         List<Byte> linkSubTypeBody = new ArrayList<>();
-        for (Ip4Address remoteAddress : this.localInterfaceIPAddress) {
-            linkSubTypeBody.addAll(Bytes.asList(remoteAddress.toOctets()));
-        }
+
+        linkSubTypeBody.addAll(Bytes.asList(this.localInterfaceIPAddress.toOctets()));
+
 
 
         return Bytes.toArray(linkSubTypeBody);
         return Bytes.toArray(linkSubTypeBody);
     }
     }
@@ -111,4 +114,4 @@ public class InterfaceIpAddress extends TlvHeader implements TrafficEngineeringS
                 .add("localInterfaceIPAddress", localInterfaceIPAddress)
                 .add("localInterfaceIPAddress", localInterfaceIPAddress)
                 .toString();
                 .toString();
     }
     }
-}
+}
\ No newline at end of file

+/*
+* Copyright 2016-present Open Networking Laboratory
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*     http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+package org.onosproject.isis.io.isispacket.tlv.subtlv;
+
+import com.google.common.base.MoreObjects;
+import com.google.common.base.Objects;
+import com.google.common.primitives.Bytes;
+import org.jboss.netty.buffer.ChannelBuffer;
+import org.onlab.packet.Ip4Address;
+import org.onosproject.isis.io.isispacket.tlv.TlvHeader;
+import org.onosproject.isis.io.util.IsisUtil;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Representation of neighbor ip address TE value.
+ */
+public class NeighborIpAddress extends TlvHeader implements TrafficEngineeringSubTlv {
+    private static final Logger log =
+            LoggerFactory.getLogger(NeighborIpAddress.class);
+    private Ip4Address neighborIPAddress;
+
+    /**
+     * Creates an instance of neighbor ip address.
+     *
+     * @param header tlv header instance
+     */
+    public NeighborIpAddress(TlvHeader header) {
+        this.setTlvType(header.tlvType());
+        this.setTlvLength(header.tlvLength());
+    }
+
+    /**
+     * Sets the neighbor ip address.
+     *
+     * @param neighborIPAddress ip address
+     */
+    public void setIpAddress(Ip4Address neighborIPAddress) {
+        this.neighborIPAddress = neighborIPAddress;
+    }
+
+    /**
+     * Gets the neighbor ip address.
+     *
+     * @return neighbor ip address
+     */
+    public Ip4Address neighborIPAddress() {
+        return neighborIPAddress;
+    }
+
+    /**
+     * Reads bytes from channel buffer.
+     *
+     * @param channelBuffer channel buffer instance
+     */
+    public void readFrom(ChannelBuffer channelBuffer) {
+        while (channelBuffer.readableBytes() >= IsisUtil.FOUR_BYTES) {
+            byte[] tempByteArray = new byte[IsisUtil.FOUR_BYTES];
+            channelBuffer.readBytes(tempByteArray, 0, IsisUtil.FOUR_BYTES);
+            this.setIpAddress(Ip4Address.valueOf(tempByteArray));
+
+        }
+    }
+
+    /**
+     * Gets the neighbor ip address as byte array.
+     *
+     * @return neighbor ip address as byte array
+     */
+    public byte[] asBytes() {
+        byte[] linkSubType = null;
+
+        byte[] linkSubTlvHeader = tlvHeaderAsByteArray();
+        byte[] linkSubTlvBody = tlvBodyAsBytes();
+        linkSubType = Bytes.concat(linkSubTlvHeader, linkSubTlvBody);
+
+        return linkSubType;
+    }
+
+    /**
+     * Gets byte array of neighborIPAddress.
+     *
+     * @return byte array of neighborIPAddress
+     */
+    public byte[] tlvBodyAsBytes() {
+
+        List<Byte> linkSubTypeBody = new ArrayList<>();
+
+        linkSubTypeBody.addAll(Bytes.asList(this.neighborIPAddress.toOctets()));
+
+
+        return Bytes.toArray(linkSubTypeBody);
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (o == null || getClass() != o.getClass()) {
+            return false;
+        }
+        NeighborIpAddress that = (NeighborIpAddress) o;
+        return Objects.equal(neighborIPAddress, that.neighborIPAddress);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hashCode(neighborIPAddress);
+    }
+
+    @Override
+    public String toString() {
+        return MoreObjects.toStringHelper(getClass())
+                .omitNullValues()
+                .add("localInterfaceIPAddress", neighborIPAddress)
+                .toString();
+    }
+}
\ No newline at end of file

@@ -71,6 +71,11 @@ public final class SubTlvFinder {
                 ipInterfaceAddressTlv.readFrom(channelBuffer);
                 ipInterfaceAddressTlv.readFrom(channelBuffer);
                 subTlv = ipInterfaceAddressTlv;
                 subTlv = ipInterfaceAddressTlv;
                 break;
                 break;
+            case NEIGHBORADDRESS:
+                NeighborIpAddress ipNeighborAddressTlv = new NeighborIpAddress(tlvHeader);
+                ipNeighborAddressTlv.readFrom(channelBuffer);
+                subTlv = ipNeighborAddressTlv;
+                break;
             default:
             default:
                 //TODO
                 //TODO
                 break;
                 break;

@@ -60,8 +60,8 @@ public final class SubTlvToBytes {
         } else if (subTlv instanceof UnreservedBandwidth) {
         } else if (subTlv instanceof UnreservedBandwidth) {
             UnreservedBandwidth unreservedBandwidth = (UnreservedBandwidth) subTlv;
             UnreservedBandwidth unreservedBandwidth = (UnreservedBandwidth) subTlv;
             subTlvBytes.addAll(Bytes.asList(unreservedBandwidth.asBytes()));
             subTlvBytes.addAll(Bytes.asList(unreservedBandwidth.asBytes()));
-        } else if (subTlv instanceof InterfaceIpAddress) {
-            InterfaceIpAddress interfaceIpAddress = (InterfaceIpAddress) subTlv;
+        } else if (subTlv instanceof NeighborIpAddress) {
+            NeighborIpAddress interfaceIpAddress = (NeighborIpAddress) subTlv;
             subTlvBytes.addAll(Bytes.asList(interfaceIpAddress.asBytes()));
             subTlvBytes.addAll(Bytes.asList(interfaceIpAddress.asBytes()));
         } else {
         } else {
             log.debug("TlvsToBytes::UNKNOWN TLV TYPE ::TlvsToBytes ");
             log.debug("TlvsToBytes::UNKNOWN TLV TYPE ::TlvsToBytes ");

@@ -44,6 +44,10 @@ public enum SubTlvType {
      */
      */
     INTERFACEADDRESS(6),
     INTERFACEADDRESS(6),
     /**
     /**
+     * Represents traffic engineering neighbor address TLV.
+     */
+    NEIGHBORADDRESS(8),
+    /**
      * Represents traffic engineering unreserved bandwidth TLV.
      * Represents traffic engineering unreserved bandwidth TLV.
      */
      */
     UNRESERVEDBANDWIDTH(11);
     UNRESERVEDBANDWIDTH(11);

@@ -54,7 +54,7 @@ public class UnreservedBandwidth extends TlvHeader implements TrafficEngineering
      *
      *
      * @return List of un reserved bandwidth
      * @return List of un reserved bandwidth
      */
      */
-    public List<Float> getUnReservedBandwidthValue() {
+    public List<Float> unReservedBandwidthValue() {
         return this.unReservedBandwidth;
         return this.unReservedBandwidth;
     }
     }
 
 

@@ -65,6 +65,9 @@ public final class IsisConstants {
     public static final String AREAADDRESS = "areaAddress";
     public static final String AREAADDRESS = "areaAddress";
     public static final String HOLDINGTIME = "holdingTime";
     public static final String HOLDINGTIME = "holdingTime";
     public static final String HELLOINTERVAL = "helloInterval";
     public static final String HELLOINTERVAL = "helloInterval";
+    public static final int PORT = 7000;
+    public static final String LSPADDED = "LSP_ADDED";
+    public static final String LSPREMOVED = "LSP_REMOVED";
 
 
     /**
     /**
      * Non parameterized constructor.
      * Non parameterized constructor.

@@ -726,4 +726,37 @@ public final class IsisUtil {
         }
         }
         return Bytes.toArray(byteList);
         return Bytes.toArray(byteList);
     }
     }
+
+    /**
+     * Return the DIS value from the systemId.
+     *
+     * @param systemId system Id.
+     * @return return true if DIS else false
+     */
+    public static boolean checkIsDis(String systemId) {
+        StringTokenizer stringTokenizer = new StringTokenizer(systemId, "." + "-");
+        int count = 0;
+        while (stringTokenizer.hasMoreTokens()) {
+            String str = stringTokenizer.nextToken();
+            if (count == 3) {
+                int x = Integer.parseInt(str);
+                if (x > 0) {
+                    return true;
+                }
+            }
+            count++;
+        }
+        return false;
+    }
+
+    /**
+     * Return the systemId.
+     *
+     * @param systemId system Id.
+     * @return return system ID
+     */
+    public static String removeTailingZeros(String systemId) {
+        StringTokenizer stringTokenizer = new StringTokenizer(systemId, "-");
+        return stringTokenizer.nextToken();
+    }
 }
 }
\ No newline at end of file

@@ -33,7 +33,7 @@ import static org.hamcrest.Matchers.notNullValue;
 public class InterfaceIpAddressTest {
 public class InterfaceIpAddressTest {
     private final byte[] packet = {1, 1, 1, 1};
     private final byte[] packet = {1, 1, 1, 1};
     private final byte[] packet1 = {};
     private final byte[] packet1 = {};
-    private InterfaceIpAddress interfaceIpAddress;
+    private NeighborIpAddress interfaceIpAddress;
     private TlvHeader tlvHeader;
     private TlvHeader tlvHeader;
     private Ip4Address ip4Address = Ip4Address.valueOf("1.1.1.1");
     private Ip4Address ip4Address = Ip4Address.valueOf("1.1.1.1");
     private byte[] result;
     private byte[] result;
@@ -41,7 +41,7 @@ public class InterfaceIpAddressTest {
 
 
     @Before
     @Before
     public void setUp() throws Exception {
     public void setUp() throws Exception {
-        interfaceIpAddress = new InterfaceIpAddress(new TlvHeader());
+        interfaceIpAddress = new NeighborIpAddress(new TlvHeader());
     }
     }
 
 
     @After
     @After
@@ -61,15 +61,6 @@ public class InterfaceIpAddressTest {
     }
     }
 
 
     /**
     /**
-     * Tests addLocalInterfaceIPAddress() method.
-     */
-    @Test
-    public void testAddLocalInterfaceIPAddress() throws Exception {
-        interfaceIpAddress.addLocalInterfaceIPAddress(ip4Address);
-        assertThat(interfaceIpAddress, is(notNullValue()));
-    }
-
-    /**
      * Tests readFrom() method.
      * Tests readFrom() method.
      */
      */
     @Test
     @Test
@@ -77,7 +68,7 @@ public class InterfaceIpAddressTest {
         tlvHeader = new TlvHeader();
         tlvHeader = new TlvHeader();
         tlvHeader.setTlvType(3);
         tlvHeader.setTlvType(3);
         tlvHeader.setTlvLength(4);
         tlvHeader.setTlvLength(4);
-        interfaceIpAddress = new InterfaceIpAddress(tlvHeader);
+        interfaceIpAddress = new NeighborIpAddress(tlvHeader);
         channelBuffer = ChannelBuffers.copiedBuffer(packet);
         channelBuffer = ChannelBuffers.copiedBuffer(packet);
         interfaceIpAddress.readFrom(channelBuffer);
         interfaceIpAddress.readFrom(channelBuffer);
         assertThat(interfaceIpAddress, is(notNullValue()));
         assertThat(interfaceIpAddress, is(notNullValue()));
@@ -91,27 +82,11 @@ public class InterfaceIpAddressTest {
         tlvHeader = new TlvHeader();
         tlvHeader = new TlvHeader();
         tlvHeader.setTlvType(3);
         tlvHeader.setTlvType(3);
         tlvHeader.setTlvLength(4);
         tlvHeader.setTlvLength(4);
-        interfaceIpAddress = new InterfaceIpAddress(tlvHeader);
+        interfaceIpAddress = new NeighborIpAddress(tlvHeader);
         channelBuffer = ChannelBuffers.copiedBuffer(packet1);
         channelBuffer = ChannelBuffers.copiedBuffer(packet1);
         interfaceIpAddress.readFrom(channelBuffer);
         interfaceIpAddress.readFrom(channelBuffer);
         assertThat(interfaceIpAddress, is(notNullValue()));
         assertThat(interfaceIpAddress, is(notNullValue()));
     }
     }
 
 
-    /**
-     * Tests asBytes() method.
-     */
-    @Test
-    public void testAsBytes() throws Exception {
-        result = interfaceIpAddress.asBytes();
-        assertThat(result, is(notNullValue()));
-    }
 
 
-    /**
-     * Tests getLinkSubTypeTlvBodyAsByteArray() method.
-     */
-    @Test
-    public void testGetLinkSubTypeTlvBodyAsByteArray() throws Exception {
-        result = interfaceIpAddress.tlvBodyAsBytes();
-        assertThat(result, is(notNullValue()));
-    }
 }
 }
\ No newline at end of file

@@ -3,7 +3,7 @@ BUNDLES = [
     '//protocols/isis/ctl:onos-protocols-isis-ctl',
     '//protocols/isis/ctl:onos-protocols-isis-ctl',
     '//protocols/isis/isisio:onos-protocols-isis-isisio',
     '//protocols/isis/isisio:onos-protocols-isis-isisio',
     '//providers/isis/cfg:onos-providers-isis-cfg',
     '//providers/isis/cfg:onos-providers-isis-cfg',
-    '//providers/isis/device:onos-providers-isis-device',
+    '//providers/isis/topology:onos-providers-isis-topology',
 ]
 ]
 
 
 onos_app (
 onos_app (

@@ -21,6 +21,7 @@
     <artifact>mvn:${project.groupId}/onos-isis-api/${project.version}</artifact>
     <artifact>mvn:${project.groupId}/onos-isis-api/${project.version}</artifact>
     <artifact>mvn:${project.groupId}/onos-isis-isisio/${project.version}</artifact>
     <artifact>mvn:${project.groupId}/onos-isis-isisio/${project.version}</artifact>
     <artifact>mvn:${project.groupId}/onos-isis-ctl/${project.version}</artifact>
     <artifact>mvn:${project.groupId}/onos-isis-ctl/${project.version}</artifact>
-    <artifact>mvn:${project.groupId}/onos-isis-provider-device/${project.version}</artifact>
+    <artifact>mvn:${project.groupId}/onos-isis-provider-topology/${project.version}</artifact>
     <artifact>mvn:${project.groupId}/onos-isis-provider-cfg/${project.version}</artifact>
     <artifact>mvn:${project.groupId}/onos-isis-provider-cfg/${project.version}</artifact>
+    <artifact>mvn:${project.groupId}/onos-isis-provider-cli/${project.version}</artifact>
 </app>
 </app>
\ No newline at end of file

@@ -21,7 +21,8 @@
         <bundle>mvn:${project.groupId}/onos-isis-api/${project.version}</bundle>
         <bundle>mvn:${project.groupId}/onos-isis-api/${project.version}</bundle>
         <bundle>mvn:${project.groupId}/onos-isis-isisio/${project.version}</bundle>
         <bundle>mvn:${project.groupId}/onos-isis-isisio/${project.version}</bundle>
         <bundle>mvn:${project.groupId}/onos-isis-ctl/${project.version}</bundle>
         <bundle>mvn:${project.groupId}/onos-isis-ctl/${project.version}</bundle>
-        <bundle>mvn:${project.groupId}/onos-isis-provider-device/${project.version}</bundle>
+        <bundle>mvn:${project.groupId}/onos-isis-provider-topology/${project.version}</bundle>
         <bundle>mvn:${project.groupId}/onos-isis-provider-cfg/${project.version}</bundle>
         <bundle>mvn:${project.groupId}/onos-isis-provider-cfg/${project.version}</bundle>
+        <bundle>mvn:${project.groupId}/onos-isis-provider-cli/${project.version}</bundle>
     </feature>
     </feature>
-</features>
+</features>
\ No newline at end of file

@@ -48,7 +48,7 @@
         </dependency>
         </dependency>
         <dependency>
         <dependency>
             <groupId>org.onosproject</groupId>
             <groupId>org.onosproject</groupId>
-            <artifactId>onos-isis-provider-device</artifactId>
+            <artifactId>onos-isis-provider-topology</artifactId>
             <version>${project.version}</version>
             <version>${project.version}</version>
         </dependency>
         </dependency>
         <dependency>
         <dependency>
@@ -56,5 +56,10 @@
             <artifactId>onos-isis-provider-cfg</artifactId>
             <artifactId>onos-isis-provider-cfg</artifactId>
             <version>${project.version}</version>
             <version>${project.version}</version>
         </dependency>
         </dependency>
+        <dependency>
+            <groupId>org.onosproject</groupId>
+            <artifactId>onos-isis-provider-cli</artifactId>
+            <version>${project.version}</version>
+        </dependency>
     </dependencies>
     </dependencies>
-</project>
\ No newline at end of file
+</project>

-/*
- * Copyright 2016-present Open Networking Laboratory
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.onosproject.provider.isis.device.impl;
-
-import org.apache.felix.scr.annotations.Activate;
-import org.apache.felix.scr.annotations.Component;
-import org.apache.felix.scr.annotations.Deactivate;
-import org.apache.felix.scr.annotations.Reference;
-import org.apache.felix.scr.annotations.ReferenceCardinality;
-import org.onosproject.isis.controller.IsisController;
-import org.onosproject.net.provider.AbstractProvider;
-import org.onosproject.net.provider.ProviderId;
-import org.slf4j.Logger;
-
-import static org.slf4j.LoggerFactory.getLogger;
-
-/**
- * Provider which advertises device descriptions to the core.
- */
-@Component(immediate = true)
-public class IsisTopologyProvider extends AbstractProvider {
-
-    private static final Logger log = getLogger(IsisTopologyProvider.class);
-    final InternalDeviceProvider listener = new InternalDeviceProvider();
-    @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
-    private IsisController isisController;
-
-
-    /**
-     * Creates an ISIS device provider.
-     */
-    public IsisTopologyProvider() {
-        super(new ProviderId("isis", "org.onosproject.provider.isis"));
-    }
-
-    @Activate
-    public void activate() {
-        log.debug("Activate...!!!");
-    }
-
-    @Deactivate
-    public void deactivate() {
-        log.debug("Deactivate...!!!");
-    }
-
-    /**
-     * Internal device provider implementation.
-     */
-    private class InternalDeviceProvider {
-
-    }
-}

@@ -31,10 +31,10 @@
     <description>ONOS ISIS protocol adapters</description>
     <description>ONOS ISIS protocol adapters</description>
 
 
     <modules>
     <modules>
-        <module>device</module>
         <module>app</module>
         <module>app</module>
         <module>cfg</module>
         <module>cfg</module>
         <module>cli</module>
         <module>cli</module>
+        <module>topology</module>
     </modules>
     </modules>
 
 
     <dependencies>
     <dependencies>

 COMPILE_DEPS = [
 COMPILE_DEPS = [
     '//lib:CORE_DEPS',
     '//lib:CORE_DEPS',
     '//protocols/isis/api:onos-protocols-isis-api',
     '//protocols/isis/api:onos-protocols-isis-api',
+    '//protocols/isis/ctl:onos-protocols-isis-ctl',
+]
+
+TEST_DEPS = [
+    '//lib:TEST_ADAPTERS',
 ]
 ]
 
 
 osgi_jar_with_tests (
 osgi_jar_with_tests (
     deps = COMPILE_DEPS,
     deps = COMPILE_DEPS,
+    test_deps = TEST_DEPS,
 )
 )
-

@@ -25,7 +25,7 @@
         <version>1.7.0-SNAPSHOT</version>
         <version>1.7.0-SNAPSHOT</version>
     </parent>
     </parent>
 
 
-    <artifactId>onos-isis-provider-device</artifactId>
+    <artifactId>onos-isis-provider-topology</artifactId>
     <packaging>bundle</packaging>
     <packaging>bundle</packaging>
 
 
     <description>ONOS ISIS Providers</description>
     <description>ONOS ISIS Providers</description>

+/*
+ * Copyright 2016-present Open Networking Laboratory
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onosproject.provider.isis.topology.impl;
+
+import org.apache.felix.scr.annotations.Activate;
+import org.apache.felix.scr.annotations.Component;
+import org.apache.felix.scr.annotations.Deactivate;
+import org.apache.felix.scr.annotations.Reference;
+import org.apache.felix.scr.annotations.ReferenceCardinality;
+import org.onlab.packet.ChassisId;
+import org.onlab.util.Bandwidth;
+import org.onosproject.isis.controller.IsisController;
+import org.onosproject.isis.controller.topology.IsisLink;
+import org.onosproject.isis.controller.topology.IsisLinkListener;
+import org.onosproject.isis.controller.topology.IsisLinkTed;
+import org.onosproject.isis.controller.topology.IsisRouter;
+import org.onosproject.isis.controller.topology.IsisRouterId;
+import org.onosproject.isis.controller.topology.IsisRouterListener;
+import org.onosproject.net.AnnotationKeys;
+import org.onosproject.net.ConnectPoint;
+import org.onosproject.net.DefaultAnnotations;
+import org.onosproject.net.Device;
+import org.onosproject.net.DeviceId;
+import org.onosproject.net.Link;
+import org.onosproject.net.MastershipRole;
+import org.onosproject.net.PortNumber;
+import org.onosproject.net.config.NetworkConfigService;
+import org.onosproject.net.config.basics.BandwidthCapacity;
+import org.onosproject.net.device.DefaultDeviceDescription;
+import org.onosproject.net.device.DefaultPortDescription;
+import org.onosproject.net.device.DeviceDescription;
+import org.onosproject.net.device.DeviceProvider;
+import org.onosproject.net.device.DeviceProviderRegistry;
+import org.onosproject.net.device.DeviceProviderService;
+import org.onosproject.net.device.PortDescription;
+import org.onosproject.net.link.DefaultLinkDescription;
+import org.onosproject.net.link.LinkDescription;
+import org.onosproject.net.link.LinkProvider;
+import org.onosproject.net.link.LinkProviderRegistry;
+import org.onosproject.net.link.LinkProviderService;
+import org.onosproject.net.link.LinkService;
+import org.onosproject.net.provider.AbstractProvider;
+import org.onosproject.net.provider.ProviderId;
+import org.slf4j.Logger;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.StringTokenizer;
+
+import static org.slf4j.LoggerFactory.getLogger;
+
+/**
+ * Provider which advertises device descriptions to the core.
+ */
+@Component(immediate = true)
+public class IsisTopologyProvider extends AbstractProvider implements DeviceProvider, LinkProvider {
+
+    public static final long PSEUDO_PORT = 0xffffffff;
+    public static final String ADMINISTRATIVEGROUP = "administrativeGroup";
+    public static final String TE_METRIC = "teMetric";
+    public static final String MAXRESERVABLEBANDWIDTH = "maxReservableBandwidth";
+    public static final String ROUTERID = "routerId";
+    public static final String NEIGHBORID = "neighborId";
+    private static final Logger log = getLogger(IsisTopologyProvider.class);
+    // Default values for tunable parameters
+    private static final String UNKNOWN = "unknown";
+    final InternalTopologyProvider listener = new InternalTopologyProvider();
+    @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
+    protected DeviceProviderRegistry deviceProviderRegistry;
+    @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
+    protected LinkProviderRegistry linkProviderRegistry;
+    @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
+    protected NetworkConfigService networkConfigService;
+    @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
+    protected LinkService linkService;
+    @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
+    protected IsisController controller;
+    //This Interface that defines how this provider can interact with the core.
+    private LinkProviderService linkProviderService;
+    // The interface that defines how this Provider can interact with the core
+    private DeviceProviderService deviceProviderService;
+    private HashMap<DeviceId, List<PortDescription>> portMap = new HashMap<>();
+
+    /**
+     * Creates an ISIS device provider.
+     */
+    public IsisTopologyProvider() {
+        super(new ProviderId("l3", "org.onosproject.provider.isis"));
+    }
+
+    @Activate
+    public void activate() {
+        deviceProviderService = deviceProviderRegistry.register(this);
+        linkProviderService = linkProviderRegistry.register(this);
+        controller.addRouterListener(listener);
+        controller.addLinkListener(listener);
+        log.debug("IsisDeviceProvider::activate...!!!!");
+    }
+
+    @Deactivate
+    public void deactivate() {
+        log.debug("IsisDeviceProvider::deactivate...!!!!");
+        deviceProviderRegistry.unregister(this);
+        deviceProviderService = null;
+        linkProviderRegistry.unregister(this);
+        linkProviderService = null;
+        controller.removeRouterListener(listener);
+        controller.removeLinkListener(listener);
+    }
+
+    @Override
+    public void triggerProbe(DeviceId deviceId) {
+        log.debug("IsisDeviceProvider::triggerProbe...!!!!");
+    }
+
+    @Override
+    public void roleChanged(DeviceId deviceId, MastershipRole newRole) {
+        log.debug("IsisDeviceProvider::roleChanged...!!!!");
+    }
+
+    @Override
+    public boolean isReachable(DeviceId deviceId) {
+        log.debug("IsisDeviceProvider::isReachable...!!!!");
+        return true;
+    }
+
+    @Override
+    public void changePortState(DeviceId deviceId, PortNumber portNumber, boolean enable) {
+        log.debug("IsisDeviceProvider::changePortState...!!!!");
+    }
+
+    /**
+     * Builds link description.
+     *
+     * @param isisLink ISIS link instance
+     * @return link description
+     */
+    private LinkDescription buildLinkDes(IsisLink isisLink) {
+        long srcAddress = 0;
+        long dstAddress = 0;
+        boolean localPseduo = false;
+        boolean remotePseduo = false;
+        String localSystemId = isisLink.localSystemId();
+        String remoteSystemId = isisLink.remoteSystemId();
+        //Changing of port numbers
+        if (isisLink.interfaceIp() != null) {
+            //srcAddress = isisLink.interfaceIp().toInt();
+            srcAddress = (long) Long.parseUnsignedLong(Integer.toBinaryString(isisLink.interfaceIp().toInt()), 2);
+        }
+        if (isisLink.neighborIp() != null) {
+            //dstAddress = isisLink.neighborIp().toInt();
+            dstAddress = (long) Long.parseUnsignedLong(Integer.toBinaryString(isisLink.neighborIp().toInt()), 2);
+        }
+        DeviceId srcId = DeviceId.deviceId(IsisRouterId.uri(localSystemId));
+        DeviceId dstId = DeviceId.deviceId(IsisRouterId.uri(remoteSystemId));
+        if (checkIsDis(isisLink.localSystemId())) {
+            localPseduo = true;
+        } else if (checkIsDis(isisLink.remoteSystemId())) {
+            remotePseduo = true;
+        } else {
+            log.debug("IsisDeviceProvider::buildLinkDes : unknown type.!");
+        }
+
+        if (localPseduo && srcAddress == 0) {
+            srcAddress = PSEUDO_PORT;
+        } else if (remotePseduo && dstAddress == 0) {
+            dstAddress = PSEUDO_PORT;
+        }
+
+        ConnectPoint src = new ConnectPoint(srcId, PortNumber.portNumber(srcAddress));
+        ConnectPoint dst = new ConnectPoint(dstId, PortNumber.portNumber(dstAddress));
+        DefaultAnnotations.Builder annotationBuilder = DefaultAnnotations.builder();
+        if (isisLink != null) {
+            annotationBuilder = buildAnnotations(annotationBuilder, isisLink);
+        }
+
+        return new DefaultLinkDescription(src, dst, Link.Type.DIRECT, false, annotationBuilder.build());
+    }
+
+    /**
+     * Return the DIS value from the systemId.
+     *
+     * @param systemId system Id.
+     * @return return true if DIS else false
+     */
+    public static boolean checkIsDis(String systemId) {
+        StringTokenizer stringTokenizer = new StringTokenizer(systemId, "." + "-");
+        int count = 0;
+        while (stringTokenizer.hasMoreTokens()) {
+            String str = stringTokenizer.nextToken();
+            if (count == 3) {
+                int x = Integer.parseInt(str);
+                if (x > 0) {
+                    return true;
+                }
+            }
+            count++;
+        }
+        return false;
+    }
+
+    /**
+     * Builds port description.
+     *
+     * @param deviceId   device ID for the port
+     * @param portNumber port number of the link
+     * @return list of port description
+     */
+    private List<PortDescription> buildPortDescriptions(DeviceId deviceId,
+                                                        PortNumber portNumber) {
+        List<PortDescription> portList;
+        if (portMap.containsKey(deviceId)) {
+            portList = portMap.get(deviceId);
+        } else {
+            portList = new ArrayList<>();
+        }
+        if (portNumber != null) {
+            PortDescription portDescriptions = new DefaultPortDescription(portNumber, true);
+            portList.add(portDescriptions);
+        }
+        portMap.put(deviceId, portList);
+
+        return portList;
+    }
+
+    /**
+     * Builds the annotation details.
+     *
+     * @param annotationBuilder default annotation builder instance
+     * @param isisLink          ISIS link instance
+     * @return annotation builder instance
+     */
+    private DefaultAnnotations.Builder buildAnnotations(DefaultAnnotations.Builder annotationBuilder,
+                                                        IsisLink isisLink) {
+        int administrativeGroup = 0;
+        long teMetric = 0;
+        Bandwidth maxReservableBandwidth = Bandwidth.bps(0);
+        String routerId = null;
+        String neighborId = null;
+
+        //TE Info
+        IsisLinkTed isisLinkTed = isisLink.linkTed();
+        log.info("Ted Information:  {}", isisLinkTed.toString());
+        administrativeGroup = isisLinkTed.administrativeGroup();
+        teMetric = isisLinkTed.teDefaultMetric();
+        maxReservableBandwidth = isisLinkTed.maximumReservableLinkBandwidth();
+        routerId = isisLink.localSystemId();
+        neighborId = isisLink.remoteSystemId();
+        annotationBuilder.set(ADMINISTRATIVEGROUP, String.valueOf(administrativeGroup));
+        annotationBuilder.set(TE_METRIC, String.valueOf(teMetric));
+        annotationBuilder.set(MAXRESERVABLEBANDWIDTH, String.valueOf(maxReservableBandwidth));
+        annotationBuilder.set(ROUTERID, String.valueOf(routerId));
+        annotationBuilder.set(NEIGHBORID, String.valueOf(neighborId));
+        return annotationBuilder;
+    }
+
+    /**
+     * Internal device provider implementation.
+     */
+    private class InternalTopologyProvider implements IsisRouterListener, IsisLinkListener {
+
+        @Override
+        public void routerAdded(IsisRouter isisRouter) {
+            String systemId = isisRouter.systemId();
+            log.info("Added device {}", systemId);
+            DeviceId deviceId = DeviceId.deviceId(IsisRouterId.uri(systemId));
+            Device.Type deviceType = Device.Type.ROUTER;
+            //If our routerType is Dr or Bdr type is PSEUDO
+            if (isisRouter.isDis()) {
+                deviceType = Device.Type.ROUTER;
+            } else {
+                deviceType = Device.Type.VIRTUAL;
+            }
+            ChassisId cId = new ChassisId();
+            DefaultAnnotations.Builder newBuilder = DefaultAnnotations.builder();
+            newBuilder.set(AnnotationKeys.TYPE, "L3");
+            newBuilder.set("RouterId", systemId);
+            DeviceDescription description =
+                    new DefaultDeviceDescription(IsisRouterId.uri(systemId), deviceType, UNKNOWN, UNKNOWN, UNKNOWN,
+                                                 UNKNOWN, cId, newBuilder.build());
+            deviceProviderService.deviceConnected(deviceId, description);
+            System.out.println("Device added: " + systemId);
+        }
+
+        @Override
+        public void routerRemoved(IsisRouter isisRouter) {
+            String systemId = isisRouter.systemId();
+            log.info("Delete device {}", systemId);
+            DeviceId deviceId = DeviceId.deviceId(IsisRouterId.uri(systemId));
+            if (deviceProviderService == null) {
+                return;
+            }
+            deviceProviderService.deviceDisconnected(deviceId);
+            log.info("delete device {}", systemId);
+        }
+
+        @Override
+        public void addLink(IsisLink isisLink) {
+            log.debug("Addlink {}", isisLink.localSystemId());
+
+            LinkDescription linkDes = buildLinkDes(isisLink);
+            //Updating ports of the link
+            //If already link exists, return
+            if (linkService.getLink(linkDes.src(), linkDes.dst()) != null || linkProviderService == null) {
+                return;
+            }
+            ConnectPoint destconnectPoint = linkDes.dst();
+            PortNumber destport = destconnectPoint.port();
+            if (destport.toLong() != 0) {
+                deviceProviderService.updatePorts(linkDes.src().deviceId(),
+                                                  buildPortDescriptions(linkDes.src().deviceId(),
+                                                  linkDes.src().port()));
+                deviceProviderService.updatePorts(linkDes.dst().deviceId(),
+                                                  buildPortDescriptions(linkDes.dst().deviceId(),
+                                                  linkDes.dst().port()));
+                registerBandwidth(linkDes, isisLink);
+                linkProviderService.linkDetected(linkDes);
+                System.out.println("link desc " + linkDes.toString());
+            }
+        }
+
+        @Override
+        public void deleteLink(IsisLink isisLink) {
+            log.debug("Delete link {}", isisLink.localSystemId());
+            if (linkProviderService == null) {
+                return;
+            }
+            LinkDescription linkDes = buildLinkDes(isisLink);
+            linkProviderService.linkVanished(linkDes);
+        }
+
+        /**
+         * Registers the bandwidth for source and destination points.
+         *
+         * @param linkDes  link description instance
+         * @param isisLink ISIS link instance
+         */
+        private void registerBandwidth(LinkDescription linkDes, IsisLink isisLink) {
+            if (isisLink == null) {
+                log.error("Could not able to register bandwidth ");
+                return;
+            }
+            IsisLinkTed isisLinkTed = isisLink.linkTed();
+            Bandwidth maxReservableBw = isisLinkTed.maximumReservableLinkBandwidth();
+            if (maxReservableBw != null) {
+                if (maxReservableBw.compareTo(Bandwidth.bps(0)) == 0) {
+                    return;
+                }
+                //Configure bandwidth for src and dst port
+                BandwidthCapacity config = networkConfigService.addConfig(linkDes.src(), BandwidthCapacity.class);
+                config.capacity(maxReservableBw).apply();
+
+                config = networkConfigService.addConfig(linkDes.dst(), BandwidthCapacity.class);
+                config.capacity(maxReservableBw).apply();
+            }
+        }
+    }
+}
\ No newline at end of file

@@ -17,4 +17,4 @@
 /**
 /**
  * Provider that uses ISIS request as a means of infrastructure device discovery.
  * Provider that uses ISIS request as a means of infrastructure device discovery.
  */
  */
-package org.onosproject.provider.isis.device.impl;
\ No newline at end of file
+package org.onosproject.provider.isis.topology.impl;

+/*
+ * Copyright 2016-present Open Networking Laboratory
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ */
+
+package org.onosproject.provider.isis.topology.impl;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.node.JsonNodeFactory;
+import com.fasterxml.jackson.databind.node.ObjectNode;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.onlab.packet.Ip4Address;
+import org.onlab.util.Bandwidth;
+import org.onosproject.isis.controller.IsisController;
+import org.onosproject.isis.controller.IsisProcess;
+import org.onosproject.isis.controller.impl.topology.DefaultIsisLink;
+import org.onosproject.isis.controller.impl.topology.DefaultIsisLinkTed;
+import org.onosproject.isis.controller.impl.topology.DefaultIsisRouter;
+import org.onosproject.isis.controller.topology.IsisLink;
+import org.onosproject.isis.controller.topology.IsisLinkListener;
+import org.onosproject.isis.controller.topology.IsisLinkTed;
+import org.onosproject.isis.controller.topology.IsisRouter;
+import org.onosproject.isis.controller.topology.IsisRouterListener;
+import org.onosproject.net.ConnectPoint;
+import org.onosproject.net.Device;
+import org.onosproject.net.DeviceId;
+import org.onosproject.net.Link;
+import org.onosproject.net.MastershipRole;
+import org.onosproject.net.PortNumber;
+import org.onosproject.net.config.Config;
+import org.onosproject.net.config.ConfigApplyDelegate;
+import org.onosproject.net.config.ConfigFactory;
+import org.onosproject.net.config.NetworkConfigRegistryAdapter;
+import org.onosproject.net.config.basics.BandwidthCapacity;
+import org.onosproject.net.device.DeviceDescription;
+import org.onosproject.net.device.DeviceListener;
+import org.onosproject.net.device.DeviceProvider;
+import org.onosproject.net.device.DeviceProviderRegistry;
+import org.onosproject.net.device.DeviceProviderService;
+import org.onosproject.net.device.DeviceServiceAdapter;
+import org.onosproject.net.device.PortDescription;
+import org.onosproject.net.device.PortStatistics;
+import org.onosproject.net.link.LinkDescription;
+import org.onosproject.net.link.LinkListener;
+import org.onosproject.net.link.LinkProvider;
+import org.onosproject.net.link.LinkProviderRegistry;
+import org.onosproject.net.link.LinkProviderService;
+import org.onosproject.net.link.LinkServiceAdapter;
+import org.onosproject.net.provider.ProviderId;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.CopyOnWriteArraySet;
+
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+
+/**
+ * Test cases for ISIS topology provider.
+ */
+public class IsisTopologyProviderTest {
+
+    private final IsisTopologyProvider provider = new IsisTopologyProvider();
+    private final TestDeviceRegistry nodeRegistry = new TestDeviceRegistry();
+    private final TestLinkRegistry linkRegistry = new TestLinkRegistry();
+    private final TestController controller = new TestController();
+    private final TestLinkService linkService = new TestLinkService();
+    private MockNetConfigRegistryAdapter networkConfigService = new MockNetConfigRegistryAdapter();
+
+    @Before
+    public void setUp() throws Exception {
+        provider.deviceProviderRegistry = nodeRegistry;
+        provider.linkProviderRegistry = linkRegistry;
+        provider.networkConfigService = networkConfigService;
+        provider.controller = controller;
+        provider.linkService = linkService;
+        provider.activate();
+        assertNotNull("provider should be registered", nodeRegistry.provider);
+        assertNotNull("listener should be registered", controller.nodeListener);
+    }
+
+    @After
+    public void tearDown() throws Exception {
+        provider.deactivate();
+        provider.controller = null;
+        provider.deviceProviderRegistry = null;
+        provider.networkConfigService = null;
+    }
+
+    @Test
+    public void triggerProbe() {
+        DeviceId deviceId = DeviceId.deviceId("2929.2929.2929.00-00");
+        provider.triggerProbe(deviceId);
+    }
+
+    @Test
+    public void roleChanged() {
+        DeviceId deviceId = DeviceId.deviceId("1111.1111.1111.00-00");
+        provider.roleChanged(deviceId, MastershipRole.MASTER);
+    }
+
+    @Test
+    public void changePortState() {
+        DeviceId deviceId = DeviceId.deviceId("2222.2222.2222.00-82");
+        provider.changePortState(deviceId, PortNumber.portNumber(168430087), false);
+    }
+
+    @Test
+    public void isReachable() {
+        DeviceId deviceId = DeviceId.deviceId("1010.1010.1111.00-22");
+        provider.isReachable(deviceId);
+    }
+
+
+    /* Validate node is added to the device validating URI and should get updated properly */
+    @Test
+    public void isisTopologyProviderTestAddDevice1() {
+        int deviceAddCount = 0;
+        IsisRouter isisRouter = new DefaultIsisRouter();
+        isisRouter.setSystemId("2929.2929.2929.00");
+        isisRouter.setNeighborRouterId(Ip4Address.valueOf("10.10.10.1"));
+        isisRouter.setInterfaceId(Ip4Address.valueOf("10.10.10.2"));
+        isisRouter.setDis(false);
+
+        for (IsisRouterListener l : controller.nodeListener) {
+            l.routerAdded(isisRouter);
+            deviceAddCount = nodeRegistry.connected.size();
+            assertTrue(deviceAddCount == 1);
+            l.routerRemoved(isisRouter);
+            deviceAddCount = nodeRegistry.connected.size();
+            assertTrue(deviceAddCount == 0);
+        }
+    }
+
+    @Test
+    public void isisTopologyProviderTestAddDevice2() {
+        int deviceAddCount = 0;
+        IsisRouter isisRouter = new DefaultIsisRouter();
+        isisRouter.setSystemId("7777.7777.7777.00");
+        isisRouter.setNeighborRouterId(Ip4Address.valueOf("10.10.10.1"));
+        isisRouter.setInterfaceId(Ip4Address.valueOf("10.10.10.7"));
+        isisRouter.setDis(false);
+        IsisRouter isisRouter1 = new DefaultIsisRouter();
+        isisRouter1.setSystemId("1111.1111.1111.00");
+        isisRouter1.setNeighborRouterId(Ip4Address.valueOf("10.10.10.7"));
+        isisRouter1.setInterfaceId(Ip4Address.valueOf("10.10.10.1"));
+        isisRouter1.setDis(true);
+        for (IsisRouterListener l : controller.nodeListener) {
+            l.routerAdded(isisRouter);
+            deviceAddCount = nodeRegistry.connected.size();
+            assertTrue(deviceAddCount == 1);
+            l.routerAdded(isisRouter1);
+            deviceAddCount = nodeRegistry.connected.size();
+            assertTrue(deviceAddCount == 2);
+            l.routerRemoved(isisRouter);
+            deviceAddCount = nodeRegistry.connected.size();
+            assertTrue(deviceAddCount == 1);
+        }
+    }
+
+    @Test
+    public void isisTopologyProviderTestAddLink() {
+        int deviceAddCount = 0;
+        IsisRouter isisRouter = new DefaultIsisRouter();
+        isisRouter.setSystemId("7777.7777.7777.00");
+        isisRouter.setNeighborRouterId(Ip4Address.valueOf("10.10.10.1"));
+        isisRouter.setInterfaceId(Ip4Address.valueOf("10.10.10.7"));
+        isisRouter.setDis(false);
+        IsisRouter isisRouter1 = new DefaultIsisRouter();
+        isisRouter1.setSystemId("1111.1111.1111.00");
+        isisRouter1.setNeighborRouterId(Ip4Address.valueOf("10.10.10.7"));
+        isisRouter1.setInterfaceId(Ip4Address.valueOf("10.10.10.1"));
+        isisRouter1.setDis(true);
+        IsisLink isisLink = new DefaultIsisLink();
+        isisLink.setRemoteSystemId("7777.7777.7777.00");
+        isisLink.setLocalSystemId("1111.1111.1111.00");
+        isisLink.setInterfaceIp(Ip4Address.valueOf("10.10.10.1"));
+        isisLink.setNeighborIp(Ip4Address.valueOf("10.10.10.7"));
+        IsisLinkTed isisLinkTed = new DefaultIsisLinkTed();
+        isisLinkTed.setTeDefaultMetric(10);
+        isisLinkTed.setAdministrativeGroup(5);
+        isisLinkTed.setIpv4InterfaceAddress(Ip4Address.valueOf("10.10.10.1"));
+        isisLinkTed.setIpv4NeighborAddress(Ip4Address.valueOf("10.10.10.7"));
+        isisLinkTed.setMaximumLinkBandwidth(Bandwidth.bps(0));
+        isisLinkTed.setMaximumReservableLinkBandwidth(Bandwidth.bps(1.0));
+        List<Bandwidth> unresList = new ArrayList<>();
+        unresList.add(Bandwidth.bps(0.0));
+        unresList.add(Bandwidth.bps(1.0));
+        unresList.add(Bandwidth.bps(2.0));
+        unresList.add(Bandwidth.bps(3.0));
+        isisLinkTed.setUnreservedBandwidth(unresList);
+        isisLink.setLinkTed(isisLinkTed);
+        for (IsisRouterListener l : controller.nodeListener) {
+            l.routerAdded(isisRouter);
+            deviceAddCount = nodeRegistry.connected.size();
+            assertTrue(deviceAddCount == 1);
+            l.routerAdded(isisRouter1);
+            deviceAddCount = nodeRegistry.connected.size();
+            assertTrue(deviceAddCount == 2);
+        }
+        for (IsisLinkListener l : controller.linkListener) {
+            l.addLink(isisLink);
+            l.deleteLink(isisLink);
+
+        }
+    }
+
+
+    /* Class implement device test registry */
+    private class TestDeviceRegistry implements DeviceProviderRegistry {
+        DeviceProvider provider;
+
+        Set<DeviceId> connected = new HashSet<>();
+
+        @Override
+        public DeviceProviderService register(DeviceProvider provider) {
+            this.provider = provider;
+            return new TestProviderService();
+        }
+
+        @Override
+        public void unregister(DeviceProvider provider) {
+        }
+
+        @Override
+        public Set<ProviderId> getProviders() {
+            return null;
+        }
+
+        private class TestProviderService implements DeviceProviderService {
+
+            @Override
+            public DeviceProvider provider() {
+                return null;
+            }
+
+            @Override
+            public void deviceConnected(DeviceId deviceId, DeviceDescription deviceDescription) {
+
+                connected.add(deviceId);
+
+            }
+
+
+            @Override
+            public void deviceDisconnected(DeviceId deviceId) {
+
+                connected.remove(deviceId);
+            }
+
+
+            @Override
+            public void updatePorts(DeviceId deviceId, List<PortDescription> portDescriptions) {
+                // TODO Auto-generated method stub
+
+            }
+
+            @Override
+            public void portStatusChanged(DeviceId deviceId, PortDescription portDescription) {
+                // TODO Auto-generated method stub
+
+            }
+
+            @Override
+            public void receivedRoleReply(DeviceId deviceId, MastershipRole requested, MastershipRole response) {
+                // TODO Auto-generated method stub
+
+            }
+
+
+            @Override
+            public void updatePortStatistics(DeviceId deviceId, Collection<PortStatistics> portStatistics) {
+                // TODO Auto-generated method stub
+
+            }
+        }
+    }
+
+
+
+    private class TestDeviceService extends DeviceServiceAdapter {
+        private DeviceListener listener;
+
+        @Override
+        public void addListener(DeviceListener listener) {
+            this.listener = listener;
+        }
+
+        @Override
+        public Iterable<Device> getDevices() {
+            return Collections.emptyList();
+        }
+    }
+
+    private class TestLinkService extends LinkServiceAdapter {
+        private LinkListener listener;
+
+        @Override
+        public void addListener(LinkListener listener) {
+            this.listener = listener;
+        }
+
+        @Override
+        public Iterable<Link> getLinks() {
+            return Collections.emptyList();
+        }
+    }
+
+    /* Class implement device test registry */
+    private class TestLinkRegistry implements LinkProviderRegistry {
+        LinkProvider provider;
+
+        Set<DeviceId> connected = new HashSet<>();
+
+        @Override
+        public LinkProviderService register(LinkProvider provider) {
+            this.provider = provider;
+            return new TestLinkProviderService();
+        }
+
+        @Override
+        public void unregister(LinkProvider provider) {
+
+        }
+
+        @Override
+        public Set<ProviderId> getProviders() {
+            return null;
+        }
+
+        private class TestLinkProviderService implements LinkProviderService {
+
+            @Override
+            public void linkDetected(LinkDescription linkDescription) {
+
+            }
+
+            @Override
+            public void linkVanished(LinkDescription linkDescription) {
+
+            }
+
+            @Override
+            public void linksVanished(ConnectPoint connectPoint) {
+
+            }
+
+            @Override
+            public void linksVanished(DeviceId deviceId) {
+
+            }
+
+            @Override
+            public LinkProvider provider() {
+                return null;
+            }
+        }
+    }
+
+    /* class implement test controller */
+    private class TestController implements IsisController {
+        protected Set<IsisRouterListener> nodeListener = new CopyOnWriteArraySet<>();
+        protected Set<IsisLinkListener> linkListener = new CopyOnWriteArraySet<>();
+
+        @Override
+        public void addRouterListener(IsisRouterListener nodeListener) {
+            this.nodeListener.add(nodeListener);
+        }
+
+        @Override
+        public void removeRouterListener(IsisRouterListener nodeListener) {
+            this.nodeListener.remove(nodeListener);
+        }
+
+        @Override
+        public void addLinkListener(IsisLinkListener listener) {
+            this.linkListener.add(listener);
+        }
+
+        @Override
+        public void removeLinkListener(IsisLinkListener listener) {
+            this.linkListener.remove(listener);
+        }
+
+        @Override
+        public void updateConfig(JsonNode processesNode) {
+
+        }
+
+        @Override
+        public List<IsisProcess> allConfiguredProcesses() {
+            return null;
+        }
+
+        @Override
+        public Set<IsisRouterListener> listener() {
+            return null;
+        }
+
+        @Override
+        public Set<IsisLinkListener> linkListener() {
+            return null;
+        }
+
+    }
+
+    /* Mock test for device service */
+    private class MockNetConfigRegistryAdapter extends NetworkConfigRegistryAdapter {
+        private ConfigFactory cfgFactory;
+        private Map<ConnectPoint, BandwidthCapacity> classConfig = new HashMap<>();
+
+        @Override
+        public void registerConfigFactory(ConfigFactory configFactory) {
+            cfgFactory = configFactory;
+        }
+
+        @Override
+        public void unregisterConfigFactory(ConfigFactory configFactory) {
+            cfgFactory = null;
+        }
+
+        @Override
+        public <S, C extends Config<S>> C addConfig(S subject, Class<C> configClass) {
+            if (configClass == BandwidthCapacity.class) {
+                BandwidthCapacity devCap = new BandwidthCapacity();
+                classConfig.put((ConnectPoint) subject, devCap);
+
+                JsonNode node = new ObjectNode(new MockJsonNode());
+                ObjectMapper mapper = new ObjectMapper();
+                ConfigApplyDelegate delegate = new InternalApplyDelegate();
+                devCap.init((ConnectPoint) subject, null, node, mapper, delegate);
+                return (C) devCap;
+            }
+
+            return null;
+        }
+
+        @Override
+        public <S, C extends Config<S>> void removeConfig(S subject, Class<C> configClass) {
+            classConfig.remove(subject);
+        }
+
+        @Override
+        public <S, C extends Config<S>> C getConfig(S subject, Class<C> configClass) {
+            if (configClass == BandwidthCapacity.class) {
+                return (C) classConfig.get(subject);
+            }
+            return null;
+        }
+
+        private class MockJsonNode extends JsonNodeFactory {
+        }
+
+        // Auxiliary delegate to receive notifications about changes applied to
+        // the network configuration - by the apps.
+        private class InternalApplyDelegate implements ConfigApplyDelegate {
+            @Override
+            public void onApply(Config config) {
+            }
+        }
+    }
+}
\ No newline at end of file