use of org.onosproject.net.ConnectPoint in project trellis-control by opennetworkinglab.
the class SegmentRoutingManager method removeSubnetConfig.
private void removeSubnetConfig(ConnectPoint cp, Set<InterfaceIpAddress> ipAddressSet) {
Set<IpPrefix> ipPrefixSet = ipAddressSet.stream().map(InterfaceIpAddress::subnetAddress).collect(Collectors.toSet());
Set<InterfaceIpAddress> deviceIntfIpAddrs = interfaceService.getInterfaces().stream().filter(intf -> intf.connectPoint().deviceId().equals(cp.deviceId())).filter(intf -> !intf.connectPoint().equals(cp)).flatMap(intf -> intf.ipAddressesList().stream()).collect(Collectors.toSet());
// 1. Partial subnet population
// Remove routing rules for removed subnet from previous configuration,
// which does not also exist in other interfaces in the same device
Set<IpPrefix> deviceIpPrefixSet = deviceIntfIpAddrs.stream().map(InterfaceIpAddress::subnetAddress).collect(Collectors.toSet());
Set<IpPrefix> subnetsToBeRevoked = ipPrefixSet.stream().filter(ipPrefix -> !deviceIpPrefixSet.contains(ipPrefix)).collect(Collectors.toSet());
// Check if any of the subnets to be revoked is configured in the pairDevice.
// If any, repopulate the subnet with pairDevice connectPoint instead of revoking.
Optional<DeviceId> pairDevice = getPairDeviceId(cp.deviceId());
if (pairDevice.isPresent()) {
Set<IpPrefix> pairDeviceIpPrefix = getDeviceSubnetMap().get(pairDevice.get());
Set<IpPrefix> subnetsExistingInPairDevice = subnetsToBeRevoked.stream().filter(ipPrefix -> pairDeviceIpPrefix.contains(ipPrefix)).collect(Collectors.toSet());
// Update the subnets existing in pair device with pair device connect point.
if (!subnetsExistingInPairDevice.isEmpty()) {
// PortNumber of connect point is not relevant in populate subnet and hence providing as ANY.
ConnectPoint pairDeviceCp = new ConnectPoint(pairDevice.get(), PortNumber.ANY);
log.debug("Updating the subnets: {} with pairDevice connectPoint as it exists in the Pair device: {}", subnetsExistingInPairDevice, pairDeviceCp);
defaultRoutingHandler.populateSubnet(Collections.singleton(pairDeviceCp), subnetsExistingInPairDevice);
}
// Remove only the subnets that are not configured in the pairDevice.
subnetsToBeRevoked = Sets.difference(subnetsToBeRevoked, subnetsExistingInPairDevice);
}
if (!subnetsToBeRevoked.isEmpty()) {
log.debug("Removing subnets for connectPoint: {}, subnets: {}", cp, subnetsToBeRevoked);
defaultRoutingHandler.revokeSubnet(subnetsToBeRevoked, cp.deviceId());
}
// 2. Interface IP punts
// Remove IP punts for old Intf address
Set<IpAddress> deviceIpAddrs = deviceIntfIpAddrs.stream().map(InterfaceIpAddress::ipAddress).collect(Collectors.toSet());
ipAddressSet.stream().map(InterfaceIpAddress::ipAddress).filter(interfaceIpAddress -> !deviceIpAddrs.contains(interfaceIpAddress)).forEach(interfaceIpAddress -> routingRulePopulator.revokeSingleIpPunts(cp.deviceId(), interfaceIpAddress));
// 3. Host unicast routing rule
// Remove unicast routing rule
hostEventExecutor.execute(() -> hostHandler.processIntfIpUpdatedEvent(cp, ipPrefixSet, false));
}
use of org.onosproject.net.ConnectPoint in project trellis-control by opennetworkinglab.
the class McastHandler method recoverFailure.
/**
* General failure recovery procedure.
*
* @param mcastIp the group to recover
* @param failedElement the failed element
*/
private void recoverFailure(IpAddress mcastIp, Object failedElement) {
// Do not proceed if we are not the leaders
if (!mcastUtils.isLeader(mcastIp)) {
log.debug("Skip {} due to lack of leadership", mcastIp);
return;
}
// Skip if it is not an infra failure
Set<DeviceId> transitDevices = getDevice(mcastIp, TRANSIT);
if (!mcastUtils.isInfraFailure(transitDevices, failedElement)) {
log.debug("Skip {} not an infrastructure failure", mcastIp);
return;
}
// Do not proceed if the sources of this group are missing
Set<ConnectPoint> sources = getSources(mcastIp);
if (sources.isEmpty()) {
log.warn("Missing sources for group {}", mcastIp);
return;
}
// Get all the paths, affected paths, good links and good devices
Set<List<Link>> storedPaths = getStoredPaths(mcastIp);
Set<List<Link>> affectedPaths = mcastUtils.getAffectedPaths(storedPaths, failedElement);
Set<Link> goodLinks = Sets.newHashSet();
Map<DeviceId, Set<DeviceId>> goodDevicesBySource = Maps.newHashMap();
Map<DeviceId, Set<ConnectPoint>> processedSourcesByEgress = Maps.newHashMap();
Sets.difference(storedPaths, affectedPaths).forEach(goodPath -> {
goodLinks.addAll(goodPath);
DeviceId srcDevice = goodPath.get(0).src().deviceId();
Set<DeviceId> goodDevices = Sets.newHashSet();
goodPath.forEach(link -> goodDevices.add(link.src().deviceId()));
goodDevicesBySource.compute(srcDevice, (k, v) -> {
v = v == null ? Sets.newHashSet() : v;
v.addAll(goodDevices);
return v;
});
});
affectedPaths.forEach(affectedPath -> {
// TODO remove
log.info("Good links {}", goodLinks);
// TODO remove
log.info("Good devices {}", goodDevicesBySource);
// TODO trace
log.info("Healing the path {}", affectedPath);
DeviceId srcDevice = affectedPath.get(0).src().deviceId();
DeviceId dstDevice = affectedPath.get(affectedPath.size() - 1).dst().deviceId();
// Fix in one shot multiple sources
Set<ConnectPoint> affectedSources = sources.stream().filter(device -> device.deviceId().equals(srcDevice)).collect(Collectors.toSet());
Set<ConnectPoint> processedSources = processedSourcesByEgress.getOrDefault(dstDevice, Collections.emptySet());
Optional<Path> alternativePath = getPath(srcDevice, dstDevice, mcastIp, null);
// If an alternative is possible go ahead
if (alternativePath.isPresent()) {
// TODO trace
log.info("Alternative path {}", alternativePath.get().links());
} else {
// Otherwise try to come up with an alternative
// TODO trace
log.info("No alternative path");
Set<ConnectPoint> notAffectedSources = Sets.difference(sources, affectedSources);
Set<ConnectPoint> remainingSources = Sets.difference(notAffectedSources, processedSources);
alternativePath = recoverSinks(dstDevice, mcastIp, affectedSources, remainingSources);
processedSourcesByEgress.compute(dstDevice, (k, v) -> {
v = v == null ? Sets.newHashSet() : v;
v.addAll(affectedSources);
return v;
});
}
// Recover from the failure if possible
Optional<Path> finalPath = alternativePath;
affectedSources.forEach(affectedSource -> {
// Update the mcastPath store
McastPathStoreKey mcastPathStoreKey = new McastPathStoreKey(mcastIp, affectedSource);
// Verify if there are local sinks
Set<DeviceId> localSinks = getSinks(mcastIp, srcDevice, affectedSource).stream().map(ConnectPoint::deviceId).collect(Collectors.toSet());
Set<DeviceId> goodDevices = goodDevicesBySource.compute(affectedSource.deviceId(), (k, v) -> {
v = v == null ? Sets.newHashSet() : v;
v.addAll(localSinks);
return v;
});
// TODO remove
log.info("Good devices {}", goodDevicesBySource);
Collection<? extends List<Link>> storedPathsBySource = Versioned.valueOrElse(mcastPathStore.get(mcastPathStoreKey), Lists.newArrayList());
Optional<? extends List<Link>> storedPath = storedPathsBySource.stream().filter(path -> path.equals(affectedPath)).findFirst();
// Remove bad links
affectedPath.forEach(affectedLink -> {
DeviceId affectedDevice = affectedLink.src().deviceId();
// If there is overlap with good paths - skip it
if (!goodLinks.contains(affectedLink)) {
removePortFromDevice(affectedDevice, affectedLink.src().port(), mcastIp, mcastUtils.assignedVlan(affectedDevice.equals(affectedSource.deviceId()) ? affectedSource : null));
}
// Remove role on the affected links if last
if (!goodDevices.contains(affectedDevice)) {
mcastRoleStore.remove(new McastRoleStoreKey(mcastIp, affectedDevice, affectedSource));
}
});
// trying with the original object as workaround
if (storedPath.isPresent()) {
mcastPathStore.remove(mcastPathStoreKey, storedPath.get());
} else {
log.warn("Unable to find the corresponding path - trying removeal");
mcastPathStore.remove(mcastPathStoreKey, affectedPath);
}
// Program new links
if (finalPath.isPresent()) {
List<Link> links = finalPath.get().links();
installPath(mcastIp, affectedSource, links);
mcastPathStore.put(mcastPathStoreKey, links);
links.forEach(link -> goodDevices.add(link.src().deviceId()));
goodDevicesBySource.compute(srcDevice, (k, v) -> {
v = v == null ? Sets.newHashSet() : v;
v.addAll(goodDevices);
return v;
});
goodLinks.addAll(finalPath.get().links());
}
});
});
}
use of org.onosproject.net.ConnectPoint in project trellis-control by opennetworkinglab.
the class McastHandler method getSinks.
/**
* Gets sink(s) of given multicast group.
*
* @param mcastIp multicast IP
* @return set of connect point or empty set if not found
*/
private Set<ConnectPoint> getSinks(IpAddress mcastIp, DeviceId device, ConnectPoint source) {
McastPathStoreKey pathStoreKey = new McastPathStoreKey(mcastIp, source);
Collection<? extends List<Link>> storedPaths = Versioned.valueOrElse(mcastPathStore.get(pathStoreKey), Lists.newArrayList());
VlanId assignedVlan = mcastUtils.assignedVlan(device.equals(source.deviceId()) ? source : null);
McastStoreKey mcastStoreKey = new McastStoreKey(mcastIp, device, assignedVlan);
NextObjective nextObjective = Versioned.valueOrNull(mcastNextObjStore.get(mcastStoreKey));
ImmutableSet.Builder<ConnectPoint> cpBuilder = ImmutableSet.builder();
if (nextObjective != null) {
Set<PortNumber> outputPorts = mcastUtils.getPorts(nextObjective.next());
outputPorts.forEach(portNumber -> cpBuilder.add(new ConnectPoint(device, portNumber)));
}
Set<ConnectPoint> egressCp = cpBuilder.build();
return egressCp.stream().filter(connectPoint -> !mcastUtils.isInfraPort(connectPoint, storedPaths)).collect(Collectors.toSet());
}
use of org.onosproject.net.ConnectPoint in project trellis-control by opennetworkinglab.
the class McastHandler method buildMcastPaths.
/**
* Build the mcast paths.
*
* @param storedPaths mcast tree
* @param mcastIp the group ip
* @param source the source
*/
private Map<ConnectPoint, List<ConnectPoint>> buildMcastPaths(Collection<? extends List<Link>> storedPaths, IpAddress mcastIp, ConnectPoint source) {
Map<ConnectPoint, List<ConnectPoint>> mcastTree = Maps.newHashMap();
// Local sinks
Set<ConnectPoint> localSinks = getSinks(mcastIp, source.deviceId(), source);
localSinks.forEach(localSink -> mcastTree.put(localSink, Lists.newArrayList(localSink, source)));
// Remote sinks
storedPaths.forEach(path -> {
List<Link> links = path;
DeviceId egressDevice = links.get(links.size() - 1).dst().deviceId();
Set<ConnectPoint> remoteSinks = getSinks(mcastIp, egressDevice, source);
List<ConnectPoint> connectPoints = Lists.newArrayList(source);
links.forEach(link -> {
connectPoints.add(link.src());
connectPoints.add(link.dst());
});
Collections.reverse(connectPoints);
remoteSinks.forEach(remoteSink -> {
List<ConnectPoint> finalPath = Lists.newArrayList(connectPoints);
finalPath.add(0, remoteSink);
mcastTree.put(remoteSink, finalPath);
});
});
return mcastTree;
}
use of org.onosproject.net.ConnectPoint in project trellis-control by opennetworkinglab.
the class McastHandler method processMcastEventInternal.
private void processMcastEventInternal(McastEvent event) {
lastMcastChange.set(Instant.now());
// Current subject is null, for ROUTE_REMOVED events
final McastRouteUpdate mcastUpdate = event.subject();
final McastRouteUpdate mcastPrevUpdate = event.prevSubject();
IpAddress mcastIp = mcastPrevUpdate.route().group();
Set<ConnectPoint> prevSinks = mcastPrevUpdate.sinks().values().stream().flatMap(Collection::stream).collect(Collectors.toSet());
Set<ConnectPoint> prevSources = mcastPrevUpdate.sources().values().stream().flatMap(Collection::stream).collect(Collectors.toSet());
Set<ConnectPoint> sources;
// Events handling
if (event.type() == ROUTE_ADDED) {
processRouteAddedInternal(mcastUpdate.route().group());
} else if (event.type() == ROUTE_REMOVED) {
processRouteRemovedInternal(prevSources, mcastIp);
} else if (event.type() == SOURCES_ADDED) {
// Current subject and prev just differ for the source connect points
sources = mcastUpdate.sources().values().stream().flatMap(Collection::stream).collect(Collectors.toSet());
Set<ConnectPoint> sourcesToBeAdded = Sets.difference(sources, prevSources);
processSourcesAddedInternal(sourcesToBeAdded, mcastIp, mcastUpdate.sinks());
} else if (event.type() == SOURCES_REMOVED) {
// Current subject and prev just differ for the source connect points
sources = mcastUpdate.sources().values().stream().flatMap(Collection::stream).collect(Collectors.toSet());
Set<ConnectPoint> sourcesToBeRemoved = Sets.difference(prevSources, sources);
processSourcesRemovedInternal(sourcesToBeRemoved, sources, mcastIp, mcastUpdate.sinks());
} else if (event.type() == SINKS_ADDED) {
processSinksAddedInternal(prevSources, mcastIp, mcastUpdate.sinks(), prevSinks);
} else if (event.type() == SINKS_REMOVED) {
processSinksRemovedInternal(prevSources, mcastIp, mcastUpdate.sinks(), mcastPrevUpdate.sinks());
} else {
log.warn("Event {} not handled", event);
}
}
Aggregations