/** * Merges the appropriate PortConfig with the description. * * @param did ID of the Device where the port is attached * @param desc {@link PortDescription} * @return merged {@link PortDescription} */ private PortDescription applyAllPortOps(DeviceId did, PortDescription desc) { return applyAllPortOps(new ConnectPoint(did, desc.portNumber()), desc); }
private void kickOutBadDevice(DeviceId deviceId) { Device badDevice = getDevice(deviceId); if (badDevice != null) { removeDevice(deviceId); } } }
private boolean isReachable(DeviceId deviceId) { if (deviceId == null) { return false; } DeviceProvider provider = getProvider(deviceId); if (provider != null) { boolean reachable = provider.isReachable(deviceId); if (reachable && !isLocallyConnected(deviceId)) { deviceLocalStatus.put(deviceId, new LocalStatus(true, Instant.now())); } else if (!reachable && isLocallyConnected(deviceId)) { deviceLocalStatus.put(deviceId, new LocalStatus(false, Instant.now())); } return reachable; } else { log.debug("Provider not found for {}", deviceId); return false; } }
final Device device = getDevice(did); if (device != null && !isAvailable(did) && canMarkOnline(device)) { post(store.markOnline(did)); if (!applyRoleAndProbe(did, MASTER)) { log.warn("Unsuccessful applying role {} to {}", myNextRole, did); case STANDBY: log.debug("Applying role {} to {}", myNextRole, did); if (!applyRoleAndProbe(did, STANDBY)) { log.warn("Unsuccessful applying role {} to {}", myNextRole, did);
for (Device device : getDevices()) { final DeviceId deviceId = device.id(); MastershipRole myRole = mastershipService.getLocalRole(deviceId); log.trace("Checking device {}. Current role is {}", deviceId, myRole); if (!isReachable(deviceId)) { if (myRole != NONE) { if (myRole == MASTER) { log.info("Local Role {}, Marking unreachable device {} offline", MASTER, deviceId); post(store.markOffline(deviceId)); if (master == null && isAvailable(deviceId)) { CompletableFuture<MastershipRole> roleFuture = mastershipService.requestRoleFor(deviceId); roleFuture.thenAccept(role -> { if (term != null && localNodeId.equals(term.master())) { log.info("Marking unreachable device {} offline", deviceId); post(store.markOffline(deviceId)); } else { log.info("Failed marking {} offline. {}", deviceId, role); post(store.markOnline(deviceId)); reassertRole(deviceId, NONE);
ProviderId pid = Optional.ofNullable(getProvider(did)) .map(Provider::id) .orElse(null); .map(pdesc -> applyAllPortOps(did, pdesc)) .collect(Collectors.toList()); return store.updatePorts(pid, did, pds);
final boolean isReachable = isReachable(did); if (!isReachable) { reassertRole(did, myNextRole); } else { log.debug("Device is not yet/no longer in the store: {}", did);
@Override public void deletePort(DeviceId deviceId, PortDescription basePortDescription) { checkNotNull(deviceId, DEVICE_ID_NULL); checkNotNull(basePortDescription, PORT_DESCRIPTION_NULL); checkValidity(); if (!mastershipService.isLocalMaster(deviceId)) { // Never been a master for this device // any update will be ignored. log.trace("Ignoring {} port update on standby node. {}", deviceId, basePortDescription); return; } Device device = getDevice(deviceId); if (device == null) { log.trace("Device not found: {}", deviceId); } PortDescription newPortDescription = DefaultPortDescription.builder(basePortDescription) .isRemoved(true) .build(); final DeviceEvent event = store.updatePortStatus(this.provider().id(), deviceId, newPortDescription); if (event != null) { log.info("Device {} port {} status changed", deviceId, event.port().number()); post(event); } }
private void handlePortRequest(InternalPortUpDownEvent event) { DeviceId deviceId = event.deviceId(); checkNotNull(deviceId, DEVICE_ID_NULL); checkNotNull(deviceId, PORT_NUMBER_NULL); checkState(mastershipService.isLocalMaster(deviceId), EVENT_NON_MASTER); changePortStateAtMaster(event.deviceId(), event.portNumber(), event.isEnable()); }
private void changePortStateAtMaster(DeviceId deviceId, PortNumber portNumber, boolean enable) { DeviceProvider provider = getProvider(deviceId); if (provider != null) { log.info("Port {} on device {} being administratively brought {}", portNumber, deviceId, (enable) ? "UP" : "DOWN"); provider.changePortState(deviceId, portNumber, enable); } else { log.warn("Provider not found for {}", deviceId); } }
kickOutBadDevice(did); } else { Device dev = getDevice(did); DeviceDescription desc = (dev == null) ? null : BasicDeviceOperator.descriptionOf(dev); DeviceProvider dp = getProvider(did); if (!event.config().isPresent() || getDevice(did) == null || dp == null) { DeviceId did = (DeviceId) event.subject(); DeviceProvider dp = getProvider(did); Device dev = getDevice(did); DeviceDescription desc = (dev == null) ? null : BasicDeviceOperator.descriptionOf(dev);
@Override public void changePortState(DeviceId deviceId, PortNumber portNumber, boolean enable) { checkNotNull(deviceId, DEVICE_ID_NULL); checkNotNull(deviceId, PORT_NUMBER_NULL); NodeId masterId = mastershipService.getMasterFor(deviceId); if (masterId == null) { // No master found; device is offline log.info("No master found for port state change for {}", deviceId); return; } if (!masterId.equals(localNodeId)) { //Send the request to the master node for the device log.info("Device {} is managed by {}, forwarding the request to the MASTER", deviceId, masterId); communicationService.unicast( new InternalPortUpDownEvent(deviceId, portNumber, enable), PORT_UPDOWN_SUBJECT, SERIALIZER::encode, masterId).whenComplete((r, error) -> { if (error != null) { log.warn("Failed to send packet-updown-req to {}", masterId, error); } }); } else { changePortStateAtMaster(deviceId, portNumber, enable); } }
/** * Apply role to device and send probe if MASTER. * * @param deviceId device identifier * @param newRole new role to apply to the device * @return true if the request was sent to provider */ private boolean applyRoleAndProbe(DeviceId deviceId, MastershipRole newRole) { if (newRole.equals(MastershipRole.NONE)) { //no-op return true; } DeviceProvider provider = getProvider(deviceId); if (provider == null) { log.warn("Provider for {} was not found. Cannot apply role {}", deviceId, newRole); return false; } provider.roleChanged(deviceId, newRole); if (newRole.equals(MastershipRole.MASTER)) { log.debug("sent TriggerProbe({})", deviceId); // only trigger event when request was sent to provider provider.triggerProbe(deviceId); } return true; }
return; Device device = getDevice(deviceId); if (device == null) { log.trace("Device not found: {}", deviceId);