@Override public void notify(PacketEvent event) { localEmit(event.subject()); }
@Override public void emit(OutboundPacket packet) { PacketProgrammable programmable = getPacketProgrammable(packet.sendThrough()); if (programmable != null) { programmable.emit(packet); } }
private void handlePacket(PacketContext context) { InboundPacket pkt = context.inPacket(); Ethernet ethPkt = pkt.parsed(); NeighbourMessageContext msgContext = DefaultNeighbourMessageContext.createContext(ethPkt, pkt.receivedFrom(), actions); if (msgContext == null) { return; } if (handleMessage(msgContext)) { context.block(); } }
/** * 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); } }
@Override public void process(PacketContext context) { if (context.isHandled()) { return; } InboundPacket pkt = context.inPacket(); Ethernet ethernet = pkt.parsed(); if (ethernet != null && ethernet.getEtherType() == Ethernet.TYPE_ARP) { arpHandler.processPacketIn(pkt, openstackPortInfoMap.values()); } } }
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); }
@Override public DefaultOutboundPacket read(Kryo kryo, Input input, Class<DefaultOutboundPacket> type) { DeviceId sendThrough = (DeviceId) kryo.readClassAndObject(input); TrafficTreatment treatment = (TrafficTreatment) kryo.readClassAndObject(input); byte[] data = (byte[]) kryo.readClassAndObject(input); return new DefaultOutboundPacket(sendThrough, treatment, ByteBuffer.wrap(data)); }
private DefaultForwardingObjective.Builder createBuilder(PacketRequest request) { TrafficTreatment treatment = DefaultTrafficTreatment.builder() .punt() .wipeDeferred() .build(); return DefaultForwardingObjective.builder() .withPriority(request.priority().priorityValue()) .withSelector(request.selector()) .fromApp(appId) .withFlag(ForwardingObjective.Flag.VERSATILE) .withTreatment(treatment) .makePermanent(); }
private void localEmit(OutboundPacket packet) { Device device = deviceService.getDevice(packet.sendThrough()); if (device == null) { return; } PacketProvider packetProvider = getProvider(device.providerId()); if (packetProvider != null) { packetProvider.emit(packet); } }
@Override public void emit(OutboundPacket packet) { if (packet != null) { DeviceId deviceId = packet.sendThrough(); Device device = deviceService.getDevice(deviceId); if (device.is(PacketProgrammable.class)) { PacketProgrammable packetProgrammable = device.as(PacketProgrammable.class); packetProgrammable.emit(packet); } else { log.info("No PacketProgrammable behavior for device {}", deviceId); } } }
@Override public void cancelPackets(TrafficSelector selector, PacketPriority priority, ApplicationId appId, Optional<DeviceId> deviceId) { checkPermission(PACKET_READ); checkNotNull(selector, ERROR_NULL_SELECTOR); checkNotNull(appId, ERROR_NULL_APP_ID); checkNotNull(deviceId, ERROR_NULL_DEVICE_ID); PacketRequest request = new DefaultPacketRequest(selector, priority, appId, localNodeId, deviceId); store.cancelPackets(request); }
@Override public void requestPackets(TrafficSelector selector, PacketPriority priority, ApplicationId appId, Optional<DeviceId> deviceId) { checkPermission(PACKET_READ); checkNotNull(selector, ERROR_NULL_SELECTOR); checkNotNull(appId, ERROR_NULL_APP_ID); checkNotNull(deviceId, ERROR_NULL_DEVICE_ID); PacketRequest request = new DefaultPacketRequest(selector, priority, appId, localNodeId, deviceId); store.requestPackets(request); }
private void cancelPackets() { packetService.cancelPackets(buildArpSelector(), CONTROL, appId); packetService.cancelPackets(buildNeighborSolicitationSelector(), CONTROL, appId); packetService.cancelPackets(buildNeighborAdvertisementSelector(), CONTROL, appId); }
@Override public void write(Kryo kryo, Output output, DefaultOutboundPacket object) { kryo.writeClassAndObject(output, object.sendThrough()); kryo.writeClassAndObject(output, object.treatment()); kryo.writeClassAndObject(output, object.data().array()); }
@Override public void requestPackets(PacketRequest request) { DeviceId deviceid = request.deviceId().orElse(null); if (deviceid != null) { Device device = deviceService.getDevice(deviceid); if (device != null) { pushRule(deviceService.getDevice(deviceid), request); } } else { pushToAllDevices(request); } }
@Override public List<PacketRequest> getRequests() { checkPermission(PACKET_READ); return store.existingRequests(); }
@Override public void emit(OutboundPacket packet) { notifyDelegate(new PacketEvent(Type.EMIT, packet)); }
@Override protected void doExecute() { PacketService service = get(PacketService.class); if (outputJson()) { print("%s", json(service.getRequests())); } else { service.getRequests().forEach(this::print); } }
@Override public void cancelPackets(TrafficSelector selector, PacketPriority priority, ApplicationId appId) { checkPermission(PACKET_READ); checkNotNull(selector, ERROR_NULL_SELECTOR); checkNotNull(appId, ERROR_NULL_APP_ID); PacketRequest request = new DefaultPacketRequest(selector, priority, appId, localNodeId, Optional.empty()); store.cancelPackets(request); }
@Override public void requestPackets(TrafficSelector selector, PacketPriority priority, ApplicationId appId) { checkPermission(PACKET_READ); checkNotNull(selector, ERROR_NULL_SELECTOR); checkNotNull(appId, ERROR_NULL_APP_ID); PacketRequest request = new DefaultPacketRequest(selector, priority, appId, localNodeId, Optional.empty()); store.requestPackets(request); }