private void sendNotification(OfHeader message, String messageClass) { TranslatorKey key = new TranslatorKey(message.getVersion(), messageClass); if (messageTranslators.containsKey(key)) { for (IMDMessageTranslator<OfHeader, List<DataObject>> translator : messageTranslators.get(key)) { List<DataObject> list = translator.translate(null, sc, message); for (DataObject dataObj : list) { notificationProviderService.offerNotification((Notification) dataObj); } } } }
Class<? extends DataContainer> messageType = ticket.getMessage().getImplementedInterface(); ConnectionConductor conductor = ticket.getConductor(); Collection<IMDMessageTranslator<OfHeader, List<DataObject>>> translators = null; LOG.trace("translating ticket: {}, ticket: {}", messageType.getSimpleName(), System.identityHashCode(ticket)); Short version = message.getVersion(); if (version == null) { throw new IllegalArgumentException("version is NULL");
/** * @param message * @return */ private static RpcResponseKey createRpcResponseKey(final OfHeader message) { return new RpcResponseKey(message.getXid(), message.getImplementedInterface().getName()); }
@Override public void push(OfHeader message, ConnectionConductor conductor, QueueKeeper.QueueType queueType) { QueueItemOFImpl qItem = new QueueItemOFImpl(message, conductor, queueType); boolean enqueued = false; switch (queueType) { case DEFAULT: enqueued = queueDefault.offer(qItem); break; case UNORDERED: enqueued = queueUnordered.offer(qItem); break; default: LOG.warn("unsupported queue type: [{}] -> dropping message [{}]", queueType, message.getImplementedInterface()); } if (enqueued) { harvesterHandle.ping(); } else { LOG.debug("ingress throttling is use -> {}", queueType); } // if enqueueing fails -> message will be dropped }
private static boolean completeEntry(final OutboundQueueEntry entry, final OfHeader response) { if (response instanceof Error) { final Error err = (Error)response; LOG.debug("Device-reported request XID {} failed {}:{}", response.getXid(), err.getTypeString(), err.getCodeString()); entry.fail(new DeviceRequestFailedException("Device-side failure", err)); return true; } return entry.complete(response); }
@Override public void run() { LOG.debug("message received, type: {}", ticket.getMessage().getImplementedInterface().getSimpleName()); List<DataObject> translate; try { translate = translate(ticket); ticket.getResult().set(translate); ticket.setDirectResult(translate); // spying on result if (spy != null) { spy.spyIn(ticket.getMessage()); for (DataObject outMessage : translate) { spy.spyOut(outMessage); } } } catch (Exception e) { LOG.warn("translation problem: {}", e.getMessage()); ticket.getResult().setException(e); } LOG.debug("message processing done (type: {}, ticket: {})", ticket.getMessage().getImplementedInterface().getSimpleName(), System.identityHashCode(ticket)); } };
/** * sends given message to switch, sending result or switch response will be reported via return value * * @param input message to send * @param responseClazz type of response * @param failureInfo describes, what type of message caused failure by sending * @return future object, * <ul> * <li>if send fails, {@link RpcResult} will contain errors and failed status</li> * <li>else {@link RpcResult} will be stored in responseCache and wait for particular timeout ( * {@link ConnectionAdapterImpl#RPC_RESPONSE_EXPIRATION}), * <ul> * <li>either switch will manage to answer and then corresponding response message will be set into returned * future</li> * <li>or response in cache will expire and returned future will be cancelled</li> * </ul> * </li> * </ul> */ protected <IN extends OfHeader, OUT extends OfHeader> ListenableFuture<RpcResult<OUT>> sendToSwitchExpectRpcResultFuture( final IN input, final Class<OUT> responseClazz, final String failureInfo) { final RpcResponseKey key = new RpcResponseKey(input.getXid(), responseClazz.getName()); final ResponseExpectedRpcListener<OUT> listener = new ResponseExpectedRpcListener<>(input, failureInfo, responseCache, key); return enqueueMessage(listener); }
@Override public List<DataObject> translate(SwitchConnectionDistinguisher cookie, SessionContext sc, OfHeader msg) { if (msg instanceof GetFeaturesOutput) { GetFeaturesOutput features = (GetFeaturesOutput) msg; List<DataObject> list = new CopyOnWriteArrayList<DataObject>(); BigInteger datapathId = sc.getFeatures().getDatapathId(); if( features.getPhyPort() != null ) { for (PhyPort port : features.getPhyPort()) { list.add(PortTranslatorUtil.translatePort(msg.getVersion(), datapathId, port.getPortNo(), port)); } } return list; } else { // TODO - Do something smarter than returning null if translation fails... what Exception should we throw here? return Collections.emptyList(); } } }
@Override public void directProcessQueueItem(QueueItem<OfHeader> queueItem) { messageSpy.spyMessage(queueItem.getMessage(), STATISTIC_GROUP.FROM_SWITCH_ENQUEUED); TicketImpl<OfHeader, DataObject> ticket = new TicketImpl<>(); ticket.setConductor(queueItem.getConnectionConductor()); ticket.setMessage(queueItem.getMessage()); LOG.debug("ticket scheduling: {}, ticket: {}", queueItem.getMessage().getImplementedInterface().getSimpleName(), System.identityHashCode(queueItem)); ticketProcessorFactory.createProcessor(ticket).run(); // publish notification finisher.firePopNotification(ticket.getDirectResult()); }
OutboundQueueEntry pairRequest(final OfHeader response) { // Explicitly 'long' to force unboxing before performing operations final long xid = response.getXid(); if (!xidInRange(xid)) { LOG.debug("Queue {} {}/{} ignoring XID {}", this, baseXid, entries.length, xid); return null; } final int offset = (int) (xid - baseXid); final OutboundQueueEntry entry = entries[offset]; if (entry.isCompleted()) { LOG.debug("Entry {} already is completed, not accepting response {}", entry, response); return null; } if (entry.isBarrier()) { // This has been a barrier -- make sure we complete all preceding requests. // XXX: Barriers are expected to complete in one message. // If this assumption is changed, this logic will need to be expanded // to ensure that the requests implied by the barrier are reported as // completed *after* the barrier. LOG.trace("Barrier XID {} completed, cascading completion to XIDs {} to {}", xid, baseXid + lastBarrierOffset + 1, xid - 1); completeRequests(offset); lastBarrierOffset = offset; final boolean success = completeEntry(entry, response); Verify.verify(success, "Barrier request failed to complete"); completeCount++; } else if (completeEntry(entry, response)) { completeCount++; } return entry; }
@Override public List<DataObject> translate(SwitchConnectionDistinguisher cookie, SessionContext sc, OfHeader msg) { if(msg instanceof MultipartReply && ((MultipartReply) msg).getType() == MultipartType.OFPMPPORTDESC) { BigInteger datapathId = sc.getFeatures().getDatapathId(); LOG.trace("MultiPartReplyPortToNodeConnectorUpdatedTranslator Being translated to NodeConnectorUpdated "); MultipartReplyMessage message = (MultipartReplyMessage) msg; MultipartReplyPortDescCase caseBody = (MultipartReplyPortDescCase) message.getMultipartReplyBody(); MultipartReplyPortDesc body = caseBody.getMultipartReplyPortDesc(); List<DataObject> list = new CopyOnWriteArrayList<DataObject>(); for ( Ports port : body.getPorts() ) { LOG.debug("Port: " + port); list.add(PortTranslatorUtil.translatePort(msg.getVersion(), datapathId, port.getPortNo(), port)); } return list; } else { return Collections.emptyList(); } }
@Override public void enqueueQueueItem(QueueItem<OfHeader> queueItem) { messageSpy.spyMessage(queueItem.getMessage(), STATISTIC_GROUP.FROM_SWITCH_ENQUEUED); TicketImpl<OfHeader, DataObject> ticket = new TicketImpl<>(); ticket.setConductor(queueItem.getConnectionConductor()); ticket.setMessage(queueItem.getMessage()); ticket.setQueueType(queueItem.getQueueType()); LOG.trace("ticket scheduling: {}, ticket: {}", queueItem.getMessage().getImplementedInterface().getSimpleName(), System.identityHashCode(queueItem)); scheduleTicket(ticket); }
@Override protected void encode(ChannelHandlerContext ctx, UdpMessageListenerWrapper wrapper, List<Object> out) throws Exception { LOG.trace("Encoding"); try { ByteBuf buffer = PooledByteBufAllocator.DEFAULT.buffer(); serializationFactory.messageToBuffer(wrapper.getMsg().getVersion(), buffer, wrapper.getMsg()); out.add(new DatagramPacket(buffer, wrapper.getAddress())); } catch(Exception e) { LOG.warn("Message serialization failed: {}", e.getMessage()); Future<Void> newFailedFuture = ctx.newFailedFuture(e); wrapper.getListener().operationComplete(newFailedFuture); return; } }
PacketInMessage message = (PacketInMessage)msg; LOG.trace("PacketIn[v{}]: InPort: {}", msg.getVersion(), message.getInPort());
@Override protected void encode(final ChannelHandlerContext ctx, final MessageListenerWrapper wrapper, final ByteBuf out) throws Exception { LOG.trace("Encoding"); try { serializationFactory.messageToBuffer(wrapper.getMsg().getVersion(), out, wrapper.getMsg()); if(wrapper.getMsg() instanceof FlowModInput){ statisticsCounters.incrementCounter(CounterEventTypes.DS_FLOW_MODS_SENT); } statisticsCounters.incrementCounter(CounterEventTypes.DS_ENCODE_SUCCESS); } catch(final Exception e) { LOG.warn("Message serialization failed ", e); statisticsCounters.incrementCounter(CounterEventTypes.DS_ENCODE_FAIL); if (wrapper.getListener() != null) { final Future<Void> newFailedFuture = ctx.newFailedFuture(e); wrapper.getListener().operationComplete(newFailedFuture); } out.clear(); return; } }
switch (mpReply.getType()){ case OFPMPFLOW: { logger.debug("Received flow statistics reponse from openflow {} switch",msg.getVersion()==1?"1.0":"1.3+"); FlowsStatisticsUpdateBuilder message = new FlowsStatisticsUpdateBuilder(); message.setId(node); logger.debug("Received aggregate flow statistics reponse from openflow {} switch",msg.getVersion()==1?"1.0":"1.3+"); AggregateFlowStatisticsUpdateBuilder message = new AggregateFlowStatisticsUpdateBuilder(); message.setId(node); logger.debug("Received flow table statistics reponse from openflow {} switch",msg.getVersion()==1?"1.0":"1.3+");