How to use

type

method

in

org.onosproject.net.device.DeviceEvent

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

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

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