@Override public void event(DeviceEvent event) { DeviceEvent.Type type = event.type(); if (type == DEVICE_ADDED || type == DEVICE_REMOVED || type == DEVICE_AVAILABILITY_CHANGED) { processEvent(event); } } }
@Override public void event(DeviceEvent event) { if (event.type() == PORT_STATS_UPDATED) { return; } processDeviceEvent(event); } }
@Override public void event(DeviceEvent event) { if (event.type() == Type.PORT_STATS_UPDATED) { return; } Runnable deviceEventProcessor = new DeviceEventProcessor(event); eventExecutor.execute(deviceEventProcessor); } }
@Override public boolean isRelevant(DeviceEvent event) { Device device = event.subject(); return POSITIVE_DEVICE_EVENT.contains(event.type()) && device.is(GroupProgrammable.class); }
@Override public boolean isRelevant(DeviceEvent event) { Device device = event.subject(); return POSITIVE_DEVICE_EVENT.contains(event.type()) && device.is(MeterProgrammable.class); }
@Override public boolean isRelevant(DeviceEvent event) { Device device = event.subject(); return POSITIVE_DEVICE_EVENT.contains(event.type()) && device.is(FlowRuleProgrammable.class); }
@Override public void notify(DeviceEvent event) { post(event); if (event.type().equals(DeviceEvent.Type.DEVICE_REMOVED)) { // When device is administratively removed, force disconnect. DeviceId deviceId = event.subject().id(); deviceLocalStatus.remove(deviceId); DeviceProvider provider = getProvider(deviceId); if (provider != null) { log.info("Triggering disconnect for device {}", deviceId); try { provider.triggerDisconnect(deviceId); } catch (UnsupportedOperationException e) { log.warn("Unable to trigger disconnect due to {}", e.getMessage()); } } } } }
private void processEventInternal(DeviceEvent event) { switch (event.type()) { case DEVICE_REMOVED: case DEVICE_AVAILABILITY_CHANGED: DeviceId deviceId = event.subject().id(); if (!deviceService.isAvailable(deviceId)) { log.debug("Device {} became unavailable for {}; clearing initial audit status", deviceId, event.type()); store.deviceInitialAuditCompleted(deviceId, false); if (purgeOnDisconnection) { store.purgeGroupEntry(deviceId); } } break; default: break; } } }
@Override public void event(DeviceEvent event) { DeviceEvent.Type type = event.type(); DeviceId deviceId = event.subject().id(); if (type == PORT_STATS_UPDATED) { // Update port load updateDeviceData(deviceId); } else if (type == DEVICE_REMOVED || (type == DEVICE_AVAILABILITY_CHANGED && !deviceService.isAvailable(deviceId))) { // Clean-up all port loads pruneDeviceData(deviceId); } } }
@Override public void event(DeviceEvent event) { DeviceEvent.Type type = event.type(); switch (type) { case DEVICE_ADDED: case DEVICE_AVAILABILITY_CHANGED: case DEVICE_REMOVED: case DEVICE_SUSPENDED: case DEVICE_UPDATED: DeviceId id = event.subject().id(); // TODO we need to check whether AVAILABILITY_CHANGED means up or down boolean available = (type == DeviceEvent.Type.DEVICE_AVAILABILITY_CHANGED || type == DeviceEvent.Type.DEVICE_ADDED || type == DeviceEvent.Type.DEVICE_UPDATED); executorService.execute(new DeviceAvailabilityHandler(id, available)); break; case PORT_ADDED: case PORT_REMOVED: case PORT_UPDATED: case PORT_STATS_UPDATED: default: // Don't handle port events for now break; } } }
@Override public boolean isRelevant(DeviceEvent event) { return event.type().equals(DeviceEvent.Type.DEVICE_AVAILABILITY_CHANGED) && deviceService.isAvailable(event.subject().id()); }
@Override public void event(DeviceEvent event) { switch (event.type()) { case DEVICE_ADDED: case DEVICE_AVAILABILITY_CHANGED: if (deviceService.isAvailable(event.subject().id())) { DeviceId deviceId = event.subject().id(); CompletableFuture<DeviceId> future = devices.get(deviceId); if (future != null) { future.complete(deviceId); } } break; case DEVICE_UPDATED: case DEVICE_REMOVED: case DEVICE_SUSPENDED: case PORT_ADDED: case PORT_UPDATED: case PORT_REMOVED: default: break; } } }
@Override public void event(DeviceEvent event) { switch (event.type()) { case DEVICE_REMOVED: case DEVICE_AVAILABILITY_CHANGED: DeviceId deviceId = event.subject().id(); if (!deviceService.isAvailable(deviceId)) { if (purgeOnDisconnection) { store.purgeFlowRule(deviceId); } } break; default: break; } } }
/** * Transform Port instance on the event to Optical specific port, if it is well-formed. * * @param event original event to transform * @return transformed {@link DeviceEvent} */ public DeviceEvent augment(DeviceEvent event) { final Port port = augment(event.port()); if (port == event.port()) { // If the Port not changed, pass through return event; } return new DeviceEvent(event.type(), event.subject(), port, event.time()); }
@Override public void event(DeviceEvent event) { final Device device = event.subject(); switch (event.type()) { case DEVICE_ADDED: case DEVICE_UPDATED: case DEVICE_AVAILABILITY_CHANGED: if (!deviceService.isAvailable(device.id())) { signalStatusUnknown(device.id()); } break; case DEVICE_REMOVED: case DEVICE_SUSPENDED: signalStatusUnknown(device.id()); break; case PORT_ADDED: case PORT_UPDATED: case PORT_REMOVED: case PORT_STATS_UPDATED: default: break; } } }
@Override public void event(DeviceEvent event) { switch (event.type()) { case DEVICE_ADDED: case DEVICE_AVAILABILITY_CHANGED: if (deviceService.isAvailable(event.subject().id())) { log.info("Device connected {}", event.subject().id()); if (event.subject().id().equals(deviceId)) { updateDevice(); } } break; // TODO other cases case DEVICE_UPDATED: case DEVICE_REMOVED: case DEVICE_SUSPENDED: case PORT_ADDED: case PORT_UPDATED: case PORT_REMOVED: default: break; } } }
@Override public void event(DeviceEvent event) { if (controlPlaneConnectPoint != null && event.subject().id().equals(controlPlaneConnectPoint.deviceId())) { switch (event.type()) { case DEVICE_ADDED: case DEVICE_AVAILABILITY_CHANGED: if (deviceService.isAvailable(event.subject().id())) { log.info("Device connected {}", event.subject().id()); updateDevice(); } break; case DEVICE_UPDATED: case DEVICE_REMOVED: case DEVICE_SUSPENDED: case PORT_ADDED: case PORT_UPDATED: case PORT_REMOVED: default: break; } } } }
private void processDeviceEvent(DeviceEvent event) { //FIXME handle the case where a device is suspended, this may or may not come up DeviceEvent.Type type = event.type(); DeviceId id = event.subject().id(); if (type == DEVICE_ADDED || type == DEVICE_AVAILABILITY_CHANGED && deviceService.isAvailable(id)) { // When device is added or becomes available, add all its ports deviceService.getPorts(event.subject().id()) .forEach(p -> addEdgePort(new ConnectPoint(id, p.number()))); } else if (type == DEVICE_REMOVED || type == DEVICE_AVAILABILITY_CHANGED && !deviceService.isAvailable(id)) { // When device is removed or becomes unavailable, remove all its ports. // Note: cannot rely on Device subsystem, ports may be gone. Optional.ofNullable(connectionPoints.remove(id)) .orElse(ImmutableSet.of()) .forEach(point -> post(new EdgePortEvent(EDGE_PORT_REMOVED, point))); } else if (type == DeviceEvent.Type.PORT_ADDED || type == PORT_UPDATED && event.port().isEnabled()) { addEdgePort(new ConnectPoint(id, event.port().number())); } else if (type == DeviceEvent.Type.PORT_REMOVED || type == PORT_UPDATED && !event.port().isEnabled()) { removeEdgePort(new ConnectPoint(id, event.port().number())); } }