How to use

emit

method

in

org.onosproject.net.packet.PacketService

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

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

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

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

  /**
   * Send packet back to classifier.
   *
   * @param context packet context
   */
  private void sendPacket(PacketContext context) {
    ConnectPoint sourcePoint = context.inPacket().receivedFrom();
    TrafficTreatment treatment = DefaultTrafficTreatment.builder().setOutput(PortNumber.TABLE).build();
    OutboundPacket packet = new DefaultOutboundPacket(sourcePoint.deviceId(), treatment, context.inPacket()
        .unparsed());
    packetService.emit(packet);
    log.trace("Sending packet: {}", packet);
  }
}

/**
 * Outputs a packet out a specific port.
 *
 * @param packet packet to send
 * @param outPort port to send it out
 */
private void sendTo(ByteBuffer packet, ConnectPoint outPort) {
  if (!edgeService.isEdgePoint(outPort)) {
    // Sanity check to make sure we don't send the packet out an
    // internal port and create a loop (could happen due to
    // misconfiguration).
    return;
  }
  TrafficTreatment.Builder builder = DefaultTrafficTreatment.builder();
  builder.setOutput(outPort.port());
  packetService.emit(new DefaultOutboundPacket(outPort.deviceId(),
      builder.build(), packet));
}

               ByteBuffer.wrap(probePacket.serialize()));
packetService.emit(outboundPacket);

    .build();
packetService.emit(new DefaultOutboundPacket(
    pkt.receivedFrom().deviceId(),
    treatment,