How to use

PacketService

in

org.onosproject.net.packet

@Activate
protected void activate(ComponentContext context) {
  appId = coreService.registerApplication(APP_NAME);
  componentConfigService.registerProperties(getClass());
  modified(context);
  actions = new DefaultNeighbourMessageActions(packetService, edgeService);
  packetService.addProcessor(processor, PacketProcessor.director(1));
}

@Deactivate
public void deactivate() {
  vtnRscService.removeListener(vtnRscListener);
  packetService.removeProcessor(processor);
  log.info("Stopped");
}

@Override
public void emitPacket(DeviceId deviceId, ByteBuffer data,
            Optional<TrafficTreatment> treatment) {
  TrafficTreatment.Builder builder = treatment.map(DefaultTrafficTreatment::builder)
      .orElse(DefaultTrafficTreatment.builder());
  getEdgePoints(deviceId).forEach(p -> packetService.emit(packet(builder, p, data)));
}

private void requestPackets() {
  if (arpEnabled) {
    packetService.requestPackets(buildArpSelector(), CONTROL, appId);
  } else {
    packetService.cancelPackets(buildArpSelector(), CONTROL, appId);
  }
  if (ndpEnabled) {
    packetService.requestPackets(buildNeighborSolicitationSelector(),
        CONTROL, appId);
    packetService.requestPackets(buildNeighborAdvertisementSelector(),
        CONTROL, appId);
  } else {
    packetService.cancelPackets(buildNeighborSolicitationSelector(),
        CONTROL, appId);
    packetService.cancelPackets(buildNeighborAdvertisementSelector(),
        CONTROL, appId);
  }
}

private void cancelPackets() {
  packetService.cancelPackets(buildArpSelector(), CONTROL, appId);
  packetService.cancelPackets(buildNeighborSolicitationSelector(),
      CONTROL, appId);
  packetService.cancelPackets(buildNeighborAdvertisementSelector(),
      CONTROL, appId);
}

/**
 * Requests packet intercepts.
 */
private void requestIntercepts() {
  TrafficSelector.Builder selector = DefaultTrafficSelector.builder();
  selector.matchEthType(TYPE_LLDP);
  packetService.requestPackets(selector.build(), PacketPriority.CONTROL, appId);
  selector.matchEthType(TYPE_BSN);
  if (useBddp) {
    packetService.requestPackets(selector.build(), PacketPriority.CONTROL, appId);
  } else {
    packetService.cancelPackets(selector.build(), PacketPriority.CONTROL, appId);
  }
}

/**
 * Withdraws packet intercepts.
 */
private void withdrawIntercepts() {
  TrafficSelector.Builder selector = DefaultTrafficSelector.builder();
  selector.matchEthType(TYPE_LLDP);
  packetService.cancelPackets(selector.build(), PacketPriority.CONTROL, appId);
  selector.matchEthType(TYPE_BSN);
  packetService.cancelPackets(selector.build(), PacketPriority.CONTROL, appId);
}

@Activate
public void activate(ComponentContext context) {
  cfgService.registerProperties(getClass());
  appId = coreService.registerApplication("org.onosproject.proxyarp");
  packetService.addProcessor(processor, PacketProcessor.director(1));
  readComponentConfiguration(context);
  requestPackets();
  log.info("Started with Application ID {}", appId.id());
}

@Deactivate
public void deactivate() {
  cfgService.unregisterProperties(getClass(), false);
  withdrawIntercepts();
  packetService.removeProcessor(processor);
  processor = null;
  log.info("Stopped");
}

@Override
public void emitPacket(ByteBuffer data, Optional<TrafficTreatment> treatment) {
  checkPermission(PACKET_WRITE);
  TrafficTreatment.Builder builder = treatment.map(DefaultTrafficTreatment::builder)
      .orElse(DefaultTrafficTreatment.builder());
  getEdgePoints().forEach(p -> packetService.emit(packet(builder, p, data)));
}

    DefaultTrafficSelector.builder();
selectorBuilder.matchEthType(TYPE_ARP);
packetService.requestPackets(selectorBuilder.build(),
               CONTROL, appId);
if (ipv6NeighborDiscovery) {
  packetService.requestPackets(selectorBuilder.build(),
                 CONTROL, appId);
} else {
  packetService.cancelPackets(selectorBuilder.build(),
                CONTROL, appId);
selectorBuilder.matchIcmpv6Type(NEIGHBOR_ADVERTISEMENT);
if (ipv6NeighborDiscovery) {
  packetService.requestPackets(selectorBuilder.build(),
                 CONTROL, appId);
} else {
  packetService.cancelPackets(selectorBuilder.build(),
                CONTROL, appId);

/**
 * Cancel requested packet in via packet service.
 */
private void withdrawIntercepts() {
  TrafficSelector.Builder selectorBuilder =
      DefaultTrafficSelector.builder();
  selectorBuilder.matchEthType(TYPE_ARP);
  packetService.cancelPackets(selectorBuilder.build(), CONTROL, appId);
  selectorBuilder = DefaultTrafficSelector.builder();
  selectorBuilder.matchEthType(TYPE_IPV6);
  selectorBuilder.matchIPProtocol(PROTOCOL_ICMP6);
  selectorBuilder.matchIcmpv6Type(NEIGHBOR_SOLICITATION);
  packetService.cancelPackets(selectorBuilder.build(), CONTROL, appId);
  selectorBuilder = DefaultTrafficSelector.builder();
  selectorBuilder.matchEthType(TYPE_IPV6);
  selectorBuilder.matchIPProtocol(PROTOCOL_ICMP6);
  selectorBuilder.matchIcmpv6Type(NEIGHBOR_ADVERTISEMENT);
  packetService.cancelPackets(selectorBuilder.build(), CONTROL, appId);
}

/**
 * Enables link discovery processing.
 */
private void enable() {
  providerService = providerRegistry.register(this);
  masterService.addListener(roleListener);
  deviceService.addListener(deviceListener);
  packetService.addProcessor(packetProcessor, PacketProcessor.advisor(0));
  loadDevices();
  executor = newSingleThreadScheduledExecutor(groupedThreads("onos/link", "discovery-%d", log));
  executor.scheduleAtFixedRate(new SyncDeviceInfoTask(),
                 DEVICE_SYNC_DELAY, DEVICE_SYNC_DELAY, SECONDS);
  executor.scheduleAtFixedRate(new LinkPrunerTask(),
                 LINK_PRUNER_DELAY, LINK_PRUNER_DELAY, SECONDS);
  requestIntercepts();
}

@Deactivate
protected void deactivate() {
  cancelPackets();
  packetService.removeProcessor(processor);
  componentConfigService.unregisterProperties(getClass(), false);
}

private void sendProbes(Long portNumber) {
  if (context.packetService() == null) {
    return;
  }
  log.trace("Sending probes out to {}@{}", portNumber, device.id());
  OutboundPacket pkt = createOutBoundLldp(portNumber);
  context.packetService().emit(pkt);
  if (context.useBddp()) {
    OutboundPacket bpkt = createOutBoundBddp(portNumber);
    context.packetService().emit(bpkt);
  }
}

@Activate
protected void activate() {
  appId = coreService
      .registerApplication("org.onosproject.openstackswitching");
  packetService.addProcessor(internalPacketProcessor, PacketProcessor.director(1));
  deviceService.addListener(internalDeviceListener);
  hostService.addListener(internalHostListener);
  configRegistry.registerConfigFactory(configFactory);
  configService.addListener(configListener);
  arpHandler = new OpenstackArpHandler(openstackService, packetService, hostService);
  sgRulePopulator = new OpenstackSecurityGroupRulePopulator(appId, openstackService, flowObjectiveService);
  networkConfig.registerConfigFactory(configFactory);
  networkConfig.addListener(configListener);
  readConfiguration();
  log.info("Started");
}

@Deactivate
protected void deactivate() {
  packetService.removeProcessor(internalPacketProcessor);
  deviceService.removeListener(internalDeviceListener);
  deviceEventExecutorService.shutdown();
  configEventExecutorService.shutdown();
  hostService.removeListener(internalHostListener);
  configService.removeListener(configListener);
  configRegistry.unregisterConfigFactory(configFactory);
  log.info("Stopped");
}

private void sendPacketOut(DeviceId deviceId, PortNumber portNumber,
              Ethernet payload) {
  TrafficTreatment treatment = DefaultTrafficTreatment.builder()
      .setOutput(portNumber).build();
  OutboundPacket packet = new DefaultOutboundPacket(deviceId, treatment,
                           ByteBuffer
                               .wrap(payload
                                   .serialize()));
  packetService.emit(packet);
}

    .asDistributedSet();
packetService.addProcessor(processor, PacketProcessor.director(4));
topologyService.addListener(topologyListener);
executor = Executors.newSingleThreadScheduledExecutor();

/**
 * Disables link discovery processing.
 */
private void disable() {
  withdrawIntercepts();
  providerRegistry.unregister(this);
  masterService.removeListener(roleListener);
  deviceService.removeListener(deviceListener);
  packetService.removeProcessor(packetProcessor);
  if (executor != null) {
    executor.shutdownNow();
  }
  discoverers.values().forEach(LinkDiscovery::stop);
  discoverers.clear();
  providerService = null;
}