You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@activemq.apache.org by ro...@apache.org on 2024/07/24 13:52:03 UTC

(activemq-artemis) 02/02: ARTEMIS-4931 fix bridge config encoding

This is an automated email from the ASF dual-hosted git repository.

robbie pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/activemq-artemis.git

commit 8d1a66fbbd4a5eef3728b53ed772678a42772630
Author: Justin Bertram <jb...@apache.org>
AuthorDate: Wed Jul 17 16:45:45 2024 -0500

    ARTEMIS-4931 fix bridge config encoding
    
    This commit fixes 3 distinct issues with bridge configuration encoding:
    
     - The encoding size was calculated incorrectly in three ways:
       - Using 0 instead of `DataConstants.SIZE_NULL` when no transformer is
         defined resulting in a calculated size discrepancy of -1.
       - Using `DataConstants.INT` instead of `DataConstants.SIZE_INT` for
         the number of transformer properties resulting in a calculated size
         discrepancy of +2 when using a configuration with a transformer.
       - Using 0 or `sizeOfNullableInteger` instead of
         `DataConstants.SIZE_INT` for the number of static connectors
         resulting in a variable calculated size discrepancy of either -4 or
         +1 respectively.
     - Encoding was using `writeString` instead of `writeNullableString` for
       the name of the transformer class resulting in an actual buffer size
       discrepancy of -1.
    
    Aside from these fixes this commit also adds new tests specifically for
    encoding & decoding include a test to verify known bytes during
    encoding.
    
    Lastly, it's worth noting that this *won't fix* bad data that was
    already stored to disk by an older broker or bad data that comes over
    the wire from an older broker (e.g. if a older primary broker paired
    with a newer backup).
---
 .../artemis/core/config/BridgeConfiguration.java   |  23 +-
 .../config/BridgeConfigurationEncodingTest.java    | 546 +++++++++++++++++++++
 .../BridgeConfigurationStorageTest.java            |   2 -
 3 files changed, 557 insertions(+), 14 deletions(-)

diff --git a/artemis-server/src/main/java/org/apache/activemq/artemis/core/config/BridgeConfiguration.java b/artemis-server/src/main/java/org/apache/activemq/artemis/core/config/BridgeConfiguration.java
index f4e3a4e0af..c26564d754 100644
--- a/artemis-server/src/main/java/org/apache/activemq/artemis/core/config/BridgeConfiguration.java
+++ b/artemis-server/src/main/java/org/apache/activemq/artemis/core/config/BridgeConfiguration.java
@@ -842,19 +842,19 @@ public final class BridgeConfiguration implements Serializable {
    }
 
    public int getEncodeSize() {
-      int transformerSize = 0;
+      int transformerSize;
       if (transformerConfiguration != null) {
-         transformerSize += BufferHelper.sizeOfNullableString(transformerConfiguration.getClassName());
-         transformerSize += DataConstants.INT;
-         Map<String, String> properties = transformerConfiguration.getProperties();
-         for (Map.Entry<String, String> entry : properties.entrySet()) {
+         transformerSize = BufferHelper.sizeOfNullableString(transformerConfiguration.getClassName());
+         transformerSize += DataConstants.SIZE_INT;
+         for (Map.Entry<String, String> entry : transformerConfiguration.getProperties().entrySet()) {
             transformerSize += BufferHelper.sizeOfNullableString(entry.getKey());
             transformerSize += BufferHelper.sizeOfNullableString(entry.getValue());
          }
+      } else {
+         transformerSize = DataConstants.SIZE_NULL;
       }
-      int staticConnectorSize = 0;
+      int staticConnectorSize = DataConstants.SIZE_INT;
       if (staticConnectors != null) {
-         staticConnectorSize += BufferHelper.sizeOfNullableInteger(staticConnectors.size());
          for (String connector : staticConnectors) {
             staticConnectorSize += BufferHelper.sizeOfNullableString(connector);
          }
@@ -882,11 +882,11 @@ public final class BridgeConfiguration implements Serializable {
          BufferHelper.sizeOfNullableInteger(minLargeMessageSize) +
          BufferHelper.sizeOfNullableLong(callTimeout) +
          BufferHelper.sizeOfNullableInteger(concurrency) +
-         BufferHelper.sizeOfNullableLong(pendingAckTimeout) +
          BufferHelper.sizeOfNullableBoolean(configurationManaged) +
-         DataConstants.SIZE_BYTE +
+         DataConstants.SIZE_BYTE + // routingType
          transformerSize +
-         staticConnectorSize;
+         staticConnectorSize +
+         BufferHelper.sizeOfNullableLong(pendingAckTimeout);
       return size;
    }
 
@@ -917,7 +917,7 @@ public final class BridgeConfiguration implements Serializable {
       buffer.writeNullableBoolean(configurationManaged);
       buffer.writeByte(routingType != null ? routingType.getType() : ComponentConfigurationRoutingType.valueOf(ActiveMQDefaultConfiguration.getDefaultDivertRoutingType()).getType());
       if (transformerConfiguration != null) {
-         buffer.writeString(transformerConfiguration.getClassName());
+         buffer.writeNullableString(transformerConfiguration.getClassName());
          Map<String, String> properties = transformerConfiguration.getProperties();
          buffer.writeInt(properties.size());
          for (Map.Entry<String, String> entry : properties.entrySet()) {
@@ -983,5 +983,4 @@ public final class BridgeConfiguration implements Serializable {
          pendingAckTimeout = buffer.readNullableLong();
       }
    }
-
 }
diff --git a/artemis-server/src/test/java/org/apache/activemq/artemis/core/config/BridgeConfigurationEncodingTest.java b/artemis-server/src/test/java/org/apache/activemq/artemis/core/config/BridgeConfigurationEncodingTest.java
new file mode 100644
index 0000000000..12159ff4b1
--- /dev/null
+++ b/artemis-server/src/test/java/org/apache/activemq/artemis/core/config/BridgeConfigurationEncodingTest.java
@@ -0,0 +1,546 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.activemq.artemis.core.config;
+
+import java.util.List;
+import java.util.Map;
+
+import org.apache.activemq.artemis.api.core.ActiveMQBuffer;
+import org.apache.activemq.artemis.api.core.ActiveMQBuffers;
+import org.apache.activemq.artemis.core.server.ComponentConfigurationRoutingType;
+import org.apache.activemq.artemis.utils.DataConstants;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNull;
+
+public class BridgeConfigurationEncodingTest {
+
+   @Test
+   public void testEncodedBytesWithTransformerWithPropertiesWithStaticConnectors() {
+      doEncodedBytesTestImpl(true, true, true);
+   }
+
+   @Test
+   public void testEncodedBytesWithTransformerWithoutPropertiesWithStaticConnectors() {
+      doEncodedBytesTestImpl(true, false, true);
+   }
+
+   @Test
+   public void testEncodedBytesWithTransformerWithPropertiesWithoutStaticConnectors() {
+      doEncodedBytesTestImpl(true, true, false);
+   }
+
+   @Test
+   public void testEncodedBytesWithTransformerWithoutPropertiesWithoutStaticConnectors() {
+      doEncodedBytesTestImpl(true, false, false);
+   }
+
+   @Test
+   public void testEncodedBytesWithoutTransformerWithStaticConnectors() {
+      doEncodedBytesTestImpl(false, false, true);
+   }
+
+   @Test
+   public void testEncodedBytesWithoutTransformerWithoutStaticConnectors() {
+      doEncodedBytesTestImpl(false, false, false);
+   }
+
+   private void doEncodedBytesTestImpl(final boolean transformer, boolean properties, boolean staticConnectors) {
+      if (properties && !transformer) {
+         throw new IllegalArgumentException("Must have transformer to have properties for it");
+      }
+
+      final String name = "aa";
+      final String parentName = "bb";
+      final String queueName = "cc";
+      final String forwardingAddress = "dd";
+      final String filterString = "ee";
+      final String discoveryGroup = "ff";
+      final boolean ha = true;
+      final long retryInterval = 0L;
+      final double retryIntervalMultiplier = 0.0;
+      final int initialConnectAttempts = 0;
+      final int reconnectAttempts = 1;
+      final int reconnectAttemptsOnSameNode = 2;
+      final boolean useDuplicateDetection = false;
+      final int confirmationWindowSize = 3;
+      final int producerWindowSize = 4;
+      final long clientFailureCheckPeriod = 1L;
+      final String user = "gg";
+      final String password = "hh";
+      final long connectionTtl = 2L;
+      final long maxRetryInterval = 3L;
+      final int minLargeMessageSize = 5;
+      final long callTimeout = 4L;
+      final int concurrency = 6;
+      final boolean configurationManaged = false;
+      final ComponentConfigurationRoutingType routingType = ComponentConfigurationRoutingType.ANYCAST;
+      final long pendingAckTimeout = 5L;
+      final String staticConnector = "ii";
+
+      BridgeConfiguration configuration = new BridgeConfiguration()
+         .setName(name)
+         .setParentName(parentName)
+         .setQueueName(queueName)
+         .setForwardingAddress(forwardingAddress)
+         .setFilterString(filterString)
+         .setDiscoveryGroupName(discoveryGroup)
+         .setHA(ha)
+         .setRetryInterval(retryInterval)
+         .setRetryIntervalMultiplier(retryIntervalMultiplier)
+         .setInitialConnectAttempts(initialConnectAttempts)
+         .setReconnectAttempts(reconnectAttempts)
+         .setReconnectAttemptsOnSameNode(reconnectAttemptsOnSameNode)
+         .setUseDuplicateDetection(useDuplicateDetection)
+         .setConfirmationWindowSize(confirmationWindowSize)
+         .setProducerWindowSize(producerWindowSize)
+         .setClientFailureCheckPeriod(clientFailureCheckPeriod)
+         .setUser(user)
+         .setPassword(password)
+         .setConnectionTTL(connectionTtl)
+         .setMaxRetryInterval(maxRetryInterval)
+         .setMinLargeMessageSize(minLargeMessageSize)
+         .setCallTimeout(callTimeout)
+         .setConcurrency(concurrency)
+         .setConfigurationManaged(configurationManaged)
+         .setRoutingType(routingType);
+
+      if (transformer) {
+         final String transformerClass = "jj";
+         final TransformerConfiguration myDivertTransformer = new TransformerConfiguration(transformerClass);
+
+         if (properties) {
+            final String transformerKey = "kk";
+            final String transformerValue = "ll";
+            myDivertTransformer.getProperties().put(transformerKey, transformerValue);
+         }
+
+         configuration.setTransformerConfiguration(myDivertTransformer);
+      }
+
+      if (staticConnectors) {
+         configuration.setStaticConnectors(List.of(staticConnector));
+      }
+      configuration.setPendingAckTimeout(pendingAckTimeout);
+
+      int encodeSize = configuration.getEncodeSize();
+      ActiveMQBuffer data = ActiveMQBuffers.fixedBuffer(encodeSize);
+      configuration.encode(data);
+      assertEquals(encodeSize, data.writerIndex());
+
+      // name
+      byte[] read = new byte[9];
+      data.readBytes(read, 0, 9);
+      assertArrayEquals(new byte[] {DataConstants.NOT_NULL, 0, 0, 0, 2, 0, 97, 0, 97}, read);
+
+      // parentName
+      read = new byte[9];
+      data.readBytes(read, 0, 9);
+      assertArrayEquals(new byte[] {DataConstants.NOT_NULL, 0, 0, 0, 2, 0, 98, 0, 98}, read);
+
+      // queueName
+      read = new byte[9];
+      data.readBytes(read, 0, 9);
+      assertArrayEquals(new byte[] {DataConstants.NOT_NULL, 0, 0, 0, 2, 0, 99, 0, 99}, read);
+
+      // forwardingAddress
+      read = new byte[9];
+      data.readBytes(read, 0, 9);
+      assertArrayEquals(new byte[] {DataConstants.NOT_NULL, 0, 0, 0, 2, 0, 100, 0, 100}, read);
+
+      // filterString
+      read = new byte[9];
+      data.readBytes(read, 0, 9);
+      assertArrayEquals(new byte[] {DataConstants.NOT_NULL, 0, 0, 0, 2, 0, 101, 0, 101}, read);
+
+      // discoveryGroup
+      read = new byte[9];
+      data.readBytes(read, 0, 9);
+      assertArrayEquals(new byte[] {DataConstants.NOT_NULL, 0, 0, 0, 2, 0, 102, 0, 102}, read);
+
+      // ha
+      read = new byte[2];
+      data.readBytes(read, 0, 2);
+      assertArrayEquals(new byte[] {DataConstants.NOT_NULL, -1}, read);
+
+      // retryInterval
+      read = new byte[9];
+      data.readBytes(read, 0, 9);
+      assertArrayEquals(new byte[] {DataConstants.NOT_NULL, 0, 0, 0, 0, 0, 0, 0, 0}, read);
+
+      // retryIntervalMultiplier
+      read = new byte[9];
+      data.readBytes(read, 0, 9);
+      assertArrayEquals(new byte[] {-1, 0, 0, 0, 0, 0, 0, 0, 0}, read);
+
+      // initialConnectAttempts
+      read = new byte[5];
+      data.readBytes(read, 0, 5);
+      assertArrayEquals(new byte[] {DataConstants.NOT_NULL, 0, 0, 0, 0}, read);
+
+      // reconnectAttempts
+      read = new byte[5];
+      data.readBytes(read, 0, 5);
+      assertArrayEquals(new byte[] {DataConstants.NOT_NULL, 0, 0, 0, 1}, read);
+
+      // reconnectAttemptsOnSameNode
+      read = new byte[5];
+      data.readBytes(read, 0, 5);
+      assertArrayEquals(new byte[] {DataConstants.NOT_NULL, 0, 0, 0, 2}, read);
+
+      // useDuplicateDetection
+      read = new byte[2];
+      data.readBytes(read, 0, 2);
+      assertArrayEquals(new byte[] {DataConstants.NOT_NULL, 0}, read);
+
+      // confirmationWindowSize
+      read = new byte[5];
+      data.readBytes(read, 0, 5);
+      assertArrayEquals(new byte[] {DataConstants.NOT_NULL, 0, 0, 0, 3}, read);
+
+      // producerWindowSize
+      read = new byte[5];
+      data.readBytes(read, 0, 5);
+      assertArrayEquals(new byte[] {DataConstants.NOT_NULL, 0, 0, 0, 4}, read);
+
+      // clientFailureCheckPeriod
+      read = new byte[9];
+      data.readBytes(read, 0, 9);
+      assertArrayEquals(new byte[] {DataConstants.NOT_NULL, 0, 0, 0, 0, 0, 0, 0, 1}, read);
+
+      // user
+      read = new byte[9];
+      data.readBytes(read, 0, 9);
+      assertArrayEquals(new byte[] {DataConstants.NOT_NULL, 0, 0, 0, 2, 0, 103, 0, 103}, read);
+
+      // password
+      read = new byte[9];
+      data.readBytes(read, 0, 9);
+      assertArrayEquals(new byte[] {DataConstants.NOT_NULL, 0, 0, 0, 2, 0, 104, 0, 104}, read);
+
+      // connectionTtl
+      read = new byte[9];
+      data.readBytes(read, 0, 9);
+      assertArrayEquals(new byte[] {DataConstants.NOT_NULL, 0, 0, 0, 0, 0, 0, 0, 2}, read);
+
+      // maxRetryInterval
+      read = new byte[9];
+      data.readBytes(read, 0, 9);
+      assertArrayEquals(new byte[] {DataConstants.NOT_NULL, 0, 0, 0, 0, 0, 0, 0, 3}, read);
+
+      // minLargeMessageSize
+      read = new byte[5];
+      data.readBytes(read, 0, 5);
+      assertArrayEquals(new byte[] {DataConstants.NOT_NULL, 0, 0, 0, 5}, read);
+
+      // callTimeout
+      read = new byte[9];
+      data.readBytes(read, 0, 9);
+      assertArrayEquals(new byte[] {DataConstants.NOT_NULL, 0, 0, 0, 0, 0, 0, 0, 4}, read);
+
+      // concurrency
+      read = new byte[5];
+      data.readBytes(read, 0, 5);
+      assertArrayEquals(new byte[] {DataConstants.NOT_NULL, 0, 0, 0, 6}, read);
+
+      // configurationManaged
+      read = new byte[2];
+      data.readBytes(read, 0, 2);
+      assertArrayEquals(new byte[] {DataConstants.NOT_NULL, 0}, read);
+
+      // routingType
+      assertEquals(ComponentConfigurationRoutingType.ANYCAST.getType(), data.readByte());
+
+      if (transformer) {
+         // transformerClassName
+         read = new byte[9];
+         data.readBytes(read, 0, 9);
+         assertArrayEquals(new byte[] {DataConstants.NOT_NULL, 0, 0, 0, 2, 0, 106, 0, 106}, read);
+
+         if (properties) {
+            // number of transformer properties
+            read = new byte[4];
+            data.readBytes(read, 0, 4);
+            assertArrayEquals(new byte[] {0, 0, 0, 1}, read);
+
+            // transformer key name
+            read = new byte[9];
+            data.readBytes(read, 0, 9);
+            assertArrayEquals(new byte[] {DataConstants.NOT_NULL, 0, 0, 0, 2, 0, 107, 0, 107}, read);
+
+            // transformer key value
+            read = new byte[9];
+            data.readBytes(read, 0, 9);
+            assertArrayEquals(new byte[] {DataConstants.NOT_NULL, 0, 0, 0, 2, 0, 108, 0, 108}, read);
+         } else {
+            // transformer properties not present (indicated via 0 count)
+            read = new byte[4];
+            data.readBytes(read, 0, 4);
+            assertArrayEquals(new byte[] {0, 0, 0, 0}, read);
+         }
+      } else {
+         // transformer not present
+         assertEquals(DataConstants.NULL, data.readByte());
+      }
+
+      if (staticConnectors) {
+         // staticConnector count
+         read = new byte[4];
+         data.readBytes(read, 0, 4);
+         assertArrayEquals(new byte[]{0, 0, 0, 1}, read);
+
+         // static connector
+         read = new byte[9];
+         data.readBytes(read, 0, 9);
+         assertArrayEquals(new byte[] {DataConstants.NOT_NULL, 0, 0, 0, 2, 0, 105, 0, 105}, read);
+      } else {
+         // staticConnector count
+         read = new byte[4];
+         data.readBytes(read, 0, 4);
+         assertArrayEquals(new byte[]{0, 0, 0, 0}, read);
+      }
+
+      // pendingAckTimeout
+      read = new byte[9];
+      data.readBytes(read, 0, 9);
+      assertArrayEquals(new byte[] {DataConstants.NOT_NULL, 0, 0, 0, 0, 0, 0, 0, 5}, read);
+
+      assertEquals(0, data.readableBytes());
+   }
+
+   @Test
+   public void testEncodeDecodeWithTransformer() {
+      TransformerConfiguration mytransformer = new TransformerConfiguration("myBridgeTransformer");
+      mytransformer.getProperties().put("key1", "prop1");
+      mytransformer.getProperties().put("key2", "prop2");
+      mytransformer.getProperties().put("key3", "prop3");
+
+      BridgeConfiguration configuration = new BridgeConfiguration()
+         .setName("name")
+         .setParentName("parentName")
+         .setQueueName("queueName")
+         .setForwardingAddress("forwardingAddress")
+         .setFilterString("filterString")
+         .setDiscoveryGroupName("discoveryGroup")
+         .setHA(false)
+         .setRetryInterval(0)
+         .setRetryIntervalMultiplier(1)
+         .setInitialConnectAttempts(2)
+         .setReconnectAttempts(3)
+         .setReconnectAttemptsOnSameNode(4)
+         .setUseDuplicateDetection(false)
+         .setConfirmationWindowSize(5)
+         .setProducerWindowSize(6)
+         .setClientFailureCheckPeriod(7)
+         .setUser("user")
+         .setPassword("password")
+         .setConnectionTTL(8)
+         .setMaxRetryInterval(9)
+         .setMinLargeMessageSize(10)
+         .setCallTimeout(11)
+         .setConcurrency(12)
+         .setConfigurationManaged(true)
+         .setRoutingType(ComponentConfigurationRoutingType.ANYCAST)
+         .setTransformerConfiguration(mytransformer)
+         .setStaticConnectors(List.of("tcp://localhost:61616"))
+         .setPendingAckTimeout(13);
+
+      int encodeSize = configuration.getEncodeSize();
+      ActiveMQBuffer data = ActiveMQBuffers.fixedBuffer(encodeSize);
+      configuration.encode(data);
+      BridgeConfiguration persistedBridgeConfiguration = new BridgeConfiguration();
+      persistedBridgeConfiguration.decode(data);
+
+      assertEquals(configuration.getName(), persistedBridgeConfiguration.getName());
+      assertEquals(configuration.getParentName(), persistedBridgeConfiguration.getParentName());
+      assertEquals(configuration.getQueueName(), persistedBridgeConfiguration.getQueueName());
+      assertEquals(configuration.getForwardingAddress(), persistedBridgeConfiguration.getForwardingAddress());
+      assertEquals(configuration.getFilterString(), persistedBridgeConfiguration.getFilterString());
+      assertEquals(configuration.getDiscoveryGroupName(), persistedBridgeConfiguration.getDiscoveryGroupName());
+      assertEquals(configuration.isHA(), persistedBridgeConfiguration.isHA());
+      assertEquals(configuration.getRetryInterval(), persistedBridgeConfiguration.getRetryInterval());
+      assertEquals(configuration.getRetryIntervalMultiplier(), persistedBridgeConfiguration.getRetryIntervalMultiplier());
+      assertEquals(configuration.getInitialConnectAttempts(), persistedBridgeConfiguration.getInitialConnectAttempts());
+      assertEquals(configuration.getReconnectAttempts(), persistedBridgeConfiguration.getReconnectAttempts());
+      assertEquals(configuration.getReconnectAttemptsOnSameNode(), persistedBridgeConfiguration.getReconnectAttemptsOnSameNode());
+      assertEquals(configuration.isUseDuplicateDetection(), persistedBridgeConfiguration.isUseDuplicateDetection());
+      assertEquals(configuration.getConfirmationWindowSize(), persistedBridgeConfiguration.getConfirmationWindowSize());
+      assertEquals(configuration.getProducerWindowSize(), persistedBridgeConfiguration.getProducerWindowSize());
+      assertEquals(configuration.getClientFailureCheckPeriod(), persistedBridgeConfiguration.getClientFailureCheckPeriod());
+      assertEquals(configuration.getUser(), persistedBridgeConfiguration.getUser());
+      assertEquals(configuration.getPassword(), persistedBridgeConfiguration.getPassword());
+      assertEquals(configuration.getConnectionTTL(), persistedBridgeConfiguration.getConnectionTTL());
+      assertEquals(configuration.getMaxRetryInterval(), persistedBridgeConfiguration.getMaxRetryInterval());
+      assertEquals(configuration.getMinLargeMessageSize(), persistedBridgeConfiguration.getMinLargeMessageSize());
+      assertEquals(configuration.getCallTimeout(), persistedBridgeConfiguration.getCallTimeout());
+      assertEquals(configuration.getConcurrency(), persistedBridgeConfiguration.getConcurrency());
+      assertEquals(configuration.isConfigurationManaged(), persistedBridgeConfiguration.isConfigurationManaged());
+      assertEquals(configuration.getRoutingType(), persistedBridgeConfiguration.getRoutingType());
+      assertNotNull(persistedBridgeConfiguration.getTransformerConfiguration());
+      assertEquals("myBridgeTransformer", persistedBridgeConfiguration.getTransformerConfiguration().getClassName());
+      Map<String, String> properties = persistedBridgeConfiguration.getTransformerConfiguration().getProperties();
+      assertEquals(3, properties.size());
+      assertEquals("prop1", properties.get("key1"));
+      assertEquals("prop2", properties.get("key2"));
+      assertEquals("prop3", properties.get("key3"));
+      assertEquals(configuration.getStaticConnectors(), persistedBridgeConfiguration.getStaticConnectors());
+      assertEquals(configuration.getPendingAckTimeout(), persistedBridgeConfiguration.getPendingAckTimeout());
+   }
+
+   @Test
+   public void testEncodeDecodeWithTransformerWithNoProperties() {
+      TransformerConfiguration mytransformer = new TransformerConfiguration("myBridgeTransformer");
+
+      BridgeConfiguration configuration = new BridgeConfiguration()
+         .setName("name")
+         .setParentName("parentName")
+         .setQueueName("queueName")
+         .setForwardingAddress("forwardingAddress")
+         .setFilterString("filterString")
+         .setDiscoveryGroupName("discoveryGroup")
+         .setHA(false)
+         .setRetryInterval(0)
+         .setRetryIntervalMultiplier(1)
+         .setInitialConnectAttempts(2)
+         .setReconnectAttempts(3)
+         .setReconnectAttemptsOnSameNode(4)
+         .setUseDuplicateDetection(false)
+         .setConfirmationWindowSize(5)
+         .setProducerWindowSize(6)
+         .setClientFailureCheckPeriod(7)
+         .setUser("user")
+         .setPassword("password")
+         .setConnectionTTL(8)
+         .setMaxRetryInterval(9)
+         .setMinLargeMessageSize(10)
+         .setCallTimeout(11)
+         .setConcurrency(12)
+         .setConfigurationManaged(true)
+         .setRoutingType(ComponentConfigurationRoutingType.ANYCAST)
+         .setTransformerConfiguration(mytransformer)
+         .setStaticConnectors(List.of("tcp://localhost:61616"))
+         .setPendingAckTimeout(13);
+
+      int encodeSize = configuration.getEncodeSize();
+      ActiveMQBuffer data = ActiveMQBuffers.fixedBuffer(encodeSize);
+      configuration.encode(data);
+      BridgeConfiguration persistedBridgeConfiguration = new BridgeConfiguration();
+      persistedBridgeConfiguration.decode(data);
+
+      assertEquals(configuration.getName(), persistedBridgeConfiguration.getName());
+      assertEquals(configuration.getParentName(), persistedBridgeConfiguration.getParentName());
+      assertEquals(configuration.getQueueName(), persistedBridgeConfiguration.getQueueName());
+      assertEquals(configuration.getForwardingAddress(), persistedBridgeConfiguration.getForwardingAddress());
+      assertEquals(configuration.getFilterString(), persistedBridgeConfiguration.getFilterString());
+      assertEquals(configuration.getDiscoveryGroupName(), persistedBridgeConfiguration.getDiscoveryGroupName());
+      assertEquals(configuration.isHA(), persistedBridgeConfiguration.isHA());
+      assertEquals(configuration.getRetryInterval(), persistedBridgeConfiguration.getRetryInterval());
+      assertEquals(configuration.getRetryIntervalMultiplier(), persistedBridgeConfiguration.getRetryIntervalMultiplier());
+      assertEquals(configuration.getInitialConnectAttempts(), persistedBridgeConfiguration.getInitialConnectAttempts());
+      assertEquals(configuration.getReconnectAttempts(), persistedBridgeConfiguration.getReconnectAttempts());
+      assertEquals(configuration.getReconnectAttemptsOnSameNode(), persistedBridgeConfiguration.getReconnectAttemptsOnSameNode());
+      assertEquals(configuration.isUseDuplicateDetection(), persistedBridgeConfiguration.isUseDuplicateDetection());
+      assertEquals(configuration.getConfirmationWindowSize(), persistedBridgeConfiguration.getConfirmationWindowSize());
+      assertEquals(configuration.getProducerWindowSize(), persistedBridgeConfiguration.getProducerWindowSize());
+      assertEquals(configuration.getClientFailureCheckPeriod(), persistedBridgeConfiguration.getClientFailureCheckPeriod());
+      assertEquals(configuration.getUser(), persistedBridgeConfiguration.getUser());
+      assertEquals(configuration.getPassword(), persistedBridgeConfiguration.getPassword());
+      assertEquals(configuration.getConnectionTTL(), persistedBridgeConfiguration.getConnectionTTL());
+      assertEquals(configuration.getMaxRetryInterval(), persistedBridgeConfiguration.getMaxRetryInterval());
+      assertEquals(configuration.getMinLargeMessageSize(), persistedBridgeConfiguration.getMinLargeMessageSize());
+      assertEquals(configuration.getCallTimeout(), persistedBridgeConfiguration.getCallTimeout());
+      assertEquals(configuration.getConcurrency(), persistedBridgeConfiguration.getConcurrency());
+      assertEquals(configuration.isConfigurationManaged(), persistedBridgeConfiguration.isConfigurationManaged());
+      assertEquals(configuration.getRoutingType(), persistedBridgeConfiguration.getRoutingType());
+      assertNotNull(persistedBridgeConfiguration.getTransformerConfiguration());
+      assertEquals("myBridgeTransformer", persistedBridgeConfiguration.getTransformerConfiguration().getClassName());
+      Map<String, String> properties = persistedBridgeConfiguration.getTransformerConfiguration().getProperties();
+      assertEquals(0, properties.size());
+      assertEquals(configuration.getStaticConnectors(), persistedBridgeConfiguration.getStaticConnectors());
+      assertEquals(configuration.getPendingAckTimeout(), persistedBridgeConfiguration.getPendingAckTimeout());
+   }
+
+   @Test
+   public void testEncodeDecodeWithoutTransformer() {
+      BridgeConfiguration configuration = new BridgeConfiguration()
+         .setName("name")
+         .setParentName("parentName")
+         .setQueueName("queueName")
+         .setForwardingAddress("forwardingAddress")
+         .setFilterString("filterString")
+         .setDiscoveryGroupName("discoveryGroup")
+         .setHA(false)
+         .setRetryInterval(0)
+         .setRetryIntervalMultiplier(1)
+         .setInitialConnectAttempts(2)
+         .setReconnectAttempts(3)
+         .setReconnectAttemptsOnSameNode(4)
+         .setUseDuplicateDetection(false)
+         .setConfirmationWindowSize(5)
+         .setProducerWindowSize(6)
+         .setClientFailureCheckPeriod(7)
+         .setUser("user")
+         .setPassword("password")
+         .setConnectionTTL(8)
+         .setMaxRetryInterval(9)
+         .setMinLargeMessageSize(10)
+         .setCallTimeout(11)
+         .setConcurrency(12)
+         .setConfigurationManaged(true)
+         .setRoutingType(ComponentConfigurationRoutingType.ANYCAST)
+         .setStaticConnectors(List.of("tcp://localhost:61616"))
+         .setPendingAckTimeout(13);
+
+      int encodeSize = configuration.getEncodeSize();
+      ActiveMQBuffer data = ActiveMQBuffers.fixedBuffer(encodeSize);
+      configuration.encode(data);
+      BridgeConfiguration persistedBridgeConfiguration = new BridgeConfiguration();
+      persistedBridgeConfiguration.decode(data);
+
+      assertEquals(configuration.getName(), persistedBridgeConfiguration.getName());
+      assertEquals(configuration.getParentName(), persistedBridgeConfiguration.getParentName());
+      assertEquals(configuration.getQueueName(), persistedBridgeConfiguration.getQueueName());
+      assertEquals(configuration.getForwardingAddress(), persistedBridgeConfiguration.getForwardingAddress());
+      assertEquals(configuration.getFilterString(), persistedBridgeConfiguration.getFilterString());
+      assertEquals(configuration.getDiscoveryGroupName(), persistedBridgeConfiguration.getDiscoveryGroupName());
+      assertEquals(configuration.isHA(), persistedBridgeConfiguration.isHA());
+      assertEquals(configuration.getRetryInterval(), persistedBridgeConfiguration.getRetryInterval());
+      assertEquals(configuration.getRetryIntervalMultiplier(), persistedBridgeConfiguration.getRetryIntervalMultiplier());
+      assertEquals(configuration.getInitialConnectAttempts(), persistedBridgeConfiguration.getInitialConnectAttempts());
+      assertEquals(configuration.getReconnectAttempts(), persistedBridgeConfiguration.getReconnectAttempts());
+      assertEquals(configuration.getReconnectAttemptsOnSameNode(), persistedBridgeConfiguration.getReconnectAttemptsOnSameNode());
+      assertEquals(configuration.isUseDuplicateDetection(), persistedBridgeConfiguration.isUseDuplicateDetection());
+      assertEquals(configuration.getConfirmationWindowSize(), persistedBridgeConfiguration.getConfirmationWindowSize());
+      assertEquals(configuration.getProducerWindowSize(), persistedBridgeConfiguration.getProducerWindowSize());
+      assertEquals(configuration.getClientFailureCheckPeriod(), persistedBridgeConfiguration.getClientFailureCheckPeriod());
+      assertEquals(configuration.getUser(), persistedBridgeConfiguration.getUser());
+      assertEquals(configuration.getPassword(), persistedBridgeConfiguration.getPassword());
+      assertEquals(configuration.getConnectionTTL(), persistedBridgeConfiguration.getConnectionTTL());
+      assertEquals(configuration.getMaxRetryInterval(), persistedBridgeConfiguration.getMaxRetryInterval());
+      assertEquals(configuration.getMinLargeMessageSize(), persistedBridgeConfiguration.getMinLargeMessageSize());
+      assertEquals(configuration.getCallTimeout(), persistedBridgeConfiguration.getCallTimeout());
+      assertEquals(configuration.getConcurrency(), persistedBridgeConfiguration.getConcurrency());
+      assertEquals(configuration.isConfigurationManaged(), persistedBridgeConfiguration.isConfigurationManaged());
+      assertEquals(configuration.getRoutingType(), persistedBridgeConfiguration.getRoutingType());
+      assertNull(persistedBridgeConfiguration.getTransformerConfiguration());
+      assertEquals(configuration.getStaticConnectors(), persistedBridgeConfiguration.getStaticConnectors());
+      assertEquals(configuration.getPendingAckTimeout(), persistedBridgeConfiguration.getPendingAckTimeout());
+   }
+}
diff --git a/tests/integration-tests/src/test/java/org/apache/activemq/artemis/tests/integration/persistence/BridgeConfigurationStorageTest.java b/tests/integration-tests/src/test/java/org/apache/activemq/artemis/tests/integration/persistence/BridgeConfigurationStorageTest.java
index 17c8f39141..fc7048643c 100644
--- a/tests/integration-tests/src/test/java/org/apache/activemq/artemis/tests/integration/persistence/BridgeConfigurationStorageTest.java
+++ b/tests/integration-tests/src/test/java/org/apache/activemq/artemis/tests/integration/persistence/BridgeConfigurationStorageTest.java
@@ -25,7 +25,6 @@ import org.apache.activemq.artemis.core.config.StoreConfiguration;
 import org.apache.activemq.artemis.core.config.TransformerConfiguration;
 import org.apache.activemq.artemis.core.persistence.config.PersistedBridgeConfiguration;
 import org.apache.activemq.artemis.tests.extensions.parameterized.ParameterizedTestExtension;
-import org.junit.jupiter.api.Disabled;
 import org.junit.jupiter.api.TestTemplate;
 import org.junit.jupiter.api.extension.ExtendWith;
 
@@ -42,7 +41,6 @@ public class BridgeConfigurationStorageTest extends StorageManagerTestBase {
    }
 
    @TestTemplate
-   @Disabled
    public void testStoreBridgeConfiguration() throws Exception {
       TransformerConfiguration mytransformer = new TransformerConfiguration("mytransformer");
       mytransformer.getProperties().put("key1", "prop1");


---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@activemq.apache.org
For additional commands, e-mail: commits-help@activemq.apache.org
For further information, visit: https://activemq.apache.org/contact