* @return boolean value for usability of Barrier
*/
boolean useBarrier();
+
+ /**
+ * Checks if group add mod messages are enabled.
+ * @return true if group add mod messages are enabled
+ */
+ boolean isGroupAddModEnabled();
}
* @author michal.polkorab
*/
public interface SerializerRegistry {
-
/**
* Serializer registry provisioning
*/
* false if no serializer was found under specified key
*/
<K> boolean unregisterSerializer(MessageTypeKey<K> key);
+
+ /**
+ * Checks if group add mod messages are enabled.
+ * @return true if group add mod messages are enabled
+ */
+ boolean isGroupAddModEnabled();
+
+ /**
+ *
+ * @param isGroupAddModEnabled true if group add mod messages are enabled
+ */
+ void setGroupAddModConfig(boolean isGroupAddModEnabled);
}
@Override
public SwitchConnectionProvider newInstance(SwitchConnectionConfig config) {
- SwitchConnectionProviderImpl switchConnectionProviderImpl = new SwitchConnectionProviderImpl();
- switchConnectionProviderImpl.setConfiguration(new ConnectionConfigurationImpl(config));
+ SwitchConnectionProviderImpl switchConnectionProviderImpl =
+ new SwitchConnectionProviderImpl(new ConnectionConfigurationImpl(config));
return switchConnectionProviderImpl;
}
public boolean useBarrier() {
return config.isUseBarrier();
}
+
+ @Override
+ public boolean isGroupAddModEnabled() {
+ return config.isGroupAddModEnabled();
+ }
}
}
.getLogger(SwitchConnectionProviderImpl.class);
private SwitchConnectionHandler switchConnectionHandler;
private ServerFacade serverFacade;
- private ConnectionConfiguration connConfig;
+ private final ConnectionConfiguration connConfig;
private final SerializationFactory serializationFactory;
private final SerializerRegistry serializerRegistry;
private final DeserializerRegistry deserializerRegistry;
private final DeserializationFactory deserializationFactory;
private TcpConnectionInitializer connectionInitializer;
- /** Constructor */
- public SwitchConnectionProviderImpl() {
+ public SwitchConnectionProviderImpl(ConnectionConfiguration connConfig) {
+ this.connConfig = connConfig;
serializerRegistry = new SerializerRegistryImpl();
+ if (connConfig != null) {
+ serializerRegistry.setGroupAddModConfig(connConfig.isGroupAddModEnabled());
+ }
serializerRegistry.init();
serializationFactory = new SerializationFactory();
serializationFactory.setSerializerTable(serializerRegistry);
deserializationFactory.setRegistry(deserializerRegistry);
}
- @Override
- public void setConfiguration(final ConnectionConfiguration connConfig) {
- this.connConfig = connConfig;
- }
-
@Override
public void setSwitchConnectionHandler(final SwitchConnectionHandler switchConnectionHandler) {
LOG.debug("setSwitchConnectionHandler");
registryHelper.registerSerializer(GetConfigInput.class, new GetConfigInputMessageFactory());
registryHelper.registerSerializer(GetFeaturesInput.class, new GetFeaturesInputMessageFactory());
registryHelper.registerSerializer(GetQueueConfigInput.class, new GetQueueConfigInputMessageFactory());
- registryHelper.registerSerializer(GroupModInput.class, new GroupModInputMessageFactory());
+ registryHelper.registerSerializer(GroupModInput.class,
+ new GroupModInputMessageFactory(serializerRegistry.isGroupAddModEnabled()));
registryHelper.registerSerializer(HelloInput.class, new HelloInputMessageFactory());
registryHelper.registerSerializer(MeterModInput.class, new MeterModInputMessageFactory());
registryHelper.registerSerializer(MultipartRequestInput.class, new MultipartRequestInputFactory());
private static final short OF13 = EncodeConstants.OF13_VERSION_ID;
private Map<MessageTypeKey<?>, OFGeneralSerializer> registry;
+ private boolean isGroupAddModEnabled = false;
+
@Override
public void init() {
registry = new HashMap<>();
InstructionsInitializer.registerInstructionSerializers(this);
}
+ public void setGroupAddModConfig(boolean isGroupAddModEnabled) {
+ this.isGroupAddModEnabled = isGroupAddModEnabled;
+ }
+
+ @Override
+ public boolean isGroupAddModEnabled() {
+ return isGroupAddModEnabled;
+ }
+
/**
* @param msgTypeKey
* @return encoder for current type of message (msgTypeKey)
import org.opendaylight.openflowjava.protocol.impl.util.ListSerializer;
import org.opendaylight.openflowjava.protocol.impl.util.TypeKeyMakerFactory;
import org.opendaylight.openflowjava.util.ByteBufUtils;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.types.rev130731.GroupModCommand;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.GroupMod;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.buckets.grouping.BucketsList;
private static final byte MESSAGE_TYPE = 15;
private static final byte PADDING_IN_GROUP_MOD_MESSAGE = 1;
private static final byte PADDING_IN_BUCKET = 4;
+ private static final int OFPGC_ADD_OR_MOD = 32768;
private SerializerRegistry registry;
+ private final boolean isGroupAddModEnaled;
+
+ public GroupModInputMessageFactory(final boolean isGroupAddModEnaled) {
+ this.isGroupAddModEnaled = isGroupAddModEnaled;
+ }
@Override
public void serialize(GroupMod message, ByteBuf outBuffer) {
int index = outBuffer.writerIndex();
ByteBufUtils.writeOFHeader(MESSAGE_TYPE, message, outBuffer, EncodeConstants.EMPTY_LENGTH);
- outBuffer.writeShort(message.getCommand().getIntValue());
+ if (isGroupAddModEnaled) {
+ if (message.getCommand().equals(GroupModCommand.OFPGCADD)
+ || message.getCommand().equals(GroupModCommand.OFPGCMODIFY)) {
+ outBuffer.writeShort(OFPGC_ADD_OR_MOD);
+ } else {
+ outBuffer.writeShort(message.getCommand().getIntValue());
+ }
+ } else {
+ outBuffer.writeShort(message.getCommand().getIntValue());
+ }
outBuffer.writeByte(message.getType().getIntValue());
outBuffer.writeZero(PADDING_IN_GROUP_MOD_MESSAGE);
outBuffer.writeInt(message.getGroupId().getValue().intValue());
private final long switchIdleTimeout;
private ThreadConfiguration threadConfig;
private final boolean useBarrier;
+ private final boolean isGroupAddModEnabled;
/**
* Creates {@link ConnectionConfigurationImpl}
* @param useBarrier
*/
public ConnectionConfigurationImpl(final InetAddress address, final int port, final TlsConfiguration tlsConfig,
- final long switchIdleTimeout, final boolean useBarrier) {
+ final long switchIdleTimeout, final boolean useBarrier, final boolean isGroupAddModEnabled) {
this.address = address;
this.port = port;
this.tlsConfig = tlsConfig;
this.switchIdleTimeout = switchIdleTimeout;
this.useBarrier = useBarrier;
+ this.isGroupAddModEnabled = isGroupAddModEnabled;
}
@Override
public boolean useBarrier() {
return useBarrier;
}
+
+ @Override
+ public boolean isGroupAddModEnabled() {
+ return isGroupAddModEnabled;
+ }
}
\ No newline at end of file
@Mock OFSerializer<ExperimenterDataOfChoice> serializerExperimenterInput;
@Mock OFSerializer<ExperimenterDataOfChoice> serializerMultipartRequestExpCase;
@Mock OFSerializer<MeterBandExperimenterCase> serializerMeterBandExpCase;
+ @Mock ConnectionConfigurationImpl config;
private static final int SWITCH_IDLE_TIMEOUT = 2000;
private InetAddress startupAddress;
private TlsConfiguration tlsConfiguration;
private SwitchConnectionProviderImpl provider;
- private ConnectionConfigurationImpl config;
/**
* Creates new {@link SwitchConnectionProvider} instance for each test
if (protocol != null) {
createConfig(protocol);
}
- provider = new SwitchConnectionProviderImpl();
+ provider = new SwitchConnectionProviderImpl(config);
}
private void createConfig(final TransportProtocol protocol) {
"/selfSignedController", PathType.CLASSPATH,
Lists.newArrayList("TLS_RSA_WITH_AES_128_CBC_SHA", "TLS_RSA_WITH_AES_128_CBC_SHA256")) ;
}
- config = new ConnectionConfigurationImpl(startupAddress, 0, tlsConfiguration, SWITCH_IDLE_TIMEOUT, true);
+ config = new ConnectionConfigurationImpl(startupAddress, 0, tlsConfiguration, SWITCH_IDLE_TIMEOUT, true, false);
config.setTransferProtocol(protocol);
}
@Test
public void testServerFacade(){
startUp(TransportProtocol.TCP);
- provider.setConfiguration(config);
final ListenableFuture<Boolean> future = provider.startup();
final ServerFacade serverFacade = provider.getServerFacade();
Assert.assertNotNull("Wrong -- getServerFacade return null",serverFacade);
@Test
public void testUnregisterWrongKeys(){
startUp(TransportProtocol.TCP);
- provider.setConfiguration(config);
final ExperimenterInstructionSerializerKey testSerKey
= new ExperimenterInstructionSerializerKey(EncodeConstants.OF10_VERSION_ID,42L);
Assert.assertFalse("Wrong -- unregisterSerializer",provider.unregisterSerializer(testSerKey));
@Test
public void testUnregisterExistingKeys(){
startUp(TransportProtocol.TCP);
- provider.setConfiguration(config);
// -- registerActionSerializer
final ExperimenterActionSerializerKey key1
= new ExperimenterActionSerializerKey(EncodeConstants.OF10_VERSION_ID, 42L, TestSubType.class);
if (protocol != null) {
createConfig(protocol);
}
- provider = new SwitchConnectionProviderImpl();
+ provider = new SwitchConnectionProviderImpl(config);
}
private void createConfig(final TransportProtocol protocol) {
"/selfSignedController", PathType.CLASSPATH,
Lists.newArrayList("TLS_RSA_WITH_AES_128_CBC_SHA", "TLS_RSA_WITH_AES_128_CBC_SHA256")) ;
}
- config = new ConnectionConfigurationImpl(startupAddress, 0, tlsConfiguration, SWITCH_IDLE_TIMEOUT, true);
+ config = new ConnectionConfigurationImpl(startupAddress, 0, tlsConfiguration, SWITCH_IDLE_TIMEOUT, true, false);
config.setTransferProtocol(protocol);
}
*/
@Test
public void testStartup1() {
- provider = new SwitchConnectionProviderImpl();
+ provider = new SwitchConnectionProviderImpl(config);
final ListenableFuture<Boolean> future = provider.startup();
try {
future.get(WAIT_TIMEOUT, TimeUnit.MILLISECONDS);
@Test
public void testStartup3() {
startUp(TransportProtocol.TCP);
- provider.setConfiguration(config);
final ListenableFuture<Boolean> future = provider.startup();
try {
future.get(WAIT_TIMEOUT, TimeUnit.MILLISECONDS);
@Test
public void testStartup4() {
startUp(TransportProtocol.TCP);
- provider.setConfiguration(config);
provider.setSwitchConnectionHandler(handler);
try {
Assert.assertTrue("Failed to start", provider.startup().get(WAIT_TIMEOUT, TimeUnit.MILLISECONDS));
@Test
public void testStartup5() {
startUp(TransportProtocol.TLS);
- provider.setConfiguration(config);
provider.setSwitchConnectionHandler(handler);
try {
Assert.assertTrue("Failed to start", provider.startup().get(WAIT_TIMEOUT, TimeUnit.MILLISECONDS));
@Test
public void testStartup6() {
startUp(TransportProtocol.UDP);
- provider.setConfiguration(config);
provider.setSwitchConnectionHandler(handler);
try {
Assert.assertTrue("Failed to start", provider.startup().get(WAIT_TIMEOUT, TimeUnit.MILLISECONDS));
@Test
public void testShutdown() {
startUp(TransportProtocol.TCP);
- provider.setConfiguration(config);
provider.setSwitchConnectionHandler(handler);
try {
Assert.assertTrue("Failed to start", provider.startup().get(WAIT_TIMEOUT, TimeUnit.MILLISECONDS));
private static final byte MESSAGE_TYPE = 15;
private static final byte PADDING_IN_GROUP_MOD_MESSAGE = 1;
private SerializerRegistry registry;
- private OFSerializer<GroupModInput> groupModFactory;
+ private GroupModInputMessageFactory groupModFactory;
/**
* Initializes serializer registry and stores correct factory in field
public void startUp() {
registry = new SerializerRegistryImpl();
registry.init();
- groupModFactory = registry.getSerializer(
- new MessageTypeKey<>(EncodeConstants.OF13_VERSION_ID, GroupModInput.class));
+ groupModFactory = new GroupModInputMessageFactory(false);
}
/**
out.writeShort(3);
groupModFactory.serialize(message, out);
-
// read parent message
out.readInt();
out.skipBytes(2);
"/selfSignedController", PathType.CLASSPATH,
new ArrayList<String>());
}
- connConfig = new ConnectionConfigurationImpl(startupAddress, 0, tlsConfiguration, SWITCH_IDLE_TIMEOUT, true);
+ connConfig = new ConnectionConfigurationImpl(startupAddress, 0, tlsConfiguration, SWITCH_IDLE_TIMEOUT, true, false);
connConfig.setTransferProtocol(protocol);
mockPlugin = new MockPlugin();
- switchConnectionProvider = new SwitchConnectionProviderImpl();
+ switchConnectionProvider = new SwitchConnectionProviderImpl(connConfig);
switchConnectionProvider.setSwitchConnectionHandler(mockPlugin);
- switchConnectionProvider.setConfiguration(connConfig);
switchConnectionProvider.startup().get(CONNECTION_TIMEOUT, TimeUnit.MILLISECONDS);
if (protocol.equals(TransportProtocol.TCP) || protocol.equals(TransportProtocol.TLS)) {
final TcpHandler tcpHandler = (TcpHandler) switchConnectionProvider.getServerFacade();
public interface SwitchConnectionProvider extends AutoCloseable,
SerializerExtensionProvider, DeserializerExtensionProvider {
- /**
- * @param configuration [protocol, port, address and supported features]
- */
- void setConfiguration(ConnectionConfiguration configuration);
-
/**
* return the connection configuration
* @return configuration [protocol, port, address and supported features]
default true;
}
+ leaf group-add-mod-enabled {
+ description "Group Add Mod Enabled";
+ type boolean;
+ default false;
+ }
+
leaf switch-idle-timeout {
description "idle timeout in [ms]";
type uint32;
<instance-name>openflow-switch-connection-provider-default-impl</instance-name>
<port>6653</port>
<transport-protocol>TCP</transport-protocol>
+ <group-add-mod-enabled>false</group-add-mod-enabled>
<tls>
<keystore>configuration/ssl/ctl.jks</keystore>
<keystore-type>JKS</keystore-type>
<certificate-password>opendaylight</certificate-password>
<cipher-suites></cipher-suites>
</tls>
-</switch-connection-config>
\ No newline at end of file
+</switch-connection-config>
<instance-name>openflow-switch-connection-provider-legacy-impl</instance-name>
<port>6633</port>
<transport-protocol>TCP</transport-protocol>
+ <group-add-mod-enabled>false</group-add-mod-enabled>
<tls>
<keystore>configuration/ssl/ctl.jks</keystore>
<keystore-type>JKS</keystore-type>
Futures.addCallback(Futures.allAsList(switchConnectionProviders.stream().map(switchConnectionProvider -> {
// Inject OpenFlowPlugin custom serializers and deserializers into OpenFlowJava
if (config.isUseSingleLayerSerialization()) {
- SerializerInjector.injectSerializers(switchConnectionProvider);
+ SerializerInjector.injectSerializers(switchConnectionProvider,
+ switchConnectionProvider.getConfiguration().isGroupAddModEnabled());
DeserializerInjector.injectDeserializers(switchConnectionProvider);
} else {
DeserializerInjector.revertDeserializers(switchConnectionProvider);
/**
* Injects message serializers into provided
* {@link org.opendaylight.openflowjava.protocol.api.extensibility.SerializerExtensionProvider}.
- *
* @param provider OpenflowJava serializer extension provider
+ * @param isGroupAddModEnabled config to enale/disable GroupAddMod Message
*/
- static void injectSerializers(final SerializerExtensionProvider provider) {
+ static void injectSerializers(final SerializerExtensionProvider provider, final boolean isGroupAddModEnabled) {
// Inject new message serializers here using injector created by createInjector method
final Function<Class<?>, Consumer<OFSerializer<? extends OfHeader>>> injector =
createInjector(provider, EncodeConstants.OF13_VERSION_ID);
injector.apply(FlowMessage.class).accept(new FlowMessageSerializer());
injector.apply(MeterMessage.class).accept(new MeterMessageSerializer());
injector.apply(PortMessage.class).accept(new PortMessageSerializer());
- injector.apply(GroupMessage.class).accept(new GroupMessageSerializer());
+ injector.apply(GroupMessage.class).accept(new GroupMessageSerializer(isGroupAddModEnabled));
injector.apply(MultipartRequest.class).accept(new MultipartRequestMessageSerializer());
injector.apply(AsyncConfigMessage.class).accept(new AsyncConfigMessageSerializer());
}
/**
* Injects serializers into provided
* {@link org.opendaylight.openflowjava.protocol.api.extensibility.SerializerExtensionProvider}.
- *
* @param provider OpenflowJava serializer extension provider
+ * @param isGroupAddModEnabled config to enale/disable GroupAddMod Message
*/
- public static void injectSerializers(final SerializerExtensionProvider provider) {
+ public static void injectSerializers(final SerializerExtensionProvider provider,
+ final boolean isGroupAddModEnabled) {
// Inject new serializers here
MatchSerializerInjector.injectSerializers(provider);
ActionSerializerInjector.injectSerializers(provider);
InstructionSerializerInjector.injectSerializers(provider);
MultipartSerializerInjector.injectSerializers(provider);
- MessageSerializerInjector.injectSerializers(provider);
+ MessageSerializerInjector.injectSerializers(provider, isGroupAddModEnabled);
}
}
* OF protocol versions: 1.3.
*/
public class GroupMessageSerializer extends AbstractMessageSerializer<GroupMessage> implements
- SerializerRegistryInjector {
+ SerializerRegistryInjector {
private static final byte PADDING_IN_GROUP_MOD_MESSAGE = 1;
private static final byte PADDING_IN_BUCKET = 4;
+ private static final int OFPGC_ADD_OR_MOD = 32768;
+ private final boolean isGroupAddModEnabled;
private static final Comparator<Bucket> COMPARATOR = (bucket1, bucket2) -> {
if (bucket1.getBucketId() == null || bucket2.getBucketId() == null) {
private SerializerRegistry registry;
+ public GroupMessageSerializer(boolean isGroupAddModEnabled) {
+ this.isGroupAddModEnabled = isGroupAddModEnabled;
+ }
+
@Override
public void serialize(GroupMessage message, ByteBuf outBuffer) {
final int index = outBuffer.writerIndex();
super.serialize(message, outBuffer);
- outBuffer.writeShort(message.getCommand().getIntValue());
+ if (isGroupAddModEnabled) {
+ if (message.getCommand().equals(GroupModCommand.OFPGCADD)
+ || message.getCommand().equals(GroupModCommand.OFPGCMODIFY)) {
+ outBuffer.writeShort(OFPGC_ADD_OR_MOD);
+ } else {
+ outBuffer.writeShort(message.getCommand().getIntValue());
+ }
+ } else {
+ outBuffer.writeShort(message.getCommand().getIntValue());
+ }
outBuffer.writeByte(message.getGroupType().getIntValue());
outBuffer.writeZero(PADDING_IN_GROUP_MOD_MESSAGE);
outBuffer.writeInt(message.getGroupId().getValue().intValue());
outBuffer.setShort(bucketIndex, outBuffer.writerIndex() - bucketIndex);
}));
-
outBuffer.setShort(index + 2, outBuffer.writerIndex() - index);
}
registry = new SerializerRegistryImpl();
registry.init();
provider = new SerializerExtensionProviderImpl(registry);
- SerializerInjector.injectSerializers(provider);
+ SerializerInjector.injectSerializers(provider, false);
init();
}
Code Review / openflowplugin.git / commitdiff