protocols/ospf/ctl/src/main/java/org/onosproject/ospf/controller/impl/Controller.java

/*
 * 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.ospf.controller.impl;

import org.jboss.netty.bootstrap.ServerBootstrap;
import org.jboss.netty.channel.AdaptiveReceiveBufferSizePredictor;
import org.jboss.netty.channel.ChannelPipelineFactory;
import org.jboss.netty.channel.FixedReceiveBufferSizePredictorFactory;
import org.jboss.netty.channel.group.ChannelGroup;
import org.jboss.netty.channel.group.DefaultChannelGroup;
import org.jboss.netty.channel.socket.nio.NioServerSocketChannelFactory;
import org.onosproject.net.driver.DriverService;
import org.onosproject.ospf.controller.OspfAgent;
import org.onosproject.ospf.controller.OspfArea;
import org.onosproject.ospf.controller.OspfInterface;
import org.onosproject.ospf.controller.OspfLinkTed;
import org.onosproject.ospf.controller.OspfProcess;
import org.onosproject.ospf.controller.OspfRouter;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.net.NetworkInterface;
import java.net.SocketException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Enumeration;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
import java.util.concurrent.Executor;
import java.util.concurrent.Executors;

/**
 * Representation of the main controller class. Handles all setup and network listeners.
 */
public class Controller {

    protected static final Logger log = LoggerFactory.getLogger(Controller.class);
    protected static final int BUFFER_SIZE = 4 * 1024 * 1024;
    private static final String PROCESS = "process";
    private static final String AREA = "area";
    private static final String INTERFACE = "interface";

    protected int ospfPort = 7000;
    protected int workerThreads = 16;
    protected long systemStartTime;
    private DriverService driverService;
    private OspfAgent agent;
    private List<ChannelGroup> cgList = new ArrayList();
    private List<NioServerSocketChannelFactory> execFactoryLst = new ArrayList<>();
    private List<OspfProcess> processes;

    /**
     * Gets all configured processes.
     *
     * @return all configured processes
     */
    public List<OspfProcess> getAllConfiguredProcesses() {
        return processes;
    }

    /**
     * Adds device details.
     *
     * @param ospfRouter OSPF router instance
     */
    public void addDeviceDetails(OspfRouter ospfRouter) {
        agent.addConnectedRouter(ospfRouter);
    }

    /**
     * Removes device details.
     *
     * @param ospfRouter OSPF router instance
     */
    public void removeDeviceDetails(OspfRouter ospfRouter) {
        agent.removeConnectedRouter(ospfRouter);
    }

    /**
     * Adds link details.
     *
     * @param ospfRouter  OSPF router instance
     * @param ospfLinkTed OSPF link ted instance
     */
    public void addLinkDetails(OspfRouter ospfRouter, OspfLinkTed ospfLinkTed) {
        agent.addLink(ospfRouter, ospfLinkTed);
    }

    /**
     * Removes link details.
     *
     * @param ospfRouter OSPF router instance
     */
    public void removeLinkDetails(OspfRouter ospfRouter) {
        agent.deleteLink(ospfRouter);
    }

    /**
     * Creates a server bootstrap.
     *
     * @return ServerBootstrap bootstrap instance
     */
    private ServerBootstrap createServerBootStrap() {

        Executor bossPool = Executors.newCachedThreadPool();
        Executor workerPool = Executors.newCachedThreadPool();
        NioServerSocketChannelFactory executerFactory;

        if (workerThreads == 0) {
            executerFactory = new NioServerSocketChannelFactory(bossPool, workerPool);
            execFactoryLst.add(executerFactory);
        } else {
            executerFactory = new NioServerSocketChannelFactory(bossPool, workerPool, workerThreads);
            execFactoryLst.add(executerFactory);
        }

        return new ServerBootstrap(executerFactory);
    }


    /**
     * Initializes internal data structures.
     */
    public void init() {
        this.systemStartTime = System.currentTimeMillis();
    }

    /**
     * Starts the controller.
     *
     * @param ag            OSPF agent instance
     * @param driverService driver service instance
     */
    public void start(OspfAgent ag, DriverService driverService) {
        log.info("Starting OSPF Controller...!!!");
        this.agent = ag;
        this.driverService = driverService;
        this.init();
    }

    /**
     * Stops the Controller.
     */
    public void stop() {
        log.info("Stopping OSPF Controller...!!!");

        for (ChannelGroup cg : cgList) {
            cg.close();
        }

        for (NioServerSocketChannelFactory execFactory : execFactoryLst) {
            execFactory.shutdown();
        }

        processes.clear();
    }

    /**
     * Deletes configured interface from the area.
     *
     * @param processId         process id
     * @param areaId            area id
     * @param interfaceToDelete interface to delete
     * @return true if operation success else false
     */
    public boolean deleteInterfaceFromArea(String processId, String areaId, String interfaceToDelete) {
        Iterator<OspfProcess> processItr = processes.iterator();

        while (processItr.hasNext()) {
            OspfProcess process = processItr.next();
            if (processId.equalsIgnoreCase(process.processId())) {
                Iterator<OspfArea> areaItr = process.areas().iterator();
                while (areaItr.hasNext()) {
                    OspfArea area = areaItr.next();
                    Iterator<OspfInterface> ospfIntrItr = area.getInterfacesLst().iterator();
                    if (area.areaId().toString().equalsIgnoreCase(areaId)) {
                        while (ospfIntrItr.hasNext()) {
                            OspfInterface ospfIntr = ospfIntrItr.next();
                            if (interfaceToDelete.equalsIgnoreCase(ospfIntr.ipAddress().toString())) {
                                ospfIntrItr.remove();
                                log.debug("Interface With Id {} is removed from Area {}",
                                          ospfIntr.ipAddress(), ospfIntr.areaId());
                                return true;
                            }
                        }
                    }
                }
            }
        }

        return false;
    }

    /*
    * Checks area with area id exists in process.
    *
    * @param processId process id
    * @param areaId area id
    * @return true if exist else false
    */
    public boolean checkArea(String processId, String areaId) {
        for (OspfProcess process : processes) {
            if (processId.equalsIgnoreCase(process.processId())) {
                for (OspfArea area : process.areas()) {
                    if (area.areaId().toString().equalsIgnoreCase(areaId)) {
                        return true;
                    }
                }
            }
        }
        return false;
    }

    /*
    * Checks process with process id exists or not.
    *
    * @param processId process id
    * @return true if exist else false
    */
    public boolean checkProcess(String processId) {
        log.debug("CheckProcess,Process Id ={} processes={}", processId, processes);
        for (OspfProcess process : processes) {
            if (processId.equalsIgnoreCase(process.processId())) {
                return true;
            }
        }
        return false;
    }

    /*
    * Checks interface exists in given area.
    *
    * @param processId process id
    * @param areaId area id
    * @param ipAddress interface
    * @return true if exist else false
    */
    public boolean checkInterface(String processId, String areaId, String interfaceIp) {
        for (OspfProcess process : processes) {
            if (processId.equalsIgnoreCase(process.processId())) {
                for (OspfArea area : process.areas()) {
                    if (area.areaId().toString().equalsIgnoreCase(areaId)) {
                        for (OspfInterface ospfInterface : area.getInterfacesLst()) {
                            if (ospfInterface.ipAddress().toString().equalsIgnoreCase(interfaceIp)) {
                                return true;
                            }
                        }
                    }
                }
            }
        }
        return false;
    }

    /**
     * Create processes first time when no process exist.
     * Create server bootstraps for all the interfaces in the processes.
     *
     * @param ospfProcesses list of OSPF processes to create
     */
    private void createProcessWhenNoProcessesExists(List<OspfProcess> ospfProcesses) {
        Set<String> interfaceIpList = new HashSet<>();
        Set<String> areaIdList = new HashSet<>();
        if (processes != null) {
            if (processes.size() == 0) {

                processes.addAll(ospfProcesses);
                for (OspfProcess process : ospfProcesses) {
                    for (OspfArea area : process.areas()) {
                        areaIdList.add(area.areaId().toString());
                        for (OspfInterface intrfc : area.getInterfacesLst()) {
                            interfaceIpList.add(intrfc.ipAddress().toString());
                        }
                    }
                }
                createBootStrapForCreatedInterface(interfaceIpList, areaIdList);
            }
        } else {
            processes = new ArrayList<>();
            processes.addAll(ospfProcesses);

            for (OspfProcess process : ospfProcesses) {
                for (OspfArea area : process.areas()) {
                    areaIdList.add(area.areaId().toString());
                    for (OspfInterface intrfc : area.getInterfacesLst()) {
                        interfaceIpList.add(intrfc.ipAddress().toString());
                    }
                }
            }
            createBootStrapForCreatedInterface(interfaceIpList, areaIdList);
        }
    }

    /**
     * Creates processes when already process exist.
     * It can be modifying existing process or adding a new process.
     *
     * @param ospfProcesses list of processes
     */
    private void createProcessWhenProcessesExists(List<OspfProcess> ospfProcesses) {
        if (ospfProcesses != null) {
            for (OspfProcess process : ospfProcesses) {
                if (!checkProcess(process.processId())) {
                    createNewProcess(process.processId(), process);
                } else {
                    List<OspfArea> areas = process.areas();
                    for (OspfArea area : areas) {
                        if (!checkArea(process.processId(), area.areaId().toString())) {
                            createAreaInProcess(process.processId(),
                                                area.areaId().toString(), area);
                        } else {
                            updateAreaInProcess(process.processId(), area.areaId().toString(), area);
                            for (OspfInterface interfc : area.getInterfacesLst()) {
                                if (!checkInterface(process.processId(),
                                                    area.areaId().toString(), interfc.ipAddress().toString())) {
                                    createInterfaceInAreaInProcess(process.processId(),
                                                                   area.areaId().toString(), interfc);
                                } else {
                                    updateInterfaceParameters(process.processId(),
                                                              area.areaId().toString(),
                                                              interfc.ipAddress().toString(), interfc);
                                }
                            }
                        }
                    }
                }
            }
        }
    }

    /**
     * Updates the area information in already started OSPF processes.
     *
     * @param processId     process id
     * @param areaId        area id
     * @param areaFrmConfig area to update
     */
    public void updateAreaInProcess(String processId, String areaId, OspfArea areaFrmConfig) {
        if (processes != null) {
            Iterator<OspfProcess> processItr = processes.iterator();
            while (processItr.hasNext()) {
                OspfProcess process = processItr.next();
                if (processId.equalsIgnoreCase(process.processId())) {
                    Iterator<OspfArea> area = process.areas().iterator();
                    while (area.hasNext()) {
                        OspfArea ospfArea = area.next();
                        if (areaId.equalsIgnoreCase(ospfArea.areaId().toString())) {
                            ospfArea.setAddressRanges(areaFrmConfig.addressRanges());
                            ospfArea.setRouterId(areaFrmConfig.routerId());
                            ospfArea.setTransitCapability(areaFrmConfig.isTransitCapability());
                            ospfArea.setExternalRoutingCapability(areaFrmConfig.isExternalRoutingCapability());
                            ospfArea.setStubCost(areaFrmConfig.stubCost());
                            ospfArea.setOptions(areaFrmConfig.options());
                            ospfArea.setIsOpaqueEnabled(areaFrmConfig.isOpaqueEnabled());
                            log.debug("updateAreaInProcess::Process Id::{}::Ospf Area with Id::{}::is " +
                                              "updated", processId, areaId);
                        }
                    }
                }
            }
        }
    }

    /**
     * Updates the processes configuration.
     *
     * @param ospfProcesses list of OSPF processes
     */
    public void updateConfig(List<OspfProcess> ospfProcesses) {
        log.info("Controller::UpdateConfig called");
        if (processes != null) {
            if (processes.size() == 0) {
                createProcessWhenNoProcessesExists(ospfProcesses);
            } else {
                createProcessWhenProcessesExists(ospfProcesses);
            }
        } else {
            createProcessWhenNoProcessesExists(ospfProcesses);
        }
    }

    /**
     * Deletes configuration.
     *
     * @param ospfProcesses OSPF processes
     * @param attribute     attribute to delete
     */
    public void deleteConfig(List<OspfProcess> ospfProcesses, String attribute) {
        log.info("Controller::UpdateConfig called");
        if (processes != null) {
            if (processes.size() == 0) {
                log.debug("DeleteConfig:: No process exists");
            } else {
                deleteProcessWhenExists(ospfProcesses, attribute);
            }
        } else {
            log.debug("DeleteConfig:: No process exists");
        }
    }

    /**
     * Creates a new process.
     *
     * @param processId process id
     * @param process   OSPF process instance
     */
    private void createNewProcess(String processId, OspfProcess process) {
        Set<String> interfaceIpList = new HashSet<>();
        Set<String> areaIdList = new HashSet<>();

        processes.add(process);
        for (OspfArea area : process.areas()) {
            areaIdList.add(area.areaId().toString());
            for (OspfInterface interfc : area.getInterfacesLst()) {
                interfaceIpList.add(interfc.ipAddress().toString());
            }
        }
        log.debug("createNewProcess::List of areas in process::{} areas::{}", processId, areaIdList);

        createBootStrapForCreatedInterface(interfaceIpList, areaIdList);

        log.debug("createNewProcess:: all processes::{}", processes);
    }

    /**
     * Creates a new area information in the process.
     *
     * @param processId process id
     * @param areaId    area id
     * @param area      OSPF area instance
     */
    private void createAreaInProcess(String processId, String areaId, OspfArea area) {
        Set<String> interfaceIpList = new HashSet<>();
        Set<String> areaIdList = new HashSet<>();

        Iterator<OspfProcess> processItr = processes.iterator();
        while (processItr.hasNext()) {
            OspfProcess process = processItr.next();
            List<OspfArea> areasInProcess = process.areas();
            if (processId.equalsIgnoreCase(process.processId())) {
                areasInProcess.add(area);

                for (OspfInterface intrfc : area.getInterfacesLst()) {
                    interfaceIpList.add(intrfc.ipAddress().toString());
                }
                areaIdList.add(area.areaId().toString());
                log.debug("createAreaInProcess::List of areas in process Id::{} " +
                                  "AreaId ::{} update process::{}",
                          processId, areaId, process);
            }
        }
        createBootStrapForCreatedInterface(interfaceIpList, areaIdList);
        log.debug("createAreaInProcess:: all processes::{}", processes);
    }

    /**
     * Creates an interface in the given area and process.
     *
     * @param processId     process id
     * @param areaId        area id
     * @param ospfInterface OSPF interface instance
     */
    private void createInterfaceInAreaInProcess(String processId,
                                                String areaId, OspfInterface ospfInterface) {
        Set<String> interfaceIpList = new HashSet<>();
        Set<String> areaIdList = new HashSet<>();

        Iterator<OspfProcess> processItr = processes.iterator();
        while (processItr.hasNext()) {
            OspfProcess process = processItr.next();
            List<OspfArea> areasInProcess = process.areas();
            if (processId.equalsIgnoreCase(process.processId())) {
                Iterator<OspfArea> areaItr = areasInProcess.iterator();
                while (areaItr.hasNext()) {
                    OspfArea area = areaItr.next();
                    if (areaId.equalsIgnoreCase(area.areaId().toString())) {
                        area.getInterfacesLst().add(ospfInterface);
                        interfaceIpList.add(ospfInterface.ipAddress().toString());

                        log.debug("createInterfaceInAreaInProcess::Interface " +
                                          "updated in process Id::{} AreaId ::{} Interface List{}",
                                  processId, areaId, area.getInterfacesLst());

                    }
                }
            }
        }
        createBootStrapForCreatedInterface(interfaceIpList, areaIdList);
        log.debug("createInterfaceInAreaInProcess:: all processes::{}", processes);
    }

    /**
     * Updates interface parameters.
     *
     * @param processId     process id
     * @param areaId        area id
     * @param interfaceId   interface id
     * @param ospfInterface OSPF interface instance
     */
    private void updateInterfaceParameters(String processId, String areaId, String interfaceId,
                                           OspfInterface ospfInterface) {
        Iterator<OspfProcess> processItr = processes.iterator();
        while (processItr.hasNext()) {
            OspfProcess process = processItr.next();
            if (processId.equalsIgnoreCase(process.processId())) {
                Iterator<OspfArea> areItr = process.areas().iterator();
                while (areItr.hasNext()) {
                    OspfArea area = (OspfArea) areItr.next();
                    if (area.areaId().toString().equalsIgnoreCase(areaId)) {
                        Iterator<OspfInterface> intfcList = area.getInterfacesLst().iterator();
                        while (intfcList.hasNext()) {
                            OspfInterface intrfcObj = intfcList.next();
                            if (interfaceId.equalsIgnoreCase(intrfcObj.ipAddress().toString())) {
                                intrfcObj.setPollInterval(ospfInterface.pollInterval());
                                intrfcObj.setTransmitDelay(ospfInterface.transmitDelay());
                                intrfcObj.setBdr(ospfInterface.bdr());
                                intrfcObj.setDr(ospfInterface.dr());
                                intrfcObj.setAuthKey(ospfInterface.authKey());
                                intrfcObj.setAuthType(ospfInterface.authType());
                                intrfcObj.setHelloIntervalTime(ospfInterface.helloIntervalTime());
                                intrfcObj.setReTransmitInterval(ospfInterface.reTransmitInterval());
                                intrfcObj.setMtu(ospfInterface.mtu());
                                intrfcObj.setInterfaceCost(ospfInterface.interfaceCost());
                                intrfcObj.setInterfaceType(ospfInterface.interfaceType());
                                intrfcObj.setRouterDeadIntervalTime(ospfInterface.routerDeadIntervalTime());
                                intrfcObj.setRouterPriority(ospfInterface.routerPriority());
                                intrfcObj.setIpNetworkMask(ospfInterface.ipNetworkMask());
                                log.debug("updateInterfaceParameters::Interface updated in " +
                                                  "process Id::{} AreaId ::{} Interface Id:{} " +
                                                  "Updated Interface List: {}", processId, areaId,
                                          interfaceId, intfcList);
                            }
                        }
                    }
                }
            }
        }
        log.debug("updateInterfaceParameters:: all processes::{}", processes);
    }

    /**
     * Creates server bootstrap for interface.
     *
     * @param interfaceIPs set of interfaces
     * @param areaIds      set of area id's
     */
    private void createBootStrapForCreatedInterface(Set<String> interfaceIPs, Set<String> areaIds) {

        log.debug("createBootStrapForCreatedInterface:: List of new Interfaces::{}, " +
                          "List of new areas::{}", interfaceIPs, areaIds);
        List<String> networkInterfaces = new ArrayList();
        //get the connected interfaces
        Enumeration<NetworkInterface> nets = null;
        try {
            nets = NetworkInterface.getNetworkInterfaces();
            // Check NetworkInterfaces and add the IP's
            for (NetworkInterface netInt : Collections.list(nets)) {
                // if the interface is up & not loopback
                if (!netInt.isUp() && !netInt.isLoopback()) {
                    continue;
                }
                //get all the InetAddresses
                Enumeration<InetAddress> inetAddresses = netInt.getInetAddresses();
                for (InetAddress inetAddress : Collections.list(inetAddresses)) {
                    String ipAddress = inetAddress.getHostAddress();
                    networkInterfaces.add(ipAddress);
                }
            }
            //Search for the address in all configured areas interfaces
            for (OspfProcess process : processes) {
                for (OspfArea area : process.areas()) {
                    for (OspfInterface ospfIf : area.getInterfacesLst()) {
                        String ipFromConfig = ospfIf.ipAddress().toString();
                        if (interfaceIPs.contains(ipFromConfig)) {
                            log.debug("Ip address::{} for area {} is newly created" + ipFromConfig);
                            if (networkInterfaces.contains(ipFromConfig)) {
                                log.debug("Both Config and Interface have ipAddress {} for area {}",
                                          ipFromConfig, area.areaId());
                                // if same IP address create
                                try {
                                    log.debug("Creating ServerBootstrap for {} @ {}", ipFromConfig, ospfPort);

                                    final ServerBootstrap bootstrap = createServerBootStrap();

                                    bootstrap.setOption("receiveBufferSize", Controller.BUFFER_SIZE);
                                    bootstrap.setOption("receiveBufferSizePredictorFactory",
                                                        new FixedReceiveBufferSizePredictorFactory(
                                                                Controller.BUFFER_SIZE));
                                    bootstrap.setOption("reuseAddress", true);
                                    bootstrap.setOption("tcpNoDelay", true);
                                    bootstrap.setOption("keepAlive", true);

                                    bootstrap.setOption("child.receiveBufferSize", Controller.BUFFER_SIZE);
                                    bootstrap.setOption("child.receiveBufferSizePredictorFactory",
                                                        new FixedReceiveBufferSizePredictorFactory(
                                                                Controller.BUFFER_SIZE));
                                    bootstrap.setOption("child.reuseAddress", true);
                                    bootstrap.setOption("child.tcpNoDelay", true);
                                    bootstrap.setOption("child.keepAlive", true);
                                    bootstrap.setOption("receiveBufferSizePredictorFactory",
                                                        new FixedReceiveBufferSizePredictorFactory(
                                                                Controller.BUFFER_SIZE));
                                    bootstrap.setOption("receiveBufferSizePredictor",
                                                        new AdaptiveReceiveBufferSizePredictor(64, 1024, 65536));

                                    ChannelPipelineFactory pfact = new OspfPipelineFactory(this, area, ospfIf);
                                    bootstrap.setPipelineFactory(pfact);
                                    InetSocketAddress sa = new InetSocketAddress(InetAddress.getByName(ipFromConfig),
                                                                                 ospfPort);

                                    ChannelGroup cg = new DefaultChannelGroup();
                                    cg.add(bootstrap.bind(sa));
                                    cgList.add(cg);

                                    log.debug("Listening for connections on {}", sa);

                                } catch (Exception e) {
                                    throw new RuntimeException(e);
                                }
                            }
                        } else {
                            log.debug("Ip address::{} for area {} is not newly created" + ipFromConfig);
                        }
                    }
                    if (areaIds.contains(area.areaId().toString())) {
                        area.initializeDb();
                    }
                }
            }

        } catch (SocketException e) {
            log.error("Error occured due to SocketException::Class::{},Line::{},Method::{}",
                      e.getStackTrace()[0].getFileName(), e.getStackTrace()[0].getLineNumber(),
                      e.getStackTrace()[0].getMethodName());
        }
    }

    /**
     * Deletes given process.
     *
     * @param ospfProcesses list of OSPF process instance.
     * @param attribute     attribute to delete
     */
    public void deleteProcessWhenExists(List<OspfProcess> ospfProcesses, String attribute) {
        if (ospfProcesses != null) {
            for (OspfProcess process : ospfProcesses) {
                if (checkProcess(process.processId())) {
                    if (PROCESS.equalsIgnoreCase(attribute)) {
                        deleteProcess(process.processId(), process);
                    } else {
                        List<OspfArea> areas = process.areas();
                        for (OspfArea area : areas) {
                            if (checkArea(process.processId(), area.areaId().toString())) {
                                if (AREA.equalsIgnoreCase(attribute)) {
                                    deleteAreaFromProcess(process.processId(),
                                                          area.areaId().toString(), area);
                                } else {
                                    for (OspfInterface interfc : area.getInterfacesLst()) {
                                        if (checkInterface(process.processId(),
                                                           area.areaId().toString(),
                                                           interfc.ipAddress().toString())) {
                                            if (INTERFACE.equalsIgnoreCase(attribute)) {
                                                deleteInterfaceFromAreaProcess(process.processId(),
                                                                               area.areaId().toString(),
                                                                               interfc);
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }

    /**
     * Deletes given process.
     *
     * @param processId process id
     * @param process   OSPF process instance
     */
    private void deleteProcess(String processId, OspfProcess process) {
        if (processes != null) {
            Iterator<OspfProcess> itrProcess = processes.iterator();
            while (itrProcess.hasNext()) {
                OspfProcess ospfPrs = itrProcess.next();
                if (processId.equalsIgnoreCase(ospfPrs.processId())) {
                    itrProcess.remove();
                }
            }
        }
    }

    /**
     * Deletes area from process.
     *
     * @param processId process id
     * @param areaId    area id
     * @param area      OSPF area instance
     */
    private void deleteAreaFromProcess(String processId, String areaId, OspfArea area) {
        if (processes != null) {
            Iterator<OspfProcess> itrProcess = processes.iterator();
            while (itrProcess.hasNext()) {
                OspfProcess ospfPrs = itrProcess.next();
                if (processId.equalsIgnoreCase(ospfPrs.processId())) {
                    if (ospfPrs.areas() != null) {
                        Iterator<OspfArea> itrArea = ospfPrs.areas().iterator();
                        while (itrArea.hasNext()) {
                            OspfArea ospfArea = itrArea.next();
                            if (areaId.equalsIgnoreCase(ospfArea.areaId().toString())) {
                                itrArea.remove();
                            }
                        }
                    }
                }
            }
        }
    }

    /**
     * Deletes interface from area.
     *
     * @param processId         process id
     * @param areaId            area id
     * @param interfaceToDelete interface to delete
     */
    private void deleteInterfaceFromAreaProcess(String processId, String areaId, OspfInterface interfaceToDelete) {
        if (processes != null) {
            Iterator<OspfProcess> itrProcess = processes.iterator();
            while (itrProcess.hasNext()) {
                OspfProcess ospfPrs = itrProcess.next();
                if (processId.equalsIgnoreCase(ospfPrs.processId())) {
                    if (ospfPrs.areas() != null) {
                        Iterator<OspfArea> itrArea = ospfPrs.areas().iterator();
                        while (itrArea.hasNext()) {
                            OspfArea ospfArea = itrArea.next();
                            if (areaId.equalsIgnoreCase(ospfArea.areaId().toString())) {
                                if (ospfArea.getInterfacesLst() != null) {
                                    Iterator<OspfInterface> intrfcList = ospfArea.getInterfacesLst().iterator();
                                    while (intrfcList.hasNext()) {
                                        OspfInterface ospfItrfc = intrfcList.next();
                                        if (interfaceToDelete.ipAddress().equals(ospfItrfc.ipAddress())) {
                                            intrfcList.remove();
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}