Examples with ExperimenterIdDeserializerKey org.opendaylight.openflowjava.protocol.api.keys.ExperimenterIdDeserializerKey used on opensource projects

Example 1 with ExperimenterIdDeserializerKey

use of org.opendaylight.openflowjava.protocol.api.keys.ExperimenterIdDeserializerKey in project openflowplugin by opendaylight.

the class MultipartReplyMeterConfigDeserializer method deserialize.

@Override
public MultipartReplyBody deserialize(ByteBuf message) {
    final MultipartReplyMeterConfigBuilder builder = new MultipartReplyMeterConfigBuilder();
    final List<MeterConfigStats> items = new ArrayList<>();
    while (message.readableBytes() > 0) {
        final int itemLength = message.readUnsignedShort();
        final MeterConfigStatsBuilder itemBuilder = new MeterConfigStatsBuilder().setFlags(readMeterFlags(message)).setMeterId(new MeterId(message.readUnsignedInt()));
        final List<MeterBandHeader> subItems = new ArrayList<>();
        int actualLength = METER_CONFIG_LENGTH;
        while (actualLength < itemLength) {
            final int itemStartIndex = message.readerIndex();
            final int itemBandType = message.readUnsignedShort();
            final MeterBandHeaderBuilder subItemBuilder = new MeterBandHeaderBuilder();
            actualLength += message.readUnsignedShort();
            switch(itemBandType) {
                case OFPMBTDROP:
                    subItemBuilder.setMeterBandTypes(new MeterBandTypesBuilder().setFlags(new MeterBandType(true, false, false)).build()).setBandType(new DropBuilder().setDropRate(message.readUnsignedInt()).setDropBurstSize(message.readUnsignedInt()).build());
                    message.skipBytes(PADDING_IN_METER_BAND_DROP_HEADER);
                    break;
                case OFPMBTDSCP:
                    subItemBuilder.setMeterBandTypes(new MeterBandTypesBuilder().setFlags(new MeterBandType(false, true, false)).build()).setBandType(new DscpRemarkBuilder().setDscpRemarkRate(message.readUnsignedInt()).setDscpRemarkBurstSize(message.readUnsignedInt()).setPrecLevel(message.readUnsignedByte()).build());
                    message.skipBytes(PADDING_IN_METER_BAND_DSCP_HEADER);
                    break;
                case OFPMBTEXPERIMENTER:
                    // TODO: Finish meter band experimenter deserialization
                    final long expId = message.getUnsignedInt(message.readerIndex() + 2 * EncodeConstants.SIZE_OF_INT_IN_BYTES);
                    message.readerIndex(itemStartIndex);
                    final OFDeserializer<Experimenter> deserializer = registry.getDeserializer(new ExperimenterIdDeserializerKey(EncodeConstants.OF13_VERSION_ID, expId, Experimenter.class));
                    subItemBuilder.setMeterBandTypes(new MeterBandTypesBuilder().setFlags(new MeterBandType(false, false, true)).build()).setBandType(deserializer.deserialize(message));
                    break;
                default:
            }
            subItems.add(subItemBuilder.build());
        }
        items.add(itemBuilder.setKey(new MeterConfigStatsKey(itemBuilder.getMeterId())).setMeterBandHeaders(new MeterBandHeadersBuilder().setMeterBandHeader(subItems).build()).build());
    }
    return builder.setMeterConfigStats(items).build();
}

Example 2 with ExperimenterIdDeserializerKey

use of org.opendaylight.openflowjava.protocol.api.keys.ExperimenterIdDeserializerKey in project openflowplugin by opendaylight.

the class MeterMessageDeserializer method deserialize.

@Override
public MeterMessage deserialize(ByteBuf message) {
    final MeterMessageBuilder builder = new MeterMessageBuilder().setVersion((short) EncodeConstants.OF13_VERSION_ID).setXid(message.readUnsignedInt()).setCommand(MeterModCommand.forValue(message.readUnsignedShort())).setFlags(readMeterFlags(message)).setMeterId(new MeterId(message.readUnsignedInt()));
    final List<MeterBandHeader> bands = new ArrayList<>();
    while (message.readableBytes() > 0) {
        final MeterBandHeaderBuilder bandBuilder = new MeterBandHeaderBuilder();
        final int bandStartIndex = message.readerIndex();
        final int bandType = message.readUnsignedShort();
        switch(bandType) {
            case OFPMBTDROP:
                {
                    bandBuilder.setMeterBandTypes(new MeterBandTypesBuilder().setFlags(new MeterBandType(true, false, false)).build()).setBandType(new DropBuilder().setDropRate(message.readUnsignedInt()).setDropBurstSize(message.readUnsignedInt()).build());
                    message.skipBytes(PADDING_IN_METER_BAND_DROP_HEADER);
                    break;
                }
            case OFPMBTDSCP:
                {
                    bandBuilder.setMeterBandTypes(new MeterBandTypesBuilder().setFlags(new MeterBandType(false, true, false)).build()).setBandType(new DscpRemarkBuilder().setDscpRemarkRate(message.readUnsignedInt()).setDscpRemarkBurstSize(message.readUnsignedInt()).setPrecLevel(message.readUnsignedByte()).build());
                    message.skipBytes(PADDING_IN_METER_BAND_DSCP_HEADER);
                    break;
                }
            case OFPMBTEXPERIMENTER:
                {
                    // TODO: Finish meter band experimenter deserialization
                    long expId = message.getUnsignedInt(message.readerIndex() + 2 * EncodeConstants.SIZE_OF_INT_IN_BYTES);
                    message.readerIndex(bandStartIndex);
                    OFDeserializer<Experimenter> deserializer = registry.getDeserializer(new ExperimenterIdDeserializerKey(EncodeConstants.OF13_VERSION_ID, expId, Experimenter.class));
                    bandBuilder.setMeterBandTypes(new MeterBandTypesBuilder().setFlags(new MeterBandType(false, false, true)).build()).setBandType(deserializer.deserialize(message));
                    break;
                }
            default:
        }
        bands.add(bandBuilder.build());
    }
    return builder.setMeterBandHeaders(new MeterBandHeadersBuilder().setMeterBandHeader(bands).build()).build();
}

Example 3 with ExperimenterIdDeserializerKey

use of org.opendaylight.openflowjava.protocol.api.keys.ExperimenterIdDeserializerKey in project openflowplugin by opendaylight.

the class OnfExtensionProvider method registerDeserializers.

private void registerDeserializers() {
    switchConnectionProvider.registerExperimenterMessageDeserializer(new ExperimenterIdTypeDeserializerKey(OFConstants.OFP_VERSION_1_3, OnfConstants.ONF_EXPERIMENTER_ID, OnfConstants.ONF_ET_BUNDLE_CONTROL, ExperimenterDataOfChoice.class), new org.opendaylight.openflowplugin.extension.onf.deserializer.BundleControlFactory());
    switchConnectionProvider.registerErrorDeserializer(new ExperimenterIdDeserializerKey(OFConstants.OFP_VERSION_1_3, OnfConstants.ONF_EXPERIMENTER_ID, ErrorMessage.class), new OnfExperimenterErrorFactory());
}

Example 4 with ExperimenterIdDeserializerKey

use of org.opendaylight.openflowjava.protocol.api.keys.ExperimenterIdDeserializerKey in project openflowplugin by opendaylight.

the class SwitchConnectionProviderImpl02Test method testUnregisterExistingKeys.

/**
 * Test register and unregister method.
 */
@Test
public void testUnregisterExistingKeys() throws UnknownHostException {
    startUp(TransportProtocol.TCP);
    // -- registerActionSerializer
    final ExperimenterActionSerializerKey key1 = new ExperimenterActionSerializerKey(EncodeConstants.OF10_VERSION_ID, 42L, TestSubType.class);
    provider.registerActionSerializer(key1, serializer);
    Assert.assertTrue("Wrong -- unregister ActionSerializer", provider.unregisterSerializer(key1));
    Assert.assertFalse("Wrong -- unregister ActionSerializer by not existing key", provider.unregisterSerializer(key1));
    // -- registerActionDeserializer
    final ExperimenterActionDeserializerKey key2 = new ExperimenterActionDeserializerKey(EncodeConstants.OF10_VERSION_ID, 42L);
    provider.registerActionDeserializer(key2, deserializer);
    Assert.assertTrue("Wrong -- unregister ActionDeserializer", provider.unregisterDeserializer(key2));
    Assert.assertFalse("Wrong -- unregister ActionDeserializer by not existing key", provider.unregisterDeserializer(key2));
    // -- registerInstructionSerializer
    final ExperimenterInstructionSerializerKey key3 = new ExperimenterInstructionSerializerKey(EncodeConstants.OF10_VERSION_ID, 42L);
    provider.registerInstructionSerializer(key3, serializer);
    Assert.assertTrue("Wrong -- unregister InstructionSerializer", provider.unregisterSerializer(key3));
    Assert.assertFalse("Wrong -- unregister InstructionSerializer by not existing key", provider.unregisterSerializer(key3));
    // -- registerInstructionDeserializer
    final ExperimenterInstructionDeserializerKey key4 = new ExperimenterInstructionDeserializerKey(EncodeConstants.OF10_VERSION_ID, 42L);
    provider.registerInstructionDeserializer(key4, deserializer);
    Assert.assertTrue("Wrong -- unregister InstructionDeserializer", provider.unregisterDeserializer(key4));
    Assert.assertFalse("Wrong -- unregister InstructionDeserializer by not existing key", provider.unregisterDeserializer(key4));
    // -- registerMatchEntryDeserializer
    final MatchEntryDeserializerKey key5 = new MatchEntryDeserializerKey(EncodeConstants.OF10_VERSION_ID, 0x8000, 42);
    provider.registerMatchEntryDeserializer(key5, deserializer);
    Assert.assertTrue("Wrong -- unregister MatchEntryDeserializer", provider.unregisterDeserializer(key5));
    Assert.assertFalse("Wrong -- unregister MatchEntryDeserializer by not existing key", provider.unregisterDeserializer(key5));
    // -- registerErrorDeserializer
    final ExperimenterIdDeserializerKey key6 = new ExperimenterIdDeserializerKey(EncodeConstants.OF10_VERSION_ID, 42L, ErrorMessage.class);
    provider.registerErrorDeserializer(key6, deserializerError);
    Assert.assertTrue("Wrong -- unregister ErrorDeserializer", provider.unregisterDeserializer(key6));
    Assert.assertFalse("Wrong -- unregister ErrorDeserializer by not existing key", provider.unregisterDeserializer(key6));
    // -- registerExperimenterMessageDeserializer
    final ExperimenterIdDeserializerKey key7 = new ExperimenterIdDeserializerKey(EncodeConstants.OF10_VERSION_ID, 42L, ExperimenterMessage.class);
    provider.registerExperimenterMessageDeserializer(key7, deserializerExpMsg);
    Assert.assertTrue("Wrong -- unregister ExperimenterMessageDeserializer", provider.unregisterDeserializer(key7));
    Assert.assertFalse("Wrong -- unregister ExperimenterMessageDeserializer by not existing key", provider.unregisterDeserializer(key7));
    // -- registerMultipartReplyMessageDeserializer
    final ExperimenterIdDeserializerKey key8 = new ExperimenterIdDeserializerKey(EncodeConstants.OF10_VERSION_ID, 42L, MultipartReplyMessage.class);
    provider.registerMultipartReplyMessageDeserializer(key8, deserializerMultipartRplMsg);
    Assert.assertTrue("Wrong -- unregister MultipartReplyMessageDeserializer", provider.unregisterDeserializer(key8));
    Assert.assertFalse("Wrong -- unregister MultipartReplyMessageDeserializer by not existing key", provider.unregisterDeserializer(key8));
    // -- registerMultipartReplyTFDeserializer
    final ExperimenterIdDeserializerKey key9 = new ExperimenterIdDeserializerKey(EncodeConstants.OF10_VERSION_ID, 42L, MultipartReplyMessage.class);
    provider.registerMultipartReplyTFDeserializer(key9, deserializer);
    Assert.assertTrue("Wrong -- unregister MultipartReplyTFDeserializer", provider.unregisterDeserializer(key9));
    Assert.assertFalse("Wrong -- unregister MultipartReplyTFDeserializer by non existing key", provider.unregisterDeserializer(key9));
    // -- registerQueuePropertyDeserializer
    final ExperimenterIdDeserializerKey key10 = new ExperimenterIdDeserializerKey(EncodeConstants.OF10_VERSION_ID, 42L, QueueProperty.class);
    provider.registerQueuePropertyDeserializer(key10, deserializerQueueProperty);
    Assert.assertTrue("Wrong -- unregister QueuePropertyDeserializer", provider.unregisterDeserializer(key10));
    Assert.assertFalse("Wrong -- unregister QueuePropertyDeserializer by not existing key", provider.unregisterDeserializer(key10));
    // -- registerMeterBandDeserializer
    final ExperimenterIdDeserializerKey key11 = new ExperimenterIdDeserializerKey(EncodeConstants.OF10_VERSION_ID, 42L, MeterBandExperimenterCase.class);
    provider.registerMeterBandDeserializer(key11, deserializerMeterBandExpCase);
    Assert.assertTrue("Wrong -- unregister MeterBandDeserializer", provider.unregisterDeserializer(key11));
    Assert.assertFalse("Wrong -- unregister MeterBandDeserializer by not existing key", provider.unregisterDeserializer(key11));
    // -- registerExperimenterMessageSerializer
    ExperimenterIdSerializerKey<ExperimenterDataOfChoice> key12 = new ExperimenterIdSerializerKey<>(EncodeConstants.OF10_VERSION_ID, 42L, ExperimenterDataOfChoice.class);
    provider.registerExperimenterMessageSerializer(key12, serializerExperimenterInput);
    Assert.assertTrue("Wrong -- unregister ExperimenterMessageSerializer", provider.unregisterSerializer(key12));
    Assert.assertFalse("Wrong -- unregister ExperimenterMessageSerializer by not existing key", provider.unregisterSerializer(key12));
    // registerMultipartRequestSerializer
    ExperimenterIdSerializerKey<ExperimenterDataOfChoice> key13 = new ExperimenterIdSerializerKey<>(EncodeConstants.OF10_VERSION_ID, 42L, ExperimenterDataOfChoice.class);
    provider.registerMultipartRequestSerializer(key13, serializerMultipartRequestExpCase);
    Assert.assertTrue("Wrong -- unregister MultipartRequestSerializer", provider.unregisterSerializer(key13));
    Assert.assertFalse("Wrong -- unregister MultipartRequestSerializer by not existing key", provider.unregisterSerializer(key13));
    // -- registerMultipartRequestTFSerializer
    final ExperimenterIdSerializerKey<TableFeatureProperties> key14 = new ExperimenterIdSerializerKey<>(EncodeConstants.OF10_VERSION_ID, 42L, TableFeatureProperties.class);
    provider.registerMultipartRequestTFSerializer(key14, serializer);
    Assert.assertTrue("Wrong -- unregister MultipartRequestTFSerializer", provider.unregisterSerializer(key14));
    Assert.assertFalse("Wrong -- unregister MultipartRequestTFSerializer by not existing key", provider.unregisterSerializer(key14));
    // -- registerMeterBandSerializer
    final ExperimenterIdMeterSubTypeSerializerKey<MeterBandExperimenterCase> key15 = new ExperimenterIdMeterSubTypeSerializerKey<>(EncodeConstants.OF10_VERSION_ID, 42L, MeterBandExperimenterCase.class, null);
    provider.registerMeterBandSerializer(key15, serializerMeterBandExpCase);
    Assert.assertTrue("Wrong -- unregister MeterBandSerializer", provider.unregisterSerializer(key15));
    Assert.assertFalse("Wrong -- unregister MeterBandSerializer by not existing key", provider.unregisterSerializer(key15));
    // -- registerMatchEntrySerializer
    final MatchEntrySerializerKey<OpenflowBasicClass, InPort> key16 = new MatchEntrySerializerKey<>(EncodeConstants.OF13_VERSION_ID, OpenflowBasicClass.class, InPort.class);
    provider.registerMatchEntrySerializer(key16, serializer);
    Assert.assertTrue("Wrong -- unregister MatchEntrySerializer", provider.unregisterSerializer(key16));
    Assert.assertFalse("Wrong -- unregister MatchEntrySerializer by not existing key", provider.unregisterSerializer(key15));
    // -- registerSerializer
    final MessageTypeKey key17 = new MessageTypeKey<>(EncodeConstants.OF13_VERSION_ID, TestSubType.class);
    provider.registerSerializer(key17, serializer);
    // -- registerDeserializer
    final MessageCodeKey key18 = new MessageCodeKey(EncodeConstants.OF13_VERSION_ID, 42, TestSubType.class);
    provider.registerDeserializer(key18, deserializer);
}

Example 5 with ExperimenterIdDeserializerKey

use of org.opendaylight.openflowjava.protocol.api.keys.ExperimenterIdDeserializerKey in project openflowplugin by opendaylight.

the class ExperimenterDeserializerKeyFactoryTest method testCreateExperimenterErrorDeserializerKey.

@Test
public void testCreateExperimenterErrorDeserializerKey() throws Exception {
    ExperimenterIdDeserializerKey createdKey;
    ExperimenterIdDeserializerKey comparationKey;
    createdKey = ExperimenterDeserializerKeyFactory.createExperimenterErrorDeserializerKey(EncodeConstants.OF10_VERSION_ID, 42L);
    comparationKey = new ExperimenterIdDeserializerKey(EncodeConstants.OF10_VERSION_ID, 42L, ErrorMessage.class);
    Assert.assertEquals("Wrong key created", comparationKey, createdKey);
}