How to use

DeviceEvent

in

org.onosproject.net.device

@Override
public boolean isRelevant(DeviceEvent event) {
  Device device = event.subject();
  return POSITIVE_DEVICE_EVENT.contains(event.type()) &&
      device.is(GroupProgrammable.class);
}

  @Override
  public void event(DeviceEvent event) {
    if (event.type() == DeviceEvent.Type.DEVICE_REMOVED) {
      removeLinks(event.subject().id());
    } else if (event.type() == DeviceEvent.Type.PORT_REMOVED) {
      removeLinks(new ConnectPoint(event.subject().id(),
          event.port().number()));
    }
  }
}

/**
 * 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) {
  log.debug("InternalDeviceListener has got event from device-service{} with ", event);
  eventHandlingExecutor.execute(() -> triggerProbe(event.subject().id()));
}

  @Override
  public void event(DeviceEvent event) {
    DeviceEvent.Type type = event.type();
    if (type == DEVICE_ADDED || type == DEVICE_REMOVED ||
        type == DEVICE_AVAILABILITY_CHANGED) {
      processEvent(event);
    }
  }
}

private DeviceEvent createPort(Device device, Port newPort,
                Map<PortNumber, Port> ports) {
  ports.put(newPort.number(), newPort);
  return new DeviceEvent(PORT_ADDED, device, newPort);
}

@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);
  }
}

  @Override
  public void event(DeviceEvent event) {
    eventHandlingExecutor.execute(() -> {
      try {
        if (driverService == null) {
          // Event came in after the driver service shut down, nothing to be done
          return;
        }
        Device device = event.subject();
        Driver driver = driverService.getDriver(device.id());
        if (driver == null) {
          return;
        }
        if (!Boolean.parseBoolean(driver.getProperty(SUPPORT_PACKET_REQUEST_PROPERTY))) {
          return;
        }
        if (!deviceService.isAvailable(event.subject().id())) {
          return;
        }
        pushRulesToDevice(device);
      } catch (Exception e) {
        log.warn("Failed to process {}", event, e);
      }
    });
  }
}

  @Override
  public void event(DeviceEvent event) {
    if (event.type() == PORT_STATS_UPDATED) {
      return;
    }
    processDeviceEvent(event);
  }
}

private List<DeviceEvent> pruneOldPorts(Device device,
                    Map<PortNumber, Port> ports,
                    Set<PortNumber> processed) {
  List<DeviceEvent> events = new ArrayList<>();
  Iterator<Entry<PortNumber, Port>> iterator = ports.entrySet().iterator();
  while (iterator.hasNext()) {
    Entry<PortNumber, Port> e = iterator.next();
    PortNumber portNumber = e.getKey();
    if (!processed.contains(portNumber)) {
      events.add(new DeviceEvent(PORT_REMOVED, device, e.getValue()));
      iterator.remove();
    }
  }
  return events;
}

                         portDescription);
if (event != null) {
  log.info("Device {} port {} status changed", deviceId, event.port().number());
  post(event);

@Override
public boolean isRelevant(DeviceEvent event) {
  Device device = event.subject();
  return POSITIVE_DEVICE_EVENT.contains(event.type()) &&
      device.is(FlowRuleProgrammable.class);
}

DeviceEvent deviceEvent = (DeviceEvent) event;
switch (deviceEvent.type()) {
  case DEVICE_ADDED:
    log.debug("device {} is added", deviceEvent.subject().id());
    break;
  case DEVICE_AVAILABILITY_CHANGED:
    Device device = deviceEvent.subject();
    if (deviceService.isAvailable(device.id())) {
      log.debug("device {} is added", device.id());
    processPortUpdated(deviceEvent.subject(), deviceEvent.port());
    break;
  case PORT_UPDATED:
    processPortUpdated(deviceEvent.subject(), deviceEvent.port());
    break;
  case PORT_REMOVED:
    processPortRemoved(deviceEvent.port());
    break;
  default:
    log.debug("Unsupported deviceEvent type {}", deviceEvent.type().toString());
    break;

  private void handleEvent(DeviceEvent event) {
    Device device = event.subject();
    boolean isRelevant = mastershipService.isLocalMaster(device.id()) &&
        deviceService.isAvailable(device.id());
    if (isRelevant) {
      pollDeviceFlowEntries(device);
    }
  }
}

@Override
public boolean isRelevant(DeviceEvent event) {
  return event.type() == DeviceEvent.Type.DEVICE_ADDED ||
      event.type() == DeviceEvent.Type.DEVICE_AVAILABILITY_CHANGED;
}

@Override
public DeviceEvent removeDevice(DeviceId deviceId) {
  Map<ProviderId, DeviceDescriptions> descs = getOrCreateDeviceDescriptions(deviceId);
  synchronized (descs) {
    Device device = devices.remove(deviceId);
    // should DEVICE_REMOVED carry removed ports?
    Map<PortNumber, Port> ports = devicePorts.get(deviceId);
    if (ports != null) {
      ports.clear();
    }
    availableDevices.remove(deviceId);
    descs.clear();
    return device == null ? null :
        new DeviceEvent(DEVICE_REMOVED, device, null);
  }
}

@Override
public boolean isRelevant(DeviceEvent event) {
  Device device = event.subject();
  return POSITIVE_DEVICE_EVENT.contains(event.type()) &&
      device.is(MeterProgrammable.class);
}

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()));
  }
}

  private void handleEvent(DeviceEvent event) {
    Device device = event.subject();
    boolean isRelevant = mastershipService.isLocalMaster(device.id()) &&
        deviceService.isAvailable(device.id());
    if (isRelevant) {
      pollDeviceGroups(device.id());
    }
  }
}

  @Override
  public void event(DeviceEvent event) {
    if (event.type() == Type.PORT_STATS_UPDATED) {
      return;
    }
    Runnable deviceEventProcessor = new DeviceEventProcessor(event);
    eventExecutor.execute(deviceEventProcessor);
  }
}