@Override public void registerErrorDeserializer(final ExperimenterIdDeserializerKey key, final OFDeserializer<ErrorMessage> deserializer) { deserializerRegistry.registerDeserializer(key, deserializer); }
@Override public boolean unregisterDeserializer(final ExperimenterDeserializerKey key) { return deserializerRegistry.unregisterDeserializer((MessageCodeKey) key); }
public void sendToSwitch(ConnectionAdapter connectionAdapter, ByteBuf input, short ofVersion, ZeroMQBaseConnector coreConnector, long datapathId, int moduleId) { DeserializationFactory factory = createDeserializationFactory(); DeserializerRegistry registry = new DeserializerRegistryImpl(); registry.init(); factory.setRegistry(registry); DataObject msg = factory.deserialize(input, ofVersion); sendDataObjectToSwitch(connectionAdapter, msg, ofVersion, coreConnector, datapathId, moduleId); }
/** * Deserializes items into list * @param version openflow wire version * @param length length of list in ByteBuf (bytes) * @param input input buffer * @param keyMaker creates keys for deserializer lookup * @param registry stores deserializers * @return list of items */ public static <E extends DataObject> List<E> deserializeList(short version, int length, ByteBuf input, CodeKeyMaker keyMaker, DeserializerRegistry registry) { List<E> items = null; if (input.readableBytes() > 0) { items = new ArrayList<>(); int startIndex = input.readerIndex(); while ((input.readerIndex() - startIndex) < length){ OFDeserializer<E> deserializer = registry.getDeserializer(keyMaker.make(input)); E item = deserializer.deserialize(input); items.add(item); } } return items; }
/** Constructor */ public SwitchConnectionProviderImpl() { serializerRegistry = new SerializerRegistryImpl(); serializerRegistry.init(); serializationFactory = new SerializationFactory(); serializationFactory.setSerializerTable(serializerRegistry); deserializerRegistry = new DeserializerRegistryImpl(); deserializerRegistry.init(); deserializationFactory = new DeserializationFactory(); deserializationFactory.setRegistry(deserializerRegistry); }
MessageCodeKey key = keyMaker.make(input); try { deserializer = registry.getDeserializer(key); } catch (ClassCastException | IllegalStateException e) {
/** * To openflow message. * * @param message * the message * @return the openflow message */ private static OpenFlowMessage toOpenFlowMessage(Message message) { if (message.getHeader().getMessageType() != MessageType.OPENFLOW) throw new IllegalArgumentException("Can only convert OPENFLOW messages"); ByteBuf buffer = Unpooled.wrappedBuffer(message.getPayload()); short ofVersion = buffer.readUnsignedByte(); OpenFlowMessage ofm = new OpenFlowMessage(ofVersion); ofm.setPayload(message.getPayload()); ofm.setHeader(message.header); // DESERIALIZATION DeserializerRegistry registry = new DeserializerRegistryImpl(); registry.init(); DeserializationFactory factory = new DeserializationFactory(); factory.setRegistry(registry); DataObject dObj = factory.deserialize(buffer, ofVersion); ofm.setOfMessage(dObj); return ofm; }
/** * Transforms ByteBuf into correct POJO message * * @param rawMessage * @param version * version decoded from OpenFlow protocol message * @return correct POJO as DataObject */ public DataObject deserialize(final ByteBuf rawMessage, final short version) { DataObject dataObject = null; int type = rawMessage.readUnsignedByte(); Class<?> clazz = messageClassMap.get(new TypeToClassKey(version, type)); rawMessage.skipBytes(EncodeConstants.SIZE_OF_SHORT_IN_BYTES); OFDeserializer<DataObject> deserializer = registry.getDeserializer(new MessageCodeKey(version, type, clazz)); dataObject = deserializer.deserialize(rawMessage); return dataObject; }
@Override public void registerMultipartReplyTFDeserializer(final ExperimenterIdDeserializerKey key, final OFGeneralDeserializer deserializer) { deserializerRegistry.registerDeserializer(key, deserializer); }
@Override public Action deserialize(ByteBuf input) { org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.action.rev150203.actions.grouping.ActionBuilder builder = new ActionBuilder(); int startIndex = input.readerIndex(); input.skipBytes(2 * EncodeConstants.SIZE_OF_SHORT_IN_BYTES); SetFieldCaseBuilder caseBuilder = new SetFieldCaseBuilder(); SetFieldActionBuilder actionBuilder = new SetFieldActionBuilder(); int oxmClass = input.getUnsignedShort(input.readerIndex()); // get oxm_field & hasMask byte and extract the field value int oxmField = input.getUnsignedByte(input.readerIndex() + EncodeConstants.SIZE_OF_SHORT_IN_BYTES) >>> 1; MatchEntryDeserializerKey key = new MatchEntryDeserializerKey(EncodeConstants.OF13_VERSION_ID, oxmClass, oxmField); if (oxmClass == EncodeConstants.EXPERIMENTER_VALUE) { long expId = input.getUnsignedInt(input.readerIndex() + EncodeConstants.SIZE_OF_SHORT_IN_BYTES + 2 * EncodeConstants.SIZE_OF_BYTE_IN_BYTES); key.setExperimenterId(expId); } OFDeserializer<MatchEntry> matchDeserializer = registry.getDeserializer(key); List<MatchEntry> entry = new ArrayList<>(); entry.add(matchDeserializer.deserialize(input)); actionBuilder.setMatchEntry(entry); caseBuilder.setSetFieldAction(actionBuilder.build()); builder.setActionChoice(caseBuilder.build()); int paddingRemainder = (input.readerIndex() - startIndex) % EncodeConstants.PADDING; if (paddingRemainder != 0) { input.skipBytes(EncodeConstants.PADDING - paddingRemainder); } return builder.build(); }
@Override public void registerMeterBandDeserializer(final ExperimenterIdDeserializerKey key, final OFDeserializer<MeterBandExperimenterCase> deserializer) { deserializerRegistry.registerDeserializer(key, deserializer); }
private MultipartRequestFlowCase setFlow(ByteBuf input) { MultipartRequestFlowCaseBuilder caseBuilder = new MultipartRequestFlowCaseBuilder(); MultipartRequestFlowBuilder flowBuilder = new MultipartRequestFlowBuilder(); flowBuilder.setTableId(input.readUnsignedByte()); input.skipBytes(FLOW_PADDING_1); flowBuilder.setOutPort(input.readUnsignedInt()); flowBuilder.setOutGroup(input.readUnsignedInt()); input.skipBytes(FLOW_PADDING_2); byte[] cookie = new byte[EncodeConstants.SIZE_OF_LONG_IN_BYTES]; input.readBytes(cookie); flowBuilder.setCookie(new BigInteger(1, cookie)); byte[] cookie_mask = new byte[EncodeConstants.SIZE_OF_LONG_IN_BYTES]; input.readBytes(cookie_mask); flowBuilder.setCookieMask(new BigInteger(1, cookie_mask)); OFDeserializer<Match> matchDeserializer = registry.getDeserializer( new MessageCodeKey(EncodeConstants.OF13_VERSION_ID, EncodeConstants.EMPTY_VALUE, Match.class)); flowBuilder.setMatch(matchDeserializer.deserialize(input)); caseBuilder.setMultipartRequestFlow(flowBuilder.build()); return caseBuilder.build(); }
@Override public void registerInstructionDeserializer(final ExperimenterInstructionDeserializerKey key, final OFGeneralDeserializer deserializer) { deserializerRegistry.registerDeserializer(key, deserializer); }
private MultipartRequestAggregateCase setAggregate(ByteBuf input) { MultipartRequestAggregateCaseBuilder caseBuilder = new MultipartRequestAggregateCaseBuilder(); MultipartRequestAggregateBuilder aggregateBuilder = new MultipartRequestAggregateBuilder(); aggregateBuilder.setTableId(input.readUnsignedByte()); input.skipBytes(AGGREGATE_PADDING_1); aggregateBuilder.setOutPort(input.readUnsignedInt()); aggregateBuilder.setOutGroup(input.readUnsignedInt()); input.skipBytes(AGGREGATE_PADDING_2); byte[] cookie = new byte[EncodeConstants.SIZE_OF_LONG_IN_BYTES]; input.readBytes(cookie); aggregateBuilder.setCookie(new BigInteger(1, cookie)); byte[] cookie_mask = new byte[EncodeConstants.SIZE_OF_LONG_IN_BYTES]; input.readBytes(cookie_mask); aggregateBuilder.setCookieMask(new BigInteger(1, cookie_mask)); OFDeserializer<Match> matchDeserializer = registry.getDeserializer( new MessageCodeKey(EncodeConstants.OF13_VERSION_ID, EncodeConstants.EMPTY_VALUE, Match.class)); aggregateBuilder.setMatch(matchDeserializer.deserialize(input)); caseBuilder.setMultipartRequestAggregate(aggregateBuilder.build()); return caseBuilder.build(); }
@Override public void registerQueuePropertyDeserializer(final ExperimenterIdDeserializerKey key, final OFDeserializer<QueueProperty> deserializer) { deserializerRegistry.registerDeserializer(key, deserializer); }
@Override public ErrorMessage deserialize(ByteBuf rawMessage) { int startIndex = rawMessage.readerIndex(); ErrorMessageBuilder builder = new ErrorMessageBuilder(); builder.setVersion((short) EncodeConstants.OF13_VERSION_ID); builder.setXid(rawMessage.readUnsignedInt()); int type = rawMessage.readUnsignedShort(); ErrorType errorType = ErrorType.forValue(type); if (ErrorType.EXPERIMENTER.equals(errorType)) { OFDeserializer<ErrorMessage> deserializer = registry.getDeserializer( ExperimenterDeserializerKeyFactory.createExperimenterErrorDeserializerKey( EncodeConstants.OF13_VERSION_ID, rawMessage.getUnsignedInt( rawMessage.readerIndex() + EncodeConstants.SIZE_OF_SHORT_IN_BYTES))); rawMessage.readerIndex(startIndex); return deserializer.deserialize(rawMessage); } decodeType(builder, errorType, type); decodeCode(rawMessage, builder, errorType); int remainingBytes = rawMessage.readableBytes(); if (remainingBytes > 0) { byte[] data = new byte[remainingBytes]; rawMessage.readBytes(data); builder.setData(data); } return builder.build(); }
@Override public void registerActionDeserializer(final ExperimenterActionDeserializerKey key, final OFGeneralDeserializer deserializer) { deserializerRegistry.registerDeserializer(key, deserializer); }
private List<QueueProperty> createPropertiesList(ByteBuf input, int length){ int propertiesLength = length; List<QueueProperty> propertiesList = new ArrayList<>(); while (propertiesLength > 0) { int propertyStartIndex = input.readerIndex(); QueuePropertyBuilder propertiesBuilder = new QueuePropertyBuilder(); QueueProperties property = QueueProperties.forValue(input.readUnsignedShort()); propertiesBuilder.setProperty(property); int currentPropertyLength = input.readUnsignedShort(); propertiesLength -= currentPropertyLength; input.skipBytes(PADDING_IN_QUEUE_PROPERTY_HEADER); if (property.equals(QueueProperties.OFPQTMINRATE) || property.equals(QueueProperties.OFPQTMAXRATE)) { RateQueuePropertyBuilder rateBuilder = new RateQueuePropertyBuilder(); rateBuilder.setRate(input.readUnsignedShort()); propertiesBuilder.addAugmentation(RateQueueProperty.class, rateBuilder.build()); input.skipBytes(PADDING_IN_RATE_QUEUE_PROPERTY); } else if (property.equals(QueueProperties.OFPQTEXPERIMENTER)) { long expId = input.readUnsignedInt(); input.readerIndex(propertyStartIndex); OFDeserializer<QueueProperty> deserializer = registry.getDeserializer( ExperimenterDeserializerKeyFactory.createQueuePropertyDeserializerKey( EncodeConstants.OF13_VERSION_ID, expId)); propertiesList.add(deserializer.deserialize(input)); continue; } propertiesList.add(propertiesBuilder.build()); } return propertiesList; }
@Override public void registerMatchEntryDeserializer(final MatchEntryDeserializerKey key, final OFGeneralDeserializer deserializer) { deserializerRegistry.registerDeserializer(key, deserializer); }
@Override public FlowRemovedMessage deserialize(ByteBuf rawMessage) { FlowRemovedMessageBuilder builder = new FlowRemovedMessageBuilder(); builder.setVersion((short) EncodeConstants.OF10_VERSION_ID); builder.setXid(rawMessage.readUnsignedInt()); OFDeserializer<MatchV10> matchDeserializer = registry.getDeserializer( new MessageCodeKey(EncodeConstants.OF10_VERSION_ID, EncodeConstants.EMPTY_VALUE, MatchV10.class)); builder.setMatchV10(matchDeserializer.deserialize(rawMessage)); byte[] cookie = new byte[EncodeConstants.SIZE_OF_LONG_IN_BYTES]; rawMessage.readBytes(cookie); builder.setCookie(new BigInteger(1, cookie)); builder.setPriority(rawMessage.readUnsignedShort()); builder.setReason(FlowRemovedReason.forValue(rawMessage.readUnsignedByte())); rawMessage.skipBytes(PADDING_IN_FLOW_REMOVED_MESSAGE); builder.setDurationSec(rawMessage.readUnsignedInt()); builder.setDurationNsec(rawMessage.readUnsignedInt()); builder.setIdleTimeout(rawMessage.readUnsignedShort()); rawMessage.skipBytes(PADDING_IN_FLOW_REMOVED_MESSAGE_2); byte[] packetCount = new byte[EncodeConstants.SIZE_OF_LONG_IN_BYTES]; rawMessage.readBytes(packetCount); builder.setPacketCount(new BigInteger(1, packetCount)); byte[] byteCount = new byte[EncodeConstants.SIZE_OF_LONG_IN_BYTES]; rawMessage.readBytes(byteCount); builder.setByteCount(new BigInteger(1, byteCount)); return builder.build(); }