void LinkAggregationManager::stateUpdated(const StateDelta& delta) { CHECK(sw_->getUpdateEvb()->inRunningEventBaseThread()); folly::SharedMutexWritePriority::WriteHolder writeGuard(&controllersLock_); if (!initialized_) { bool inserted; for (const auto& port : *(delta.newState()->getPorts())) { // TODO(samank): use try_emplace once OSS build uses boost >1.63.0 std::tie(std::ignore, inserted) = portToController_.insert(std::make_pair( port->getID(), std::make_shared<LacpController>( port->getID(), sw_->getLacpEvb(), this))); CHECK(inserted); } for (const auto& portAndController : portToController_) { portAndController.second->startMachines(); } initialized_ = true; } DeltaFunctions::forEachChanged( delta.getAggregatePortsDelta(), &LinkAggregationManager::aggregatePortChanged, &LinkAggregationManager::aggregatePortAdded, &LinkAggregationManager::aggregatePortRemoved, this); // Downgrade to a reader lock folly::SharedMutexWritePriority::ReadHolder readGuard(std::move(writeGuard)); DeltaFunctions::forEachChanged( delta.getPortsDelta(), &LinkAggregationManager::portChanged, this); }
void NeighborUpdater::stateUpdated(const StateDelta& delta) { CHECK(sw_->getUpdateEVB()->inRunningEventBaseThread()); for (const auto& entry : delta.getVlansDelta()) { sendNeighborUpdates(entry); auto oldEntry = entry.getOld(); auto newEntry = entry.getNew(); if (!newEntry) { vlanDeleted(oldEntry.get()); } else if (!oldEntry) { vlanAdded(delta.newState().get(), newEntry.get()); } else { vlanChanged(oldEntry.get(), newEntry.get()); } } const auto& oldState = delta.oldState(); const auto& newState = delta.newState(); if (oldState->getArpTimeout() != newState->getArpTimeout() || oldState->getNdpTimeout() != newState->getNdpTimeout() || oldState->getMaxNeighborProbes() != newState->getMaxNeighborProbes() || oldState->getStaleEntryInterval() != newState->getStaleEntryInterval()) { std::lock_guard<std::mutex> g(cachesMutex_); for (auto& vlanAndCaches : caches_) { auto& arpCache = vlanAndCaches.second->arpCache; auto& ndpCache = vlanAndCaches.second->ndpCache; arpCache->setTimeout(newState->getArpTimeout()); arpCache->setMaxNeighborProbes(newState->getMaxNeighborProbes()); arpCache->setStaleEntryInterval(newState->getStaleEntryInterval()); ndpCache->setTimeout(newState->getNdpTimeout()); ndpCache->setMaxNeighborProbes(newState->getMaxNeighborProbes()); ndpCache->setStaleEntryInterval(newState->getStaleEntryInterval()); } } }
void NeighborUpdater::stateUpdated(const StateDelta& delta) { CHECK(sw_->getUpdateEVB()->inRunningEventBaseThread()); for (const auto& entry : delta.getVlansDelta()) { sendNeighborUpdates(entry); auto oldEntry = entry.getOld(); auto newEntry = entry.getNew(); if (!newEntry) { vlanDeleted(oldEntry.get()); } else if (!oldEntry) { vlanAdded(delta.newState().get(), newEntry.get()); } else { vlanChanged(oldEntry.get(), newEntry.get()); } } unresolvedNhopsProber_->stateChanged(delta); }
void TunManager::stateUpdated(const StateDelta& delta) { // TODO(aeckert): We currently compare the entire interface map instead // of using the iterator in this delta because some of the interfaces may get // get probed from hardware, before they are in the SwitchState. It would be // nicer if we did a little more work at startup to sync the state, perhaps // updating the SwitchState with the probed interfaces. This would allow us // to reuse the iterator in the delta for more readable code and also not // have to worry about waiting to listen to updates until the SwSwitch is in // the configured state. t4155406 should also help with that. auto state = delta.newState(); evb_->runInEventBaseThread([this, state]() { this->sync(state); }); }
void RouteUpdateLogger::stateUpdated(const StateDelta& delta) { for (const auto& rtDelta : delta.getRouteTablesDelta()) { DeltaFunctions::forEachChanged( rtDelta.getRoutesV4Delta(), &handleChangedRoute<folly::IPAddressV4>, &handleAddedRoute<folly::IPAddressV4>, &handleRemovedRoute<folly::IPAddressV4>, prefixTracker_, routeLoggerV4_); DeltaFunctions::forEachChanged( rtDelta.getRoutesV6Delta(), &handleChangedRoute<folly::IPAddressV6>, &handleAddedRoute<folly::IPAddressV6>, &handleRemovedRoute<folly::IPAddressV6>, prefixTracker_, routeLoggerV6_); } }
void NexthopToRouteCount::stateChanged(const StateDelta& delta) { for (auto const& rtDelta : delta.getRouteTablesDelta()) { // Do add/changed first so we don't remove next hops due to decrements // in ref count via removed routes, only to add them back again if these // next hops show up in added/changed routes if (rtDelta.getNew()) { RouterID id = rtDelta.getNew()->getID(); forEachChanged( rtDelta.getRoutesV4Delta(), &NexthopToRouteCount::processChangedRoute<RouteV4>, &NexthopToRouteCount::processAddedRoute<RouteV4>, [&](NexthopToRouteCount *, RouterID, const shared_ptr<RouteV4>&) {}, this, id); forEachChanged( rtDelta.getRoutesV6Delta(), &NexthopToRouteCount::processChangedRoute<RouteV6>, &NexthopToRouteCount::processAddedRoute<RouteV6>, [&](NexthopToRouteCount *, RouterID, const shared_ptr<RouteV6>&) {}, this, id); } // Process removed routes if (rtDelta.getOld()) { RouterID id = rtDelta.getOld()->getID(); forEachRemoved( rtDelta.getRoutesV4Delta(), &NexthopToRouteCount::processRemovedRoute<RouteV4>, this, id); forEachRemoved( rtDelta.getRoutesV6Delta(), &NexthopToRouteCount::processRemovedRoute<RouteV6>, this, id); } } }