@Override protected PacketProviderService createProviderService(PacketProvider provider) { return new InternalPacketProviderService(provider); }
/** * Removes packet request flow rule from all devices. * * @param request the packet request */ private void removeFromAllDevices(PacketRequest request) { deviceService.getAvailableDevices().forEach(d -> removeRule(d, request)); }
@Override public void addProcessor(PacketProcessor processor, int priority) { checkPermission(PACKET_EVENT); checkNotNull(processor, ERROR_NULL_PROCESSOR); ProcessorEntry entry = new ProcessorEntry(processor, priority); // Insert the new processor according to its priority. int i = 0; for (; i < processors.size(); i++) { if (priority < processors.get(i).priority()) { break; } } processors.add(i, entry); }
@Activate public void activate() { eventHandlingExecutor = Executors.newSingleThreadExecutor( groupedThreads("onos/net/packet", "event-handler", log)); localNodeId = clusterService.getLocalNode().id(); appId = coreService.getAppId(CoreService.CORE_APP_NAME); store.setDelegate(delegate); deviceService.addListener(deviceListener); defaultProvider.init(deviceService); store.existingRequests().forEach(request -> { if (request.deviceId().isPresent()) { Device device = deviceService.getDevice(request.deviceId().get()); if (device != null) { pushRule(device, request); } else { log.info("Device is not ready yet; not processing packet request {}", request); } } else { pushToAllDevices(request); } }); log.info("Started"); }
@Override public void processPacket(PacketContext context) { // TODO filter packets sent to processors based on registrations for (ProcessorEntry entry : processors) { try { if (log.isTraceEnabled()) { log.trace("Starting packet processing by {}", entry.processor().getClass().getName()); } long start = System.nanoTime(); entry.processor().process(context); entry.addNanos(System.nanoTime() - start); if (log.isTraceEnabled()) { log.trace("Finished packet processing by {}", entry.processor().getClass().getName()); } } catch (Exception e) { log.warn("Packet processor {} threw an exception", entry.processor(), e); } } }
/** * Removes packet intercept flow rules from the device. * * @param device the device to remove the rules deom * @param request the packet request */ private void removeRule(Device device, PacketRequest request) { if (!device.type().equals(Device.Type.SWITCH)) { return; } ForwardingObjective forwarding = createBuilder(request) .remove(new ObjectiveContext() { @Override public void onError(Objective objective, ObjectiveError error) { log.warn("Failed to withdraw packet request {} from {}: {}", request, device.id(), error); } }); objectiveService.forward(device.id(), forwarding); }
/** * Pushes all rules to the specified device. * * @param device device on which to install packet request flows */ private void pushRulesToDevice(Device device) { log.debug("Pushing packet requests to device {}", device.id()); for (PacketRequest request : store.existingRequests()) { if (!request.deviceId().isPresent()) { pushRule(device, request); } else if (request.deviceId().get().equals(device.id())) { pushRule(device, request); } } }
@Override public void removeProcessor(PacketProcessor processor) { checkPermission(PACKET_EVENT); checkNotNull(processor, ERROR_NULL_PROCESSOR); // Remove the processor entry. for (int i = 0; i < processors.size(); i++) { if (processors.get(i).processor() == processor) { processors.remove(i); break; } } }
@Override public void emit(OutboundPacket packet) { PacketProgrammable programmable = getPacketProgrammable(packet.sendThrough()); if (programmable != null) { programmable.emit(packet); } }
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); } }
/** * Pushes packet intercept flow rules to the device. * * @param device the device to push the rules to * @param request the packet request */ private void pushRule(Device device, PacketRequest request) { if (!device.type().equals(Device.Type.SWITCH)) { return; } if (!deviceService.isAvailable(device.id())) { return; } ForwardingObjective forwarding = createBuilder(request) .add(new ObjectiveContext() { @Override public void onError(Objective objective, ObjectiveError error) { log.warn("Failed to install packet request {} to {}: {}", request, device.id(), error); } }); objectiveService.forward(device.id(), forwarding); }
/** * Pushes a packet request flow rule to all devices. * * @param request the packet request */ private void pushToAllDevices(PacketRequest request) { log.debug("Pushing packet request {} to all devices", request); for (Device device : deviceService.getDevices()) { try { Driver driver = driverService.getDriver(device.id()); if (driver != null && Boolean.parseBoolean(driver.getProperty(SUPPORT_PACKET_REQUEST_PROPERTY))) { pushRule(device, request); } } catch (ItemNotFoundException e) { log.warn("Device driver not found for {}; not processing packet request {}", device.id(), request); } } }