Examples with Bridge org.opennms.netmgt.model.topology.Bridge used on opensource projects

Example 36 with Bridge

use of org.opennms.netmgt.model.topology.Bridge in project opennms by OpenNMS.

the class BroadcastDomainTest method testDFThenE.

@Test
public void testDFThenE() {
    DEFGHILTopology topology = new DEFGHILTopology();
    BroadcastDomain domain = new BroadcastDomain();
    domain.addBridge(new Bridge(topology.nodeDId));
    domain.addBridge(new Bridge(topology.nodeFId));
    domain.setBridgeElements(topology.elemlist);
    NodeDiscoveryBridgeTopology ndbt = new NodeDiscoveryBridgeTopology(linkd, new Node(topology.nodeDId, null, null, null, location));
    ndbt.setDomain(domain);
    ndbt.addUpdatedBFT(domain.getBridge(topology.nodeDId), topology.bftD);
    ndbt.addUpdatedBFT(domain.getBridge(topology.nodeFId), topology.bftF);
    ndbt.calculate();
    topology.checkDF(ndbt.getDomain());
    domain.addBridge(new Bridge(topology.nodeEId));
    domain.setBridgeElements(topology.elemlist);
    ndbt.addUpdatedBFT(domain.getBridge(topology.nodeEId), topology.bftE);
    ndbt.calculate();
    topology.checkDEF(ndbt.getDomain());
}

Example 37 with Bridge

use of org.opennms.netmgt.model.topology.Bridge in project opennms by OpenNMS.

the class BroadcastDomainTest method testBC.

@Test
public void testBC() {
    ABCTopology topology = new ABCTopology();
    BroadcastDomain domain = new BroadcastDomain();
    domain.addBridge(new Bridge(topology.nodeBId));
    domain.addBridge(new Bridge(topology.nodeCId));
    domain.setBridgeElements(topology.elemlist);
    NodeDiscoveryBridgeTopology ndbt = new NodeDiscoveryBridgeTopology(linkd, new Node(topology.nodeAId, null, null, null, location));
    ndbt.setDomain(domain);
    ndbt.addUpdatedBFT(domain.getBridge(topology.nodeBId), topology.bftB);
    ndbt.addUpdatedBFT(domain.getBridge(topology.nodeCId), topology.bftC);
    ndbt.calculate();
    topology.checkBC(ndbt.getDomain());
}

Example 38 with Bridge

use of org.opennms.netmgt.model.topology.Bridge in project opennms by OpenNMS.

the class BridgeTopologyDaoHibernate method load.

@Override
public Set<BroadcastDomain> load() {
    List<SharedSegment> bblsegments = new ArrayList<SharedSegment>();
    Map<Integer, Set<Integer>> rootnodetodomainnodemap = new HashMap<Integer, Set<Integer>>();
    // start bridge bridge link parsing
    for (BridgeBridgeLink link : m_bridgeBridgeLinkDao.findAll()) {
        if (LOG.isDebugEnabled()) {
            LOG.debug("getAllPersisted: Parsing BridgeBridgeLink: {}", link.printTopology());
        }
        boolean segmentnotfound = true;
        for (SharedSegment bblsegment : bblsegments) {
            if (bblsegment.containsPort(link.getDesignatedNode().getId(), link.getDesignatedPort())) {
                bblsegment.add(link);
                segmentnotfound = false;
                if (LOG.isDebugEnabled()) {
                    LOG.debug("getAllPersisted: found Bridge Bridge Link Shared Segment: {}", bblsegment.printTopology());
                }
                break;
            }
        }
        if (segmentnotfound) {
            SharedSegment bblsegment = new SharedSegment();
            bblsegment.add(link);
            bblsegment.setDesignatedBridge(link.getDesignatedNode().getId());
            bblsegments.add(bblsegment);
            if (LOG.isDebugEnabled()) {
                LOG.debug("getAllPersisted: created new Bridge Bridge Link Shared Segment: {}", bblsegment.printTopology());
            }
        }
        // set up domains
        if (rootnodetodomainnodemap.containsKey(link.getDesignatedNode().getId())) {
            rootnodetodomainnodemap.get(link.getDesignatedNode().getId()).add(link.getNode().getId());
            if (rootnodetodomainnodemap.containsKey(link.getNode().getId())) {
                rootnodetodomainnodemap.get(link.getDesignatedNode().getId()).addAll(rootnodetodomainnodemap.remove(link.getNode().getId()));
            }
            if (LOG.isDebugEnabled()) {
                LOG.debug("getAllPersisted: designated {} is root, dependency set: {}", link.getDesignatedNode().getId(), rootnodetodomainnodemap.get(link.getDesignatedNode().getId()));
            }
        } else if (rootnodetodomainnodemap.containsKey(link.getNode().getId())) {
            Set<Integer> dependentsnode = rootnodetodomainnodemap.remove(link.getNode().getId());
            dependentsnode.add(link.getNode().getId());
            if (LOG.isDebugEnabled()) {
                LOG.debug("getAllPersisted: node {} is root, dependency set: {}", link.getNode().getId(), dependentsnode);
            }
            Integer rootdesignated = null;
            for (Integer rootid : rootnodetodomainnodemap.keySet()) {
                if (rootnodetodomainnodemap.get(rootid).contains(link.getDesignatedNode().getId())) {
                    rootdesignated = rootid;
                    break;
                }
            }
            if (rootdesignated != null) {
                if (LOG.isDebugEnabled()) {
                    LOG.debug("getAllPersisted: node {} found root: {}", link.getNode().getId(), rootdesignated);
                }
                dependentsnode.add(link.getDesignatedNode().getId());
                rootnodetodomainnodemap.get(rootdesignated).addAll(dependentsnode);
                if (LOG.isDebugEnabled()) {
                    LOG.debug("getAllPersisted: node {} found root: {}, dependency set: {}", link.getNode().getId(), rootdesignated, rootnodetodomainnodemap.get(rootdesignated));
                }
            } else {
                rootnodetodomainnodemap.put(link.getDesignatedNode().getId(), dependentsnode);
                if (LOG.isDebugEnabled()) {
                    LOG.debug("getAllPersisted: node {} created root: {}, dependency set: {}", link.getNode().getId(), link.getDesignatedNode().getId(), rootnodetodomainnodemap.get(link.getDesignatedNode().getId()));
                }
            }
        } else {
            Integer rootdesignated = null;
            for (Integer rootid : rootnodetodomainnodemap.keySet()) {
                if (rootnodetodomainnodemap.get(rootid).contains(link.getDesignatedNode().getId())) {
                    rootdesignated = rootid;
                    break;
                }
            }
            if (rootdesignated != null) {
                rootnodetodomainnodemap.get(rootdesignated).add(link.getNode().getId());
                if (LOG.isDebugEnabled()) {
                    LOG.debug("getAllPersisted: designatednode {} found root: {}, dependency set: {}", link.getDesignatedNode().getId(), rootdesignated, rootnodetodomainnodemap.get(rootdesignated));
                }
            } else {
                rootnodetodomainnodemap.put(link.getDesignatedNode().getId(), new HashSet<Integer>());
                rootnodetodomainnodemap.get(link.getDesignatedNode().getId()).add(link.getNode().getId());
                if (LOG.isDebugEnabled()) {
                    LOG.debug("getAllPersisted: designatednode {} : {}", link.getDesignatedNode().getId(), rootnodetodomainnodemap.get(link.getDesignatedNode().getId()));
                }
            // FIXME: Check if node is a child of some other and manage exception :-)
            }
        }
    }
    LOG.debug("getAllPersisted: bridge topology set: {}", rootnodetodomainnodemap);
    // end bridge bridge link parsing
    List<SharedSegment> bmlsegments = new ArrayList<SharedSegment>();
    Map<String, List<BridgeMacLink>> mactobridgeportbbl = new HashMap<String, List<BridgeMacLink>>();
    BML: for (BridgeMacLink link : m_bridgeMacLinkDao.findAll()) {
        link.setBridgeDot1qTpFdbStatus(BridgeDot1qTpFdbStatus.DOT1D_TP_FDB_STATUS_LEARNED);
        if (LOG.isDebugEnabled()) {
            LOG.debug("getAllPersisted: Parsing BridgeMacLink: {}", link.printTopology());
        }
        for (SharedSegment bblsegment : bblsegments) {
            if (bblsegment.containsPort(link.getNode().getId(), link.getBridgePort())) {
                if (!mactobridgeportbbl.containsKey(link.getMacAddress())) {
                    mactobridgeportbbl.put(link.getMacAddress(), new ArrayList<BridgeMacLink>());
                }
                if (LOG.isDebugEnabled()) {
                    LOG.debug("getAllPersisted: Found BridgeBridgeLink Segment: {}", bblsegment.printTopology());
                }
                mactobridgeportbbl.get(link.getMacAddress()).add(link);
                continue BML;
            }
        }
        if (!rootnodetodomainnodemap.containsKey(link.getNode().getId())) {
            boolean norootnodetodomainmapentry = true;
            for (Set<Integer> nodes : rootnodetodomainnodemap.values()) {
                if (nodes.contains(link.getNode().getId())) {
                    norootnodetodomainmapentry = false;
                    break;
                }
            }
            if (norootnodetodomainmapentry)
                rootnodetodomainnodemap.put(link.getNode().getId(), new HashSet<Integer>());
        }
        for (SharedSegment bmlsegment : bmlsegments) {
            if (bmlsegment.containsPort(link.getNode().getId(), link.getBridgePort())) {
                bmlsegment.add(link);
                if (LOG.isDebugEnabled()) {
                    LOG.debug("getAllPersisted: found Bridge Mac Link Shared Segment: {}", bmlsegment.printTopology());
                }
                continue BML;
            }
        }
        SharedSegment bmlsegment = new SharedSegment();
        bmlsegment.add(link);
        bmlsegment.setDesignatedBridge(link.getNode().getId());
        if (LOG.isDebugEnabled()) {
            LOG.debug("getAllPersisted: created new Bridge Mac Link Shared Segment: {}", bmlsegment.printTopology());
        }
        bmlsegments.add(bmlsegment);
    }
    List<BridgeMacLink> forwarders = new ArrayList<BridgeMacLink>();
    for (String macaddress : mactobridgeportbbl.keySet()) {
        LOG.debug("getAllPersisted: assigning mac {} to Bridge Bridge Link Shared Segment", macaddress);
        for (SharedSegment segment : bblsegments) {
            if (LOG.isDebugEnabled()) {
                LOG.debug("getAllPersisted: parsing Bridge Bridge Link Shared Segment {}", segment.printTopology());
            }
            List<BridgeMacLink> bblfoundonsegment = new ArrayList<BridgeMacLink>();
            for (BridgeMacLink link : mactobridgeportbbl.get(macaddress)) {
                if (LOG.isDebugEnabled()) {
                    LOG.debug("getAllPersisted: parsing Bridge Mac Link {}", link.printTopology());
                }
                if (segment.containsPort(link.getNode().getId(), link.getBridgePort())) {
                    bblfoundonsegment.add(link);
                    if (LOG.isDebugEnabled()) {
                        LOG.debug("getAllPersisted: adding Bridge Mac Link {}", link.printTopology());
                    }
                }
            }
            if (bblfoundonsegment.size() == segment.getBridgePortsOnSegment().size()) {
                for (BridgeMacLink link : bblfoundonsegment) segment.add(link);
            } else {
                forwarders.addAll(bblfoundonsegment);
            }
        }
    }
    Set<BroadcastDomain> domains = new CopyOnWriteArraySet<BroadcastDomain>();
    for (Integer rootnode : rootnodetodomainnodemap.keySet()) {
        BroadcastDomain domain = new BroadcastDomain();
        domain.addBridge(new Bridge(rootnode));
        for (Integer nodeid : rootnodetodomainnodemap.get(rootnode)) domain.addBridge(new Bridge(nodeid));
        if (LOG.isDebugEnabled()) {
            LOG.debug("getAllPersisted: created new Broadcast Domain: {}", domain.getBridgeNodesOnDomain());
        }
        domains.add(domain);
    }
    for (SharedSegment segment : bblsegments) {
        for (BroadcastDomain cdomain : domains) {
            if (cdomain.containsAtleastOne(segment.getBridgeIdsOnSegment())) {
                cdomain.loadTopologyEntry(segment);
                break;
            }
        }
    }
    for (SharedSegment segment : bmlsegments) {
        for (BroadcastDomain cdomain : domains) {
            if (cdomain.containsAtleastOne(segment.getBridgeIdsOnSegment())) {
                cdomain.loadTopologyEntry(segment);
                break;
            }
        }
    }
    for (BridgeMacLink forwarder : forwarders) {
        for (BroadcastDomain domain : domains) {
            if (domain.containBridgeId(forwarder.getNode().getId())) {
                domain.addForwarding(forwarder);
                break;
            }
        }
    }
    for (BroadcastDomain domain : domains) {
        if (LOG.isDebugEnabled()) {
            LOG.info("getAllPersisted: loading root Broadcast Domain: {}", domain.getBridgeNodesOnDomain());
        }
        domain.loadTopologyRoot();
    }
    return domains;
}

Example 39 with Bridge

use of org.opennms.netmgt.model.topology.Bridge in project opennms by OpenNMS.

the class NodeDiscoveryBridgeTopology method findBridgesTopo.

// here we assume that rbridge exists in topology
// while xBridge is to be added
private boolean findBridgesTopo(BridgeTopologyHelper rx, SharedSegment topSegment, Bridge xBridge, List<BridgeMacLink> xBFT, int level) {
    if (topSegment == null) {
        LOG.warn("calculate: node: [{}]: level: {}, bridge: [{}], top segment is null exiting.....", getNodeId(), level, xBridge.getId());
        return false;
    }
    level++;
    if (level == 30) {
        LOG.warn("calculate: node: [{}]: level: {}, bridge: [{}], too many iteration on topology exiting.....", getNodeId(), level, xBridge.getId());
        return false;
    }
    if (LOG.isDebugEnabled()) {
        LOG.debug("calculate: node: [{}], level: {}, bridge: [{}], checking if is child of segment: [ids {}, designated bridge {}, port {}, macs {}]", getNodeId(), level, xBridge.getId(), topSegment.getBridgeIdsOnSegment(), topSegment.getDesignatedBridge(), topSegment.getDesignatedPort(), topSegment.getMacsOnSegment());
    }
    Set<Integer> portsAdded = new HashSet<Integer>();
    Set<String> macsOnSegment = rx.getSimpleConnectionMacs();
    Map<Integer, List<BridgeMacLink>> bftSets = new HashMap<Integer, List<BridgeMacLink>>();
    List<BridgeMacLink> forwarders = new ArrayList<BridgeMacLink>();
    forwarders.addAll(rx.getFirstBridgeForwarders());
    forwarders.addAll(rx.getSecondBridgeForwarders());
    for (Bridge yBridge : m_domain.getBridgeOnSharedSegment(topSegment)) {
        bftSets.put(yBridge.getId(), m_domain.calculateBFT(yBridge));
    }
    for (Bridge yBridge : m_domain.getBridgeOnSharedSegment(topSegment)) {
        Integer yBridgeId = yBridge.getId();
        // X is a leaf of top segment: of course
        if (yBridgeId.intValue() == topSegment.getDesignatedBridge().intValue()) {
            continue;
        }
        Integer yrDesignatedPort = yBridge.getRootPort();
        LOG.debug("calculate: node: [{}], level: {}, bridge: [{}], bridge: [{}, designated port: {}]", getNodeId(), level, xBridge.getId(), yBridgeId, yrDesignatedPort);
        BridgeTopologyHelper yx = new BridgeTopologyHelper(yBridge, bftSets.get(yBridgeId), xBridge, xBFT);
        Integer xyDesignatedPort = yx.getSecondBridgeConnectionPort();
        Integer yxDesignatedPort = yx.getFirstBridgeConnectionPort();
        // if X is a leaf of Y then iterate
        if (xyDesignatedPort == rx.getSecondBridgeConnectionPort() && yxDesignatedPort != yrDesignatedPort) {
            LOG.debug("calculate: node: [{}]: level: {}, bridge: [{}] is a leaf of bridge: [{}], going one level down", getNodeId(), level, xBridge.getId(), yBridge.getId());
            if (!findBridgesTopo(yx, m_domain.getSharedSegment(yBridgeId, yxDesignatedPort), xBridge, xBFT, level))
                return false;
            return true;
        }
        // Clean also topSegment macs.
        if (yxDesignatedPort == yrDesignatedPort && xyDesignatedPort != rx.getSecondBridgeConnectionPort()) {
            // create a SharedSegment with root port
            LOG.info("calculate: node: [{}], level: {}, bridge: [{},designated port [{}]]: found level.", getNodeId(), level, xBridge.getId(), xyDesignatedPort);
            LOG.debug("calculate: node: [{}], level: {}, bridge: [{},designated port [{}]]: is 'up' for bridge: [{}].", getNodeId(), level, xBridge.getId(), xyDesignatedPort, yBridge.getId());
            SharedSegment leafSegment = m_domain.getSharedSegment(xBridge.getId(), xyDesignatedPort);
            if (leafSegment == null) {
                leafSegment = new SharedSegment(m_domain, yx.getSimpleConnection(), yx.getSimpleConnectionMacs());
                leafSegment.setDesignatedBridge(xBridge.getId());
                m_domain.add(leafSegment);
            } else {
                leafSegment.retain(yx.getSimpleConnectionMacs(), yx.getFirstBridgePort());
            }
            portsAdded.add(xyDesignatedPort);
            if (LOG.isDebugEnabled()) {
                LOG.debug("calculate: node: [{}], level: {}, bridge [{}]. Remove bridge [{}] and macs {} from top segment.", getNodeId(), level, xBridge.getId(), yBridge.getId(), topSegment.getMacsOnSegment());
            }
            topSegment.getMacsOnSegment().clear();
            topSegment.removeBridge(yBridgeId);
        } else if (xyDesignatedPort != rx.getSecondBridgeConnectionPort() && yxDesignatedPort != yrDesignatedPort) {
            LOG.warn("calculate: node: [{}]: level {}: bridge [{}]. Topology mismatch. Clearing...topology", getNodeId(), level, xBridge.getId());
            return false;
        } else {
            macsOnSegment.retainAll(yx.getSimpleConnectionMacs());
        }
        forwarders.addAll(yx.getFirstBridgeForwarders());
        forwarders.addAll(yx.getSecondBridgeForwarders());
    }
    // if we are here is because X is NOT a leaf of any bridge found
    // on topSegment so X is connected to top Segment by it's root
    // port or rx is a direct connection
    LOG.debug("calculate: node: [{}]: level: {}, bridge: [{}]. assign macs {} to top segment", getNodeId(), level, xBridge.getId(), macsOnSegment);
    topSegment.assign(macsOnSegment, rx.getSecondBridgePort());
    if (LOG.isDebugEnabled()) {
        LOG.debug("calculate: node: [{}]: level: {}, bridge: [{}]. resulting top segment: [ids {}, designated bridge [{}, port: {}], mac : {}]", getNodeId(), level, xBridge.getId(), topSegment.getBridgeIdsOnSegment(), topSegment.getDesignatedBridge(), topSegment.getDesignatedPort(), topSegment.getMacsOnSegment());
    }
    for (Integer xbridgePort : rx.getSecondBridgeTroughSetBft().keySet()) {
        if (portsAdded.contains(xbridgePort))
            continue;
        SharedSegment xleafSegment = new SharedSegment(m_domain, rx.getSecondBridgeTroughSetBft().get(xbridgePort));
        xleafSegment.setDesignatedBridge(xBridge.getId());
        m_domain.add(xleafSegment);
        if (LOG.isDebugEnabled()) {
            LOG.debug("calculate: node: [{}]: level: {}, bridge: [{}]. Add shared segment. " + "[ designated bridge:[{}], " + "port:{}, " + "mac: {}]", getNodeId(), level, xBridge.getId(), xleafSegment.getDesignatedBridge(), xleafSegment.getDesignatedPort(), xleafSegment.getMacsOnSegment());
        }
    }
    addForwarding(m_domain, forwarders);
    return true;
}

Example 40 with Bridge

use of org.opennms.netmgt.model.topology.Bridge in project opennms by OpenNMS.

the class NodeDiscoveryBridgeTopology method run.

@Override
public void run() {
    if (!m_linkd.getQueryManager().hasUpdatedBft(getNodeId())) {
        LOG.info("run: node: [{}], no bft.Exiting Bridge Topology Discovery", getNodeId());
        return;
    }
    List<BridgeMacLink> links = m_linkd.getQueryManager().getBridgeTopologyUpdateBFT(getNodeId());
    if (links == null || links.size() == 0) {
        LOG.info("run: node: [{}]. no updates macs found.", getNodeId());
        return;
    }
    Date now = new Date();
    Set<String> incomingSet = new HashSet<String>();
    synchronized (links) {
        for (BridgeMacLink link : links) {
            incomingSet.add(link.getMacAddress());
        }
    }
    LOG.debug("run: node: [{}]. macs found: {}", getNodeId(), incomingSet);
    LOG.info("run: node: [{}], getting broadcast domain. Start", getNodeId());
    for (BroadcastDomain domain : m_linkd.getQueryManager().getAllBroadcastDomains()) {
        LOG.debug("run: node: [{}], parsing domain with nodes: {}, macs: {}", getNodeId(), domain.getBridgeNodesOnDomain(), domain.getMacsOnDomain());
        Set<String> retainedSet = new HashSet<String>(domain.getMacsOnDomain());
        retainedSet.retainAll(incomingSet);
        LOG.debug("run: node: [{}], retained: {}", getNodeId(), retainedSet);
        // should contain at list 5 or 10% of the all size
        if (retainedSet.size() > DOMAIN_MATCH_MIN_SIZE || retainedSet.size() >= incomingSet.size() * DOMAIN_MATCH_MIN_RATIO) {
            if (LOG.isDebugEnabled()) {
                LOG.debug("run: node: [{}], domain {} found!", getNodeId(), domain.getBridgeNodesOnDomain());
            }
            m_domain = domain;
        // TODO: We should find the *best* domain, instead of using the last match
        }
    }
    if (m_domain == null) {
        LOG.debug("run: node: [{}] Creating a new Domain", getNodeId());
        m_domain = new BroadcastDomain();
        m_linkd.getQueryManager().save(m_domain);
    } else if (!m_domain.hasRootBridge()) {
        LOG.debug("run: node: [{}] Domain without root, clearing topology", getNodeId());
        m_domain.clearTopology();
    }
    LOG.info("run: node: [{}], getting broadcast domain. End", getNodeId());
    Map<Integer, List<BridgeMacLink>> nodeBftMap = m_linkd.getQueryManager().getUpdateBftMap();
    Set<Integer> nodeswithupdatedbftonbroadcastdomain = getAllNodesWithUpdatedBFTOnDomain(incomingSet, nodeBftMap);
    LOG.info("run: node: [{}], clean broadcast domains. Start", getNodeId());
    boolean clean = false;
    for (BroadcastDomain domain : m_linkd.getQueryManager().getAllBroadcastDomains()) {
        if (m_domain == domain)
            continue;
        if (LOG.isDebugEnabled()) {
            LOG.debug("run: node [{}]: cleaning broadcast domain {}.", getNodeId(), domain.getBridgeNodesOnDomain());
        }
        for (Integer curNodeId : nodeswithupdatedbftonbroadcastdomain) {
            if (domain.containBridgeId(curNodeId)) {
                if (LOG.isDebugEnabled()) {
                    LOG.debug("run: node [{}]: node [{}]: removing from broadcast domain {}!", getNodeId(), curNodeId, domain.getBridgeNodesOnDomain());
                }
                synchronized (domain) {
                    domain.clearTopologyForBridge(curNodeId);
                    domain.removeBridge(curNodeId);
                    m_linkd.getQueryManager().store(domain);
                    m_linkd.getQueryManager().reconcileBridgeTopology(domain, now);
                }
                clean = true;
            }
        }
    }
    if (clean) {
        m_linkd.getQueryManager().cleanBroadcastDomains();
    }
    LOG.info("run: node: [{}], clean broadcast domains. End", getNodeId());
    synchronized (m_domain) {
        m_notYetParsedBFTMap = new HashMap<Bridge, List<BridgeMacLink>>();
        for (Integer nodeid : nodeswithupdatedbftonbroadcastdomain) {
            sendStartEvent(nodeid);
            m_domain.addBridge(new Bridge(nodeid));
            LOG.debug("run: node: [{}], getting update bft for node [{}] on domain", getNodeId(), nodeid);
            List<BridgeMacLink> bft = m_linkd.getQueryManager().useBridgeTopologyUpdateBFT(nodeid);
            if (bft == null || bft.isEmpty()) {
                LOG.debug("run: node: [{}], no update bft for node [{}] on domain", getNodeId(), nodeid);
                continue;
            }
            m_notYetParsedBFTMap.put(m_domain.getBridge(nodeid), bft);
        }
        Set<Integer> nodetoberemovedondomain = new HashSet<Integer>();
        synchronized (nodeBftMap) {
            for (Integer nodeid : nodeBftMap.keySet()) {
                if (nodeswithupdatedbftonbroadcastdomain.contains(nodeid))
                    continue;
                LOG.info("run: node [{}]: bridge [{}] with updated bft. Not even more on broadcast domain {}: clear topology.", getNodeId(), nodeid, m_domain.getBridgeNodesOnDomain());
                nodetoberemovedondomain.add(nodeid);
            }
        }
        for (Integer nodeid : nodetoberemovedondomain) {
            m_domain.clearTopologyForBridge(nodeid);
            m_domain.removeBridge(nodeid);
        }
        m_linkd.getQueryManager().cleanBroadcastDomains();
        m_domain.setBridgeElements(m_linkd.getQueryManager().getBridgeElements(m_domain.getBridgeNodesOnDomain()));
        if (m_notYetParsedBFTMap.isEmpty()) {
            LOG.info("run: node: [{}], broadcast domain has no topology updates. No more action is needed.", getNodeId());
        } else {
            calculate();
        }
        LOG.info("run: node: [{}], saving Topology.", getNodeId());
        m_linkd.getQueryManager().store(m_domain);
        m_linkd.getQueryManager().reconcileBridgeTopology(m_domain, now);
        LOG.info("run: node: [{}], saved Topology.", getNodeId());
        for (Integer curNode : nodeswithupdatedbftonbroadcastdomain) {
            sendCompletedEvent(curNode);
        }
    }
}