From fb54707e2db9a6308e53a6be7f45b66129eb225f Mon Sep 17 00:00:00 2001 From: "Christopher L. Shannon (cshannon)" Date: Tue, 12 Nov 2019 10:57:40 -0500 Subject: [PATCH] ARTEMIS-2549 - Add Downstream support to Federation This commit introduces the ability to configure a downstream connection for federation. This works by sending information to the remote broker and that broker will parse the message and create a new upstream back to the original broker. --- .../artemis/api/core/ActiveMQBuffer.java | 53 +++ .../buffers/impl/ChannelBufferWrapper.java | 60 +++ .../config/ActiveMQDefaultConfiguration.java | 91 +++++ .../impl/ResetLimitWrappedActiveMQBuffer.java | 21 ++ .../CompressedLargeMessageControllerImpl.java | 45 +++ .../impl/LargeMessageControllerImpl.java | 45 +++ .../core/config/FederationConfiguration.java | 32 ++ .../core/config/TransformerConfiguration.java | 0 .../FederationAddressPolicyConfiguration.java | 61 ++++ .../FederationConnectionConfiguration.java | 275 ++++++++++++++ .../FederationDownstreamConfiguration.java | 96 +++++ .../config/federation/FederationPolicy.java | 7 + .../federation/FederationPolicySet.java | 28 ++ .../FederationQueuePolicyConfiguration.java | 56 +++ .../FederationStreamConfiguration.java | 47 ++- .../FederationTransformerConfiguration.java | 33 ++ .../FederationUpstreamConfiguration.java | 21 ++ .../core/protocol/core/impl/ChannelImpl.java | 3 + .../protocol/core/impl/PacketDecoder.java | 6 + .../core/protocol/core/impl/PacketImpl.java | 2 + .../FederationDownstreamConnectMessage.java | 36 ++ .../FederationStreamConnectMessage.java | 156 ++++++++ .../FederationConnectionConfiguration.java | 117 ------ .../impl/FileConfigurationParser.java | 51 ++- .../core/protocol/ServerPacketDecoder.java | 6 + .../core/impl/CoreProtocolManager.java | 172 ++++++++- .../artemis/core/server/ActiveMQServer.java | 8 +- .../core/server/ActiveMQServerLogger.java | 14 +- .../federation/FederatedQueueConsumer.java | 18 +- .../core/server/federation/Federation.java | 65 +++- .../federation/FederationConnection.java | 20 + .../federation/FederationDownstream.java | 212 +++++++++++ .../server/federation/FederationManager.java | 2 - .../server/federation/FederationStream.java | 109 ++++++ .../server/federation/FederationUpstream.java | 62 +--- .../federation/address/FederatedAddress.java | 6 +- .../core/server/impl/ServiceRegistryImpl.java | 1 + .../schema/artemis-configuration.xsd | 110 +++++- .../ConfigurationTest-full-config.xml | 30 ++ docs/user-manual/en/federation-address.md | 120 +++++- docs/user-manual/en/federation-queue.md | 114 +++++- .../eu-west-east-us-central.png | Bin 0 -> 226275 bytes .../pom.xml | 215 +++++++++++ .../readme.md | 34 ++ ...ratedAddressDownstreamUpstreamExample.java | 29 ++ .../resources/activemq/server0/broker.xml | 118 ++++++ .../resources/activemq/server1/broker.xml | 100 +++++ .../resources/activemq/server2/broker.xml | 70 ++++ .../eu-west-east-us-central.png | Bin 0 -> 226275 bytes .../federated-address-downstream/pom.xml | 215 +++++++++++ .../federated-address-downstream/readme.md | 34 ++ .../FederatedAddressDownstreamExample.java | 29 ++ .../resources/activemq/server0/broker.xml | 100 +++++ .../resources/activemq/server1/broker.xml | 100 +++++ .../resources/activemq/server2/broker.xml | 100 +++++ .../eu-west-east-us-central.png | Bin 0 -> 226275 bytes .../pom.xml | 215 +++++++++++ .../readme.md | 51 +++ ...deratedQueueDownstreamUpstreamExample.java | 29 ++ .../resources/activemq/server0/broker.xml | 118 ++++++ .../resources/activemq/server1/broker.xml | 100 +++++ .../resources/activemq/server2/broker.xml | 73 ++++ .../eu-west-east-us-central.png | Bin 0 -> 226275 bytes .../federated-queue-downstream/pom.xml | 215 +++++++++++ .../federated-queue-downstream/readme.md | 51 +++ .../FederatedQueueDownstreamExample.java | 29 ++ .../resources/activemq/server0/broker.xml | 100 +++++ .../resources/activemq/server1/broker.xml | 100 +++++ .../resources/activemq/server2/broker.xml | 100 +++++ .../jms/example/FederatedQueueExample.java | 1 + examples/features/federation/pom.xml | 7 + .../federation/FederatedAddressTest.java | 266 ++++++++++++-- .../federation/FederatedQueueTest.java | 345 ++++++++++++++++-- .../core/remoting/ActiveMQBufferTestBase.java | 36 ++ 74 files changed, 5109 insertions(+), 282 deletions(-) rename {artemis-server => artemis-core-client}/src/main/java/org/apache/activemq/artemis/core/config/FederationConfiguration.java (80%) rename {artemis-server => artemis-core-client}/src/main/java/org/apache/activemq/artemis/core/config/TransformerConfiguration.java (100%) rename {artemis-server => artemis-core-client}/src/main/java/org/apache/activemq/artemis/core/config/federation/FederationAddressPolicyConfiguration.java (70%) create mode 100644 artemis-core-client/src/main/java/org/apache/activemq/artemis/core/config/federation/FederationConnectionConfiguration.java create mode 100644 artemis-core-client/src/main/java/org/apache/activemq/artemis/core/config/federation/FederationDownstreamConfiguration.java rename {artemis-server => artemis-core-client}/src/main/java/org/apache/activemq/artemis/core/config/federation/FederationPolicy.java (87%) rename {artemis-server => artemis-core-client}/src/main/java/org/apache/activemq/artemis/core/config/federation/FederationPolicySet.java (72%) rename {artemis-server => artemis-core-client}/src/main/java/org/apache/activemq/artemis/core/config/federation/FederationQueuePolicyConfiguration.java (70%) rename artemis-server/src/main/java/org/apache/activemq/artemis/core/config/federation/FederationUpstreamConfiguration.java => artemis-core-client/src/main/java/org/apache/activemq/artemis/core/config/federation/FederationStreamConfiguration.java (56%) rename {artemis-server => artemis-core-client}/src/main/java/org/apache/activemq/artemis/core/config/federation/FederationTransformerConfiguration.java (60%) create mode 100644 artemis-core-client/src/main/java/org/apache/activemq/artemis/core/config/federation/FederationUpstreamConfiguration.java create mode 100644 artemis-core-client/src/main/java/org/apache/activemq/artemis/core/protocol/core/impl/wireformat/FederationDownstreamConnectMessage.java create mode 100644 artemis-core-client/src/main/java/org/apache/activemq/artemis/core/protocol/core/impl/wireformat/FederationStreamConnectMessage.java delete mode 100644 artemis-server/src/main/java/org/apache/activemq/artemis/core/config/federation/FederationConnectionConfiguration.java create mode 100644 artemis-server/src/main/java/org/apache/activemq/artemis/core/server/federation/FederationDownstream.java create mode 100644 artemis-server/src/main/java/org/apache/activemq/artemis/core/server/federation/FederationStream.java create mode 100644 examples/features/federation/federated-address-downstream-upstream/eu-west-east-us-central.png create mode 100644 examples/features/federation/federated-address-downstream-upstream/pom.xml create mode 100644 examples/features/federation/federated-address-downstream-upstream/readme.md create mode 100644 examples/features/federation/federated-address-downstream-upstream/src/main/java/org/apache/activemq/artemis/jms/example/FederatedAddressDownstreamUpstreamExample.java create mode 100644 examples/features/federation/federated-address-downstream-upstream/src/main/resources/activemq/server0/broker.xml create mode 100644 examples/features/federation/federated-address-downstream-upstream/src/main/resources/activemq/server1/broker.xml create mode 100644 examples/features/federation/federated-address-downstream-upstream/src/main/resources/activemq/server2/broker.xml create mode 100644 examples/features/federation/federated-address-downstream/eu-west-east-us-central.png create mode 100644 examples/features/federation/federated-address-downstream/pom.xml create mode 100644 examples/features/federation/federated-address-downstream/readme.md create mode 100644 examples/features/federation/federated-address-downstream/src/main/java/org/apache/activemq/artemis/jms/example/FederatedAddressDownstreamExample.java create mode 100644 examples/features/federation/federated-address-downstream/src/main/resources/activemq/server0/broker.xml create mode 100644 examples/features/federation/federated-address-downstream/src/main/resources/activemq/server1/broker.xml create mode 100644 examples/features/federation/federated-address-downstream/src/main/resources/activemq/server2/broker.xml create mode 100644 examples/features/federation/federated-queue-downstream-upstream/eu-west-east-us-central.png create mode 100644 examples/features/federation/federated-queue-downstream-upstream/pom.xml create mode 100644 examples/features/federation/federated-queue-downstream-upstream/readme.md create mode 100644 examples/features/federation/federated-queue-downstream-upstream/src/main/java/org/apache/activemq/artemis/jms/example/FederatedQueueDownstreamUpstreamExample.java create mode 100644 examples/features/federation/federated-queue-downstream-upstream/src/main/resources/activemq/server0/broker.xml create mode 100644 examples/features/federation/federated-queue-downstream-upstream/src/main/resources/activemq/server1/broker.xml create mode 100644 examples/features/federation/federated-queue-downstream-upstream/src/main/resources/activemq/server2/broker.xml create mode 100644 examples/features/federation/federated-queue-downstream/eu-west-east-us-central.png create mode 100644 examples/features/federation/federated-queue-downstream/pom.xml create mode 100644 examples/features/federation/federated-queue-downstream/readme.md create mode 100644 examples/features/federation/federated-queue-downstream/src/main/java/org/apache/activemq/artemis/jms/example/FederatedQueueDownstreamExample.java create mode 100644 examples/features/federation/federated-queue-downstream/src/main/resources/activemq/server0/broker.xml create mode 100644 examples/features/federation/federated-queue-downstream/src/main/resources/activemq/server1/broker.xml create mode 100644 examples/features/federation/federated-queue-downstream/src/main/resources/activemq/server2/broker.xml diff --git a/artemis-commons/src/main/java/org/apache/activemq/artemis/api/core/ActiveMQBuffer.java b/artemis-commons/src/main/java/org/apache/activemq/artemis/api/core/ActiveMQBuffer.java index 3a208a6980..e9cd68be18 100644 --- a/artemis-commons/src/main/java/org/apache/activemq/artemis/api/core/ActiveMQBuffer.java +++ b/artemis-commons/src/main/java/org/apache/activemq/artemis/api/core/ActiveMQBuffer.java @@ -677,6 +677,15 @@ public interface ActiveMQBuffer extends DataInput { @Override int readInt(); + /** + * Gets a (potentially {@code null}) 32-bit integer at the current {@code readerIndex} + * and increases the {@code readerIndex} by {@code 4} in this buffer. + * + * @return a (potentially {@code null}) 32-bit integer at the current {@code readerIndex} + * @throws IndexOutOfBoundsException if {@code this.readableBytes} is less than {@code 4} + */ + Integer readNullableInt(); + /** * Gets an unsigned 32-bit integer at the current {@code readerIndex} * and increases the {@code readerIndex} by {@code 4} in this buffer. @@ -696,6 +705,15 @@ public interface ActiveMQBuffer extends DataInput { @Override long readLong(); + /** + * Gets a (potentially {@code null}) 64-bit integer at the current {@code readerIndex} + * and increases the {@code readerIndex} by {@code 8} in this buffer. + * + * @return a (potentially {@code null}) 64-bit integer at the current {@code readerIndex} + * @throws IndexOutOfBoundsException if {@code this.readableBytes} is less than {@code 8} + */ + Long readNullableLong(); + /** * Gets a char at the current {@code readerIndex} * and increases the {@code readerIndex} by {@code 2} in this buffer. @@ -736,6 +754,15 @@ public interface ActiveMQBuffer extends DataInput { @Override boolean readBoolean(); + /** + * Gets a (potentially {@code null}) boolean at the current {@code readerIndex} + * and increases the {@code readerIndex} by {@code 1} in this buffer. + * + * @return a (potentially {@code null}) boolean at the current {@code readerIndex} + * @throws IndexOutOfBoundsException if {@code this.readableBytes} is less than {@code 1} + */ + Boolean readNullableBoolean(); + /** * Gets a SimpleString (potentially {@code null}) at the current {@code readerIndex} * @@ -917,6 +944,15 @@ public interface ActiveMQBuffer extends DataInput { */ void writeInt(int value); + /** + * Sets the specified (potentially {@code null}) 32-bit integer at the current {@code writerIndex} + * and increases the {@code writerIndex} by {@code 4} in this buffer. + * + * @param value The specified (potentially {@code null}) 32-bit integer + * @throws IndexOutOfBoundsException if {@code this.writableBytes} is less than {@code 4} + */ + void writeNullableInt(Integer value); + /** * Sets the specified 64-bit long integer at the current * {@code writerIndex} and increases the {@code writerIndex} by {@code 8} @@ -927,6 +963,16 @@ public interface ActiveMQBuffer extends DataInput { */ void writeLong(long value); + /** + * Sets the specified (potentially {@code null}) 64-bit long integer at the current + * {@code writerIndex} and increases the {@code writerIndex} by {@code 8} + * in this buffer. + * + * @param value The specified (potentially {@code null}) 64-bit long integer + * @throws IndexOutOfBoundsException if {@code this.writableBytes} is less than {@code 8} + */ + void writeNullableLong(Long value); + /** * Sets the specified char at the current {@code writerIndex} * and increases the {@code writerIndex} by {@code 2} in this buffer. @@ -961,6 +1007,13 @@ public interface ActiveMQBuffer extends DataInput { */ void writeBoolean(boolean val); + /** + * Sets the specified (potentially {@code null}) Boolean at the current {@code writerIndex} + * + * @param val The specified boolean + */ + void writeNullableBoolean(Boolean val); + /** * Sets the specified SimpleString (potentially {@code null}) at the current {@code writerIndex} * diff --git a/artemis-commons/src/main/java/org/apache/activemq/artemis/core/buffers/impl/ChannelBufferWrapper.java b/artemis-commons/src/main/java/org/apache/activemq/artemis/core/buffers/impl/ChannelBufferWrapper.java index 92314e208e..a6a5b80f00 100644 --- a/artemis-commons/src/main/java/org/apache/activemq/artemis/core/buffers/impl/ChannelBufferWrapper.java +++ b/artemis-commons/src/main/java/org/apache/activemq/artemis/core/buffers/impl/ChannelBufferWrapper.java @@ -64,6 +64,16 @@ public class ChannelBufferWrapper implements ActiveMQBuffer { return readByte() != 0; } + @Override + public Boolean readNullableBoolean() { + int b = readByte(); + if (b == DataConstants.NULL) { + return null; + } else { + return readBoolean(); + } + } + @Override public SimpleString readNullableSimpleString() { return SimpleString.readNullableSimpleString(buffer); @@ -125,6 +135,16 @@ public class ChannelBufferWrapper implements ActiveMQBuffer { buffer.writeByte((byte) (val ? -1 : 0)); } + @Override + public void writeNullableBoolean(Boolean val) { + if (val == null) { + buffer.writeByte(DataConstants.NULL); + } else { + buffer.writeByte(DataConstants.NOT_NULL); + writeBoolean(val); + } + } + @Override public void writeNullableSimpleString(final SimpleString val) { SimpleString.writeNullableSimpleString(buffer, val); @@ -345,11 +365,31 @@ public class ChannelBufferWrapper implements ActiveMQBuffer { return buffer.readInt(); } + @Override + public Integer readNullableInt() { + int b = readByte(); + if (b == DataConstants.NULL) { + return null; + } else { + return readInt(); + } + } + @Override public long readLong() { return buffer.readLong(); } + @Override + public Long readNullableLong() { + int b = readByte(); + if (b == DataConstants.NULL) { + return null; + } else { + return readLong(); + } + } + @Override public short readShort() { return buffer.readShort(); @@ -565,11 +605,31 @@ public class ChannelBufferWrapper implements ActiveMQBuffer { buffer.writeInt(value); } + @Override + public void writeNullableInt(final Integer value) { + if (value == null) { + buffer.writeByte(DataConstants.NULL); + } else { + buffer.writeByte(DataConstants.NOT_NULL); + writeInt(value); + } + } + @Override public void writeLong(final long value) { buffer.writeLong(value); } + @Override + public void writeNullableLong(Long value) { + if (value == null) { + buffer.writeByte(DataConstants.NULL); + } else { + buffer.writeByte(DataConstants.NOT_NULL); + writeLong(value); + } + } + @Override public int writerIndex() { return buffer.writerIndex(); diff --git a/artemis-core-client/src/main/java/org/apache/activemq/artemis/api/config/ActiveMQDefaultConfiguration.java b/artemis-core-client/src/main/java/org/apache/activemq/artemis/api/config/ActiveMQDefaultConfiguration.java index 76e1557d3d..66b7289d74 100644 --- a/artemis-core-client/src/main/java/org/apache/activemq/artemis/api/config/ActiveMQDefaultConfiguration.java +++ b/artemis-core-client/src/main/java/org/apache/activemq/artemis/api/config/ActiveMQDefaultConfiguration.java @@ -572,6 +572,33 @@ public final class ActiveMQDefaultConfiguration { public static final CriticalAnalyzerPolicy DEFAULT_ANALYZE_CRITICAL_POLICY = CriticalAnalyzerPolicy.LOG; + // The period (in milliseconds) used to check if the federation connection has failed to receive pings from another server + private static long DEFAULT_FEDERATION_FAILURE_CHECK_PERIOD = 30000; + + // how long to keep a connection alive in the absence of any data arriving from the client + private static long DEFAULT_FEDERATION_CONNECTION_TTL = getDefaultConnectionTtl(); + + // How long to wait for a reply + private static long DEFAULT_FEDERATION_CALL_TIMEOUT = 30000; + + // period (in ms) between successive retries + private static long DEFAULT_FEDERATION_RETRY_INTERVAL = 500; + + // multiplier to apply to the retry-interval + private static double DEFAULT_FEDERATION_RETRY_INTERVAL_MULTIPLIER = getDefaultRetryIntervalMultiplier(); + + // Maximum value for retry-interval + private static long DEFAULT_FEDERATION_MAX_RETRY_INTERVAL = getDefaultMaxRetryInterval(); + + // How many attempts should be made to connect initially + private static int DEFAULT_FEDERATION_INITIAL_CONNECT_ATTEMPTS = -1; + + // How many attempts should be made to reconnect after failure + private static int DEFAULT_FEDERATION_RECONNECT_ATTEMPTS = -1; + + // How long to wait for a reply if in the middle of a fail-over. -1 means wait forever. + private static long DEFAULT_FEDERATION_CALL_FAILOVER_TIMEOUT = -1; + /** * If true then the ActiveMQ Artemis Server will make use of any Protocol Managers that are in available on the classpath. If false then only the core protocol will be available, unless in Embedded mode where users can inject their own Protocol Managers. */ @@ -1537,4 +1564,68 @@ public final class ActiveMQDefaultConfiguration { public static long getDefaultRetryReplicationWait() { return DEFAULT_RETRY_REPLICATION_WAIT; } + + /** + * The period (in milliseconds) used to check if the federation connection has failed to receive pings from another server + */ + public static long getDefaultFederationFailureCheckPeriod() { + return DEFAULT_FEDERATION_FAILURE_CHECK_PERIOD; + } + + /** + * how long to keep a connection alive in the absence of any data arriving from the client + */ + public static long getDefaultFederationConnectionTtl() { + return DEFAULT_FEDERATION_CONNECTION_TTL; + } + + /** + * How long to wait for a reply + */ + public static long getDefaultFederationCallTimeout() { + return DEFAULT_FEDERATION_CALL_TIMEOUT; + } + + /** + * period (in ms) between successive retries + */ + public static long getDefaultFederationRetryInterval() { + return DEFAULT_FEDERATION_RETRY_INTERVAL; + } + + /** + * multiplier to apply to the retry-interval + */ + public static double getDefaultFederationRetryIntervalMultiplier() { + return DEFAULT_FEDERATION_RETRY_INTERVAL_MULTIPLIER; + } + + /** + * Maximum value for retry-interval + */ + public static long getDefaultFederationMaxRetryInterval() { + return DEFAULT_FEDERATION_MAX_RETRY_INTERVAL; + } + + /** + * How many attempts should be made to connect initially + */ + public static int getDefaultFederationInitialConnectAttempts() { + return DEFAULT_FEDERATION_INITIAL_CONNECT_ATTEMPTS; + } + + /** + * How many attempts should be made to reconnect after failure + */ + public static int getDefaultFederationReconnectAttempts() { + return DEFAULT_FEDERATION_RECONNECT_ATTEMPTS; + } + + /** + * How long to wait for a reply if in the middle of a fail-over. -1 means wait forever. + */ + public static long getDefaultFederationCallFailoverTimeout() { + return DEFAULT_FEDERATION_CALL_FAILOVER_TIMEOUT; + } + } diff --git a/artemis-core-client/src/main/java/org/apache/activemq/artemis/core/buffers/impl/ResetLimitWrappedActiveMQBuffer.java b/artemis-core-client/src/main/java/org/apache/activemq/artemis/core/buffers/impl/ResetLimitWrappedActiveMQBuffer.java index b5d5474558..7845deee7d 100644 --- a/artemis-core-client/src/main/java/org/apache/activemq/artemis/core/buffers/impl/ResetLimitWrappedActiveMQBuffer.java +++ b/artemis-core-client/src/main/java/org/apache/activemq/artemis/core/buffers/impl/ResetLimitWrappedActiveMQBuffer.java @@ -226,6 +226,13 @@ public final class ResetLimitWrappedActiveMQBuffer extends ChannelBufferWrapper super.writeBoolean(val); } + @Override + public void writeNullableBoolean(final Boolean val) { + changed(); + + super.writeNullableBoolean(val); + } + @Override public void writeByte(final byte value) { changed(); @@ -304,6 +311,13 @@ public final class ResetLimitWrappedActiveMQBuffer extends ChannelBufferWrapper super.writeInt(value); } + @Override + public void writeNullableInt(final Integer value) { + changed(); + + super.writeNullableInt(value); + } + @Override public void writeLong(final long value) { changed(); @@ -311,6 +325,13 @@ public final class ResetLimitWrappedActiveMQBuffer extends ChannelBufferWrapper super.writeLong(value); } + @Override + public void writeNullableLong(final Long value) { + changed(); + + super.writeNullableLong(value); + } + @Override public void writeNullableSimpleString(final SimpleString val) { changed(); diff --git a/artemis-core-client/src/main/java/org/apache/activemq/artemis/core/client/impl/CompressedLargeMessageControllerImpl.java b/artemis-core-client/src/main/java/org/apache/activemq/artemis/core/client/impl/CompressedLargeMessageControllerImpl.java index ce652d20f0..5c33fafd4d 100644 --- a/artemis-core-client/src/main/java/org/apache/activemq/artemis/core/client/impl/CompressedLargeMessageControllerImpl.java +++ b/artemis-core-client/src/main/java/org/apache/activemq/artemis/core/client/impl/CompressedLargeMessageControllerImpl.java @@ -375,6 +375,16 @@ final class CompressedLargeMessageControllerImpl implements LargeMessageControll } } + @Override + public Integer readNullableInt() { + int b = readByte(); + if (b == DataConstants.NULL) { + return null; + } else { + return readInt(); + } + } + @Override public long readUnsignedInt() { return readInt() & 0xFFFFFFFFL; @@ -389,6 +399,16 @@ final class CompressedLargeMessageControllerImpl implements LargeMessageControll } } + @Override + public Long readNullableLong() { + int b = readByte(); + if (b == DataConstants.NULL) { + return null; + } else { + return readLong(); + } + } + @Override public void readBytes(final byte[] dst, final int dstIndex, final int length) { try { @@ -487,11 +507,21 @@ final class CompressedLargeMessageControllerImpl implements LargeMessageControll throw new IllegalAccessError(OPERATION_NOT_SUPPORTED); } + @Override + public void writeNullableInt(final Integer value) { + throw new IllegalAccessError(OPERATION_NOT_SUPPORTED); + } + @Override public void writeLong(final long value) { throw new IllegalAccessError(OPERATION_NOT_SUPPORTED); } + @Override + public void writeNullableLong(final Long value) { + throw new IllegalAccessError(OPERATION_NOT_SUPPORTED); + } + @Override public void writeBytes(final byte[] src, final int srcIndex, final int length) { throw new IllegalAccessError(OPERATION_NOT_SUPPORTED); @@ -532,6 +562,16 @@ final class CompressedLargeMessageControllerImpl implements LargeMessageControll return readByte() != 0; } + @Override + public Boolean readNullableBoolean() { + int b = readByte(); + if (b == DataConstants.NULL) { + return null; + } else { + return readBoolean(); + } + } + @Override public char readChar() { return (char) readShort(); @@ -624,6 +664,11 @@ final class CompressedLargeMessageControllerImpl implements LargeMessageControll throw new IllegalAccessError(OPERATION_NOT_SUPPORTED); } + @Override + public void writeNullableBoolean(final Boolean val) { + throw new IllegalAccessError(OPERATION_NOT_SUPPORTED); + } + @Override public void writeChar(final char val) { throw new IllegalAccessError(OPERATION_NOT_SUPPORTED); diff --git a/artemis-core-client/src/main/java/org/apache/activemq/artemis/core/client/impl/LargeMessageControllerImpl.java b/artemis-core-client/src/main/java/org/apache/activemq/artemis/core/client/impl/LargeMessageControllerImpl.java index d5d1c82242..f08e2b82d3 100644 --- a/artemis-core-client/src/main/java/org/apache/activemq/artemis/core/client/impl/LargeMessageControllerImpl.java +++ b/artemis-core-client/src/main/java/org/apache/activemq/artemis/core/client/impl/LargeMessageControllerImpl.java @@ -744,6 +744,16 @@ public class LargeMessageControllerImpl implements LargeMessageController { return getInt(pos); } + @Override + public Integer readNullableInt() { + int b = readByte(); + if (b == DataConstants.NULL) { + return null; + } else { + return readInt(); + } + } + @Override public long readUnsignedInt() { return readInt() & 0xFFFFFFFFL; @@ -756,6 +766,16 @@ public class LargeMessageControllerImpl implements LargeMessageController { return v; } + @Override + public Long readNullableLong() { + int b = readByte(); + if (b == DataConstants.NULL) { + return null; + } else { + return readLong(); + } + } + @Override public void readBytes(final byte[] dst, final int dstIndex, final int length) { getBytes(readerIndex, dst, dstIndex, length); @@ -833,11 +853,21 @@ public class LargeMessageControllerImpl implements LargeMessageController { throw new IllegalAccessError(LargeMessageControllerImpl.READ_ONLY_ERROR_MESSAGE); } + @Override + public void writeNullableInt(final Integer value) { + throw new IllegalAccessError(LargeMessageControllerImpl.READ_ONLY_ERROR_MESSAGE); + } + @Override public void writeLong(final long value) { throw new IllegalAccessError(LargeMessageControllerImpl.READ_ONLY_ERROR_MESSAGE); } + @Override + public void writeNullableLong(final Long value) { + throw new IllegalAccessError(LargeMessageControllerImpl.READ_ONLY_ERROR_MESSAGE); + } + @Override public void writeBytes(final byte[] src, final int srcIndex, final int length) { throw new IllegalAccessError(LargeMessageControllerImpl.READ_ONLY_ERROR_MESSAGE); @@ -915,6 +945,16 @@ public class LargeMessageControllerImpl implements LargeMessageController { return readByte() != 0; } + @Override + public Boolean readNullableBoolean() { + int b = readByte(); + if (b == DataConstants.NULL) { + return null; + } else { + return readBoolean(); + } + } + @Override public char readChar() { return (char) readShort(); @@ -1008,6 +1048,11 @@ public class LargeMessageControllerImpl implements LargeMessageController { throw new IllegalAccessError(LargeMessageControllerImpl.READ_ONLY_ERROR_MESSAGE); } + @Override + public void writeNullableBoolean(final Boolean val) { + throw new IllegalAccessError(LargeMessageControllerImpl.READ_ONLY_ERROR_MESSAGE); + } + @Override public void writeChar(final char val) { throw new IllegalAccessError(LargeMessageControllerImpl.READ_ONLY_ERROR_MESSAGE); diff --git a/artemis-server/src/main/java/org/apache/activemq/artemis/core/config/FederationConfiguration.java b/artemis-core-client/src/main/java/org/apache/activemq/artemis/core/config/FederationConfiguration.java similarity index 80% rename from artemis-server/src/main/java/org/apache/activemq/artemis/core/config/FederationConfiguration.java rename to artemis-core-client/src/main/java/org/apache/activemq/artemis/core/config/FederationConfiguration.java index a9973f628d..a42040adeb 100644 --- a/artemis-server/src/main/java/org/apache/activemq/artemis/core/config/FederationConfiguration.java +++ b/artemis-core-client/src/main/java/org/apache/activemq/artemis/core/config/FederationConfiguration.java @@ -22,6 +22,9 @@ import java.util.HashMap; import java.util.List; import java.util.Map; import java.util.Objects; + +import org.apache.activemq.artemis.api.core.ActiveMQBuffer; +import org.apache.activemq.artemis.core.config.federation.FederationDownstreamConfiguration; import org.apache.activemq.artemis.core.config.federation.FederationPolicy; import org.apache.activemq.artemis.core.config.federation.FederationTransformerConfiguration; import org.apache.activemq.artemis.core.config.federation.FederationUpstreamConfiguration; @@ -34,6 +37,8 @@ public class FederationConfiguration implements Serializable { private List upstreamConfigurations = new ArrayList<>(); + private List downstreamConfigurations = new ArrayList<>(); + private Map federationPolicyMap = new HashMap<>(); private Map transformerConfigurationMap = new HashMap<>(); @@ -47,11 +52,28 @@ public class FederationConfiguration implements Serializable { return this; } + public List getDownstreamConfigurations() { + return downstreamConfigurations; + } + + public FederationConfiguration addDownstreamConfiguration(FederationDownstreamConfiguration federationDownstreamConfiguration) { + this.downstreamConfigurations.add(federationDownstreamConfiguration); + return this; + } + public FederationConfiguration addFederationPolicy(FederationPolicy federationPolicy) { federationPolicyMap.put(federationPolicy.getName(), federationPolicy); return this; } + public void clearDownstreamConfigurations() { + this.downstreamConfigurations.clear(); + } + + public void clearUpstreamConfigurations() { + this.upstreamConfigurations.clear(); + } + public Map getFederationPolicyMap() { return federationPolicyMap; } @@ -121,6 +143,16 @@ public class FederationConfiguration implements Serializable { public int hashCode() { return Objects.hash(user, password); } + + public void encode(ActiveMQBuffer buffer) { + buffer.writeNullableString(user); + buffer.writeNullableString(password); + } + + public void decode(ActiveMQBuffer buffer) { + user = buffer.readNullableString(); + password = buffer.readNullableString(); + } } @Override diff --git a/artemis-server/src/main/java/org/apache/activemq/artemis/core/config/TransformerConfiguration.java b/artemis-core-client/src/main/java/org/apache/activemq/artemis/core/config/TransformerConfiguration.java similarity index 100% rename from artemis-server/src/main/java/org/apache/activemq/artemis/core/config/TransformerConfiguration.java rename to artemis-core-client/src/main/java/org/apache/activemq/artemis/core/config/TransformerConfiguration.java diff --git a/artemis-server/src/main/java/org/apache/activemq/artemis/core/config/federation/FederationAddressPolicyConfiguration.java b/artemis-core-client/src/main/java/org/apache/activemq/artemis/core/config/federation/FederationAddressPolicyConfiguration.java similarity index 70% rename from artemis-server/src/main/java/org/apache/activemq/artemis/core/config/federation/FederationAddressPolicyConfiguration.java rename to artemis-core-client/src/main/java/org/apache/activemq/artemis/core/config/federation/FederationAddressPolicyConfiguration.java index f41e5890b5..71188e692c 100644 --- a/artemis-server/src/main/java/org/apache/activemq/artemis/core/config/federation/FederationAddressPolicyConfiguration.java +++ b/artemis-core-client/src/main/java/org/apache/activemq/artemis/core/config/federation/FederationAddressPolicyConfiguration.java @@ -21,6 +21,9 @@ import java.util.HashSet; import java.util.Objects; import java.util.Set; +import org.apache.activemq.artemis.api.core.ActiveMQBuffer; +import org.apache.activemq.artemis.utils.Preconditions; + public class FederationAddressPolicyConfiguration implements FederationPolicy, Serializable { private String name; @@ -106,6 +109,55 @@ public class FederationAddressPolicyConfiguration implements FederationPolicy(); + excludes = new HashSet<>(); + decodeMatchers(buffer, includes); + decodeMatchers(buffer, excludes); + + } + + private void encodeMatchers(final ActiveMQBuffer buffer, final Set matchers) { + buffer.writeInt(matchers == null ? 0 : matchers.size()); + if (matchers != null) { + for (Matcher matcher : matchers) { + matcher.encode(buffer); + } + } + } + + private void decodeMatchers(final ActiveMQBuffer buffer, final Set matchers) { + final int size = buffer.readInt(); + + for (int i = 0; i < size; i++) { + Matcher matcher = new Matcher(); + matcher.decode(buffer); + matchers.add(matcher); + } + } + public static class Matcher implements Serializable { private String addressMatch; @@ -131,6 +183,15 @@ public class FederationAddressPolicyConfiguration implements FederationPolicy staticConnectors; + private int priorityAdjustment; + + private long circuitBreakerTimeout = DEFAULT_CIRCUIT_BREAKER_TIMEOUT; + private String username; + private String password; + private boolean shareConnection; + + private long clientFailureCheckPeriod = ActiveMQDefaultConfiguration.getDefaultFederationFailureCheckPeriod(); + private long connectionTTL = ActiveMQDefaultConfiguration.getDefaultFederationConnectionTtl(); + private long retryInterval = ActiveMQDefaultConfiguration.getDefaultFederationRetryInterval(); + private double retryIntervalMultiplier = ActiveMQDefaultConfiguration.getDefaultFederationRetryIntervalMultiplier(); + private long maxRetryInterval = ActiveMQDefaultConfiguration.getDefaultFederationMaxRetryInterval(); + private int initialConnectAttempts = ActiveMQDefaultConfiguration.getDefaultFederationInitialConnectAttempts(); + private int reconnectAttempts = ActiveMQDefaultConfiguration.getDefaultFederationReconnectAttempts(); + private long callTimeout = ActiveMQDefaultConfiguration.getDefaultFederationCallTimeout(); + private long callFailoverTimeout = ActiveMQDefaultConfiguration.getDefaultFederationCallFailoverTimeout(); + + public String getDiscoveryGroupName() { + return discoveryGroupName; + } + + public FederationConnectionConfiguration setDiscoveryGroupName(String discoveryGroupName) { + this.discoveryGroupName = discoveryGroupName; + return this; + } + + public List getStaticConnectors() { + return staticConnectors; + } + + public FederationConnectionConfiguration setStaticConnectors(List staticConnectors) { + this.staticConnectors = staticConnectors; + return this; + } + + public boolean isHA() { + return isHA; + } + + public FederationConnectionConfiguration setHA(boolean HA) { + isHA = HA; + return this; + } + + public long getCircuitBreakerTimeout() { + return circuitBreakerTimeout; + } + + public FederationConnectionConfiguration setCircuitBreakerTimeout(long circuitBreakerTimeout) { + this.circuitBreakerTimeout = circuitBreakerTimeout; + return this; + } + + public String getUsername() { + return username; + } + + public FederationConnectionConfiguration setUsername(String username) { + this.username = username; + return this; + } + + public String getPassword() { + return password; + } + + public FederationConnectionConfiguration setPassword(String password) { + this.password = password; + return this; + } + + public int getPriorityAdjustment() { + return priorityAdjustment; + } + + public FederationConnectionConfiguration setPriorityAdjustment(int priorityAdjustment) { + this.priorityAdjustment = priorityAdjustment; + return this; + } + + public boolean isShareConnection() { + return shareConnection; + } + + public FederationConnectionConfiguration setShareConnection(boolean shareConnection) { + this.shareConnection = shareConnection; + return this; + } + + public long getClientFailureCheckPeriod() { + return clientFailureCheckPeriod; + } + + public FederationConnectionConfiguration setClientFailureCheckPeriod(long clientFailureCheckPeriod) { + this.clientFailureCheckPeriod = clientFailureCheckPeriod; + return this; + } + + public long getConnectionTTL() { + return connectionTTL; + } + + public FederationConnectionConfiguration setConnectionTTL(long connectionTTL) { + this.connectionTTL = connectionTTL; + return this; + } + + public long getRetryInterval() { + return retryInterval; + } + + public FederationConnectionConfiguration setRetryInterval(long retryInterval) { + this.retryInterval = retryInterval; + return this; + } + + public double getRetryIntervalMultiplier() { + return retryIntervalMultiplier; + } + + public FederationConnectionConfiguration setRetryIntervalMultiplier(double retryIntervalMultiplier) { + this.retryIntervalMultiplier = retryIntervalMultiplier; + return this; + } + + public long getMaxRetryInterval() { + return maxRetryInterval; + } + + public FederationConnectionConfiguration setMaxRetryInterval(long maxRetryInterval) { + this.maxRetryInterval = maxRetryInterval; + return this; + } + + public int getInitialConnectAttempts() { + return initialConnectAttempts; + } + + public FederationConnectionConfiguration setInitialConnectAttempts(int initialConnectAttempts) { + this.initialConnectAttempts = initialConnectAttempts; + return this; + } + + public int getReconnectAttempts() { + return reconnectAttempts; + } + + public FederationConnectionConfiguration setReconnectAttempts(int reconnectAttempts) { + this.reconnectAttempts = reconnectAttempts; + return this; + } + + public long getCallTimeout() { + return callTimeout; + } + + public FederationConnectionConfiguration setCallTimeout(long callTimeout) { + this.callTimeout = callTimeout; + return this; + } + + public long getCallFailoverTimeout() { + return callFailoverTimeout; + } + + public FederationConnectionConfiguration setCallFailoverTimeout(long callFailoverTimeout) { + this.callFailoverTimeout = callFailoverTimeout; + return this; + } + + @Override + public boolean equals(Object o) { + if (this == o) { + return true; + } + if (o == null || getClass() != o.getClass()) { + return false; + } + FederationConnectionConfiguration that = (FederationConnectionConfiguration) o; + return clientFailureCheckPeriod == that.clientFailureCheckPeriod && + connectionTTL == that.connectionTTL && + retryInterval == that.retryInterval && + Double.compare(that.retryIntervalMultiplier, retryIntervalMultiplier) == 0 && + maxRetryInterval == that.maxRetryInterval && + initialConnectAttempts == that.initialConnectAttempts && + reconnectAttempts == that.reconnectAttempts && + callTimeout == that.callTimeout && + callFailoverTimeout == that.callFailoverTimeout && + isHA == that.isHA && + priorityAdjustment == that.priorityAdjustment && + circuitBreakerTimeout == that.circuitBreakerTimeout && + shareConnection == that.shareConnection && + Objects.equals(discoveryGroupName, that.discoveryGroupName) && + Objects.equals(staticConnectors, that.staticConnectors) && + Objects.equals(username, that.username) && + Objects.equals(password, that.password); + } + + @Override + public int hashCode() { + return Objects + .hash(clientFailureCheckPeriod, connectionTTL, retryInterval, retryIntervalMultiplier, + maxRetryInterval, initialConnectAttempts, reconnectAttempts, callTimeout, + callFailoverTimeout, isHA, discoveryGroupName, staticConnectors, priorityAdjustment, + circuitBreakerTimeout, username, password, shareConnection); + } + + public void encode(ActiveMQBuffer buffer) { + + buffer.writeNullableString(username); + buffer.writeNullableString(password); + buffer.writeBoolean(shareConnection); + buffer.writeInt(priorityAdjustment); + + buffer.writeLong(clientFailureCheckPeriod); + buffer.writeLong(connectionTTL); + buffer.writeLong(retryInterval); + buffer.writeDouble(retryIntervalMultiplier); + buffer.writeLong(retryInterval); + buffer.writeInt(initialConnectAttempts); + buffer.writeInt(reconnectAttempts); + buffer.writeLong(callTimeout); + buffer.writeLong(callFailoverTimeout); + } + + public void decode(ActiveMQBuffer buffer) { + username = buffer.readNullableString(); + password = buffer.readNullableString(); + shareConnection = buffer.readBoolean(); + priorityAdjustment = buffer.readInt(); + + clientFailureCheckPeriod = buffer.readLong(); + connectionTTL = buffer.readLong(); + retryInterval = buffer.readLong(); + retryIntervalMultiplier = buffer.readDouble(); + maxRetryInterval = buffer.readLong(); + initialConnectAttempts = buffer.readInt(); + reconnectAttempts = buffer.readInt(); + callTimeout = buffer.readLong(); + callFailoverTimeout = buffer.readLong(); + + } +} diff --git a/artemis-core-client/src/main/java/org/apache/activemq/artemis/core/config/federation/FederationDownstreamConfiguration.java b/artemis-core-client/src/main/java/org/apache/activemq/artemis/core/config/federation/FederationDownstreamConfiguration.java new file mode 100644 index 0000000000..7e8c5cf7cc --- /dev/null +++ b/artemis-core-client/src/main/java/org/apache/activemq/artemis/core/config/federation/FederationDownstreamConfiguration.java @@ -0,0 +1,96 @@ +/* + * 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.federation; + +import java.util.HashMap; +import java.util.Map; +import java.util.Objects; +import org.apache.activemq.artemis.api.core.ActiveMQBuffer; +import org.apache.activemq.artemis.api.core.TransportConfiguration; +import org.apache.activemq.artemis.core.remoting.impl.netty.TransportConstants; + +public class FederationDownstreamConfiguration extends FederationStreamConfiguration { + + private String upstreamConfigurationRef; + private TransportConfiguration upstreamConfiguration; + + public String getUpstreamConfigurationRef() { + return upstreamConfigurationRef; + } + + public void setUpstreamConfigurationRef(String upstreamConfigurationRef) { + this.upstreamConfigurationRef = upstreamConfigurationRef; + } + + public TransportConfiguration getUpstreamConfiguration() { + return upstreamConfiguration; + } + + public void setUpstreamConfiguration(TransportConfiguration transportConfiguration) { + + final Map params = new HashMap<>(transportConfiguration.getParams()); + + //clear any TLS settings as they won't apply to the federated server that uses this config + //The federated server that creates the upstream back will rely on its config from the acceptor for TLS + params.remove(TransportConstants.SSL_ENABLED_PROP_NAME); + params.remove(TransportConstants.SSL_PROVIDER); + params.remove(TransportConstants.SSL_KRB5_CONFIG_PROP_NAME); + params.remove(TransportConstants.KEYSTORE_PATH_PROP_NAME); + params.remove(TransportConstants.KEYSTORE_PASSWORD_PROP_NAME); + params.remove(TransportConstants.KEYSTORE_PROVIDER_PROP_NAME); + params.remove(TransportConstants.TRUSTSTORE_PATH_PROP_NAME); + params.remove(TransportConstants.TRUSTSTORE_PASSWORD_PROP_NAME); + params.remove(TransportConstants.TRUSTSTORE_PROVIDER_PROP_NAME); + + this.upstreamConfiguration = new TransportConfiguration(transportConfiguration.getFactoryClassName(), params, + transportConfiguration.getName(), transportConfiguration.getExtraParams()); + } + + @Override + public void encode(ActiveMQBuffer buffer) { + super.encode(buffer); + upstreamConfiguration.encode(buffer); + } + + @Override + public void decode(ActiveMQBuffer buffer) { + super.decode(buffer); + upstreamConfiguration = new TransportConfiguration(); + upstreamConfiguration.decode(buffer); + } + + @Override + public boolean equals(Object o) { + if (this == o) { + return true; + } + if (o == null || getClass() != o.getClass()) { + return false; + } + if (!super.equals(o)) { + return false; + } + FederationDownstreamConfiguration that = (FederationDownstreamConfiguration) o; + return Objects.equals(upstreamConfigurationRef, that.upstreamConfigurationRef) && + Objects.equals(upstreamConfiguration, that.upstreamConfiguration); + } + + @Override + public int hashCode() { + return Objects.hash(super.hashCode(), upstreamConfigurationRef, upstreamConfiguration); + } +} diff --git a/artemis-server/src/main/java/org/apache/activemq/artemis/core/config/federation/FederationPolicy.java b/artemis-core-client/src/main/java/org/apache/activemq/artemis/core/config/federation/FederationPolicy.java similarity index 87% rename from artemis-server/src/main/java/org/apache/activemq/artemis/core/config/federation/FederationPolicy.java rename to artemis-core-client/src/main/java/org/apache/activemq/artemis/core/config/federation/FederationPolicy.java index 870fb6e120..d8d9d5eebb 100644 --- a/artemis-server/src/main/java/org/apache/activemq/artemis/core/config/federation/FederationPolicy.java +++ b/artemis-core-client/src/main/java/org/apache/activemq/artemis/core/config/federation/FederationPolicy.java @@ -16,9 +16,16 @@ */ package org.apache.activemq.artemis.core.config.federation; +import org.apache.activemq.artemis.api.core.ActiveMQBuffer; + public interface FederationPolicy { String getName(); T setName(String name); + + void encode(ActiveMQBuffer buffer); + + void decode(ActiveMQBuffer buffer); + } diff --git a/artemis-server/src/main/java/org/apache/activemq/artemis/core/config/federation/FederationPolicySet.java b/artemis-core-client/src/main/java/org/apache/activemq/artemis/core/config/federation/FederationPolicySet.java similarity index 72% rename from artemis-server/src/main/java/org/apache/activemq/artemis/core/config/federation/FederationPolicySet.java rename to artemis-core-client/src/main/java/org/apache/activemq/artemis/core/config/federation/FederationPolicySet.java index 4af0bb7cca..4e19181ed1 100644 --- a/artemis-server/src/main/java/org/apache/activemq/artemis/core/config/federation/FederationPolicySet.java +++ b/artemis-core-client/src/main/java/org/apache/activemq/artemis/core/config/federation/FederationPolicySet.java @@ -22,6 +22,9 @@ import java.util.HashSet; import java.util.Objects; import java.util.Set; +import org.apache.activemq.artemis.api.core.ActiveMQBuffer; +import org.apache.activemq.artemis.utils.Preconditions; + public class FederationPolicySet implements FederationPolicy, Serializable { private String name; @@ -65,4 +68,29 @@ public class FederationPolicySet implements FederationPolicy(); + + for (int i = 0; i < policyRefsSize; i++) { + policyRefs.add(buffer.readString()); + } + } } diff --git a/artemis-server/src/main/java/org/apache/activemq/artemis/core/config/federation/FederationQueuePolicyConfiguration.java b/artemis-core-client/src/main/java/org/apache/activemq/artemis/core/config/federation/FederationQueuePolicyConfiguration.java similarity index 70% rename from artemis-server/src/main/java/org/apache/activemq/artemis/core/config/federation/FederationQueuePolicyConfiguration.java rename to artemis-core-client/src/main/java/org/apache/activemq/artemis/core/config/federation/FederationQueuePolicyConfiguration.java index 34a8632629..3294165669 100644 --- a/artemis-server/src/main/java/org/apache/activemq/artemis/core/config/federation/FederationQueuePolicyConfiguration.java +++ b/artemis-core-client/src/main/java/org/apache/activemq/artemis/core/config/federation/FederationQueuePolicyConfiguration.java @@ -21,6 +21,9 @@ import java.util.HashSet; import java.util.Objects; import java.util.Set; +import org.apache.activemq.artemis.api.core.ActiveMQBuffer; +import org.apache.activemq.artemis.utils.Preconditions; + public class FederationQueuePolicyConfiguration implements FederationPolicy, Serializable { private String name; @@ -86,6 +89,49 @@ public class FederationQueuePolicyConfiguration implements FederationPolicy(); + excludes = new HashSet<>(); + decodeMatchers(buffer, includes); + decodeMatchers(buffer, excludes); + } + + private void encodeMatchers(final ActiveMQBuffer buffer, final Set matchers) { + buffer.writeInt(matchers == null ? 0 : matchers.size()); + if (matchers != null) { + for (Matcher matcher : matchers) { + matcher.encode(buffer); + } + } + } + + private void decodeMatchers(final ActiveMQBuffer buffer, final Set matchers) { + final int size = buffer.readInt(); + + for (int i = 0; i < size; i++) { + Matcher matcher = new Matcher(); + matcher.decode(buffer); + matchers.add(matcher); + } + } + public static class Matcher implements Serializable { private String queueMatch; @@ -122,6 +168,16 @@ public class FederationQueuePolicyConfiguration implements FederationPolicy> implements Serializable { private String name; @@ -33,23 +35,23 @@ public class FederationUpstreamConfiguration implements Serializable { return name; } - public FederationUpstreamConfiguration setName(String name) { + public T setName(String name) { this.name = name; - return this; + return (T) this; } public Set getPolicyRefs() { return policyRefs; } - public FederationUpstreamConfiguration addPolicyRef(String name) { + public T addPolicyRef(String name) { policyRefs.add(name); - return this; + return (T) this; } - public FederationUpstreamConfiguration addPolicyRefs(Collection names) { + public T addPolicyRefs(Collection names) { policyRefs.addAll(names); - return this; + return (T) this; } public FederationConnectionConfiguration getConnectionConfiguration() { @@ -58,16 +60,35 @@ public class FederationUpstreamConfiguration implements Serializable { @Override public boolean equals(Object o) { - if (this == o) return true; - if (!(o instanceof FederationUpstreamConfiguration)) return false; - FederationUpstreamConfiguration that = (FederationUpstreamConfiguration) o; - return Objects.equals(name, that.name) && - Objects.equals(connectionConfiguration, that.connectionConfiguration) && - Objects.equals(policyRefs, that.policyRefs); + if (this == o) + return true; + if (!(o instanceof FederationStreamConfiguration)) + return false; + FederationStreamConfiguration that = (FederationStreamConfiguration) o; + return Objects.equals(name, that.name) && Objects.equals(connectionConfiguration, that.connectionConfiguration) && Objects.equals(policyRefs, that.policyRefs); } @Override public int hashCode() { return Objects.hash(name, connectionConfiguration, policyRefs); } + + public void encode(ActiveMQBuffer buffer) { + buffer.writeString(name); + connectionConfiguration.encode(buffer); + + buffer.writeInt(policyRefs == null ? 0 : policyRefs.size()); + for (String policyRef : policyRefs) { + buffer.writeString(policyRef); + } + } + + public void decode(ActiveMQBuffer buffer) { + name = buffer.readString(); + connectionConfiguration.decode(buffer); + int policyRefNum = buffer.readInt(); + for (int i = 0; i < policyRefNum; i++) { + policyRefs.add(buffer.readString()); + } + } } diff --git a/artemis-server/src/main/java/org/apache/activemq/artemis/core/config/federation/FederationTransformerConfiguration.java b/artemis-core-client/src/main/java/org/apache/activemq/artemis/core/config/federation/FederationTransformerConfiguration.java similarity index 60% rename from artemis-server/src/main/java/org/apache/activemq/artemis/core/config/federation/FederationTransformerConfiguration.java rename to artemis-core-client/src/main/java/org/apache/activemq/artemis/core/config/federation/FederationTransformerConfiguration.java index 003ed33362..2a16883fdd 100644 --- a/artemis-server/src/main/java/org/apache/activemq/artemis/core/config/federation/FederationTransformerConfiguration.java +++ b/artemis-core-client/src/main/java/org/apache/activemq/artemis/core/config/federation/FederationTransformerConfiguration.java @@ -17,8 +17,12 @@ package org.apache.activemq.artemis.core.config.federation; import java.io.Serializable; +import java.util.Map; import java.util.Objects; + +import org.apache.activemq.artemis.api.core.ActiveMQBuffer; import org.apache.activemq.artemis.core.config.TransformerConfiguration; +import org.apache.activemq.artemis.utils.Preconditions; public class FederationTransformerConfiguration implements Serializable { @@ -26,6 +30,9 @@ public class FederationTransformerConfiguration implements Serializable { private TransformerConfiguration transformerConfiguration; + public FederationTransformerConfiguration() { + } + public FederationTransformerConfiguration(String name, TransformerConfiguration transformerConfiguration) { this.name = name; this.transformerConfiguration = transformerConfiguration; @@ -52,4 +59,30 @@ public class FederationTransformerConfiguration implements Serializable { public int hashCode() { return Objects.hash(name, transformerConfiguration); } + + + public void encode(ActiveMQBuffer buffer) { + Preconditions.checkArgument(name != null, "name can not be null"); + Preconditions.checkArgument(transformerConfiguration != null, "transformerConfiguration can not be null"); + buffer.writeString(name); + + buffer.writeString(transformerConfiguration.getClassName()); + buffer.writeInt(transformerConfiguration.getProperties() == null ? 0 : transformerConfiguration.getProperties().size()); + if (transformerConfiguration.getProperties() != null) { + for (Map.Entry entry : transformerConfiguration.getProperties().entrySet()) { + buffer.writeString(entry.getKey()); + buffer.writeString(entry.getValue()); + } + } + } + + public void decode(ActiveMQBuffer buffer) { + name = buffer.readString(); + transformerConfiguration = new TransformerConfiguration(buffer.readString()); + + final int propertiesSize = buffer.readInt(); + for (int i = 0; i < propertiesSize; i++) { + transformerConfiguration.getProperties().put(buffer.readString(), buffer.readString()); + } + } } diff --git a/artemis-core-client/src/main/java/org/apache/activemq/artemis/core/config/federation/FederationUpstreamConfiguration.java b/artemis-core-client/src/main/java/org/apache/activemq/artemis/core/config/federation/FederationUpstreamConfiguration.java new file mode 100644 index 0000000000..e2c0a833cd --- /dev/null +++ b/artemis-core-client/src/main/java/org/apache/activemq/artemis/core/config/federation/FederationUpstreamConfiguration.java @@ -0,0 +1,21 @@ +/* + * 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.federation; + +public class FederationUpstreamConfiguration extends FederationStreamConfiguration { + +} diff --git a/artemis-core-client/src/main/java/org/apache/activemq/artemis/core/protocol/core/impl/ChannelImpl.java b/artemis-core-client/src/main/java/org/apache/activemq/artemis/core/protocol/core/impl/ChannelImpl.java index 154ab8aa80..84cc135fcf 100644 --- a/artemis-core-client/src/main/java/org/apache/activemq/artemis/core/protocol/core/impl/ChannelImpl.java +++ b/artemis-core-client/src/main/java/org/apache/activemq/artemis/core/protocol/core/impl/ChannelImpl.java @@ -64,6 +64,9 @@ public final class ChannelImpl implements Channel { * cluster used for controlling nodes in a cluster remotely */ CLUSTER(3), + + FEDERATION(4), + /** * Channels [0-9] are reserved for the system, user channels must be greater than that. */ diff --git a/artemis-core-client/src/main/java/org/apache/activemq/artemis/core/protocol/core/impl/PacketDecoder.java b/artemis-core-client/src/main/java/org/apache/activemq/artemis/core/protocol/core/impl/PacketDecoder.java index f576feaf5e..9cc62b25a6 100644 --- a/artemis-core-client/src/main/java/org/apache/activemq/artemis/core/protocol/core/impl/PacketDecoder.java +++ b/artemis-core-client/src/main/java/org/apache/activemq/artemis/core/protocol/core/impl/PacketDecoder.java @@ -40,6 +40,7 @@ import org.apache.activemq.artemis.core.protocol.core.impl.wireformat.Disconnect import org.apache.activemq.artemis.core.protocol.core.impl.wireformat.DisconnectConsumerWithKillMessage; import org.apache.activemq.artemis.core.protocol.core.impl.wireformat.DisconnectMessage; import org.apache.activemq.artemis.core.protocol.core.impl.wireformat.DisconnectMessage_V2; +import org.apache.activemq.artemis.core.protocol.core.impl.wireformat.FederationDownstreamConnectMessage; import org.apache.activemq.artemis.core.protocol.core.impl.wireformat.NullResponseMessage; import org.apache.activemq.artemis.core.protocol.core.impl.wireformat.NullResponseMessage_V2; import org.apache.activemq.artemis.core.protocol.core.impl.wireformat.PacketsConfirmedMessage; @@ -109,6 +110,7 @@ import static org.apache.activemq.artemis.core.protocol.core.impl.PacketImpl.DIS import static org.apache.activemq.artemis.core.protocol.core.impl.PacketImpl.DISCONNECT_CONSUMER; import static org.apache.activemq.artemis.core.protocol.core.impl.PacketImpl.DISCONNECT_V2; import static org.apache.activemq.artemis.core.protocol.core.impl.PacketImpl.EXCEPTION; +import static org.apache.activemq.artemis.core.protocol.core.impl.PacketImpl.FEDERATION_DOWNSTREAM_CONNECT; import static org.apache.activemq.artemis.core.protocol.core.impl.PacketImpl.NULL_RESPONSE; import static org.apache.activemq.artemis.core.protocol.core.impl.PacketImpl.PACKETS_CONFIRMED; import static org.apache.activemq.artemis.core.protocol.core.impl.PacketImpl.PING; @@ -471,6 +473,10 @@ public abstract class PacketDecoder implements Serializable { packet = new DisconnectConsumerWithKillMessage(); break; } + case FEDERATION_DOWNSTREAM_CONNECT: { + packet = new FederationDownstreamConnectMessage(); + break; + } default: { throw ActiveMQClientMessageBundle.BUNDLE.invalidType(packetType); } diff --git a/artemis-core-client/src/main/java/org/apache/activemq/artemis/core/protocol/core/impl/PacketImpl.java b/artemis-core-client/src/main/java/org/apache/activemq/artemis/core/protocol/core/impl/PacketImpl.java index f8f85e8a42..aea8b39e39 100644 --- a/artemis-core-client/src/main/java/org/apache/activemq/artemis/core/protocol/core/impl/PacketImpl.java +++ b/artemis-core-client/src/main/java/org/apache/activemq/artemis/core/protocol/core/impl/PacketImpl.java @@ -277,6 +277,8 @@ public class PacketImpl implements Packet { public static final byte SESS_BINDINGQUERY_RESP_V4 = -15; + public static final byte FEDERATION_DOWNSTREAM_CONNECT = -16; + // Static -------------------------------------------------------- diff --git a/artemis-core-client/src/main/java/org/apache/activemq/artemis/core/protocol/core/impl/wireformat/FederationDownstreamConnectMessage.java b/artemis-core-client/src/main/java/org/apache/activemq/artemis/core/protocol/core/impl/wireformat/FederationDownstreamConnectMessage.java new file mode 100644 index 0000000000..5f74629b62 --- /dev/null +++ b/artemis-core-client/src/main/java/org/apache/activemq/artemis/core/protocol/core/impl/wireformat/FederationDownstreamConnectMessage.java @@ -0,0 +1,36 @@ +/* + * 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.protocol.core.impl.wireformat; + +import org.apache.activemq.artemis.api.core.ActiveMQBuffer; +import org.apache.activemq.artemis.core.config.federation.FederationDownstreamConfiguration; + +public class FederationDownstreamConnectMessage extends FederationStreamConnectMessage { + + public static final String UPSTREAM_SUFFIX = "-upstream"; + + public FederationDownstreamConnectMessage() { + super(FEDERATION_DOWNSTREAM_CONNECT); + } + + @Override + protected FederationDownstreamConfiguration decodeStreamConfiguration(ActiveMQBuffer buffer) { + final FederationDownstreamConfiguration downstreamConfiguration = new FederationDownstreamConfiguration(); + downstreamConfiguration.decode(buffer); + return downstreamConfiguration; + } +} diff --git a/artemis-core-client/src/main/java/org/apache/activemq/artemis/core/protocol/core/impl/wireformat/FederationStreamConnectMessage.java b/artemis-core-client/src/main/java/org/apache/activemq/artemis/core/protocol/core/impl/wireformat/FederationStreamConnectMessage.java new file mode 100644 index 0000000000..1b2a28d4f3 --- /dev/null +++ b/artemis-core-client/src/main/java/org/apache/activemq/artemis/core/protocol/core/impl/wireformat/FederationStreamConnectMessage.java @@ -0,0 +1,156 @@ +/* + * 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.protocol.core.impl.wireformat; + +import java.util.HashMap; +import java.util.Map; + +import org.apache.activemq.artemis.api.core.ActiveMQBuffer; +import org.apache.activemq.artemis.core.config.FederationConfiguration.Credentials; +import org.apache.activemq.artemis.core.config.federation.FederationPolicy; +import org.apache.activemq.artemis.core.config.federation.FederationStreamConfiguration; +import org.apache.activemq.artemis.core.config.federation.FederationTransformerConfiguration; +import org.apache.activemq.artemis.core.protocol.core.impl.PacketImpl; +import org.apache.activemq.artemis.utils.Preconditions; + +public abstract class FederationStreamConnectMessage extends PacketImpl { + + private String name; + private Credentials credentials; + private Map federationPolicyMap = new HashMap<>(); + private Map transformerConfigurationMap = new HashMap<>(); + private T streamConfiguration; + + public FederationStreamConnectMessage(final byte type) { + super(type); + } + + public String getName() { + return name; + } + + public void setName(String name) { + this.name = name; + } + + public Credentials getCredentials() { + return credentials; + } + + public void setCredentials( + Credentials credentials) { + this.credentials = credentials; + } + + public T getStreamConfiguration() { + return streamConfiguration; + } + + public void setStreamConfiguration(T streamConfiguration) { + this.streamConfiguration = streamConfiguration; + } + + public Map getFederationPolicyMap() { + return federationPolicyMap; + } + + public void setFederationPolicyMap( + Map federationPolicyMap) { + this.federationPolicyMap = federationPolicyMap; + } + + public Map getTransformerConfigurationMap() { + return transformerConfigurationMap; + } + + public void setTransformerConfigurationMap( + Map transformerConfigurationMap) { + this.transformerConfigurationMap = transformerConfigurationMap; + } + + @Override + public void encodeRest(ActiveMQBuffer buffer) { + Preconditions.checkNotNull(streamConfiguration); + + super.encodeRest(buffer); + buffer.writeString(name); + + if (credentials != null) { + buffer.writeBoolean(true); + credentials.encode(buffer); + } else { + buffer.writeBoolean(false); + } + + buffer.writeInt(federationPolicyMap == null ? 0 : federationPolicyMap.size()); + if (federationPolicyMap != null) { + for (FederationPolicy policy : federationPolicyMap.values()) { + buffer.writeString(policy.getClass().getName()); + policy.encode(buffer); + } + } + + buffer.writeInt(transformerConfigurationMap == null ? 0 : transformerConfigurationMap.size()); + if (transformerConfigurationMap != null) { + for (FederationTransformerConfiguration transformerConfiguration : transformerConfigurationMap.values()) { + transformerConfiguration.encode(buffer); + } + } + + streamConfiguration.encode(buffer); + } + + @Override + public void decodeRest(ActiveMQBuffer buffer) { + super.decodeRest(buffer); + + this.name = buffer.readString(); + boolean hasCredentials = buffer.readBoolean(); + if (hasCredentials) { + credentials = new Credentials(); + credentials.decode(buffer); + } + + int policySize = buffer.readInt(); + for (int i = 0; i < policySize; i++) { + String clazz = buffer.readString(); + FederationPolicy policy = getFederationPolicy(clazz); + policy.decode(buffer); + federationPolicyMap.put(policy.getName(), policy); + } + + int transformerSize = buffer.readInt(); + for (int i = 0; i < transformerSize; i++) { + FederationTransformerConfiguration transformerConfiguration + = new FederationTransformerConfiguration(); + transformerConfiguration.decode(buffer); + transformerConfigurationMap.put(transformerConfiguration.getName(), transformerConfiguration); + } + + streamConfiguration = decodeStreamConfiguration(buffer); + } + + protected abstract T decodeStreamConfiguration(ActiveMQBuffer buffer); + + private FederationPolicy getFederationPolicy(String clazz) { + try { + return (FederationPolicy) Class.forName(clazz).getConstructor(null).newInstance(); + } catch (Exception e) { + throw new IllegalStateException("Error. Unable to instantiate FederationPolicy: " + e.getMessage(), e); + } + } +} diff --git a/artemis-server/src/main/java/org/apache/activemq/artemis/core/config/federation/FederationConnectionConfiguration.java b/artemis-server/src/main/java/org/apache/activemq/artemis/core/config/federation/FederationConnectionConfiguration.java deleted file mode 100644 index 78a69553d3..0000000000 --- a/artemis-server/src/main/java/org/apache/activemq/artemis/core/config/federation/FederationConnectionConfiguration.java +++ /dev/null @@ -1,117 +0,0 @@ -/* - * 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.federation; - -import java.io.Serializable; -import java.util.List; -import java.util.Objects; - -public class FederationConnectionConfiguration implements Serializable { - - public static long DEFAULT_CIRCUIT_BREAKER_TIMEOUT = 30000; - - private boolean isHA; - private String discoveryGroupName; - private List staticConnectors; - private int priorityAdjustment; - - private long circuitBreakerTimeout = DEFAULT_CIRCUIT_BREAKER_TIMEOUT; - private String username; - private String password; - - public String getDiscoveryGroupName() { - return discoveryGroupName; - } - - public FederationConnectionConfiguration setDiscoveryGroupName(String discoveryGroupName) { - this.discoveryGroupName = discoveryGroupName; - return this; - } - - public List getStaticConnectors() { - return staticConnectors; - } - - public FederationConnectionConfiguration setStaticConnectors(List staticConnectors) { - this.staticConnectors = staticConnectors; - return this; - } - - public boolean isHA() { - return isHA; - } - - public FederationConnectionConfiguration setHA(boolean HA) { - isHA = HA; - return this; - } - - public long getCircuitBreakerTimeout() { - return circuitBreakerTimeout; - } - - public FederationConnectionConfiguration setCircuitBreakerTimeout(long circuitBreakerTimeout) { - this.circuitBreakerTimeout = circuitBreakerTimeout; - return this; - } - - public String getUsername() { - return username; - } - - public FederationConnectionConfiguration setUsername(String username) { - this.username = username; - return this; - } - - public String getPassword() { - return password; - } - - public FederationConnectionConfiguration setPassword(String password) { - this.password = password; - return this; - } - - public int getPriorityAdjustment() { - return priorityAdjustment; - } - - public FederationConnectionConfiguration setPriorityAdjustment(int priorityAdjustment) { - this.priorityAdjustment = priorityAdjustment; - return this; - } - - @Override - public boolean equals(Object o) { - if (this == o) return true; - if (!(o instanceof FederationConnectionConfiguration)) return false; - FederationConnectionConfiguration that = (FederationConnectionConfiguration) o; - return isHA == that.isHA && - circuitBreakerTimeout == that.circuitBreakerTimeout && - Objects.equals(discoveryGroupName, that.discoveryGroupName) && - Objects.equals(staticConnectors, that.staticConnectors) && - Objects.equals(priorityAdjustment, that.priorityAdjustment) && - Objects.equals(username, that.username) && - Objects.equals(password, that.password); - } - - @Override - public int hashCode() { - return Objects.hash(isHA, discoveryGroupName, staticConnectors, priorityAdjustment, circuitBreakerTimeout, username, password); - } -} diff --git a/artemis-server/src/main/java/org/apache/activemq/artemis/core/deployers/impl/FileConfigurationParser.java b/artemis-server/src/main/java/org/apache/activemq/artemis/core/deployers/impl/FileConfigurationParser.java index 648943c04e..ce4e39d1ce 100644 --- a/artemis-server/src/main/java/org/apache/activemq/artemis/core/deployers/impl/FileConfigurationParser.java +++ b/artemis-server/src/main/java/org/apache/activemq/artemis/core/deployers/impl/FileConfigurationParser.java @@ -57,8 +57,11 @@ import org.apache.activemq.artemis.core.config.ScaleDownConfiguration; import org.apache.activemq.artemis.core.config.TransformerConfiguration; import org.apache.activemq.artemis.core.config.WildcardConfiguration; import org.apache.activemq.artemis.core.config.federation.FederationAddressPolicyConfiguration; +import org.apache.activemq.artemis.core.config.federation.FederationDownstreamConfiguration; import org.apache.activemq.artemis.core.config.federation.FederationPolicySet; import org.apache.activemq.artemis.core.config.federation.FederationQueuePolicyConfiguration; +import org.apache.activemq.artemis.core.config.federation.FederationStreamConfiguration; +import org.apache.activemq.artemis.core.config.federation.FederationTransformerConfiguration; import org.apache.activemq.artemis.core.config.federation.FederationUpstreamConfiguration; import org.apache.activemq.artemis.core.config.ha.ColocatedPolicyConfiguration; import org.apache.activemq.artemis.core.config.ha.LiveOnlyPolicyConfiguration; @@ -2002,12 +2005,18 @@ public final class FileConfigurationParser extends XMLConfigurationUtil { if (child.getNodeName().equals("upstream")) { config.addUpstreamConfiguration(getUpstream((Element) child, mainConfig)); + } else if (child.getNodeName().equals("downstream")) { + config.addDownstreamConfiguration(getDownstream((Element) child, mainConfig)); } else if (child.getNodeName().equals("policy-set")) { config.addFederationPolicy(getPolicySet((Element)child, mainConfig)); } else if (child.getNodeName().equals("queue-policy")) { config.addFederationPolicy(getQueuePolicy((Element)child, mainConfig)); } else if (child.getNodeName().equals("address-policy")) { config.addFederationPolicy(getAddressPolicy((Element)child, mainConfig)); + } else if (child.getNodeName().equals("transformer")) { + TransformerConfiguration transformerConfiguration = getTransformerConfiguration(child); + config.addTransformerConfiguration(new FederationTransformerConfiguration( + ((Element)child).getAttribute("name"), transformerConfiguration)); } } @@ -2128,9 +2137,8 @@ public final class FileConfigurationParser extends XMLConfigurationUtil { return config; } - private FederationUpstreamConfiguration getUpstream(Element upstreamNode, final Configuration mainConfig) throws Exception { - - FederationUpstreamConfiguration config = new FederationUpstreamConfiguration(); + private T getFederationStream(final T config, final Element upstreamNode, + final Configuration mainConfig) throws Exception { String name = upstreamNode.getAttribute("name"); config.setName(name); @@ -2158,6 +2166,16 @@ public final class FileConfigurationParser extends XMLConfigurationUtil { long circuitBreakerTimeout = getLong(upstreamNode, "circuit-breaker-timeout", config.getConnectionConfiguration().getCircuitBreakerTimeout(), Validators.MINUS_ONE_OR_GE_ZERO); + long clientFailureCheckPeriod = getLong(upstreamNode, "check-period", ActiveMQDefaultConfiguration.getDefaultFederationFailureCheckPeriod(), Validators.GT_ZERO); + long connectionTTL = getLong(upstreamNode, "connection-ttl", ActiveMQDefaultConfiguration.getDefaultFederationConnectionTtl(), Validators.GT_ZERO); + long retryInterval = getLong(upstreamNode, "retry-interval", ActiveMQDefaultConfiguration.getDefaultFederationRetryInterval(), Validators.GT_ZERO); + long callTimeout = getLong(upstreamNode, "call-timeout", ActiveMQClient.DEFAULT_CALL_TIMEOUT, Validators.GT_ZERO); + long callFailoverTimeout = getLong(upstreamNode, "call-failover-timeout", ActiveMQClient.DEFAULT_CALL_FAILOVER_TIMEOUT, Validators.MINUS_ONE_OR_GT_ZERO); + double retryIntervalMultiplier = getDouble(upstreamNode, "retry-interval-multiplier", ActiveMQDefaultConfiguration.getDefaultFederationRetryIntervalMultiplier(), Validators.GT_ZERO); + long maxRetryInterval = getLong(upstreamNode, "max-retry-interval", ActiveMQDefaultConfiguration.getDefaultFederationMaxRetryInterval(), Validators.GT_ZERO); + int initialConnectAttempts = getInteger(upstreamNode, "initial-connect-attempts", ActiveMQDefaultConfiguration.getDefaultFederationInitialConnectAttempts(), Validators.MINUS_ONE_OR_GE_ZERO); + int reconnectAttempts = getInteger(upstreamNode, "reconnect-attempts", ActiveMQDefaultConfiguration.getDefaultFederationReconnectAttempts(), Validators.MINUS_ONE_OR_GE_ZERO); + List staticConnectorNames = new ArrayList<>(); String discoveryGroupName = null; @@ -2181,8 +2199,17 @@ public final class FileConfigurationParser extends XMLConfigurationUtil { config.addPolicyRefs(policyRefs); config.getConnectionConfiguration() - .setCircuitBreakerTimeout(circuitBreakerTimeout) - .setHA(ha); + .setCircuitBreakerTimeout(circuitBreakerTimeout) + .setHA(ha) + .setClientFailureCheckPeriod(clientFailureCheckPeriod) + .setConnectionTTL(connectionTTL) + .setRetryInterval(retryInterval) + .setRetryIntervalMultiplier(retryIntervalMultiplier) + .setMaxRetryInterval(maxRetryInterval) + .setInitialConnectAttempts(initialConnectAttempts) + .setReconnectAttempts(reconnectAttempts) + .setCallTimeout(callTimeout) + .setCallFailoverTimeout(callFailoverTimeout); if (!staticConnectorNames.isEmpty()) { config.getConnectionConfiguration().setStaticConnectors(staticConnectorNames); @@ -2192,6 +2219,20 @@ public final class FileConfigurationParser extends XMLConfigurationUtil { return config; } + private FederationUpstreamConfiguration getUpstream(final Element upstreamNode, final Configuration mainConfig) throws Exception { + return getFederationStream(new FederationUpstreamConfiguration(), upstreamNode, mainConfig); + } + + private FederationDownstreamConfiguration getDownstream(final Element downstreamNode, final Configuration mainConfig) throws Exception { + final FederationDownstreamConfiguration downstreamConfiguration = + getFederationStream(new FederationDownstreamConfiguration(), downstreamNode, mainConfig); + + final String upstreamRef = getString(downstreamNode,"upstream-connector-ref", null, Validators.NOT_NULL_OR_EMPTY); + downstreamConfiguration.setUpstreamConfigurationRef(upstreamRef); + + return downstreamConfiguration; + } + private void getStaticConnectors(List staticConnectorNames, Node child) { NodeList children2 = ((Element) child).getElementsByTagName("connector-ref"); diff --git a/artemis-server/src/main/java/org/apache/activemq/artemis/core/protocol/ServerPacketDecoder.java b/artemis-server/src/main/java/org/apache/activemq/artemis/core/protocol/ServerPacketDecoder.java index 0428abebd0..311cd30e1b 100644 --- a/artemis-server/src/main/java/org/apache/activemq/artemis/core/protocol/ServerPacketDecoder.java +++ b/artemis-server/src/main/java/org/apache/activemq/artemis/core/protocol/ServerPacketDecoder.java @@ -27,6 +27,7 @@ import org.apache.activemq.artemis.core.protocol.core.impl.wireformat.BackupRequ import org.apache.activemq.artemis.core.protocol.core.impl.wireformat.BackupResponseMessage; import org.apache.activemq.artemis.core.protocol.core.impl.wireformat.ClusterConnectMessage; import org.apache.activemq.artemis.core.protocol.core.impl.wireformat.ClusterConnectReplyMessage; +import org.apache.activemq.artemis.core.protocol.core.impl.wireformat.FederationDownstreamConnectMessage; import org.apache.activemq.artemis.core.protocol.core.impl.wireformat.NodeAnnounceMessage; import org.apache.activemq.artemis.core.protocol.core.impl.wireformat.QuorumVoteMessage; import org.apache.activemq.artemis.core.protocol.core.impl.wireformat.QuorumVoteReplyMessage; @@ -59,6 +60,7 @@ import static org.apache.activemq.artemis.core.protocol.core.impl.PacketImpl.BAC import static org.apache.activemq.artemis.core.protocol.core.impl.PacketImpl.BACKUP_REQUEST_RESPONSE; import static org.apache.activemq.artemis.core.protocol.core.impl.PacketImpl.CLUSTER_CONNECT; import static org.apache.activemq.artemis.core.protocol.core.impl.PacketImpl.CLUSTER_CONNECT_REPLY; +import static org.apache.activemq.artemis.core.protocol.core.impl.PacketImpl.FEDERATION_DOWNSTREAM_CONNECT; import static org.apache.activemq.artemis.core.protocol.core.impl.PacketImpl.NODE_ANNOUNCE; import static org.apache.activemq.artemis.core.protocol.core.impl.PacketImpl.QUORUM_VOTE; import static org.apache.activemq.artemis.core.protocol.core.impl.PacketImpl.QUORUM_VOTE_REPLY; @@ -252,6 +254,10 @@ public class ServerPacketDecoder extends ClientPacketDecoder { packet = new ScaleDownAnnounceMessage(); break; } + case FEDERATION_DOWNSTREAM_CONNECT: { + packet = new FederationDownstreamConnectMessage(); + break; + } default: { packet = super.decode(packetType, connection); } diff --git a/artemis-server/src/main/java/org/apache/activemq/artemis/core/protocol/core/impl/CoreProtocolManager.java b/artemis-server/src/main/java/org/apache/activemq/artemis/core/protocol/core/impl/CoreProtocolManager.java index 5862003672..c596c6eb58 100644 --- a/artemis-server/src/main/java/org/apache/activemq/artemis/core/protocol/core/impl/CoreProtocolManager.java +++ b/artemis-server/src/main/java/org/apache/activemq/artemis/core/protocol/core/impl/CoreProtocolManager.java @@ -16,6 +16,7 @@ */ package org.apache.activemq.artemis.core.protocol.core.impl; +import java.util.ArrayList; import java.util.Collections; import java.util.HashMap; import java.util.List; @@ -27,6 +28,7 @@ import java.util.concurrent.RejectedExecutionException; import io.netty.channel.ChannelPipeline; import org.apache.activemq.artemis.api.core.ActiveMQBuffer; import org.apache.activemq.artemis.api.core.ActiveMQBuffers; +import org.apache.activemq.artemis.api.core.ActiveMQException; import org.apache.activemq.artemis.api.core.BaseInterceptor; import org.apache.activemq.artemis.api.core.Interceptor; import org.apache.activemq.artemis.api.core.Pair; @@ -37,6 +39,12 @@ import org.apache.activemq.artemis.api.core.client.ActiveMQClient; import org.apache.activemq.artemis.api.core.client.ClusterTopologyListener; import org.apache.activemq.artemis.api.core.client.TopologyMember; import org.apache.activemq.artemis.core.config.Configuration; +import org.apache.activemq.artemis.core.config.FederationConfiguration; +import org.apache.activemq.artemis.core.config.federation.FederationConnectionConfiguration; +import org.apache.activemq.artemis.core.config.federation.FederationDownstreamConfiguration; +import org.apache.activemq.artemis.core.config.federation.FederationPolicy; +import org.apache.activemq.artemis.core.config.federation.FederationTransformerConfiguration; +import org.apache.activemq.artemis.core.config.federation.FederationUpstreamConfiguration; import org.apache.activemq.artemis.core.protocol.ServerPacketDecoder; import org.apache.activemq.artemis.core.protocol.core.Channel; import org.apache.activemq.artemis.core.protocol.core.ChannelHandler; @@ -47,10 +55,12 @@ import org.apache.activemq.artemis.core.protocol.core.impl.ChannelImpl.CHANNEL_I import org.apache.activemq.artemis.core.protocol.core.impl.wireformat.ClusterTopologyChangeMessage; import org.apache.activemq.artemis.core.protocol.core.impl.wireformat.ClusterTopologyChangeMessage_V2; import org.apache.activemq.artemis.core.protocol.core.impl.wireformat.ClusterTopologyChangeMessage_V3; +import org.apache.activemq.artemis.core.protocol.core.impl.wireformat.FederationDownstreamConnectMessage; import org.apache.activemq.artemis.core.protocol.core.impl.wireformat.Ping; import org.apache.activemq.artemis.core.protocol.core.impl.wireformat.SubscribeClusterTopologyUpdatesMessage; import org.apache.activemq.artemis.core.protocol.core.impl.wireformat.SubscribeClusterTopologyUpdatesMessageV2; import org.apache.activemq.artemis.core.remoting.CloseListener; +import org.apache.activemq.artemis.core.remoting.FailureListener; import org.apache.activemq.artemis.core.remoting.impl.netty.ActiveMQFrameDecoder2; import org.apache.activemq.artemis.core.remoting.impl.netty.NettyServerConnection; import org.apache.activemq.artemis.core.server.ActiveMQServer; @@ -111,12 +121,15 @@ public class CoreProtocolManager implements ProtocolManager { } @Override - public ConnectionEntry createConnectionEntry(final Acceptor acceptorUsed, final Connection connection) { + public ConnectionEntry createConnectionEntry(final Acceptor acceptorUsed, + final Connection connection) { final Configuration config = server.getConfiguration(); Executor connectionExecutor = server.getExecutorFactory().getExecutor(); - final CoreRemotingConnection rc = new RemotingConnectionImpl(new ServerPacketDecoder(), connection, incomingInterceptors, outgoingInterceptors, server.getNodeID(), connectionExecutor); + final CoreRemotingConnection rc = new RemotingConnectionImpl(new ServerPacketDecoder(), + connection, incomingInterceptors, outgoingInterceptors, server.getNodeID(), + connectionExecutor); Channel channel1 = rc.getChannel(CHANNEL_ID.SESSION.id, -1); @@ -130,13 +143,19 @@ public class CoreProtocolManager implements ProtocolManager { ttl = config.getConnectionTTLOverride(); } - final ConnectionEntry entry = new ConnectionEntry(rc, connectionExecutor, System.currentTimeMillis(), ttl); + final ConnectionEntry entry = new ConnectionEntry(rc, connectionExecutor, + System.currentTimeMillis(), ttl); final Channel channel0 = rc.getChannel(ChannelImpl.CHANNEL_ID.PING.id, -1); channel0.setHandler(new LocalChannelHandler(config, entry, channel0, acceptorUsed, rc)); - server.getClusterManager().addClusterChannelHandler(rc.getChannel(CHANNEL_ID.CLUSTER.id, -1), acceptorUsed, rc, server.getActivation()); + server.getClusterManager() + .addClusterChannelHandler(rc.getChannel(CHANNEL_ID.CLUSTER.id, -1), acceptorUsed, rc, + server.getActivation()); + + final Channel federationChannel = rc.getChannel(CHANNEL_ID.FEDERATION.id, -1); + federationChannel.setHandler(new LocalChannelHandler(config, entry, channel0, acceptorUsed, rc)); return entry; } @@ -249,18 +268,22 @@ public class CoreProtocolManager implements ProtocolManager { // Just send a ping back channel0.send(packet); - } else if (packet.getType() == PacketImpl.SUBSCRIBE_TOPOLOGY || packet.getType() == PacketImpl.SUBSCRIBE_TOPOLOGY_V2) { + } else if (packet.getType() == PacketImpl.SUBSCRIBE_TOPOLOGY + || packet.getType() == PacketImpl.SUBSCRIBE_TOPOLOGY_V2) { SubscribeClusterTopologyUpdatesMessage msg = (SubscribeClusterTopologyUpdatesMessage) packet; if (packet.getType() == PacketImpl.SUBSCRIBE_TOPOLOGY_V2) { - channel0.getConnection().setChannelVersion(((SubscribeClusterTopologyUpdatesMessageV2) msg).getClientVersion()); + channel0.getConnection().setChannelVersion( + ((SubscribeClusterTopologyUpdatesMessageV2) msg).getClientVersion()); } final ClusterTopologyListener listener = new ClusterTopologyListener() { @Override public void nodeUP(final TopologyMember topologyMember, final boolean last) { try { - final Pair connectorPair = BackwardsCompatibilityUtils.checkTCPPairConversion(channel0.getConnection().getChannelVersion(), topologyMember); + final Pair connectorPair = BackwardsCompatibilityUtils + .checkTCPPairConversion( + channel0.getConnection().getChannelVersion(), topologyMember); final String nodeID = topologyMember.getNodeId(); // Using an executor as most of the notifications on the Topology @@ -270,11 +293,20 @@ public class CoreProtocolManager implements ProtocolManager { @Override public void run() { if (channel0.supports(PacketImpl.CLUSTER_TOPOLOGY_V3)) { - channel0.send(new ClusterTopologyChangeMessage_V3(topologyMember.getUniqueEventID(), nodeID, topologyMember.getBackupGroupName(), topologyMember.getScaleDownGroupName(), connectorPair, last)); + channel0.send(new ClusterTopologyChangeMessage_V3( + topologyMember.getUniqueEventID(), nodeID, + topologyMember.getBackupGroupName(), + topologyMember.getScaleDownGroupName(), connectorPair, + last)); } else if (channel0.supports(PacketImpl.CLUSTER_TOPOLOGY_V2)) { - channel0.send(new ClusterTopologyChangeMessage_V2(topologyMember.getUniqueEventID(), nodeID, topologyMember.getBackupGroupName(), connectorPair, last)); + channel0.send(new ClusterTopologyChangeMessage_V2( + topologyMember.getUniqueEventID(), nodeID, + topologyMember.getBackupGroupName(), connectorPair, + last)); } else { - channel0.send(new ClusterTopologyChangeMessage(nodeID, connectorPair, last)); + channel0.send( + new ClusterTopologyChangeMessage(nodeID, connectorPair, + last)); } } }); @@ -295,7 +327,9 @@ public class CoreProtocolManager implements ProtocolManager { @Override public void run() { if (channel0.supports(PacketImpl.CLUSTER_TOPOLOGY_V2)) { - channel0.send(new ClusterTopologyChangeMessage_V2(uniqueEventID, nodeID)); + channel0.send( + new ClusterTopologyChangeMessage_V2(uniqueEventID, + nodeID)); } else { channel0.send(new ClusterTopologyChangeMessage(nodeID)); } @@ -309,7 +343,8 @@ public class CoreProtocolManager implements ProtocolManager { @Override public String toString() { - return "Remote Proxy on channel " + Integer.toHexString(System.identityHashCode(this)); + return "Remote Proxy on channel " + Integer + .toHexString(System.identityHashCode(this)); } }; @@ -319,7 +354,8 @@ public class CoreProtocolManager implements ProtocolManager { rc.addCloseListener(new CloseListener() { @Override public void connectionClosed() { - acceptorUsed.getClusterConnection().removeClusterTopologyListener(listener); + acceptorUsed.getClusterConnection() + .removeClusterTopologyListener(listener); } }); } else { @@ -329,20 +365,120 @@ public class CoreProtocolManager implements ProtocolManager { @Override public void run() { String nodeId = server.getNodeID().toString(); - Pair emptyConfig = new Pair<>(null, null); + Pair emptyConfig = new Pair<>( + null, null); if (channel0.supports(PacketImpl.CLUSTER_TOPOLOGY_V2)) { - channel0.send(new ClusterTopologyChangeMessage_V2(System.currentTimeMillis(), nodeId, null, emptyConfig, true)); + channel0.send( + new ClusterTopologyChangeMessage_V2(System.currentTimeMillis(), + nodeId, null, emptyConfig, true)); } else { - channel0.send(new ClusterTopologyChangeMessage(nodeId, emptyConfig, true)); + channel0.send( + new ClusterTopologyChangeMessage(nodeId, emptyConfig, true)); } } }); } + } else if (packet.getType() == PacketImpl.FEDERATION_DOWNSTREAM_CONNECT) { + //If we receive this packet then a remote broker is requesting us to create federated upstream connection + //back to it which simulates a downstream connection + final FederationDownstreamConnectMessage message = (FederationDownstreamConnectMessage) packet; + final FederationDownstreamConfiguration downstreamConfiguration = message.getStreamConfiguration(); + + //Create a new Upstream Federation configuration based on the received Downstream connection message + //from the remote broker + //The idea here is to set all the same configuration parameters that apply to the upstream connection + final FederationConfiguration config = new FederationConfiguration(); + config.setName(message.getName() + FederationDownstreamConnectMessage.UPSTREAM_SUFFIX); + config.setCredentials(message.getCredentials()); + + //Add the policy map configuration + for (FederationPolicy policy : message.getFederationPolicyMap().values()) { + config.addFederationPolicy(policy); + } + + //Add any transformer configurations + for (FederationTransformerConfiguration transformerConfiguration : message.getTransformerConfigurationMap().values()) { + config.addTransformerConfiguration(transformerConfiguration); + } + + //Create an upstream configuration with the same name but apply the upstream suffix so it is unique + final FederationUpstreamConfiguration upstreamConfiguration = new FederationUpstreamConfiguration() + .setName(downstreamConfiguration.getName() + FederationDownstreamConnectMessage.UPSTREAM_SUFFIX) + .addPolicyRefs(downstreamConfiguration.getPolicyRefs()); + + //Use the provided Transport Configuration information to create an upstream connection back to the broker that + //created the downstream connection + final TransportConfiguration upstreamConfig = downstreamConfiguration.getUpstreamConfiguration(); + + //Initialize the upstream transport with the config from the acceptor as this will apply + //relevant settings such as SSL, then override with settings from the downstream config + final Map params = new HashMap<>(acceptorUsed.getConfiguration()); + params.putAll(upstreamConfig.getParams()); + + //Add the new upstream configuration that was created so we can connect back to the downstream server + final TransportConfiguration upstreamConf = new TransportConfiguration( + upstreamConfig.getFactoryClassName(), params, upstreamConfig.getName() + FederationDownstreamConnectMessage.UPSTREAM_SUFFIX, + new HashMap<>()); + server.getConfiguration() + .addConnectorConfiguration(upstreamConf.getName() + FederationDownstreamConnectMessage.UPSTREAM_SUFFIX, upstreamConf); + + //Create a new upstream connection config based on the downstream configuration + FederationConnectionConfiguration downstreamConConf = downstreamConfiguration.getConnectionConfiguration(); + FederationConnectionConfiguration upstreamConConf = upstreamConfiguration.getConnectionConfiguration(); + List connectorNames = new ArrayList<>(); + connectorNames.add(upstreamConf.getName() + FederationDownstreamConnectMessage.UPSTREAM_SUFFIX); + + //Configure all of the upstream connection parameters from the downstream connection that are relevant + //Note that HA and discoveryGroupName are skipped because the downstream connection will manage that + //In this case we just want to create a connection back to the broker that sent the downstream packet. + //If this broker goes down then the original broker (if configured with HA) will re-establish a new + //connection to another broker which will then create another upstream, etc + upstreamConConf.setStaticConnectors(connectorNames); + upstreamConConf.setUsername(downstreamConConf.getUsername()); + upstreamConConf.setPassword(downstreamConConf.getPassword()); + upstreamConConf.setShareConnection(downstreamConConf.isShareConnection()); + upstreamConConf.setPriorityAdjustment(downstreamConConf.getPriorityAdjustment()); + upstreamConConf.setClientFailureCheckPeriod(downstreamConConf.getClientFailureCheckPeriod()); + upstreamConConf.setConnectionTTL(downstreamConConf.getConnectionTTL()); + upstreamConConf.setRetryInterval(downstreamConConf.getRetryInterval()); + upstreamConConf.setRetryIntervalMultiplier(downstreamConConf.getRetryIntervalMultiplier()); + upstreamConConf.setMaxRetryInterval(downstreamConConf.getMaxRetryInterval()); + upstreamConConf.setInitialConnectAttempts(downstreamConConf.getInitialConnectAttempts()); + upstreamConConf.setReconnectAttempts(downstreamConConf.getReconnectAttempts()); + upstreamConConf.setCallTimeout(downstreamConConf.getCallTimeout()); + upstreamConConf.setCallFailoverTimeout(downstreamConConf.getCallFailoverTimeout()); + config.addUpstreamConfiguration(upstreamConfiguration); + + //Register close and failure listeners, if the initial downstream connection goes down then we + //want to terminate the upstream connection + rc.addCloseListener(() -> { + server.getFederationManager().undeploy(config.getName()); + }); + + rc.addFailureListener(new FailureListener() { + @Override + public void connectionFailed(ActiveMQException exception, boolean failedOver) { + server.getFederationManager().undeploy(config.getName()); + } + + @Override + public void connectionFailed(ActiveMQException exception, boolean failedOver, + String scaleDownTargetNodeID) { + server.getFederationManager().undeploy(config.getName()); + } + }); + + try { + server.getFederationManager().deploy(config); + } catch (Exception e) { + logger.error("Error deploying federation: " + e.getMessage(), e); + } } } - private Pair getPair(TransportConfiguration conn, - boolean isBackup) { + private Pair getPair( + TransportConfiguration conn, + boolean isBackup) { if (isBackup) { return new Pair<>(null, conn); } diff --git a/artemis-server/src/main/java/org/apache/activemq/artemis/core/server/ActiveMQServer.java b/artemis-server/src/main/java/org/apache/activemq/artemis/core/server/ActiveMQServer.java index f4378204a6..d8541dd5b3 100644 --- a/artemis-server/src/main/java/org/apache/activemq/artemis/core/server/ActiveMQServer.java +++ b/artemis-server/src/main/java/org/apache/activemq/artemis/core/server/ActiveMQServer.java @@ -16,6 +16,7 @@ */ package org.apache.activemq.artemis.core.server; +import javax.management.MBeanServer; import java.util.Collection; import java.util.EnumSet; import java.util.List; @@ -25,14 +26,13 @@ import java.util.concurrent.Executor; import java.util.concurrent.ScheduledExecutorService; import java.util.concurrent.TimeUnit; -import javax.management.MBeanServer; - import org.apache.activemq.artemis.api.core.ActiveMQException; import org.apache.activemq.artemis.api.core.RoutingType; import org.apache.activemq.artemis.api.core.SimpleString; import org.apache.activemq.artemis.core.config.BridgeConfiguration; import org.apache.activemq.artemis.core.config.Configuration; import org.apache.activemq.artemis.core.config.DivertConfiguration; +import org.apache.activemq.artemis.core.config.FederationConfiguration; import org.apache.activemq.artemis.core.management.impl.ActiveMQServerControlImpl; import org.apache.activemq.artemis.core.paging.PagingManager; import org.apache.activemq.artemis.core.persistence.OperationContext; @@ -46,7 +46,7 @@ import org.apache.activemq.artemis.core.security.SecurityAuth; import org.apache.activemq.artemis.core.security.SecurityStore; import org.apache.activemq.artemis.core.server.cluster.ClusterManager; import org.apache.activemq.artemis.core.server.cluster.ha.HAPolicy; -import org.apache.activemq.artemis.core.config.FederationConfiguration; +import org.apache.activemq.artemis.core.server.federation.FederationManager; import org.apache.activemq.artemis.core.server.group.GroupingHandler; import org.apache.activemq.artemis.core.server.impl.Activation; import org.apache.activemq.artemis.core.server.impl.AddressInfo; @@ -64,7 +64,6 @@ import org.apache.activemq.artemis.core.server.plugin.ActiveMQServerCriticalPlug import org.apache.activemq.artemis.core.server.plugin.ActiveMQServerMessagePlugin; import org.apache.activemq.artemis.core.server.plugin.ActiveMQServerQueuePlugin; import org.apache.activemq.artemis.core.server.plugin.ActiveMQServerSessionPlugin; -import org.apache.activemq.artemis.core.server.federation.FederationManager; import org.apache.activemq.artemis.core.server.reload.ReloadManager; import org.apache.activemq.artemis.core.settings.HierarchicalRepository; import org.apache.activemq.artemis.core.settings.impl.AddressSettings; @@ -749,5 +748,4 @@ public interface ActiveMQServer extends ServiceComponent { void removeAddressInfo(SimpleString address, SecurityAuth auth, boolean force) throws Exception; String getInternalNamingPrefix(); - } diff --git a/artemis-server/src/main/java/org/apache/activemq/artemis/core/server/ActiveMQServerLogger.java b/artemis-server/src/main/java/org/apache/activemq/artemis/core/server/ActiveMQServerLogger.java index 0d8a48ebc5..eee149eed9 100644 --- a/artemis-server/src/main/java/org/apache/activemq/artemis/core/server/ActiveMQServerLogger.java +++ b/artemis-server/src/main/java/org/apache/activemq/artemis/core/server/ActiveMQServerLogger.java @@ -1638,7 +1638,19 @@ public interface ActiveMQServerLogger extends BasicLogger { void federationAvoidStackOverflowPolicyRef(String upstreamName, String policyRef); @LogMessage(level = Logger.Level.WARN) - @Message(id = 222282, value = "File {0} at {1} is empty. Delete the empty file to stop this message.", + @Message(id = 222282, value = "Federation downstream {0} upstream transport configuration ref {1} could not be resolved in federation configuration", format = Message.Format.MESSAGE_FORMAT) + void federationCantFindUpstreamConnector(String downstreamName, String upstreamRef); + + @LogMessage(level = Logger.Level.INFO) + @Message(id = 222283, value = "Federation downstream {0} has been deployed", format = Message.Format.MESSAGE_FORMAT) + void federationDownstreamDeployed(String downstreamName); + + @LogMessage(level = Logger.Level.INFO) + @Message(id = 222284, value = "Federation downstream {0} has been undeployed", format = Message.Format.MESSAGE_FORMAT) + void federationDownstreamUnDeployed(String downstreamName); + + @LogMessage(level = Logger.Level.WARN) + @Message(id = 222285, value = "File {0} at {1} is empty. Delete the empty file to stop this message.", format = Message.Format.MESSAGE_FORMAT) void emptyAddressFile(String addressFile, String directory); diff --git a/artemis-server/src/main/java/org/apache/activemq/artemis/core/server/federation/FederatedQueueConsumer.java b/artemis-server/src/main/java/org/apache/activemq/artemis/core/server/federation/FederatedQueueConsumer.java index e7cced0f92..a1e08686df 100644 --- a/artemis-server/src/main/java/org/apache/activemq/artemis/core/server/federation/FederatedQueueConsumer.java +++ b/artemis-server/src/main/java/org/apache/activemq/artemis/core/server/federation/FederatedQueueConsumer.java @@ -20,15 +20,16 @@ package org.apache.activemq.artemis.core.server.federation; import java.util.concurrent.ScheduledExecutorService; import java.util.concurrent.TimeUnit; import java.util.concurrent.atomic.AtomicInteger; + import org.apache.activemq.artemis.api.core.ActiveMQException; import org.apache.activemq.artemis.api.core.ActiveMQNonExistentQueueException; import org.apache.activemq.artemis.api.core.Message; import org.apache.activemq.artemis.api.core.client.ClientConsumer; import org.apache.activemq.artemis.api.core.client.ClientMessage; import org.apache.activemq.artemis.api.core.client.ClientSession; -import org.apache.activemq.artemis.api.core.client.ClientSessionFactory; import org.apache.activemq.artemis.api.core.client.MessageHandler; import org.apache.activemq.artemis.api.core.client.SessionFailureListener; +import org.apache.activemq.artemis.core.client.impl.ClientSessionFactoryInternal; import org.apache.activemq.artemis.core.server.ActiveMQServer; import org.apache.activemq.artemis.core.server.transformer.Transformer; @@ -47,7 +48,7 @@ public class FederatedQueueConsumer implements MessageHandler, SessionFailureLis private final int intialConnectDelayMax = 30; private final ClientSessionCallback clientSessionCallback; - private ClientSessionFactory clientSessionFactory; + private ClientSessionFactoryInternal clientSessionFactory; private ClientSession clientSession; private ClientConsumer clientConsumer; @@ -83,7 +84,7 @@ public class FederatedQueueConsumer implements MessageHandler, SessionFailureLis }, delay, TimeUnit.SECONDS); } - static int getNextDelay(int delay, int delayMultiplier, int delayMax) { + public static int getNextDelay(int delay, int delayMultiplier, int delayMax) { int nextDelay; if (delay == 0) { nextDelay = 1; @@ -100,7 +101,7 @@ public class FederatedQueueConsumer implements MessageHandler, SessionFailureLis try { if (clientConsumer == null) { synchronized (this) { - this.clientSessionFactory = upstream.getConnection().clientSessionFactory(); + this.clientSessionFactory = (ClientSessionFactoryInternal) upstream.getConnection().clientSessionFactory(); this.clientSession = clientSessionFactory.createSession(upstream.getUser(), upstream.getPassword(), false, true, true, clientSessionFactory.getServerLocator().isPreAcknowledge(), clientSessionFactory.getServerLocator().getAckBatchSize()); this.clientSession.addFailureListener(this); this.clientSession.addMetaData(FEDERATION_NAME, federation.getName().toString()); @@ -149,13 +150,14 @@ public class FederatedQueueConsumer implements MessageHandler, SessionFailureLis if (clientSession != null) { clientSession.close(); } - if (clientSessionFactory != null) { - clientSessionFactory.close(); - } clientConsumer = null; clientSession = null; - clientSessionFactory = null; + if (clientSessionFactory != null && (!upstream.getConnection().isSharedConnection() || + clientSessionFactory.numSessions() == 0)) { + clientSessionFactory.close(); + clientSessionFactory = null; + } } @Override diff --git a/artemis-server/src/main/java/org/apache/activemq/artemis/core/server/federation/Federation.java b/artemis-server/src/main/java/org/apache/activemq/artemis/core/server/federation/Federation.java index c34123bed8..5fe14c17aa 100644 --- a/artemis-server/src/main/java/org/apache/activemq/artemis/core/server/federation/Federation.java +++ b/artemis-server/src/main/java/org/apache/activemq/artemis/core/server/federation/Federation.java @@ -20,9 +20,11 @@ package org.apache.activemq.artemis.core.server.federation; import java.util.HashMap; import java.util.Map; import java.util.Objects; + import org.apache.activemq.artemis.api.core.ActiveMQException; import org.apache.activemq.artemis.api.core.SimpleString; import org.apache.activemq.artemis.core.config.FederationConfiguration; +import org.apache.activemq.artemis.core.config.federation.FederationDownstreamConfiguration; import org.apache.activemq.artemis.core.config.federation.FederationPolicy; import org.apache.activemq.artemis.core.config.federation.FederationUpstreamConfiguration; import org.apache.activemq.artemis.core.server.ActiveMQServer; @@ -34,9 +36,12 @@ public class Federation { private final SimpleString name; private final Map upstreams = new HashMap<>(); + private final Map downstreams = new HashMap<>(); private final FederationConfiguration config; private FederationManager.State state; + private final Map connections = new HashMap<>(); + enum State { STOPPED, STOPPING, @@ -64,6 +69,9 @@ public class Federation { for (FederationUpstream connection : upstreams.values()) { connection.start(); } + for (FederationDownstream connection : downstreams.values()) { + connection.start(); + } state = FederationManager.State.STARTED; } @@ -74,7 +82,11 @@ public class Federation { for (FederationUpstream connection : upstreams.values()) { connection.stop(); } + for (FederationDownstream connection : downstreams.values()) { + connection.stop(); + } upstreams.clear(); + downstreams.clear(); state = FederationManager.State.STOPPED; } @@ -82,6 +94,9 @@ public class Federation { for (FederationUpstreamConfiguration upstreamConfiguration : config.getUpstreamConfigurations()) { deploy(upstreamConfiguration, config.getFederationPolicyMap()); } + for (FederationDownstreamConfiguration downstreamConfiguration : config.getDownstreamConfigurations()) { + deploy(downstreamConfiguration, config.getFederationPolicyMap()); + } if (state != FederationManager.State.STARTED) { state = FederationManager.State.DEPLOYED; } @@ -96,11 +111,14 @@ public class Federation { if (federationConnection != null) { federationConnection.stop(); } + FederationDownstream federationConnectionDownstream = downstreams.remove(name); + if (federationConnectionDownstream != null) { + federationConnectionDownstream.undeploy(); + federationConnectionDownstream.stop(); + } return true; } - - public synchronized boolean deploy(FederationUpstreamConfiguration upstreamConfiguration, Map federationPolicyMap) throws ActiveMQException { String name = upstreamConfiguration.getName(); FederationUpstream upstream = upstreams.get(name); @@ -127,11 +145,52 @@ public class Federation { return upstream; } + public synchronized boolean deploy(FederationDownstreamConfiguration downstreamConfiguration, Map federationPolicyMap) throws ActiveMQException { + String name = downstreamConfiguration.getName(); + FederationDownstream downstream = downstreams.get(name); + + //If connection has changed we will need to do a full undeploy and redeploy. + if (downstream == null) { + undeploy(name); + downstream = deploy(name, downstreamConfiguration); + } else if (!downstream.getConnection().getConfig().equals(downstreamConfiguration.getConnectionConfiguration())) { + undeploy(name); + downstream = deploy(name, downstreamConfiguration); + } + + downstream.deploy(config); + return true; + } + + private synchronized FederationDownstream deploy(String name, FederationDownstreamConfiguration downstreamConfiguration) { + //If we have a matching upstream connection already configured then use it for the initiating downstream connection + FederationConnection connection = null; + if (downstreamConfiguration.getConnectionConfiguration().isShareConnection()) { + for (FederationUpstream upstream : upstreams.values()) { + if (upstream.getConfig().getConnectionConfiguration() + .equals(downstreamConfiguration.getConnectionConfiguration())) { + connection = upstream.getConnection(); + connection.setSharedConnection(true); + break; + } + } + } + + FederationDownstream downstream = new FederationDownstream(server, this, name, downstreamConfiguration, connection); + downstreams.put(name, downstream); + if (state == FederationManager.State.STARTED) { + downstream.start(); + } + return downstream; + } + public FederationUpstream get(String name) { return upstreams.get(name); } - + public FederationDownstream getDownstream(String name) { + return downstreams.get(name); + } public void register(FederatedAbstract federatedAbstract) { server.registerBrokerPlugin(federatedAbstract); diff --git a/artemis-server/src/main/java/org/apache/activemq/artemis/core/server/federation/FederationConnection.java b/artemis-server/src/main/java/org/apache/activemq/artemis/core/server/federation/FederationConnection.java index bd63106cec..2b00b3cfdf 100644 --- a/artemis-server/src/main/java/org/apache/activemq/artemis/core/server/federation/FederationConnection.java +++ b/artemis-server/src/main/java/org/apache/activemq/artemis/core/server/federation/FederationConnection.java @@ -34,6 +34,7 @@ public class FederationConnection { private final long circuitBreakerTimeout; private volatile ClientSessionFactory clientSessionFactory; private volatile boolean started; + private volatile boolean sharedConnection; public FederationConnection(Configuration configuration, String name, FederationConnectionConfiguration config) { this.config = config; @@ -67,6 +68,17 @@ public class FederationConnection { serverLocator = ActiveMQClient.createServerLocatorWithoutHA(tcConfigs); } } + + serverLocator.setConnectionTTL(config.getConnectionTTL()); + serverLocator.setClientFailureCheckPeriod(config.getClientFailureCheckPeriod()); + serverLocator.setReconnectAttempts(config.getReconnectAttempts()); + serverLocator.setInitialConnectAttempts(config.getInitialConnectAttempts()); + serverLocator.setRetryInterval(config.getRetryInterval()); + serverLocator.setRetryIntervalMultiplier(config.getRetryIntervalMultiplier()); + serverLocator.setMaxRetryInterval(config.getMaxRetryInterval()); + serverLocator.setCallTimeout(config.getCallTimeout()); + serverLocator.setCallFailoverTimeout(config.getCallFailoverTimeout()); + } public synchronized void start() { @@ -87,6 +99,14 @@ public class FederationConnection { return started; } + public boolean isSharedConnection() { + return sharedConnection; + } + + public void setSharedConnection(boolean sharedConnection) { + this.sharedConnection = sharedConnection; + } + public final ClientSessionFactory clientSessionFactory() throws Exception { ClientSessionFactory clientSessionFactory = this.clientSessionFactory; if (started) { diff --git a/artemis-server/src/main/java/org/apache/activemq/artemis/core/server/federation/FederationDownstream.java b/artemis-server/src/main/java/org/apache/activemq/artemis/core/server/federation/FederationDownstream.java new file mode 100644 index 0000000000..2e77c861d7 --- /dev/null +++ b/artemis-server/src/main/java/org/apache/activemq/artemis/core/server/federation/FederationDownstream.java @@ -0,0 +1,212 @@ +/** + * 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.server.federation; + +import java.util.concurrent.ScheduledExecutorService; +import java.util.concurrent.TimeUnit; +import java.util.concurrent.atomic.AtomicBoolean; + +import org.apache.activemq.artemis.api.core.ActiveMQException; +import org.apache.activemq.artemis.api.core.ActiveMQExceptionType; +import org.apache.activemq.artemis.api.core.TransportConfiguration; +import org.apache.activemq.artemis.api.core.client.SessionFailureListener; +import org.apache.activemq.artemis.core.client.impl.ClientSessionFactoryInternal; +import org.apache.activemq.artemis.core.client.impl.ClientSessionInternal; +import org.apache.activemq.artemis.core.config.FederationConfiguration; +import org.apache.activemq.artemis.core.config.federation.FederationDownstreamConfiguration; +import org.apache.activemq.artemis.core.protocol.core.Channel; +import org.apache.activemq.artemis.core.protocol.core.CoreRemotingConnection; +import org.apache.activemq.artemis.core.protocol.core.impl.ChannelImpl.CHANNEL_ID; +import org.apache.activemq.artemis.core.protocol.core.impl.wireformat.FederationDownstreamConnectMessage; +import org.apache.activemq.artemis.core.protocol.core.impl.wireformat.FederationStreamConnectMessage; +import org.apache.activemq.artemis.core.server.ActiveMQServer; +import org.apache.activemq.artemis.core.server.ActiveMQServerLogger; +import org.jboss.logging.Logger; + +public class FederationDownstream extends FederationStream implements SessionFailureListener { + + private static final Logger logger = Logger.getLogger(FederationDownstream.class); + + private FederationDownstreamConfiguration config; + private ClientSessionFactoryInternal clientSessionFactory; + private ClientSessionInternal clientSession; + private Channel channel; + private AtomicBoolean initialized = new AtomicBoolean(); + private final ScheduledExecutorService scheduledExecutorService; + private final int intialConnectDelayMultiplier = 2; + private final int intialConnectDelayMax = 30; + + public static final String FEDERATION_DOWNSTREAM_NAME = "federation-downstream-name"; + private AtomicBoolean started = new AtomicBoolean(); + private FederationConfiguration federationConfiguration; + + public FederationDownstream(ActiveMQServer server, Federation federation, String name, FederationDownstreamConfiguration config, + final FederationConnection connection) { + super(server, federation, name, config, connection); + this.config = config; + this.scheduledExecutorService = server.getScheduledPool(); + } + + @Override + public synchronized void start() { + super.start(); + try { + deploy(federationConfiguration); + } catch (ActiveMQException e) { + throw new IllegalStateException(e.getMessage(), e); + } + } + + @Override + public synchronized void stop() { + super.stop(); + } + + public void deploy(FederationConfiguration federationConfiguration) + throws ActiveMQException { + + this.federationConfiguration = federationConfiguration; + + if (connection.isStarted() && started.compareAndSet(false, true)) { + final FederationStreamConnectMessage message = new FederationDownstreamConnectMessage(); + message.setName(federationConfiguration.getName()); + message.setCredentials(federationConfiguration.getCredentials()); + message.setStreamConfiguration(config); + message.setFederationPolicyMap(federationConfiguration.getFederationPolicyMap()); + message.setTransformerConfigurationMap(federationConfiguration.getTransformerConfigurationMap()); + + if (config.getUpstreamConfigurationRef() != null + && config.getUpstreamConfiguration() == null) { + TransportConfiguration[] configs = server.getConfiguration() + .getTransportConfigurations(config.getUpstreamConfigurationRef()); + if (configs != null && configs.length > 0) { + config.setUpstreamConfiguration(configs[0]); + } else { + ActiveMQServerLogger.LOGGER.federationCantFindUpstreamConnector(config.getName(), config + .getUpstreamConfigurationRef()); + throw new ActiveMQException("Could not locate upstream transport configuration for federation downstream: " + config.getName() + + "; upstream ref: " + config.getUpstreamConfigurationRef()); + } + } + + try { + scheduleConnect(0, message); + } catch (Exception e) { + throw new ActiveMQException(e.getMessage(), e, ActiveMQExceptionType.GENERIC_EXCEPTION); + } + + ActiveMQServerLogger.LOGGER.federationDownstreamDeployed(config.getName()); + } + } + + public void undeploy() { + try { + if (started.compareAndSet(true, false)) { + disconnect(); + ActiveMQServerLogger.LOGGER.federationDownstreamUnDeployed(config.getName()); + } + } catch (ActiveMQException e) { + throw new IllegalStateException(e.getMessage(), e); + } + } + + private void scheduleConnect(final int delay, final FederationStreamConnectMessage message) { + scheduledExecutorService.schedule(() -> { + try { + connect(); + if (initialized.compareAndSet(false, true)) { + channel.send(message); + } + } catch (Exception e) { + scheduleConnect(FederatedQueueConsumer.getNextDelay(delay, intialConnectDelayMultiplier, intialConnectDelayMax), + message); + } + }, delay, TimeUnit.SECONDS); + } + + private void connect() throws Exception { + try { + if (clientSession == null) { + synchronized (this) { + this.clientSessionFactory = (ClientSessionFactoryInternal) getConnection().clientSessionFactory(); + this.clientSession = (ClientSessionInternal) clientSessionFactory.createSession(getUser(), getPassword(), false, true, true, clientSessionFactory.getServerLocator().isPreAcknowledge(), clientSessionFactory.getServerLocator().getAckBatchSize()); + this.clientSession.addFailureListener(this); + this.clientSession.addMetaData(FederatedQueueConsumer.FEDERATION_NAME, federation.getName().toString()); + this.clientSession.addMetaData(FEDERATION_DOWNSTREAM_NAME, config.getName().toString()); + this.clientSession.start(); + + CoreRemotingConnection connection = (CoreRemotingConnection) clientSessionFactory.getConnection(); + channel = connection.getChannel(CHANNEL_ID.FEDERATION.id, -1); + } + } + } catch (Exception e) { + try { + if (clientSessionFactory != null) { + clientSessionFactory.cleanup(); + } + disconnect(); + } catch (ActiveMQException ignored) { + } + throw e; + } + } + + @Override + public void connectionFailed(ActiveMQException exception, boolean failedOver) { + connectionFailed(exception, failedOver, null); + } + + @Override + public void connectionFailed(ActiveMQException exception, boolean failedOver, String scaleDownTargetNodeID) { + try { + started.set(false); + initialized.set(false); + channel.close(); + clientSessionFactory.cleanup(); + clientSessionFactory.close(); + channel = null; + clientSession = null; + clientSessionFactory = null; + } catch (Throwable dontCare) { + } + start(); + } + + private void disconnect() throws ActiveMQException { + initialized.set(false); + + if (channel != null) { + channel.close(); + } + if (clientSession != null) { + clientSession.close(); + } + channel = null; + clientSession = null; + + if (clientSessionFactory != null && (!getConnection().isSharedConnection() || clientSessionFactory.numSessions() == 0)) { + clientSessionFactory.close(); + clientSessionFactory = null; + } + } + + @Override + public void beforeReconnect(ActiveMQException exception) { + } + +} diff --git a/artemis-server/src/main/java/org/apache/activemq/artemis/core/server/federation/FederationManager.java b/artemis-server/src/main/java/org/apache/activemq/artemis/core/server/federation/FederationManager.java index 6aba68d1e1..9d460729fe 100644 --- a/artemis-server/src/main/java/org/apache/activemq/artemis/core/server/federation/FederationManager.java +++ b/artemis-server/src/main/java/org/apache/activemq/artemis/core/server/federation/FederationManager.java @@ -122,8 +122,6 @@ public class FederationManager implements ActiveMQComponent { return federations.get(name); } - - public void register(FederatedAbstract federatedAbstract) { server.registerBrokerPlugin(federatedAbstract); } diff --git a/artemis-server/src/main/java/org/apache/activemq/artemis/core/server/federation/FederationStream.java b/artemis-server/src/main/java/org/apache/activemq/artemis/core/server/federation/FederationStream.java new file mode 100644 index 0000000000..e983ba86dc --- /dev/null +++ b/artemis-server/src/main/java/org/apache/activemq/artemis/core/server/federation/FederationStream.java @@ -0,0 +1,109 @@ +/** + * 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.server.federation; + +import java.util.HashMap; +import java.util.Map; +import java.util.Objects; + +import org.apache.activemq.artemis.api.core.SimpleString; +import org.apache.activemq.artemis.core.config.federation.FederationStreamConfiguration; +import org.apache.activemq.artemis.core.server.ActiveMQServer; +import org.apache.activemq.artemis.core.server.federation.address.FederatedAddress; +import org.apache.activemq.artemis.core.server.federation.queue.FederatedQueue; +import org.jboss.logging.Logger; + +public abstract class FederationStream { + + + private static final Logger logger = Logger.getLogger(FederationStream.class); + protected final ActiveMQServer server; + protected final Federation federation; + protected final SimpleString name; + protected final FederationConnection connection; + private FederationStreamConfiguration config; + protected Map federatedQueueMap = new HashMap<>(); + protected Map federatedAddressMap = new HashMap<>(); + + + public FederationStream(ActiveMQServer server, Federation federation, String name, FederationStreamConfiguration config) { + this(server, federation, name, config, null); + } + + public FederationStream(final ActiveMQServer server, final Federation federation, final String name, final FederationStreamConfiguration config, + final FederationConnection connection) { + this.server = server; + this.federation = federation; + Objects.requireNonNull(config.getName()); + this.name = SimpleString.toSimpleString(config.getName()); + this.config = config; + this.connection = connection != null ? connection : new FederationConnection(server.getConfiguration(), name, config.getConnectionConfiguration()); + } + + public synchronized void start() { + if (connection != null) { + connection.start(); + } + } + + public synchronized void stop() { + if (connection != null) { + connection.stop(); + } + } + + public Federation getFederation() { + return federation; + } + + public FederationStreamConfiguration getConfig() { + return config; + } + + public SimpleString getName() { + return name; + } + + public FederationConnection getConnection() { + return connection; + } + + + public String getUser() { + String user = config.getConnectionConfiguration().getUsername(); + if (user == null || user.isEmpty()) { + return federation.getFederationUser(); + } else { + return user; + } + } + + public String getPassword() { + String password = config.getConnectionConfiguration().getPassword(); + if (password == null || password.isEmpty()) { + return federation.getFederationPassword(); + } else { + return password; + } + } + + public int getPriorityAdjustment() { + return config.getConnectionConfiguration().getPriorityAdjustment(); + } + +} diff --git a/artemis-server/src/main/java/org/apache/activemq/artemis/core/server/federation/FederationUpstream.java b/artemis-server/src/main/java/org/apache/activemq/artemis/core/server/federation/FederationUpstream.java index ee09cfb57f..38663e457d 100644 --- a/artemis-server/src/main/java/org/apache/activemq/artemis/core/server/federation/FederationUpstream.java +++ b/artemis-server/src/main/java/org/apache/activemq/artemis/core/server/federation/FederationUpstream.java @@ -17,12 +17,10 @@ package org.apache.activemq.artemis.core.server.federation; -import java.util.HashMap; import java.util.Map; -import java.util.Objects; import java.util.Set; + import org.apache.activemq.artemis.api.core.ActiveMQException; -import org.apache.activemq.artemis.api.core.SimpleString; import org.apache.activemq.artemis.core.config.federation.FederationAddressPolicyConfiguration; import org.apache.activemq.artemis.core.config.federation.FederationPolicy; import org.apache.activemq.artemis.core.config.federation.FederationPolicySet; @@ -33,28 +31,18 @@ import org.apache.activemq.artemis.core.server.ActiveMQServerLogger; import org.apache.activemq.artemis.core.server.federation.address.FederatedAddress; import org.apache.activemq.artemis.core.server.federation.queue.FederatedQueue; -public class FederationUpstream { - - private final ActiveMQServer server; - private final Federation federation; - private final SimpleString name; - private FederationConnection connection; +public class FederationUpstream extends FederationStream { private FederationUpstreamConfiguration config; - private Map federatedQueueMap = new HashMap<>(); - private Map federatedAddressMap = new HashMap<>(); public FederationUpstream(ActiveMQServer server, Federation federation, String name, FederationUpstreamConfiguration config) { - this.server = server; - this.federation = federation; - Objects.requireNonNull(config.getName()); - this.name = SimpleString.toSimpleString(config.getName()); + super(server, federation, name, config); this.config = config; - this.connection = new FederationConnection(server.getConfiguration(), name, config.getConnectionConfiguration()); - } + @Override public synchronized void start() { - connection.start(); + super.start(); + for (FederatedQueue federatedQueue : federatedQueueMap.values()) { federatedQueue.start(); } @@ -63,6 +51,7 @@ public class FederationUpstream { } } + @Override public synchronized void stop() { for (FederatedAddress federatedAddress : federatedAddressMap.values()) { federatedAddress.stop(); @@ -74,7 +63,7 @@ public class FederationUpstream { } federatedQueueMap.clear(); - connection.stop(); + super.stop(); } public void deploy(Set policyRefsToDeploy, Map policyMap) throws ActiveMQException { @@ -156,41 +145,8 @@ public class FederationUpstream { } } + @Override public FederationUpstreamConfiguration getConfig() { return config; } - - private Exception circuitBreakerException; - private long lastCreateClientSessionFactoryExceptionTimestamp; - - public SimpleString getName() { - return name; - } - - public FederationConnection getConnection() { - return connection; - } - - - public String getUser() { - String user = config.getConnectionConfiguration().getUsername(); - if (user == null || user.isEmpty()) { - return federation.getFederationUser(); - } else { - return user; - } - } - - public String getPassword() { - String password = config.getConnectionConfiguration().getPassword(); - if (password == null || password.isEmpty()) { - return federation.getFederationPassword(); - } else { - return password; - } - } - - public int getPriorityAdjustment() { - return config.getConnectionConfiguration().getPriorityAdjustment(); - } } diff --git a/artemis-server/src/main/java/org/apache/activemq/artemis/core/server/federation/address/FederatedAddress.java b/artemis-server/src/main/java/org/apache/activemq/artemis/core/server/federation/address/FederatedAddress.java index 788f7fa7cb..329cbdc0af 100644 --- a/artemis-server/src/main/java/org/apache/activemq/artemis/core/server/federation/address/FederatedAddress.java +++ b/artemis-server/src/main/java/org/apache/activemq/artemis/core/server/federation/address/FederatedAddress.java @@ -24,6 +24,7 @@ import java.util.Objects; import java.util.Set; import java.util.concurrent.TimeUnit; import java.util.function.Predicate; + import org.apache.activemq.artemis.api.core.ActiveMQException; import org.apache.activemq.artemis.api.core.Message; import org.apache.activemq.artemis.api.core.QueueAttributes; @@ -31,11 +32,11 @@ import org.apache.activemq.artemis.api.core.RoutingType; import org.apache.activemq.artemis.api.core.SimpleString; import org.apache.activemq.artemis.api.core.client.ClientSession; import org.apache.activemq.artemis.core.config.WildcardConfiguration; +import org.apache.activemq.artemis.core.config.federation.FederationAddressPolicyConfiguration; import org.apache.activemq.artemis.core.postoffice.QueueBinding; import org.apache.activemq.artemis.core.security.SecurityAuth; import org.apache.activemq.artemis.core.server.ActiveMQServer; import org.apache.activemq.artemis.core.server.Queue; -import org.apache.activemq.artemis.core.config.federation.FederationAddressPolicyConfiguration; import org.apache.activemq.artemis.core.server.federation.FederatedAbstract; import org.apache.activemq.artemis.core.server.federation.FederatedConsumerKey; import org.apache.activemq.artemis.core.server.federation.Federation; @@ -57,6 +58,7 @@ import org.apache.activemq.artemis.utils.ByteUtil; */ public class FederatedAddress extends FederatedAbstract implements ActiveMQServerQueuePlugin, Serializable { + public static final String FEDERATED_QUEUE_PREFIX = "federated"; public static final SimpleString HDR_HOPS = new SimpleString("_AMQ_Hops"); private final SimpleString queueNameFormat; private final SimpleString filterString; @@ -74,7 +76,7 @@ public class FederatedAddress extends FederatedAbstract implements ActiveMQServe } else { this.filterString = HDR_HOPS.concat(" IS NULL OR ").concat(HDR_HOPS).concat("<").concat(Integer.toString(config.getMaxHops())); } - this.queueNameFormat = SimpleString.toSimpleString("federated.${federation}.${upstream}.${address}.${routeType}"); + this.queueNameFormat = SimpleString.toSimpleString(FEDERATED_QUEUE_PREFIX + ".${federation}.${upstream}.${address}.${routeType}"); if (config.getIncludes().isEmpty()) { includes = Collections.emptySet(); } else { diff --git a/artemis-server/src/main/java/org/apache/activemq/artemis/core/server/impl/ServiceRegistryImpl.java b/artemis-server/src/main/java/org/apache/activemq/artemis/core/server/impl/ServiceRegistryImpl.java index 49eeff1bfe..7161a68ba2 100644 --- a/artemis-server/src/main/java/org/apache/activemq/artemis/core/server/impl/ServiceRegistryImpl.java +++ b/artemis-server/src/main/java/org/apache/activemq/artemis/core/server/impl/ServiceRegistryImpl.java @@ -69,6 +69,7 @@ public class ServiceRegistryImpl implements ServiceRegistry { this.connectorServices = new ConcurrentHashMap<>(); this.divertTransformers = new ConcurrentHashMap<>(); this.bridgeTransformers = new ConcurrentHashMap<>(); + this.federationTransformers = new ConcurrentHashMap<>(); this.acceptorFactories = new ConcurrentHashMap<>(); } diff --git a/artemis-server/src/main/resources/schema/artemis-configuration.xsd b/artemis-server/src/main/resources/schema/artemis-configuration.xsd index 724485429b..e3c34cc464 100644 --- a/artemis-server/src/main/resources/schema/artemis-configuration.xsd +++ b/artemis-server/src/main/resources/schema/artemis-configuration.xsd @@ -1589,13 +1589,11 @@ - - - + @@ -1607,9 +1605,31 @@ - + + + + + + + + Name of the transport connector reference to use for the new upstream connection + back to this broker. + + + + + + + + + + + + + + @@ -1628,6 +1648,88 @@ + + + + if there is a downstream and upstream connection configured for the same broker then + the same connection will be shared as long as both stream configs set this flag to true + + + + + + + + how long to keep a connection alive in the absence of any data arriving from the client + + + + + + + + How long to wait for a reply + + + + + + + + period (in ms) between successive retries + + + + + + + + multiplier to apply to the retry-interval + + + + + + + + Maximum value for retry-interval + + + + + + + + How many attempts should be made to connect initially + + + + + + + + How many attempts should be made to reconnect after failure + + + + + + + + The period (in milliseconds) used to check if the federation connection has failed to receive pings from + another server + + + + + + + + How long to wait for a reply if in the middle of a fail-over. -1 means wait forever. + + + + diff --git a/artemis-server/src/test/resources/ConfigurationTest-full-config.xml b/artemis-server/src/test/resources/ConfigurationTest-full-config.xml index 5c40d7ea02..1fd0f7c352 100644 --- a/artemis-server/src/test/resources/ConfigurationTest-full-config.xml +++ b/artemis-server/src/test/resources/ConfigurationTest-full-config.xml @@ -278,6 +278,36 @@ + + + + + connector1 + + + + + + true + + + + connector1 + + + + + + + + + + + org.foo.FederationTransformer4 + + + + diff --git a/docs/user-manual/en/federation-address.md b/docs/user-manual/en/federation-address.md index b7bb2d8cd3..8a77cb9f1f 100644 --- a/docs/user-manual/en/federation-address.md +++ b/docs/user-manual/en/federation-address.md @@ -6,12 +6,11 @@ Address federation is like full multicast over the connected brokers, in that ev on `Broker-A` will be delivered to every queue on that broker, but like wise will be delivered to `Broker-B` and all attached queues there. - -Address federation dynamically links to other addresses in upstream brokers. It automatically creates a queue on the remote address for itself, +Address federation dynamically links to other addresses in upstream or downstream brokers. It automatically creates a queue on the remote address for itself, to which then it consumes, copying to the local address, as though they were published directly to it. The upstream brokers do not need to be reconfigured or the address, simply permissions to the address need to be -given to the address for the downstream broker. +given to the address for the downstream broker. Similarly the same applies for downstream configurations. ![Address Federation](images/federation-address.png) @@ -182,14 +181,125 @@ Finally look at `upstream`, this is what defines the upstream broker connection information about what discovery-groups are and how to configure them, please see [Discovery Groups](clusters.md). - - `ha`. This optional parameter determines whether or not this bridge should support high availability. True means it will connect to any available server in a cluster and support failover. The default value is `false`. - `circuit-breaker-timeout` in milliseconds, When a connection issue occurs, as the single connection is shared by many federated queue and address consumers, -to avoid each one trying to reconnect and possibly causing a thrundering heard issue, +to avoid each one trying to reconnect and possibly causing a thundering heard issue, the first one will try, if unsuccessful the circuit breaker will open, returning the same exception to all, this is the timeout until the circuit can be closed and connection retried. +- `share-connection`. If there is a downstream and upstream connection configured for the same broker then + the same connection will be shared as long as both stream configs set this flag to true. + Default is false. + +- `check-period`. The period (in milliseconds) used to check if the + federation connection has failed to receive pings from another server. + Default is 30000. + +- `connection-ttl`. This is how long a federation connection should stay + alive if it stops receiving messages from the remote broker. Default is 60000. + +- `call-timeout`. When a packet is sent via a federation connection and + is a blocking call, i.e. for acknowledgements, this is how long it + will wait (in milliseconds) for the reply before throwing an + exception. Default is 30000. + +- `call-failover-timeout`. Similar to `call-timeout` but used when a + call is made during a failover attempt. Default is -1 (no timeout). + +- `retry-interval`. This optional parameter determines the period in + milliseconds between subsequent reconnection attempts, if the connection to + the target server has failed. The default value is `500` milliseconds. + +- `retry-interval-multiplier`. This is a multiplier used to increase + the `retry-interval` after each reconnect attempt, default is 1. + +- `max-retry-interval`. The maximum delay (in milliseconds) for + retries. Default is 2000. + +- `initial-connect-attempts`. The number of times the system will try + to connect to the remote broker in the federation. If the max-retry is + achieved this broker will be considered permanently down and the + system will not route messages to this broker. Default is -1 (infinite + retries). + +- `reconnect-attempts`. The number of times the system will try to + reconnect to the remote broker in the federation. If the max-retry is achieved + this broker will be considered permanently down and the system will + stop routing messages to this broker. Default is -1 (infinite + retries). + +## Configuring Downstream Federation + +Similarly to `upstream` configuration, a downstream configuration can be configured. This works by sending a command +to the `downstream` broker to have it create an `upstream` connection back to the downstream broker. The benefit of +this is being able to configure everything for federation on one broker in some cases to make it easier, such +as a hub and spoke topology + +All of the same configuration options apply to to `downstream` as does `upstream` with the exception of one +extra configuration flag that needs to be set: + + The `transport-connector-ref` is an element pointing to a + `connector` elements defined elsewhere. This ref is used to tell the downstream broker + what connector to use to create a new upstream connection back to the downstream broker. + + A *connector* encapsulates knowledge of what transport to use (TCP, SSL, HTTP etc) as well as + the server connection parameters (host, port etc). For more information about what connectors are and + how to configure them, please see [Configuring the + Transport](configuring-transports.md). + +Sample Downstream Address Federation setup: + +```xml + + + + + tcp://localhost:61616 + tcp://localhost:61616 + tcp://localhost:61617 + + + + tcp://localhost:61616 + + + + + + + + + eu-east-connector1 + + netty-connector + + + + + eu-west-connector1 + + netty-connector + + + + + + + + + + + + + org.foo.NewsTransformer + + + + + + +``` \ No newline at end of file diff --git a/docs/user-manual/en/federation-queue.md b/docs/user-manual/en/federation-queue.md index 171fc76aa3..8f2b0f968c 100644 --- a/docs/user-manual/en/federation-queue.md +++ b/docs/user-manual/en/federation-queue.md @@ -162,7 +162,6 @@ Finally look at `upstream`, this is what defines the upstream broker connection information about what discovery-groups are and how to configure them, please see [Discovery Groups](clusters.md). - - `ha`. This optional parameter determines whether or not this bridge should support high availability. True means it will connect to any available server in a cluster and support failover. The default value is `false`. @@ -173,3 +172,116 @@ to avoid each one trying to reconnect and possibly causing a thrundering heard i the first one will try, if unsuccessful the circuit breaker will open, returning the same exception to all, this is the timeout until the circuit can be closed and connection retried. +- `share-connection`. If there is a downstream and upstream connection configured for the same broker then + the same connection will be shared as long as both stream configs set this flag to true. + Default is false. + +- `check-period`. The period (in milliseconds) used to check if the + federation connection has failed to receive pings from another server. + Default is 30000. + +- `connection-ttl`. This is how long a federation connection should stay + alive if it stops receiving messages from the remote broker. Default is 60000. + +- `call-timeout`. When a packet is sent via a federation connection and + is a blocking call, i.e. for acknowledgements, this is how long it + will wait (in milliseconds) for the reply before throwing an + exception. Default is 30000. + +- `call-failover-timeout`. Similar to `call-timeout` but used when a + call is made during a failover attempt. Default is -1 (no timeout). + +- `retry-interval`. This optional parameter determines the period in + milliseconds between subsequent reconnection attempts, if the connection to + the target server has failed. The default value is `500` milliseconds. + +- `retry-interval-multiplier`. This is a multiplier used to increase + the `retry-interval` after each reconnect attempt, default is 1. + +- `max-retry-interval`. The maximum delay (in milliseconds) for + retries. Default is 2000. + +- `initial-connect-attempts`. The number of times the system will try + to connect to the remote broker in the federation. If the max-retry is + achieved this broker will be considered permanently down and the + system will not route messages to this broker. Default is -1 (infinite + retries). + +- `reconnect-attempts`. The number of times the system will try to + reconnect to the remote broker in the federation. If the max-retry is achieved + this broker will be considered permanently down and the system will + stop routing messages to this broker. Default is -1 (infinite + retries). + +## Configuring Downstream Federation + +Similarly to `upstream` configuration, a downstream configuration can be configured. This works by sending a command +to the `downstream` broker to have it create an `upstream` connection back to the downstream broker. The benefit of +this is being able to configure everything for federation on one broker in some cases to make it easier, such +as a hub and spoke topology. + +All of the same configuration options apply to to `downstream` as does `upstream` with the exception of one +extra configuration flag that needs to be set: + + The `transport-connector-ref` is an element pointing to a + `connector` elements defined elsewhere. This ref is used to tell the downstream broker + what connector to use to create a new upstream connection back to the downstream broker. + + A *connector* encapsulates knowledge of what transport to use (TCP, SSL, HTTP etc) as well as + the server connection parameters (host, port etc). For more information about what connectors are and + how to configure them, please see [Configuring the + Transport](configuring-transports.md). + + + Sample Downstream Address Federation setup: + +```xml + + + + + tcp://localhost:61616 + tcp://localhost:61616 + tcp://localhost:61617 + + + + tcp://localhost:61616 + + + + + + + + + eu-east-connector1 + + netty-connector + + + + + eu-west-connector1 + + netty-connector + + + + + + + + + + + + + org.foo.NewsTransformer + + + + + + + ``` \ No newline at end of file diff --git a/examples/features/federation/federated-address-downstream-upstream/eu-west-east-us-central.png b/examples/features/federation/federated-address-downstream-upstream/eu-west-east-us-central.png new file mode 100644 index 0000000000000000000000000000000000000000..0ba844733e6107026271a61c23c6dd5b93148219 GIT binary patch literal 226275 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∈nI(%8}vYb?6bCOWvn*(ve|< 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

xhH&T%=U1R#23Ug-Lfj>P6@N4_K@h;+x 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 + + + + 4.0.0 + + + org.apache.activemq.examples.federation + broker-federation + 2.11.0-SNAPSHOT + + + federated-address-downstream-upstream + jar + ActiveMQ Artemis Downstream/Upstream Federated Address Example + + + ${project.basedir}/../../../.. + + + + + org.apache.activemq.examples.federation + federated-address + ${project.version} + + + + + + + org.apache.activemq + artemis-maven-plugin + + + create0 + + create + + + ${noServer} + ${basedir}/target/server0 + ${basedir}/target/classes/activemq/server0 + + -Djava.net.preferIPv4Stack=true + + + + create1 + + create + + + ${noServer} + ${basedir}/target/server1 + ${basedir}/target/classes/activemq/server1 + + -Djava.net.preferIPv4Stack=true + + + + create2 + + create + + + ${noServer} + ${basedir}/target/server2 + ${basedir}/target/classes/activemq/server2 + + -Djava.net.preferIPv4Stack=true + + + + start0 + + cli + + + ${noServer} + true + ${basedir}/target/server0 + tcp://localhost:61616 + + run + + eu-west-1 + + + + start1 + + cli + + + ${noServer} + true + ${basedir}/target/server1 + tcp://localhost:61617 + + run + + eu-east-1 + + + + start2 + + cli + + + ${noServer} + true + ${basedir}/target/server2 + tcp://localhost:61618 + + run + + us-central-1 + + + + runClient + + runClient + + + org.apache.activemq.artemis.jms.example.FederatedAddressDownstreamUpstreamExample + + + + stop0 + + cli + + + ${noServer} + ${basedir}/target/server0 + + stop + + + + + stop1 + + cli + + + ${noServer} + ${basedir}/target/server1 + + stop + + + + + stop2 + + cli + + + ${noServer} + ${basedir}/target/server2 + + stop + + + + + + + org.apache.activemq.examples.federation + federated-address-downstream-upstream + ${project.version} + + + + + org.apache.maven.plugins + maven-clean-plugin + + + + + + release + + + + com.vladsch.flexmark + markdown-page-generator-plugin + + + + + + diff --git a/examples/features/federation/federated-address-downstream-upstream/readme.md b/examples/features/federation/federated-address-downstream-upstream/readme.md new file mode 100644 index 0000000000..d89db44af8 --- /dev/null +++ b/examples/features/federation/federated-address-downstream-upstream/readme.md @@ -0,0 +1,34 @@ +# Federated Address Example + +To run the example, simply type **mvn verify** from this directory, or **mvn -PnoServer verify** if you want to start and create the broker manually. + +This example demonstrates a core multicast address deployed on three different brokers. The three brokers are configured to form a federated address mesh. + +In the example we name the brokers, eu-west, eu-east and us-central to give an idea of the use case. + +![EU West, EU East and US Central Diagram](eu-west-east-us-central.png) + +The following is then carried out: + +1. create a consumer on the queue on each node, and we create a producer on only one of the nodes. + +2. send some messages via the producer on EU West, and we verify that **all** the consumers receive the sent messages, in essence multicasting the messages within and accross brokers. + +3. Next then verify the same on US Central. + +4. Next then verify the same on EU East. + + + +In other words, we are showing how with Federated Address, ActiveMQ Artemis **replicates** sent messages to all addresses and subsequently delivered to all all consumers, regardless if the consumer is local or is on a distant broker. Decoupling the location where producers and consumers need to be. + +The config that defines the federation you can see in the broker.xml for each broker is within the following tags. You will note upstreams are different in each as well as the federation name, which has to be globally unique. + +``` + + ... + +``` + + +For more information on ActiveMQ Artemis Federation please see the federation section of the user manual. \ No newline at end of file diff --git a/examples/features/federation/federated-address-downstream-upstream/src/main/java/org/apache/activemq/artemis/jms/example/FederatedAddressDownstreamUpstreamExample.java b/examples/features/federation/federated-address-downstream-upstream/src/main/java/org/apache/activemq/artemis/jms/example/FederatedAddressDownstreamUpstreamExample.java new file mode 100644 index 0000000000..08e958e665 --- /dev/null +++ b/examples/features/federation/federated-address-downstream-upstream/src/main/java/org/apache/activemq/artemis/jms/example/FederatedAddressDownstreamUpstreamExample.java @@ -0,0 +1,29 @@ +/* + * 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.jms.example; + +/** + * A simple example that demonstrates multicast address replication between remote servers, + * using Address Federation downstream and upstream feature combined. + */ +public class FederatedAddressDownstreamUpstreamExample { + + public static void main(final String[] args) throws Exception { + //Re-use the same Federated address test for upstream + FederatedAddressExample.main(args); + } +} diff --git a/examples/features/federation/federated-address-downstream-upstream/src/main/resources/activemq/server0/broker.xml b/examples/features/federation/federated-address-downstream-upstream/src/main/resources/activemq/server0/broker.xml new file mode 100644 index 0000000000..e3eb6df0bd --- /dev/null +++ b/examples/features/federation/federated-address-downstream-upstream/src/main/resources/activemq/server0/broker.xml @@ -0,0 +1,118 @@ + + + + + + eu-west-1-master + + ./data/bindings + + ./data/journal + + ./data/largemessages + + ./data/paging + + + + tcp://localhost:61616 + tcp://localhost:61616 + tcp://localhost:61617 + tcp://localhost:61618 + + + + + tcp://localhost:61616 + + + + + + + + 1000 + true + + eu-east-1-connector + + + + + 1000 + true + + us-central-1-connector + + + + + 1000 + true + + eu-east-1-connector + + + netty-connector + + + 1000 + true + + us-central-1-connector + + + netty-connector + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+ + + +
+ + + diff --git a/examples/features/federation/federated-address-downstream-upstream/src/main/resources/activemq/server1/broker.xml b/examples/features/federation/federated-address-downstream-upstream/src/main/resources/activemq/server1/broker.xml new file mode 100644 index 0000000000..626cd9582a --- /dev/null +++ b/examples/features/federation/federated-address-downstream-upstream/src/main/resources/activemq/server1/broker.xml @@ -0,0 +1,100 @@ + + + + + + eu-east-1-master + + target/server1/data/messaging/bindings + + target/server1/data/messaging/journal + + target/server1/data/messaging/largemessages + + target/server1/data/messaging/paging + + + + tcp://localhost:61617 + tcp://localhost:61617 + tcp://localhost:61618 + + + + + tcp://localhost:61617 + + + + + + + + 1000 + true + + us-central-1-connector + + + + + 1000 + true + + us-central-1-connector + + + netty-connector + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + +
+ + + diff --git a/examples/features/federation/federated-address-downstream-upstream/src/main/resources/activemq/server2/broker.xml b/examples/features/federation/federated-address-downstream-upstream/src/main/resources/activemq/server2/broker.xml new file mode 100644 index 0000000000..8cb6973fed --- /dev/null +++ b/examples/features/federation/federated-address-downstream-upstream/src/main/resources/activemq/server2/broker.xml @@ -0,0 +1,70 @@ + + + + + + us-central-1-master + + target/server2/data/messaging/bindings + + target/server2/data/messaging/journal + + target/server2/data/messaging/largemessages + + target/server2/data/messaging/paging + + + + tcp://localhost:61618 + + + + + tcp://localhost:61618 + + + + + + + + + + + + + + + + + + + + + +
+ + + +
+ + + diff --git a/examples/features/federation/federated-address-downstream/eu-west-east-us-central.png b/examples/features/federation/federated-address-downstream/eu-west-east-us-central.png new file mode 100644 index 0000000000000000000000000000000000000000..0ba844733e6107026271a61c23c6dd5b93148219 GIT binary patch literal 226275 zcmZ5o1z42rwuNB?MnJlyyGuaHp}V`gQ|V?DP^443K|va%Q&Ob6K|s2t^M2zw=iYn% z=lN)Ocw@h7ueJ7mCtOuo2IDEoQv?JA3^`dzbp!;I0t5t58!9sJohODl1i%MGH+30t zg!19%JHQtZS6Mwb1O!4H_#2{4_Bik-Py{(iF->p8{Y(^p(%;v8E0@aE7Cy9|bruR> zRF=qb5aIxHWwetV`FQJNwm1{*Y&hGVve)O86G-ym@+I-grTcoo@}*DVYO)*X!0oH&%!`AJ z4AOWLWOp>WJo#eeLSl@Q&GHzTkm#>|_GERM99C4vc^1Uo^{Z$b^ zABL_r!IRn{l2_s!XXH5r4^G9JuL-0u4HGrxawoqk<(-7T78`rz3cE-gB_QWDB)sud z|KSum3X<>t1v1&Ua}q6+ug|3t!A*<&Xj!7RP3^1UHZh=z>em>D0Ez9e2AlsH5H38< zXqJt=CWoP%sbaEMBLmBS`A~E;bW587EOoauzY26Qt=iO#HZd;ps9cny^c0LllPm z{GXebbl+N<**sk5w3PO^Po|tb^vf?l5hj}Eyo;Avf9r*ZEEHLn9#u4-FZl^)mu=e{ zA9krT`s1dWV|LQEMENNLB97}*#MCdCLMRrPuRnIyCV*vw!PVl>a5{M+uMdZlqW+)C zBdw+ALt}xp`G3!bFk-sbU2}WD+WCVFwyi+teU`va39vN@R)P1Z>e|D&>4vb4o{Gbg zI3;=c4GeES;KNuNw*isZ4vK$gKXKy*{#VS5uS{At$uZVfVS8N?ZE0Z|L$OYwgVTGx z=u;8r3A{|o$d?ki6Aq!qpSL@{iGKVgTVd+jEvhaq+~*gpp&#uT550iY4xYFee2J*f zbdMPjc_L4Xh||vi3Ntg*FeJUV61i41kqd^;=zpJ5s*d1V-VDDUrx#u?9O?|nek@lj?9_5_a#*(xV@shuTYpxP#hBztu$e>gz6)L4rT0sHg=}^e z34|xBZ)Gd?kKd2g`Q8{`mY?^uP|zXGsIg8!bh%xSYqrhV2l!C=XmTcH`1xc!*WS>l zzy783f8hj=D_AL(DO7-k=$6CMM;6b~;8zf4XVJlpNjmQv320AfJf_*?l~a#KzRN~0 zvi%SW$jPnb*~#`iPlJfJ;-yYFL&RH*zO-^1o+nkV=e%i?fo*fnef~YvzVDN!UleFG z&igvFHoi%z@9?9tzBdkbU(~AOn`Y`|I$?S{5fNv$`lIe}m@ePCH2PJK`@9^8HkKGB zIs2%vm=Kht=QK?X4}2S}4(L8g+>>p08(jsKf9ybpbTH!1^KZIB`KSjAl(G@hQ5*X%xnJbh7%!cs$sl^kC?E@q3zt&_O2;*FmNI zgWq@Rxv6{GF{^CehFOCqX^@W+rSVp~vHj`CmN4iRFjPY&gb|*YtG5^ojq`E>G9X}w z{_lz90inxoA>7NDslAlG5$&8GOM0cMlB7p_+@qgg-A1$QD>&g}gY8Hj@p0-2``C-u z5rwFUO-+nM*Wd63K81wXtmHmmV$m*5KMkeOmzHw;NU z3JoahdoxEB9K9GMXLi@9P#mgwkV#gQC=T+Z4$e8V%ne^zClQ=f_8cRC2Sz_KV#@;G zwLSIVmjsNIM6v%jTwv(O7{G{wkixG8%{?BN(&)ERE5b=wX>ue<)iajZCEt|8fgshG z`3)J&`{l8awG4%0nT5TNnv$gsi+gX^)Mse%b!Mk!5lNfl<-i z#UP0F(fv~bjJo$)*G^IbFWEv)g5^Jm5{yKa54wajxWKC{OTz%logTj&%a**F8~Ro`%?}Pdc{ZDZKm`j8}+CZTyig zNHje3{<3bQe11snVnSCCd$z~dV&kgrRlZl9G>7$}fPaFxFgl?lZe(;Q%VmZtwr-f| znc-}YX|2*Q$0F`U_i9A?H)>*~5G0k}z59e@C2ZsL6d4}i$Z^xEij)-=z9ee&9aD(2 zAEX!Rz}odihx(A#KUr8LnF=zr1V-=B1#gEFX`kf+%C6(_GTvC{nQ z(4@Tk*}#e3%uGF{<7r`Ai)%RdoY@H0vK3;K4h`37d{d@GYoB|*VYDx}yLh&jrSVpK zyPBCrbo58<%h#!=ssC`UGT1rmf5YVAKiAK@?CqexyQ&qAdA{VeZr%BER34&0z3`&!C-^e1=*gPdiq>^(93KCind>_Y$QUh-s}SrgCwE7J#p@U~0F!QmJS~3Z zdvK!g$tmx^$?zC_m^!!}ex0Be!n@HaRHyDG!$zLx72kc`@Cix^ znVYdx*EGO2o3);v%e?lzyD3J4d1M#VSYN-ksZP`yl+``m+LQmzVEXXHo#jEskir1nxW{z5UT8XE3}OO+CJ4ftzgOxR3nLO*+O_{ zM-A`=1PJYBq>%nR+QIUBoxNzDLCeJJO?qYujUnx5e{K17yl#5uVsS~?a&Nb zTZe;E%756fY07Ew(FP}$vC01SR;lL>6m6(Gp&?C^O?V@_nqSFSiu2&b`Ntz;%9`l4 zMP#a7NF3GLr{g^x?b{@_fDg}=yBy=r1cqKM%x`Lvt&N?_gyLDf;(7bAMg_`*B!09l zPojg7wLF^<@FY<6MdJQ>Bq?7Lz5)1AH?OZACv)FJ zXWgB-bcNT_EYQJq+#iAVK9(yo{ZJa5&}`jhh+H!|$+%nhK-=`M^M6HgW1`zDo)3YEMpl*E>9 z#`^`*pdF2Xx%Vx7S2dEiTMFZzPs-Kyq!$z=75U@V_k^*&qcc%r?>oMgh}sQ^{BcTVw~n_mK70&0 zl6zsp(F1Bc+6Gx|E1Qnxl^=&NS`9Te`gtm!c`OxW5?B^vbv#+h~|^biK)vw0ik ziFJ=|n)HUozPbgl_jWymrm*|TPy6Rn%3#YDZ`8}bRdRVXU`wI^qOFty^}lr!K|WXt z^Aq6Fa*D&lj7NaXh6htcCVX_ri<$jFKmRxD{vQafvI4xoVA5EZ;$>vwATL32ewsg3 zFmD*wyBnj1W)M#-=~yE%zIvHS$6V8tX%-TLovKC2TShG}y~DnaC=E=ZCua zJCO$U75K?Ol?xcOM1#F79jg}&?I5-)TQMEcFOKZXd0fsjJ)_%WtNh&S?X8%Eck|xX zLSurDK~O+Cd04l#7yT(ksFYa}dVx)k-%xBeMrz8?N+P$qsPbpUk+2q6KU83b=h!b( z6pOfY&k(fZRwXA@M@op7Ieh*$IROFUp9#$?zp?3m?shP9dBOu1DKB9N+$g+gar0e- zj`r?vTWjO~kN?9nc1IwXD7Nm45>{*=o>&_$`~=djJ_E_Oz7JmXh-sfZ9^D9~{{8GT z_a!y?v%4qnPy=HdL&|0(vGx&6ls0~seHttU`(H8m&+^pFTTg#iMWx!LGk4O_G^`4I zmzs7%?bo$m^0Y$d7V9!9H-Kq``;a;~;Wd6T-^;cJKJ&*&(4n}Bi);rTNJ0F2jZ5gG zHafH52;LJsc{p?sV0HL?kKiwhc%HV0E>6%OkNJIYe6SmzP?HI{8L^%MIOd}lUkA?N z-4^-r;rh?J6xzK{FQ#Ez7~Ocu zI>>-&3XjJ_wJr*^;N7UWaG2Z4;Dw|k`t{vfB=9JhjR;n6j~pSc$!?9zBxy9^=u7D^TZA zV~9Tyb2yW#aZD(121NP zL#b=`Cg%mm(542QPP7;&^gJp(hG4f!$kr;GI5A4=^r9+E44YxiFhkUTb8Clp8tyeT z1VdZOcWGnr6kZFj3_m#>eF9(7tG5VQYK7&ZmF$LU(zO2=H|;0|fXGdvwaBUjJ7MW@ zYbE{&)VfJv+0}M%?D)mOq2=x<+$valX0@*Wo!lua@f0t@|6WB+sf*ou_v8Efn9l5Q z>)mZRzTtF&#k0T&y)Pb~764POl!Y)5^65EH)c2pFah*1N7?p$ZcI+W6~-sw~m) zMc6cO*3Kjm+MS%FrB+FlN?4xcjR`0H5`hodRRGcI%Wc57I10ff%z2gnRv@Nih{GM# zk>B>~6!G!nf`3AC{Jgv>Wc=)b1o%EWtx8~1+KV5V9_@_j>HYk%*9R*RW?uG8a{r2j zP`eq{0uz%D-#W|CWnDPYdFy$``1;r#Brm74vOq^Mu92PF%LuQ$+s%k(2K6a0xUddZ zr3-dwEAc^PGf~95Y-1GN!iTcp{Cf4Y_kS5#BRIBkH_|)coZ3X`Oy%DQ^8alOT{$2* z|Fr$8?5U`Soc{4N7{Pk>&`4YN3Z>yjqQ0TIil$kYys*F%hnrbZ(!?|O_tKnfSN%k} z1*b&Q4qHt_omV#n)5-N(1O3h5c$HeYI+sL$(_u=JPk&O}dC~4bvMZDF&t%4dDon(U zkf3i3d^ZZWx{?Y2Dpe~{@-_Q%>`XnNHx_YJ#5pZ6#lT^Un}#xICUD}IP@dhSnYres zRO-K%H&z7>W+mT}?w)rR+JBu?!-Q-gA%Y7T`nq7B{5!)8o^Mt}F6j#Ev*0a|sxM&J z310@^-~J-u63JYiIHf$ZJ}wx&>|~z+jqkY6Rrx-OD}AWp)5y%Mkf*DXJ`(EMZYi?d zO`Dp-wr@*JzUk1dy${@U$V1+Pd`X(#E06}Z|0`o1gHNgBGV)Wo7-K)d&LOxG(hDP%hml|Gzrhq}y;Tyr;4&i1!znZZ_7zXiap zV;>&xF{htLa(LajyoXS{C_EJ3UkVAX^`&R(o*Xwl6UH6n(<;y@rfFRKQvAV<{&{<` z1rC4AGd!aUJ&EDS9CNt8f~$*zlLh$=6DSUksA10l{f!+&FlYP)O4ZHo5#fv^#p~e4 z7yn2rl<&d&_)mUNq1I^i?Sa}YY?9^@nM6$>rhKf^91*&W^e57jKPB=^7fyGH7Dc3Xl|k{R|r=bEm122>FFCP8sn|(Y~vUX z!lvShr=ZX_SFps6; z%&(vM>Gz$O%4q(9+H^1u`mNvNZ(GL7mPbf+b{HYLiU^&n>kEL6Ft5_DIvDLR2`w_( zD>8LYqlyp16g&*>P_zE?BJs;e*fVhc%5MDHg7PzImyMhsNHv}BxcB9uhed?Xd}%~% z&?l-FzJ=QoLeAo#KhGad<3HwY5k(%-a1sE6aOFiDe1nQU@!MTTP;TqrG8#zDe;;H; zz#&4U+0RE%x~qwy(~AVlQX+wxWNx*Pr?|^;zE;SOd=TKXK;*0VVrL#UM_+CiJ=o{C zKZ2Zx(z#8jpVoXyp*~S*PWk4Ikr&*57|--+tb2DeL>F9}9Jn)P0>GeKnhT>0Nsu!T zlFBrrzDp^&PkP=!kX;TAUM$#gz|%*H6jbh@`s`1s-YL_kfAELvzx)9sUDGmEHSZ_D ziX}ikG6*$^m>-AA>MGrIAIpDIQQ!aur$bSUg+w0GOwS(A6wLH&p-R%x+{)HUNQ2n3 zScekX#evYk_Wc~VAR0P7Db`~}(Yt%6L7<4!G)Kae4NO`PtUW}cx6gDg1nZ>pvy`DO zgrBWoLDbczmj$C5d_82#qiFw?hA9zwPys!RJVkC9jrLJ_Kd|w=#3Fzgv2-BRQ*aHf z{a5pX+!h12jbl)n>K~k69U}|h^TR$H=>Y-n*gQ!~Q;$|CvRiLhh)$CvDf;1qi;3Psim8)5&`}#+$&?1JmVhQ>F#BV*FG1$8W#CDf zc9k8}AY#1A9XnM!E}aiNp7G0ugkm_TYl4-TH}#++V$S?Z2JePgI4 zcOsXKCRmpIuSTJI`wYV!K(#RUV^#z9LX^FNkQ=+8-^A*J9I4Z1M-S6A zPCj(Kv(tPe*6fH(p7H8_u4}M|$L{Y_qI!Tb-DECs2M)I)D(!Abg*aa_E_d-y0r)^; zDZm?b2Q^K(EVeqLBLp-Ow5s(I5dJf6`>ZC)Ve@4m@0q^Dhj^L#t*M0#`y;- zBsZMT_VT(Gdb+G_j_Da3HP8~>ld?y(@1fLSR4-iVi4H8ZF}{6HSH~ZZoTdOBc%3$R zNMeBffp+&^r+$QtYuqq2Q5i%#sspNW{hcK~QGV#)lMFwruok+UpRK3UUIM_6|388P zlpn~6*eafwH*b}qVy`Sc3)KPI(=h`fQYSk(Ke7&BPj5O!DmA-H);o1#pJ930f?_k# zOOM@(r$>8JR|<=3n&oe;VoJYpV?%2r+?q$;tw%vbzkyQfhq;$AzKsN9)(sU4bdx8K zJ;mua0jYaC!!FBBN@#)%QnG;kvWy6(ug#r{mwNSI!vgGVK!?}%9Heqn^k+CYpFf)^s|PSSCM{Oy{adT+D&} zQ+I06d*f3MC9tkG|+;o&uxqW*-=1KYtxYtFG zq_@y=A6yiy7JU^V->4Vbl2jb*?9?&dQ;!DmSb7B+iIk^jzdMhKu+MM5z6q@NM;`I4 zzY-T!q@?VLMpa%ZAjIc27rtaz^LY5dB5ocFNn?x$Vuc5kR-`oNNZ1Z>{84K@pG? zNCDnRaPIn{`5(|H3k8nGy9CN4ZtG1bn^rvZ0c*57Rr_W0%t0Qh1I5<*QKMj+NYx~I z?@sD?TiSM{rHo9H>Mm=6RJ&neH&a<=<^tZ7 z1_KL(b|GF&r8toDt*%Asq=FG`EC-m==-Bbfw-Nt=B)t2{JmpHDY_Z_t(}2cl*y_wd zV_m1y&8NB-ZH+EcIZCo>yL>C#G1p+%17fBSPsj_SH`k*bB|p1*P1Kprw-`+9{OwM~ z3s-VISNp)Q8U#Z(1ArsCaCjIt|et#bnudX~?t^4t(1!!lF61hz{ zY-b#^0uN(E-$QuNV#9sO>ThxpYN)KlulHnk+o-N96a>z)3AU^#2Pz#QBNKs(?V+(c zu|DzRE~Dr_7a1teGzhuIlgV1k%S~!!(!api%WD$;U_~!AKo2uUCE6X#oA19fjc@Xm#Oc>?qpdN%{j1#~ zoh^>mcE+r<5%u__y!(!JP4?U7G?|x+ClBF{eVKVwwl-L0t8G?WE66> zKPURyo+yl6JL@s zH-%no#HNMev!6sd$94pxcJJNsHlQpGMoJ@n?;ij{yOE~yWs>||0bI{C^1#yMI{ZQK zygwl{&+F|aM3ui!FW=&V%6kiBfy|F(+C8laX!Z*xG&oz6EgZz)YNo7 z3_~&@Lki)QU2|g91iYqO`rBT%3X`CREL zQXVSf+*o?k{oyOp5?11-{83xU)>skzbn*~Bzy-3eHwc?+;D2V zu}iRj>20X$ZmnQ#^1FNQeno2TNr2G+LfwO(k(d4B?oL#A+is;pqxWn(7GjLXzCFdk zfCfnZS3RAH>iCtx0MH9FrYW`BVsM?S1kSw(dAQqUvJScm92{4q{4tg*rCn5HBM8vx|pY;7L zLL65rnC@&4jQ+RNoQG0jNN#!C>wq)gXWRYkdh-7Z!u=`$vl1*=ny`ECUg4RcdTN?7 zsE6~+jz7%~7bNe_6t_4G*ow9Dc~P1D_zx%<#D?9a>jgqN-uhiO+HSW;`U7U$2P@m2 zT@7Eq@cCvyx}Z%pcpoq8I85; z^UN#XeNkvvZ(6DCQ^Z$84yf-yEa;1yyS4c+!9QIFzNsVNwO?FX>b~Q|W5}tURITW< z;~sGnbuYXJ(OVON68?XPr85n{-H;6M$aLq=a+3tT(eDkmW9RY7j25~u?h*o-@TYZp z79nual#bIs#=29By|c3a8~19FSnc9IZ1~TI{at}C+tni^rM28-9V>O;gV5M5 zh(~Ps)$PqsCi|&b4)`Q=ZVex?o9MH4F9!vAB6AgSw$Ts^m$l?Y@@pq~oXD0q;I`28 zCwn-Ej*5cVe(fGS4fQ9vM6p)gr4UG_huu--OiuMtbq9J6(-9}A%D_C(yqt2U?WtioUrp16 z611G0poT}0Lo{jS5WJQmfMs0bcD#}KIXZJr_D5K&9)C)bo!bPH7tZdWf!L^QDVmjK zF2|k&`A5OC-(RA0mq?m?mkptlUJdAb9}wzYA|^!BnvwJI7vg8Knfs)x=VE+w_+heb z=aLRTZ-M%-;%~xNz6zjWn&1^Kew=;*#6~kut;R#Osqs;e`h=%su&qvMXe%M;wV)fa z*R+p@DFr0Q%^Fd_CUCZItq3mysLmPu`5-EO^{j}IC`VQ3_+Eil12+I50?3RdCQ}Pt z4_zl6*ObV8=tnv|#!oF;TUPL9Ufi{O>QbI(TR(@PysmkOONcBgqdisvF-H^j2d%y` zg(TPdJC7+uxhNYmUR7TysV+)@0_bD^)j1L}G94h@`<8aq7qp#Y^iHfn5ECep?)%#8 zP(toLL0gtrA|W`_tX5`Ucp~g+{y+dp4rDn>H;|X8uoc75=(FC%`qq>Ew}?{qLgnlC z2GuS+=i7gx@{jhF&Rz+XshgkZ^(|kx;K97%N5&H_j576UFdgM8YPOihqPtng61bXu zshx3B%!Z=CrPRTFxJmOA4sz|*NxfNTrSP7B;~cT`m!8TheQw_{kz~lb2G=G^GxRc) z$Ap1{#ReMtWc5wLs94v_k6G1IYof{UWH5O-=6jxNmrOk#{XgAS|)-_Y=|lLNMS9S-kcl5 z^R}Sk(%s8r#q9y&RnDnHS_pTKlYk5wK-cpIaK=;f@(auDxj^>J&a!pNW*Ht^Oq@30 zV`%k$kw+XvcZN8@)~&f`Q#(5t9dwS`d*fywE>2=pD9&FVvuI2A>CEvp?PWU}f1XR~ zTD#d@%NM>IQVmN3*4pc^)6RGPRtm1=`*v0KB{YZ*sEp@hgnKHaBkptySsdBZ7vXc}3~kXR#I4<2OKicAXj7#wwJ(`uJ*YJRzZbrP9)F3E24?JjGQv zb>(@Oyxb}p=v5OI7En}?qFjpGJTYI=WxBYs=Maqx_5q_yWSAH(xPJB_xnX}LY|vEd zI$BYs>&MC9P{DHUEMG9p2;pm;^7@LR{RVFG$%S%+sKsfVKua(c=acQfs#NyQcp5PO zDzI?+rPd{!xB4oBp;_RE^SnIho*_rw+w6{ESJ;NgUaqBZ{Wo^*w}bmnT_kYRqq4Tk z!Miv;mSTBa0T6=As6DbHnQj@(#H3C8_fUqt9|acWkoq|$a}RT zX#!zP(iCU!f^HIWM%?raOYZ%|*C|~Yo!MoT0XZ{Zp`irk%e_uoxGx9-X48t>p_v_) zKF#asU{#mDT=okar!x6p6=ZuagJS%NgH0M5#7~2jI07Dk3Yv|FGP-}T*$>I2f2x%6 zp7o2&ci9*=jHSshL~SCJ@x5d=fW@l)_KERzb1NSMYevqr2KM!Q1itdi|6q zvZle{W6(8%G35wRPD-hcOSaLs^vyBrH7e(LCWlg%vEq=|pXER7eYBC*v0j3agNu;H z{66VC>V7(v@1E~FSM9Df8o=W5|AxVzUPOuVc4DVF!rv;W=lZqnvq=p)$VL_dL6&sz z4H;Er5aryos3iA!_0f3J*dnPknk*$h80S1tXr%wTaZI@k4osB6Ug>(?^^J?q>PC@) zj)0CPSE*E$#M16&>nf|J6XT_&tmhV=#SW9Nm8Ia@j{v$97U|)5dWOcev-Mmtjp(;7 zqkL;9EWnE-Jo|uuB6jqy8C zsJd=6usceuuV~M|+O37(9VZ(DZp@i1wD1|zQ@*y*b*@8Nm=Gma#pOs(&Y`}7k=AZ$ zp6P~&f`>XWTv~3VbO=Xq+_4j^q%$YIgdo8b4Z}wC0qccqTg7`8%l=_)deeqL**K+o z8e|XuPk`17tgW$Vi5xCxCfS@yH#?^6BT|weQ$WBZRWdp-ucy+Ho?e&>=a|-;pO<_oxjmAGu><->EP>QMohU!@ak_MDK7qii zjHWg9JvUHY6|;}8G2=t(s-O*aSa~{_7x;26v!!)^ya-b+1iYw7scmu}pky25Q4@0( z_1C-9w3m?CS_OJ0K2NB;p@Fr~j*577%NntKpU=q~H>oHn){@WqE$>gvn3!d*?d zjH#om%3v=BwZO;0CzTwtuGQ}{;!loKxWaOeN_Wgv%s%AqV28_gWkQ>7`M_p*-&M0q zdAb*-CP;A`j~&+cmvSF&`HRR#LJ`xqHG{ENQv|fBcivFXcRj zkJFEXX!twyDqX!emSgrzKRHAl9Wwh7D)jt{iQ9T|VSteY;E|@ph>P1K{=66qx<#=c zWjl(%v0NKCmgtQ=%zus-{P5db@5{zzgyHdR$_w*BD?(>yO(L|&k{cbfYeWGlhd)Y4 z*NL(yJzVeSI|sN?=D~engjbpn7tS3lqd+BnHL|nL? zOuI?~s;Yc6RvO?jTE`-TJ8XoA?(uCfI{S+q9XbMfz;KEUzk&M7m0PgARw<6*lJNCY za94xCgH=~{b^1NWb2UTO&(vdUJ*X7tR0{c_y}z}mo?3lqU!B{FQ!!~j(6W60;*GUb!sc26G#D(1#~41-s?$djN#c%X zPbCSM2Z23Rsp72GsFnKl8p3Y&O|hIP5e0EN9CvP{IHZe|j2YEEYh(E0peB&+y^7XA6HKFT{W+V=e|PZ!E#%Uszv8xM5@cmUPOZ5 zz^h`<`4Ofr6?2@X`>}6w#Ew?MWMgiSLps<#u57z%+okhHWvesc(%h%R!0?ls4vLfX z`?w_`UiIE^pdUO2h)$k^InHK#zY3i`N4u)*RA0t)aE2m+*p8GE^P7Q&oNf1Nidx|y zNP&$^%nI8vJ8Ft38fy^Ogd2`42zDqvr8;n%iktS4PhX0XERh{=4YIv3$C@cm#D8m_ z$1@nO()joI@WGlX+D$VKrvjrV7eCVwm8F+)m~7++U0Yn;6mV{=c^qVmiUyp1mu$OI z7L_w~08nF@go=EG7zS?$+(|PGA*GhF{#}ZHs!~NY+1kS!=eGKaUde3_prb~GCbn5B zoFt>3n3bpkN*7a-1Q%0;^@#?Ya@)9=$0pGZ+f%wA#CtAy0&Ww77Bh(0Mc)I)GxfP*)R>g5;gq_7pOSO$Z@umWPK;KdVCc8`kpbC;}YTkYz$r%n3` zPh-<^WI?9=^`ICus&j1^OutFdsZNH~@LX)!)Q(6lPu?%%Th>axh z&-5Mr-6k8*rO4}tXX+C{#RZZ<&8vQr&q&Y$hFvV4P3AM137sb7yFA)FQ_PXa>1P58 zC~hCK2X4i4g!e@a6ULwA|0H8K%Tl+(zg5!i}jw(HqPIJ3O3pQ+vxSI z9g2Yx&=_sHw zj?E=09te2*u0QJK#mLKcn1LSzWiR>AH*S_YlyrVJH$}ZW_H!U_V3q${=lKIE&~S4w zzD5JTRbG#@{o`|~_YMa`o&-%@UbuVJJ-fInrwj14TJ?~e4I`XpO74^5S2|zjj)_y@ zF;D7m90rVR?;Gk1Se&N~l^lP40$!{6+KXD@N&0rY&mbq7Sr%aM@l7*B z4cSkFSjg=o>J7R1WiaTXIiB$q%wYb!b^1%uea1#Oaq0*Tv=T3&s6ZUj=4h%D_aeft zkF+oLw8J}ai40%hb1>AnVr<3pc{)(7C_u+}3OS3i5939^AJE?Bgpc*O4`*1v#VJP|Y=T!&ArlZe!(~SxqKx z7ypp-@z%`Zjn*v+Kbw4|p#nWxPE*i*;1x-wbox`E z*b20)I^#yzB17(CpytD0oI;GR{M>UW{k3 z77(emj+04_LqZ~6UoNIA$D#>ZyFk+%1KoV0rb=PtWLe=iB?Uggfr`KJEeIk-8cWN{ ziafR;>VuWmIpi*5i0?xbl)iq(4oa(E`{on#C$-#5TWC!Y8Rc@|~g^X}jVC zL4SVBS~CyrH-#*-hnpSesd4sRm8mvrfy_7iCRFo~nKASt%O^~sjxdC`Krxhhf<)kKpJ7BErw1oVJq3F?(~n4TjpUr zR2nSuG~)Z1^i;I^rv>v4=O^5B1XLF0?_a17_1B%Bkg`P`as7cx+vpxufxb z)xQwzPW@cgt7&DvLT}7KfP>S5geGp!Jp78c%O-Fbo5jG~YP{-f{!80Ov0H^=vJlc^ zF(TVae$6VR5!&TzMgp-NEou2oJ#OApMUk78^br<`q_)%CWnGs(w^q@@_!VYAvL`tR zX5@&HlWT-JDo+$>YH(UKbwl_jq;Y_Hbj!BzJ{ljT0|GxzWi<5Wh9z{%G&fQrX)?Oc z^k>|(-DjXHACVAuHkj%xW_{_Z*m>@LQ-h=Y&K4**&M&TP@0aAMSBR91s#+u#^`c5d zcQlWv8b%D9I2)C|7$m|^;rWP>DGMpJnhv{n2%#rMm$=&!{Ym3;tv^!^;#oX&12WZ(^+7Co_Zs7e%2e3E_@KYSmac`y8!hm9S(#Grkk| zTYJatU6#kMkJVx&S1$~iKd%;AtMFe*Qpo0rf+G{FR8A(hN$-ohs^MLc@FGC^#}4c? zO@^H1%hB-KfS}zPR`@h6B`Gt1DGiK_VNbsO2AQ}QBR32RTYJ^UO5S7ep9# zf@0#dPBR--jt#f!{`FX6HQfF{!yGGU00k_`q*7&bA1EP^O$_PU2-L1kVLD@kW~t0C z=Zn$iF@WxPBD$1>Vv1l-1xf7eKZxv?~2Xl!LaTSzM>+BuWHy|gj`b}w(kd`;3 zLb}7sk7?5RCC4+#RV!Ih$tqhBT;Re=DK81@GimY>8+4N!a?IPKu6M^V?RUUD77lkuz*C=wtbT||wki^tkDl&Shrxg|2NX$BG zFgIocqAl$J-7Q7zXA$braI+R!InzBJ-Bfsk_A`$Zv=^ViH)7C2$!dq&JiD(V2QqX7 zbTDIxqyMnxgNeoQv?e$o&6lko3BGBoAdv3ETA36Fum9)IXRGY4G3@`Dq80ei_l%*? zS4_;8(*f%UXF;zh<>PY+1lW$$Qt@GSme-;YMl@Gi*d`m|3`&8;`P9lxA|FFvu_Ym? z+-u{L+OUz+3q`l!b$ACuNRjAAQlXiBH>ls-kmO*IpBhPTi`E_~1v$_(;aM}{=r_)E zdRcZH^uhhgVrY8G~S-NMXPNN zm>{81!`B%W_U|F}6f{^y^D8&3*(Tu8And;2j_jbOvpRvnBL35#e!hFOpz;GD=dYOl zDmu))es03#vNZY6@bIa`wVUy+Gvv?Zo&U6f~n0P=9*Y&0d zgXRT_KKgV~?YF>9Y%BU7KHt_nv>4=+f@YnQ*KY(d#0ncdYkn$SlxFi-%ECTdikjKt zVkJKikh6Qf4?;B7SehL0*^a<*3io#K=)vFP-^jgme-#17F?*b7ASX|iio^Tc;9AF! zgTAhL5j5MDYD@VStb(IZLkP2t`E*&*BSn(jM(Z2eqZIR*o>2vhjOs`+dtB)CEuG{_ zC>EvqNOx!=l*>(kImur~7Qbgp+v)?jTqXOndhbH}(&$y*f^-?(E|N;{Y1MSX zp%G1aGbSZvfb}{fiQXDjMowXu}4BB76*- zBo5&tv1tMnV$nDeQyOFtM{$Iix1X>Xg-sJOpFPHt@2lxjS7y~ccOldnubKYD$B!-w zu-sR%=|3U;Kwm>o;qT?AbXJ9`Z)(RkY=r`2rVIFxM}BF|>O>(@Yqg*>+$r|Q`!xi% zY@+e)f1-Phm+&5LVxoVD|MO?mqY0>7#P)$l|6G?;6v23!Pp_Wm?EMSFTXEqSULThx zgacry1lA2_BI{x6i_$|qRt~+0sh(qHtlvyCwt&F-4#C9CvUNI*8EQb?ukSbpyjBmovTv7 z4UtvD9exEDc+D3mFF2eS2$J&Xp$&~sP&B6K`5C`f>N0{StwZ`)WuC(%y1dnS`~N_87^F@nf$DI4!`Kq!d@wgEYWs%9&iUt844<= z&q>TxFGlj8NHg~MmhB$>Zx(bTyNaojtx*>7orY8QffH=;Ox&6uJ$_3Xw29k6d8@@F zk@=8d;o>*!?=%So888Gp$tn}2$vlpZr2dmu1*xzL)n^mNNAvIYiS{ zn7zTcEEst$+SIK>s)u^uk5JPFG0f$Hlgh#}uRhzRGs*}T8fYsfvXSHZ)2(gE5pd#F zE#oX_-PXHB1z>AOwRKv*%Gg(|>chSrvaK||{&^ckWl3Y)dsu5Ih!1$+8~BK4j*Bri z2Ry%CWPkfp@_XkmX^QRm1U@wOA8Si18YN^?mKKtHd?Wf85A^ltn4FDS+RVg^z?DN| zUFgl9PaWDw<8bTnHzhA3;)F1^#xe#h#3-0$iD_%d#F5^oyc;E@=MvY%sf&f)u3w?* z#P{(xD$!!fr{M{^TP)Q)ExGjzO_`a}apJFkJP)F^YNQD;*`L2a%RD9gUHMu>Q8a{V zy*C{-mY@2wX|pV(c<)W6S$}84h#6MWE)LVVo&)#w#TVkQTpxl-A!o`tY(n-8MNcoK zSN25G=r5#x9IY)f@3bPvyo?I|w+F;TB8(khTAYdt>HVi$4<^4-xPpLo>>+X(eH^_X zo;sQib8(n`m^SkZBn2v2BjP+XyZ<5TDx%qx$AqegM}IR7SY-WR0$+y2W)zTqE?4|U;vUr+ZdNnj`|@g-uU_&=PsaZY$( zADaNp`UEUF%ya#zG64niG42r?Bp$kd_|3rk9uo0tVa$UCv_q21o!yX!#+;zr>?r$IXs;t7I_a|}|BIV7vcVNp- zME_)?gT@~Ywc7@*x7MSo*7k(X;`TQmr6SQDq`}&ViB<#=55{w35fUIt_L*^{=2_Bb z8`;#MpKXTr(!36DKeM%kJ`}(WzAK2(J!*@KmVhsePc$``VIfL;LFm}$%YPytFGHv; zIpk>rAdZ!ouS+5jEl8qJ1-ICm_FgAZy?QXgo3d8BD+9J|mN0Irijx)DmZjNx;lyM3 zWjyjI7iMsni(i`piXE1UPZ*GcasJAFN}*1{BhHsUH^ou`6Pz`3P^|a{_pe$&W%O8n zy!}5ts|~j|X9h=ICw0rL?)?PpSb6u{z^@C8R zEUobH5K9Y7({${>u^D4%%+X%@O(3~#K1lviS?cmw@f4pQ4Kx~!YrUT|t>fDhC>D}8Bf_CeEl1;z zR<{0hO(*Dw^$oY+)vdqm;wW{E10c&}Kl3-^p$oE>lSrcTkv2YH3N^IE>ECK^^(98+gG`t+=8K%B(xG z5mOm^y}UI;Q&s4|5ne&&{mQ3^c_E@{OJgkq{txTkSz@g<|1$@?`XT4gLho>L%T-|@H#_a-IU3JaM_nH(S_#9oWmV+M+YrA zDox^_?1}O5*$fs;;S&X1$IpKwM`dpZL|g0f_Tl{2XjxBLNtE`q>_>-vq#(AlXXPl1 z0(Jb6Dg;@5l;Q2lP-YUrA0$-}&?yZKe1`oZaTMDcKWfjO`tG_lS(JX(LAH$(`j4^7 zPb6)2tbKc#?o+Ts*&kJ3ymj>Bub5eCBl6f2dClForM0)8!=roZY$8_QErT!WRt$)K zOhhdg=Z=Hr2zQo{-aZ7|6Vu#&N=|HCTCw_?SPTl z&v5agmRB(Fp>3)@ndOB)6mj|H&=u7K*JMc`1DW~pgC2yT zBO7DrZL`cG_Xwh%#kxy7jV{MMI$$mH9i+$f_k}!K;H@?%@t#{cXknIejUTPyA_5?& zAwsWPpBjEFzPC<_aZ7>xUz}wwuAN&(%ZcFu)>?$Vv9pY2;xlqzEZ75Q`q3VPbc623 zv1T5vA#v%YEN| z2ZQwI7V}^JvsBu#y^_db^2;|C!(=L0T>R_zB&)0nP=>p#-cBvAO?y{qKB)LHh^e0k ztg#)=@d5NAdtsmi)8RbTfz6lqaj9sTS<4mwUGqSi9-wXmgkZ?vOYe6nnxZEMKWp4K z#2f+qt$zR*dPIn-lgIDpK}clReTsG?yjvBYVdl~Rz?IHgv<44{>&81(s^>Q+$pWhl zuxJRWL}YGhUh=0z#B7C3n9iq%O=(x`X*-Cfh;)L+D^$=gdJeR#)G%v17((g;p43FE zQ3FmCanYwV=0DxWG%DuB7i|k+3mZ?Tb0kM2YdiAf0}yW=VegBHnBl2^8zRa(u0}-V z9=fMeB;uCyKV2A_N6H((z47mS5Amqn_vON#?D->@2 zs(&}H(`lLQ!HuM>Pf?rF40n4_=Lh|Wv{5>pq_7^$jdJ`P&|}g|yDj?3aUioBc^ z??@=qF^K8L&?YC0|3>gR$ubD1c*B0~w4U=fJnYCIC62#^ql+(p0w+uV^nnGpYTA|t zkj5k5>C?JA8|EOwsTRZ+0dJe8G#KNruf4kKIy~p{R}LRZ?VJrJx&PMo-qwiqyZx}z z-STXXYrHP)+yEsJKu%_ES;*IMf#&B_JB3wxQf}}q1YsR;DdY$mi|4lL$S>Z-!g3`X z>%HnFM<$3ClHa&<>ti^j8)Dc9nDeb2kUhEbk#)nC*9pI-oib)ThOi-hw41Z<@o-V* ze0d)Vcr9E_XRHi#9~9C3dDq71(=7g6N{Pu{#HzDY>nSGcL=Fd&8pOwev7yNYH_QKr z=XV9wd0})98X)D#_)R!`P0UY}rKPRSja4=3*&(;UZem44G@c#=4>)FA*5aDvizDAb zddD9=Z~K!$j4Er|?%>$e`vROq0f_xbk<%}fX=sV47tFxx;|UM>)hG#gxx}c#X-iF=J`YC!ApiWb zIAEr<)&eG%czJFuI0E-QM4wC@slW|G04L%KH;Fc=>hgGY_g zfeVvEf34#UpEr(+agn1zg=K-~K1P)lW1PMmcj_uD3v29d7yD1UgZ#B*N4$}a??&TF z{9Kr!y`R5jmRtKxw#8wgO&gQYKbt>k_gs~tOBnikF@!0&*Ng}LCJJQ`)g=V|swxf% zaH%%_jyLB?X#2*+02D&V?U~e1ErX)L=7}{SyP$unPafp@$8uwY@z9W$Aig`1-R#$^ zBtT5mo_UqWbw`WyMp=Or8rTEkt+2(X=^D@d>d}`;b0R4GJ4%`lBE<)jOodY2xE;%Q zdp_*s*(mS$a#cFEPCq5NIqV1Iv9i76;4DC~pLYBp#mUM!F%%P>PD>m6J%n!V&LvM> z|3~rd4AVWfPlkFPLrGDBqL~{oOiEXJD49V?LBTBDKftfcQ3(~C+MAgxMN-Z z70~*(+d=H}R{yz7k9v}lJ01wye<=7n69HDnLUb*>cLYa6c1r_P$dPA8>x0||I%eAB^?-P07cqY z7#HWFLUkWTB=2diW!yNJ%@#)@~?f|M797E|>sT>pB?!xXnaxw6Cgop?#vj$5uGEjs*O2AdK>B%$dlx+GhE;#JKJ_-89tw_G+fCu^@Xe3*D?^ zS*m3Iu7{uD&l?X2vX(sp&4v7%xT+FZg~g?4 z(y`UP(G{CWwIa4(@*=jKH@clCcmOT@w*;{C@!5^EliPr!2RtY+qXgRAfAm^x5$!E9 z+D_49e|#~+zV@ge90(_sJJkvI9GBxx#D3AVal@u0yZB zNuJ?yVF>t`9K&)gNaAwh@PW(77~<9-Fm}ZL;TQ{WVu?c@jhBv~ag2Tb%uxH*aesz= z*)F)&k87-=#7y!r+H;h}X0)T|n0@bH#c#Ls3{&Xp`OO&T(OkpLY8q5%Dq)Kj_A;T( z`ull;wd%FUs-$cxq`Im8B+fbKJD=;A%A`%BGd5)s$b}pcsD|~qLq%+U);|A6=XPyx z0d}^5*vq(>H7>TUOl|h89l%!l;_#*bE1bWzg99)VpTv+Frx%4CooUpv_=QKRs{*kH z<;*xk8?Gz6P)552*Mu4AAk5j&BW_rbS^n+tEqMasOn7O$Y462_DgJi8Qa`h6>Y-7J*AO1w~v}G z#f=-&t?PK@EeFH|imkPn1C7a>^oPe}jI-YAXJ7aqZ?P|a-^IR5UERKmiEgXew12@a z>`&qKB5A2|$EHME9Ghp4uDYv&kH4rD%(SfaZ0;qA-@qz$lGt|oJLqf`*7cP&^VTci z49OQ>y<70`04k|BM9aIG+-6k)<4IohSj8FMdnAVUD@=~>#B$N0Xx`}w1snP+0kF}p zfj$H@L|R9PdmFv6#mf*J6!)o*oQnX7;(x7%-81?Ox9yu^vLlu=kiu2-=icKdgc zd%wXslE+}Z|12H&`sLAf9`#OWhs;?yelo<>Vqku-^Mp75%P4?%!Qk81doDE>a?at> z{8_z~T{33qAMWJ7rU%NF`OUAgYFFTtFW-a!BmDJ5!#RE-l~+USx(uJ{HOTy_EQMh6 z793f2BkYYm_Aa*bfOL!k;;%=PTJlHoJ@4A#i?r~9zR*%1y4tPwT{fEH*5rofSdGg>6ob0e*|PCK4VR968=d)5QK zt0jb9nbkypx>X(R)6ou&evy2?-1DNO)><{+uE>!mSf0b3r$X∈nI(%8}vYb?6bCOWvn*(ve|< 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
+ + + +
+ + + diff --git a/examples/features/federation/federated-address-downstream/src/main/resources/activemq/server1/broker.xml b/examples/features/federation/federated-address-downstream/src/main/resources/activemq/server1/broker.xml new file mode 100644 index 0000000000..0bc2579fb7 --- /dev/null +++ b/examples/features/federation/federated-address-downstream/src/main/resources/activemq/server1/broker.xml @@ -0,0 +1,100 @@ + + + + + + eu-east-1-master + + target/server1/data/messaging/bindings + + target/server1/data/messaging/journal + + target/server1/data/messaging/largemessages + + target/server1/data/messaging/paging + + + + tcp://localhost:61617 + tcp://localhost:61616 + tcp://localhost:61617 + tcp://localhost:61618 + + + + + tcp://localhost:61617 + + + + + + + + 1000 + + eu-west-1-connector + + + netty-connector + + + 1000 + + us-central-1-connector + + + netty-connector + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + +
+ + + diff --git a/examples/features/federation/federated-address-downstream/src/main/resources/activemq/server2/broker.xml b/examples/features/federation/federated-address-downstream/src/main/resources/activemq/server2/broker.xml new file mode 100644 index 0000000000..a80ea60b9f --- /dev/null +++ b/examples/features/federation/federated-address-downstream/src/main/resources/activemq/server2/broker.xml @@ -0,0 +1,100 @@ + + + + + + us-central-1-master + + target/server2/data/messaging/bindings + + target/server2/data/messaging/journal + + target/server2/data/messaging/largemessages + + target/server2/data/messaging/paging + + + + tcp://localhost:61618 + tcp://localhost:61616 + tcp://localhost:61617 + tcp://localhost:61618 + + + + + tcp://localhost:61618 + + + + + + + + + 1000 + + eu-east-1-connector + + + netty-connector + + + 1000 + + eu-west-1-connector + + + netty-connector + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + +
+ + + diff --git a/examples/features/federation/federated-queue-downstream-upstream/eu-west-east-us-central.png b/examples/features/federation/federated-queue-downstream-upstream/eu-west-east-us-central.png new file mode 100644 index 0000000000000000000000000000000000000000..0ba844733e6107026271a61c23c6dd5b93148219 GIT binary patch literal 226275 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∈nI(%8}vYb?6bCOWvn*(ve|< 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
+ + + +
+ + + diff --git a/examples/features/federation/federated-queue-downstream-upstream/src/main/resources/activemq/server1/broker.xml b/examples/features/federation/federated-queue-downstream-upstream/src/main/resources/activemq/server1/broker.xml new file mode 100644 index 0000000000..1e9a497713 --- /dev/null +++ b/examples/features/federation/federated-queue-downstream-upstream/src/main/resources/activemq/server1/broker.xml @@ -0,0 +1,100 @@ + + + + + + eu-east-1-master + + target/server1/data/messaging/bindings + + target/server1/data/messaging/journal + + target/server1/data/messaging/largemessages + + target/server1/data/messaging/paging + + + + tcp://localhost:61617 + tcp://localhost:61617 + tcp://localhost:61618 + + + + + tcp://localhost:61617 + + + + + + + + 1000 + true + + us-central-1-connector + + + + + 1000 + true + + us-central-1-connector + + + netty-connector + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + +
+ + + diff --git a/examples/features/federation/federated-queue-downstream-upstream/src/main/resources/activemq/server2/broker.xml b/examples/features/federation/federated-queue-downstream-upstream/src/main/resources/activemq/server2/broker.xml new file mode 100644 index 0000000000..f674e9f329 --- /dev/null +++ b/examples/features/federation/federated-queue-downstream-upstream/src/main/resources/activemq/server2/broker.xml @@ -0,0 +1,73 @@ + + + + + + us-central-1-master + + target/server2/data/messaging/bindings + + target/server2/data/messaging/journal + + target/server2/data/messaging/largemessages + + target/server2/data/messaging/paging + + + + tcp://localhost:61618 + tcp://localhost:61616 + tcp://localhost:61617 + tcp://localhost:61618 + + + + + tcp://localhost:61618 + + + + + + + + + + + + + + + + + + + + + +
+ + + +
+ + + diff --git a/examples/features/federation/federated-queue-downstream/eu-west-east-us-central.png b/examples/features/federation/federated-queue-downstream/eu-west-east-us-central.png new file mode 100644 index 0000000000000000000000000000000000000000..0ba844733e6107026271a61c23c6dd5b93148219 GIT binary patch literal 226275 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∈nI(%8}vYb?6bCOWvn*(ve|< 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
+ + + +
+ + + diff --git a/examples/features/federation/federated-queue-downstream/src/main/resources/activemq/server1/broker.xml b/examples/features/federation/federated-queue-downstream/src/main/resources/activemq/server1/broker.xml new file mode 100644 index 0000000000..fd862ccf74 --- /dev/null +++ b/examples/features/federation/federated-queue-downstream/src/main/resources/activemq/server1/broker.xml @@ -0,0 +1,100 @@ + + + + + + eu-east-1-master + + target/server1/data/messaging/bindings + + target/server1/data/messaging/journal + + target/server1/data/messaging/largemessages + + target/server1/data/messaging/paging + + + + tcp://localhost:61617 + tcp://localhost:61616 + tcp://localhost:61617 + tcp://localhost:61618 + + + + + tcp://localhost:61617 + + + + + + + + 1000 + + eu-west-1-connector + + + netty-connector + + + 1000 + + us-central-1-connector + + + netty-connector + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + +
+ + + diff --git a/examples/features/federation/federated-queue-downstream/src/main/resources/activemq/server2/broker.xml b/examples/features/federation/federated-queue-downstream/src/main/resources/activemq/server2/broker.xml new file mode 100644 index 0000000000..be8a8f1350 --- /dev/null +++ b/examples/features/federation/federated-queue-downstream/src/main/resources/activemq/server2/broker.xml @@ -0,0 +1,100 @@ + + + + + + us-central-1-master + + target/server2/data/messaging/bindings + + target/server2/data/messaging/journal + + target/server2/data/messaging/largemessages + + target/server2/data/messaging/paging + + + + tcp://localhost:61618 + tcp://localhost:61616 + tcp://localhost:61617 + tcp://localhost:61618 + + + + + tcp://localhost:61618 + + + + + + + + + 1000 + + eu-east-1-connector + + + netty-connector + + + 1000 + + eu-west-1-connector + + + netty-connector + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + +
+ + + diff --git a/examples/features/federation/federated-queue/src/main/java/org/apache/activemq/artemis/jms/example/FederatedQueueExample.java b/examples/features/federation/federated-queue/src/main/java/org/apache/activemq/artemis/jms/example/FederatedQueueExample.java index 48aaa8c0a3..e594b96151 100644 --- a/examples/features/federation/federated-queue/src/main/java/org/apache/activemq/artemis/jms/example/FederatedQueueExample.java +++ b/examples/features/federation/federated-queue/src/main/java/org/apache/activemq/artemis/jms/example/FederatedQueueExample.java @@ -23,6 +23,7 @@ import javax.jms.MessageProducer; import javax.jms.Queue; import javax.jms.Session; import javax.jms.TextMessage; + import org.apache.activemq.artemis.api.jms.ActiveMQJMSClient; import org.apache.activemq.artemis.jms.client.ActiveMQConnectionFactory; diff --git a/examples/features/federation/pom.xml b/examples/features/federation/pom.xml index 30a89d49e3..25e02809f9 100644 --- a/examples/features/federation/pom.xml +++ b/examples/features/federation/pom.xml @@ -48,14 +48,21 @@ under the License. examples federated-queue + federated-queue-downstream + federated-queue-downstream-upstream federated-address + federated-address-downstream + federated-address-downstream-upstream release federated-queue + federated-queue-downstream + federated-queue-downstream-upstream federated-address + federated-address-downstream-upstream diff --git a/tests/integration-tests/src/test/java/org/apache/activemq/artemis/tests/integration/federation/FederatedAddressTest.java b/tests/integration-tests/src/test/java/org/apache/activemq/artemis/tests/integration/federation/FederatedAddressTest.java index bdd12e5095..c0f9e1c6df 100644 --- a/tests/integration-tests/src/test/java/org/apache/activemq/artemis/tests/integration/federation/FederatedAddressTest.java +++ b/tests/integration-tests/src/test/java/org/apache/activemq/artemis/tests/integration/federation/FederatedAddressTest.java @@ -16,7 +16,6 @@ */ package org.apache.activemq.artemis.tests.integration.federation; -import java.util.Collections; import javax.jms.Connection; import javax.jms.ConnectionFactory; import javax.jms.JMSException; @@ -25,10 +24,17 @@ import javax.jms.MessageConsumer; import javax.jms.MessageProducer; import javax.jms.Session; import javax.jms.Topic; +import java.util.Collections; + import org.apache.activemq.artemis.api.core.SimpleString; +import org.apache.activemq.artemis.api.core.TransportConfiguration; import org.apache.activemq.artemis.core.config.FederationConfiguration; -import org.apache.activemq.artemis.core.config.federation.FederationUpstreamConfiguration; +import org.apache.activemq.artemis.core.config.TransformerConfiguration; import org.apache.activemq.artemis.core.config.federation.FederationAddressPolicyConfiguration; +import org.apache.activemq.artemis.core.config.federation.FederationDownstreamConfiguration; +import org.apache.activemq.artemis.core.config.federation.FederationTransformerConfiguration; +import org.apache.activemq.artemis.core.config.federation.FederationUpstreamConfiguration; +import org.apache.activemq.artemis.core.server.transformer.Transformer; import org.apache.activemq.artemis.jms.client.ActiveMQConnectionFactory; import org.apache.activemq.artemis.tests.util.Wait; import org.junit.Before; @@ -46,25 +52,133 @@ public class FederatedAddressTest extends FederatedTestBase { super.setUp(); } - protected ConnectionFactory getCF(int i) throws Exception { return new ActiveMQConnectionFactory("vm://" + i); } - - @Test - public void testFederatedAddressReplication() throws Exception { + public void testDownstreamFederatedAddressReplication() throws Exception { String address = getName(); - FederationConfiguration federationConfiguration = createFederationConfiguration("server1", address); + FederationConfiguration federationConfiguration = createDownstreamFederationConfiguration("server1", address, + getServer(0).getConfiguration().getTransportConfigurations("server0")[0]); getServer(0).getConfiguration().getFederationConfigurations().add(federationConfiguration); getServer(0).getFederationManager().deploy(); - FederationConfiguration federationConfiguration2 = createFederationConfiguration("server0", address); + FederationConfiguration federationConfiguration2 = createDownstreamFederationConfiguration("server0", address, + getServer(1).getConfiguration().getTransportConfigurations("server1")[0]); getServer(1).getConfiguration().getFederationConfigurations().add(federationConfiguration2); getServer(1).getFederationManager().deploy(); + testFederatedAddressReplication(address); + } + + @Test + public void testDownstreamFederatedAddressReplicationRef() throws Exception { + String address = getName(); + + FederationConfiguration federationConfiguration = createDownstreamFederationConfiguration("server1", address, + "server0"); + getServer(0).getConfiguration().getFederationConfigurations().add(federationConfiguration); + getServer(0).getFederationManager().deploy(); + + FederationConfiguration federationConfiguration2 = createDownstreamFederationConfiguration("server0", address, + "server1"); + getServer(1).getConfiguration().getFederationConfigurations().add(federationConfiguration2); + getServer(1).getFederationManager().deploy(); + + testFederatedAddressReplication(address); + } + + @Test + public void testDownstreamFederatedAddressReplicationRefOneWay() throws Exception { + String address = getName(); + + FederationConfiguration federationConfiguration2 = createDownstreamFederationConfiguration("server0", address, + "server1"); + getServer(1).getConfiguration().getFederationConfigurations().add(federationConfiguration2); + getServer(1).getFederationManager().deploy(); + + testFederatedAddressReplication(address); + } + + @Test + public void testUpstreamFederatedAddressReplication() throws Exception { + String address = getName(); + + FederationConfiguration federationConfiguration = createUpstreamFederationConfiguration("server1", address); + getServer(0).getConfiguration().getFederationConfigurations().add(federationConfiguration); + getServer(0).getFederationManager().deploy(); + + FederationConfiguration federationConfiguration2 = createUpstreamFederationConfiguration("server0", address); + getServer(1).getConfiguration().getFederationConfigurations().add(federationConfiguration2); + getServer(1).getFederationManager().deploy(); + + testFederatedAddressReplication(address); + } + + @Test + public void testDownstreamFederatedAddressReplicationRefOneWayTransformer() throws Exception { + String address = getName(); + + FederationConfiguration federationConfiguration2 = createDownstreamFederationConfiguration("server0", address, "server1"); + addTransformerConfiguration(federationConfiguration2, address); + getServer(1).getConfiguration().getFederationConfigurations().add(federationConfiguration2); + getServer(1).getFederationManager().deploy(); + + verifyTransformer(address); + } + + private void verifyTransformer(String address) throws Exception { + ConnectionFactory cf1 = getCF(1); + ConnectionFactory cf0 = getCF(0); + try (Connection connection1 = cf1.createConnection(); Connection connection0 = cf0.createConnection()) { + connection1.start(); + connection0.start(); + + Session session1 = connection1.createSession(); + Topic topic1 = session1.createTopic(address); + MessageProducer producer1 = session1.createProducer(topic1); + + Session session0 = connection0.createSession(); + Topic topic0 = session0.createTopic(address); + MessageConsumer consumer0 = session0.createConsumer(topic0); + + assertTrue(Wait.waitFor(() -> getServer(1).getPostOffice().getBindingsForAddress( + SimpleString.toSimpleString(address)).getBindings().size() == 1)); + + producer1.send(session1.createTextMessage("hello")); + Message message = consumer0.receive(1000); + assertNotNull(message); + assertEquals(message.getBooleanProperty(FederatedQueueTest.TestTransformer.TEST_PROPERTY), true); + } + } + + @Test + public void testUpstreamFederatedAddressReplicationOneWay() throws Exception { + String address = getName(); + + FederationConfiguration federationConfiguration = createUpstreamFederationConfiguration("server1", address); + getServer(0).getConfiguration().getFederationConfigurations().add(federationConfiguration); + getServer(0).getFederationManager().deploy(); + + testFederatedAddressReplication(address); + } + + @Test + public void testUpstreamFederatedAddressReplicationOneWayTransformer() throws Exception { + String address = getName(); + + FederationConfiguration federationConfiguration = createUpstreamFederationConfiguration("server1", address); + addTransformerConfiguration(federationConfiguration, address); + getServer(0).getConfiguration().getFederationConfigurations().add(federationConfiguration); + getServer(0).getFederationManager().deploy(); + + verifyTransformer(address); + } + + private void testFederatedAddressReplication(String address) throws Exception { + ConnectionFactory cf1 = getCF(1); ConnectionFactory cf0 = getCF(0); try (Connection connection1 = cf1.createConnection(); Connection connection0 = cf0.createConnection()) { @@ -81,7 +195,7 @@ public class FederatedAddressTest extends FederatedTestBase { Topic topic0 = session0.createTopic(address); MessageConsumer consumer0 = session0.createConsumer(topic0); - Wait.waitFor(() -> getServer(1).getPostOffice().getBindingsForAddress(SimpleString.toSimpleString(address)).getBindings().size() == 1); + assertTrue(Wait.waitFor(() -> getServer(1).getPostOffice().getBindingsForAddress(SimpleString.toSimpleString(address)).getBindings().size() == 1)); producer.send(session1.createTextMessage("hello")); @@ -143,7 +257,7 @@ public class FederatedAddressTest extends FederatedTestBase { assertNull(consumer0.receive(100)); - FederationConfiguration federationConfiguration = createFederationConfiguration("server1", address); + FederationConfiguration federationConfiguration = createUpstreamFederationConfiguration("server1", address); getServer(0).getConfiguration().getFederationConfigurations().add(federationConfiguration); getServer(0).getFederationManager().deploy(); @@ -161,7 +275,7 @@ public class FederatedAddressTest extends FederatedTestBase { public void testFederatedAddressRemoteBrokerRestart() throws Exception { String address = getName(); - FederationConfiguration federationConfiguration = createFederationConfiguration("server1", address); + FederationConfiguration federationConfiguration = createUpstreamFederationConfiguration("server1", address); getServer(0).getConfiguration().getFederationConfigurations().add(federationConfiguration); getServer(0).getFederationManager().deploy(); @@ -219,7 +333,7 @@ public class FederatedAddressTest extends FederatedTestBase { public void testFederatedAddressLocalBrokerRestart() throws Exception { String address = getName(); - FederationConfiguration federationConfiguration = createFederationConfiguration("server1", address); + FederationConfiguration federationConfiguration = createUpstreamFederationConfiguration("server1", address); getServer(0).getConfiguration().getFederationConfigurations().add(federationConfiguration); getServer(0).getFederationManager().deploy(); @@ -274,27 +388,125 @@ public class FederatedAddressTest extends FederatedTestBase { } } + @Test + public void testFederatedAddressChainOfBrokers() throws Exception { + String address = getName(); - private FederationConfiguration createFederationConfiguration(String connector, String address) { + //Set queue up on all three brokers +// for (int i = 0; i < 3; i++) { +// getServer(i).createQueue(SimpleString.toSimpleString(queueName), RoutingType.ANYCAST, SimpleString.toSimpleString(queueName), null, true, false); +// } + + //Connect broker 0 (consumer will be here at end of chain) to broker 1 + FederationConfiguration federationConfiguration0 = createUpstreamFederationConfiguration("server1", address, 2); + getServer(0).getConfiguration().getFederationConfigurations().add(federationConfiguration0); + getServer(0).getFederationManager().deploy(); + + //Connect broker 1 (middle of chain) to broker 2 + FederationConfiguration federationConfiguration1 = createUpstreamFederationConfiguration("server2", address, 2); + getServer(1).getConfiguration().getFederationConfigurations().add(federationConfiguration1); + getServer(1).getFederationManager().deploy(); + //Broker 2 we dont setup any federation as he is the upstream (head of the chain) + + //Now the test. + + + ConnectionFactory cf2 = getCF(2); + ConnectionFactory cf0 = getCF(0); + try (Connection connection2 = cf2.createConnection(); Connection connection0 = cf0.createConnection()) { + connection0.start(); + Session session0 = connection0.createSession(); + Topic topic0 = session0.createTopic(address); + + connection2.start(); + Session session2 = connection2.createSession(); + Topic topic2 = session2.createTopic(address); + + MessageProducer producer2 = session2.createProducer(topic2); + MessageConsumer consumer0 = session0.createConsumer(topic0); + + assertTrue(Wait.waitFor(() -> getServer(1).getPostOffice().getBindingsForAddress(SimpleString.toSimpleString(address)).getBindings().size() == 1)); + assertTrue(Wait.waitFor(() -> getServer(2).getPostOffice().getBindingsForAddress(SimpleString.toSimpleString(address)).getBindings().size() == 1)); + + //Test producers being on broker 2 and consumer on broker 0, with broker 2 being in the middle of the chain. + producer2.send(session2.createTextMessage("hello")); + assertNotNull(consumer0.receive(1000)); + } + } + + private FederationConfiguration createFederationConfiguration(String address, int hops) { + FederationAddressPolicyConfiguration addressPolicyConfiguration = new FederationAddressPolicyConfiguration(); + addressPolicyConfiguration.setName( "AddressPolicy" + address); + addressPolicyConfiguration.addInclude(new FederationAddressPolicyConfiguration.Matcher().setAddressMatch(address)); + addressPolicyConfiguration.setMaxHops(hops); + + FederationConfiguration federationConfiguration = new FederationConfiguration(); + federationConfiguration.setName("default"); + federationConfiguration.addFederationPolicy(addressPolicyConfiguration); + + return federationConfiguration; + } + + private FederationConfiguration createUpstreamFederationConfiguration(String connector, String address, int hops) { FederationUpstreamConfiguration upstreamConfiguration = new FederationUpstreamConfiguration(); upstreamConfiguration.setName(connector); upstreamConfiguration.getConnectionConfiguration().setStaticConnectors(Collections.singletonList(connector)); upstreamConfiguration.getConnectionConfiguration().setCircuitBreakerTimeout(-1); upstreamConfiguration.addPolicyRef("AddressPolicy" + address); - - FederationAddressPolicyConfiguration addressPolicyConfiguration = new FederationAddressPolicyConfiguration(); - addressPolicyConfiguration.setName( "AddressPolicy" + address); - addressPolicyConfiguration.addInclude(new FederationAddressPolicyConfiguration.Matcher().setAddressMatch(address)); - addressPolicyConfiguration.setMaxHops(1); - - FederationConfiguration federationConfiguration = new FederationConfiguration(); - federationConfiguration.setName("default"); + FederationConfiguration federationConfiguration = createFederationConfiguration(address, hops); federationConfiguration.addUpstreamConfiguration(upstreamConfiguration); - federationConfiguration.addFederationPolicy(addressPolicyConfiguration); return federationConfiguration; } + private FederationConfiguration createUpstreamFederationConfiguration(String connector, String address) { + return createUpstreamFederationConfiguration(connector, address, 1); + } + + private FederationConfiguration createDownstreamFederationConfiguration(String connector, String address, TransportConfiguration transportConfiguration) { + return createDownstreamFederationConfiguration(connector, address, transportConfiguration, 1); + } + + private FederationConfiguration createDownstreamFederationConfiguration(String connector, String address, TransportConfiguration transportConfiguration, + int hops) { + FederationDownstreamConfiguration downstreamConfiguration = new FederationDownstreamConfiguration(); + downstreamConfiguration.setName(connector); + downstreamConfiguration.getConnectionConfiguration().setStaticConnectors(Collections.singletonList(connector)); + downstreamConfiguration.getConnectionConfiguration().setCircuitBreakerTimeout(-1); + downstreamConfiguration.addPolicyRef("AddressPolicy" + address); + downstreamConfiguration.setUpstreamConfiguration(transportConfiguration); + + FederationConfiguration federationConfiguration = createFederationConfiguration(address, hops); + federationConfiguration.addDownstreamConfiguration(downstreamConfiguration); + + return federationConfiguration; + } + + private FederationConfiguration createDownstreamFederationConfiguration(String connector, String address, String transportConfigurationRef, + int hops) { + FederationDownstreamConfiguration downstreamConfiguration = new FederationDownstreamConfiguration(); + downstreamConfiguration.setName(connector); + downstreamConfiguration.getConnectionConfiguration().setStaticConnectors(Collections.singletonList(connector)); + downstreamConfiguration.getConnectionConfiguration().setCircuitBreakerTimeout(-1); + downstreamConfiguration.addPolicyRef("AddressPolicy" + address); + downstreamConfiguration.setUpstreamConfigurationRef(transportConfigurationRef); + + FederationConfiguration federationConfiguration = createFederationConfiguration(address, hops); + federationConfiguration.addDownstreamConfiguration(downstreamConfiguration); + + return federationConfiguration; + } + + private FederationConfiguration createDownstreamFederationConfiguration(String connector, String address, String transportConfigurationRef) { + return createDownstreamFederationConfiguration(connector, address, transportConfigurationRef, 1); + } + + private void addTransformerConfiguration(final FederationConfiguration federationConfiguration, final String address) { + federationConfiguration.addTransformerConfiguration( + new FederationTransformerConfiguration("transformer", new TransformerConfiguration(TestTransformer.class.getName()))); + FederationAddressPolicyConfiguration policy = (FederationAddressPolicyConfiguration) federationConfiguration.getFederationPolicyMap().get("AddressPolicy" + address); + policy.setTransformerRef("transformer"); + } private Message createTextMessage(Session session1, String group) throws JMSException { Message message = session1.createTextMessage("hello"); @@ -302,5 +514,15 @@ public class FederatedAddressTest extends FederatedTestBase { return message; } + public static class TestTransformer implements Transformer { + + static String TEST_PROPERTY = "transformed"; + + @Override + public org.apache.activemq.artemis.api.core.Message transform(org.apache.activemq.artemis.api.core.Message message) { + message.putBooleanProperty(TEST_PROPERTY, true); + return message; + } + } } diff --git a/tests/integration-tests/src/test/java/org/apache/activemq/artemis/tests/integration/federation/FederatedQueueTest.java b/tests/integration-tests/src/test/java/org/apache/activemq/artemis/tests/integration/federation/FederatedQueueTest.java index 514778c1e0..871a8b1ed2 100644 --- a/tests/integration-tests/src/test/java/org/apache/activemq/artemis/tests/integration/federation/FederatedQueueTest.java +++ b/tests/integration-tests/src/test/java/org/apache/activemq/artemis/tests/integration/federation/FederatedQueueTest.java @@ -16,7 +16,6 @@ */ package org.apache.activemq.artemis.tests.integration.federation; -import java.util.Collections; import javax.jms.Connection; import javax.jms.ConnectionFactory; import javax.jms.JMSException; @@ -26,12 +25,18 @@ import javax.jms.MessageProducer; import javax.jms.Queue; import javax.jms.Session; import javax.jms.TextMessage; +import java.util.Collections; + import org.apache.activemq.artemis.api.core.RoutingType; import org.apache.activemq.artemis.api.core.SimpleString; -import org.apache.activemq.artemis.core.postoffice.QueueBinding; import org.apache.activemq.artemis.core.config.FederationConfiguration; +import org.apache.activemq.artemis.core.config.TransformerConfiguration; +import org.apache.activemq.artemis.core.config.federation.FederationDownstreamConfiguration; import org.apache.activemq.artemis.core.config.federation.FederationQueuePolicyConfiguration; +import org.apache.activemq.artemis.core.config.federation.FederationTransformerConfiguration; import org.apache.activemq.artemis.core.config.federation.FederationUpstreamConfiguration; +import org.apache.activemq.artemis.core.postoffice.QueueBinding; +import org.apache.activemq.artemis.core.server.transformer.Transformer; import org.apache.activemq.artemis.jms.client.ActiveMQConnectionFactory; import org.apache.activemq.artemis.tests.util.Wait; import org.junit.Before; @@ -54,16 +59,136 @@ public class FederatedQueueTest extends FederatedTestBase { return new ActiveMQConnectionFactory("vm://" + i); } - - @Test - public void testFederatedQueueRemoteConsume() throws Exception { + public void testFederatedQueueRemoteConsumeUpstream() throws Exception { String queueName = getName(); - FederationConfiguration federationConfiguration = createFederationConfiguration("server1", queueName); + FederationConfiguration federationConfiguration = createUpstreamFederationConfiguration("server1", queueName); getServer(0).getConfiguration().getFederationConfigurations().add(federationConfiguration); getServer(0).getFederationManager().deploy(); + testFederatedQueueRemoteConsume(queueName); + } + + @Test + public void testFederatedQueueRemoteConsumeUpstreamPriorityAdjustment() throws Exception { + String queueName = getName(); + + FederationConfiguration federationConfiguration = createUpstreamFederationConfiguration("server1", queueName); + FederationQueuePolicyConfiguration policy = (FederationQueuePolicyConfiguration) federationConfiguration.getFederationPolicyMap().get("QueuePolicy" + queueName); + //Favor federated broker over local consumers + policy.setPriorityAdjustment(1); + + getServer(0).getConfiguration().getFederationConfigurations().add(federationConfiguration); + getServer(0).getFederationManager().deploy(); + + testFederatedQueueRemoteConsumeUpstreamPriorityAdjustment(queueName); + } + + @Test + public void testFederatedQueueRemoteConsumeDownstreamPriorityAdjustment() throws Exception { + String queueName = getName(); + + FederationConfiguration federationConfiguration = createDownstreamFederationConfiguration("server0", queueName, "server1"); + FederationQueuePolicyConfiguration policy = (FederationQueuePolicyConfiguration) federationConfiguration.getFederationPolicyMap().get("QueuePolicy" + queueName); + //Favor federated broker over local consumers + policy.setPriorityAdjustment(1); + + getServer(1).getConfiguration().getFederationConfigurations().add(federationConfiguration); + getServer(1).getFederationManager().deploy(); + + testFederatedQueueRemoteConsumeUpstreamPriorityAdjustment(queueName); + } + + private void testFederatedQueueRemoteConsumeUpstreamPriorityAdjustment(final String queueName) throws Exception { + ConnectionFactory cf1 = getCF(1); + ConnectionFactory cf0 = getCF(0); + try (Connection connection1 = cf1.createConnection(); Connection connection0 = cf0.createConnection()) { + connection0.start(); + connection1.start(); + Session session0 = connection0.createSession(); + Session session1 = connection1.createSession(); + Queue queue0 = session0.createQueue(queueName); + Queue queue1 = session1.createQueue(queueName); + + MessageConsumer consumer0 = session0.createConsumer(queue0); + MessageConsumer consumer1 = session1.createConsumer(queue1); + + //Wait for local and federated consumer to be established on Server 1 + assertTrue(Wait.waitFor(() -> getServer(1).locateQueue(SimpleString.toSimpleString(queueName)).getConsumerCount() == 2, + 5000, 100)); + + MessageProducer producer1 = session1.createProducer(queue1); + producer1.send(session1.createTextMessage("hello")); + + //Consumer 0 should receive the message over consumer because of adjusted priority + //to favor the federated broker + assertNull(consumer1.receive(500)); + assertNotNull(consumer0.receive(1000)); + + consumer0.close(); + consumer1.close(); + } + } + + private void verifyTransformer(String queueName) throws Exception { + ConnectionFactory cf1 = getCF(1); + ConnectionFactory cf0 = getCF(0); + try (Connection connection1 = cf1.createConnection(); Connection connection0 = cf0.createConnection()) { + connection1.start(); + Session session1 = connection1.createSession(); + Queue queue1 = session1.createQueue(queueName); + MessageProducer producer1 = session1.createProducer(queue1); + producer1.send(session1.createTextMessage("hello")); + + connection0.start(); + Session session0 = connection0.createSession(); + Queue queue0 = session0.createQueue(queueName); + MessageConsumer consumer0 = session0.createConsumer(queue0); + + Message message = consumer0.receive(1000); + assertNotNull(message); + assertEquals(message.getBooleanProperty(TestTransformer.TEST_PROPERTY), true); + } + } + + @Test + public void testFederatedQueueRemoteConsumeUpstreamTransformer() throws Exception { + String queueName = getName(); + + FederationConfiguration federationConfiguration = createUpstreamFederationConfiguration("server1", queueName); + addTransformerConfiguration(federationConfiguration, queueName); + getServer(0).getConfiguration().getFederationConfigurations().add(federationConfiguration); + getServer(0).getFederationManager().deploy(); + + verifyTransformer(queueName); + } + + @Test + public void testFederatedQueueRemoteConsumeDownstream() throws Exception { + String queueName = getName(); + + FederationConfiguration federationConfiguration = createDownstreamFederationConfiguration("server0", queueName, "server1"); + getServer(1).getConfiguration().getFederationConfigurations().add(federationConfiguration); + getServer(1).getFederationManager().deploy(); + + testFederatedQueueRemoteConsume(queueName); + } + + @Test + public void testFederatedQueueRemoteConsumeDownstreamTransformer() throws Exception { + String queueName = getName(); + + FederationConfiguration federationConfiguration = createDownstreamFederationConfiguration("server0", queueName, "server1"); + addTransformerConfiguration(federationConfiguration, queueName); + getServer(1).getConfiguration().getFederationConfigurations().add(federationConfiguration); + getServer(1).getFederationManager().deploy(); + + verifyTransformer(queueName); + } + + private void testFederatedQueueRemoteConsume(final String queueName) throws Exception { + ConnectionFactory cf1 = getCF(1); ConnectionFactory cf0 = getCF(0); try (Connection connection1 = cf1.createConnection(); Connection connection0 = cf0.createConnection()) { @@ -130,7 +255,7 @@ public class FederatedQueueTest extends FederatedTestBase { assertNull(consumer0.receive(100)); - FederationConfiguration federationConfiguration = createFederationConfiguration("server1", queueName); + FederationConfiguration federationConfiguration = createUpstreamFederationConfiguration("server1", queueName); getServer(0).getConfiguration().getFederationConfigurations().add(federationConfiguration); getServer(0).getFederationManager().deploy(); @@ -141,20 +266,134 @@ public class FederatedQueueTest extends FederatedTestBase { } @Test - public void testFederatedQueueBiDirectional() throws Exception { + public void testFederatedQueueBiDirectionalUpstream() throws Exception { String queueName = getName(); //Set queue up on both brokers for (int i = 0; i < 2; i++) { getServer(i).createQueue(SimpleString.toSimpleString(queueName), RoutingType.ANYCAST, SimpleString.toSimpleString(queueName), null, true, false); } - FederationConfiguration federationConfiguration0 = createFederationConfiguration("server1", queueName); + FederationConfiguration federationConfiguration0 = createUpstreamFederationConfiguration("server1", queueName); getServer(0).getConfiguration().getFederationConfigurations().add(federationConfiguration0); getServer(0).getFederationManager().deploy(); - FederationConfiguration federationConfiguration1 = createFederationConfiguration("server0", queueName); + FederationConfiguration federationConfiguration1 = createUpstreamFederationConfiguration("server0", queueName); getServer(1).getConfiguration().getFederationConfigurations().add(federationConfiguration1); getServer(1).getFederationManager().deploy(); + testFederatedQueueBiDirectional(queueName, false); + } + + @Test + public void testFederatedQueueBiDirectionalDownstream() throws Exception { + String queueName = getName(); + //Set queue up on both brokers + for (int i = 0; i < 2; i++) { + getServer(i).createQueue(SimpleString.toSimpleString(queueName), RoutingType.ANYCAST, SimpleString.toSimpleString(queueName), null, true, false); + } + FederationConfiguration federationConfiguration0 = createDownstreamFederationConfiguration("server1", queueName, "server0"); + getServer(0).getConfiguration().getFederationConfigurations().add(federationConfiguration0); + getServer(0).getFederationManager().deploy(); + + FederationConfiguration federationConfiguration1 = createDownstreamFederationConfiguration("server0", queueName, "server1"); + getServer(1).getConfiguration().getFederationConfigurations().add(federationConfiguration1); + getServer(1).getFederationManager().deploy(); + + testFederatedQueueBiDirectional(queueName, false); + } + + @Test + public void testFederatedQueueBiDirectionalDownstreamUpstream() throws Exception { + String queueName = getName(); + //Set queue up on both brokers + for (int i = 0; i < 2; i++) { + getServer(i).createQueue(SimpleString.toSimpleString(queueName), RoutingType.ANYCAST, SimpleString.toSimpleString(queueName), null, true, false); + } + + FederationConfiguration federationConfiguration0 = createDownstreamFederationConfiguration("server1-downstream", + "server1", queueName, null, false, "server0"); + FederationUpstreamConfiguration upstreamConfig = createFederationUpstream("server1", queueName); + federationConfiguration0.addUpstreamConfiguration(upstreamConfig); + getServer(0).getConfiguration().getFederationConfigurations().add(federationConfiguration0); + getServer(0).getFederationManager().deploy(); + + testFederatedQueueBiDirectional(queueName, false); + } + + @Test + public void testFederatedQueueBiDirectionalDownstreamUpstreamSharedConnection() throws Exception { + String queueName = getName(); + //Set queue up on both brokers + for (int i = 0; i < 2; i++) { + getServer(i).createQueue(SimpleString.toSimpleString(queueName), RoutingType.ANYCAST, SimpleString.toSimpleString(queueName), null, true, false); + } + + FederationConfiguration federationConfiguration0 = createDownstreamFederationConfiguration("server1-downstream", + "server1", queueName, null, true, "server0"); + FederationUpstreamConfiguration upstreamConfig = createFederationUpstream("server1", queueName); + upstreamConfig.getConnectionConfiguration().setShareConnection(true); + federationConfiguration0.addUpstreamConfiguration(upstreamConfig); + getServer(0).getConfiguration().getFederationConfigurations().add(federationConfiguration0); + getServer(0).getFederationManager().deploy(); + + testFederatedQueueBiDirectional(queueName, true); + } + + @Test + public void testFederatedQueueShareUpstreamConnectionFalse() throws Exception { + String queueName = getName(); + //Set queue up on both brokers + for (int i = 0; i < 2; i++) { + getServer(i).createQueue(SimpleString.toSimpleString(queueName), RoutingType.ANYCAST, SimpleString.toSimpleString(queueName), null, true, false); + } + + FederationConfiguration federationConfiguration0 = createDownstreamFederationConfiguration("server1-downstream", + "server1", queueName, null, false, "server0"); + federationConfiguration0.addUpstreamConfiguration(createFederationUpstream("server1", queueName)); + getServer(0).getConfiguration().getFederationConfigurations().add(federationConfiguration0); + getServer(0).getFederationManager().deploy(); + + testFederatedQueueShareUpstreamConnection(queueName, 2, 3); + } + + @Test + public void testFederatedQueueShareUpstreamConnectionTrue() throws Exception { + String queueName = getName(); + //Set queue up on both brokers + for (int i = 0; i < 2; i++) { + getServer(i).createQueue(SimpleString.toSimpleString(queueName), RoutingType.ANYCAST, SimpleString.toSimpleString(queueName), null, true, false); + } + + FederationConfiguration federationConfiguration0 = createDownstreamFederationConfiguration("server1-downstream", + "server1", queueName, null, true, "server0"); + FederationUpstreamConfiguration upstreamConfiguration = createFederationUpstream("server1", queueName); + upstreamConfiguration.getConnectionConfiguration().setShareConnection(true); + federationConfiguration0.addUpstreamConfiguration(upstreamConfiguration); + getServer(0).getConfiguration().getFederationConfigurations().add(federationConfiguration0); + getServer(0).getFederationManager().deploy(); + + testFederatedQueueShareUpstreamConnection(queueName, 2, 2); + } + + private void testFederatedQueueShareUpstreamConnection(String queueName, int server0Connections, int server1Connections) throws Exception { + ConnectionFactory cf1 = getCF(1); + ConnectionFactory cf0 = getCF(0); + try (Connection connection1 = cf1.createConnection(); Connection connection0 = cf0.createConnection()) { + connection0.start(); + connection1.start(); + Session session0 = connection0.createSession(); + Session session1 = connection1.createSession(); + + MessageConsumer consumer0 = session0.createConsumer(session0.createQueue(queueName)); + MessageConsumer consumer1 = session1.createConsumer(session1.createQueue(queueName)); + + assertTrue(Wait.waitFor(() -> getServer(0).getConnectionCount() == server0Connections, 500, 100)); + assertTrue(Wait.waitFor(() -> getServer(1).getConnectionCount() == server1Connections, 500, 100)); + assertFalse(Wait.waitFor(() -> getServer(0).getConnectionCount() > server0Connections, 500, 100)); + assertFalse(Wait.waitFor(() -> getServer(1).getConnectionCount() > server1Connections, 500, 100)); + } + } + + private void testFederatedQueueBiDirectional(String queueName, boolean shared) throws Exception { ConnectionFactory cf1 = getCF(1); ConnectionFactory cf0 = getCF(0); try (Connection connection1 = cf1.createConnection(); Connection connection0 = cf0.createConnection()) { @@ -169,7 +408,6 @@ public class FederatedQueueTest extends FederatedTestBase { MessageProducer producer1 = session1.createProducer(queue1); MessageConsumer consumer0 = session0.createConsumer(queue0); - //Test producers being on broker 0 and broker 1 and consumer on broker 0. producer0.send(session1.createTextMessage("hello")); assertNotNull(consumer0.receive(1000)); @@ -183,13 +421,21 @@ public class FederatedQueueTest extends FederatedTestBase { assertFalse(Wait.waitFor(() -> getServer(1).locateQueue(SimpleString.toSimpleString(queueName)).getConsumerCount() > 1, 500, 100)); //Test consumer move from broker 0, to broker 1 + final int server1ConsumerCount = getServer(1).getConnectionCount(); consumer0.close(); Wait.waitFor(() -> ((QueueBinding) getServer(0).getPostOffice().getBinding(SimpleString.toSimpleString(queueName))).consumerCount() == 0, 1000); + //Make sure we don't drop connection if shared + if (shared) { + assertFalse(Wait.waitFor(() -> getServer(1).getConnectionCount() == server1ConsumerCount - 1, + 500, 100)); + assertTrue(server1ConsumerCount == getServer(1).getConnectionCount()); + } + MessageConsumer consumer1 = session1.createConsumer(queue1); producer0.send(session1.createTextMessage("hello")); - assertNotNull(consumer1.receive(10000)); + assertNotNull(consumer1.receive(1000)); producer1.send(session1.createTextMessage("hello")); assertNotNull(consumer1.receive(1000)); @@ -210,7 +456,6 @@ public class FederatedQueueTest extends FederatedTestBase { } } - @Test public void testFederatedQueueChainOfBrokers() throws Exception { String queueName = getName(); @@ -221,12 +466,12 @@ public class FederatedQueueTest extends FederatedTestBase { } //Connect broker 0 (consumer will be here at end of chain) to broker 1 - FederationConfiguration federationConfiguration0 = createFederationConfiguration("server1", queueName, true); + FederationConfiguration federationConfiguration0 = createUpstreamFederationConfiguration("server1", queueName, true); getServer(0).getConfiguration().getFederationConfigurations().add(federationConfiguration0); getServer(0).getFederationManager().deploy(); //Connect broker 1 (middle of chain) to broker 2 - FederationConfiguration federationConfiguration1 = createFederationConfiguration("server2", queueName, true); + FederationConfiguration federationConfiguration1 = createUpstreamFederationConfiguration("server2", queueName, true); getServer(1).getConfiguration().getFederationConfigurations().add(federationConfiguration1); getServer(1).getFederationManager().deploy(); //Broker 2 we dont setup any federation as he is the upstream (head of the chain) @@ -263,7 +508,7 @@ public class FederatedQueueTest extends FederatedTestBase { getServer(i).createQueue(SimpleString.toSimpleString(queueName), RoutingType.ANYCAST, SimpleString.toSimpleString(queueName), null, true, false); } - FederationConfiguration federationConfiguration = createFederationConfiguration("server1", queueName); + FederationConfiguration federationConfiguration = createUpstreamFederationConfiguration("server1", queueName); getServer(0).getConfiguration().getFederationConfigurations().add(federationConfiguration); getServer(0).getFederationManager().deploy(); @@ -307,7 +552,6 @@ public class FederatedQueueTest extends FederatedTestBase { assertNotNull(consumer0.receive(1000)); } - @Test public void testFederatedQueueLocalBrokerRestart() throws Exception { String queueName = getName(); @@ -317,7 +561,7 @@ public class FederatedQueueTest extends FederatedTestBase { getServer(i).createQueue(SimpleString.toSimpleString(queueName), RoutingType.ANYCAST, SimpleString.toSimpleString(queueName), null, true, false); } - FederationConfiguration federationConfiguration = createFederationConfiguration("server1", queueName); + FederationConfiguration federationConfiguration = createUpstreamFederationConfiguration("server1", queueName); getServer(0).getConfiguration().getFederationConfigurations().add(federationConfiguration); getServer(0).getFederationManager().deploy(); @@ -365,17 +609,56 @@ public class FederatedQueueTest extends FederatedTestBase { assertNotNull(consumer0.receive(1000)); } - private FederationConfiguration createFederationConfiguration(String connector, String queueName) { - return createFederationConfiguration(connector, queueName, null); + private FederationConfiguration createDownstreamFederationConfiguration(String connector, String queueName, Boolean includeFederated, + String transportConfigurationRef) { + return createDownstreamFederationConfiguration(null, connector, queueName, includeFederated, false, transportConfigurationRef); } - private FederationConfiguration createFederationConfiguration(String connector, String queueName, Boolean includeFederated) { + private FederationConfiguration createDownstreamFederationConfiguration(String name, String connector, String queueName, Boolean includeFederated, + boolean shareConnection, String transportConfigurationRef) { + FederationDownstreamConfiguration downstreamConfiguration = new FederationDownstreamConfiguration(); + downstreamConfiguration.setName(name != null ? name : connector); + downstreamConfiguration.getConnectionConfiguration().setStaticConnectors(Collections.singletonList(connector)); + downstreamConfiguration.getConnectionConfiguration().setCircuitBreakerTimeout(-1); + downstreamConfiguration.getConnectionConfiguration().setShareConnection(shareConnection); + downstreamConfiguration.addPolicyRef("QueuePolicy" + queueName); + downstreamConfiguration.setUpstreamConfigurationRef(transportConfigurationRef); + + FederationConfiguration federationConfiguration = createFederationConfiguration(connector, queueName, includeFederated); + federationConfiguration.addDownstreamConfiguration(downstreamConfiguration); + + return federationConfiguration; + } + + private FederationConfiguration createDownstreamFederationConfiguration(String connector, String queueName, String transportConfigurationRef) { + return createDownstreamFederationConfiguration(null, connector, queueName, null, false, transportConfigurationRef); + } + + private FederationConfiguration createUpstreamFederationConfiguration(String connector, String queueName, Boolean includeFederated) { + FederationUpstreamConfiguration upstreamConfiguration = createFederationUpstream(connector, queueName); + + FederationConfiguration federationConfiguration = createFederationConfiguration(connector, queueName, includeFederated); + federationConfiguration.addUpstreamConfiguration(upstreamConfiguration); + + return federationConfiguration; + } + + private FederationUpstreamConfiguration createFederationUpstream(String connector, String queueName) { + FederationUpstreamConfiguration upstreamConfiguration = new FederationUpstreamConfiguration(); - upstreamConfiguration.setName(connector); + upstreamConfiguration.setName("server1-upstream"); upstreamConfiguration.getConnectionConfiguration().setStaticConnectors(Collections.singletonList(connector)); upstreamConfiguration.getConnectionConfiguration().setCircuitBreakerTimeout(-1); upstreamConfiguration.addPolicyRef("QueuePolicy" + queueName); + return upstreamConfiguration; + } + + private FederationConfiguration createUpstreamFederationConfiguration(String connector, String queueName) { + return createUpstreamFederationConfiguration(connector, queueName, null); + } + + private FederationConfiguration createFederationConfiguration(String connector, String queueName, Boolean includeFederated) { FederationQueuePolicyConfiguration queuePolicyConfiguration = new FederationQueuePolicyConfiguration(); queuePolicyConfiguration.setName( "QueuePolicy" + queueName); @@ -387,17 +670,33 @@ public class FederatedQueueTest extends FederatedTestBase { FederationConfiguration federationConfiguration = new FederationConfiguration(); federationConfiguration.setName("default"); - federationConfiguration.addUpstreamConfiguration(upstreamConfiguration); federationConfiguration.addFederationPolicy(queuePolicyConfiguration); return federationConfiguration; } + private void addTransformerConfiguration(final FederationConfiguration federationConfiguration, final String queueName) { + federationConfiguration.addTransformerConfiguration( + new FederationTransformerConfiguration("transformer", new TransformerConfiguration(TestTransformer.class.getName()))); + FederationQueuePolicyConfiguration policy = (FederationQueuePolicyConfiguration) federationConfiguration.getFederationPolicyMap().get("QueuePolicy" + queueName); + policy.setTransformerRef("transformer"); + } + private Message createTextMessage(Session session1, String group) throws JMSException { Message message = session1.createTextMessage("hello"); message.setStringProperty("JMSXGroupID", group); return message; } + public static class TestTransformer implements Transformer { + + static String TEST_PROPERTY = "transformed"; + + @Override + public org.apache.activemq.artemis.api.core.Message transform(org.apache.activemq.artemis.api.core.Message message) { + message.putBooleanProperty(TEST_PROPERTY, true); + return message; + } + } } diff --git a/tests/unit-tests/src/test/java/org/apache/activemq/artemis/tests/unit/core/remoting/ActiveMQBufferTestBase.java b/tests/unit-tests/src/test/java/org/apache/activemq/artemis/tests/unit/core/remoting/ActiveMQBufferTestBase.java index f4611405e9..57014b38ce 100644 --- a/tests/unit-tests/src/test/java/org/apache/activemq/artemis/tests/unit/core/remoting/ActiveMQBufferTestBase.java +++ b/tests/unit-tests/src/test/java/org/apache/activemq/artemis/tests/unit/core/remoting/ActiveMQBufferTestBase.java @@ -158,6 +158,27 @@ public abstract class ActiveMQBufferTestBase extends ActiveMQTestBase { Assert.assertFalse(wrapper.readBoolean()); } + @Test + public void testPutNullableTrueBoolean() throws Exception { + wrapper.writeNullableBoolean(true); + + Assert.assertTrue(wrapper.readNullableBoolean()); + } + + @Test + public void testPutNullableFalseBoolean() throws Exception { + wrapper.writeNullableBoolean(false); + + Assert.assertFalse(wrapper.readNullableBoolean()); + } + + @Test + public void testNullBoolean() throws Exception { + wrapper.writeNullableBoolean(null); + + Assert.assertNull(wrapper.readNullableBoolean()); + } + @Test public void testChar() throws Exception { wrapper.writeChar('a'); @@ -195,6 +216,21 @@ public abstract class ActiveMQBufferTestBase extends ActiveMQTestBase { Assert.assertEquals(l, wrapper.readLong()); } + @Test + public void testNullableLong() throws Exception { + Long l = RandomUtil.randomLong(); + wrapper.writeNullableLong(l); + + Assert.assertEquals(l, wrapper.readNullableLong()); + } + + @Test + public void testNullLong() throws Exception { + wrapper.writeNullableLong(null); + + Assert.assertNull(wrapper.readNullableLong()); + } + @Test public void testUnsignedShort() throws Exception { short s1 = Short.MAX_VALUE;

xhH&T%=U1R#23Ug-Lfj>P6@N4_K@h;+x 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 + + + + 4.0.0 + + + org.apache.activemq.examples.federation + broker-federation + 2.11.0-SNAPSHOT + + + federated-queue-downstream + jar + ActiveMQ Artemis Downstream Federated Queue Example + + + ${project.basedir}/../../../.. + + + + + org.apache.activemq.examples.federation + federated-queue + ${project.version} + + + + + + + org.apache.activemq + artemis-maven-plugin + + + create0 + + create + + + ${noServer} + ${basedir}/target/server0 + ${basedir}/target/classes/activemq/server0 + + -Djava.net.preferIPv4Stack=true + + + + create1 + + create + + + ${noServer} + ${basedir}/target/server1 + ${basedir}/target/classes/activemq/server1 + + -Djava.net.preferIPv4Stack=true + + + + create2 + + create + + + ${noServer} + ${basedir}/target/server2 + ${basedir}/target/classes/activemq/server2 + + -Djava.net.preferIPv4Stack=true + + + + start0 + + cli + + + ${noServer} + true + ${basedir}/target/server0 + tcp://localhost:61616 + + run + + eu-west-1 + + + + start1 + + cli + + + ${noServer} + true + ${basedir}/target/server1 + tcp://localhost:61617 + + run + + eu-east-1 + + + + start2 + + cli + + + ${noServer} + true + ${basedir}/target/server2 + tcp://localhost:61618 + + run + + us-central-1 + + + + runClient + + runClient + + + org.apache.activemq.artemis.jms.example.FederatedQueueDownstreamExample + + + + stop0 + + cli + + + ${noServer} + ${basedir}/target/server0 + + stop + + + + + stop1 + + cli + + + ${noServer} + ${basedir}/target/server1 + + stop + + + + + stop2 + + cli + + + ${noServer} + ${basedir}/target/server2 + + stop + + + + + + + org.apache.activemq.examples.federation + federated-queue-downstream + ${project.version} + + + + + org.apache.maven.plugins + maven-clean-plugin + + + + + + release + + + + com.vladsch.flexmark + markdown-page-generator-plugin + + + + + + \ No newline at end of file diff --git a/examples/features/federation/federated-queue-downstream/readme.md b/examples/features/federation/federated-queue-downstream/readme.md new file mode 100644 index 0000000000..347c60d810 --- /dev/null +++ b/examples/features/federation/federated-queue-downstream/readme.md @@ -0,0 +1,51 @@ +# Federated Queue Example + +To run the example, simply type **mvn verify** from this directory, or **mvn -PnoServer verify** if you want to start and create the broker manually. + +This example demonstrates a core queue deployed on three different brokers. The three brokers are configured to form a federated queue mesh. + +In the example we name the brokers, eu-west, eu-east and us-central to give an idea of the use case. + +![EU West, EU East and US Central Diagram](eu-west-east-us-central.png) + +The following is then carried out: + +1. create a consumer on the queue on each node, and we create a producer on only one of the nodes. + +2. send some messages via the producer on EU West, and we verify that **only the local** consumer receives the sent messages. + +3. Next then verify the same on US Central. + +4. Now the consumer on EU West is closed leaving it no local consumers. + +5. Send some more messages to server EU West + +6. We now consume those messages on EU East demonstrating that messages will **re-route** to the another broker based on upstream priority. You will note, US Central is configured to be -1 priority compared to EU East, +there for messages should re-route to EU East as it will have a slightly higher priority for its consumers to consume. +If US Central and EU East were even priority then the re-direct would be loaded between the two. + +7. Next the consumer on US Central is closed leaving it no local consumers. And we send some more messages to US Cental + +8. Again we consume on EU East demonstrating that US Central messages also can **re-route**, if no local-consumer. + +9. Now we restart EU West and US Centrals consumers. + +10. We produce and consume on US Central, showing that dynamically re-adjusts now local consumers exist and messages delivery by priority to local consumer. + +11. And repeat the same on EU West. + + +In other words, we are showing how with Federated Queues, ActiveMQ Artemis **routes** sent messages to local consumers as priority, but is able to re-route the sent messages to other distant brokers if consumers are attached to those brokers. Decoupling the location where producers and consumers need to be. + +Here's the relevant snippet from the broker configuration, which tells the broker to form a cluster between the two nodes and to load balance the messages between the nodes. + +The config that defines the federation you can see in the broker.xml for each broker is within the following tags. You will note upstreams are different in each as well as the federation name, which has to be globally unique. + +``` + + ... + +``` + + +For more information on ActiveMQ Artemis Federation please see the federation section of the user manual. \ No newline at end of file diff --git a/examples/features/federation/federated-queue-downstream/src/main/java/org/apache/activemq/artemis/jms/example/FederatedQueueDownstreamExample.java b/examples/features/federation/federated-queue-downstream/src/main/java/org/apache/activemq/artemis/jms/example/FederatedQueueDownstreamExample.java new file mode 100644 index 0000000000..935f09d459 --- /dev/null +++ b/examples/features/federation/federated-queue-downstream/src/main/java/org/apache/activemq/artemis/jms/example/FederatedQueueDownstreamExample.java @@ -0,0 +1,29 @@ +/* + * 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.jms.example; + +/** + * A simple example that demonstrates dynamic queue messaging routing between remote servers, + * as consumers come and go, routing based on priorities. + * using Queue Federation feature. + */ +public class FederatedQueueDownstreamExample { + + public static void main(final String[] args) throws Exception { + FederatedQueueExample.main(args); + } +} diff --git a/examples/features/federation/federated-queue-downstream/src/main/resources/activemq/server0/broker.xml b/examples/features/federation/federated-queue-downstream/src/main/resources/activemq/server0/broker.xml new file mode 100644 index 0000000000..4cb986a9f3 --- /dev/null +++ b/examples/features/federation/federated-queue-downstream/src/main/resources/activemq/server0/broker.xml @@ -0,0 +1,100 @@ + + + + + + eu-west-1-master + + ./data/bindings + + ./data/journal + + ./data/largemessages + + ./data/paging + + + + tcp://localhost:61616 + tcp://localhost:61616 + tcp://localhost:61617 + tcp://localhost:61618 + + + + + tcp://localhost:61616 + + + + + + + + 1000 + + eu-east-1-connector + + + netty-connector + + + 1000 + + us-central-1-connector + + + netty-connector + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

xhH&T%=U1R#23Ug-Lfj>P6@N4_K@h;+x zuX4IrN;-mw#^pL=O>#vy-=3sYU$3*Gf0F1J4A=tx_euYwk&u1ZUnY3%B4f6I=bM^W zdAD6+*qKq>o%{5BD(p`iCZBqkMWk)#>bdEx7LdIw%Dz^SMrTImuZwW9{uap2+&sFB37rDhWqy$k{&%natY z>jKqTOhjtK3VgG@$SI3|>~Ad{|8m76ROwn6(L_}%#VjMq)uWX06K;)ik520|f@DqN z-CTlvNtyb*TswfZZ0&)gbT?%P=j4?3v>j<=dTwerLHJb1!tu?RawZa6dZtG`jt+4@ zr+7jGrt3H^#Umpna9AvBDABH&o$GFZ*GFQT_b`y9=!K3(4WVW=>wjYOv@pbXIU~&z zHJZ0Q?NonVYqE0TA<1gm%K}(1x9UQRYEBa3oij`B7s%d`yP%e1# zUU$}$z$dQzLt1+%Le#Ii@YYCn*^F_8iJZ|k@GMP*h~Y9(5si|F{f^FnHj#{S=0M+s zw>B+KPpvt6CQmm>XY&R1O1$nom>Yw4dXOJ2U>GJHzmjPJqMIbOzd;+w)0tL!4-B#L zXC{C(BLSB5jO0Mz7g8X$&B$Xof&AviL)^vrBgwV;38c7FA8|!ree}^2n^eX=Sjn_5(IY2R-S8rf%zqDic$7wJuw4)fRiOU%swCI{ocIHzdW8HvJaA|UAr&6(Wt8l zL}`po-QiEzY*@?6gSXULpYF$4>^%$GHoC+;|2*uIa_A^NYFRUD6Bdz+!yUeZH;6RF z5!0QN#q<&5CDgz7qoTOR!Dns2DRF$y z_%N*^&?fbOhoAGx6A)R{ejdmSvVv!lZMUaO4;-%+f;S)w98#>Fab6xwFBn+_g#J6R!Rsqhl~!F~75kqrA0ncN62#BQW4E|Q^SEUL8tmh1}R)6yR?RZWSY zEO+`J3CAvLXb~8AKK;H_6;?U+NePCthU&Si;Zc5B=#D5o${ZjR>BUvw zi&%{uK6kB8MUIfZSUsRw+@O6O0*Zpde_mclRG?#N&g`^}nE2Ss-~>N*(sMhQk*E&W8S;@%kdhm?hTs z1wXI;_8#i>uG@1sAT>5y9apRF_i^qP)X8I2+oYJ(*wz_bUxo5_K^h&(DC)YFF;afj zv(#j6w;R@kwLK|jZp_lklSMXsK1@&Sq7u``-O!pPJgzajNvQDY$1M_Q{`6eFnNVg2 z*u*jc|0UCbYF)37_vP| zr*|1E{Xd?>TvX^Tv2)x1T{`e8RbsloH@7l+>A;+CL$_ zcOqkUhFifT@LYySN_Bb502|K~=jy->tGJWmFDmXbL&r(+``UeI6QJ{NT zq&Ke!4S!83j<8uSSFhh+LivJT?8u#i=XTmhtYwRd%|?1=`0k9q^?pq(4=(5aL}li9 zs=5-2)&z6ZG~=tNXuWic<9qpw&Wy5A+?9ob8;!q}#jt2T?o4QHI6D2i*e{SmP&jy! zyql^eay763sMr_Km08-()6egRFut@Tqdd`fQp#g;x0S}V?_D3NNq9yXBfjf$M}8KO zovPr$GxdVF-~ouW?mT?3(;<8?Sdc=Yg^OYvHlg9@QyeuYT}p+?lz2TunF0GVP!^Wk zEaIKgc-RPyfn;sZ6!fMJ9=pu#PFwO5F0IOiw>v>>U%398Gw`q=5k`XbHJA|VNkWlW z`nA>0>`WP-{2oe3go$WX!8REpoU#(Yxzgz-PDC~4aNG>EQQwBvva;CLo z!zy(FG%*rfMevh<)TI`!bJw2%bfyT#o~OndembylG(}Agy@gZ&*fURQFtQktxl<)fOr0fq_&gNW;0I`wrTnO`*|la$inUhkPU zrH{^JK^ALgpi`DQLAf%A8bjBULP;k^y)wlu_okfzX~%+sT_`GcjpnsJ*KLJa`$L6! zru*3Tg98VrDqr-nb;NEWfhgm2S6Vgi0EEYJ!m5*BV;QdHA3gR98@+{7@8OLc0%T?5_;m!TYp1qCe4sy}RNS7CqkDYMmD z;mF{@M*`VH((!dy*2v_gz&_6{Exlo6#ofr=%<*-!l>hvzRuS%6T{UBUYbBRfTNU;DoV+`7z=sgO)gA>EYgB zICgsv&RwUtMnxLD^cyA&!m!-pS_Pd$-Hk5|87YJ7q8-cbXJW%`;;h9WG3l(K=Ov!) zuY;nTK1w!9w*+0^+2Z6Q?@8F>3V5PHLV3<+#7r z&rZ9c78#gQq5r;cn)YuIh?%+7ZtPcR3TtI_;?2F!LEgC~;M*}u+BHA-R~+s6LeaB- z2;l%yQu3~@?E-L^lz@7xD!39G({Qyt()^e}k&$J23#>Xm1~+_{h z6#7_y&c^8(ufZ$%PZlDutyXk%?K3Tt zh-!Obf}haUHW9K zq#V3)EA|J|e*jb3)C-4BEzR6qlC#Vyj39 z@=ugqn}Nv|m3h>OtX(GO0t#CWTsuf9El$t2OcBgzYDVWvSO0~3kqx-%z=k-|KN~c? zBNQ$>Kv`nD#cuO;2~-fzgV$#-R@GV81*{9tA@8E|*x;oVr#O@1p8e(AiM4s1LaUZE zwX47O(*MO&1VRvA&g%vr8QXxWnd+?0h;{W!^}PF}TyCrlCT<;;3sL)Ym*~ESaJ?P8 z+gdxe_~fmBv2a01eo9+kVzFW-8&eMK&AM8NKn@6)oz(lD9|U#2m9duhZq-F(79RQs!n%!@O{AiOoxQW|=g0$fs$q##c#-b{ zfNVdgy+&ARbz(5Qb(2* zW&;xH;954!`<<^a3^RV@;n6KRh?8w(*7KjDFmqQEk?Wh-zh3vFfhQ5nWtdW3) z!6Ayn_4dX&-NF$*JwoTNPo$gOPFS+8J+T(2)_>J!3F&(GhM)qlN*Sn=MQCU$EOV;w zZOdb8i2kxA|Fwy991}L zxNL-vP#ejdzjn}3j~C0vmIKn8#HyRwRS8@Q*PyzYyYQcG5F5b&!qQjbsa<*VspJG* zmNK{W>Hc>w0mKY_+ZmF0FEw#LLbP)JRm`=dqTdgu4xi;q`Bh7t$`zGuDC4>reW6r& zaloY6XOR-qkAe}klNMYTzTimKAf3+M@`=7oiO?3hb4{vCFs0qG#H#4;C~dCQbfc(% zoZ$F#yRs>$@j+R`t!TD}v=Zgnhyq9)?GWfT#CZ?{bv)kno2ErMm28&~nvH&!M~$C$ z-H&G*hh@%I#;1eCx5fvN-d3pxy_&YEf|ThE*&Hjz5^)`n_S zzm=i1#tXO{S7hQpv;pgb78&aW&mFe-Tx5YnemIL!VbS?G>ArA1u92Nvm@vwBdFQ3C!V(=p85!dbr%!_d`x1OBc}dSBNdVK2RF2U@nvp0L1;DG z?>Evwr4F#T1p)fQ4?01>Rd_SSfjz+N6PH`9_Yx{ z8s)QfFLxRWvchm^!rLwaUB@OU4Nip`Y&g=t*%ZA<1M}9=bf;Jnz}ozUTo0Z69%8Dm z8&DQ+0)_9(lK$n`A_SR8ZT=;!wMrKpnZ&_TNVUW=Aq{!dxvR{i-&8Hhg{=@6Y-MeK zqfKi1#cXq&TT^$3J+?B)=!u56!}FES8c)Ok0gi!Yho+pfLYtMv$o_vJk>eLQ-BFFvJ3BflKT9mij$J-4I&55_uUbvPy@RT7DSqdwYoXa{6JgYi z;+>^&>{NAvg+l!HPP8))6d!Gq_q5iRq84|Lp9GG|+810PF7+>c2iejYprTrk0RHAr zXeY>`5LseS+Wqv+8HNQo?NL|sYbB<}!2+il>_D@e?jDeGe-IhRb4g8oVW}pFK zw_*72$$`c04atXYKH^Txw5E?UPbTc)De;*@v%LCs*oNKZ0%d#z3D?&|x#<%GN=x!p zWI&clU~sT`@z`t>D(VZ&pv8*HiW34!o;+oNTUx>|++nv)iVTJAEAvD5@tlVD4?0w{ z8G1jvjD;wRwF*yPh<#ZS=2ySwF?UrQk3Y_4x^N!T;wNDg>^s_iH~FsHuqK~1Zq`V? zb*tB?zV>Z&$9A}MEz87}O`};*pGP-3hGvPWv`sQ(L_JR)w=K-DodAvZ0`qjbcnY=T zI@gyr<>FVbeIokIKY|-BdcLzmiB^dZ?_Zk&cM5Q>6{*a{qxIZVE3{PfCI~b+Bk|-Z zaF=3x_EJ%4KDF5-2ToHK&8~4Tbfa2dJ$fIz=yU^oo}VLC0%e#={~r|y6w8PGkox&0 z?cp=8&d6rffi)>IzN!HK0hifOQE`MzO$DZ&ybm$)@rG1+JwT2ZF%hYjhB;%(mT+>L zYAl+X_P5~9c$l13rmZnPRR!eIx5c?>`{-kp!7cY%(a2@JF~lC z#{^?Xk(gj|$<-{0q&pmybu&`4%?ZVN;c#ueBkV*O@6)`T3gZVBf;RrFIUk{4(@`I( zil6LAUB)8C689ju^Vt$7gbRT<919}@id zjrJ&PJ$KL?-4m>bAlst)*U3DGc^conB?>yB0GNwUE*wyn5|GNHqXVTs;^NM z6?er&I2lMvdx*`iR8NOOspos0+;d-JI)*3QfZQNsMXKIzuBMQV>U=af${q!bx2BTX z?b3NkJioga@-DhoWvwh4jZWjz`GBAQ*p+%_eY~ zxd^-h4PL;AAtB63DgVFRFo?D!1^xOm2urlP_u4EWEuS=U00}j%aMC1~G-I(zPA2~4 zQ~P0Xy`GA=Iyo(n>-~=n*bhQPpBwQ%E+HNUc1N^zp*!1Y0Z;o4bW@x1vqmYG zs@qlE$-QDT@FTiUH9`05?~ap4;Tk;hxAwHAuaE4U&V+v~;bzk+Q$BS0ptoBGSuVnX z*Ebz)rJinyf4uBfZ}F4IwVMK4%wNw!AH8}jT%Dt3R;vvV{bD2%p=jj+n+K(9`ioOC zJ9v1C-j8>){^SDjk!t8V!nbl!!p1of8{hu9`wBgzSXezT}9YpWv#JSylhMPcLX! zG#jDtIy_%21;4uNvwnoEhn7$EYJA@9w3oQnjSPcayquBn{-oUUD;m!rp-b;rnOd>% z$I|n)sZgyQ$F$~0z0dn(`1Z$CKx+Qw5pg)1d1mpRbE%8nv5U*;!M#u*sALT_hjOP5 zpw*RJ$oW<3x8GC{Or$UCMw3S9dhaD`poJmkYxE;c~*PD;>qnQ>CxqOn8C31 z3(z|Vb>A7MVgdMG_X*TZgjsH6QvIk}tPQbP6nzhcX2jU0_I?V8gb!KN?`_E3lP z0u~?tbWzo9WkM%i*adrghl-y+WOlFJX>-7`fsZf@n^tz#U_&2ZX045<^s68SP)8?RPM2(Hv&KQ1ee0hn=iY9+!9!T9y|?ZQ zaiFb0^tQ^Cb(-22a#hj}Qha400Kjbc%hS1V*wrREG{61{E&gU9C+oDET3UMGfU@vA zHH4gYSx$i*Vo#qZhKr9Y=$K~apwCc>6k;-jedgCS6ukGN97!c+%)~1`cBG439DO<% z?uJWcIV40jw*A>fEoafh3d2lP4e?+HcvHMR%bks$qjB>@ux!oGjsACv*_`ypfX$1g z#f;o8-@x^wy8q=;*uT05ih8)yq?2NQ-GZ&|UoD%;>xwau8Yy?b}&EP{0&w{**y!!tCRBw-{ZXyQp}j;*&FMT(?Vp zaWbsSW^cib7DIRYH@S!3SCTqOn29k)yZcAP<87GA@*9RmpRP}|<6_Rbq{&}OfQ_W? zam1mx&)m-_#2*ZI*dB4(RDN~qs{UU)2tp88a#NT)fG+{VS0jSQ8H73=xOM(n%%9`; zltJjpIQ+PSy;yrW{9y5ULDM1Q(+o4~II02rTWM6zh+l7&*eA4NlRm z5ssUKdH8Fn+pR0rY8?rD^ZExh`mvOp&yk?T<^qcq?tA)4JL(Zv*U3c!(r<1Jlp%P0 zr=?|}yLQyqHhxdJG4yXwPU2^7w9w`+m_Gc41DN7Y^CX0!W>FGVIG0=rdB@ za~xw{c#P)HreNlXQC4R*v6H-mu^IJpbQ@2UXkfld;sSRi||4bq@7eNLQ!Z??i zQd_D=6?zr%BWtF~jq`_)bUt-E#Y3{7wL>+*kM_2z|CR;)5rGt3;pnRcxy!fe^URa2 zV-LaEC-I{f77!=VB9VKmkVU*RJyRL-5nDdIk4^rqa|vdBTy}C_92?2xB>gjbSkaw4 zWW6KMuq;zajO*>U*=^b>2YxfdQEF+NrOmmhdzJ0v`}%AmBfjYa?UyIdaILKq%M{Ia=i)54zok0lO8>y%Wr zxjesGupX1{#3}rh=FaXRG0+H^K##{FvGu)9gMzA>2mn<3JmIpGDzC6UJ>f~`e0(EX*PpL7U+9ix!Z`k`1V zw7y62AlbR%*(2x_Vr7-wCW>vi8e z>FLqik1VM+p5V0+XnUrj!fv{K&||XXGtocZFJU@2GNLa?d@`I#EM9lC_W7JG zRjS^|8J2qQHXxVLs-aoC_0a*FsxsiG|KP+a)a|KHYC$`OBe$u&CPHcnHG54#b9ZpA zT_jM_X2Ot&ul-{sF_$1qna6*X7*=|?Ph#Hc#@%g__R3mO0*f2-ek^-F0KAnA)~pGw zhXWu&h#_%>ZG%|85j3X(s6Jdm?ik--)%VB`lqaPV#Rvx7C8DE?Fi7?!=IfF_LmEQi>+w0VRRm|KmihZ zu}69*4e@F^=!26hQheD5VOK$1`h6>ue%8%hT0;im>z_910)vb}KF3hKeyY(AnalUQ zs|u!xhlUSr_>P6MaF2JAlAZ~}2jOusJQv9w|0igDfkPsAUrMa#|3}t4JzPFE!S&h; zih$f6j*r#xaY9BR9>c`<-oCphb5d`5ZYaX+m6rcirjbL#N4xn^abUJ|qgTNY;N?=_ z^9X+sYngua4ei9K&}%Hq`o90I$7>Uox`EzJ#+fEuw zC?H{)B#zLryBmIQe%K`Hz3Eq)Q#AHvk#p}-(#rXGzyQu{`*r^}_t9%*%8cSJW=D*` zi{sgpA0^1265U&BnGzlPmubOY``S*h7!~CM59^TpI+=)&V4RvBDPME!MYGDQnwgKX z|C^g)F#hHy>dkP|rMd3Pw36=uw$BdR0Rz8?14xYH5lcNCl6cxJ`5x#u`;CSo_2*pQ;oY{vAjuqOZW#H`@yErNqSx?=Jl0k`l+W9W*`Vwh{_pN1~iK;xiH@_vqOtDN^hp^1P28AZ^PhS zYDsc`xlx7FM}?~qdncSiWAMsWioboolvK#mVlcIL3K!~{_1$5glxX9J+SxVm%HvNc zSm%~rYu;p;C-LgcjQBjQ>KhH0{{KsB5P=nPp=>AVRTX!J8orbuncXZ046Z^U1?^5s zD*cv7S4{Nh58QS+x1)=JV#Jr?=i26~YNI6Wc@aVdzJS?eYW(MN1G* z1%xGD0=gq^xD*<&_xl>VO9ov z%1!(N@OH;VMV#i!$5)An|Arr4mj#Eljf=ycKV=Ayv)MqzMV@*VnRuXjgu@)zpOCM(^h-As(_&@on|xjVd)GJXkcgUUurbJh z8b;JI0@4bwNclC>J(s>WH18Q{GC2J3nS=~q5hy>fT?_PVl8^ROXz{sIW|Ls$=YIvP zm`sjrejYd7zuA1raqQV~44t2Z@Khi~Cb5*WN0645zjl|%IBLTsSjQc8h8!8W6RD1t zIXYcru=VNWPE`UWM09b{V)GOY)Hkg3@XV23Y`e}YVSraQFGn^S|K}yMYNCG$xz_IF z2##miij3kQa*sY<>IfI-Uz75;3eV$)WlJL{{EH|OA|yeBlxj!BS+V5Wiu?l?5nQm& zN1aB6POrMVO1YI@cg(pr@8o`Z6n6Y(9hSIbV?g&-5)wHVXo6Q{(rED;PYt9nTTxDf3qZluwVZaaQ2 zH1NZr9vKnj_hE^utx>A_Z~@B7X-m1iA;Rj92;hesoe#R3CGF2mN60nOyA|}LoR|>m zS>tH=-Vnk!q``UVt?QHoGSpsaRb5uJ1RY`@1v>Wx2aTJ*ZGlzf(0#drgs%MkVeOi` zY5ZCtxi%ND0T8l}dM?O)=oV*VMAY9tUNbT2SQ~0TwObM8S9aNHq9>tP@&A*DFoW7n zlY~UwgpKB0BV$tGY)VN_-9I)Q9Gt|6L1_EFN3Fsy6!k@%e$paLfj7bg8hy5u=c0Rk z1=Gm7RyA%i1`B@W1Xs{H%Pq2tB}|+`3ji0Y!fWD1V%9ixdxX)mj!**;1?^#gN-`n+GL0q?D}mZ2vL8)1}DxLFNjM zlJJY6fj6U^I1LEG?_h*ic<+g6E|LzH%#*hCAR|~^E>)$^4;hjdQlAao zV&HJClr#E9tc3yD{+Obc zVOfSXFwVD}>9e!(7o+W4^nA!uhqG`cO3_jZ_G}YpXcM0*Sw^kJ<=7KR{oz1!>JwqJ z>)^2F^#J@XV?s5zEIe|1Fhvm)&g|g90ozSSS$`CtQQ%sp>)@^5>PA3rMPQQK;IQdf zF3pJOy@ESfxcYx&S#uY%hXufF?F*YdycG^nR==q4E*rS<>f8oN1zM#!43GEC zR}42`9Y!W;;~t?=f||j0uDI+;G-gZL;qiEB#j-o+7lpS0LLygZN!hZRZM@A31$m?< z8rAjUyZvaU-WMPP+Anv%-Z4baz5hnME;oen(<0oevoueIX@3 zrvP`IpC10jaPZpUo}cGg6hZvmszj62^vlXmAri93A2b=$n_)5z9~d7jBrw(7&KdkA z>j|N4fGu-Ptc>lz&zcJnlk$1}jP@R;-(F+&rIf86p?IAxv55rarEk);wI|@I${oW- ztwVQUq&`(^!vvguywB1D;*^KyP-KFM@B+qkd9{Ugt+*3Dp>FTI2skx8!y%=TMOrTa znpnj$hsd0Bd8Uoo77Bs;%9f+eyEdI?kHs$YKOj|uw>_t_l9M(Ug*Q#)flOv{i-5{4 zO4Qg!sKnEM2V=25?4UyW;^Mk}aB2srih?D7+;;7(%#{J#vwElqr@`p8Oo+rF?Stc$ojL3ub zL)LDXS^y{Kv{dc+J;NtvKUCFWe!T1cm9x3*do_%238H$Ty;~yB%Un(*{9!$imJeA8 zM=BWDLrOB4=mi4Ti3d*)fGcHCzdvo>#Oe;V4oiB86P15G&c#xARxU&>$Tp~Dc~lS?5#qH#!v z0*m}AsF~b~DizjFH&v#tm!v(O(K8+b$`gL@*>E&+E;q(fWBew{pqQur+B`E~s_vF^ zzT=_&0F>q=og~bZuRWeV*H(UH1Sx6>u9zFV3 zKdV;NtXcD!rQZCF?f{shOz@|YDG2&yb+~q0X@PIZpP4_Q?+D;PqgJGlFSk!e#~tO8pa_Nz7$A4zEw0KgKICMu36j5M0rj1PA~oob!i zbi*5p6SFc0N+@kv{*5xLgJ1uNthca-!aRpd%+r$~b!npK#GJAVKU)OMe~2?v?9mT& z1m%lhtE5|rP2l^tqX_wV6{nr^DyYGaZ#P~2aL_-SBcox;3(44gF))aWZrS!pr(cHq*?~(4$i|a=4NIii95OHz+dwz}d+(eN zb&|_0$)l@@>5Sgj^EasRO?h_ms@Vez4)PKE>g9Q5p8tmQKw$3aT$785f9T#cUWw~V z_)S{D_J6OKbaIORHccbc7Lw%}AcE~YGic$}V{M4q*26IyRnR&j6)w?8!AD za+%kZbivqdkFw*N;M6dqfoxpUc0X3`HJ$=AzYk3N2TIgSlB?EuXgf>|@4pLcdxMJ3l`i zcB=X;Ew~v)hBzc5OTrDM9HImFF4VeferY9Dr?>o`gPW5lU0k21m25Yu8&il=cMB5p^^95f}w)U=(=pE z!SEz^AUc*aX8`{q(y3Rz8CsndeRua+@}fzj>DRBr_Y02KVgP}&?<2GDZ7PmUu2~{& zU4D;09OEzO@+r1SBOOzx6=U4yPwX(V0vl>s(<530()<=E>2beqN8I{$?81kT$;%24 zzt0M!rjf3ht#z&4T+K+6SZN^bw;{o?HVLc^0W;`@N8qd9Ucb--Cb7+>O}#Kfs^edN zVUl5XP?dj5MPY=|PFF=jjxtNnumWcKM0GzhdVlL#h5^~M0SE2iPn&qe98G2e zw$3;yw&WH69woQ`!d%-%D?`8=Lw5a4-9XAj-!gHr3Cv31em`c-wov`H=jQz6YJYsZ zeD1c)#$_gSV0;-?Bswi1$z_Q*;Z$VeLaPI{{Mo9Vc8j`tS>+@bm7-anXV-`b+27vyMbsjvVS z{>a7{t?H1*q zE{=sBunluMI~Vhyv8+*bl~-OHbYGhaQsmHpHP4%goFi#{a3bOhObX*BJ5xfZ*!)4A zb?jV08d2_6Q~FcIty25PPX5XPp5m6hw9A*N@rY{*ChQ zQDDpe8F%ommJ`Rb-G-z#@9tgN8V_%1du4AbrT!yxWrYQ*mPJ-H0Dk4qDEuZTrmM>* z&z%<&zI*l`<7~FX!CZNUyPehtY~apyy2BJnxt@EUm6X!!>Jkq2WVYqrh!#Bn(d~2| zS!pvLJ|}=!tq=XC1FkxjBOk3{*ruAcj4)zV$Aq6lQwAGNaW-v}fgW=SHXeH@OE`73 zmUmJzj+fC^-%_bu10u9`7yPCpnmLd=`RTCCT^Wou%G_kMJdovPG6ltFF~78VAR0<8 z5^U$}eK+hQ<@)IN_^(drQP?j_h1+Ysj!EEcmcTel;2sU(pk$5`@XrvP&BWvO!=-&Y26_8mnied}B7itdGT|3>5BAQnZ}(HT)j~H?ss2nFT-RgU`Mv39 zOoqa{Jka3dINO5mGv&7$uLV7@8Q*AaVj^cuT`>lJ)?e~qYka9}vnWLF2rn&LPP&X84z&~Z1k-Drl`d*Q~s1sdV9 zY68M}E;XMEp;c_6qL)N|qEmMm(_!SAbnGE(v{HTM)LYmkvcTv>L)rzBvR%%y^d~W4 z?*i?Txt*>`dDR=oq#v)bP)M|rvYj4iAZn%;9y+J;wFQkFR1jFK+ag!8{>@nO$D2;NclO!%Bwjg~>CbImXyc_8JOxC>o zWs7RxtElKyWxtgnM-)r>u3zd|!kXfItpGtB@AFB?Nq!squm6%u6P4^DrIXC>Y*8yk32SUU}wIlvQ+G&&Y}- zlQt4{@|G?Eh^o#7Nv}l2r&|#GClBzze*D3Y%`-(KS%C|&tfbt6?R-D4$`_OR$8VG5 zGgQe;47((OIU!ThOl)L9=5{%M;CtH_Or1(j*CR$IS8B}h#w6-2Hw98xQfNBv9q~_7 zt>KHwO!{mIjdr(6#5q6T8qq6KDI!3#yq+aR_ZmwehsI9{0?R)f*Wcc2AZ3ai$J1^< z_j!Esx`H69q!7?ERG0t4_91qnq=62wG0z_o{-i1h-VhqO_%Qe~brN1-a_f5`Ncb^E zuJUxQ$GCXe!*6_stX0+||I=uY_3#JQ7UA>zf<)G~cAlc7my$Ui$mV=%#_~7f(JXJ| z{>3cgoGX8f+ci@~(?30Cj;LQ&6Y^RU$=ke`*gXA?$E@2ywSm_xabvytSOj#4ez^>KCas@O!OHO2~ajyftZyuzA0py8G;nB(@DUS%RUn!q0`VbhJV zu0?VM4Z0g4mbsT`7_qW3_vTZQyo~o%nNa3EKhT-+xlzbSiFf57bm5yh=7t;0keD6^$+ORapXKm|Lj(1}4Woy26XIwis-bb*(K@W9cASqP>w>E?j zK3?9tc#=&KV#U!C>R=_9U@%HYZSMVLqt&yT?}%+>@4aXbY5diIp|%Qn*8lg~qd;b5 z)4C!sjjgX2zIvE_9AdY~eRdkbqB#8CoNp6lclZ!H_2_gUgfGBGP+bjIrGAo}-k?>( zSDUp4U%8G^Pb2z;jc5c?h^W*eDrao*ou&+=^H}>%o0u|wKMUa^ir{~nyV&0lhEsjV z3V=5-iOi)V4T)Sap-pZH4}7&@ZK7x4YgizF?fmS)N|3@16X&4f)be6oyM9_$GqBV7ZvS^q5C#gEig3%*>sdQbghyd0JaGSrWRF%adeum`NS+IwmXCE26- zJoIj?s{@A_!HPUb8ps}0h>+M@2_pvGo(KHX+PH8Nz5^Akws=ixd#5ctiI+WeZ-%-K<_pF!4l=v!yC+73E6SIAZuOfLqD zsMpY#HGV)&4eh7-xK;QN>*xd3q9*e76c(&*=DSM0Aq^+#Q(ca7*pF;bX1z~G!I7h@l-wOp8%_?uVr%EiOSpIv!|6t=;c6O5_P@tB$pAZu-W|Y8m`!+Z z+78d;-KuLsm>Z`ilUVY@UvL}Ci90g!R^ynb6^<+XmLP=>NwRt|nPr1NUO9sWiQ=~1 zfD+c_2#fw~Afz=4g=q(s^!sAR!YoKQ(6iNsJ7&4cYOQAUV*`pfSbIHST+LWwn0SgYBy1E9N2jpRZMY7tgraI zvxQ2n3e&KV!DyHgp)gz>E^G*Zyu;peGzUZ}+_Nvr+){P*BCFd%!HTmHRbfbfbqDY< z6d}3P5u(R^Rgg5W_%Z~V1<9lf&=}(ykSK+-@PDyq(~Qiqc~i$UhA)G{UBaCdJ^k2aQq86F*SA(*)FIhE8OhgFe)UN0{~)sQ%!zsm%hqJ&M{OZ(2R_$PgZ(;h;0` zqnRTRW}WsM7$=B2-*+=wy+x7RJ`=Y*GUrT2TLnCbrX)14`d@=8l#mDRb`@y!GoI!d zi{ywRm#6utA$xEk;)d>QWd%mLQE$pO5qmuHh;1Sps|NLvb(x9B*?=wb79P}=#xn?g zM2H4B%B*67s9&MLC#6?K@);Q(`NA!l`+C_6!{9NI7GQasQWUZ(=wt{AqhpnjC^au} z*V6L9EE*>ibuhpsEijCUW5PqP!OAP#KwC;j?5BE#ZI)a*<)ieqz0TshV37b0F&?8C z1fNe4DlC8dPHMU?u4Ktp7}<=Ve!vo)z@7jC-=I6c&ax}n{CK3!5q8rZ-Ov(5hsk3S zt{X9$5BE{!R(zSA`ALJErLHMOc8u&p(z}Sr2-QmX&lv-=HS_Ipr}#=WJDe70sX_S| z)B3+OnXIS0@cG&Zlq2@SS@(6QM^9?7&&VwvO<2>&KaQC2i&MVHCvI8THJ>BQMI>ID zaQp;Y0Q9Yr#-dnuuuE~1nuo^Fw^!F)nuHV{efg8FvSB|8L&ZlE1`-XAp;13BC)L-t z$G_0<6Z1RQ7)?53_~(TBiAo|=(~6eN#9<0I&l(%N7^36i(b(C&91W&2BDjcS=aQl^ zd3PUL0*!DygJMqK2~FuQmZN?M;d8%+{~{E7S!$UlWlBY;U56Z59i;G<`>QvM?qP?@ z)0Kf&maL;B`@?j2^^95iPF?Y$SMTQ}Lz5^IM02z$h}4uo=i~2^RKA`ZOPU#cU()#G zh1?ybzdpS32kzu|#oz}thTBVIzQCrszQHPFdd$V1etz}LG`iQxVfpU9qJail_v6xE zIbSV0l|jWmg+1SuThCdq^AYe?xnEDjM7lfq&?4YttbFy;(y8ht*g}A1bVA96JU{pl zrr3ez@9BJi3dHeB9uS$yd+VKlyTc?aq{K<5an~quq%|tRS1H7(S<>coaKI{*OARhA z#!iHqwrTypEHf+Olfc;-0W zTJZOg;K?bSsO~A!WF{B3!iW~U>46G^wk;56ObcPrB?n$$V=&b1jU~cCS|T%{Va+Zn zFYO%4h=`}~Y@wkUL#dv>)e?_UO&7Zh#^JK9?ty!H^vY(qZr#Rb1Jm%p4C)S25)vlk zXJMA zo%_aoT;#}W@p{(^v)%QvZ;7$Xj)xo>Mc2yzzEy&#f_hji(EEuZovUlF+WbvyYYuqx zh%}Hdet!EB!ZOkt<}?XHA^Qoe(@4#)GoP}4OfRlg!&fenpqiM%A4ig|pa$59AF~B( zq0b4YUU$5DaFP}mL@J4@c_oo1T0ZfaMl6Af5I|n-fiVj?>!;o;(M4m33`55i@vZ|D z{14sUJjsW{P8p`hlsvay{mV<^`^N}oV|PXAzkzREO=El$7td};BIbuyDV4gdMRY}@w_43V|dhFz1aB} zlie>RCNYbD+~Yf31E-RIGKxQ5pkGx$){cF6^F|tP;aaw{?JF~d(hpeT@okeO!oc|Y zDIOh?{GGbi=6946_@ah!9Tj#amquvq4LB}A?XV0f3mTeub`^Fo!=)1}7_Ov|87~Oz zL~hWg3_juPs_53lD)Gv@1|u8u=dZWEJx$+FfTpZBzua~EQkOdd;1;DnJ`J!PDOI{I zkTRNY6G(*O4Ut*a`ZCgJOow>QoCzQ!pS%}}0~wG-W5S!ttQ_8Dh(JpRyK5|kZzxfY zi*S?Hwb`J}(IczIuVxb|iI)qz43FBVdNx$yV`200V=s+g;)q-2V5 zNMe0VeBvF~G$so-_cQLh=loLC!4;t@pUW4v_rlL&68q=JMx;|}ydEOfKL`i(*KS?% z+MO!57U!qI`lQ&o(#i<Vc=!k#wMB;b)@dk}J>IjCIcR0c5_xYr5QYRIT?rw3OkjA(pVrV;Tb1c-7lVz~YcG}8_7z{Cp- zqi&zrw(TKmcz(~na^oHUEwjIPl*{dW+_$$BdRpYV*q&pxm0u8FT#SiIz-u`u-}fJC|GG=D{CTQ zC$$fx`5Tl4?rYMyt#Mai`s7VZRyujm?5b{6&ZV)GP*eJ6OPdReT=PAbwSN5d%@~zB z$KmOb{L$HeUD)1GLzq3!vQ_NQh>XW}73JTvC=Yo1}0fD3; zlO;K+*2!!9e3CR?mCqLR7uz+z@%CyE(n>WMUdRRN{r*-MRiznxGKthDMwn@biOht^ zA@n#z7hVf5OhqCs;CG_-5mqI#P(*U(WbLY`9P5X0Dsy>hQzzF6LvO;^fdTreessRD zpcLflkO6x&4@gC@%*G{j!++(Q(hme4^~%x;SewfSlGy!x4n@?D_IO$CJbb`%mMnkc zr6fIr885~YMMoNDQf|dM7#6`NFhuXn7W8u+ep9$}7*DhJ)lL?mf@%&Cp5a+uk3@8Q zrtB!rwaLZiFfy+hx^}0(-b7TF!BY57jQoIubawKIbkx!;x@|5GL3^Z%now-;3agAA ze!6z{{?S)CYLfUR?Pi(qSz$`WqkB0ebL^y^i6;#PV>W1^-IM?gT`?vmGpM%rBAHL0 z4mXV^g})`4yN)yVPRRC5a8fiwcZ%6JSAi<5FElaHV=me!SYft>(S62YH0=^43Wmvk zMlpSO8Th_vogH}4#G5s`Z-$B?XP9kDgI)sN*giw7qi%IWIq=olUBbbg3&c=(&TR*)x@>@MO$ZO5~fwPmOkixN-z5%o+UhAi~`n|d0(dle!*pxBDc#`xT zH+$27h@wmi^r)TiT5Oq&*zd&>F!g8Py-i9O;mt^8AApK#ifeufT=qXqYstTSl>E6{ zML(q<+xNgIx!{5#JLRp}LjcSWARMyXC8lMeKBuy2EN_IL#f$7*?f00?L0KnYNlQ88 zu|N1kw#I~Ef{UAeQr_t1MDs4 zs}z>W!fE9}&}Ifmh&z25$n})Ah9v*p@*gh%Lt@!-_Sh*vel3PRDm!?bk6kn_$CB$q zN}9*WZ;Bc^ET3ClfOb-`OA|BZ9qlLLQ6qaFGW4U+;h5(J^NS^eUe`5)!7=bbjq{3$ zj51vRnu*|N93_Z-)0NdsUv@inwP>T%7Cs{!(=c2@tXl1q>z-oyw?fOwr_|H5s0H^e zz1+OF+7JZ0=VSKTMycO1GpirQO_n^>ax^e;vQ12&o(O6Y0vB8EK;iZ37bhioFlINe zS#t*U`on_>oNlL4F9J>D#eX~H?LVFJptlhRK(ArwrWBE#Jm2=?O7k$Ikf0MGoNywn z4u@{Rn!TqR1z=1a@#m~>3mvs>Z@qR<+0Kky!I8!UsDcqTXZ6$Sc?jQe6(V?BuqQ93WCnD)2;ED*!lv|2&F%gs`WlW*OWTaKleD)q+ zJ5`AbgM(PGm2E_R-l6C51E!?D{aP$0K5@R+bCr6up}}2Fvpe5+k--;ukBS-t43X)Y z0lDTjK2sgZ=w_GuD|B>O%&W%REqxR=1Bf!+ydWeYW!L9GZ2{=J%j_+~S=Ur*UZi@f z=MRK$64A|?I=`(FxP+i2>Z=Zu_b2mXeNH zTOZJ|LE-1}5nDjW#>X<4(D+P_0|m0a$dA@X0j+n9sA2ZZzI;pRPOOuK|Hg`)G--C= zHOj;N$g8V`QP~*(faxXqC09-Vvc+)3vyJ_bUR z{L)|nvM)u z7)NdXF01rT^NhO;BZbKz5_{oH_^)CR1%&p2IXn9trA6m#=% zY;I>Zm$wyOk77a(R-QaX?eOAeX^>?*rgAJ~=xYjt`MR1ey}2U76KP}}2Xw*#y~Ru! zGGiL>4lQrYm0|Kw?5qTlHl2NJC_nJ|3+IGI1>p`*AX;!%HGSjTl5g~12Vpq#0O5mr zCY_o`(p=D9@0NaFxUX}4^)#Qp#M(I3eegQEpD7M>di!2lgQx_>otL|Mo#-4JZQ~S+ zJKp?$E78keXV?WG_f+M61YPz-g=`Z$`yNoL7~)`G&iBNif6+}#o17$8Fcf%>8Y1y@ zEL@A3Skv!FLu$_xFaG69xNsRg7q!I=P4O%xY!FVJF?jK-FV)27+%&mQ+2y%}{84yx zK^SJ^41LKRZ}?G5CLDi`NhykC`rBa(i8UF_%9 zSo#m<{R@5nd^GlGv*KjH`xqI7Inq2Sr|Mx z9he*Uq>+&xMC9oP0^WLzEr5LA0w_+sfeU|nU@ZXL(At-5LS-BVM8#5Ut7_<)>6Xk} zZF+z<;DGS*B-P9MiG_%t!`Z{qJDQPqa4w1$-9N~2ci`!~sj3|B$Oc>e(DFu+vm&!u z;{5X3h!C^If|8jKJ_s}$O|ON-bH(a5wlS4*iV}KuEtEJD%Z;X|6gAaf(=2OMxGZRChCYcWae&NYi#hmx-O^%Pa3i)l~Vc? z;M_!2X@RsBl?%ESrzmBm$#cBVZy;m9c07PRfAtt=NTyV0D08xp-@@K=wba{69R|U%KqK z22?ZJbQm_1x2hfLbd-H!Mep^4r76L7$HUjI?1XeV>X-4QnX{54X?FG!N^3(*W**Xl z3^`;enk)O=XH=tnV^VHz%#x5TMw4F1Z!;L#b#3jAsh@TFsEA{_e9*;E-dCImzpQTn z`{S8hNtoydfT@^MP1Frg{Ahc^P*Kmj?|~^igvMk)(&R86YpQODL!Xv{0-hrlW(j!Z zH3!u>`O!!8KEqH%rupX;_2=epkinTZ2+%bLVNW8F#Z0|yP}w#Bs%)-no{u2`k1$Ok zU5jHTh&}no7@RH}FJ08xQU&135&#e3!}e)9;DDLsdo75NV4yO?{u86aSGbbyYd8q< z{3od82)vo|o^Uv?W}MmOP%mtmUBgL^a(1tpoq}TmFBMOBU1w01fb2}|gdsKKfv$w@ z4~T$e9-k@=kY{I%~Qib5w-RllDzl}NNYQcNqz7PWHOaWvpMXa7v` zX}M5?SfML_O+a*iNht98)|f9^EA;j1ppzX!cF$5w)w179&^R7!u5=! zI*OClbmf4Wz!ghy^Y=f}#ou6o1^S^(FBglS81!CmvZ76wF%h71CNzlZ@s4jHIL*D% z>5?08bNnU=*vW;Xt@TQXKK&#OYtDe-LUUs#xqRXh5;-Pe9y>K4ch;8=SHr|k0v{{v zzFAx_*ixIMFh$ALFM=Q(&3&tED7N=Ys3SGG-t*g|RyY9@k$xnVVR~Ga>QH4v_JI>| z>{({O_R}u$&6+zfH9q3f)io~^>1KQi*Tf2;wMx}OLK;0lh$u}|vgJ_o>&2RmsQeIM z+X(Gm#?fbaw53Xak9>2nv)B<_*g3aHEPYvj&ic0%y^d7TL1!{BelRG4o9PWiZ-hQY zxi1~{(vG4>7{+KQvQ@u<94S);FWb>e{v18wIryX#br*0;aqM{tQmwd1^tk9Vo=Xqf zI;*)KeT%z$fa@`uXxL_tx53{gYMC{Vg;y5k7i8E-CJ#@gw|I!T6CblK7m$CoQ8p~T zs?srkO2}o+L7ICF?WFVb6U836Vrw#s1dSYo;#BH6MTSAlE$ryWXlkP zi*J_e;&3-Qvowr%QQ~2@Z2=xADKR-agrch8^BB@H6KaP)Zaqk}_!8$zh)TcgE@>Aj zTx>v)ZZ0a%LuFYNYX-$%>Y|378S{86-^1#tS>P)Yss$ET;{bYH3}vC^Y`oDk54A+a zl2H%9H+-dsZK%EJVn8qXS2q|7zxz{CsH``8sz%)jcNfyL`&l`)$#N_|GB;;XkJSE6 z#s5sm{-Tg<*uWp)*vVCeV``&f^Y3*sVC=n4Y8=KY*?Pm$4N4wIu%5+RSq`2$nspAD z!Pv78iM|EvdqrzJ;e1AahFD-xY4L!QSn z9N9Vxp5#vx!|Mh@(Wy`zDqmj#i~4jyPh&drV*r3@Sc|wUL?n1D_m03@@hdtal45(= zaTE{JR7*@>W`l(w#LWOdK?mrJFH9l?uRzT0ey>t zd2yg>h6C2Tjf~PRmD}UW8|MOUzLA>L2+(Rp|B&v)1 z>L;U^_pd2oS4-s@`fHQIoi*v_KDVj)+g-6GGX5RYsrfqR^#9BT{~I_|knckTi|JeF z56fbmEmYkRG2@ckr-8{xW*-uO2b6BS0E0&kua~_pDVaD-exZ|l|D%iBqkz}iRrVGP z!X@fsdYW!Er6ru*{+KwP=*-jz9?Wuf65paoosgx+5l)X+k=mwI{_;@YHqQBHo0?$# z{>EAC6fV5jc6E)DOqSvmJJ^atKq^1o`IL`h#~W{|9A>u16Lr3?4fW<;)Ijpv5h~jB zw8CRBK`~D>f_$8jqha2w6$#g|grw+9AS$E%#N0mPLYyIJd_rf+FL(tuHwtMp0S}4P zX3>d^KJz1sbT(aT1ANl(M0Pzn7Jcm0>#_CoC+vs{54S<8qj!J6S{QvE&1>JIX;xh-ZSZ%(d;%B@NQkW74+;4V#f7?A^1ik)i`$elqRArA8r0-bXy<1@CorUhMW9m0bQ;WeFtgc2h4ooIyjG?R)WKFM+d|_?H z)O5XzCmq2(+C9xGGCKqSX0UPkYy9f#{{B~{?Lr$F$KGz{7iu+AUPL7|t*@4e^|kub zJ74fiNnV8_U{}nMk7WPvQq>p=PB)qoa;L|i3k&+4SmFBL$%3QB-HE)A0czj3hvC7i zFkrRhbhFhu-L$wiKdwH8_9iymW!i2dTg1atlLiTY@%x2gA+ZB^5gw4>EhN{~Y{_K?ha#^Z0{UWR1gprks$q#?B7F84qfu1p^(e}#ic(sK8+g%*WXxCy&F zu0Lqq^Am>eQs3aA_c^O{>b@N5k7}n%0U27PlQOH{_${a`&SY?>*m<|N;gTa&<`ZJc zv^Is{b@aojCK)MLAL_QeDtYFR{$UVSP@q=$8GNRu4xje+h#t+wbXC1}GgXn^EMBhq zo`(kykMOxqcZpHX;f{Ah3TRwOP##t{r{mQk!)RC<>_>mm`x7 z)uZR4w{J?wC+jT|!P=`^ZbzyY3MO6VC$6B;$@$ZXX5&GLo*7V6_@0;nBsgjx^u{&9s}W9% zD48(?e$751YxR$>_8l*llsmI1_$m1)%L8}bWmL3~iPlDsUC4~_z17Q%W^q7H7v^KH zP3|PfO32=#PuCCH&@f|EI(+d-6p(~?-hh(Zif-3{+v;mKI>OfMlWk(m7 zpSyw)tj#X+ayXG^=&0UsCms-Y<&enD!x6Kd;i~5$!>C8xC?f@Hmsd~Oj|G0=fZJ># z(Q&B6!O-sT3(Kz>&WT1h?xa#nRr=WIy2{UO{K#9HB*kf(h>D9+duzeV!f$e#d& zYH?V&)x}-_6SE;ZMYu*NY_LFD^3Qs>gtKEIP2%_4*!1(xUVEJGY#@~17B*r8(&22G zRHEIxk`hnd1i&<|57jmO;85_q608 z87S(BNdzt=yNzbJaIl{~lBZjr0HB&hrKI~g&;wA&s09BCeFRmZymo4{e2)%h1zx=8 zYhKRz+lY22scj(tC|;l@MYN|7)(QFNXc3&X7+)TW;{goa0}sh}jdmtll*#%_;;4-U zs3^Y{Wx-xHF14-f!BO3f2@|9gF{m9@u_RB(wpqgN$~CB~%aom>!7Zf&(CNa1mL^@o z-)a$+DD(Apv<;auM4hlPYFk@zt(FpP-6RBV?pgE6#Bk~o(9Y5$n^#T0)*Te<>VH&m zM|)AsKNvarzL3&$BGKmSudpRqXl`EGQ<7nu*S3uv+oR5rTGC8P00!n%<|aqXgJy@* z0m4lz-Hc5y{BUg6& z3-n|Z`6Tr05GmAg7r!sxV9Ko#$?^|A$@9&fILFbnOKpaZby-xC61za*-AWDX#c2R&_$3%msDnfh%|g8$!F~2>;7G0rR1{ zX5(5soTL3|H|i% z2nszsD5Jmhz^L%6(S=3Y8%MI)dyZ$6Q!BnN?n0b#*+ zV^)Q=i)6VS5Lbg3KYlHy(O%vW*X0xdoNzEq|4>fs;vpB0(04!$;!eqoNP=yehrsKdJze(EGj-l!56UYg9oAwS8B5YBZwndu+^#Mh>6 z*M9v@{vT)T*B6LeF?=HzCgCrBQ91qzK*zLm&CbjlVzsD zbDejVTD7QR1YnPK9_z3uQ9Ob5->O#=ROUUa5o5((wnVw6k$}-_5D+%1_c?_|p^2P` zUp@kr;KY#5JS3JKW}}u+LZ$7WK<~5@^rHY7G*j?BUGoWO3ZOhyr5MigjnzvptVzgQXD#7gO1>u7~0NM^7k)4q!OZg6z>L! zZjU=Y%}k)&nH*D-V-8u`inytS=2Xq9Cj4HhXxJ!cU{-X(D`^IA@MFtwTBQMjgoaq& zWsIsz>-nDF*?HYss{vLQX>d+*(Z2i$_vMZaTi@1JVfJ{(kDj6U|L5KOUjc%^16guq zw+lP^H5yv+ny|Wv_Z)Z(zCi=-hr5;MgK#TtzLorSyG1P}J$umU3B)ZXv88Bqbd_jK zbfBrr!`s>`I~))9POirX13b8cxhV~R${k2Y`1`6%Fa)~ft)8NhW;X$&`eH}r#)wvB zQ#K@>yYYF`i!VAUGXMv5U8gbx0`8;6KI0TH0`PCLZeWIN1^eWccd=M!5AG9nJV<;x z*U?M#9oQFLiK8KTYM;%X0I%jIisuK~^!caiPu7?HM2ocNzBW*}=PK=zKoPWX% zjR^RXD>qP)9&zk!I7pJxdVh5zdtCxlE~T(cS9u*!85#F65+p+Fx*2`xj|drvLC4^< zFa2~P$FM1>D4!7@@ui0GK>kzHrGf5C2;WpOzT2nhEqEBfVZEZ~Vs~^Qu z3A)bDMe+aQ#IWt4(#fQPlGo(Kw|LZo-NZadNZyOfATYfs6Uu{7-lW@KX`C0jA+TmD zli!k$p0kVUJ|<+af3$btK;kaYbW@{Kks%TwDxpr1;j(7KUtI57_P>AmYLu9u^G-Q?iGOjl^@+YM%`wPH`nNV3fu?r>uI*|%>^ z>OCz@Y3-_Vs11YFB@&)asK;>CKbY0DW23Hke1fTz&~w#TmVl8ahgB7Id30z^-g&8u z@FVvydMQ_I$y);->MTgxb{k>>6N~p%9=857o&4WPn{oTkAca(#(b_b0zn}|!dct8# zKCbo|8cb@@<4SziIytFSC%E6qio#PMFq$XQ5dj`=?mNJ{%9y{?qb{ZL(_UTN|b^|xuzS!D_ zhek$a{itWBwB!rga4-*0sPvd$BhjL_3=Fesq7wc=dCkUh@5^*yz(!iMz8)PWxfPeZ z#oMPTL7K0SKJ0EeNm1g)c z${b)wxek^CP{P8=;b+LDuU=s_(#Qqi44@7@&c%RTcZHWIN_v4o`zah{izIq2cWi0^ z+K(PXBV*S07YC56lCLiRcMFd7It^b zo?SWL;q}IVtE+pra@W+~;ldHT@If?#LuZHY1gF9U8Ej^Wcu=wkaHV<3G>)sW(>Yx)NWi)d}jV;%L}h+t%Mx! zo&??OIl_j1mK+)=7KgYT?8N0^z~F!o*-f}nNU&}3<@_Cr6Gu(vKLY|i&d-y>o>%L9 z?i2EF6N0w8v&ik~JyYl%dt=W4jW8Gw&4%q~DI27iD8Ahe-3l9TYEQhrHb)?^%m57K zkRYh-dudfZP_J%pbLico8BJWzV_-s`b>=AIb82;aE8!fe6CM3Ow%##34zBGQZqhVt zY&B|Z+je8Sv6G3N#Cdq>#Iu0)Bmqecx-!Pg159v5d3M%+l{j+R|hl~c9 z{kxJPYJ4g%fK*A}kk96+v#0|L^S(P6IvftU;tkE9;PgIzhHY|T1E3Rd`q5m4(X#3F zHOt--G$1@D#9zOT7 zulZtwf_ViK0QKl%uN;$MbCyh_6NbqR9cDQtZ~Gubg4mD(k0YYQsLLIVQ8Oc;JGCXZ zxZH#ZMpH`p!SK&+mQ4<9be-pRYcnp772C068^2FS5bU_t1oqS>v+u~}Kr0)YzM1%T zX#aTD*6O$!liJ)z0~m&U-GB0?{v%<}%bkLEG0**YT6X5QW1Y9t3vv`$j5SE_l>$Vd zCf7&LU)o2H(Yh_Qt5?xhe1U>c+ZNJ7D4O3kGLqBLBBdH2~95v8mfonscI$2!Q+obvJ2A) z)-XX{MO;tfp+nOiuid=$FGtnqu-Otcg)S+0|bSk4QhD< zj7bS?c77JDcO%Wj*KgZc2_6JP{kTo91aTBZ&of{oT5aj#F4IOSOt>{+$3V6Y(CB9f zIVMZkJ`;^yF@p_=-z!t1S~!iWI2H*wYoP*3P4%0e^vO#vtBb7>aGK@w@=gC4C}LSa zU#|_CJ_~vaFFfda0%?x~q(8>=_|Q$lpnam{_&dcB;2RjYe7Xs90s!4Tu0~|`jgRm9 zAuMkxAD=uX5CKNtXI0Srw4lIFg~WVo=A$tbSB<4bgbp963(PkMEwo$I_of2TX_(i) z@ZHXYMA{RkomBra&&yzCYsM|@7nVbmGma=DbC^=gZRi-4mvB^wp8$u8&cQvZ6?u|8 z%o)bQ*BCBkK}2vz4|e30oU<+#qLP;OqEt|yxZNXTvwbJya7z(iM;Kf0Hl(^*`z*DW zqxP7IEvcTCP)%L%HMD*IQalI`5 z$Zx(ZJXgO(o%!TCdeve>V_y{3_R0#2;gaNl%*ypAfd@1n=(gHxP4!5)Y)5%rq2|rp zQ1`b~-yc|I<$z4fGBR+mXEoNQV6%$(5&bf@z=Q?I82~YX6Vz?Qxy4Y&?y_9FF9{_i z%vdoa?*p-j>~H_(iNMq7sJ!#3_G!CwVxERziG9GtaPW+(qF+cTiT+N8+Xs-F1+NX- zmU=FF&aZ=grD{cbm>#sc!auY?Lh?|Nb3+pprq0?p&g_MCR@bp=kmoLKW;}jyLqZAlE!$#aURY!1G4y)C|?oMH_lLj(LL#A#@We4*g5#qbh!SRN5N)3DE^$IbI@>u4io&8kAl+pIg&6)QS zGot(_pKRjsYOB2LEm!)BAiT?jlbW~`wrEZ4AEONl$T}j5?gkb-2x<#PsG%ou7^BNY z|CMm@SDz%(z=2hrlW!j*(jXE9gZx&_9v*TTW~}w=;ptj^%rgu3f)vzeX7i$;%YF_* znlngpU1u{QRg7o;ntAV_@mbmzJuk0r@XBiouGFeRbR+BI<>E_T2h>VI@kqU+Eu&a8 z*^qQ&Yl0r+eMzYtmu(MPI=GFW5&Z2U%l_Nk5a>AT)l6h4(0gH?wS;sRD+m0uez+xO5vBA3{T$QTr^ADRkhZ-EkIzrVucm#i3u)L)5Y@rvJ z<u%aCXAQ4hf=T*nXXSYYDq*_8bT00RrTOQV<&* zc{{l}Hfwca7{XBt-r=Dma{Q(q`5SU5&7xPAGd89$3hEBLzc7x%3a&8-m#OLj~jl^)U<9W0X@HnzW1QhQNME4 zIs)gsExme|Lz{pPPU%%0Wp2wiwXsO{FsobW;4UQ{&lHc`0;l%Gf%GfT{}wypCy*Xi71CnF$Da|AI)A7yj$mN4SmW;h6eQ_w%)7b|5ylc}oa` zggHoBKfy?zxiTD?5`>KX4%&lraXrI?hPH%@JkMKl%R55*wD_6o&yymaXwO5}ylsMd+3Gi<^0d>v&LlRb! zOV;yKMU2A41*}|LW+9FF#CB&y+rqT$vY$&HpgRutbeZYgd96jy($Xw8-GQ`0yiaS< zTb|#kn8@gYpGb6!u_5O!Wzk>xKWc0gt9rW(k2k*~qCB86qPc7`ui#4@QF5d#p5PM5hbZrsG&kW;*@ zxLPjg+t;-y^9#*7lBf&)HPpp}Z#K{S$}}0tql_65uxhlU*PR4eg1w=zRCa1@-n)@Y zmWFSX^gI#!HkLQrin{1!psj8pwbVx^rJ=J}qY3+*@rv8}0Zz)=C}Q-kNP$-by9}6f zIWOX2x9lnD)oh4Wky}CLSKa+gFPxxxgwWJ^kNH?JsfcjY`m>4EcSf(I>iwdCq!18lj%d;Pf$2 ztjq>m$FsCoB3nmk&Z6WdSA*VNx4W6zo45llo*a#slM>Iq*1(RTUH!B_d>bn^q{R&t zX^?A%FYb6DJv#3-np?p|WY!iWs}>P?5MgmyMfS{gAZL-0D7ywu(TdIw(2#Jo<<=q) zT)84TMUsYuG!fIRUq;6`$HWxjOIT6yhA!ZKbN_oGt)KrvX zai&YzH}$98xq$IsC#I>1b~r9K{CESy;Y5ae#`n8$*yhWeYkMk+mSJMM+Q9w^xu3$! zLv^NaOVqI$xg|cqYD{>aQsTAy=+}pwfl+m4B{R3uf>951V&)PWcTb^GD6?d+2`ZN)7|RT;D}zu&G4wmu0J+Z2uB3}|Ln-=M6oy@Or8@%uX+ zCL5&QbIiHxytwH^549{yj3|stoPgM&b`?cCuu)477h_jOc_hlnmvDAmV*d|L3CRoY z1}{UqfjA*YtVx_FOqi#meV@$pZd`*hqodF0^~BumdL-WMwyUMu{zS^ooZHCOZoihW z7MsQOd%7RQ5@fUO47qDnkvWj3WBR%L!`{l_N7i4x z&|X#6V{Yx}_HekMe%oo;_b{1|=P!yN_&XEV+o1)Lc0Clgoy+%Dr-#4905W{CyRS_7 zJ#Rz-0Z2Ma=AV3w0S#Cj-F&{%$MfvSf3p?wqnAz^x`|Ie;^j$K)RO&QMkxp#TasX? zJr*37gNGu?>8H_E#v~XB#lPCVZ`31_v^E4d!Y0vw3uXWCObY;*on6CaI~8O;+8KSL zD$`{6X!`myCLt=UF5mBnUb|#SL5v}rPb(BFON)aa4i4+U^Tl5#!Z_{fq8+y8sE1UW zro>O_luJ+iI4sJ9B)-c|5W{3jpZ5FZu=suRz7RZu^|-MY$b(qV$!0HXkU>uXv z{|36qWJ!A|=mKj$m%{vh#?PoVldd>L*F6ZH8VWnECPEm$PY!4YfW2j0zXI3~U(op9Eq+T#;M@E+ znB*%vL|5a{d~sbE95O9y-qkoX7i%-pO!XZSaho0V_DX5)TG!JfZufh)&$WQIdddZX zQD2=5>hQS1go#hyAoCHGIXeZLRAgWoA5MoYIqQu0g3_#(+5$^{P6-0)5Ghew6FeiG ztLCc0>#0~mXD8g{sTc`svm`N?zYRVcEDq%}ahiy6aHN#*?dns_z%%n=qFRFC!~37_ z13J(~qYc*xOsh5p=VaIu`kzS7w5ORY#6guTRuc4M&8E@q`|w=3cT?y~yq0lyGx^oi zXnA$D2VJ%tm(Pw4on6_Gd@Ywz`-6w}VQW(I}{YxS-dPmTSb!;qr#`_G`! z=fmd^cK0x!YP$7j7nqeoPeQrw8Ot;Gu%5~=UkVGMYbIIPIi>X10G6v9gG1+xtv_r< zG~ST24y;+ej8PO3t+b zh{V(fYb4U%dQ(u<=MbHGnfxk6V4ZMYCGT_PXW*9^9+Dd?i)MeAPHuE z?Y39IN=iq1il(HUbOMXPH!hH0$W-sg=cySrjgteoh_rVqnHg-b19^Ct?VH-v7Ix|{ z>C$C2ATDakoi<;;VHSE(|7~qp2Lc$+q?}8 zA;vO|jV{M!L}Io(XTQI(l0=`d%D1*e@~wP+=896B-i&W?Wg-?U#3^knoL?DbhWfFl z4q2Ybmcu}uUr^`_AV;or%CGixeilP+5k=ni+SREZzT2I9cz->P^xZC9;9q-v4yt~G zzXE)4emY~Fqj>ZAD9n96sB)@=($Cy1W-*Yx%4`_^AqtW$5Iv4|jwr+UJfOS_%yhFt z464PV`w@lu9t-bgPzN+1<69dAG-Nu(rq<=;opVfHXhm~UcMH_5g4ju@wJ9@WSDtoN zwjQicDei0GadBh`Nvzl+Ex|vll40{7S712ls&*nPIK6HGUw%_-+3gszUTX8DHKxSH z#(s-rj7ZTPmN@eilWuP3N!akehKA#-HvuP$lxEwHn_oLZOx%8K@|2SgX9kyF&}c`*HEA5L(9DL=QF`D@O>96;)#~** z?k<6}Q87+M-H?v2DZbnxF3Z;|3MU}LXl#%+wKl&3(mGSL@pIIC_$zWv%IGZ@dQ=9-y0>eY}VXfNXN2yJ7-}S%Y zARPHS^>Q!;3|$U|@GT>G4v_iJ%upiI_y%H66sV{sGXBu#&3xTxC|o8|m_b09W$Ti< zFeADX?j;JyG*kNBSvWhV z_-FXdhhBs$2HzM%CmA`ALGm~|Z#qGVgE#yWM$&>`0#fZ1;BS7uv0`bbk*+`{=vBf( zk`vN1KswTi)$nL!HIeZ?T0{m%xK!8|OSNcI*&`|Kk!nWhgCE8W3P$k)KW{YeL;8kc zzIK)=weFTv{GyqNxSb`lTJ}UPo>DP7j9{TLkh)ZHi5lDwrQ`rq1eA8b#inaTKHb&X zEoJ6Mplvg`927#HyM3UYj-_+BUH@#La0|*KPd`l%--NQ5mA@Az?tFIOz4vlOz&1iL zK&&S*27YCkdIPs;ex)8YD;9j!I;OZF^|Q{)@qdf4)Me)}-Q2wqPZ_QXa=KqKkW0m} z!<_*x>ZNCfwS%@s)^`jM7UQ1C|^&QprlY zS5|&D6pEVt1NOqy+$n(lGg$VN@Z7to=EGFnK8G;!?PIeCV+nbEI#G2MHkMxqCf$Xt z7bSPLOyv7#_^*k&DiF``V4*QdV!`SG%tEUZX1dKw0jkB=6N#pFb{q6DG57pPsL4M? zDEJ$kiFG~p7%VK-o>kRKgayBrkl*GZ%}vnK6+KoB8OM#2r(k$I&EnA%KHQjIruwGN z&DMD6F)A6>ep3`msD(6B!_Me9kQ4ZT@0?pcTorA@q9Z)4#Vo{su3pxVp?oaB<5Q5FgC>f}nmBlQNm% zgU_(^jx#BAK+POqOT#-OvDf+Jz-o~h$13-~?m_<^#0j`SV~GH$EJaM~=5d^8s0-Q%LNNj zxR*9}efE0$HI&AF6)yWKj^efV+>}(E^|0kbXIA2NGAO>~aBm&uhn>iJmdfHS&IxJa zoawZU9MerZx7B;JsWSZ|d2M4W8D;kK2j$mg*be0P*eUfb?3ynCLr~xXX}N{sG#@7@ z3L1oGotcHW`V52;=6=oY5$vq@lBT#U!T9DL&w}Q3K<=#m#P^Z zurZXiCfa&x`1qt0IvhYqOb0JHcO|?6<$>jODblWyH>1&tYUa5PAZ`}=sx3^@1Bdt^aINdzw@u|m>mi%enD4X z@1~nT{57R1oy4!I>|flyo*a?wyM$BQUx_jy$Aj~!m#~o`@9;;M#Lq%CXJ2Q%Gt=r~ zW-{+ocI6rMA&mkTFiy)tLw6)( z!hFMxht?Gxe%ByRr)E^c@c1m%DYV!wa1=0-x){ZyUR802BQ9nNgMdd~-Rf9LxpQjr zaDXV4hezqHO#OU1fO&;C%F%pB7$}Hd~W$9ym zv#_A5eb_c>Xgx(1#SJ4FHz_!2Vh(F#=6e3kBp6n>0Rr6hp-Bi8vKZdp;vZi3ee5wi zx72NVR11ghRuQ|ORTj~fWqy^ezx=Y~W4SJRHY%R_^H#ln2QqP`@K5jJcV8J-J)nO1 zJd(};^`3PRMKz*D%4jF%%Hwd?i8oJKUlgX)Kp^et-R2)xUD zaQ7WE7+84~!#-;g{l;J->pr0b{EWcEQ{JHA+6}|o_}Kx?js#({NnxZjG3P&t_(5m% zQ$3j+GX#vh_qy&H53jEj2uRI^0|wvF@AgGln4ay%J=(*T()T`kR8N?FhS+#&!v>TTrMv!vxwcMedlrqK~DRai?bL4ooys{ zT1znQ9=2VL(7^xk0?2QE%t*y8T&?WOpMnpb>4 z=)Cj2LB~+U#qmmEc4^4kk=@X7Tbj@^&|o3Qo;VeGC3LKa(Ykqp0N?8;6s)uyGcUU^ z5VX+!R7~rusat5o;_>n3yC$%Wn86ci+bb`MY(6+!<1RiLYON|u{qD}X+V*iZ95^G-m6cP8(E3Kn2d%u|sR^b$L>(ceS98 zKaZ+aa%TAfB90YY*tl`Fr?6*M;MV6=<$>O@zi+{16Vq=s3rP?4GY)^&fIK|D24>B+ zA~Sxu3wMI%jk}gyGuiBa$V59A50ete5x8?AXT*MM>$^jRvydz-abK@?`=}L$jf#qm z_|CMm4XCc3Pcej*P>mT{$WC>|xAcQO4GmFosM2dcNQ#brhl=ua7Ln}E#dxnBDRf-& zoLAxOj!~E!@?_){wD)b7^T92N)Auwyy!;hLC50l+nF}&iIBo4SXT)L|;T@f(fe7d) z>yX~ge?dF_5u)w8)Go{?cG2vx2=Caglq-tgui(T-92d}6L&>_=8z%}reqY~G04 z`<3p+YiCbhKz4dtYzM;9o_|-%fM32yGjXD)RUjArk6mRUks~MOgCBgPIISr-W~sg# zCiR2fZ)bXXYzBP+ZUzPhu`F=g%cBnGt6CvNCSu~jCEal5xMKaoW$i<|;n6a}?wV** zk6I8Ug{Cz;%gU=fMY3{(wW!7^tjzdI7XxrZYOvrp5 z8w_WKEX|Z_7huXSr$q*+cl!{f$)V+e;AO6caC*U|T4D|Hc>m?sEqTG0siz3ymF%2S zZb(1}Xl0p$C#2#x-LG0!1@?6nyG+iPFEQ?|b9(G)0S&)E?GFMXn;2<|WRgpBuqFB8 z*57|mop4(?cl1K@ZQQF`>S9fBB}?K)?Mkl+mLCLihYwOcdyY=W21ev~x^5eZNE2$ifM<|n*^dfMH zA~QeQ%iK18Q?(Hwo-A2zU6O4RhQ>L&@r-bLVh=Zy8-bl!ui+#7l+lg2b);6vejzUs zeZVT6DZNu5D$wqykZPl*=?WrlY4$_}L4LkYhiV3?&sZ{SB=wq0HcK7ZNSI$ZVR5u1 zWYl(kTJNzg{lWa(sdPY3^WA47Z_&JZ>ycVL?}VI~#2;{OqVZ2%ksM;2TRGI9dqy*C zPLba=kE+)HSxHKEynphnIwH}d;B+Vq?)qP+oPQDx5g}dEnqHEof-r z7(A`|3tc7ab)d&CFh;l0VnO6vxuKz9+<=XO;$p~z7TvBQ%pXxAYhf1g5%4(;6U&RV z8wuH)_$D4F+4`8Dx;+)9aBdAvZLu!7I0W_+_#Utt&eE$%=LX4oO;X6Py3FLm{6jT#W${eqL;Oit zH@9-zv+=%TFNTuqGTCCKWRaHpLjQQ$Map@>L{@sD7%=V;)=G!}JAU=(n-f~A+rp5dDi z<5>LOSa7yx7je>Fr*Y&yue=x^CD|9^hPZ7wYQUib;tsYdNTi_8DKFbfVwxEq#F*gGy|YT)K2I-51b z46$2gFp|PijL!#;t0fK?yXb9`b$hfErlVuxZCNJx3eFxPu8InC78Yi5&TWTnBu@T3 zYK!wpadA@oyaVQ%s}N^mAv7YyoG6i0NC0n%($tmh^JfiJ+M_kZ-ZdfO4r!nFU0YpE z1>>(IRh`<*4%%e-wQm}~zjHm0jN)IXt_Rh3M8@v0iHT`p^;X8tWPUm=CuVp>-p0=x z*ays3zpj@Bzm3%XjTe>ux+vO)i+K2xT^xm~G@4 za}muJKQl$P8gp);gY%b+7`iwzRuo8aLIqKp$ZsV>i*LeA6j#s?Z{AK)N^@}Wjyg2e ziA$ME61h6zLQfEh&kd)bxjACCg|rd(@+rslb<`6foS(qILG3?Ebu4gb2nBLYLtpODV@F|q z>1^9u9Q%qp9rdCbOBmFEcZsJs!iD=u3uo_uwd<`{X4qF2hrhC_TfBFr&yL zILM!a=c&&MS(!;6yFMpJK${!2f(DYhK{$DC9A@;)V-xA|evd5-{ZT}v4cv3)4{YK` ze~u+dxV9kQsP5x4J@^a(fG>DECM2TGB4S$D_SVLsZ1v}X;%YAv)A5%7pvg?o*Sgck zLADdgOI?aAKLfsH`FoFBSArmZ+~@XPwZj`W*Go5>3F<7(CgHW9 zYYb(8sJ;X-VOYrZZ-?bnInZAl8W-h|f;0i#n5>Ime!G;PR@XB+w*{8CR_L-~Fftm< zf8jn^_giTj&q_h^ds&k4o!5^$v~k(%dA_6I(}7t;6qHuNy^TuH->`(bIZAdRdAKh8 z$nInYvny+R__*5q$rS(d9@|7;A44_ROI$?R&d9Nxuc1p-Ksl*wes#60soJaIhuu zk>}La!!N=N(Rh=u`5xJLqMvO}#cmc|2Q2!!%z()s%!W0Y9>zaD&R|E<42dn%5+T=@ z6K`R;V+8$-mTxRau%0$(mT z{>WDNHfl$_-_ri5S(13;cYb+0AaWyy2=GNh0v8ehIS(C^^$4-FA71`)dv1;rjxv2_<0?m#c9LR7jR#vM!x9XEo) zr?F2q<4Aq>Xo~#@_Vc-~Q)AXN6yoCNZ4@BYQ+Z=Z_3t|;waG4<>*uJsgXtGg!E96Q z#4=!Z9&zNj&ThYSkxv>eL>L6)+Hevbp?59%HJX7d=x}yXR9t+`fS&b&L@V-TD0NSZ zOpKYaHYUn%3f|kfayYtEl92%o+aD=}3jBFMB$~7miESzl&c9)-QqibGOcDVq(fc0q z;$k&gOwKiAmmw6_$5MU+eqqhd;ET}~hV1Ms*w3B}z&QMuc_^D!c%(56WjaoEv20tO zAgm=inGy#6!N~pt;PjJYqq5qHM6p4kcFWOM_#jdjB13+slT^W%=Byn2D}tiAV4^Z3 z6gJ>}77MT`D`AB)mPQgD{n+njgYu;69q2jN4PPu%Jr0u#a; zLTPH?h3PAkA`#LB1j|LuaOHZ|EfD4kq43jid}b^=)Wd=Sn67i-E)1l~+i=||%l7*L zz@YI;YVaWAKZg!RL>lD}Y?s-K7?*v?SKQN`y7cy~0j^KgVrJ{S2}Jo8q2LYTVZ=!vS7RAliG7u1Ca z&#}p2XqPmdmk2pWQUlygQPc&Wu&BqR;+DdbT{yaY>W26ag+l?0l1D65Y51xc7%_jI z(gAI>&j+Ih?NT_-fdt;+cq10Q6G%k_cd^5yqVp#Of z=rc;Pv|Wv1fqB5zyP*y!bGK1FEtP0(nt#QFYgBzAcWfrOnV0@8&w<7fRHMR@l948h zg|f`Rz(6ktN5{Lk?XHVwQYtA82g?nN^TD=W^ydE`9>XzVxu^l$Z<>DV3(|dhmRXhwppXMg4C#b zsJ4ixQI@BdB_;5V4zCs~_QY?LOJnTKCOuBnNCmdu`h+^{rR=HWNDYqdN*|j`Gn+&u_ukehYL5h?EoUGUiw)%uc*sJ zt0VlCoux`!j!Z)t0%(Q?^PN|x4v~GbjO{Xrg&ty+7HoWuP=bVm+HWOeiy>hok9ofbDc%Q6vkc7EhoSB?t3H>f#mID9x2FzVurv2inFa5|222*tW6 z4|BmcJuH|Vkqk^oOFWL0Kj1!@B3U(!zu`Jxe}DazulyNPhsU0U-1NuM&clqGOWh<~ z8f&Y4eSZw0#EX*sdD0D9r+C!TCCSSfB4`C*|1y3_gbcI@Ggu^oncNiC*c`cB69CJu za)aQZUyio(J#5JwxJR9p9RD{h{EZNx91%hT&KGX>?gb>Q3z^w`2yV4=?tXthd)f4Q z*tlSo@GMiC0<;;+s7VczIq-gAh(0uLLp{StXHTA;q?Z%^*~HF?c;poF3`tH(IyjfF z1T|A}(r%}Dxxt|*~0PyBHSZc9ay91rcsVeHU z5IJ!qg*(|BhP%_XEb8LbiLbkDrR>;+YzYT1d#H&8t(;j_EU$*2<49fxsJ4du%NPwwj#KR6m3ZVmU!!;lOvFx90Bzfb4X^pEg_XKmpe7ebrgt{B2Jod*Pa9Dw!b=a6;U8<@*usnRz%n;;%E- zY}j|=SgaBrx}3xcrH?;Be1(2bm`h+)dhSPEWg)Zb?4>SK9HpX|9qYzoC&NCFd}%j0 zSwpc=s78hk9L+0p{F7qa=l>L@rtKa##>HzB@=$EHBt8hZ7|{L6Li(eaFaKmc*IwE2 zT$TxY1MMnk%m&Sb+FUXPEBiSi!`4fx3gN8-V{T(u=gAAh40O@~fuAn@xU~_MTJ{Mt zsBC3_QDM6`9X?a*!cm{Bn%+Gd8trXTC&mB!QkZFh)0onUn}nM^Z8)5G?8Lik#5ia1 zc|E_5(RaU&ZukE3ASENyoPZ(QJ63ROfXfu|doZ9IR%3t>&_*U$~Pt*5gQMb1KjN?Zq zqqhi#=$uh(s&2MkxdAvcTdc`M!1O}6vK;i7I=Sp~n<#88z*+Xd$u>s2E*Zi;`|=G@ z+eXg-X5dq22Je8i_;Kw#f~u4ZtCG!;&3y3-#j2Yf{PQ-M63?QBddiT#8}FCw?!z{s z;lCM25&RK%3r20DTGaf(sA-M)N?X0_=S2nocGpXM3jR-)uQGGa^NY&sPr$daUrn3> z5GQ7?dvC}2;&)a`=qeEA{OXd(L`bmU3^GHP8r6XSa2^c}BzdltiqpjoV^imuOGMqm znFl@uIFrv#)Drm!sY%r*GtV-0fm*gtOj#86|w-yPs$5-oEtjmgS#21jucmAO*i?&7{Tvq zTrJy$+#*YJVKUaxmaZiDYddS#{nBn?xe3ejs;S|M^SO_Gr|a$^Tg z5(`&*Y@>W55Rn93l?E`di_GVspck&!l8&avNDpQCIIuB`Tq#JB4Zk*H19oNKLf!vA zZh&gb999U|!{HkqjgZZ`v@k=U=3&1O3-_KgVLh(wS`w{R7`xT-HRrnX5n&dWRzAWqnFt8Oczh?%v+N({kq$qS1 zgRaXW`KF{<`25?Gp_wPZl}@L*es>h`y=bq&X-$&Ltu89#{9Yz|D!=#`w2Oi@!ZO%7 z*W0VE)^DrC-Bz3!VVLj8D5F z+ZaX6+mVWFU%KMO33UFh@#`A1G65BQM(EQ+?p9897q?Oapj`)8zpC`IhQ|8D=n1d0 zB2}g{Z5A*1O&DuBwDG0Tg6?U}_l3`mR{pFQfVqHe3ft znEEwW5e&FyP73z2JH$H0H$*iu;eaq|7GY{E_s#D~iFMisS0ihSRGnUA0|LSDr{MDO>31S%)R#;&o6J^Qt{J7kU0I8EI32rUTqdr zR9lc}=cg;WMO{!I6KH&|pmi;Wb;TF*!_u_}mD|fHEI6HQ0L4?=TCh&99dEvng8;hcd5P6M3xl-ex}% zM7{OCfB7XWkdNbP)OlCiuE&F$0oz?B3UN}cF7k)Dd8~EVET9|vpGSiY))aR*P+Ks; zAm`NE*#HM#HW#Qqt0Hc;V3r*edo%yArZ_uQ3IwZRhukMLhlG@DuZ&Wo-PM zPwy&6PSj_YzZ@varOUkM&20TPZ#g(~ch0pFPMlLR&>9lThYSLPgqKs_KK z>NLxF{EW9*s?zg|{^I$43qmQ;ALkqZqKQu--Tyvm0cZ%n9?x-?53B(9Rbh0VClkR{ zQ=$#uBbb^vI`@ya2T-Wm|7mP$YWlM;&yA(e9zWpVW;DJrMa`)0V}{68Qpx~M1r!Z<1E=gCLL8(9*Crqk1KXKcTJ>ILP#IE*y$0_WW_63 zJUJf+Z_`nUK_c7HiAhsh4~qO4UWivbk{+!Pr2tl*pkkiG z4Q`9XAbeS1E2-Z+pp=YtsfQntju+Zi1W(ED5lX8pV1x^BY7kcSxCu>6&y@Z zb{X}AhaWQXo-JgK=}_uAS#_WE5Z&E&e_&?@QPV{sZ)oqnXHxUZ4%}X)nBUl4bS!-1J zgbv8dJ0?e31^MF;{6BW~k61VRHg7m^GJz*)!UO4hj%|fXu#1Xf@R<^}IrIqPq--zk zK==8tj|Rn+f`c@)tE#;ld71)szI$VvC> z0ln7U-5vM+$y_lZCFQ2wS&EIadtF+SHNUL$fT!4eZH#OU{PpEf`a*P1q|4|i&T8Y) zSJ|}baL9)<5kxP?Pw?2w$bGgvPQRsQkDlmgEY3HyMaU77V$(6DH5qP>q&4kQZT@(k zs&iWV96=ZQcp#<5?@~59vQwRNg*oHve>!Z*$}|Z`@~c zA7q?@!*^m6W{sMAsh_+vJkbIb*^ZF|HJP3L=w*dFBZHEU+Z!!#e*5HtC0>*C)24uw=HxMDK(b*vva z%(muv0Zgtu63RIA?QH}+ZJP29L-oeUQvHCEzhVC#ag~g~FJah=ZdEU3SVX-xmEVcs zd*`LCoJk3QJ=$g4In1%3>nHKTEXWJqvuG)KofE_0yz%g*A$J) zf0{}p@EK{}WVB_eH0JPGKIxNHcw9C-JYIKT7oAQUU}St;hHgZ<@Jt+#n?GE3JkELF z9yv=SW2G>jHJxFH+kA012f(>W6OTBSY3`A77ubqIBZwA_hb#Sxu>jSS^usF>eq;CI z4XlFZnuDWR$Y6=^JYd5O<@z2ky|&1Q5p)o!o+9mZBNq(f3?v#ukG7JPLj)rF2Gx{`75 z(yT~c^YLW2vA&2Z>>hS2(8#60nyXGM;9Dk}%ca=nK1SVlf56Celjz_N>+hf^Gkpl5 zeyzfY%w)Jbn8zXw{VHod5HJL`vut>)$x`oOjZwi_U$QG4>#$E`#%l zw&JYtfZ*@L7Knj10|?x?7HMR2-JC2~RD1|~lMm*|_F7xg*mSY)4jC_2_iAF0FM!)3 z(eHz{Kxy;WO>+KWT>@y6{TbcegP%Hj0}FTH-(BjJc|3)Yl*!S*S2#rh|JO}0OY*fP z^&?ohgRh2TBVHoWDladmR;^I4-8)RT?SiyvuOw5-Fu>a7wB7IyqoT$g@e2&Ft2jNo zDV~{@9Ej4rSrp{*s*5t=XNzb%EcR**`hhTZ5rp&Ak2`>1szWUAVWJx0nPGbsBT6FB zrM12=vB6RartqlX*kGV-A5fU})NgiG3%}3OGHNy;=60TNB>TtxgRVl>t~^dtT)?S~ z4N|jz{svC9C-EUzm83JId3RHwI{Ee@{nI5*;YGRtFw%SV@o5ay(Lpso@r&qP<>wBs z(i5aIeCU^WQ27H&V1n!4eVY)2>WyZTkj#7_T=!^-U0nH&>?&d_;KOTIx=%i%s$?!#e}&hi6?*T{`FF(vwCbe z%IG}HdHLk=GWuj-QY8W7C>Nr^I7$gZGCrAVn_Qrk zPqTi%zC+teyAE3&pcX>`c^7w8-yFo3j8`lSL^8%4SeqZ*aXW*xLxugz(V+v#*bb=Dle9@U&? zmy>`~SCm{ncO?0@t=Vwi2ihUX|Lc&MX*|J~!?Yu)XSWLVvcDa1Bo}6m<@u{kefWK5 zzPqc--E|&Jbc9lUcVTC-*I|Dh5I>yj?nTMeSrsLP^b}*ZtFf|v@;gyv%qK}*h zDu*gAsN(ypsoIaRPnCMesp$iQqR&bn#x9)aQg?+LEc+FiR;Cp4U>4_6Ajkw_g2-(* zPBRA0vRb76d6fa-pS+E{4(-jCG_z>DhUghJN426~=I2`2pU+Ivo1Z$CuZ1o@%SKX~ zUY0^4auN(oq=Vvn(z?ymnqavM)&Kpnslh9T|39j}DlD$F=@tkYf(2;YgIn<67Cd-x zcXxMp4el<%T^o0IcXxN^bY{+c|IG9BUEl0oZ&kgkR;{XS3u2zePU=&=*yac`wOX7n z?*xMo(U%E)=GWzi^TySwgR=*u*f@LPu%~@a`h3RLPj~6 zxk&y==@@g~I&B_1>dnF&T_eFh!XtjE--YuRs333C3wsMm$>~1Y2Lffel?V=B4lPs3 z%$=nHGH(k~_slr70LX&K%y*HMOruS}2u{@(C?BvF&llLsgRU(PEHkYbT_3Q1(jKIW zT4l_zaDLdHkKh#)qjUvgPVA!z!)c=!G@htLGImnpjjng`x7=ihTdd#D;C(Hw0yyL@ zlG4B?aiR=g>Zz97e<6Ck{fcDfA&Pv83hcef8hh%Y(jMb#65PWZO}o|Te8IF9T7%a% z35GM|y2V+I|M=uEV-y*2TW5bzQ}g3E zh7N8+#09F0c;w}LDCXB(p~P!7S)jp9g^f{56=?@D@n(MDKBtq(k*ecighPduc2$|s z+y}{-CWgyHRAA~ix}blM-Cx&sP83*4Zp*iEU*>mB{rOebwFay8K_uQK=gR6UT-+Vw zxHwE{k|2iyM7+|Z?I0sdgvSKAi8Bx{^V^KS_{?Dx!N%#mkhJzPQ)?oW*P@{881Zw^ z7aZn#>Qx3kNCaRROuoYpViJIY^J@n=m!5he>8I5~glGK6j>K_#YR~+{4jcV_v7Q<_ z(!%s^TU1>!q};R-f#3-$_H@ft+tlYl-@3dFWWJFzHC46g8Jp|%xs@dZXCi(5;HD!&an6ND`5zZingQ(JE{ z;QN+8bK$MMaLmqkp&~3vi%I8YH#m};*$Skd?d^u-eY`$c!N+0-JL{rJN@`Y@;!tYI zj5K$NrCFF6+SV@YI`_c_+<`SksGTUm09I`8wJ!2m`NdU&ukJrbRht~7* zwI$Cl0Zt0CrJ=en26pr0JPKEcWMd5*_^Na2SnZK!*ugA|s)Ha@oaeE2|q4_Zwd1AhBt zs{j)(A$761&84z_XAb;#Nk%eEl#e68l?Vzw@UW?t-8Ic~Q1cWocc{jp`5-MOO*l7D zijagfb{M=}$a)n)T5y0SCI~Z4it6qie9%f#lNHNK|9EO9ya6kobg>%U?NV z*C!v>7S)aeXRk^whsPm$-4`A-V>= ztWP&AA2)WyL3k=B5iB8&`83n9VQ%?Ke^7pqmt6&AKpE8R&y`&Rb^!(g5)(Wsw;peH zB#=CAKfXRGo85d8;8kn!LoZ;GuI#;4svBbZgUkNcxu+oS7@|-U)iNh73!9Ac^g3zp zQ#tWiTdws*#9xzS1tR2BCR?^PQQx+ap;pDvA9xc@DRLuQ)Kq^yWHlEaKaKHiYK735 zm&_Clr(4v5=I#{yILB^&>$udkN%4ApPcS_cpmun2DeiH)^>)6_7pu*%YN0K{sK>;a z4K!!42vn;x6SglnK0lKH^)zEhM+N3rT@Vm}b>s#e)!0w9ZF9(#`OHspwi`63%1*)9 z$BP?jzm4uaXBwUnvTzF3#DEKOOMV9K^>F}MRil{{uSyg`D>>Vz237f>^QC^WHs_on z4Nh!={o6LZD+)+D@+`{G_RTuF_Me&}$Uc-#Esg7|3*T_>H@&{gG~^UgW209T7dbPf z;Q{zL(rN`469kX~{{MjwkZzy?RgzeBb^9Rb;HR58t(7s!olTABIVBF<7fn2n6TYBo za8@DZJBgdbhQzjoVP)93BA$H@SU5EIf2>#-vU6O#2%NaK!i28B%U;id1XL;`(|S3gdfXgY7MED&b+S1XKJSGW;GCUGus$?;+tew(_m^cf7*jE`vCj*M8ZmD1NSfj+HW!m!1v!miRk0E8Ht} z8)Qk26{N+yp1TvRhUdHOUFqlgFXeDufgJV-EL`)uIKNw!4pgI4{F1$Q zSs6~Mp{bf$kY{TSV)r(+QVF$<6y^Dome#d^ln!pMWFK8FLt`#dXAZu)w0aC;r{^}y zsGb|$Ws#i`Jv#~g|HAuE<*ge6Hr~t*e7l$r@`NzkDLgtpu{N{FbFT4;OgJgn?uDV` zF8e^*Lq4IcjA!-6>^BxaANzsd?5hTn>6Y?vItSU*01A6t3dFJDm!MH0H#Q9UN6M4< zp2uOfjAzZn^xp+YM4}j{oDw8`w>kKN9Mh7qFfx|sh(8s7N(x$@`&8;r(9^3?f7L1d zAncU?bj_;TuFpBExP0SCPhCJ@c18dNj~s7gW^$gOd!!sKm9XPHG;(5mw0?TGrS*EG zrbFBqNiXLarDPtT_6P0n&q(aPXbE8Wb4(jyxZ1z~~S?mDC8hB1gfr&O>907ntvRq7S5+>T)NVc@}LEFF8iM2gihCo6+a9T5%|lr1ewb0y>O;AE4sRdL*6hj zzMLRlT8LEPr)FgIbYf9`*<_(gIBSR1-N3IVYnOC>GG&n(Fpn!4cGi*1FKT`tMm6R( zgnFD2vZ^MtE7Z~`i}UywW_WG@u+tyxevj9=xQ-lzg=$^RfMM8vu%yZI$V`|ZDs^kr zz=T68c-*6F()0qSK3pY0m#2r_RKFuZQ9wREwn#B6j2h>&8-E~SVV0O*bl<`iU<^n@YEOrGW%BPRv@UiW+ zCtt8#jI2(^SYwt?3#Nr&jCp&mzSQ}|5DKdi<&hKCkkbS577?11MPPREqQya{Il+tp z*weJ3zR?o13%!TJframmpx+@7Xf3-{-*zCF>_RMfUw$-IA5w|=Po>RCTxmS3=l2P^ zn;O}#LWe&|P`|ec#cB~ZNJb^tEqwnO$xAqZ8(LP}mLpQl7;WpTk%97W#IqXuN%PCD zfLb^=Y{nc`)|eK{S$rXv_rcqm53k4xP$)`^7=3r50OWfecc4 z!+rgsfq{XSKDIWS@eovU#P+Kp>N-bG$Ax3rvi9(GkATVAH#A6-(z_Afkd$v$SF?@A zleLgTA?^IPzZ(Sm+hGJ8kk*@w-F|*L$^jieUOI=(+nDw(UP3HAttRL8C*Mxm?xp1W zZp_l5{EUMySs{dY=~ii8t)9*=zIAqql4tX@q}wL$(=TXBgV6pJxyu)~g4w*pzV-)L zL3shKc7ro4wCAKRWO`1kF@J>?2RI;KVWfJCaHl%!*q6e>rU==UrPyiV@Mf&R#Hj(? z{xv;H2KVD9+-bkD&e_=ng#~1X-6r*8SiLP63=Dx%UV|J@Z`a@T4v0r$hS>wI&Vu?anfY=9vC#nb${D;}7tyN#dw#AN%>^9FxO? zt8fd$hU>?WF$O}Tz#uD!-2zZbq-?b#y1m@^2l}LGNwV_YfZAcy1LqO zMWXPlESBp%-0sf|5?666)EZ*?^t`L@Nz3XUdb^S64Rv19;UBSJoBhx~NOl{pSm|+- zw)Ucf*1Lr~yp*f9xb`7TlhJWum(u;fX}6xunXR#sRj^P%V}t`h7wt!8&ZWE{;{NYuDPec_KA)}qb_CEG=agjM}@TuHAn0EhWS{$Kjtq?Ig>RrCqTdzc#Kn>PF{uF*6vHm@n8L?&VBta7M32 z7ooNrTXL2PtwFV*sm^Y9A4iItX_x+XvIhyEUEmuRE>a13f%+o@`0zA#3_-I=9LZ3$ zP&tM(b^C3K4vC#;A|ZoEG$`_HvMjF*kh!TmJa^bsMoro%{x;Rhszyt0lyqp$FbB!? z^%o+c4Yjf&VHEsQMP_vc{Mr^5{(Zz=)B66PU@&(MR|Gs?EJi4 zS(*-F7Vj1j;}q2KR{A(y>WdZDAXZeC8*k4tnv8N5D_%&By_`ZfkiOh?r$B_f^(Ss= z8yA<&8o9)}r+qEJ$Q{OuDBVw?Vg}U%^5QD;YMd+`D3nBin{vb^^+Ddg%vh(pT^znB-ujPdZn;W6(Sh;k= zeEfjCO2=^hDo$=-0}y+ML6!6@=2cI6uTBdFY4aS3X;s*O;*+(y2kAl-4rp?BC|AZo zXo~UqG3b4iIq!#u#6!=wn+{$09o3;iH z{f|%R*XFy8^S|T^nzI}v_ZmcApIB{O3FpeT&p9EmLb#jw^^M2I%5|^?(O4s`RT0KN z5gXnX>Baw4fZo=%JnCBB0KSDrO;nZ)Sv2?7KoMWYmpkaa=6cp-1VwifpX06-@&xhtpvZR9h*<3cs$;1Bkf-Mq2LW^ zL@8tlx}rS;?@O~zUD5c4KklZ67u+Y7r!g1~rNc`=G+u=Y6|P)vdBU#F_hW4<$0a;e zE9IdtlWQ27kqJ}y+MBnJYDHQ;HS${ZwOW4{XdAlkB-s8AoD;spQ@J5c`^p1%QSvRE zJGOw1Naj|{#e|Hyte0RoSVC$5{?D=SF+r*aU+;Xc7Yr}2cllktCaHjc&k=PPOrl4) z`q-LCk*i0iZiJft?Wa_jS5?MPsM*cx^ytsUt8Qbx0SoSfH-Z&d9qg)-%3PQA0=C2L zUf!%9@*nb5eh&R$K8WIRTE&G=b+Y@rw0Mx_E4hxoN~@82_Gk<^7=B*3P=BM4t84gx zo?mrwo3J|=1EjBz{<~@W5A;(P;8Uq~oNE`ea9%v!_40P&@VB%JzF0bpaFK z;cw`7Xv}Uq8rZ(4H<}+Mk_=OnJpPS|YU$H-|Ef%o7Tj0fn1m?J@9G88BBLgBNd<+S zC=*t)eEW?^S9)xQx6`5O1Ft#z&CcCK(c%>)Po;FXM~?R?r-J$-m%d7YalW77w|p$) zK{iagpdgHv2;3!HFpP$@)!4Ft8!sJM;p%I?^C|F7JZgmwxY1^ICyH$=AuV3X`Z{-w z8H$vayW770y)a79O84-gR|gnqo!G@}_|Ec-bFS17$XUk}w!0Ccr*Kh|Wvo{+*$ zrD_v-00M@8Ef!}4Xi=6UlB;1e`3D7Ildzgt#=CPDD`I>yS9&7s5 zs-wT&>g#cQb54+V|8A4XQXUk6uyj;@VJ8STjp}tP^j4y+s|9oxGc6sl*BfN$SmHF6 zB7q!Zsj^SlD^ZfHJDqK(-H$*@PfzbV;@vQH$cG)Ka@ zMd>u+WPIYsJK@AsgHu9lby}E?6Ll0jNPRp0VcoE0dSN}!S^F_fHwR8WP>%mS^2tD9 zxA5?kmrL0GNnSh%Gu<)((?Wrg-Dg`w@1E80P7~hbG36?;2BbhcP4(`3dwV;nUVJAx zOs?4{4(JW|O6}GE#ppM$N0-HOX%4$cQo9?KF#znXmfGMS4*_wy$QF^klfXf$4=zgK^Z+&cA;C8(_Dcc85>KuSTR=oXPM$T)UYe~*b5HLlN&ivROGpJikPC?YSE?`cn z=gMDrx43yfHnTx3OLY3iGclrW&DP+GV)a9t?xmo3Nkd@0ah))0;+Lmh@fM_{A6O_i-DOS^DCAEq6Zm|J`7iZs$>sOPNl-MwNHF**%MkdlmK zXwZ>+)Sp?^nk`CG4xi+GQWh>uQ4r^^@1xfDEnx=a^>Q??dbvY+BVR;$7g$&~rQ5}{ zIk~obVfZ(oS<$31bKEnmOt(daNJZ_b&EIX^J@8FUle(qSlNkNWB?v(tk^K5e-SXWj zE>@c#`?6FgD6DnoAstp;$G54%5TU-efeu*@aa@2ltOhZ79I-wwkPrcB=E)AD$CPJW zaa6sHG^Aph-ar-;Fx7Io8sgei_DzsjGV}TJ>YrTzZWkulJUh^<;?3p7zt)^}m`)de z=BbGtpF&lNj{+v3JZcV~fX{N8=Rd@M)Exju%wIJ;iv#Q1JiHxkR#~+XvozNmxfd4J z&76%~H(=OgTno`OE_mD@E(Y1{_Ff*-oz@<4tJsER66{zQ>GQrtKXO}Oaj7pr!)Zbr zj&&XlTU9L*ZI$I;E^_FT+$SY(V`Lzbl?Yk=kYG_BF_Yb|>nv3|3Wb13x$~pk-hb!$ z=t`yWiOA=#cHnH>`i3x)R{AN)=JFC8|I!Q~*P>I&R?WWVwSKU?c^fr;n=pFHlX74H z#61~Pf&(I5SbKc!TLp8M;B#(NzAKeg_R1C>7fvsDy`m)3Dz?ID7~d6E@f9jR)a&>p zlmA9H5;tCb=jIRLkqZBR`h?x$_uoUV%FYNxBOW_GKpcKbz1riHFoW_G$k{bk{ z-+Np;NxXeV__Xm+%!7=@>9?s&zh3&0>kYwWF&a5wAW{eJ>ULY9m-=~Z7Na^x=i8LX zzkvmuPvSgxn%Tr>L=ivlIWq4Qlb;}bjwAy}Tii~bKJ=|)hBOVHFvmOXv!Uyj_W-!5 zQHk4KyO%W}Sgq2y&(ANK7{8|;W`xK)P@5?4Pu(Gi7_Uy9{`AcGNLS~Al9fEhW|ySI z`8jrErpSoHz(I=0Z;(%6|L9<6^4k9G2Mg;IjC%gs=lRrVu;YV5;mIrp&12)#(LL2> z`@j-F%&a1eB$^;Cw%vuLPu{ z9n}-(zv-#n^=k~ON&J4o+EDWN-Ar`LDw1{ixRR+IwqB9SN&iO)jtrqh(hx@0o5bbhn0al)W@4uY0SSH74&q6*a@G5roy@eI079|))D5`sx{WjREA&nvFa*gID~d0}C8oa*#y8Z|&mPRK*(Mp!4# zE#sRD&V#$u^Zb!;n&Jw}JOr=TG|NAJs2W3h!s|aX{Yt&wq&r)c&Y6P8k_TZ?U5g0wkKh#7>Xf37`eMrrWBKTI#D#_CEi&=?_HG??4Ksc@&pKc6O7CDb85m{RTyC*oA z76?t(N&JT(g^dOa146GzDj!G&%fs3UHeM@jr-h*|1=S>wk4^*Zq`)jE&}z$SKN~_|EP) zORH;7SesvpY-|LH8~}EoM4;NHcBRgV)AUK{Um_+@Ht$yqRDRHw@b9}rl+HA|p23&5 z`!EMhxEM3ES5nw0baygQT3cqqv&WWfv4E^Kg(YdVTSH0&O{_VkB z>Sxs0!4%yBoo%PUdPT^PYaz?PIVzeyLL4{DL*IL*qei7`Jk6zIUYye(NAY_Gb zkr=4Qb|>zwp#o3NdTnSHC#g!6ddK@Xg8yVZoX=ScCCuEWltoyb=Ws^kS z@<5>btv`UQy7Iz&hC-!EUJhbQNDDbfQn*5)7Tja|>TmKz62)6m1j=Mc138zC%|SEr zKN7?qRv-O*ZQPswodtY@1L6JD+?unKc&jQh@6ltL{HrQHRABv^>eO);7J>jX*`s;Y zh#1E2P3)HX<}{w=N0i;&yR1l+^ddce>{~n)K5|5*=k>M7ky=maxDc>33oPGQ z#AvGoHYPdu&Q+f7a@k@hABX@&D2B9wvBjUd4tPG@!&be}Q_8`0uwJf-o~GVNfNXw1 z(&0-V)_yqvhwO*CNya&wBi9^2F{oY09P1}1=_npiL$pkZH$HvQlFvT7AZju&7zjPH zE*e6mnY+f!q=-x?N=}@rgJscGZvMd#l}maTuKF()ykj2Lc*!Pl*`ak8*h?(zg%FAR z_wewa9)&+2CsCGjUw!PaK>MWTuMu#Kz9TsdYF}}x+|mg?3<~Fho81lk-X0F;*xJY# z9f(>;#z*pDTf-HBGek|MC9D3Da$r12M@7jkj#wyY)jnT27PriVI*+ydb9T0ppSN8a z1|+gqV$97<6BidBqtR-6nT{owu1-C})~}DegPUp;z{tBq<}?}dhpGUopH(g7$p8j( zyN+b7|?U^qQJ&1pG6A3uO z$#lNES41sBCVOkd1#yF@LdP9&=HC-|;Bg5#e^RrLA>4(3ER@LzT3A%D$`@5H~$jf{td~pG*G?$If^wtz;10g$YLKuV(?b8 z*o83yaAt<9r56l!mh>3~l33*+AP*sfrz0Z8L0q12@oz2|3DbzFYE+Yp(N)SaJz@a# z*8$c_7Q^EM|G%1?(bdg)N4l+}hIVD@O}5AV1YYjQUQImc$f2G+J0WEYWk^DLW174 zF%C?cdGX^SEO?S0tD0n`T$?s&IDp~j1x@8Pp?E4XFAX?g+MKfWe8R~7;sQgz#sy)*6=6L8%#Q;E zhIo3c!=|iTG=h0lg(aZzX60{B4!J5*t*OaEa-ujzEE=>?_DMKiIM-J1>(MWczZ?YvReKb} zwbqih40skuF=AP>=)r2_xH)>6{`jj`Z|p_gYqTF?pp9eUV=8UVEi2)7HA4TIW9v+V z+TclycEKxkkYCfo8SD3Bk82d!ZH!C*w~YWK`#PDnhH$<3;D|sp1U*jIxww^5mcJO$ z04GoZmoQ~cTUNxnRCg{8aa$?}}G;uP-1wP+XcrI~OUf zs+z1a98F0NLL%S^@vI~qOrEtHk+nZQNCMB06+i~ci01q_?n4&&2oYbSBY zLu=Ig8t$Gb{6iyIO0qv*c99BpE_W9)m4tMZQ;Bs3q;>sa0w^RB?Kb5=>8he9C+)}q z4dWkc`=pjtl^Of3+Sed^R$-nx?dNCxDcwT7MY8*8?WD{tl>8Dp|I$VOWqnXuV3zFQ z3y{o=&P9;~gGZ*SrW4l!%?aD&vlrY_%sfjopuftWsEnIi6HT-u84{XmebkR!em?HB*S4buxNaWN&ZdF%YE1f zNVw9zGV=(_kr2#M!In^(ep}OIM`@hWUwa9!wAuae9Wp|``STBmj}C~24suH7C`n8< z5qNG1_(FSbo+G3YaWI)0tc$o~K2WE7xMNZcLG>4E#-eVRh2fxiG@lF92@Ru5I)fc& z4MH+;Z_yE58%BR4E5*x&tC1X5qjEuve4-zq(p8ta#r_a5wbG_U*#BMrFMrt}h6tXm znR(K`l)%7?Df};xO#<7CvtGF%BYFC^%_Soau!Zpgv>{iF6OD3WpcSxyDnB65S*;H zXO`ub{95E_246J7I}O8&5IiLrO$SawnQe-2VZSm~i-b$3=e$%O52ze#sWNbrD|@6f zdUm?Q%8f&p@D!2T!WyT1t{oTK2^V(-+3kdqpUA@G>v4EovvvCqY3acvz}VYg3L?+? zI&((18HJ}u74^`+aEGd-cUb}bSQ7n_O}g4sa8tnYNbET(q%~I(OpO0G={>M)h)6A2-1)t zFkpWZi;5f?@oSm!t$Qd=od7s9giQ3!bh+^8o_xin@JWE(Qa0Adt7gs^M-V>W=n$(4 z1b>U#{oE*jwKe`)S}h4^v=tN>Ihd{hO{L#~D4xXae0s;5UR`E2ksvv;ear9mDXgBI za#2B+ff-tWNjy?gC?baU8H=6L)v)=o=8C#5=JNZQ*`Mz4+iU2H+X-t>-}xrxK2XsI zER*^Kk&n<%p}CR(V4}_s&fr{z^fs|mVW&2U@%T7x^2F8Cz?{Wo|5r{E3d1_rCdRfo z>FR}t3kMSY$vOX^B;+p;DaxWSA^JE9xoYCws5mtF9_7GA@sw?`Wet{_-i*LEW3G4VJ4$K*v)m0bCQu+0&YE zP{)wg7v%mLVUw8c83mGQ?+jfu5gnX0qfRus1nBulTS@I7+15l7OVeLtg{Y10%uTci z+Pz%Tr%(B~PDL@c)i}EDobXBoyA83H-VXZag1OHY?3YK+KXWC&xKH9tcU7|sLLS1t z0KG+0%25_*|7u?S6W#*C-sHD;(7VaeEQIL)!Y+KU-${K2hskgzE`5KWwAibXci7|+ zeI(AP1?}lGlrRS5qSDyJCB^Z%A$f^EBYH@&s^x07S?lxMVkQV0N^lL~lxHANpz;}( zobr%d|L)%y(`UvS_z=4eN|6M5#|Kwew)HOtN~>v2f;7T42B0FudqcvU!MUY*%heq1 zA@^@GkG^C1&CE}XyB0LE{W{>K*H+LqwcX|l9^Q&Z` zK=@Z=XGOp{b1nV&BiF3AVf(A8_&+c3fhFkxM9>fmDL3SCf`6W%P2$iu+QyTZjA*`RLK1J=;$c$kLu>#9kg<4UF76|iDLXRcU)`0oM_b79_TcW04-Sn z>X5&|)12(_FJG%ISXAe*at%N*l^QH6JiEBZogi0Mq41aV?;p`{F`sl8-PQG*tB6?~CPh<6@i#-jEB%(_O< zly@sT>boM7L)QxwD39R#M@^NA;wRpm4nbPqZ;Xog}^6Dux%GP+#|1%os zU;jk!CAOARF|+J19p%6X>+aJKKLe)kCQiOVxQJ|vI5@`p8Iph6`PE6!#B;SFpXC?T z+>BAx?dJu;-*&!yRxK7P7cpc=k*x9Xt!=-XZ_M*301dEKm0ZJMlw~|RH5$GXw2Zdu zhCqg~L>Ckm{vPc9Lk=v6^tb;sp?4f-*x!E3qhRZqQeK`_X5N)3xmU)%S3h}eGLh-$ zids$&l0;QOmitxYS5T~iX_Sy-Vq&d?AGHd&T%ba$Fma9)aqo-BGj^Q1anoimXAc{9 zDiXQIy)+)uaT9z!3lTYbuxiyHbC$67F&K%&Yt{!pvpH${s*e-)JvwqEDhhV$*JGP# z#s5VVA!n~7RJl?@4%pGu<;PkMyr+!E< zWN{jfsUM`>Kb3k_DI4QN?)QxlE>H4p)NN`rBRQ>lo13K-BlrRz-xioAQ5%Xg9#W5e zI2GAexVII$^HW{hT5`8OJn!1wfoHW};C1GnA3}XA&iQP)uK(jl9ul;Q^fpf$f|ADx z(S83PV}0%LxrJyv@JKY8OvlqEsC(~3XsvB0x#*!}d1HKV z%v_mXh*s`Fd=;@*{{$b%xS(ZP*Z`N6JAv!_F*G5C_WYWE{fP{rLsDsfS}IqX-~^}U zHzhLwSBYcUphi+SEri$;YiVvR^Fdc^er{o4n_14))`$^{*81>tZn#RqQbXnra~RJ7 zE)#N!zi}r}s9rWCD#{2iZCf5Fn}`!N_Vo00UD5V*l;H=1gl`92MgKN>=C-In2@gVu z5#PGD20@?ujsujY>4<%$jOtK&cIs%U6pH_TB!oYnM~Mn3-8-YzWOJjaS2g$LOGGYO zjrU{`?AXQPF_`kT7)^`#-Cg1))6$#90y%W?^@SUu*TV+0r**B7{ph})^|(|RQ5n&y z-{MIyO8EE`!H74*`TP3Bw4ugFq3$q%q{P>qB=)fu7PMOt<@ATU+aK=EE51&?tMn*& zev-_vw=6uFR{c`&^2o(8RR8l&5d5iv{Oa>mW*{}#E@TdqulFBAT8MAtqfgsyecoD( zug=3H?trLC6*B3Gc4X()Z(yenp8C^0+o%gOch;|38Xew}VgI&_okqU)vRwb(3M-Ul zwrqYnl3bRlVsD7CO2hSBnoD0F4GL}z$1n$G!dg~ZO{QzWfgy6iA>9l*yr!Cx6c$@l ze-62Mn#-pyLSS<|8aL#TqGDnpUAq^%n?P`5?Wf2uj4=90eoO95E8;8R2uSm}v3tSC z2lJdW-l=;q7l93$4o!2bwS~Ix^I_lDQC=c={o8HsA}4ragjo<19ba>uM%GbBz+s;9 z@kZ+N%gJElc$Rz9u#Ak2x8iXB1^)O(kUOw{s*udy4J64A0$~3p_x@)c5Z_b_gxaV; z2_F4GBWi}61VT!*NqCMJi|lM14h$(!ra|3i+^2N~fq|a_J_y_<3yphS{Gk3_**N0M z3_nUEIRZWt)hSP%vF3~N1KpU1t9@WS5pkyvRX)A zPBp+41~HvBu_AFIpc#AZ)J^Ua>42c&!Pw=)$nI{q*MR#>K3;rv6g9!>jge&9eD)d} zWHs??JDxF{;?{_*kh~2P=aVyx@tpc~;<1}^_;PA@zR9@EZHsgC7C@I`tgOQ4azQhz zM^$tCW}{TeBjn)VSNHxMh8Q^G3Soiswew6_(c(*dWr20Sw{UMvyaNx~&w-QX1TDnn zSB<(^{qZxA2skjN=ekTCR6)yit}7WsQ-<{6(Wvl%k>Ic}wwDj7k{^llBsPzsyYhRm zw$?N%9s3ZN`sumw!UOe=y74{{T4;!D+p)Xk^`SR7@aB2^>yGpf_bxb9d6XT@dQLnJ z<0mo`rUDJj{NH?WuqK4ve$3Ks^WuJ`b23V6ZghrLh&LVc@fol+VM;1!p1T2`6Z@=X zv5ZYkE*G}iQdZ;cye2WC>Gv4le7%akA-svFKD;rYP{n_5pGM%h$5;ysHwH}{A~sQy z^@sRiQnv98HLTKMwmJ2J!*=fDu*vrRYk%);Tdm<8iw%`UHv?w6Sg1OLszYvfEYtN^ zfW=nP-D?}3D}`{k;D#OV&i+DZ1%5|rEmPZyY*W>+U zh!wX?kE3O;04URr!3Jp0s)>`DxI6AEc0fKo9jdjUE&nhqjWRn46Ooh$O3uwHZAmt5 z`IKfdi0t-DY-rIRJt+zm52NR$s~`#T-pj@)kV;}BPvcfyW@G2>jJ^OX8WKeQRsnCc zEIXMXyw4KAx)JyuxooNBHT+h*ReyA!xt5V`s1s%>^h|UnCT1}kC2ESH){WR*{JQsN zCZsAc#v4dM2mBxmSb|5JC3$NW3{y7!KYnj18jJ?_%@l>98DSmVMD<^wbCRD=cGhHa zQvT3D0!}-dAW=6Nr%eVy8O30H<>O29XT?(XdS>zp^tv~+eQp|jyR`keFB%XcP%i_w zmn3X^!_HKcE0Eens*$YcD$S02G;%XWmn*nuJdi6HbG7%-u;~&YI%br?n*g>^s)_Iu zB(tOqa4#U6C?#wIQV&{Rx{LNqCwSt;_@f9=b}>-ELE} zWFIuJz@5u-e$lSYrphRQGiKUyX5cF{PGV#Uwug?L8)ALm*6X+x_tGq;QHz*@$>%n} zS;up{ciTgX`F+&J-j}@JMlJANzgCqFHLT$(6>fG1onU=$-wsjt z?}0Dw@S0j{1G^P!GWqJCX&~s!(%C0Ok5pls@%$8wD2_UV44*-wh(Hzvw)O6j!9e;f zquoD!n>svja~~JIqsGVkz-kzrCj$eLfd`V%;*sy1F4^WKtuqn#r?8%=?&1AW8dCfH z4QFL54Li4#So&2wer~;}8`=R42x|*+zU`xO0kx-kYgtZ9iEjTVgixfl2UC)zy9J)^QPyP-wUy!cO4odaE@X8qeqx)ULRc@Z z2?(vMGs22BmsS*de9!cy30@)B1RSB#5p(lw=vkxd4RfW$2HY7fL#&f0;6sF9XBOdqQtKX z8c2zx_mat9c{eJlOp`b$Mjs?P%77u44YeRy(ElEq&mMWgxGZ>b@={TZ{(tWX8V^l? z+@ni1_od!HuQMRXI}Ik4L8;=7jf9Hts11RSVl_RRRHo$pJQM1tj8#g_zUN#6YOn;P zYNtP@8p02RRHAkiBs2&R3R9mW3^XIr6|~Fz><)T(dnyQ?%=R)P;z44?jALU%JZa1w zUttrL!s9)EZZxv*cYDEAwff|NwB!J(|{*le*bXJI>_%r0k#1|AoPzS_NXO-n_bd6U{Id;xuN z%?nTISV>m0mmVd`@qTt_@bN21OW&}Z`}!@3)&e)$W517okrSc#iAtRp3D$5`F3}58 zIf+a`rL)U^6G`b)5Jp7d39FIPsNlOF_R(vJkT{e$m?qd3n&hKeRt|`A@QFcmaACVs z{5P!yLN*g$kuHAJxWE528Tljz{jXKKAUyaP0wj6;q?9@&EhyLY6Z->X+&05kSS$fB zNc`ll=UID~FYt6WP}VBSp#srGEvkZc=UQjhCK)Ca7&fo%s_S~ET)MFI={z=_ZQ9|- zf36fhFbzMvhDJoKmXPW=k!|{Iq4Wtcw!!;w zX0;p{Gvvb1+P3A3n3X zgTT~&)KK3teBeAgee8~R+KI?~mq;AV*q^K=*tDur$P5_3GU&PK5r=lY?yZZ;(<&1o z7S)Q7NgB_TeI@_41WBFI!25E`0eIDFzaVo11 zam}`4E+K=!_AtoV3#_e8V^wn^I!2P=(=Baze*}NPrSu4bH*VJ$uzRoCG<5xP%PaRS zu$iDT^i_N4;gP<+ApIUj-)mZ1hDQm_K;P`>msz(oSeHFf(a~pfvTrM|Mpj;&$03j7 zE>dicx6yZaH+|>rn-}+7&8j`;4K3e7)$Hpu!w5ZC1ax@T?GP6)d%rM{c8zGH{9g+4 z6#*-cuID&9xI^TnO8my%*-gdrFUpLt0FDB(N;n4DIHMzQPkJ!3e>vIZ`&@V9KYk>H85VhTn^dhjgwhea{oiC?d>XZxhJgASFmj$Nb3fdF-ne-mufU^ zXjG{t4zOAdZ)09T19x|sJ~YL!U^mS5vMecNsrjycFc8`;J=Uv=$Ib_ zH>9n`rMd<7Xy4-E8Bb%u5}Xu8CI+g!d^w1s1U!)+HFt;xOa@{=zI^TM>2pNVl{9SN zg#Xe0_x{-IEAEuBP1d~FV*<*BGib=JpO(sEaCW#k+GQl`giZVLaXUese*QZZcz$eg zal3p(;8wra>*RP1{`>J0<@O#DVU*ElKrO4VX+>^TJLgy z<|6PWS|)Zvpau*gn?gvaS6KEW%X^B(`=f6wPVZZTE|GRN#S!(#9EvOo?GL3CS-uDY zu>eA%SId15vgjSvnBxYg`&6Xv)3GtG>k%hmLD|?vwOF=FyH8-`Fl=(i9O! z<7SBy3ew^Q$m{ORpQFeV@Nz~+`qmGt!f<3%x#i;*)YgV`{e)a+n>ZScw5jSWKI$8d3P2xL zba@*VWtj|6IrAvTWdd3077PuJ4EE0tRtusgF_NGd z?$XN#vopx*T@+Z4cLO}onZM1BdlJbAC{;|?^l%N(An13p6gT>GVhnnj!Oj-qr*Ew)~7u?w`KKfMTEnbVc_Cm z+3`+T6x&oL&S?YaarLysMZ;-n=qW8+Zv!f%^|4NmW43#5)tW{#IF^dUa(|`u+nsf= z`_z=gjR&;bcqUxCrJ1Fu%bw2G$W!g}6$B|iXn`MX;3l}8$SzW)J#~TI>XAE+OX*-_bF;)+|;0swV-JbQh zN9zgxXjc#)gS7T&!tR{Wlf}yOd@1RCMjqUB8CQ)vC7dibKLO7+TvI`d^!@+i>Mf(% z-kSDdpcE;^i(6=+6e(JqKq3KY4g(u!_Z0Bsfs z_99AE2<1K|z3+Y~;o+@!JnFGxOoY%F2br=@8SSTiogR>m-rg) zdeKyQ{$A+$-dT|oZY^31?Xzd_OUm9~{p_2Qv~VqZ(j0W6YyJUrquIWSp&@Paw#}Z0 zjGKewVM9ZaoQgrVqLUx}XKR+mfl)v}k1@EHYC-;XP&Qy^feO&be+4E)|Hz9~;oo^o zIi&I&4V5vwHJ4*>K?0v$bT^4>Q6)tT$yyX!do^){gC_ubcHMLq)^4?qDs%&GS>~2% zQ8mAzW1NPiJnRNTj@o7nW^i2=N=FzkZu$NBDMLKdS1+naRX^Q!i0mVG6>pg#(^P~c z>w5+id5J#-%kaGzc~mLif(+G7Bcc+xjHp3GG3rCK6EG)HUL#doFnM0v*7vUf6tsWV zr}xfJgU1PW=j)r)`qTJX%(SlJQll5H&+&?edL>OS#&%MzTNP)R9{|#gwOmqVlo`#C z&zQV;xuwZUPPT*zMBCLTgwPPd7Ly29_0m^ltvxps{Wyg7l@TS0eY@FsX1_hE%1xsC z=mHiWJKI52`H61~G}#>AxRQnwi4kbGaDX2)*!njIY=(G*UW;P)nTst4{v@Uk>{HB5 zPJLJXRbwtf!{%6L++o@;T~=K^VbHF?>n3dg!O{1Vs7_!x2tB5oY_{4`Z>$hB1TA^5K;!8J{Hlv* zQAg*>YHe9*%qMni4VPV`6l-rexhI={%4(h_HuNP|`tJ%qL}i~GIu`ZXOniUI(*HY4 zq2(r{Bh@Sbl#p+z^6{xfD6tdAX1QkfD}NL$zkinB6?)(n_S%Wu5CIi-i4XLv;<<1d zU!xdr%H5bRi@?@mWy2}-$o7?L=3>-dpzYgfkul*sjP~2IO z6I%~|Ugz?2w4t1%ch`ywlWx{NftlczaMZkjf|Z|S>tU5!;= z-z@&ymUqbgbTj1O+FEKyjFcmi*|Nl)+n!#krPS6{<9m%VF~RY}K2CkO;A3Eq(?p(b{Ilk+TkP8GA|IG%d4S*J9mFGF*zLAIj5 zf+}TCl*D$aKOt#j75?Ien%!qo*yCbV;DKGnMsw{`mBGwFh05|R5>@DPZHJ3c$guB4 zE{1JAFj!(>E@9bpP-Q}9rN0B75PxRBW@!F!m^^&O{uqO$|Pp+2HTR_d7n_gTKKWuqH&z4#Xq;@30b zd7Az2a^8ZED=4qmz=yBvIT{8ZDI-+i(uLjfN&|uWUo1`aH22lMMN`{&E2%U!VUxn? z?CNCqJt6q&S)M*yEV|qAY)9Ofp_XR{E~8cUpaXk_j6$dOlymgaC}O$N5vkDwfwKJN zp+vGG;XRMa>G8tcRN?lKoz{jPF{_r{UfxSc^N(5>_#?;}wD6IXWQ;5{lq1+OdX7lp zwv|(FP3J7IM5p@=ZTz#fs4X7Urpz{-u_k0()2cfKc5Et=ugpGm%<}zTkH96$(FlAS zj;QOSh%N-)ZhtDPYjvLGxLf;yIBlGA7Y<{-53)xUJ}l{#m%&5-VGuo+9BCog@W58D zUB)tFjayv$Eg+jX=8*o#(f~A0A|5jF0Z=tAH)U{0A#!vU?0i%b)san9rDobBToA^EkQ-+MaBGqDHYqB(OKJE6GCd&u4l@gUWsUEM=ilA@FqN~cE&cST?^uXy2 z^@sdv^sD|;A{f7~Uyr>;;gV=Kumx^sgh7G#oO&Fy%M55(HGe7+z@*@5aph9t9ZmmBADJn+?274J&{) z*Mqi|3zcVC9k9a5ILEN?=xSCsm$Q(75NE0I+v#H2wgaiFv67}Ixd^rc1+6o0Hnl!O ztvg}Ev2DTn0nK0=)A!({bIQ>Q0j)xGQRSSLF%jKtK0Y_CtF*?-3i0O7fClN7^P3=C zo_B%gyy<$kY$MXBdF&}I;L(~>EB9xJ7j%*y%jsF!kO(TysfB_y30afA-|Q)E&i6Kl zp*NW!3Mwo9C~NUE))BPjt7Le|%R&YVya+-hZSz3IQ1J^F^lPVJAmo?9SEKgCHP-Vz z_*JH`$tE(~4D4tiJXsfNoj^M>rSZJ3P(`Ifdh5$z;K6WK&= zALb#2!OkCgkxIKZ-N=asYwmeYgeVm_-uOsM)%#M58PN}#_LmznQKJCRsA-0i-=57z z{Pjbd1Z4Q@{0VG@Bf1#%iwcOoJ7}qaxBK+1wZPg~__JIf@7KK3<%!4=d8fO(;>P>LqBN4mDbcVQ?MMJ=hiK+ubIZRsLA`(j?=6k z(WwZn>GZUnw_IO3^;q^MG~3257nuNW-UFa9RCzifVZUl)hSY?2LvfQ0Z_CttqdUgN zw#x1qIViV(a(Oz)Hu*L{`gS!krb5nvZLE|FM!z$O2)OP+6zs;v?Rqo3h_qQZ@I27y z{pj1LA#ljJENE=Kbq2~Xse<<5J1C0tbBrs4v7Zy3xZV|q=#yP+l9wTVi&k@7moRde zw)%lb(bsBc#NOrM{+obfesJ=9;?4QicH)g9eQFCNqF{{4Og(T3o?jI#`}%e__+1#! z5=7PL_Y87TO3@4d!1=%nGosvh+Ym%VH5I!^pCZSY!^&UE4 zdeKMO50!KCU-n4p-+s2qJFL>3_T47L)SqDL%!23HyevFkn zmC)4(Xvqr@=u=c&{ce_hiXgZmMw%7ZJ1zJrwC|y~wcOL+`@kekIhmM;l|!qwxi*N03EQiPR2EHIyPt6(faWWQ*-@WdMKZ zQ60F!R_$p?iPZ&Dd4{Xg8%a-br0@m=#pf<-Z=^?FB2~+fju*;~`RZhGQEt>Y&nKfk zKDQq&!-SB($1Nt1M0cfisnV_*KG>8)jknt}7dpT2U%2_c$uBsp5C4@$Uhn$&e7|r= zhAUIa&*=u)AQ!O$1L}I~&xP&%^Bhr`Js1|eR^QOk)@9zuwZ5`YJuc>3c+sdKv5tiy z6!1^5gn|_qh!WDWOc)n6Ve!=eI*{Dbt96mGQHc4KgMmdr4{{>It1e#=s5{TQbaL+6 z;-tmY@lexqx~{9RRpqR~FJn6LIIUq;QpZ3ttEqT=NRlF~74Xw$B;rzpL+y{GT2`ud zJy8c`et-JakdU}zrIMVa;bxC@H=U5>pNplP$LJ_=-A>XfjH&j9M#@Z#g4&0T%a{)9 z1V)COB*yRmQKydw1y*g_;Dk%#4m1`2)?JNaiptt*9m6~|T2X(tUe`D*T&AFH!r6W% zwr#i8Z8zPieHtO=ZEjA0<`I<1@%vzkFDh;mJ>@#SfSbu45dJo~bE7>F8}0pwmiZU z9_Gv4Dvf$1{!dPbg8niTg(?vlk$)PvsZHJEN=D6+W3Xfy-M7;Sc4jh-IbNN#yA>22vw>0ag^?H@q0`JS)sIeK^VJW#$VlEe} zqHY7$fRa>b#qaeEh3w?XkmZ5641;xz@>SL@c~x7=C9tN=U8+|>I9ridlTl+U ze=B8P2j%HiuccMWs?S#E-nma~NkJj7H~1HO`@nlWg5sBe@BBO@JtJR_(h_y{#2_tJ zr-HbBJ0kANYo*;DhJ&IChFUX`aZf2LzHk$IkZF5va4xM#rCrpxn%E$uP5$Sj*VOf98B5>*&^j}Kilhor~vJAuup$&}Vs z783ACwH~JtQH`UxxrU%O*Ju&7H8m{yH6yYUk9C~=3Js1&c;d!(pTBzVAt5ZpZpP>A z8!gOozg{Jopr!7!HgmZSEQ=f`b5qD2JU>5#>t*%Q&J@uc=(v0J`$oF@zLpl6w+Ek7 z&ZNR6MOUhS!ev7#sWv|hU{jw)tnvZ3!ruRl8U26Y(a%=^zB3DO%gc21#P=cPI~VIq z@W)00>bMpQd8kcwg7MRkFpC4j8NR_E+VS-x)fQJjh<91r%b!b*r~?%@+7FAOn8=apN{B~RJ}-gKpIz_gDoRcOU&N)5hETl zcnkHuxO&2)&orUd+PXyF+ofZU6A@`3S&O*SFUc*wsWv$AS>ir7fb}q&?~l_pUKX=RTf?3A>i% zB`^MYXUzu_SW2psLs0{(z~nRjj1G{?}1#c=2FOkXtf3#O&Y1%Ou28a)Ds$!6S2=qhyXmP!%_?Z z6x0C1KW&MiV6(a|+h^0L{}N6y0FaNwRSrz*tft`^pf(Zf|7qbfV${Nqw6?3=Zp#;I zI?mO~Bwu<+wDVxd5{%ff4slvitCy}GZ19VwS$dq`biEhN?n&NlYH7{X*chBkKscWN zSb!lk2VQiN=O-@Sc#5lsTvZ&+R&#k8>68>~7NbsOoy?FURCwgRjE!iOeRw%L%T?*` z$AON{`&q9if!t{I7ifw#s>#a;+Q&cIXnK{|GcupHF9cHF+;8birj4A}d@EEY2k+o6 z4Rau{L{oi6o-g4;oLl^W)54${{{v1+yr+Zw~ub0`;0*|)8i`d4P=R$*pyd(@CW_?-KPo^e*G|>DUeohMr=&DTug>*ppzbt8VVq=j%-U@ZMw~$CZCaRA##i;+q zJ04RjS9G?TLsqzE_$a21Fj06t^fVSM>Nd?Sl51JRvAtMwdhZ7 zWrPCdJC3X;&qRpc+!!%yO+uP0vw)@GQN}sY$$kftT%zqYh1vr7$}C+C;0gLNV`uOl zPvGlSxlg0>4jWTh!1)dMRXg8Cynu?M(LDu>LgTEZDKJBPI%(Ubv%+q&{;pYO zQe$cXaAXaL$fq}E>!T;=zZ2m|kC6%h%`4n6!pFd*cpu+A6y=7MH%uOl-VMVoiQO0= zQF)q?-yXPX5ZP^9y0O+YXh3S%pDeGTyC|%L7a|D%0hliEYWw(ur zL|*(G=>Gl;%>;8~QP^!SkWL_QTh^cU1iXYl0qZ!vXr{V6^!0{*1wr^7d+-eO#_9M# z6JD;{Q(cH4^^Vw)^Xh~<=d#v|D;Hs?P(<%6R$F>i2_{r-%wN;n`?*;r%vr8TIKg`m zdMw&P-S6^fLEp1zti%ePYpRuxR=hEca^p&JYxpF`UE=U?d} zaBttf70WS_CUR80l#XBfC_#YLDCyVnf~q=lo0MorPt#>YThh%}p!TQx)d*NbXlu5Q zIg;Ike(vmBXuB;oPJmotjld;PClT#I++ci=15#C&!n+Rrl0^G#fr z;`~l&$slxia}FIu9&`1nu>UBNW-><8mObYQUrt^YLL`fQn_y=}x6gxZ3=4Ofc2%CA zbguXr)x7x}J!@j^(M^Xp>m&5|k;+v_tg4~dE|-a;VujOghH=Ee1h!qiIu;p!L~5_G zn@eh^KlwIvdUYakZ;odBLd}-h1=>N+K)}g>YM`I&EM0lUV;fBUA_47Rp7HxTv_txf zSOB4YfU|=N1<-ZrWz{LO(uS5;>+Ats%66WsjN+|#4@jau+Iehhk%l?JxzloHjM{1S zQ$6L{?B|A{F@Cxd_0x_sc4ScP(dsz#q$y8a$bXm`*2J{loLKG7XlAEI$X{38uoQaZ zKX&V+84OR=%qf%QEa(`r-YS)OID3$f-r=~e_e9It;6|P^`8#ZWO&T*0LfY~Dp@u0n zv77Eq-r?gVqh;VQ;p(aidF?e~@=k)>+9?+pMP?w$($~R~lfTO_cdVcNGB^3nH8oF; zo2Cu;^P!L*U6CnX0LaX|8FU=&EvWPiap`*i&x9|=VfUx;A}r$;HLP1lPo#dTEbi)t zW@%(>;&giOO&CA)Iwd}ID@QM(m8`g*(Sq0s7Y zeU}x|YNK*FuP@UhJ&=^czGN7C%I=nTRwC^~vPwpItS}~@qqMuSkJXWhePc^XYs<3< zzYB++4r(Ohg0nx=7^ZKs2qoQ>vYK4<^B1ZOW7LCZeBfT#NA@SBw5zp+P!$lGPi~vI zu0{UyX-=6Iu$?lGJG%R6UrT7b(;7Y~dKdd&$r1{B>ni|T($$;SJM=K!yhJgqy3LrC zp+BQu^_rnebw*l=;<`)+8rBh@F|w+vQv0pWS>fihIBvEj%KWjN^Swl}=yv$doOTFz zhv!G30r-XUTmIeAo3EpJf=rH;to7^9h@*Bs`1+)rKM1gzP^qF|$%uo`e`|flom5Rq zd@&G>mfapd5Pg2WgQsZWEUg@IsMv;C<%c`oOmN13e9E)(Qf&SV5m8lJ%bJUa{xOuq zV2a(?)eGH~=V z^QQB>hXlzmI*CI*OV@@@P`5Uwtef?chqFdZ^@{*LLZxh*cyiCoD@LS~rIV+*z0dy0 zdeaPT>v4WAx9kwl)itK;xDOpIz(7axNsOF(33VLMpVf^|=Zuk$YXn8-Fb`Wv)|JZFLKFp|Qxr+UY z55JPa|8a9VftLuWwQ)3!ab-K`$E7y=p;$}O-QOZ$Xa5H0a&N7?6E~elaIN=7Z*+## zOSFWsWab#+u-bjYH5#=EeaT>m{gd9TrHXssa!d-gy%{_zqOJu5>t~5MwS`>kII;8645!EflDbe*w8*$m&Pz=tBu&{Li>i<; zIU3ZYo<|)87w2$pma^?4$XU7Xey#Uvv~Crr?GiWZw$(XU73U*RzDG%J!w^qe#7Av2 z1KeRJ{Fw~V#k1~PnnBGpFF)&GRCU)K?bhS2n^s3wW&Ux6Zb3Gvl{1?g*l+eO7de?V9(IG>S%Ya zuT9qP2+r(h`lXzeDVQ`t;pQ|K#AdoyZOjDCO6`WOi0)8?vfw1M_zKbKjU?STSIiiN_I`38e3Hjhww zP}8%DBb(cvfM6E3l}%|Upf50^c4IuG_AEDQQ(sNBY!$YZ-mOCcd6Jlbm+VDK43umlJQepQ=Wd>{WLF*+c(Mt`hxBGpuIA6d)4(SRp6f1#>?p?G za;q-emJ9aPl#8h{h;PuBu{!Hx3*+nBoD|xopQs9%Sy~!~Z>fKrz=AU3&)y>RP4b;=2PpPgRue20chjx72ez3t6JaQ;v zS*qTa6qH6;@P!=VC5kW7fwiJGyFBKJuYHdE_51DJjl|wO|5s-J9#Dg=UF@8hvO#N_ z=iFH?ub?+u)RNiCY5YDZDPih&QTvIzNZXh|FckYR56nzY)4~UdXIwZsy)taD^J4c} zP?F|I|5Y_Z4E(rudL!N;FM-|?olAFTd}Lvr@yo{h@2?R;C_>3!3vP+ zA0lYKHrF&Lt$vf|3?5CkuN?gD4m4cqN?F@Pm6c_4i6V=8j6+AmM{p?Ut-7Tqj;s@~ zwI8fc*yn4D?8Q5U?BD(fVXVE$Xz(-H3kO#LlTykavy;wP>R1#F? zsA!qQf1dL1hu@6;_%Sc6Womk#zjil4r5Wyhe2D9HoLTSOUDB!tO}rO$p_sGUZMx`e zcq6lBa3t7o@JJERUKN$AI*Ea+V5A24Jz)PzeR{c}yvnjBTr7&Hg`{U*Ul5FJ`xMcr z!8Zb&eWB<=IVra`$63?ky~us!JDG=5L&0qlO^#KS=q{hdSsUuhv0d+YM}xJkXZRO( zNcIY%y4x((A*0R1%c3InL<+>8`8sl40nrf~UN`Ex@%)G3JSDz)FX6Jbk(tJ&xj*!x zUiG!>9(c(mhZeU7lrjCQ5oR`N zEzb8W4R144q&4*M2>ki_`Ess*k+U$fRPC>~R3R7iTs}BQjZ_OcKOeF2(xLbD62_bT$;g>7~)P%qx8!aK9LJzLMVW==v$zzAGf1UjWqERN zF4`PbIY{7P1ty?in$O5MlYRBHG@Xl3+Jir}I~-gB-ayQPKUv35+5Jznf@!iyB@>DKs5aQ7HhA^ec1euoU}h7*}-!+|xS}2AX^{ z@pQ5_kyH3nDja;bX%l%k*>QIdr3W6?w>i%`wUnKaR4t0SEx1@U5|iYb z-=0Xlfc{+GMdIU6YCds~#eAlHe)}~QY(w1qy(eC{Fg0R$?cU%+n%f=BC-2t9^pEQ_ zCKNzmj&`ry_}b!(kGIPo{eLo2BkA`P;BEyAt#hFQ#&)1xQqt}0s$OuaY#ux#ZGrc} zsR!J^x}2!8z&Gr@V#zS6_j-l`pugj!bEY3#ZX=c|32 z#M#!)eNzvvpJ!GHqwzheZ|yn1#@%}Lsh8`PS+5GG_EfB?7<_w0@clWOwf)zAbILdG zPBlIAE>_G$YAmJ7^vFniud+mctEwgy#;b#-=+3B(61fCkyo#Rq?Ru9k@Pq9`4$*CS z==-6qjI{8=`o&=}%d}~A%(;Ow8T)t;}VveMjZ>_m64 zg7?q_bC|LZ&XD6)sJQ>7!Tg2s3!?>*dWtQu8Ez=oBXR0?GFWUO+~@gGgXOU^UzLhi zgz=hIRyBHoEoT{FCMFq0j>PfCe{rWKxd zne1~jUh&D6{cb{&1Kl*I{+>(ypJ`6pUjkF>1QXBA(v>!?)6`Q4Cs)b?E3~fIMd@}5 zjL(}gQc=9ta(uEyKr?B_4x^dJOhv-GWST`E$WVD?Y9+6yCZ2#6$XNh+7{9M$uHul1 zMS3lPa+q3(npk-;1}Cti%ZQ9AqGpnP<2%(+WInMoDryHYK`t#-v9y!O;l!TKp4TMI zP-Kl|_lRfisL8yqWv+lB-<<5kY(W`0E5^UuQSmP4L-vkl)WVI{r)`o}N`DlNXNiVq z?Sjda;uO0C+JD7Nu2PF)SJw?ha9G>uk?u=W_byC& zh5;4MnU0#z-d;Bq8&}!6R8F3W$?Zn+hU|sK$3?yP_~(H}@R>~XZ|z$yh-dY;MUzFY z?ep${D{u{1+iqpxQ&GdYwRn%)y>Inp&8nAnQSU+c?nY&o>0wm|tF)p3z8G5T?djdt zV3SnJ0JfOlIQhR)7{C^Kr5N}Y6;G`tfk}}AtBITTO-wqGQiyd#cT0m72hr90PZ}Cp z7)M_#(xGYz(&yvV4SX9cgdjSB<5wf$pqU;=x6z>haf(9LDKc+m;GUX}E@H^(4@n=C zwJco5L%YniXg;B&XB!WiBc#!HK4l}MWzy(h3y~Uoy6h?jl}cw-s~vhG)=}!^kep>o z2}sklQO6t@rQv#eDDcab8=1aV9qDN>@Br{VYpJGvbi&J$fYO~ zxlvnzjx6{p_(&q~(b8v6%r zHw&Y?-}WEfwh51ZBov)?Dvstv(;Un=)ArM@HIz)}`nKHh8~hH2C2Nt)VOD*3VTOL1d65-eIjdtB7U#iIk2t@KFmv#?T}HrV zf3DjJx!}L(H;K`Rw!zUfE@)SXdRnyD>x_p{oJN_Z5Drx5l;t|gw?ie+Da9e(cgsw(I$-!mOva08{mDi5Nr8|rv#CJc=B;mk7p!}u+n*YcG z^8?NmwH_Shf`nCqfqTop1&QAKhT0ZYnKT}w<2?b(@{f@jJr|+(-*+PST*?=jfSei= zF%V$!p(3%CZ@2u9!XNu>|9=@PnD`BuDP8sNpPoN0=i0ehTzDhLM3AeIHe7 zq{H=X0;X$#R99$ULBp^8@!r8u2nVZkREFxuVd_zX3?V7|{k}wYhvLShu_LB0)GX+y z7aU|hf>BG7iIm~GrzFxpmaNJnacGGLMql&pZ5|qJR5KJ|L<=MaW@j6FHzUolnkx(B zb+m^iCG?3@)65?mbJ4NL{r$2x1uh;C_lS01Q_Vg)U>5RX^tT@AJ+I^E(L_eQa*IPr zA9jvzkCgn2tE;IS5$^^!I$3z_ZeoEu?{ojH!KJx#s&zl37vEl@zWT$$cHv~WH5Hs; zN_%zl=P|;Jksw+s939Dsbl$&hq9J~h8R^ilXUZ1{z9?%GUxItu^c&i`@_mJDC=d9{ zY~C%h7Xl}H4h}PJcZtS&jCIQ6Dxtt6mxkT>!gC=n+x$8ky8TVzyCNZqX|Yv;?`yj` zv=%N8DYzMHc0&Y)DYLLQwK#hfLy7%9HIbMurYp^$8Q-0#VC#BLEtUaFoTM*Ma#`2a9g4*&af0O=ZH! zt7!3eL!=1thKWu8&lR@g52FpVso=94(ovTJ1O2X9?yA>0$ByP(=5?-()YDT1%W0dx zLbVHS7h9pHc*~Jl^OkDr2dfJ%d3y)dAjkf6|zu!3d?rW zR}1-e5A#u1GXy1oXB)&z35S;%?~tP6&`94!{M}+E(doW z_bF~Y1E_*;3qY9#2e&IC{RrL%(lQ&pC?OpO?UUa+SrKYddtvAS&WzZb?JVc>T74S$ zsW;)BDDb*Z3P1Uu>n#NH`L6md4&RBiq_tn?{Q%wdEs(paBw6*8a(4@Y)G+E*YOi9? z$l(knh-BDS%y^WA%vERkpSIhCFZ;8T3*(}f@eRCmR{N0iqw!^+=%Jr=z+^=iu4 zA5m4f7zpwY(=?jX=u}MTauy0X-r-0smL1V|--0!qF1lSrX@0Ie+(vjgyDLE(EURo+ zO;{~|m}Cb7l#Q8xwtvM^c+}T_b4#v+{Pd5>xWtL#W_aR>;t!#3rk&Qy#>%tr1ESy~ zsfmjxQ?9zFgLaA}iX!zDYB~TMeTsRSTPG%cH`Dm$eabyhnJjNTtky==Y1hu-*hp`; z?^ISF%1n0oh)hs~dB6N)7;TU<)h1f93GF)%8HLn{-*SnCU+ShObR&C4tz`Wz%qz+A zA||l?WARD=1cK=EpS_<`;T^wA`7KsHB==w@soAIYIDS`df!n^1I1l3!%xnH-sj|8RiQXd>tULsCU$W7L!;y`xos8~*Ll0UQUYAJoebk$7e=AgH!4edCK`qg4*M7LGR z(5qXHklCTBO{!5I0lH25kyCa5mbi0hI*q|nBBYV&uu({L1w9b)MQH`svb@Xb)XTWXkGcL(Qx0t{aGN zhI9*!-8~DZO~+PWCq4ERg&s@Cm(cO8p_3oo!4F`#j!cjZ($tH>W^p9IIkwX5$+6B6 z@Xn@y6rbVK1;TBeiN8>#V-t9=)Jt#}Rx?(mL|4I4SaJ7Am8^99k;Tv})G?QMh16(^ z+Y2xZ8{qSXP?nzAYu=f7q)o5Qp2WxPRu_aEe*C@Bk>MmX?MsI^&BXq7*J}$9z{Wvq zmdv6h4f`PbKPqG&-)VFJr&Cj?7+UaR>Kl1&tD%Om5sUD7xbg1a4ET$be0WPefU!sC z0fSb6VYRFrENppA96k#2WJo!iD22Sjx2nt)IxN!N33XOW;HSGcW&zrcklVG zU$SnZXKt%y;mSPf<|+}v%g8j)h^?X4@bpDbSc6KrZON`6SR#vBVzj5z}Yt;x^B(>-P zF~8Pp$rNOYYBTSmk*f#ydioTq8m|1zR2Q3MyxAu6eg;~WV|_bRo3*M?y*0sgbP7E%js@ODdwL6E5!=ABDw@aF8znxk)LRY;LD{S6^~w~>h_%Nm|P zZ~`tiE+t9U;c3%2U=A-g!EDfXEScL^dpkB_fyHjlIRArfpwe?%jK@tj$@f<=iLX4F z^pE~v0Bq^+?H{j*PM5}CyGK1*wdgR{ae+vI$!_24tUGN;zJx{5oD4xkah}EafpOqtmhqF{@ET;hJ_QqxXSxV7z5M z!um;8mx4Qum~Xvzj^MP@o#FN2p(@V0$(6s=Q3x4LHo;IZmBo4 z2{7ckT`u|7>F{Zjko)Y*s^Ac*M09u9kDJG75v*gUlndzUKaK{?3dZN-tLpQUfz zkwUu7f5=!^T{t!j^6I`c-|w$Z-$j@_$!U=OtA$Io=e2AC1TtQ2pwMU9@7VwyIyp3# zS?V$!A{Lz9`~3D<`LXnae@>r zg7!WCy|7W6fPy2y;AAMDSOI%ppZpGA%|pE8s>x^)szU+1@fjcGd?rpv@ZBA4LmSDK zYP_-BZsm!TBg&FnY5q}OSH9NQ_Fw?CzkMy0eU|nth)%R9kv#u1!5iP4#Ab*7r+FL~ zMr>%LW%);#Y!@7`hdbEB&lSD%D3O6WE9*kn!;BJ;hWYV3u@FpA-R^i&*=S8oH{tA`@sZeFlhJS@N6@{d&j+6Zh9zsE1rss4U45X)KyD@Ovr)-Lv zDXmqx;yhaDrEiJe@o9->OI3W#GZNRe+Pv0nt>QbNCQ99@PA&{~*uQmz)_M5C(vNJs;LA&(n2wGfTnT7MFEFjmy4ytr zN4V$U^frecR=;BO=^+JtEuOIUv3x)dtWVrM4m$RwVng@$i^V=cVjhBSaP;((bX^W6 z#pYmluGA`mBKeWtQ|T^hWmvS1>{7D%#L9h>vymn&jvbo;!iyN8ulHk1YOah5zm++- z*fCqXx7Ve)Wp2!<+W!a8?qlriI9}zhbRB>GKi|Up)n~?GQsSV8i-OQAEUUO!)mWw7 z9jf@xkR8dNV0QKaJ<>y8+~uq@P2{>c-_KN)!c@RY5uvSvdSRfZhR5WsqA;h7hXx?{h(7!w}xnCK;nLiyR*GMi(;YrFj0aW(l8Iey`ruT?f}wF&{ChgIw@ z7X$S=za0*deDlwhC%}?M`(Xba>_Go~(#ZLosPG;Vl&?)8#Ui2ccVOj@LKvf3u8>;e zqUHBXg6)4YvA}e{8QtSL4~K!oFrugPGFqeY{ja3)JWVwco>TNZH$z+XlA)V*X%?jp zLBbX(?5bgl9666@vC607Ti2N?&R+dLrPQX6$L^y?38-^84$@1Np)YFDAWZxR-F}(s zN8qUP5uYI7-%Nn-o@k~8A)jOLx?21)6d*FJmsEnEg&MG)p@N_@&R=T}OXK~BCFV16&e`rot%&S$7MT0_4wz~qutyZ_4;^am)fqsn|C&yxo9nNz2n z;TY&PM;&H4oj=+f9bXh^936fCHQ>A4L8XR4Kx8APWYgvTe%uLga?o=smf)_7MxrSu zScfy;&0;x7I*ULbZ5Q{klA!kZNxbBKqg=}4Y|FRm5{f;?wdcr2`#-q{e)F4_{I2;v z#JFyk_+OR;NX7n1wi#tk3(oEz4KAlS)Dud;oiK}}JsIkIe}#DiczpaKPEI6tm{6vQ zLeTwdC6i5ruG?QuAm#-Jx?aZKy1HHbdcrQZ1QMKKinfZXz@z2GL3Xk>k zcQ3JJ#P61A$U9(JbU*;q$L%0QqD{gR8Nl#3R$*^QFKm_X47cZFRm=zB*XAbD(vKns z5p#O25aCM5b?WM#LP2djo8t!fvsKd+AlQvDg7EibFTh&VX4f$$G{P#}AF3M9^Zq z^?pIVimEEs!h!R}`qk{t=Zj5OI@PZyw3D`4(vpwvW1PTGTu)C#)0to)9*Fs@el1_y*?J_y9!>_^1H=^sPqh?W_xSboYVDv- zTCPc!l*E9~c6s^igxd5-H=367e6vZuZ|s#qL~&aoOv@vuM|Z8@TIHLRtZxE_%A@2^ zU!nv!`*mVSSgSZpsL5i7&Yj`M7Iy98`}`v!az7L$O7izO#s6s4e>URu_UGd_y-vxB zKe}h@J;e7ojfK~h<(nJ97oF)LuUx-l&}vr^E->p-6zGiT62sLMi9g7jJaHsG`tHz_ z!p(QSvH4Xbuux=tto`f!Fjo833|hKhE9Xa2oM)eywq%5994bbwc0gsQYeN+eli(DwY|Sa zC+8I_r-*GR#^X`N8UAcSv~yppQF|MFTlEas)g zvy`DZH4ik=pkZ7X`D>S(`+Z0`Ke6e7REJjOMOv+Mx0ZF3=*%hQTAG+k#wZOBr&;)B zz06}9y|cFx->C0MR`R_l?)#0l(g&URDHh?h$W9E|vYJW5KONOnxVd=KkGEs7Kg#n- zUO()jjSY(m(RGd#|Mh$x=cj+W(37b59{vRmLo32BJvAV1U&f#PZN87n517RM4H81C z@;w*r4-O%X71ivBR2niID!#9=!f1sjuYC!w0!-Y69cp%e+5f0o$3!2!o>RBE90t`) zt3~DD@($Ty8etqkx~{gF+%vo_HU>R>xlehm;NABKxfXAiI^o&1H>M9spWcaa6b}V9 z)(Xn^8F0KiD)1|&->!I!|3zpB7C_GoCU|{nq&9Ro(()*<{NBf4bpmJ@#{CZqPZl&4 zf^;gObPADZ3;19DX)p>*@7xIt)r-b&B31s!hX1qq@bU9(`NV0i#j-M&?`~g4SCwEyEG7O{&Rt}*Ag;x@jfoUggZR5 z--Q|o`oEj^KL^PTMG1+R(Y>V18qBObT6n(_-1BN~DzN1QFY(fFb+ydmjW`h zbaxG10!nvx3rI-Kh=NKth=6p1v^0WJ(%m2}-5uWr)Ysqt^U?eGFn74;?6daTYwr`6 zHY293<#D@xg!*A-MZ}=IyTh0m-7nU&Cj=$WOB!j8ctQ^-__}!VU<XkHKwZhCKWSr+`Ho6+lHyq_JiZoNt%sr5xjCaVKpF+N=q< ztCc27m$xq}gT2yN!$==U9?CX9;{R%k6T6+%<)@hy>0S(Pe_Z{h^wBzs=lrV25faUU zGp`?t$kg{qvw6PSinzJJ)!N1^U0Uz#@S_xiG3pIj3>BXQmU#&sAape10HNcvmmmE_ zz}n+XlV$b1(-UON*eMQoL;ss`?1VK;VHj3?f+;c1du&$T)B&wLB(qzZRta_ z=h-!p6)*3KVyg&NS&EZfyIWRB#YT#V_#Br;k}B?-Uo0l}_nUMYa}dv{yc%OU1=!6o8L;wZ zDQe({H%eu;G&tYgNZzM;Xg)@#{<~3ZlCn{!k(8cEq5X@Uo2onimwQO%|AG(Ns0m*3 zVmE?pP4EZbA7}-Oa~zs3Zdc7EJ-d_1f+^*jvYNIWmSfk+W(*FnXuy$LX`DgwF^GPq zrGGKBm&}CW<*-6d1lHFRtXFx0UiZz_Z(#CQ=*%6Y^ReBMjI#akJQlCS(BNcs7ug2w zfp2*&BX|#AL0ztG4chYjS!O=P$?p4Iq&tGb(Vggzwvb?eccI``8Xx$UO?w9s{{s&o zdOtZcHPrQ1$)l@X-rul|v&TaI?!hvmlu;&b2Bg^Tc zGd#)_JO%!!wHW)EhUhxx4=p73O%hA@t9>NK%WVaS+FDXhD@@ECR&bcl)M;NT5k%Jt zEzOPHvnvW{-svcOVC#~#)-0;Af(+`Df?aWkQ-ni*mUVvp@aawMdz7Q?#~C&0OSHw5u7i(Lm}XdF)5&gP4p=XB$|!QT#mmM^Zc9>+ssU0&wtMm4y0 z!A353)sjRf0`;581jTX3iOgN;Je_GCs`k9qke6Gd&RZ60-1{MeEeEZwcNZg8h*aQ8 zLCcdm>!|3RnQ!T0#9ZDnFDer?VC&n#GA%^?_gvGR& z#*X|Tw(~K*;4}s*X(li_2^d}KQ#YCL-2uW?cbQKsZ#pMVq$hD7af`qBtH}JY!>Vfq zcQS$US|-8&?9u{);dU5o_oJc=PU|X7-~0RB@wS}rG$?ol%M0bJba0J5`J(NNSXLUU z;x_uj<4@7!BcRWNndeYe+14+-33`mI!}lvcaPE5$Xx{neTy<1%KD85LNrAvJhMx#FtCXxWw3JRkF6lA;Cur4$^|+BieX9$ z)%PEn8Tr@ixK``CsJFXUCU{a5lnC0AI+e3V* zJHM0oa3z>{#v-+1haKJt<#*)2v~%kY6!1p2JG3oaxiiO{De>JFq2J^^aH>71f*3xu zH1?$U@tGdYSw7@wc_;)Hww8L=9-Odk5#{>OA*eS%B&&L_1%<9p9Dx!EK8p(raM_Lz z$d{gW+r_|`(R;r=MP7rn@@F|vEfu7~a}2BNe~1mR0zlY`wN9%$Y!Th&Y28qq60$9n zM53sWK3OQTjM3Bstgl$8pt}%OcUt_u?mBrb{Ae|t9|BpGY*vHe>9$2E1*Ea%Ml7o_ zB=z-tzDXJCgH67GJ5=A6_G#-8#Mx$s>szgJ6y6r4a$vsV?pmr}B$^AYDs9)QExtF!Z;^_!2 zXm|afW=P$NUO@7$dnFPzr;J_ixAgcA$n0E@l#ykj9F>zu=67qfr2#KMz8Ederf^sh7DXAJI^vl?H_j@z9T&Gd*Z!9{`Z6&qBt1y!lOHR_lEwD zwJE}&YaAu>3EU|JFM}-Gmm*zlh4^Cbv$pO%6_8KmwtWPLQ-QW>9^w$U?w32XZU*=M zGy?YCu)$L%a^fn;+7|uk?{S&!-E*j%C#I#w8VY>J!4=g%-j;3^>_Yc&H_OrF5@O#$ z*4mX3)-}j*g~Vgl%uW0~{5pUchH(#HAb;SNjjT{$d0D@RsISQpEATx)rME4O@;9Aq ze}sh@H!K(Qg8tV(As>)c-I;LB+BBIGUB<$eFCK0mtEBhhjFGZD^Vlp7Z=y=){3WKc z*JRF3pD?DPQST6eiaqB_wS-M%g5*(^{}p8*49_;GdzjMZ zDbao8*R*h3ibU=W2Ez@tLXIfmk&#o^>=|W_R#Jx7f-#9WYQjl%Wi`9^JUC*2C8^{< zeaJ=TGjZC$w}gs1XLs!-;Sk~-;j2$i*!I-(EyuBN^qC%}HzRUBPKv6H9QCc#|j^#yFPCO!$BUv+wN+YH2Fcccx%ywyBI>uM7d#09d%?FO)cv0SrEI~7Um za8+)py*Et)vq143b=i&7eEWCf?=~SK-H&r>RHy%g=^%wqza^Wh_4tV`)k>b{Oz$>{NEi{^Y>1e28(~fPfl2FextW z#%R)!yPpa!&KlD!W&(#_FLm{G&GY83VYUV z{Iq8zJ|hzIdPQcP#HDl}}5g*p$`@iFekrGrpaN(zaFwNp( zz{OKmg#X0|;wp!!9Oyge7j4Tq?j+A2U>qz~3b@l$|K?d`$rW3weJ`-N4RQBM}bGl5k;U?dx<#beQ|wzeNMbSXg>At5gjd+QDCA zT>q!>3-~2^x8l0c+|LO~-DW1S0bVNlpuUzmo!(AH1^lyEznjH6k3kpiMOGf$4V%gx zBcfn%?R9~dXD~Hgq5qp5nP$PT3U#~PGj>z-KSe}zX=ub{$n6wXi4*{xx{StNJgIv`>KFRtR?xT~v5MT%~Y*qQB5|c!I-ANUk0r@8z-($x*`? zUh*`nGtHHIeMfU$8_bzGbN*Y>2H=j24HpJ7x5OuNDBNO4 zsNtx967iyd@Y!aTX^$6r(0T?cy}DlN3o%B?U;j}5wqcq1?I@zLp$|0zrd7jSkgkzk zNeDna&9s`J=a5`)c4Y-421@F;%4?var=Ul%3L?785ML5JQ2N?Dpq-S5vV(C& zV`V6~@d^94{E`5}yCh3y)1@MJcPWiIiT-y1mjo|-TEnz*_(^7ta<5|&hac|K*E3t$ z50at;jutko&PE~#<w+6k+aK*ZO7SI{CL6NN%Ue`HmxaTr^Nu*P%mygmmy zOuY3-l#&b?xi4R~xy;5Z43-HD7PcZZc9COLor=;cjwp!?xlw!^6Dv*a+cfRN5qY^M zUXi|*CZRA(Z(PI4+o8RrhM2Maa)LH3*cqH^u%`bN2Db&r<49kk>8yVWol967(E<2bwlt%g{JI@=fuGQYD5j&6Dl zjTAV{sY7I@{}>ZrfKnam3p0U>$4v@kqujvD5DKyls*rp55#6K=(E&sC-!dNpVyZr6 ziH>Euo>aQtk5WTY4`y^tC}a-hGl#POyC;}?P+G}zLpCTtFDxi+TPFh8cdb}{Ny>Aa zTfdJHAf0_qAT%>)oMPpCB2LTKs3$7;XP_S;$|4bn5)LJNIS6bcCXxDIo;H%34YJ*9 z?<%*a`W~;G7I;!lOPtD<{4lc;*V;`T~>ze zAaCRBy%1w*VEvhySk*Fs0c<|_lapL0y9>B0&rb$ji`iUILiZ`ib7;3@0+=u;uPRJl zPvaho#%zk%9h_SP))B&E09=Jj8A`^M>2N8W8KeiJ&F`=v5~W}K!0nHNx^i1p^0aw9 zv7B>7_#3Vr6`*o_4h@nG6^mUHJCLo1*m8f};@T__2-uwkNcpWP-}DxmXT2{(`~?;h zg@~az9&d*3{a}o>{g|vrkRtx=GjO*c)#qFre|D*vRU;17PqGh?Mg?T^hLt}CM^}J$80)>C0E$+sXQeTyzl~+fG1FJjp^r-`1a{n4NyR`y!=Sn@zL00 z@ApL|y}+~~U`YgUQzXK@m6*AB-@S@yZ!vE2d@c8B3Cllm`?`Tx=C|0B<(guVne2@G z#AcK!JcxwYj5~X8>R_0?db{T2=)%U`ECm7p1B%SJ7Li0y^ls{UFE_R%G%&l*kky|m zOwgle(|6CQhlQxTlELD5NKmEcoZ?GlrF|+g~N6g!MEcLBY^mAax8g%u@?b78>l&%+hG`Vmn&^Gub&9TzRu#HQP{HxQ_2f?3;0t>F?C0dQTHD;|E=X-3pRKdmZi6p zt5+#OriJ^am6!}3Gz)_D20S>xa^;!%sq-bzVRT3n4}w3*5ZL`{#ciyYmnxUsaN8am z$Q_xUWG^Uz-msJrWy=l-)LJOL7g-b|`0YJJ{;=Km1THVGwHRxV;?utza5EYd9~<9k zC<+Ptzy3h9h4WMV`!=*O3_SYyLLgwL-nFattby&;c8x_~^|DO&0w4Z>HG|1$1rPa2dETNc}YIaKf8ur&9K>e-IVH05BEVSLlW)Et&CWdi4%WUL7;T#xc zLve_}8M<>q(uP1DAFkd2wZW;$^}Ob&>em!Bkhi~(OLcGAo6Z7w;E%@uBO~J=F4A}D zb@jG8wT^p?ortayOaa{S8g{J?filOe7Wv9UJ%4h*(VMq3CEs@-4X}TRd+bWS#pNWI z9)vP~D~sP6gOo32sfrZi$~N*IXTnncEvdQ78g|pp*M!s1ppvr~DW$3Eu-VR>h*qwc zw0`7quCwC{3B_7*UTkjWHQcsMGI@`L3n0f2E6j)1=k|HoDwh*pdEvpwsTE0|@q z9-hT}FQR@^<1G!sY(PcKb=5}b-$Rz)1Z(U}%6N{Hhs4P7Ll=h&Dev`k7L@Bp>8*2| zr-a+KB~#0MjwAr8pRk|EGTIhH1(ikKXYd~MEMh#sl-nN~ub1g`y&8VWgm6DC1W2}? zx%~*{n{6W07V1>Ge?+7rUZM;C_$_iNZFFKq|Jjj_s!V*hqhN8s+%7cXB1 zwAEdW%BrrGprZZ{Re!n*Dvb#uvokK5e#ktc*_l$~7POi?klKR!%;o2TkxCC$@SrL0 zQh4f0y-9XB6zY?zvmkCWT}74@9quT==ATW~=qa826|G5KVsVzuvIrQs4K998bTGWh zs-Sz|wO6dhJ=(is!lr))t_MtI7h!5tv_fj*6@!F$Yqi_!Gik`#6nU|oGV#`eY?V|J zMv@Tv0Z;~)uH)I3Z7!Yoz_sT#&AK1Ow+f&T*so)eKF~Z<|6(f^aSibm&?}HA^t0Rk z!*x={Y&7N zaQ|fsnalCA9%0Ch+3D2bI)BlCC1SO(^-Q}EJ#C}bs0%b;Gklj8nahiZ+hdV0< z)>~IlZEt2)@5)r9Nh$ZygUjAvz3w_Ly773!bBLiT=xSy-=uuDDydZq^@yzQAqpqA?l3gCEJDq7M2PMr#y2#u?1Y_X$uF8*>m=n6#RpwYW z1qnz;b*?+F7}ZN5z|{$R$9}FG*c6~?3*msa(_voz^KW3DNVz`KYeWnqFP~Yxc;%T! z#eVZBUsR%bUh9^`nlugyY>yIrmj7BYgW9R%qE^FgSFrUsgC!ziUMUjalay+VbeC@1 zW5UT?pUwKRT9u|@cB~z<14%EQrAos~x{5)n$Ah{`|I%`*fj44`nYK*5yD#=499s(l zgQkI`#+($6*(TJF^4(2Occmtrun@uh%%5!yD}Tidn^`5lMe$;QijG%i4U4=ZJ(i5! zOyRC#X>&$V+*MKsJP3pgnYBhtJCsGLrfMjgqtj@Wb-Xd=&4mf)c#1;|4NR%M$UOR6;43{OBxn z3Fca-_GIZ|sK}78blCa%SpfHHQr-PxkwPt!9HkP0E^O$hHy{>_6<0->yk#Km+Fp(! zP?U8eLwy={_*3@4MDA>BeVFTGWNA=p8CefAA2~46%($$pX_}q7Pu;y;f`3p@lKizX z91rDuGl$`x*3WGrC!_UF3I8b6Z2}AVuGpe4bMSGAaoT?KuMzFe<^3A8{oKl4$_CLO)b)D&urbq@y!OO7QvK#wV zs=etL(hXu|YfN2?Y4#Ek+&GRmqfR+enusfX*GErv%{l`vJHzsC05}POxal?6ji?ho z3vz89gWUboT8Iz`Q`l2M_A#DzxFs9^qc>$jQb(2?+|k%Wn=gE*zDHZWGO?d5_gyZ+ zwOwm4=S#7nlRDcfi@*l8qqZpsPMKM}n zrSG3U548DUz1%wQ-TI_G96x;Il#Rzp3<17`BJ+%2<1*e>%Q_J+^GeY8JczuD_#I$i zM^3oeMGfA9<|$njcKTM|__i>p9rzE-B{r5gx7*kNuIpJ=oR57eNd{=2U|EBg*0KKjEt5iq#nT(!Ti2vJF_90?S_3;*_HIA?Qs;Upd#&;iEjpgWArSOfF+X z#hdZHLT=-pdR9~Dsv1BH4BK*k1j?U=I+`M;9mFooS(oaEDA#-#Dt@Pk+uE5}3HZI1 z_S#i=W^#=>EziPC<<3EsN&->SNC1PA0rg9JTiTgrt2B}^Nr_=UD;+xAnP`(rk{KqR zovpr*X#(eUh4LCqTc5M4nq03IG5!E#M&iNxIy14Jjx=_E(p_!?ie6**lFwa-op0zc zs63MO=7v^kes41qX~5-;*%1j?Gg~S)u#pD1i%>s&DHe;V=WuSYT(!-2>=)67B$aZ)3+wIJ(|P-aKH`p(7$E(c zppr!g`pXRANg^)jY`$Mnzt|=61ap6$Oj;L*Z|rq}^WyS~*6vZq17*|oUMI&=>Gy-g zX0-<$ykzeWUrxl8yXISObbJ??nb_TVkWvm#y0Bh;WLIKlRyORX&2V?=pa=oU>MCgh zYO2mvb3_``&vTDLD?;KL`7%{7+faAC>A{scI_1@ytV_4u7|}kz$loO1ewVg9 zcs$Y5%@uvs`D5gPoZ4CHj@d|uk6wP1@V0^ATq#;95fb-;~mwD>4XRC~y?X*2;< zpn{1pTx>_J#Ob{3Nzx0C&TlkyFB>QiZ5RuNiCXnbi$n|bN_m|ik3Yg#z1fL*NW!Ox*j9Bj;uSt`7icq@o_)dK{!g+WNFBlrqLTtLmo?O}$ zQ%ZYqUG3ix2z~`|JW8FL?B3w_rpl|Xrim>&Xv70=b}S%dxtAYl;X6 z8LR{K`8C4`;;BFE-IqRR>;poNUL0wCcfS;YM?cKPF z86RgO33V-Jg_irvR%0;cnTq^g&^zj$`#V^EB1n&A&h~2W(&t^2R=c6(tUFbiR7iiq zq1C$f6*vKMTM@KECCY6o6Q7Cbb>Sa}MgTp+)BL=!N~f(=8iArGEQFE3`*M@GeLuzS z2U0rZqBy8OW08^#1oRw>ko5;KiRXJfG4G?%!j#xfA|i~n0JER!=f#-%9viU@1~V}h z>ajX4bZ#VS(@z)k^-mfc;-hE+gAaQ) zon18_coat1KK_b!qb1-p;Dyae>0LPnxet~tMt`^*0g((9kA)sXZ?t01rX*t}Ork$B z`bCcd373T`g`HI-KRhK?q8_IkwIQ||`vD5@tKPD-a)spgUKHe3WHp?|%A98s_B8k_ z#jz<8uOU{kC#@Zr3JZzs+FH}8wmLl2G>aAc*`u;{S+-iS60{#E{x~U6 zW|*z)(RCJ!$(W9aLj53<*HXNp0#N2vGtKyO-tVAhIs1mkrf(j}?|eoN07%x09>SBm z6}>DUJ5-SOvD|6#{BBVRI+=)b>hO|JLD}LE2~OZdTi2cHbHkMJe5drMb*VmGp4L0Y z0>zhQr%w!@`9@DsPj1khaO{~>y-Vq`*xGXd_cK97`KOwKlG)(E%M5knl4C2Se8LVp zM$@0%1}Gs!lcXO^!6i-KJuO1s{&7cm6sq8HC)f85c3)fDO0Id{5k(S?t@;3DNd*w2!a~KO z3VBP@Nz@&vLL`Id?Znp@`DBII8drRh(MS8iUKZ^?gfyTry1VXTE*KxyIT;XqncB$I-?|a^9kaB~Hl|5V~&=K*G4JOZa2GX8}dRUK0uWZR>;bl&uT?VvEW_ zo9l1fIf&EVwIs_IES?OOh@4I2iWd2J*Id9)b*N&-cqcg~`Xg&F!YqPf+l}jsH{ZRN zc|`-5*wSM1>ST3w%v(QFWVHD_nf}2I5IDsRw>}Kv>nSD|3D%Hma5!b6{fSgCC?yCj zscuQv13a4O#AMX_)qIJxwNE68)4bb&_*Y8`CmLQb%UPP>h?DMzEF*WIud_3tlHf|l zIPSnj|MXuB1ktsGS#o`?-qjsdrR8V?;|}uA^Kw?5z{0|s-L4<60240jSe3RqGTbPsLd)TgF<@}gx3HvO4o0pOrr(i-L;}Pzve?t42scy!~PuRu8#&Ap|lRMG8?KcP}c?M-Doqv1J z9rxe2KMd`K83E$tfBivC26UQq23-)GSW%a|3)zWT+zCt1qaSv%9x z!u%`5;fGZoDQ}glRp0js`W&=9fqNYJHBGOk)jnGNvRVLdkC(Wh29j)p#->^_cY*s9qK%}^BgeDK+s!M0h+SS|Z(rblCLieA`zUTsipp0Mk{wkQ>AE*A-nuU<`K_>nf3zy5UP#wA89Qw z>C(<@y2{tTpcJv7+A^->3@;z4dgpO_12Z>}StlScGK+}59$|-@Q0V05ZEfs*t{A+s z8bnTk9c zxRUqLeF>JH_0Xc8a-&50HT&`Tm8ta!Ek3*GY#S&9_v|1%bes7GaADxGj4Esv8QPD! zf3yN3Sdh+fH6z@_^u_G+B=n?Dw;#xqLOB}(v^9EZyGmIFK{WM5P&>7E4v3d(+H_REuBf($7woMJa)lL7ORaoGCtO$PP%z+5K~ z$;f406)m##e8RE;oVOW;OhRJ?cjC~*#%ZRV*Ig;d5CA`nU z|GGnA>WE_{H744$hK~P9AuyI@I81#wn&}~|`9V9z)tax33ITK-(+Q)L!@q> z0^tR*xIDyeyYHmL58A&T^Gw#u2!~(@PfW!A*X9VK2HC9K#F*T@@>_`&1~^? zk(wOg7Z!es>tO-b#IYd}cI6RfI3$yrcJJ2$g6Fp6L&s967)WD~OuSL_z&vbo2 zx}CSf+UCKOzI}&P5z~;qYv4*o`6lhfS%*SYtL)iR5Qk^=JNJXP5>eDw+wP=F$+EBh zEA?zAKzZ}+BW5g0E@B8zZfh!GC~(4R^k-R{T3Jp0^7`@H<{?WcpFzqMU^cYBHjF^!STaYlZ3<8^%8)pnx)YwU4jYMDG>RuU^mga;=4DDaJW+ z!FNy!sLZA@mMYpu*zF~|o%{i61U6C4BDGqX%?oxt%Rs0U5RfdQ651yzKC`8cyKIdv zPxIlLpy-RW_^r8tfP1;l()=N zj&ae>u!BPjLOxb$Br2D-+N-twS|>5WBN%(s%oJ_^!(~RV)dj=i4NGJqbv?_3KBl9N zSNpg5$IEl)bkU*I0|6EP;E#&l@oGRL8LuRtc)@v(_gCbMrbsIymIM+;#SbWm%uw@0p6to);8lUrlQzy~~Na15XFqN2?%pPXwiHcuGE_5y#-9^_srh z;u^o&eHogsVDr^FQd}$PZ~Q>Ezcm9~0rrgC-LKwUJd%^~;@M%+T@9tb3;+ z@eu>%CL_^vLo-=)5d^nrd4S&*s+N~9?fKL!K~rkkj2#dX$h7@$xsi|6AOtEZ%|@ki zJ|{mLkQ$Oqcf}g1K|9gCPS02S;))3`uci_Vc2_y(or?0jv}6o~9hG_zWALl>7)Ote_oo(2Pzaj#HVHdvXlS>MbW91g|y= z#6zo2Z3^gQYEHq}B!ApzRtSDC<_R;OW{{%r;VUocN6GpA7{p|JbSKl(8*HhjOC#w- z-gRyq5T{!>Ptt8WEf1&`L@##FzNPO4*!Pb2sjM)wqoGBYi&hnpBrrjOB@+xQj%M!> zkn^5-T%%-f_1(iGqfh!wTGiXS#ckwqRYr8txv_;y9Ntux+>UocO{#zxXUo1|Q%&tZ z5*=EKWU8=V`C)?3oJ{vwLHP?O=hkiQ29-dE%~Zxc&jQX7>N?lmw}jUe-gp4w`pIqW zktJFf8j0XX+jy^GHqn_~_{k?5(^kaRQ4O*~?wRYT`VN&-hRrntFJ)Oy)K#q6r$%Qp zYGq_EOZA+)$Yn26;@*x^&GCB&y6PU~gM+NM-<^1tDG2Kx%ha5Jv4Ps}Ez`})B2E=o z8Es7wUY6x8W~Bx!snfQV%YY1Oq)1ZE-K)z=8iA z#cuwLrFp|S(}a1L6Zg5s4(-dShb!!Qp2CI0B8S3;XiVQY8*BY+3Y*8{AGfyAs_tdW z>{YHVICnF6EIBBap^%g>*A`o}w@|e^rfi7O-WkK~B$1~*CY#dHpR3LNbJ~Pah3>iP z!->MlhvVn=4a#b*9?JAb{ss7f?}ysZdR8t>c8=fiR_~;av*GA?J$V1~hh^iAri| z!ahQJDy+;PS)h!j_#p_x2jB87--wyn8!6f7)I0-cDi&}p4VHliGlMi`Pno&P-P9Dd&9;(<>YR;!Rgf0G4>Y`0 zA=ge>%V5}vs~naTWed`&v|ylgYv@RfP&>S*(-FC`RelJRRipu=Hf+p4u!6zd zkht^Rw~BBs{7pHI4Na!MGD|TTR5|&Gmt52h)&tpSuyRoSlsp?Q!|iwU39>QG@?xve z)$jA$S{LLmFWmidZ!uZgY^O(L@zkdCM-_Gr57L~D`YtfHA`Z^AIMS!eV++Le2xI{! zf9`;GjVuG$yL(*6%@vE*c#2E-?kvT}8E;Jq37EeT_l*ful65eOD?GNH52Alu;Ki&r z&vB!gZ?U}%egu@LDj5qF$J*Z2t*(~6-0pkS;X22V-u0qL$YrhW-NC+oUTQ=i%R&^K%ue`P_#sq!DmYZDpQqamWieip*ox3(mkB=)w zkTl6RdiLbhnXoJ^9cg~B_~~e~g7tv5(;=Gt7@jP(9=xpgP+{20Bud0fS|e_COCHUq zmul}BI?lz`s1=hsa+HLC;Wv-HzRVKCWz&`~Wrg=>bi;g>>t6M|?;GN}w~kZ~=j9Ba zn|s>#I=+-nitK&U$nW5$It#P2ZY9$W3hD9b^GseRJ2^a*?$#~0GwrPC2`c)~ZK?W% zKnBQS;DQ@eQ*qE*_cd6=BFuYp^}H3 zL#;Ng0l}eVOdSu73CBK!OQ(5kEMT)-LjvXiHl>WA)ev-QJ#4|@w>Sui6=9y?mawL% z?C5%7yEsKe(5g)Z6|DxUV~2TAF9r>|kLMjlC*g#kLM+y$Ds9iL91oRLUpGlXaJV}B zI!4nPyo+h;8K&*$eBq3=a^GnqMuOg(ND>x3acsm*3=V@Z90H>KicsI{?pgx|Yu ztUf_+Os*pLW$Ey`rbEJLyfUGO$XI=u^d~mNF`)oLU>1|+sZh-bXF+}qu}w1@5VC>u ziu#Tg6$-v^7Y~>1mNvq*S~1XbdTr#^CWDr(21_RU-mxIeikMu00;xZy05pek5gfV@l(sP9%r>IkLE~$)~Q0(5gAXv7p|Cv zzjead5Et-88=Rat6X@v2H0PH;DLppVw{o$}Ts9N_<3k8=LsSwT_WsO?V(YMs{M?a8 z^>*bW_;(EmetjfG4UQe^6$wKN^sY<7+_}}5vl@sVH2b3?WGC&oU0n{p8oLeJm5sEX zre3}<(Q}qgB?IlYV}pTgRNL?>e^XD4zD9S`aeqlez1b$L{lm+#q_Qaz%9+U#>J~_6Ps?&LjLV3voic*Uf&6KfY;*`syWNdf%OJ z^4vGY;l92N`suo!8maH=e)=kg>SB&Au?PK)SkI4xn*5j`aRYD@7I4o1FsnS_x}H2` zAvPMfY(`9CKWd!Y`aLW4YR1`Bb)cjW) z<0S-b7|%yKL?|;@r`8PF#t-PQAis@CLIXkiHIM0;r!|vQZaq=7Fh12}{vs0>&{Llv zU1Uh$2rT#2==T!~V`)DkSHx7nASMWzs(mNJ)V|awY?*pl_~Ae*aZumPvyQgS&0oIl za~Kswav~fYw{q`V%eg}hw`cQ8-naC85t9Ekw99wmROQ%ZVTSpU=e9Bcg^0p&acxIT zOY67}O{<1$>f8M}p|g(xfgB2Ioa|?mnFq z@bYVX2HurtNOB_K*n1qHa$fN>oSKfnjQ1~^f!F8+ec|orTK=Zb(iYinpN6$jw2Ahl|{Nn6pCh<}z(W@uj^YbdD6+8cb{XdqyDNMwlZ_k*? zZ*rVR5mx>Fu+bO1;9q*45}RFr<&kA(kf>6>ao=p8l!^Gwv?##hq=Otv(@Z#R$=W+* zc$1sfeGnI^##T@Zug31AC0X(;X9mH$$64GJZncx!k<%N#W#(^OK6H~e|Hm_53=CzS zr+f0+>PG|)($zpWF7w|3OP8+GB}3HL;y;aYI?wBN?aX#H2i%nTXiSjA0X}B!=FrL% zH3S%gY4`KMNIxs5IK`|L;t6!u@p7=ERVWeswekZrz{>ORTTr#kgK`mXQPU-@p&tjj>i?;q8eVG)2FPlRWTYSy} z6nC$drwP7a+8;;8c{~oZkB_D%s-KtxTllm zJ{+9a&HME~gPY1hvg|CAYzKsRRrc8aXvDHYSVos`2LCIi%1w21#p^1AFF=}yM<>)Z zoM;P*Q#f29RTNzVK!Gv|n^k*8RkPYIzyd_`bOd$5K;uMX?9E(E88}V>3`S) z>oPv&^l5R+AQJleo&0ur008=Q%|;?2!&0me z%Q2nok3T=R*r%ausf+$f7mtb&(uZBJF#M^0CqO-t;{TX@&Ql3_1#lAYfP zR}E>^ymgct`+m`b2nYxo7&E$fe*AVlQ+@qYE3DqrkDNidQZWvmQ0BW0@gcL@(&&CIz0?DiQ6FrKIFWv>LLMjxqci}Sxx(!z4#31s!z9?R&d*vOvj9PUGxt$As zyM?O3-+BM%k%psYmA>-o(!oyuJoFcKnAq&feo(&Yi2d0qXK>eNVW9N5QHm?aUqIXI zqwV6?*R56nyitO(R}SPvDV1NbIjsI6(drJQ_i|~)UQI(p$~AQ~;=PMmR%)mU8-~e$ z_<_v2!msCIUW*M+*@s3R|4xD+!60pKD@|Fg2A57p^^=grlA52%*AscC@~~HB4c)Y3 zWhKz*s1A`1daIFXFAfHXWRn1@!=xgdrF0#hz;vA$R+vb&-8I9jzTMD=R1f8BejmOM0w$&y?d+uK2WlcPw$jz&qi8 zpDAnTxDz_wu0B=iPG@d>Glc=r!#*;RU9dt=n_QyKW&2sjvj+K* + + + + 4.0.0 + + + org.apache.activemq.examples.federation + broker-federation + 2.11.0-SNAPSHOT + + + federated-queue-downstream-upstream + jar + ActiveMQ Artemis Downstream/Upstream Federated Queue Example + + + ${project.basedir}/../../../.. + + + + + org.apache.activemq.examples.federation + federated-queue + ${project.version} + + + + + + + org.apache.activemq + artemis-maven-plugin + + + create0 + + create + + + ${noServer} + ${basedir}/target/server0 + ${basedir}/target/classes/activemq/server0 + + -Djava.net.preferIPv4Stack=true + + + + create1 + + create + + + ${noServer} + ${basedir}/target/server1 + ${basedir}/target/classes/activemq/server1 + + -Djava.net.preferIPv4Stack=true + + + + create2 + + create + + + ${noServer} + ${basedir}/target/server2 + ${basedir}/target/classes/activemq/server2 + + -Djava.net.preferIPv4Stack=true + + + + start0 + + cli + + + ${noServer} + true + ${basedir}/target/server0 + tcp://localhost:61616 + + run + + eu-west-1 + + + + start1 + + cli + + + ${noServer} + true + ${basedir}/target/server1 + tcp://localhost:61617 + + run + + eu-east-1 + + + + start2 + + cli + + + ${noServer} + true + ${basedir}/target/server2 + tcp://localhost:61618 + + run + + us-central-1 + + + + runClient + + runClient + + + org.apache.activemq.artemis.jms.example.FederatedQueueDownstreamUpstreamExample + + + + stop0 + + cli + + + ${noServer} + ${basedir}/target/server0 + + stop + + + + + stop1 + + cli + + + ${noServer} + ${basedir}/target/server1 + + stop + + + + + stop2 + + cli + + + ${noServer} + ${basedir}/target/server2 + + stop + + + + + + + org.apache.activemq.examples.federation + federated-queue-downstream-upstream + ${project.version} + + + + + org.apache.maven.plugins + maven-clean-plugin + + + + + + release + + + + com.vladsch.flexmark + markdown-page-generator-plugin + + + + + + \ No newline at end of file diff --git a/examples/features/federation/federated-queue-downstream-upstream/readme.md b/examples/features/federation/federated-queue-downstream-upstream/readme.md new file mode 100644 index 0000000000..347c60d810 --- /dev/null +++ b/examples/features/federation/federated-queue-downstream-upstream/readme.md @@ -0,0 +1,51 @@ +# Federated Queue Example + +To run the example, simply type **mvn verify** from this directory, or **mvn -PnoServer verify** if you want to start and create the broker manually. + +This example demonstrates a core queue deployed on three different brokers. The three brokers are configured to form a federated queue mesh. + +In the example we name the brokers, eu-west, eu-east and us-central to give an idea of the use case. + +![EU West, EU East and US Central Diagram](eu-west-east-us-central.png) + +The following is then carried out: + +1. create a consumer on the queue on each node, and we create a producer on only one of the nodes. + +2. send some messages via the producer on EU West, and we verify that **only the local** consumer receives the sent messages. + +3. Next then verify the same on US Central. + +4. Now the consumer on EU West is closed leaving it no local consumers. + +5. Send some more messages to server EU West + +6. We now consume those messages on EU East demonstrating that messages will **re-route** to the another broker based on upstream priority. You will note, US Central is configured to be -1 priority compared to EU East, +there for messages should re-route to EU East as it will have a slightly higher priority for its consumers to consume. +If US Central and EU East were even priority then the re-direct would be loaded between the two. + +7. Next the consumer on US Central is closed leaving it no local consumers. And we send some more messages to US Cental + +8. Again we consume on EU East demonstrating that US Central messages also can **re-route**, if no local-consumer. + +9. Now we restart EU West and US Centrals consumers. + +10. We produce and consume on US Central, showing that dynamically re-adjusts now local consumers exist and messages delivery by priority to local consumer. + +11. And repeat the same on EU West. + + +In other words, we are showing how with Federated Queues, ActiveMQ Artemis **routes** sent messages to local consumers as priority, but is able to re-route the sent messages to other distant brokers if consumers are attached to those brokers. Decoupling the location where producers and consumers need to be. + +Here's the relevant snippet from the broker configuration, which tells the broker to form a cluster between the two nodes and to load balance the messages between the nodes. + +The config that defines the federation you can see in the broker.xml for each broker is within the following tags. You will note upstreams are different in each as well as the federation name, which has to be globally unique. + +``` + + ... + +``` + + +For more information on ActiveMQ Artemis Federation please see the federation section of the user manual. \ No newline at end of file diff --git a/examples/features/federation/federated-queue-downstream-upstream/src/main/java/org/apache/activemq/artemis/jms/example/FederatedQueueDownstreamUpstreamExample.java b/examples/features/federation/federated-queue-downstream-upstream/src/main/java/org/apache/activemq/artemis/jms/example/FederatedQueueDownstreamUpstreamExample.java new file mode 100644 index 0000000000..cc12ee96b2 --- /dev/null +++ b/examples/features/federation/federated-queue-downstream-upstream/src/main/java/org/apache/activemq/artemis/jms/example/FederatedQueueDownstreamUpstreamExample.java @@ -0,0 +1,29 @@ +/* + * 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.jms.example; + +/** + * A simple example that demonstrates dynamic queue messaging routing between remote servers, + * as consumers come and go, routing based on priorities. + * using Queue Federation feature. + */ +public class FederatedQueueDownstreamUpstreamExample { + + public static void main(final String[] args) throws Exception { + FederatedQueueExample.main(args); + } +} diff --git a/examples/features/federation/federated-queue-downstream-upstream/src/main/resources/activemq/server0/broker.xml b/examples/features/federation/federated-queue-downstream-upstream/src/main/resources/activemq/server0/broker.xml new file mode 100644 index 0000000000..5c06f6229d --- /dev/null +++ b/examples/features/federation/federated-queue-downstream-upstream/src/main/resources/activemq/server0/broker.xml @@ -0,0 +1,118 @@ + + + + + + eu-west-1-master + + ./data/bindings + + ./data/journal + + ./data/largemessages + + ./data/paging + + + + tcp://localhost:61616 + tcp://localhost:61616 + tcp://localhost:61617 + tcp://localhost:61618 + + + + + tcp://localhost:61616 + + + + + + + + 1000 + true + + eu-east-1-connector + + + + + 1000 + true + + us-central-1-connector + + + + + 1000 + true + + eu-east-1-connector + + + netty-connector + + + 1000 + true + + us-central-1-connector + + + netty-connector + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

xhH&T%=U1R#23Ug-Lfj>P6@N4_K@h;+x zuX4IrN;-mw#^pL=O>#vy-=3sYU$3*Gf0F1J4A=tx_euYwk&u1ZUnY3%B4f6I=bM^W zdAD6+*qKq>o%{5BD(p`iCZBqkMWk)#>bdEx7LdIw%Dz^SMrTImuZwW9{uap2+&sFB37rDhWqy$k{&%natY z>jKqTOhjtK3VgG@$SI3|>~Ad{|8m76ROwn6(L_}%#VjMq)uWX06K;)ik520|f@DqN z-CTlvNtyb*TswfZZ0&)gbT?%P=j4?3v>j<=dTwerLHJb1!tu?RawZa6dZtG`jt+4@ zr+7jGrt3H^#Umpna9AvBDABH&o$GFZ*GFQT_b`y9=!K3(4WVW=>wjYOv@pbXIU~&z zHJZ0Q?NonVYqE0TA<1gm%K}(1x9UQRYEBa3oij`B7s%d`yP%e1# zUU$}$z$dQzLt1+%Le#Ii@YYCn*^F_8iJZ|k@GMP*h~Y9(5si|F{f^FnHj#{S=0M+s zw>B+KPpvt6CQmm>XY&R1O1$nom>Yw4dXOJ2U>GJHzmjPJqMIbOzd;+w)0tL!4-B#L zXC{C(BLSB5jO0Mz7g8X$&B$Xof&AviL)^vrBgwV;38c7FA8|!ree}^2n^eX=Sjn_5(IY2R-S8rf%zqDic$7wJuw4)fRiOU%swCI{ocIHzdW8HvJaA|UAr&6(Wt8l zL}`po-QiEzY*@?6gSXULpYF$4>^%$GHoC+;|2*uIa_A^NYFRUD6Bdz+!yUeZH;6RF z5!0QN#q<&5CDgz7qoTOR!Dns2DRF$y z_%N*^&?fbOhoAGx6A)R{ejdmSvVv!lZMUaO4;-%+f;S)w98#>Fab6xwFBn+_g#J6R!Rsqhl~!F~75kqrA0ncN62#BQW4E|Q^SEUL8tmh1}R)6yR?RZWSY zEO+`J3CAvLXb~8AKK;H_6;?U+NePCthU&Si;Zc5B=#D5o${ZjR>BUvw zi&%{uK6kB8MUIfZSUsRw+@O6O0*Zpde_mclRG?#N&g`^}nE2Ss-~>N*(sMhQk*E&W8S;@%kdhm?hTs z1wXI;_8#i>uG@1sAT>5y9apRF_i^qP)X8I2+oYJ(*wz_bUxo5_K^h&(DC)YFF;afj zv(#j6w;R@kwLK|jZp_lklSMXsK1@&Sq7u``-O!pPJgzajNvQDY$1M_Q{`6eFnNVg2 z*u*jc|0UCbYF)37_vP| zr*|1E{Xd?>TvX^Tv2)x1T{`e8RbsloH@7l+>A;+CL$_ zcOqkUhFifT@LYySN_Bb502|K~=jy->tGJWmFDmXbL&r(+``UeI6QJ{NT zq&Ke!4S!83j<8uSSFhh+LivJT?8u#i=XTmhtYwRd%|?1=`0k9q^?pq(4=(5aL}li9 zs=5-2)&z6ZG~=tNXuWic<9qpw&Wy5A+?9ob8;!q}#jt2T?o4QHI6D2i*e{SmP&jy! zyql^eay763sMr_Km08-()6egRFut@Tqdd`fQp#g;x0S}V?_D3NNq9yXBfjf$M}8KO zovPr$GxdVF-~ouW?mT?3(;<8?Sdc=Yg^OYvHlg9@QyeuYT}p+?lz2TunF0GVP!^Wk zEaIKgc-RPyfn;sZ6!fMJ9=pu#PFwO5F0IOiw>v>>U%398Gw`q=5k`XbHJA|VNkWlW z`nA>0>`WP-{2oe3go$WX!8REpoU#(Yxzgz-PDC~4aNG>EQQwBvva;CLo z!zy(FG%*rfMevh<)TI`!bJw2%bfyT#o~OndembylG(}Agy@gZ&*fURQFtQktxl<)fOr0fq_&gNW;0I`wrTnO`*|la$inUhkPU zrH{^JK^ALgpi`DQLAf%A8bjBULP;k^y)wlu_okfzX~%+sT_`GcjpnsJ*KLJa`$L6! zru*3Tg98VrDqr-nb;NEWfhgm2S6Vgi0EEYJ!m5*BV;QdHA3gR98@+{7@8OLc0%T?5_;m!TYp1qCe4sy}RNS7CqkDYMmD z;mF{@M*`VH((!dy*2v_gz&_6{Exlo6#ofr=%<*-!l>hvzRuS%6T{UBUYbBRfTNU;DoV+`7z=sgO)gA>EYgB zICgsv&RwUtMnxLD^cyA&!m!-pS_Pd$-Hk5|87YJ7q8-cbXJW%`;;h9WG3l(K=Ov!) zuY;nTK1w!9w*+0^+2Z6Q?@8F>3V5PHLV3<+#7r z&rZ9c78#gQq5r;cn)YuIh?%+7ZtPcR3TtI_;?2F!LEgC~;M*}u+BHA-R~+s6LeaB- z2;l%yQu3~@?E-L^lz@7xD!39G({Qyt()^e}k&$J23#>Xm1~+_{h z6#7_y&c^8(ufZ$%PZlDutyXk%?K3Tt zh-!Obf}haUHW9K zq#V3)EA|J|e*jb3)C-4BEzR6qlC#Vyj39 z@=ugqn}Nv|m3h>OtX(GO0t#CWTsuf9El$t2OcBgzYDVWvSO0~3kqx-%z=k-|KN~c? zBNQ$>Kv`nD#cuO;2~-fzgV$#-R@GV81*{9tA@8E|*x;oVr#O@1p8e(AiM4s1LaUZE zwX47O(*MO&1VRvA&g%vr8QXxWnd+?0h;{W!^}PF}TyCrlCT<;;3sL)Ym*~ESaJ?P8 z+gdxe_~fmBv2a01eo9+kVzFW-8&eMK&AM8NKn@6)oz(lD9|U#2m9duhZq-F(79RQs!n%!@O{AiOoxQW|=g0$fs$q##c#-b{ zfNVdgy+&ARbz(5Qb(2* zW&;xH;954!`<<^a3^RV@;n6KRh?8w(*7KjDFmqQEk?Wh-zh3vFfhQ5nWtdW3) z!6Ayn_4dX&-NF$*JwoTNPo$gOPFS+8J+T(2)_>J!3F&(GhM)qlN*Sn=MQCU$EOV;w zZOdb8i2kxA|Fwy991}L zxNL-vP#ejdzjn}3j~C0vmIKn8#HyRwRS8@Q*PyzYyYQcG5F5b&!qQjbsa<*VspJG* zmNK{W>Hc>w0mKY_+ZmF0FEw#LLbP)JRm`=dqTdgu4xi;q`Bh7t$`zGuDC4>reW6r& zaloY6XOR-qkAe}klNMYTzTimKAf3+M@`=7oiO?3hb4{vCFs0qG#H#4;C~dCQbfc(% zoZ$F#yRs>$@j+R`t!TD}v=Zgnhyq9)?GWfT#CZ?{bv)kno2ErMm28&~nvH&!M~$C$ z-H&G*hh@%I#;1eCx5fvN-d3pxy_&YEf|ThE*&Hjz5^)`n_S zzm=i1#tXO{S7hQpv;pgb78&aW&mFe-Tx5YnemIL!VbS?G>ArA1u92Nvm@vwBdFQ3C!V(=p85!dbr%!_d`x1OBc}dSBNdVK2RF2U@nvp0L1;DG z?>Evwr4F#T1p)fQ4?01>Rd_SSfjz+N6PH`9_Yx{ z8s)QfFLxRWvchm^!rLwaUB@OU4Nip`Y&g=t*%ZA<1M}9=bf;Jnz}ozUTo0Z69%8Dm z8&DQ+0)_9(lK$n`A_SR8ZT=;!wMrKpnZ&_TNVUW=Aq{!dxvR{i-&8Hhg{=@6Y-MeK zqfKi1#cXq&TT^$3J+?B)=!u56!}FES8c)Ok0gi!Yho+pfLYtMv$o_vJk>eLQ-BFFvJ3BflKT9mij$J-4I&55_uUbvPy@RT7DSqdwYoXa{6JgYi z;+>^&>{NAvg+l!HPP8))6d!Gq_q5iRq84|Lp9GG|+810PF7+>c2iejYprTrk0RHAr zXeY>`5LseS+Wqv+8HNQo?NL|sYbB<}!2+il>_D@e?jDeGe-IhRb4g8oVW}pFK zw_*72$$`c04atXYKH^Txw5E?UPbTc)De;*@v%LCs*oNKZ0%d#z3D?&|x#<%GN=x!p zWI&clU~sT`@z`t>D(VZ&pv8*HiW34!o;+oNTUx>|++nv)iVTJAEAvD5@tlVD4?0w{ z8G1jvjD;wRwF*yPh<#ZS=2ySwF?UrQk3Y_4x^N!T;wNDg>^s_iH~FsHuqK~1Zq`V? zb*tB?zV>Z&$9A}MEz87}O`};*pGP-3hGvPWv`sQ(L_JR)w=K-DodAvZ0`qjbcnY=T zI@gyr<>FVbeIokIKY|-BdcLzmiB^dZ?_Zk&cM5Q>6{*a{qxIZVE3{PfCI~b+Bk|-Z zaF=3x_EJ%4KDF5-2ToHK&8~4Tbfa2dJ$fIz=yU^oo}VLC0%e#={~r|y6w8PGkox&0 z?cp=8&d6rffi)>IzN!HK0hifOQE`MzO$DZ&ybm$)@rG1+JwT2ZF%hYjhB;%(mT+>L zYAl+X_P5~9c$l13rmZnPRR!eIx5c?>`{-kp!7cY%(a2@JF~lC z#{^?Xk(gj|$<-{0q&pmybu&`4%?ZVN;c#ueBkV*O@6)`T3gZVBf;RrFIUk{4(@`I( zil6LAUB)8C689ju^Vt$7gbRT<919}@id zjrJ&PJ$KL?-4m>bAlst)*U3DGc^conB?>yB0GNwUE*wyn5|GNHqXVTs;^NM z6?er&I2lMvdx*`iR8NOOspos0+;d-JI)*3QfZQNsMXKIzuBMQV>U=af${q!bx2BTX z?b3NkJioga@-DhoWvwh4jZWjz`GBAQ*p+%_eY~ zxd^-h4PL;AAtB63DgVFRFo?D!1^xOm2urlP_u4EWEuS=U00}j%aMC1~G-I(zPA2~4 zQ~P0Xy`GA=Iyo(n>-~=n*bhQPpBwQ%E+HNUc1N^zp*!1Y0Z;o4bW@x1vqmYG zs@qlE$-QDT@FTiUH9`05?~ap4;Tk;hxAwHAuaE4U&V+v~;bzk+Q$BS0ptoBGSuVnX z*Ebz)rJinyf4uBfZ}F4IwVMK4%wNw!AH8}jT%Dt3R;vvV{bD2%p=jj+n+K(9`ioOC zJ9v1C-j8>){^SDjk!t8V!nbl!!p1of8{hu9`wBgzSXezT}9YpWv#JSylhMPcLX! zG#jDtIy_%21;4uNvwnoEhn7$EYJA@9w3oQnjSPcayquBn{-oUUD;m!rp-b;rnOd>% z$I|n)sZgyQ$F$~0z0dn(`1Z$CKx+Qw5pg)1d1mpRbE%8nv5U*;!M#u*sALT_hjOP5 zpw*RJ$oW<3x8GC{Or$UCMw3S9dhaD`poJmkYxE;c~*PD;>qnQ>CxqOn8C31 z3(z|Vb>A7MVgdMG_X*TZgjsH6QvIk}tPQbP6nzhcX2jU0_I?V8gb!KN?`_E3lP z0u~?tbWzo9WkM%i*adrghl-y+WOlFJX>-7`fsZf@n^tz#U_&2ZX045<^s68SP)8?RPM2(Hv&KQ1ee0hn=iY9+!9!T9y|?ZQ zaiFb0^tQ^Cb(-22a#hj}Qha400Kjbc%hS1V*wrREG{61{E&gU9C+oDET3UMGfU@vA zHH4gYSx$i*Vo#qZhKr9Y=$K~apwCc>6k;-jedgCS6ukGN97!c+%)~1`cBG439DO<% z?uJWcIV40jw*A>fEoafh3d2lP4e?+HcvHMR%bks$qjB>@ux!oGjsACv*_`ypfX$1g z#f;o8-@x^wy8q=;*uT05ih8)yq?2NQ-GZ&|UoD%;>xwau8Yy?b}&EP{0&w{**y!!tCRBw-{ZXyQp}j;*&FMT(?Vp zaWbsSW^cib7DIRYH@S!3SCTqOn29k)yZcAP<87GA@*9RmpRP}|<6_Rbq{&}OfQ_W? zam1mx&)m-_#2*ZI*dB4(RDN~qs{UU)2tp88a#NT)fG+{VS0jSQ8H73=xOM(n%%9`; zltJjpIQ+PSy;yrW{9y5ULDM1Q(+o4~II02rTWM6zh+l7&*eA4NlRm z5ssUKdH8Fn+pR0rY8?rD^ZExh`mvOp&yk?T<^qcq?tA)4JL(Zv*U3c!(r<1Jlp%P0 zr=?|}yLQyqHhxdJG4yXwPU2^7w9w`+m_Gc41DN7Y^CX0!W>FGVIG0=rdB@ za~xw{c#P)HreNlXQC4R*v6H-mu^IJpbQ@2UXkfld;sSRi||4bq@7eNLQ!Z??i zQd_D=6?zr%BWtF~jq`_)bUt-E#Y3{7wL>+*kM_2z|CR;)5rGt3;pnRcxy!fe^URa2 zV-LaEC-I{f77!=VB9VKmkVU*RJyRL-5nDdIk4^rqa|vdBTy}C_92?2xB>gjbSkaw4 zWW6KMuq;zajO*>U*=^b>2YxfdQEF+NrOmmhdzJ0v`}%AmBfjYa?UyIdaILKq%M{Ia=i)54zok0lO8>y%Wr zxjesGupX1{#3}rh=FaXRG0+H^K##{FvGu)9gMzA>2mn<3JmIpGDzC6UJ>f~`e0(EX*PpL7U+9ix!Z`k`1V zw7y62AlbR%*(2x_Vr7-wCW>vi8e z>FLqik1VM+p5V0+XnUrj!fv{K&||XXGtocZFJU@2GNLa?d@`I#EM9lC_W7JG zRjS^|8J2qQHXxVLs-aoC_0a*FsxsiG|KP+a)a|KHYC$`OBe$u&CPHcnHG54#b9ZpA zT_jM_X2Ot&ul-{sF_$1qna6*X7*=|?Ph#Hc#@%g__R3mO0*f2-ek^-F0KAnA)~pGw zhXWu&h#_%>ZG%|85j3X(s6Jdm?ik--)%VB`lqaPV#Rvx7C8DE?Fi7?!=IfF_LmEQi>+w0VRRm|KmihZ zu}69*4e@F^=!26hQheD5VOK$1`h6>ue%8%hT0;im>z_910)vb}KF3hKeyY(AnalUQ zs|u!xhlUSr_>P6MaF2JAlAZ~}2jOusJQv9w|0igDfkPsAUrMa#|3}t4JzPFE!S&h; zih$f6j*r#xaY9BR9>c`<-oCphb5d`5ZYaX+m6rcirjbL#N4xn^abUJ|qgTNY;N?=_ z^9X+sYngua4ei9K&}%Hq`o90I$7>Uox`EzJ#+fEuw zC?H{)B#zLryBmIQe%K`Hz3Eq)Q#AHvk#p}-(#rXGzyQu{`*r^}_t9%*%8cSJW=D*` zi{sgpA0^1265U&BnGzlPmubOY``S*h7!~CM59^TpI+=)&V4RvBDPME!MYGDQnwgKX z|C^g)F#hHy>dkP|rMd3Pw36=uw$BdR0Rz8?14xYH5lcNCl6cxJ`5x#u`;CSo_2*pQ;oY{vAjuqOZW#H`@yErNqSx?=Jl0k`l+W9W*`Vwh{_pN1~iK;xiH@_vqOtDN^hp^1P28AZ^PhS zYDsc`xlx7FM}?~qdncSiWAMsWioboolvK#mVlcIL3K!~{_1$5glxX9J+SxVm%HvNc zSm%~rYu;p;C-LgcjQBjQ>KhH0{{KsB5P=nPp=>AVRTX!J8orbuncXZ046Z^U1?^5s zD*cv7S4{Nh58QS+x1)=JV#Jr?=i26~YNI6Wc@aVdzJS?eYW(MN1G* z1%xGD0=gq^xD*<&_xl>VO9ov z%1!(N@OH;VMV#i!$5)An|Arr4mj#Eljf=ycKV=Ayv)MqzMV@*VnRuXjgu@)zpOCM(^h-As(_&@on|xjVd)GJXkcgUUurbJh z8b;JI0@4bwNclC>J(s>WH18Q{GC2J3nS=~q5hy>fT?_PVl8^ROXz{sIW|Ls$=YIvP zm`sjrejYd7zuA1raqQV~44t2Z@Khi~Cb5*WN0645zjl|%IBLTsSjQc8h8!8W6RD1t zIXYcru=VNWPE`UWM09b{V)GOY)Hkg3@XV23Y`e}YVSraQFGn^S|K}yMYNCG$xz_IF z2##miij3kQa*sY<>IfI-Uz75;3eV$)WlJL{{EH|OA|yeBlxj!BS+V5Wiu?l?5nQm& zN1aB6POrMVO1YI@cg(pr@8o`Z6n6Y(9hSIbV?g&-5)wHVXo6Q{(rED;PYt9nTTxDf3qZluwVZaaQ2 zH1NZr9vKnj_hE^utx>A_Z~@B7X-m1iA;Rj92;hesoe#R3CGF2mN60nOyA|}LoR|>m zS>tH=-Vnk!q``UVt?QHoGSpsaRb5uJ1RY`@1v>Wx2aTJ*ZGlzf(0#drgs%MkVeOi` zY5ZCtxi%ND0T8l}dM?O)=oV*VMAY9tUNbT2SQ~0TwObM8S9aNHq9>tP@&A*DFoW7n zlY~UwgpKB0BV$tGY)VN_-9I)Q9Gt|6L1_EFN3Fsy6!k@%e$paLfj7bg8hy5u=c0Rk z1=Gm7RyA%i1`B@W1Xs{H%Pq2tB}|+`3ji0Y!fWD1V%9ixdxX)mj!**;1?^#gN-`n+GL0q?D}mZ2vL8)1}DxLFNjM zlJJY6fj6U^I1LEG?_h*ic<+g6E|LzH%#*hCAR|~^E>)$^4;hjdQlAao zV&HJClr#E9tc3yD{+Obc zVOfSXFwVD}>9e!(7o+W4^nA!uhqG`cO3_jZ_G}YpXcM0*Sw^kJ<=7KR{oz1!>JwqJ z>)^2F^#J@XV?s5zEIe|1Fhvm)&g|g90ozSSS$`CtQQ%sp>)@^5>PA3rMPQQK;IQdf zF3pJOy@ESfxcYx&S#uY%hXufF?F*YdycG^nR==q4E*rS<>f8oN1zM#!43GEC zR}42`9Y!W;;~t?=f||j0uDI+;G-gZL;qiEB#j-o+7lpS0LLygZN!hZRZM@A31$m?< z8rAjUyZvaU-WMPP+Anv%-Z4baz5hnME;oen(<0oevoueIX@3 zrvP`IpC10jaPZpUo}cGg6hZvmszj62^vlXmAri93A2b=$n_)5z9~d7jBrw(7&KdkA z>j|N4fGu-Ptc>lz&zcJnlk$1}jP@R;-(F+&rIf86p?IAxv55rarEk);wI|@I${oW- ztwVQUq&`(^!vvguywB1D;*^KyP-KFM@B+qkd9{Ugt+*3Dp>FTI2skx8!y%=TMOrTa znpnj$hsd0Bd8Uoo77Bs;%9f+eyEdI?kHs$YKOj|uw>_t_l9M(Ug*Q#)flOv{i-5{4 zO4Qg!sKnEM2V=25?4UyW;^Mk}aB2srih?D7+;;7(%#{J#vwElqr@`p8Oo+rF?Stc$ojL3ub zL)LDXS^y{Kv{dc+J;NtvKUCFWe!T1cm9x3*do_%238H$Ty;~yB%Un(*{9!$imJeA8 zM=BWDLrOB4=mi4Ti3d*)fGcHCzdvo>#Oe;V4oiB86P15G&c#xARxU&>$Tp~Dc~lS?5#qH#!v z0*m}AsF~b~DizjFH&v#tm!v(O(K8+b$`gL@*>E&+E;q(fWBew{pqQur+B`E~s_vF^ zzT=_&0F>q=og~bZuRWeV*H(UH1Sx6>u9zFV3 zKdV;NtXcD!rQZCF?f{shOz@|YDG2&yb+~q0X@PIZpP4_Q?+D;PqgJGlFSk!e#~tO8pa_Nz7$A4zEw0KgKICMu36j5M0rj1PA~oob!i zbi*5p6SFc0N+@kv{*5xLgJ1uNthca-!aRpd%+r$~b!npK#GJAVKU)OMe~2?v?9mT& z1m%lhtE5|rP2l^tqX_wV6{nr^DyYGaZ#P~2aL_-SBcox;3(44gF))aWZrS!pr(cHq*?~(4$i|a=4NIii95OHz+dwz}d+(eN zb&|_0$)l@@>5Sgj^EasRO?h_ms@Vez4)PKE>g9Q5p8tmQKw$3aT$785f9T#cUWw~V z_)S{D_J6OKbaIORHccbc7Lw%}AcE~YGic$}V{M4q*26IyRnR&j6)w?8!AD za+%kZbivqdkFw*N;M6dqfoxpUc0X3`HJ$=AzYk3N2TIgSlB?EuXgf>|@4pLcdxMJ3l`i zcB=X;Ew~v)hBzc5OTrDM9HImFF4VeferY9Dr?>o`gPW5lU0k21m25Yu8&il=cMB5p^^95f}w)U=(=pE z!SEz^AUc*aX8`{q(y3Rz8CsndeRua+@}fzj>DRBr_Y02KVgP}&?<2GDZ7PmUu2~{& zU4D;09OEzO@+r1SBOOzx6=U4yPwX(V0vl>s(<530()<=E>2beqN8I{$?81kT$;%24 zzt0M!rjf3ht#z&4T+K+6SZN^bw;{o?HVLc^0W;`@N8qd9Ucb--Cb7+>O}#Kfs^edN zVUl5XP?dj5MPY=|PFF=jjxtNnumWcKM0GzhdVlL#h5^~M0SE2iPn&qe98G2e zw$3;yw&WH69woQ`!d%-%D?`8=Lw5a4-9XAj-!gHr3Cv31em`c-wov`H=jQz6YJYsZ zeD1c)#$_gSV0;-?Bswi1$z_Q*;Z$VeLaPI{{Mo9Vc8j`tS>+@bm7-anXV-`b+27vyMbsjvVS z{>a7{t?H1*q zE{=sBunluMI~Vhyv8+*bl~-OHbYGhaQsmHpHP4%goFi#{a3bOhObX*BJ5xfZ*!)4A zb?jV08d2_6Q~FcIty25PPX5XPp5m6hw9A*N@rY{*ChQ zQDDpe8F%ommJ`Rb-G-z#@9tgN8V_%1du4AbrT!yxWrYQ*mPJ-H0Dk4qDEuZTrmM>* z&z%<&zI*l`<7~FX!CZNUyPehtY~apyy2BJnxt@EUm6X!!>Jkq2WVYqrh!#Bn(d~2| zS!pvLJ|}=!tq=XC1FkxjBOk3{*ruAcj4)zV$Aq6lQwAGNaW-v}fgW=SHXeH@OE`73 zmUmJzj+fC^-%_bu10u9`7yPCpnmLd=`RTCCT^Wou%G_kMJdovPG6ltFF~78VAR0<8 z5^U$}eK+hQ<@)IN_^(drQP?j_h1+Ysj!EEcmcTel;2sU(pk$5`@XrvP&BWvO!=-&Y26_8mnied}B7itdGT|3>5BAQnZ}(HT)j~H?ss2nFT-RgU`Mv39 zOoqa{Jka3dINO5mGv&7$uLV7@8Q*AaVj^cuT`>lJ)?e~qYka9}vnWLF2rn&LPP&X84z&~Z1k-Drl`d*Q~s1sdV9 zY68M}E;XMEp;c_6qL)N|qEmMm(_!SAbnGE(v{HTM)LYmkvcTv>L)rzBvR%%y^d~W4 z?*i?Txt*>`dDR=oq#v)bP)M|rvYj4iAZn%;9y+J;wFQkFR1jFK+ag!8{>@nO$D2;NclO!%Bwjg~>CbImXyc_8JOxC>o zWs7RxtElKyWxtgnM-)r>u3zd|!kXfItpGtB@AFB?Nq!squm6%u6P4^DrIXC>Y*8yk32SUU}wIlvQ+G&&Y}- zlQt4{@|G?Eh^o#7Nv}l2r&|#GClBzze*D3Y%`-(KS%C|&tfbt6?R-D4$`_OR$8VG5 zGgQe;47((OIU!ThOl)L9=5{%M;CtH_Or1(j*CR$IS8B}h#w6-2Hw98xQfNBv9q~_7 zt>KHwO!{mIjdr(6#5q6T8qq6KDI!3#yq+aR_ZmwehsI9{0?R)f*Wcc2AZ3ai$J1^< z_j!Esx`H69q!7?ERG0t4_91qnq=62wG0z_o{-i1h-VhqO_%Qe~brN1-a_f5`Ncb^E zuJUxQ$GCXe!*6_stX0+||I=uY_3#JQ7UA>zf<)G~cAlc7my$Ui$mV=%#_~7f(JXJ| z{>3cgoGX8f+ci@~(?30Cj;LQ&6Y^RU$=ke`*gXA?$E@2ywSm_xabvytSOj#4ez^>KCas@O!OHO2~ajyftZyuzA0py8G;nB(@DUS%RUn!q0`VbhJV zu0?VM4Z0g4mbsT`7_qW3_vTZQyo~o%nNa3EKhT-+xlzbSiFf57bm5yh=7t;0keD6^$+ORapXKm|Lj(1}4Woy26XIwis-bb*(K@W9cASqP>w>E?j zK3?9tc#=&KV#U!C>R=_9U@%HYZSMVLqt&yT?}%+>@4aXbY5diIp|%Qn*8lg~qd;b5 z)4C!sjjgX2zIvE_9AdY~eRdkbqB#8CoNp6lclZ!H_2_gUgfGBGP+bjIrGAo}-k?>( zSDUp4U%8G^Pb2z;jc5c?h^W*eDrao*ou&+=^H}>%o0u|wKMUa^ir{~nyV&0lhEsjV z3V=5-iOi)V4T)Sap-pZH4}7&@ZK7x4YgizF?fmS)N|3@16X&4f)be6oyM9_$GqBV7ZvS^q5C#gEig3%*>sdQbghyd0JaGSrWRF%adeum`NS+IwmXCE26- zJoIj?s{@A_!HPUb8ps}0h>+M@2_pvGo(KHX+PH8Nz5^Akws=ixd#5ctiI+WeZ-%-K<_pF!4l=v!yC+73E6SIAZuOfLqD zsMpY#HGV)&4eh7-xK;QN>*xd3q9*e76c(&*=DSM0Aq^+#Q(ca7*pF;bX1z~G!I7h@l-wOp8%_?uVr%EiOSpIv!|6t=;c6O5_P@tB$pAZu-W|Y8m`!+Z z+78d;-KuLsm>Z`ilUVY@UvL}Ci90g!R^ynb6^<+XmLP=>NwRt|nPr1NUO9sWiQ=~1 zfD+c_2#fw~Afz=4g=q(s^!sAR!YoKQ(6iNsJ7&4cYOQAUV*`pfSbIHST+LWwn0SgYBy1E9N2jpRZMY7tgraI zvxQ2n3e&KV!DyHgp)gz>E^G*Zyu;peGzUZ}+_Nvr+){P*BCFd%!HTmHRbfbfbqDY< z6d}3P5u(R^Rgg5W_%Z~V1<9lf&=}(ykSK+-@PDyq(~Qiqc~i$UhA)G{UBaCdJ^k2aQq86F*SA(*)FIhE8OhgFe)UN0{~)sQ%!zsm%hqJ&M{OZ(2R_$PgZ(;h;0` zqnRTRW}WsM7$=B2-*+=wy+x7RJ`=Y*GUrT2TLnCbrX)14`d@=8l#mDRb`@y!GoI!d zi{ywRm#6utA$xEk;)d>QWd%mLQE$pO5qmuHh;1Sps|NLvb(x9B*?=wb79P}=#xn?g zM2H4B%B*67s9&MLC#6?K@);Q(`NA!l`+C_6!{9NI7GQasQWUZ(=wt{AqhpnjC^au} z*V6L9EE*>ibuhpsEijCUW5PqP!OAP#KwC;j?5BE#ZI)a*<)ieqz0TshV37b0F&?8C z1fNe4DlC8dPHMU?u4Ktp7}<=Ve!vo)z@7jC-=I6c&ax}n{CK3!5q8rZ-Ov(5hsk3S zt{X9$5BE{!R(zSA`ALJErLHMOc8u&p(z}Sr2-QmX&lv-=HS_Ipr}#=WJDe70sX_S| z)B3+OnXIS0@cG&Zlq2@SS@(6QM^9?7&&VwvO<2>&KaQC2i&MVHCvI8THJ>BQMI>ID zaQp;Y0Q9Yr#-dnuuuE~1nuo^Fw^!F)nuHV{efg8FvSB|8L&ZlE1`-XAp;13BC)L-t z$G_0<6Z1RQ7)?53_~(TBiAo|=(~6eN#9<0I&l(%N7^36i(b(C&91W&2BDjcS=aQl^ zd3PUL0*!DygJMqK2~FuQmZN?M;d8%+{~{E7S!$UlWlBY;U56Z59i;G<`>QvM?qP?@ z)0Kf&maL;B`@?j2^^95iPF?Y$SMTQ}Lz5^IM02z$h}4uo=i~2^RKA`ZOPU#cU()#G zh1?ybzdpS32kzu|#oz}thTBVIzQCrszQHPFdd$V1etz}LG`iQxVfpU9qJail_v6xE zIbSV0l|jWmg+1SuThCdq^AYe?xnEDjM7lfq&?4YttbFy;(y8ht*g}A1bVA96JU{pl zrr3ez@9BJi3dHeB9uS$yd+VKlyTc?aq{K<5an~quq%|tRS1H7(S<>coaKI{*OARhA z#!iHqwrTypEHf+Olfc;-0W zTJZOg;K?bSsO~A!WF{B3!iW~U>46G^wk;56ObcPrB?n$$V=&b1jU~cCS|T%{Va+Zn zFYO%4h=`}~Y@wkUL#dv>)e?_UO&7Zh#^JK9?ty!H^vY(qZr#Rb1Jm%p4C)S25)vlk zXJMA zo%_aoT;#}W@p{(^v)%QvZ;7$Xj)xo>Mc2yzzEy&#f_hji(EEuZovUlF+WbvyYYuqx zh%}Hdet!EB!ZOkt<}?XHA^Qoe(@4#)GoP}4OfRlg!&fenpqiM%A4ig|pa$59AF~B( zq0b4YUU$5DaFP}mL@J4@c_oo1T0ZfaMl6Af5I|n-fiVj?>!;o;(M4m33`55i@vZ|D z{14sUJjsW{P8p`hlsvay{mV<^`^N}oV|PXAzkzREO=El$7td};BIbuyDV4gdMRY}@w_43V|dhFz1aB} zlie>RCNYbD+~Yf31E-RIGKxQ5pkGx$){cF6^F|tP;aaw{?JF~d(hpeT@okeO!oc|Y zDIOh?{GGbi=6946_@ah!9Tj#amquvq4LB}A?XV0f3mTeub`^Fo!=)1}7_Ov|87~Oz zL~hWg3_juPs_53lD)Gv@1|u8u=dZWEJx$+FfTpZBzua~EQkOdd;1;DnJ`J!PDOI{I zkTRNY6G(*O4Ut*a`ZCgJOow>QoCzQ!pS%}}0~wG-W5S!ttQ_8Dh(JpRyK5|kZzxfY zi*S?Hwb`J}(IczIuVxb|iI)qz43FBVdNx$yV`200V=s+g;)q-2V5 zNMe0VeBvF~G$so-_cQLh=loLC!4;t@pUW4v_rlL&68q=JMx;|}ydEOfKL`i(*KS?% z+MO!57U!qI`lQ&o(#i<Vc=!k#wMB;b)@dk}J>IjCIcR0c5_xYr5QYRIT?rw3OkjA(pVrV;Tb1c-7lVz~YcG}8_7z{Cp- zqi&zrw(TKmcz(~na^oHUEwjIPl*{dW+_$$BdRpYV*q&pxm0u8FT#SiIz-u`u-}fJC|GG=D{CTQ zC$$fx`5Tl4?rYMyt#Mai`s7VZRyujm?5b{6&ZV)GP*eJ6OPdReT=PAbwSN5d%@~zB z$KmOb{L$HeUD)1GLzq3!vQ_NQh>XW}73JTvC=Yo1}0fD3; zlO;K+*2!!9e3CR?mCqLR7uz+z@%CyE(n>WMUdRRN{r*-MRiznxGKthDMwn@biOht^ zA@n#z7hVf5OhqCs;CG_-5mqI#P(*U(WbLY`9P5X0Dsy>hQzzF6LvO;^fdTreessRD zpcLflkO6x&4@gC@%*G{j!++(Q(hme4^~%x;SewfSlGy!x4n@?D_IO$CJbb`%mMnkc zr6fIr885~YMMoNDQf|dM7#6`NFhuXn7W8u+ep9$}7*DhJ)lL?mf@%&Cp5a+uk3@8Q zrtB!rwaLZiFfy+hx^}0(-b7TF!BY57jQoIubawKIbkx!;x@|5GL3^Z%now-;3agAA ze!6z{{?S)CYLfUR?Pi(qSz$`WqkB0ebL^y^i6;#PV>W1^-IM?gT`?vmGpM%rBAHL0 z4mXV^g})`4yN)yVPRRC5a8fiwcZ%6JSAi<5FElaHV=me!SYft>(S62YH0=^43Wmvk zMlpSO8Th_vogH}4#G5s`Z-$B?XP9kDgI)sN*giw7qi%IWIq=olUBbbg3&c=(&TR*)x@>@MO$ZO5~fwPmOkixN-z5%o+UhAi~`n|d0(dle!*pxBDc#`xT zH+$27h@wmi^r)TiT5Oq&*zd&>F!g8Py-i9O;mt^8AApK#ifeufT=qXqYstTSl>E6{ zML(q<+xNgIx!{5#JLRp}LjcSWARMyXC8lMeKBuy2EN_IL#f$7*?f00?L0KnYNlQ88 zu|N1kw#I~Ef{UAeQr_t1MDs4 zs}z>W!fE9}&}Ifmh&z25$n})Ah9v*p@*gh%Lt@!-_Sh*vel3PRDm!?bk6kn_$CB$q zN}9*WZ;Bc^ET3ClfOb-`OA|BZ9qlLLQ6qaFGW4U+;h5(J^NS^eUe`5)!7=bbjq{3$ zj51vRnu*|N93_Z-)0NdsUv@inwP>T%7Cs{!(=c2@tXl1q>z-oyw?fOwr_|H5s0H^e zz1+OF+7JZ0=VSKTMycO1GpirQO_n^>ax^e;vQ12&o(O6Y0vB8EK;iZ37bhioFlINe zS#t*U`on_>oNlL4F9J>D#eX~H?LVFJptlhRK(ArwrWBE#Jm2=?O7k$Ikf0MGoNywn z4u@{Rn!TqR1z=1a@#m~>3mvs>Z@qR<+0Kky!I8!UsDcqTXZ6$Sc?jQe6(V?BuqQ93WCnD)2;ED*!lv|2&F%gs`WlW*OWTaKleD)q+ zJ5`AbgM(PGm2E_R-l6C51E!?D{aP$0K5@R+bCr6up}}2Fvpe5+k--;ukBS-t43X)Y z0lDTjK2sgZ=w_GuD|B>O%&W%REqxR=1Bf!+ydWeYW!L9GZ2{=J%j_+~S=Ur*UZi@f z=MRK$64A|?I=`(FxP+i2>Z=Zu_b2mXeNH zTOZJ|LE-1}5nDjW#>X<4(D+P_0|m0a$dA@X0j+n9sA2ZZzI;pRPOOuK|Hg`)G--C= zHOj;N$g8V`QP~*(faxXqC09-Vvc+)3vyJ_bUR z{L)|nvM)u z7)NdXF01rT^NhO;BZbKz5_{oH_^)CR1%&p2IXn9trA6m#=% zY;I>Zm$wyOk77a(R-QaX?eOAeX^>?*rgAJ~=xYjt`MR1ey}2U76KP}}2Xw*#y~Ru! zGGiL>4lQrYm0|Kw?5qTlHl2NJC_nJ|3+IGI1>p`*AX;!%HGSjTl5g~12Vpq#0O5mr zCY_o`(p=D9@0NaFxUX}4^)#Qp#M(I3eegQEpD7M>di!2lgQx_>otL|Mo#-4JZQ~S+ zJKp?$E78keXV?WG_f+M61YPz-g=`Z$`yNoL7~)`G&iBNif6+}#o17$8Fcf%>8Y1y@ zEL@A3Skv!FLu$_xFaG69xNsRg7q!I=P4O%xY!FVJF?jK-FV)27+%&mQ+2y%}{84yx zK^SJ^41LKRZ}?G5CLDi`NhykC`rBa(i8UF_%9 zSo#m<{R@5nd^GlGv*KjH`xqI7Inq2Sr|Mx z9he*Uq>+&xMC9oP0^WLzEr5LA0w_+sfeU|nU@ZXL(At-5LS-BVM8#5Ut7_<)>6Xk} zZF+z<;DGS*B-P9MiG_%t!`Z{qJDQPqa4w1$-9N~2ci`!~sj3|B$Oc>e(DFu+vm&!u z;{5X3h!C^If|8jKJ_s}$O|ON-bH(a5wlS4*iV}KuEtEJD%Z;X|6gAaf(=2OMxGZRChCYcWae&NYi#hmx-O^%Pa3i)l~Vc? z;M_!2X@RsBl?%ESrzmBm$#cBVZy;m9c07PRfAtt=NTyV0D08xp-@@K=wba{69R|U%KqK z22?ZJbQm_1x2hfLbd-H!Mep^4r76L7$HUjI?1XeV>X-4QnX{54X?FG!N^3(*W**Xl z3^`;enk)O=XH=tnV^VHz%#x5TMw4F1Z!;L#b#3jAsh@TFsEA{_e9*;E-dCImzpQTn z`{S8hNtoydfT@^MP1Frg{Ahc^P*Kmj?|~^igvMk)(&R86YpQODL!Xv{0-hrlW(j!Z zH3!u>`O!!8KEqH%rupX;_2=epkinTZ2+%bLVNW8F#Z0|yP}w#Bs%)-no{u2`k1$Ok zU5jHTh&}no7@RH}FJ08xQU&135&#e3!}e)9;DDLsdo75NV4yO?{u86aSGbbyYd8q< z{3od82)vo|o^Uv?W}MmOP%mtmUBgL^a(1tpoq}TmFBMOBU1w01fb2}|gdsKKfv$w@ z4~T$e9-k@=kY{I%~Qib5w-RllDzl}NNYQcNqz7PWHOaWvpMXa7v` zX}M5?SfML_O+a*iNht98)|f9^EA;j1ppzX!cF$5w)w179&^R7!u5=! zI*OClbmf4Wz!ghy^Y=f}#ou6o1^S^(FBglS81!CmvZ76wF%h71CNzlZ@s4jHIL*D% z>5?08bNnU=*vW;Xt@TQXKK&#OYtDe-LUUs#xqRXh5;-Pe9y>K4ch;8=SHr|k0v{{v zzFAx_*ixIMFh$ALFM=Q(&3&tED7N=Ys3SGG-t*g|RyY9@k$xnVVR~Ga>QH4v_JI>| z>{({O_R}u$&6+zfH9q3f)io~^>1KQi*Tf2;wMx}OLK;0lh$u}|vgJ_o>&2RmsQeIM z+X(Gm#?fbaw53Xak9>2nv)B<_*g3aHEPYvj&ic0%y^d7TL1!{BelRG4o9PWiZ-hQY zxi1~{(vG4>7{+KQvQ@u<94S);FWb>e{v18wIryX#br*0;aqM{tQmwd1^tk9Vo=Xqf zI;*)KeT%z$fa@`uXxL_tx53{gYMC{Vg;y5k7i8E-CJ#@gw|I!T6CblK7m$CoQ8p~T zs?srkO2}o+L7ICF?WFVb6U836Vrw#s1dSYo;#BH6MTSAlE$ryWXlkP zi*J_e;&3-Qvowr%QQ~2@Z2=xADKR-agrch8^BB@H6KaP)Zaqk}_!8$zh)TcgE@>Aj zTx>v)ZZ0a%LuFYNYX-$%>Y|378S{86-^1#tS>P)Yss$ET;{bYH3}vC^Y`oDk54A+a zl2H%9H+-dsZK%EJVn8qXS2q|7zxz{CsH``8sz%)jcNfyL`&l`)$#N_|GB;;XkJSE6 z#s5sm{-Tg<*uWp)*vVCeV``&f^Y3*sVC=n4Y8=KY*?Pm$4N4wIu%5+RSq`2$nspAD z!Pv78iM|EvdqrzJ;e1AahFD-xY4L!QSn z9N9Vxp5#vx!|Mh@(Wy`zDqmj#i~4jyPh&drV*r3@Sc|wUL?n1D_m03@@hdtal45(= zaTE{JR7*@>W`l(w#LWOdK?mrJFH9l?uRzT0ey>t zd2yg>h6C2Tjf~PRmD}UW8|MOUzLA>L2+(Rp|B&v)1 z>L;U^_pd2oS4-s@`fHQIoi*v_KDVj)+g-6GGX5RYsrfqR^#9BT{~I_|knckTi|JeF z56fbmEmYkRG2@ckr-8{xW*-uO2b6BS0E0&kua~_pDVaD-exZ|l|D%iBqkz}iRrVGP z!X@fsdYW!Er6ru*{+KwP=*-jz9?Wuf65paoosgx+5l)X+k=mwI{_;@YHqQBHo0?$# z{>EAC6fV5jc6E)DOqSvmJJ^atKq^1o`IL`h#~W{|9A>u16Lr3?4fW<;)Ijpv5h~jB zw8CRBK`~D>f_$8jqha2w6$#g|grw+9AS$E%#N0mPLYyIJd_rf+FL(tuHwtMp0S}4P zX3>d^KJz1sbT(aT1ANl(M0Pzn7Jcm0>#_CoC+vs{54S<8qj!J6S{QvE&1>JIX;xh-ZSZ%(d;%B@NQkW74+;4V#f7?A^1ik)i`$elqRArA8r0-bXy<1@CorUhMW9m0bQ;WeFtgc2h4ooIyjG?R)WKFM+d|_?H z)O5XzCmq2(+C9xGGCKqSX0UPkYy9f#{{B~{?Lr$F$KGz{7iu+AUPL7|t*@4e^|kub zJ74fiNnV8_U{}nMk7WPvQq>p=PB)qoa;L|i3k&+4SmFBL$%3QB-HE)A0czj3hvC7i zFkrRhbhFhu-L$wiKdwH8_9iymW!i2dTg1atlLiTY@%x2gA+ZB^5gw4>EhN{~Y{_K?ha#^Z0{UWR1gprks$q#?B7F84qfu1p^(e}#ic(sK8+g%*WXxCy&F zu0Lqq^Am>eQs3aA_c^O{>b@N5k7}n%0U27PlQOH{_${a`&SY?>*m<|N;gTa&<`ZJc zv^Is{b@aojCK)MLAL_QeDtYFR{$UVSP@q=$8GNRu4xje+h#t+wbXC1}GgXn^EMBhq zo`(kykMOxqcZpHX;f{Ah3TRwOP##t{r{mQk!)RC<>_>mm`x7 z)uZR4w{J?wC+jT|!P=`^ZbzyY3MO6VC$6B;$@$ZXX5&GLo*7V6_@0;nBsgjx^u{&9s}W9% zD48(?e$751YxR$>_8l*llsmI1_$m1)%L8}bWmL3~iPlDsUC4~_z17Q%W^q7H7v^KH zP3|PfO32=#PuCCH&@f|EI(+d-6p(~?-hh(Zif-3{+v;mKI>OfMlWk(m7 zpSyw)tj#X+ayXG^=&0UsCms-Y<&enD!x6Kd;i~5$!>C8xC?f@Hmsd~Oj|G0=fZJ># z(Q&B6!O-sT3(Kz>&WT1h?xa#nRr=WIy2{UO{K#9HB*kf(h>D9+duzeV!f$e#d& zYH?V&)x}-_6SE;ZMYu*NY_LFD^3Qs>gtKEIP2%_4*!1(xUVEJGY#@~17B*r8(&22G zRHEIxk`hnd1i&<|57jmO;85_q608 z87S(BNdzt=yNzbJaIl{~lBZjr0HB&hrKI~g&;wA&s09BCeFRmZymo4{e2)%h1zx=8 zYhKRz+lY22scj(tC|;l@MYN|7)(QFNXc3&X7+)TW;{goa0}sh}jdmtll*#%_;;4-U zs3^Y{Wx-xHF14-f!BO3f2@|9gF{m9@u_RB(wpqgN$~CB~%aom>!7Zf&(CNa1mL^@o z-)a$+DD(Apv<;auM4hlPYFk@zt(FpP-6RBV?pgE6#Bk~o(9Y5$n^#T0)*Te<>VH&m zM|)AsKNvarzL3&$BGKmSudpRqXl`EGQ<7nu*S3uv+oR5rTGC8P00!n%<|aqXgJy@* z0m4lz-Hc5y{BUg6& z3-n|Z`6Tr05GmAg7r!sxV9Ko#$?^|A$@9&fILFbnOKpaZby-xC61za*-AWDX#c2R&_$3%msDnfh%|g8$!F~2>;7G0rR1{ zX5(5soTL3|H|i% z2nszsD5Jmhz^L%6(S=3Y8%MI)dyZ$6Q!BnN?n0b#*+ zV^)Q=i)6VS5Lbg3KYlHy(O%vW*X0xdoNzEq|4>fs;vpB0(04!$;!eqoNP=yehrsKdJze(EGj-l!56UYg9oAwS8B5YBZwndu+^#Mh>6 z*M9v@{vT)T*B6LeF?=HzCgCrBQ91qzK*zLm&CbjlVzsD zbDejVTD7QR1YnPK9_z3uQ9Ob5->O#=ROUUa5o5((wnVw6k$}-_5D+%1_c?_|p^2P` zUp@kr;KY#5JS3JKW}}u+LZ$7WK<~5@^rHY7G*j?BUGoWO3ZOhyr5MigjnzvptVzgQXD#7gO1>u7~0NM^7k)4q!OZg6z>L! zZjU=Y%}k)&nH*D-V-8u`inytS=2Xq9Cj4HhXxJ!cU{-X(D`^IA@MFtwTBQMjgoaq& zWsIsz>-nDF*?HYss{vLQX>d+*(Z2i$_vMZaTi@1JVfJ{(kDj6U|L5KOUjc%^16guq zw+lP^H5yv+ny|Wv_Z)Z(zCi=-hr5;MgK#TtzLorSyG1P}J$umU3B)ZXv88Bqbd_jK zbfBrr!`s>`I~))9POirX13b8cxhV~R${k2Y`1`6%Fa)~ft)8NhW;X$&`eH}r#)wvB zQ#K@>yYYF`i!VAUGXMv5U8gbx0`8;6KI0TH0`PCLZeWIN1^eWccd=M!5AG9nJV<;x z*U?M#9oQFLiK8KTYM;%X0I%jIisuK~^!caiPu7?HM2ocNzBW*}=PK=zKoPWX% zjR^RXD>qP)9&zk!I7pJxdVh5zdtCxlE~T(cS9u*!85#F65+p+Fx*2`xj|drvLC4^< zFa2~P$FM1>D4!7@@ui0GK>kzHrGf5C2;WpOzT2nhEqEBfVZEZ~Vs~^Qu z3A)bDMe+aQ#IWt4(#fQPlGo(Kw|LZo-NZadNZyOfATYfs6Uu{7-lW@KX`C0jA+TmD zli!k$p0kVUJ|<+af3$btK;kaYbW@{Kks%TwDxpr1;j(7KUtI57_P>AmYLu9u^G-Q?iGOjl^@+YM%`wPH`nNV3fu?r>uI*|%>^ z>OCz@Y3-_Vs11YFB@&)asK;>CKbY0DW23Hke1fTz&~w#TmVl8ahgB7Id30z^-g&8u z@FVvydMQ_I$y);->MTgxb{k>>6N~p%9=857o&4WPn{oTkAca(#(b_b0zn}|!dct8# zKCbo|8cb@@<4SziIytFSC%E6qio#PMFq$XQ5dj`=?mNJ{%9y{?qb{ZL(_UTN|b^|xuzS!D_ zhek$a{itWBwB!rga4-*0sPvd$BhjL_3=Fesq7wc=dCkUh@5^*yz(!iMz8)PWxfPeZ z#oMPTL7K0SKJ0EeNm1g)c z${b)wxek^CP{P8=;b+LDuU=s_(#Qqi44@7@&c%RTcZHWIN_v4o`zah{izIq2cWi0^ z+K(PXBV*S07YC56lCLiRcMFd7It^b zo?SWL;q}IVtE+pra@W+~;ldHT@If?#LuZHY1gF9U8Ej^Wcu=wkaHV<3G>)sW(>Yx)NWi)d}jV;%L}h+t%Mx! zo&??OIl_j1mK+)=7KgYT?8N0^z~F!o*-f}nNU&}3<@_Cr6Gu(vKLY|i&d-y>o>%L9 z?i2EF6N0w8v&ik~JyYl%dt=W4jW8Gw&4%q~DI27iD8Ahe-3l9TYEQhrHb)?^%m57K zkRYh-dudfZP_J%pbLico8BJWzV_-s`b>=AIb82;aE8!fe6CM3Ow%##34zBGQZqhVt zY&B|Z+je8Sv6G3N#Cdq>#Iu0)Bmqecx-!Pg159v5d3M%+l{j+R|hl~c9 z{kxJPYJ4g%fK*A}kk96+v#0|L^S(P6IvftU;tkE9;PgIzhHY|T1E3Rd`q5m4(X#3F zHOt--G$1@D#9zOT7 zulZtwf_ViK0QKl%uN;$MbCyh_6NbqR9cDQtZ~Gubg4mD(k0YYQsLLIVQ8Oc;JGCXZ zxZH#ZMpH`p!SK&+mQ4<9be-pRYcnp772C068^2FS5bU_t1oqS>v+u~}Kr0)YzM1%T zX#aTD*6O$!liJ)z0~m&U-GB0?{v%<}%bkLEG0**YT6X5QW1Y9t3vv`$j5SE_l>$Vd zCf7&LU)o2H(Yh_Qt5?xhe1U>c+ZNJ7D4O3kGLqBLBBdH2~95v8mfonscI$2!Q+obvJ2A) z)-XX{MO;tfp+nOiuid=$FGtnqu-Otcg)S+0|bSk4QhD< zj7bS?c77JDcO%Wj*KgZc2_6JP{kTo91aTBZ&of{oT5aj#F4IOSOt>{+$3V6Y(CB9f zIVMZkJ`;^yF@p_=-z!t1S~!iWI2H*wYoP*3P4%0e^vO#vtBb7>aGK@w@=gC4C}LSa zU#|_CJ_~vaFFfda0%?x~q(8>=_|Q$lpnam{_&dcB;2RjYe7Xs90s!4Tu0~|`jgRm9 zAuMkxAD=uX5CKNtXI0Srw4lIFg~WVo=A$tbSB<4bgbp963(PkMEwo$I_of2TX_(i) z@ZHXYMA{RkomBra&&yzCYsM|@7nVbmGma=DbC^=gZRi-4mvB^wp8$u8&cQvZ6?u|8 z%o)bQ*BCBkK}2vz4|e30oU<+#qLP;OqEt|yxZNXTvwbJya7z(iM;Kf0Hl(^*`z*DW zqxP7IEvcTCP)%L%HMD*IQalI`5 z$Zx(ZJXgO(o%!TCdeve>V_y{3_R0#2;gaNl%*ypAfd@1n=(gHxP4!5)Y)5%rq2|rp zQ1`b~-yc|I<$z4fGBR+mXEoNQV6%$(5&bf@z=Q?I82~YX6Vz?Qxy4Y&?y_9FF9{_i z%vdoa?*p-j>~H_(iNMq7sJ!#3_G!CwVxERziG9GtaPW+(qF+cTiT+N8+Xs-F1+NX- zmU=FF&aZ=grD{cbm>#sc!auY?Lh?|Nb3+pprq0?p&g_MCR@bp=kmoLKW;}jyLqZAlE!$#aURY!1G4y)C|?oMH_lLj(LL#A#@We4*g5#qbh!SRN5N)3DE^$IbI@>u4io&8kAl+pIg&6)QS zGot(_pKRjsYOB2LEm!)BAiT?jlbW~`wrEZ4AEONl$T}j5?gkb-2x<#PsG%ou7^BNY z|CMm@SDz%(z=2hrlW!j*(jXE9gZx&_9v*TTW~}w=;ptj^%rgu3f)vzeX7i$;%YF_* znlngpU1u{QRg7o;ntAV_@mbmzJuk0r@XBiouGFeRbR+BI<>E_T2h>VI@kqU+Eu&a8 z*^qQ&Yl0r+eMzYtmu(MPI=GFW5&Z2U%l_Nk5a>AT)l6h4(0gH?wS;sRD+m0uez+xO5vBA3{T$QTr^ADRkhZ-EkIzrVucm#i3u)L)5Y@rvJ z<u%aCXAQ4hf=T*nXXSYYDq*_8bT00RrTOQV<&* zc{{l}Hfwca7{XBt-r=Dma{Q(q`5SU5&7xPAGd89$3hEBLzc7x%3a&8-m#OLj~jl^)U<9W0X@HnzW1QhQNME4 zIs)gsExme|Lz{pPPU%%0Wp2wiwXsO{FsobW;4UQ{&lHc`0;l%Gf%GfT{}wypCy*Xi71CnF$Da|AI)A7yj$mN4SmW;h6eQ_w%)7b|5ylc}oa` zggHoBKfy?zxiTD?5`>KX4%&lraXrI?hPH%@JkMKl%R55*wD_6o&yymaXwO5}ylsMd+3Gi<^0d>v&LlRb! zOV;yKMU2A41*}|LW+9FF#CB&y+rqT$vY$&HpgRutbeZYgd96jy($Xw8-GQ`0yiaS< zTb|#kn8@gYpGb6!u_5O!Wzk>xKWc0gt9rW(k2k*~qCB86qPc7`ui#4@QF5d#p5PM5hbZrsG&kW;*@ zxLPjg+t;-y^9#*7lBf&)HPpp}Z#K{S$}}0tql_65uxhlU*PR4eg1w=zRCa1@-n)@Y zmWFSX^gI#!HkLQrin{1!psj8pwbVx^rJ=J}qY3+*@rv8}0Zz)=C}Q-kNP$-by9}6f zIWOX2x9lnD)oh4Wky}CLSKa+gFPxxxgwWJ^kNH?JsfcjY`m>4EcSf(I>iwdCq!18lj%d;Pf$2 ztjq>m$FsCoB3nmk&Z6WdSA*VNx4W6zo45llo*a#slM>Iq*1(RTUH!B_d>bn^q{R&t zX^?A%FYb6DJv#3-np?p|WY!iWs}>P?5MgmyMfS{gAZL-0D7ywu(TdIw(2#Jo<<=q) zT)84TMUsYuG!fIRUq;6`$HWxjOIT6yhA!ZKbN_oGt)KrvX zai&YzH}$98xq$IsC#I>1b~r9K{CESy;Y5ae#`n8$*yhWeYkMk+mSJMM+Q9w^xu3$! zLv^NaOVqI$xg|cqYD{>aQsTAy=+}pwfl+m4B{R3uf>951V&)PWcTb^GD6?d+2`ZN)7|RT;D}zu&G4wmu0J+Z2uB3}|Ln-=M6oy@Or8@%uX+ zCL5&QbIiHxytwH^549{yj3|stoPgM&b`?cCuu)477h_jOc_hlnmvDAmV*d|L3CRoY z1}{UqfjA*YtVx_FOqi#meV@$pZd`*hqodF0^~BumdL-WMwyUMu{zS^ooZHCOZoihW z7MsQOd%7RQ5@fUO47qDnkvWj3WBR%L!`{l_N7i4x z&|X#6V{Yx}_HekMe%oo;_b{1|=P!yN_&XEV+o1)Lc0Clgoy+%Dr-#4905W{CyRS_7 zJ#Rz-0Z2Ma=AV3w0S#Cj-F&{%$MfvSf3p?wqnAz^x`|Ie;^j$K)RO&QMkxp#TasX? zJr*37gNGu?>8H_E#v~XB#lPCVZ`31_v^E4d!Y0vw3uXWCObY;*on6CaI~8O;+8KSL zD$`{6X!`myCLt=UF5mBnUb|#SL5v}rPb(BFON)aa4i4+U^Tl5#!Z_{fq8+y8sE1UW zro>O_luJ+iI4sJ9B)-c|5W{3jpZ5FZu=suRz7RZu^|-MY$b(qV$!0HXkU>uXv z{|36qWJ!A|=mKj$m%{vh#?PoVldd>L*F6ZH8VWnECPEm$PY!4YfW2j0zXI3~U(op9Eq+T#;M@E+ znB*%vL|5a{d~sbE95O9y-qkoX7i%-pO!XZSaho0V_DX5)TG!JfZufh)&$WQIdddZX zQD2=5>hQS1go#hyAoCHGIXeZLRAgWoA5MoYIqQu0g3_#(+5$^{P6-0)5Ghew6FeiG ztLCc0>#0~mXD8g{sTc`svm`N?zYRVcEDq%}ahiy6aHN#*?dns_z%%n=qFRFC!~37_ z13J(~qYc*xOsh5p=VaIu`kzS7w5ORY#6guTRuc4M&8E@q`|w=3cT?y~yq0lyGx^oi zXnA$D2VJ%tm(Pw4on6_Gd@Ywz`-6w}VQW(I}{YxS-dPmTSb!;qr#`_G`! z=fmd^cK0x!YP$7j7nqeoPeQrw8Ot;Gu%5~=UkVGMYbIIPIi>X10G6v9gG1+xtv_r< zG~ST24y;+ej8PO3t+b zh{V(fYb4U%dQ(u<=MbHGnfxk6V4ZMYCGT_PXW*9^9+Dd?i)MeAPHuE z?Y39IN=iq1il(HUbOMXPH!hH0$W-sg=cySrjgteoh_rVqnHg-b19^Ct?VH-v7Ix|{ z>C$C2ATDakoi<;;VHSE(|7~qp2Lc$+q?}8 zA;vO|jV{M!L}Io(XTQI(l0=`d%D1*e@~wP+=896B-i&W?Wg-?U#3^knoL?DbhWfFl z4q2Ybmcu}uUr^`_AV;or%CGixeilP+5k=ni+SREZzT2I9cz->P^xZC9;9q-v4yt~G zzXE)4emY~Fqj>ZAD9n96sB)@=($Cy1W-*Yx%4`_^AqtW$5Iv4|jwr+UJfOS_%yhFt z464PV`w@lu9t-bgPzN+1<69dAG-Nu(rq<=;opVfHXhm~UcMH_5g4ju@wJ9@WSDtoN zwjQicDei0GadBh`Nvzl+Ex|vll40{7S712ls&*nPIK6HGUw%_-+3gszUTX8DHKxSH z#(s-rj7ZTPmN@eilWuP3N!akehKA#-HvuP$lxEwHn_oLZOx%8K@|2SgX9kyF&}c`*HEA5L(9DL=QF`D@O>96;)#~** z?k<6}Q87+M-H?v2DZbnxF3Z;|3MU}LXl#%+wKl&3(mGSL@pIIC_$zWv%IGZ@dQ=9-y0>eY}VXfNXN2yJ7-}S%Y zARPHS^>Q!;3|$U|@GT>G4v_iJ%upiI_y%H66sV{sGXBu#&3xTxC|o8|m_b09W$Ti< zFeADX?j;JyG*kNBSvWhV z_-FXdhhBs$2HzM%CmA`ALGm~|Z#qGVgE#yWM$&>`0#fZ1;BS7uv0`bbk*+`{=vBf( zk`vN1KswTi)$nL!HIeZ?T0{m%xK!8|OSNcI*&`|Kk!nWhgCE8W3P$k)KW{YeL;8kc zzIK)=weFTv{GyqNxSb`lTJ}UPo>DP7j9{TLkh)ZHi5lDwrQ`rq1eA8b#inaTKHb&X zEoJ6Mplvg`927#HyM3UYj-_+BUH@#La0|*KPd`l%--NQ5mA@Az?tFIOz4vlOz&1iL zK&&S*27YCkdIPs;ex)8YD;9j!I;OZF^|Q{)@qdf4)Me)}-Q2wqPZ_QXa=KqKkW0m} z!<_*x>ZNCfwS%@s)^`jM7UQ1C|^&QprlY zS5|&D6pEVt1NOqy+$n(lGg$VN@Z7to=EGFnK8G;!?PIeCV+nbEI#G2MHkMxqCf$Xt z7bSPLOyv7#_^*k&DiF``V4*QdV!`SG%tEUZX1dKw0jkB=6N#pFb{q6DG57pPsL4M? zDEJ$kiFG~p7%VK-o>kRKgayBrkl*GZ%}vnK6+KoB8OM#2r(k$I&EnA%KHQjIruwGN z&DMD6F)A6>ep3`msD(6B!_Me9kQ4ZT@0?pcTorA@q9Z)4#Vo{su3pxVp?oaB<5Q5FgC>f}nmBlQNm% zgU_(^jx#BAK+POqOT#-OvDf+Jz-o~h$13-~?m_<^#0j`SV~GH$EJaM~=5d^8s0-Q%LNNj zxR*9}efE0$HI&AF6)yWKj^efV+>}(E^|0kbXIA2NGAO>~aBm&uhn>iJmdfHS&IxJa zoawZU9MerZx7B;JsWSZ|d2M4W8D;kK2j$mg*be0P*eUfb?3ynCLr~xXX}N{sG#@7@ z3L1oGotcHW`V52;=6=oY5$vq@lBT#U!T9DL&w}Q3K<=#m#P^Z zurZXiCfa&x`1qt0IvhYqOb0JHcO|?6<$>jODblWyH>1&tYUa5PAZ`}=sx3^@1Bdt^aINdzw@u|m>mi%enD4X z@1~nT{57R1oy4!I>|flyo*a?wyM$BQUx_jy$Aj~!m#~o`@9;;M#Lq%CXJ2Q%Gt=r~ zW-{+ocI6rMA&mkTFiy)tLw6)( z!hFMxht?Gxe%ByRr)E^c@c1m%DYV!wa1=0-x){ZyUR802BQ9nNgMdd~-Rf9LxpQjr zaDXV4hezqHO#OU1fO&;C%F%pB7$}Hd~W$9ym zv#_A5eb_c>Xgx(1#SJ4FHz_!2Vh(F#=6e3kBp6n>0Rr6hp-Bi8vKZdp;vZi3ee5wi zx72NVR11ghRuQ|ORTj~fWqy^ezx=Y~W4SJRHY%R_^H#ln2QqP`@K5jJcV8J-J)nO1 zJd(};^`3PRMKz*D%4jF%%Hwd?i8oJKUlgX)Kp^et-R2)xUD zaQ7WE7+84~!#-;g{l;J->pr0b{EWcEQ{JHA+6}|o_}Kx?js#({NnxZjG3P&t_(5m% zQ$3j+GX#vh_qy&H53jEj2uRI^0|wvF@AgGln4ay%J=(*T()T`kR8N?FhS+#&!v>TTrMv!vxwcMedlrqK~DRai?bL4ooys{ zT1znQ9=2VL(7^xk0?2QE%t*y8T&?WOpMnpb>4 z=)Cj2LB~+U#qmmEc4^4kk=@X7Tbj@^&|o3Qo;VeGC3LKa(Ykqp0N?8;6s)uyGcUU^ z5VX+!R7~rusat5o;_>n3yC$%Wn86ci+bb`MY(6+!<1RiLYON|u{qD}X+V*iZ95^G-m6cP8(E3Kn2d%u|sR^b$L>(ceS98 zKaZ+aa%TAfB90YY*tl`Fr?6*M;MV6=<$>O@zi+{16Vq=s3rP?4GY)^&fIK|D24>B+ zA~Sxu3wMI%jk}gyGuiBa$V59A50ete5x8?AXT*MM>$^jRvydz-abK@?`=}L$jf#qm z_|CMm4XCc3Pcej*P>mT{$WC>|xAcQO4GmFosM2dcNQ#brhl=ua7Ln}E#dxnBDRf-& zoLAxOj!~E!@?_){wD)b7^T92N)Auwyy!;hLC50l+nF}&iIBo4SXT)L|;T@f(fe7d) z>yX~ge?dF_5u)w8)Go{?cG2vx2=Caglq-tgui(T-92d}6L&>_=8z%}reqY~G04 z`<3p+YiCbhKz4dtYzM;9o_|-%fM32yGjXD)RUjArk6mRUks~MOgCBgPIISr-W~sg# zCiR2fZ)bXXYzBP+ZUzPhu`F=g%cBnGt6CvNCSu~jCEal5xMKaoW$i<|;n6a}?wV** zk6I8Ug{Cz;%gU=fMY3{(wW!7^tjzdI7XxrZYOvrp5 z8w_WKEX|Z_7huXSr$q*+cl!{f$)V+e;AO6caC*U|T4D|Hc>m?sEqTG0siz3ymF%2S zZb(1}Xl0p$C#2#x-LG0!1@?6nyG+iPFEQ?|b9(G)0S&)E?GFMXn;2<|WRgpBuqFB8 z*57|mop4(?cl1K@ZQQF`>S9fBB}?K)?Mkl+mLCLihYwOcdyY=W21ev~x^5eZNE2$ifM<|n*^dfMH zA~QeQ%iK18Q?(Hwo-A2zU6O4RhQ>L&@r-bLVh=Zy8-bl!ui+#7l+lg2b);6vejzUs zeZVT6DZNu5D$wqykZPl*=?WrlY4$_}L4LkYhiV3?&sZ{SB=wq0HcK7ZNSI$ZVR5u1 zWYl(kTJNzg{lWa(sdPY3^WA47Z_&JZ>ycVL?}VI~#2;{OqVZ2%ksM;2TRGI9dqy*C zPLba=kE+)HSxHKEynphnIwH}d;B+Vq?)qP+oPQDx5g}dEnqHEof-r z7(A`|3tc7ab)d&CFh;l0VnO6vxuKz9+<=XO;$p~z7TvBQ%pXxAYhf1g5%4(;6U&RV z8wuH)_$D4F+4`8Dx;+)9aBdAvZLu!7I0W_+_#Utt&eE$%=LX4oO;X6Py3FLm{6jT#W${eqL;Oit zH@9-zv+=%TFNTuqGTCCKWRaHpLjQQ$Map@>L{@sD7%=V;)=G!}JAU=(n-f~A+rp5dDi z<5>LOSa7yx7je>Fr*Y&yue=x^CD|9^hPZ7wYQUib;tsYdNTi_8DKFbfVwxEq#F*gGy|YT)K2I-51b z46$2gFp|PijL!#;t0fK?yXb9`b$hfErlVuxZCNJx3eFxPu8InC78Yi5&TWTnBu@T3 zYK!wpadA@oyaVQ%s}N^mAv7YyoG6i0NC0n%($tmh^JfiJ+M_kZ-ZdfO4r!nFU0YpE z1>>(IRh`<*4%%e-wQm}~zjHm0jN)IXt_Rh3M8@v0iHT`p^;X8tWPUm=CuVp>-p0=x z*ays3zpj@Bzm3%XjTe>ux+vO)i+K2xT^xm~G@4 za}muJKQl$P8gp);gY%b+7`iwzRuo8aLIqKp$ZsV>i*LeA6j#s?Z{AK)N^@}Wjyg2e ziA$ME61h6zLQfEh&kd)bxjACCg|rd(@+rslb<`6foS(qILG3?Ebu4gb2nBLYLtpODV@F|q z>1^9u9Q%qp9rdCbOBmFEcZsJs!iD=u3uo_uwd<`{X4qF2hrhC_TfBFr&yL zILM!a=c&&MS(!;6yFMpJK${!2f(DYhK{$DC9A@;)V-xA|evd5-{ZT}v4cv3)4{YK` ze~u+dxV9kQsP5x4J@^a(fG>DECM2TGB4S$D_SVLsZ1v}X;%YAv)A5%7pvg?o*Sgck zLADdgOI?aAKLfsH`FoFBSArmZ+~@XPwZj`W*Go5>3F<7(CgHW9 zYYb(8sJ;X-VOYrZZ-?bnInZAl8W-h|f;0i#n5>Ime!G;PR@XB+w*{8CR_L-~Fftm< zf8jn^_giTj&q_h^ds&k4o!5^$v~k(%dA_6I(}7t;6qHuNy^TuH->`(bIZAdRdAKh8 z$nInYvny+R__*5q$rS(d9@|7;A44_ROI$?R&d9Nxuc1p-Ksl*wes#60soJaIhuu zk>}La!!N=N(Rh=u`5xJLqMvO}#cmc|2Q2!!%z()s%!W0Y9>zaD&R|E<42dn%5+T=@ z6K`R;V+8$-mTxRau%0$(mT z{>WDNHfl$_-_ri5S(13;cYb+0AaWyy2=GNh0v8ehIS(C^^$4-FA71`)dv1;rjxv2_<0?m#c9LR7jR#vM!x9XEo) zr?F2q<4Aq>Xo~#@_Vc-~Q)AXN6yoCNZ4@BYQ+Z=Z_3t|;waG4<>*uJsgXtGg!E96Q z#4=!Z9&zNj&ThYSkxv>eL>L6)+Hevbp?59%HJX7d=x}yXR9t+`fS&b&L@V-TD0NSZ zOpKYaHYUn%3f|kfayYtEl92%o+aD=}3jBFMB$~7miESzl&c9)-QqibGOcDVq(fc0q z;$k&gOwKiAmmw6_$5MU+eqqhd;ET}~hV1Ms*w3B}z&QMuc_^D!c%(56WjaoEv20tO zAgm=inGy#6!N~pt;PjJYqq5qHM6p4kcFWOM_#jdjB13+slT^W%=Byn2D}tiAV4^Z3 z6gJ>}77MT`D`AB)mPQgD{n+njgYu;69q2jN4PPu%Jr0u#a; zLTPH?h3PAkA`#LB1j|LuaOHZ|EfD4kq43jid}b^=)Wd=Sn67i-E)1l~+i=||%l7*L zz@YI;YVaWAKZg!RL>lD}Y?s-K7?*v?SKQN`y7cy~0j^KgVrJ{S2}Jo8q2LYTVZ=!vS7RAliG7u1Ca z&#}p2XqPmdmk2pWQUlygQPc&Wu&BqR;+DdbT{yaY>W26ag+l?0l1D65Y51xc7%_jI z(gAI>&j+Ih?NT_-fdt;+cq10Q6G%k_cd^5yqVp#Of z=rc;Pv|Wv1fqB5zyP*y!bGK1FEtP0(nt#QFYgBzAcWfrOnV0@8&w<7fRHMR@l948h zg|f`Rz(6ktN5{Lk?XHVwQYtA82g?nN^TD=W^ydE`9>XzVxu^l$Z<>DV3(|dhmRXhwppXMg4C#b zsJ4ixQI@BdB_;5V4zCs~_QY?LOJnTKCOuBnNCmdu`h+^{rR=HWNDYqdN*|j`Gn+&u_ukehYL5h?EoUGUiw)%uc*sJ zt0VlCoux`!j!Z)t0%(Q?^PN|x4v~GbjO{Xrg&ty+7HoWuP=bVm+HWOeiy>hok9ofbDc%Q6vkc7EhoSB?t3H>f#mID9x2FzVurv2inFa5|222*tW6 z4|BmcJuH|Vkqk^oOFWL0Kj1!@B3U(!zu`Jxe}DazulyNPhsU0U-1NuM&clqGOWh<~ z8f&Y4eSZw0#EX*sdD0D9r+C!TCCSSfB4`C*|1y3_gbcI@Ggu^oncNiC*c`cB69CJu za)aQZUyio(J#5JwxJR9p9RD{h{EZNx91%hT&KGX>?gb>Q3z^w`2yV4=?tXthd)f4Q z*tlSo@GMiC0<;;+s7VczIq-gAh(0uLLp{StXHTA;q?Z%^*~HF?c;poF3`tH(IyjfF z1T|A}(r%}Dxxt|*~0PyBHSZc9ay91rcsVeHU z5IJ!qg*(|BhP%_XEb8LbiLbkDrR>;+YzYT1d#H&8t(;j_EU$*2<49fxsJ4du%NPwwj#KR6m3ZVmU!!;lOvFx90Bzfb4X^pEg_XKmpe7ebrgt{B2Jod*Pa9Dw!b=a6;U8<@*usnRz%n;;%E- zY}j|=SgaBrx}3xcrH?;Be1(2bm`h+)dhSPEWg)Zb?4>SK9HpX|9qYzoC&NCFd}%j0 zSwpc=s78hk9L+0p{F7qa=l>L@rtKa##>HzB@=$EHBt8hZ7|{L6Li(eaFaKmc*IwE2 zT$TxY1MMnk%m&Sb+FUXPEBiSi!`4fx3gN8-V{T(u=gAAh40O@~fuAn@xU~_MTJ{Mt zsBC3_QDM6`9X?a*!cm{Bn%+Gd8trXTC&mB!QkZFh)0onUn}nM^Z8)5G?8Lik#5ia1 zc|E_5(RaU&ZukE3ASENyoPZ(QJ63ROfXfu|doZ9IR%3t>&_*U$~Pt*5gQMb1KjN?Zq zqqhi#=$uh(s&2MkxdAvcTdc`M!1O}6vK;i7I=Sp~n<#88z*+Xd$u>s2E*Zi;`|=G@ z+eXg-X5dq22Je8i_;Kw#f~u4ZtCG!;&3y3-#j2Yf{PQ-M63?QBddiT#8}FCw?!z{s z;lCM25&RK%3r20DTGaf(sA-M)N?X0_=S2nocGpXM3jR-)uQGGa^NY&sPr$daUrn3> z5GQ7?dvC}2;&)a`=qeEA{OXd(L`bmU3^GHP8r6XSa2^c}BzdltiqpjoV^imuOGMqm znFl@uIFrv#)Drm!sY%r*GtV-0fm*gtOj#86|w-yPs$5-oEtjmgS#21jucmAO*i?&7{Tvq zTrJy$+#*YJVKUaxmaZiDYddS#{nBn?xe3ejs;S|M^SO_Gr|a$^Tg z5(`&*Y@>W55Rn93l?E`di_GVspck&!l8&avNDpQCIIuB`Tq#JB4Zk*H19oNKLf!vA zZh&gb999U|!{HkqjgZZ`v@k=U=3&1O3-_KgVLh(wS`w{R7`xT-HRrnX5n&dWRzAWqnFt8Oczh?%v+N({kq$qS1 zgRaXW`KF{<`25?Gp_wPZl}@L*es>h`y=bq&X-$&Ltu89#{9Yz|D!=#`w2Oi@!ZO%7 z*W0VE)^DrC-Bz3!VVLj8D5F z+ZaX6+mVWFU%KMO33UFh@#`A1G65BQM(EQ+?p9897q?Oapj`)8zpC`IhQ|8D=n1d0 zB2}g{Z5A*1O&DuBwDG0Tg6?U}_l3`mR{pFQfVqHe3ft znEEwW5e&FyP73z2JH$H0H$*iu;eaq|7GY{E_s#D~iFMisS0ihSRGnUA0|LSDr{MDO>31S%)R#;&o6J^Qt{J7kU0I8EI32rUTqdr zR9lc}=cg;WMO{!I6KH&|pmi;Wb;TF*!_u_}mD|fHEI6HQ0L4?=TCh&99dEvng8;hcd5P6M3xl-ex}% zM7{OCfB7XWkdNbP)OlCiuE&F$0oz?B3UN}cF7k)Dd8~EVET9|vpGSiY))aR*P+Ks; zAm`NE*#HM#HW#Qqt0Hc;V3r*edo%yArZ_uQ3IwZRhukMLhlG@DuZ&Wo-PM zPwy&6PSj_YzZ@varOUkM&20TPZ#g(~ch0pFPMlLR&>9lThYSLPgqKs_KK z>NLxF{EW9*s?zg|{^I$43qmQ;ALkqZqKQu--Tyvm0cZ%n9?x-?53B(9Rbh0VClkR{ zQ=$#uBbb^vI`@ya2T-Wm|7mP$YWlM;&yA(e9zWpVW;DJrMa`)0V}{68Qpx~M1r!Z<1E=gCLL8(9*Crqk1KXKcTJ>ILP#IE*y$0_WW_63 zJUJf+Z_`nUK_c7HiAhsh4~qO4UWivbk{+!Pr2tl*pkkiG z4Q`9XAbeS1E2-Z+pp=YtsfQntju+Zi1W(ED5lX8pV1x^BY7kcSxCu>6&y@Z zb{X}AhaWQXo-JgK=}_uAS#_WE5Z&E&e_&?@QPV{sZ)oqnXHxUZ4%}X)nBUl4bS!-1J zgbv8dJ0?e31^MF;{6BW~k61VRHg7m^GJz*)!UO4hj%|fXu#1Xf@R<^}IrIqPq--zk zK==8tj|Rn+f`c@)tE#;ld71)szI$VvC> z0ln7U-5vM+$y_lZCFQ2wS&EIadtF+SHNUL$fT!4eZH#OU{PpEf`a*P1q|4|i&T8Y) zSJ|}baL9)<5kxP?Pw?2w$bGgvPQRsQkDlmgEY3HyMaU77V$(6DH5qP>q&4kQZT@(k zs&iWV96=ZQcp#<5?@~59vQwRNg*oHve>!Z*$}|Z`@~c zA7q?@!*^m6W{sMAsh_+vJkbIb*^ZF|HJP3L=w*dFBZHEU+Z!!#e*5HtC0>*C)24uw=HxMDK(b*vva z%(muv0Zgtu63RIA?QH}+ZJP29L-oeUQvHCEzhVC#ag~g~FJah=ZdEU3SVX-xmEVcs zd*`LCoJk3QJ=$g4In1%3>nHKTEXWJqvuG)KofE_0yz%g*A$J) zf0{}p@EK{}WVB_eH0JPGKIxNHcw9C-JYIKT7oAQUU}St;hHgZ<@Jt+#n?GE3JkELF z9yv=SW2G>jHJxFH+kA012f(>W6OTBSY3`A77ubqIBZwA_hb#Sxu>jSS^usF>eq;CI z4XlFZnuDWR$Y6=^JYd5O<@z2ky|&1Q5p)o!o+9mZBNq(f3?v#ukG7JPLj)rF2Gx{`75 z(yT~c^YLW2vA&2Z>>hS2(8#60nyXGM;9Dk}%ca=nK1SVlf56Celjz_N>+hf^Gkpl5 zeyzfY%w)Jbn8zXw{VHod5HJL`vut>)$x`oOjZwi_U$QG4>#$E`#%l zw&JYtfZ*@L7Knj10|?x?7HMR2-JC2~RD1|~lMm*|_F7xg*mSY)4jC_2_iAF0FM!)3 z(eHz{Kxy;WO>+KWT>@y6{TbcegP%Hj0}FTH-(BjJc|3)Yl*!S*S2#rh|JO}0OY*fP z^&?ohgRh2TBVHoWDladmR;^I4-8)RT?SiyvuOw5-Fu>a7wB7IyqoT$g@e2&Ft2jNo zDV~{@9Ej4rSrp{*s*5t=XNzb%EcR**`hhTZ5rp&Ak2`>1szWUAVWJx0nPGbsBT6FB zrM12=vB6RartqlX*kGV-A5fU})NgiG3%}3OGHNy;=60TNB>TtxgRVl>t~^dtT)?S~ z4N|jz{svC9C-EUzm83JId3RHwI{Ee@{nI5*;YGRtFw%SV@o5ay(Lpso@r&qP<>wBs z(i5aIeCU^WQ27H&V1n!4eVY)2>WyZTkj#7_T=!^-U0nH&>?&d_;KOTIx=%i%s$?!#e}&hi6?*T{`FF(vwCbe z%IG}HdHLk=GWuj-QY8W7C>Nr^I7$gZGCrAVn_Qrk zPqTi%zC+teyAE3&pcX>`c^7w8-yFo3j8`lSL^8%4SeqZ*aXW*xLxugz(V+v#*bb=Dle9@U&? zmy>`~SCm{ncO?0@t=Vwi2ihUX|Lc&MX*|J~!?Yu)XSWLVvcDa1Bo}6m<@u{kefWK5 zzPqc--E|&Jbc9lUcVTC-*I|Dh5I>yj?nTMeSrsLP^b}*ZtFf|v@;gyv%qK}*h zDu*gAsN(ypsoIaRPnCMesp$iQqR&bn#x9)aQg?+LEc+FiR;Cp4U>4_6Ajkw_g2-(* zPBRA0vRb76d6fa-pS+E{4(-jCG_z>DhUghJN426~=I2`2pU+Ivo1Z$CuZ1o@%SKX~ zUY0^4auN(oq=Vvn(z?ymnqavM)&Kpnslh9T|39j}DlD$F=@tkYf(2;YgIn<67Cd-x zcXxMp4el<%T^o0IcXxN^bY{+c|IG9BUEl0oZ&kgkR;{XS3u2zePU=&=*yac`wOX7n z?*xMo(U%E)=GWzi^TySwgR=*u*f@LPu%~@a`h3RLPj~6 zxk&y==@@g~I&B_1>dnF&T_eFh!XtjE--YuRs333C3wsMm$>~1Y2Lffel?V=B4lPs3 z%$=nHGH(k~_slr70LX&K%y*HMOruS}2u{@(C?BvF&llLsgRU(PEHkYbT_3Q1(jKIW zT4l_zaDLdHkKh#)qjUvgPVA!z!)c=!G@htLGImnpjjng`x7=ihTdd#D;C(Hw0yyL@ zlG4B?aiR=g>Zz97e<6Ck{fcDfA&Pv83hcef8hh%Y(jMb#65PWZO}o|Te8IF9T7%a% z35GM|y2V+I|M=uEV-y*2TW5bzQ}g3E zh7N8+#09F0c;w}LDCXB(p~P!7S)jp9g^f{56=?@D@n(MDKBtq(k*ecighPduc2$|s z+y}{-CWgyHRAA~ix}blM-Cx&sP83*4Zp*iEU*>mB{rOebwFay8K_uQK=gR6UT-+Vw zxHwE{k|2iyM7+|Z?I0sdgvSKAi8Bx{^V^KS_{?Dx!N%#mkhJzPQ)?oW*P@{881Zw^ z7aZn#>Qx3kNCaRROuoYpViJIY^J@n=m!5he>8I5~glGK6j>K_#YR~+{4jcV_v7Q<_ z(!%s^TU1>!q};R-f#3-$_H@ft+tlYl-@3dFWWJFzHC46g8Jp|%xs@dZXCi(5;HD!&an6ND`5zZingQ(JE{ z;QN+8bK$MMaLmqkp&~3vi%I8YH#m};*$Skd?d^u-eY`$c!N+0-JL{rJN@`Y@;!tYI zj5K$NrCFF6+SV@YI`_c_+<`SksGTUm09I`8wJ!2m`NdU&ukJrbRht~7* zwI$Cl0Zt0CrJ=en26pr0JPKEcWMd5*_^Na2SnZK!*ugA|s)Ha@oaeE2|q4_Zwd1AhBt zs{j)(A$761&84z_XAb;#Nk%eEl#e68l?Vzw@UW?t-8Ic~Q1cWocc{jp`5-MOO*l7D zijagfb{M=}$a)n)T5y0SCI~Z4it6qie9%f#lNHNK|9EO9ya6kobg>%U?NV z*C!v>7S)aeXRk^whsPm$-4`A-V>= ztWP&AA2)WyL3k=B5iB8&`83n9VQ%?Ke^7pqmt6&AKpE8R&y`&Rb^!(g5)(Wsw;peH zB#=CAKfXRGo85d8;8kn!LoZ;GuI#;4svBbZgUkNcxu+oS7@|-U)iNh73!9Ac^g3zp zQ#tWiTdws*#9xzS1tR2BCR?^PQQx+ap;pDvA9xc@DRLuQ)Kq^yWHlEaKaKHiYK735 zm&_Clr(4v5=I#{yILB^&>$udkN%4ApPcS_cpmun2DeiH)^>)6_7pu*%YN0K{sK>;a z4K!!42vn;x6SglnK0lKH^)zEhM+N3rT@Vm}b>s#e)!0w9ZF9(#`OHspwi`63%1*)9 z$BP?jzm4uaXBwUnvTzF3#DEKOOMV9K^>F}MRil{{uSyg`D>>Vz237f>^QC^WHs_on z4Nh!={o6LZD+)+D@+`{G_RTuF_Me&}$Uc-#Esg7|3*T_>H@&{gG~^UgW209T7dbPf z;Q{zL(rN`469kX~{{MjwkZzy?RgzeBb^9Rb;HR58t(7s!olTABIVBF<7fn2n6TYBo za8@DZJBgdbhQzjoVP)93BA$H@SU5EIf2>#-vU6O#2%NaK!i28B%U;id1XL;`(|S3gdfXgY7MED&b+S1XKJSGW;GCUGus$?;+tew(_m^cf7*jE`vCj*M8ZmD1NSfj+HW!m!1v!miRk0E8Ht} z8)Qk26{N+yp1TvRhUdHOUFqlgFXeDufgJV-EL`)uIKNw!4pgI4{F1$Q zSs6~Mp{bf$kY{TSV)r(+QVF$<6y^Dome#d^ln!pMWFK8FLt`#dXAZu)w0aC;r{^}y zsGb|$Ws#i`Jv#~g|HAuE<*ge6Hr~t*e7l$r@`NzkDLgtpu{N{FbFT4;OgJgn?uDV` zF8e^*Lq4IcjA!-6>^BxaANzsd?5hTn>6Y?vItSU*01A6t3dFJDm!MH0H#Q9UN6M4< zp2uOfjAzZn^xp+YM4}j{oDw8`w>kKN9Mh7qFfx|sh(8s7N(x$@`&8;r(9^3?f7L1d zAncU?bj_;TuFpBExP0SCPhCJ@c18dNj~s7gW^$gOd!!sKm9XPHG;(5mw0?TGrS*EG zrbFBqNiXLarDPtT_6P0n&q(aPXbE8Wb4(jyxZ1z~~S?mDC8hB1gfr&O>907ntvRq7S5+>T)NVc@}LEFF8iM2gihCo6+a9T5%|lr1ewb0y>O;AE4sRdL*6hj zzMLRlT8LEPr)FgIbYf9`*<_(gIBSR1-N3IVYnOC>GG&n(Fpn!4cGi*1FKT`tMm6R( zgnFD2vZ^MtE7Z~`i}UywW_WG@u+tyxevj9=xQ-lzg=$^RfMM8vu%yZI$V`|ZDs^kr zz=T68c-*6F()0qSK3pY0m#2r_RKFuZQ9wREwn#B6j2h>&8-E~SVV0O*bl<`iU<^n@YEOrGW%BPRv@UiW+ zCtt8#jI2(^SYwt?3#Nr&jCp&mzSQ}|5DKdi<&hKCkkbS577?11MPPREqQya{Il+tp z*weJ3zR?o13%!TJframmpx+@7Xf3-{-*zCF>_RMfUw$-IA5w|=Po>RCTxmS3=l2P^ zn;O}#LWe&|P`|ec#cB~ZNJb^tEqwnO$xAqZ8(LP}mLpQl7;WpTk%97W#IqXuN%PCD zfLb^=Y{nc`)|eK{S$rXv_rcqm53k4xP$)`^7=3r50OWfecc4 z!+rgsfq{XSKDIWS@eovU#P+Kp>N-bG$Ax3rvi9(GkATVAH#A6-(z_Afkd$v$SF?@A zleLgTA?^IPzZ(Sm+hGJ8kk*@w-F|*L$^jieUOI=(+nDw(UP3HAttRL8C*Mxm?xp1W zZp_l5{EUMySs{dY=~ii8t)9*=zIAqql4tX@q}wL$(=TXBgV6pJxyu)~g4w*pzV-)L zL3shKc7ro4wCAKRWO`1kF@J>?2RI;KVWfJCaHl%!*q6e>rU==UrPyiV@Mf&R#Hj(? z{xv;H2KVD9+-bkD&e_=ng#~1X-6r*8SiLP63=Dx%UV|J@Z`a@T4v0r$hS>wI&Vu?anfY=9vC#nb${D;}7tyN#dw#AN%>^9FxO? zt8fd$hU>?WF$O}Tz#uD!-2zZbq-?b#y1m@^2l}LGNwV_YfZAcy1LqO zMWXPlESBp%-0sf|5?666)EZ*?^t`L@Nz3XUdb^S64Rv19;UBSJoBhx~NOl{pSm|+- zw)Ucf*1Lr~yp*f9xb`7TlhJWum(u;fX}6xunXR#sRj^P%V}t`h7wt!8&ZWE{;{NYuDPec_KA)}qb_CEG=agjM}@TuHAn0EhWS{$Kjtq?Ig>RrCqTdzc#Kn>PF{uF*6vHm@n8L?&VBta7M32 z7ooNrTXL2PtwFV*sm^Y9A4iItX_x+XvIhyEUEmuRE>a13f%+o@`0zA#3_-I=9LZ3$ zP&tM(b^C3K4vC#;A|ZoEG$`_HvMjF*kh!TmJa^bsMoro%{x;Rhszyt0lyqp$FbB!? z^%o+c4Yjf&VHEsQMP_vc{Mr^5{(Zz=)B66PU@&(MR|Gs?EJi4 zS(*-F7Vj1j;}q2KR{A(y>WdZDAXZeC8*k4tnv8N5D_%&By_`ZfkiOh?r$B_f^(Ss= z8yA<&8o9)}r+qEJ$Q{OuDBVw?Vg}U%^5QD;YMd+`D3nBin{vb^^+Ddg%vh(pT^znB-ujPdZn;W6(Sh;k= zeEfjCO2=^hDo$=-0}y+ML6!6@=2cI6uTBdFY4aS3X;s*O;*+(y2kAl-4rp?BC|AZo zXo~UqG3b4iIq!#u#6!=wn+{$09o3;iH z{f|%R*XFy8^S|T^nzI}v_ZmcApIB{O3FpeT&p9EmLb#jw^^M2I%5|^?(O4s`RT0KN z5gXnX>Baw4fZo=%JnCBB0KSDrO;nZ)Sv2?7KoMWYmpkaa=6cp-1VwifpX06-@&xhtpvZR9h*<3cs$;1Bkf-Mq2LW^ zL@8tlx}rS;?@O~zUD5c4KklZ67u+Y7r!g1~rNc`=G+u=Y6|P)vdBU#F_hW4<$0a;e zE9IdtlWQ27kqJ}y+MBnJYDHQ;HS${ZwOW4{XdAlkB-s8AoD;spQ@J5c`^p1%QSvRE zJGOw1Naj|{#e|Hyte0RoSVC$5{?D=SF+r*aU+;Xc7Yr}2cllktCaHjc&k=PPOrl4) z`q-LCk*i0iZiJft?Wa_jS5?MPsM*cx^ytsUt8Qbx0SoSfH-Z&d9qg)-%3PQA0=C2L zUf!%9@*nb5eh&R$K8WIRTE&G=b+Y@rw0Mx_E4hxoN~@82_Gk<^7=B*3P=BM4t84gx zo?mrwo3J|=1EjBz{<~@W5A;(P;8Uq~oNE`ea9%v!_40P&@VB%JzF0bpaFK z;cw`7Xv}Uq8rZ(4H<}+Mk_=OnJpPS|YU$H-|Ef%o7Tj0fn1m?J@9G88BBLgBNd<+S zC=*t)eEW?^S9)xQx6`5O1Ft#z&CcCK(c%>)Po;FXM~?R?r-J$-m%d7YalW77w|p$) zK{iagpdgHv2;3!HFpP$@)!4Ft8!sJM;p%I?^C|F7JZgmwxY1^ICyH$=AuV3X`Z{-w z8H$vayW770y)a79O84-gR|gnqo!G@}_|Ec-bFS17$XUk}w!0Ccr*Kh|Wvo{+*$ zrD_v-00M@8Ef!}4Xi=6UlB;1e`3D7Ildzgt#=CPDD`I>yS9&7s5 zs-wT&>g#cQb54+V|8A4XQXUk6uyj;@VJ8STjp}tP^j4y+s|9oxGc6sl*BfN$SmHF6 zB7q!Zsj^SlD^ZfHJDqK(-H$*@PfzbV;@vQH$cG)Ka@ zMd>u+WPIYsJK@AsgHu9lby}E?6Ll0jNPRp0VcoE0dSN}!S^F_fHwR8WP>%mS^2tD9 zxA5?kmrL0GNnSh%Gu<)((?Wrg-Dg`w@1E80P7~hbG36?;2BbhcP4(`3dwV;nUVJAx zOs?4{4(JW|O6}GE#ppM$N0-HOX%4$cQo9?KF#znXmfGMS4*_wy$QF^klfXf$4=zgK^Z+&cA;C8(_Dcc85>KuSTR=oXPM$T)UYe~*b5HLlN&ivROGpJikPC?YSE?`cn z=gMDrx43yfHnTx3OLY3iGclrW&DP+GV)a9t?xmo3Nkd@0ah))0;+Lmh@fM_{A6O_i-DOS^DCAEq6Zm|J`7iZs$>sOPNl-MwNHF**%MkdlmK zXwZ>+)Sp?^nk`CG4xi+GQWh>uQ4r^^@1xfDEnx=a^>Q??dbvY+BVR;$7g$&~rQ5}{ zIk~obVfZ(oS<$31bKEnmOt(daNJZ_b&EIX^J@8FUle(qSlNkNWB?v(tk^K5e-SXWj zE>@c#`?6FgD6DnoAstp;$G54%5TU-efeu*@aa@2ltOhZ79I-wwkPrcB=E)AD$CPJW zaa6sHG^Aph-ar-;Fx7Io8sgei_DzsjGV}TJ>YrTzZWkulJUh^<;?3p7zt)^}m`)de z=BbGtpF&lNj{+v3JZcV~fX{N8=Rd@M)Exju%wIJ;iv#Q1JiHxkR#~+XvozNmxfd4J z&76%~H(=OgTno`OE_mD@E(Y1{_Ff*-oz@<4tJsER66{zQ>GQrtKXO}Oaj7pr!)Zbr zj&&XlTU9L*ZI$I;E^_FT+$SY(V`Lzbl?Yk=kYG_BF_Yb|>nv3|3Wb13x$~pk-hb!$ z=t`yWiOA=#cHnH>`i3x)R{AN)=JFC8|I!Q~*P>I&R?WWVwSKU?c^fr;n=pFHlX74H z#61~Pf&(I5SbKc!TLp8M;B#(NzAKeg_R1C>7fvsDy`m)3Dz?ID7~d6E@f9jR)a&>p zlmA9H5;tCb=jIRLkqZBR`h?x$_uoUV%FYNxBOW_GKpcKbz1riHFoW_G$k{bk{ z-+Np;NxXeV__Xm+%!7=@>9?s&zh3&0>kYwWF&a5wAW{eJ>ULY9m-=~Z7Na^x=i8LX zzkvmuPvSgxn%Tr>L=ivlIWq4Qlb;}bjwAy}Tii~bKJ=|)hBOVHFvmOXv!Uyj_W-!5 zQHk4KyO%W}Sgq2y&(ANK7{8|;W`xK)P@5?4Pu(Gi7_Uy9{`AcGNLS~Al9fEhW|ySI z`8jrErpSoHz(I=0Z;(%6|L9<6^4k9G2Mg;IjC%gs=lRrVu;YV5;mIrp&12)#(LL2> z`@j-F%&a1eB$^;Cw%vuLPu{ z9n}-(zv-#n^=k~ON&J4o+EDWN-Ar`LDw1{ixRR+IwqB9SN&iO)jtrqh(hx@0o5bbhn0al)W@4uY0SSH74&q6*a@G5roy@eI079|))D5`sx{WjREA&nvFa*gID~d0}C8oa*#y8Z|&mPRK*(Mp!4# zE#sRD&V#$u^Zb!;n&Jw}JOr=TG|NAJs2W3h!s|aX{Yt&wq&r)c&Y6P8k_TZ?U5g0wkKh#7>Xf37`eMrrWBKTI#D#_CEi&=?_HG??4Ksc@&pKc6O7CDb85m{RTyC*oA z76?t(N&JT(g^dOa146GzDj!G&%fs3UHeM@jr-h*|1=S>wk4^*Zq`)jE&}z$SKN~_|EP) zORH;7SesvpY-|LH8~}EoM4;NHcBRgV)AUK{Um_+@Ht$yqRDRHw@b9}rl+HA|p23&5 z`!EMhxEM3ES5nw0baygQT3cqqv&WWfv4E^Kg(YdVTSH0&O{_VkB z>Sxs0!4%yBoo%PUdPT^PYaz?PIVzeyLL4{DL*IL*qei7`Jk6zIUYye(NAY_Gb zkr=4Qb|>zwp#o3NdTnSHC#g!6ddK@Xg8yVZoX=ScCCuEWltoyb=Ws^kS z@<5>btv`UQy7Iz&hC-!EUJhbQNDDbfQn*5)7Tja|>TmKz62)6m1j=Mc138zC%|SEr zKN7?qRv-O*ZQPswodtY@1L6JD+?unKc&jQh@6ltL{HrQHRABv^>eO);7J>jX*`s;Y zh#1E2P3)HX<}{w=N0i;&yR1l+^ddce>{~n)K5|5*=k>M7ky=maxDc>33oPGQ z#AvGoHYPdu&Q+f7a@k@hABX@&D2B9wvBjUd4tPG@!&be}Q_8`0uwJf-o~GVNfNXw1 z(&0-V)_yqvhwO*CNya&wBi9^2F{oY09P1}1=_npiL$pkZH$HvQlFvT7AZju&7zjPH zE*e6mnY+f!q=-x?N=}@rgJscGZvMd#l}maTuKF()ykj2Lc*!Pl*`ak8*h?(zg%FAR z_wewa9)&+2CsCGjUw!PaK>MWTuMu#Kz9TsdYF}}x+|mg?3<~Fho81lk-X0F;*xJY# z9f(>;#z*pDTf-HBGek|MC9D3Da$r12M@7jkj#wyY)jnT27PriVI*+ydb9T0ppSN8a z1|+gqV$97<6BidBqtR-6nT{owu1-C})~}DegPUp;z{tBq<}?}dhpGUopH(g7$p8j( zyN+b7|?U^qQJ&1pG6A3uO z$#lNES41sBCVOkd1#yF@LdP9&=HC-|;Bg5#e^RrLA>4(3ER@LzT3A%D$`@5H~$jf{td~pG*G?$If^wtz;10g$YLKuV(?b8 z*o83yaAt<9r56l!mh>3~l33*+AP*sfrz0Z8L0q12@oz2|3DbzFYE+Yp(N)SaJz@a# z*8$c_7Q^EM|G%1?(bdg)N4l+}hIVD@O}5AV1YYjQUQImc$f2G+J0WEYWk^DLW174 zF%C?cdGX^SEO?S0tD0n`T$?s&IDp~j1x@8Pp?E4XFAX?g+MKfWe8R~7;sQgz#sy)*6=6L8%#Q;E zhIo3c!=|iTG=h0lg(aZzX60{B4!J5*t*OaEa-ujzEE=>?_DMKiIM-J1>(MWczZ?YvReKb} zwbqih40skuF=AP>=)r2_xH)>6{`jj`Z|p_gYqTF?pp9eUV=8UVEi2)7HA4TIW9v+V z+TclycEKxkkYCfo8SD3Bk82d!ZH!C*w~YWK`#PDnhH$<3;D|sp1U*jIxww^5mcJO$ z04GoZmoQ~cTUNxnRCg{8aa$?}}G;uP-1wP+XcrI~OUf zs+z1a98F0NLL%S^@vI~qOrEtHk+nZQNCMB06+i~ci01q_?n4&&2oYbSBY zLu=Ig8t$Gb{6iyIO0qv*c99BpE_W9)m4tMZQ;Bs3q;>sa0w^RB?Kb5=>8he9C+)}q z4dWkc`=pjtl^Of3+Sed^R$-nx?dNCxDcwT7MY8*8?WD{tl>8Dp|I$VOWqnXuV3zFQ z3y{o=&P9;~gGZ*SrW4l!%?aD&vlrY_%sfjopuftWsEnIi6HT-u84{XmebkR!em?HB*S4buxNaWN&ZdF%YE1f zNVw9zGV=(_kr2#M!In^(ep}OIM`@hWUwa9!wAuae9Wp|``STBmj}C~24suH7C`n8< z5qNG1_(FSbo+G3YaWI)0tc$o~K2WE7xMNZcLG>4E#-eVRh2fxiG@lF92@Ru5I)fc& z4MH+;Z_yE58%BR4E5*x&tC1X5qjEuve4-zq(p8ta#r_a5wbG_U*#BMrFMrt}h6tXm znR(K`l)%7?Df};xO#<7CvtGF%BYFC^%_Soau!Zpgv>{iF6OD3WpcSxyDnB65S*;H zXO`ub{95E_246J7I}O8&5IiLrO$SawnQe-2VZSm~i-b$3=e$%O52ze#sWNbrD|@6f zdUm?Q%8f&p@D!2T!WyT1t{oTK2^V(-+3kdqpUA@G>v4EovvvCqY3acvz}VYg3L?+? zI&((18HJ}u74^`+aEGd-cUb}bSQ7n_O}g4sa8tnYNbET(q%~I(OpO0G={>M)h)6A2-1)t zFkpWZi;5f?@oSm!t$Qd=od7s9giQ3!bh+^8o_xin@JWE(Qa0Adt7gs^M-V>W=n$(4 z1b>U#{oE*jwKe`)S}h4^v=tN>Ihd{hO{L#~D4xXae0s;5UR`E2ksvv;ear9mDXgBI za#2B+ff-tWNjy?gC?baU8H=6L)v)=o=8C#5=JNZQ*`Mz4+iU2H+X-t>-}xrxK2XsI zER*^Kk&n<%p}CR(V4}_s&fr{z^fs|mVW&2U@%T7x^2F8Cz?{Wo|5r{E3d1_rCdRfo z>FR}t3kMSY$vOX^B;+p;DaxWSA^JE9xoYCws5mtF9_7GA@sw?`Wet{_-i*LEW3G4VJ4$K*v)m0bCQu+0&YE zP{)wg7v%mLVUw8c83mGQ?+jfu5gnX0qfRus1nBulTS@I7+15l7OVeLtg{Y10%uTci z+Pz%Tr%(B~PDL@c)i}EDobXBoyA83H-VXZag1OHY?3YK+KXWC&xKH9tcU7|sLLS1t z0KG+0%25_*|7u?S6W#*C-sHD;(7VaeEQIL)!Y+KU-${K2hskgzE`5KWwAibXci7|+ zeI(AP1?}lGlrRS5qSDyJCB^Z%A$f^EBYH@&s^x07S?lxMVkQV0N^lL~lxHANpz;}( zobr%d|L)%y(`UvS_z=4eN|6M5#|Kwew)HOtN~>v2f;7T42B0FudqcvU!MUY*%heq1 zA@^@GkG^C1&CE}XyB0LE{W{>K*H+LqwcX|l9^Q&Z` zK=@Z=XGOp{b1nV&BiF3AVf(A8_&+c3fhFkxM9>fmDL3SCf`6W%P2$iu+QyTZjA*`RLK1J=;$c$kLu>#9kg<4UF76|iDLXRcU)`0oM_b79_TcW04-Sn z>X5&|)12(_FJG%ISXAe*at%N*l^QH6JiEBZogi0Mq41aV?;p`{F`sl8-PQG*tB6?~CPh<6@i#-jEB%(_O< zly@sT>boM7L)QxwD39R#M@^NA;wRpm4nbPqZ;Xog}^6Dux%GP+#|1%os zU;jk!CAOARF|+J19p%6X>+aJKKLe)kCQiOVxQJ|vI5@`p8Iph6`PE6!#B;SFpXC?T z+>BAx?dJu;-*&!yRxK7P7cpc=k*x9Xt!=-XZ_M*301dEKm0ZJMlw~|RH5$GXw2Zdu zhCqg~L>Ckm{vPc9Lk=v6^tb;sp?4f-*x!E3qhRZqQeK`_X5N)3xmU)%S3h}eGLh-$ zids$&l0;QOmitxYS5T~iX_Sy-Vq&d?AGHd&T%ba$Fma9)aqo-BGj^Q1anoimXAc{9 zDiXQIy)+)uaT9z!3lTYbuxiyHbC$67F&K%&Yt{!pvpH${s*e-)JvwqEDhhV$*JGP# z#s5VVA!n~7RJl?@4%pGu<;PkMyr+!E< zWN{jfsUM`>Kb3k_DI4QN?)QxlE>H4p)NN`rBRQ>lo13K-BlrRz-xioAQ5%Xg9#W5e zI2GAexVII$^HW{hT5`8OJn!1wfoHW};C1GnA3}XA&iQP)uK(jl9ul;Q^fpf$f|ADx z(S83PV}0%LxrJyv@JKY8OvlqEsC(~3XsvB0x#*!}d1HKV z%v_mXh*s`Fd=;@*{{$b%xS(ZP*Z`N6JAv!_F*G5C_WYWE{fP{rLsDsfS}IqX-~^}U zHzhLwSBYcUphi+SEri$;YiVvR^Fdc^er{o4n_14))`$^{*81>tZn#RqQbXnra~RJ7 zE)#N!zi}r}s9rWCD#{2iZCf5Fn}`!N_Vo00UD5V*l;H=1gl`92MgKN>=C-In2@gVu z5#PGD20@?ujsujY>4<%$jOtK&cIs%U6pH_TB!oYnM~Mn3-8-YzWOJjaS2g$LOGGYO zjrU{`?AXQPF_`kT7)^`#-Cg1))6$#90y%W?^@SUu*TV+0r**B7{ph})^|(|RQ5n&y z-{MIyO8EE`!H74*`TP3Bw4ugFq3$q%q{P>qB=)fu7PMOt<@ATU+aK=EE51&?tMn*& zev-_vw=6uFR{c`&^2o(8RR8l&5d5iv{Oa>mW*{}#E@TdqulFBAT8MAtqfgsyecoD( zug=3H?trLC6*B3Gc4X()Z(yenp8C^0+o%gOch;|38Xew}VgI&_okqU)vRwb(3M-Ul zwrqYnl3bRlVsD7CO2hSBnoD0F4GL}z$1n$G!dg~ZO{QzWfgy6iA>9l*yr!Cx6c$@l ze-62Mn#-pyLSS<|8aL#TqGDnpUAq^%n?P`5?Wf2uj4=90eoO95E8;8R2uSm}v3tSC z2lJdW-l=;q7l93$4o!2bwS~Ix^I_lDQC=c={o8HsA}4ragjo<19ba>uM%GbBz+s;9 z@kZ+N%gJElc$Rz9u#Ak2x8iXB1^)O(kUOw{s*udy4J64A0$~3p_x@)c5Z_b_gxaV; z2_F4GBWi}61VT!*NqCMJi|lM14h$(!ra|3i+^2N~fq|a_J_y_<3yphS{Gk3_**N0M z3_nUEIRZWt)hSP%vF3~N1KpU1t9@WS5pkyvRX)A zPBp+41~HvBu_AFIpc#AZ)J^Ua>42c&!Pw=)$nI{q*MR#>K3;rv6g9!>jge&9eD)d} zWHs??JDxF{;?{_*kh~2P=aVyx@tpc~;<1}^_;PA@zR9@EZHsgC7C@I`tgOQ4azQhz zM^$tCW}{TeBjn)VSNHxMh8Q^G3Soiswew6_(c(*dWr20Sw{UMvyaNx~&w-QX1TDnn zSB<(^{qZxA2skjN=ekTCR6)yit}7WsQ-<{6(Wvl%k>Ic}wwDj7k{^llBsPzsyYhRm zw$?N%9s3ZN`sumw!UOe=y74{{T4;!D+p)Xk^`SR7@aB2^>yGpf_bxb9d6XT@dQLnJ z<0mo`rUDJj{NH?WuqK4ve$3Ks^WuJ`b23V6ZghrLh&LVc@fol+VM;1!p1T2`6Z@=X zv5ZYkE*G}iQdZ;cye2WC>Gv4le7%akA-svFKD;rYP{n_5pGM%h$5;ysHwH}{A~sQy z^@sRiQnv98HLTKMwmJ2J!*=fDu*vrRYk%);Tdm<8iw%`UHv?w6Sg1OLszYvfEYtN^ zfW=nP-D?}3D}`{k;D#OV&i+DZ1%5|rEmPZyY*W>+U zh!wX?kE3O;04URr!3Jp0s)>`DxI6AEc0fKo9jdjUE&nhqjWRn46Ooh$O3uwHZAmt5 z`IKfdi0t-DY-rIRJt+zm52NR$s~`#T-pj@)kV;}BPvcfyW@G2>jJ^OX8WKeQRsnCc zEIXMXyw4KAx)JyuxooNBHT+h*ReyA!xt5V`s1s%>^h|UnCT1}kC2ESH){WR*{JQsN zCZsAc#v4dM2mBxmSb|5JC3$NW3{y7!KYnj18jJ?_%@l>98DSmVMD<^wbCRD=cGhHa zQvT3D0!}-dAW=6Nr%eVy8O30H<>O29XT?(XdS>zp^tv~+eQp|jyR`keFB%XcP%i_w zmn3X^!_HKcE0Eens*$YcD$S02G;%XWmn*nuJdi6HbG7%-u;~&YI%br?n*g>^s)_Iu zB(tOqa4#U6C?#wIQV&{Rx{LNqCwSt;_@f9=b}>-ELE} zWFIuJz@5u-e$lSYrphRQGiKUyX5cF{PGV#Uwug?L8)ALm*6X+x_tGq;QHz*@$>%n} zS;up{ciTgX`F+&J-j}@JMlJANzgCqFHLT$(6>fG1onU=$-wsjt z?}0Dw@S0j{1G^P!GWqJCX&~s!(%C0Ok5pls@%$8wD2_UV44*-wh(Hzvw)O6j!9e;f zquoD!n>svja~~JIqsGVkz-kzrCj$eLfd`V%;*sy1F4^WKtuqn#r?8%=?&1AW8dCfH z4QFL54Li4#So&2wer~;}8`=R42x|*+zU`xO0kx-kYgtZ9iEjTVgixfl2UC)zy9J)^QPyP-wUy!cO4odaE@X8qeqx)ULRc@Z z2?(vMGs22BmsS*de9!cy30@)B1RSB#5p(lw=vkxd4RfW$2HY7fL#&f0;6sF9XBOdqQtKX z8c2zx_mat9c{eJlOp`b$Mjs?P%77u44YeRy(ElEq&mMWgxGZ>b@={TZ{(tWX8V^l? z+@ni1_od!HuQMRXI}Ik4L8;=7jf9Hts11RSVl_RRRHo$pJQM1tj8#g_zUN#6YOn;P zYNtP@8p02RRHAkiBs2&R3R9mW3^XIr6|~Fz><)T(dnyQ?%=R)P;z44?jALU%JZa1w zUttrL!s9)EZZxv*cYDEAwff|NwB!J(|{*le*bXJI>_%r0k#1|AoPzS_NXO-n_bd6U{Id;xuN z%?nTISV>m0mmVd`@qTt_@bN21OW&}Z`}!@3)&e)$W517okrSc#iAtRp3D$5`F3}58 zIf+a`rL)U^6G`b)5Jp7d39FIPsNlOF_R(vJkT{e$m?qd3n&hKeRt|`A@QFcmaACVs z{5P!yLN*g$kuHAJxWE528Tljz{jXKKAUyaP0wj6;q?9@&EhyLY6Z->X+&05kSS$fB zNc`ll=UID~FYt6WP}VBSp#srGEvkZc=UQjhCK)Ca7&fo%s_S~ET)MFI={z=_ZQ9|- zf36fhFbzMvhDJoKmXPW=k!|{Iq4Wtcw!!;w zX0;p{Gvvb1+P3A3n3X zgTT~&)KK3teBeAgee8~R+KI?~mq;AV*q^K=*tDur$P5_3GU&PK5r=lY?yZZ;(<&1o z7S)Q7NgB_TeI@_41WBFI!25E`0eIDFzaVo11 zam}`4E+K=!_AtoV3#_e8V^wn^I!2P=(=Baze*}NPrSu4bH*VJ$uzRoCG<5xP%PaRS zu$iDT^i_N4;gP<+ApIUj-)mZ1hDQm_K;P`>msz(oSeHFf(a~pfvTrM|Mpj;&$03j7 zE>dicx6yZaH+|>rn-}+7&8j`;4K3e7)$Hpu!w5ZC1ax@T?GP6)d%rM{c8zGH{9g+4 z6#*-cuID&9xI^TnO8my%*-gdrFUpLt0FDB(N;n4DIHMzQPkJ!3e>vIZ`&@V9KYk>H85VhTn^dhjgwhea{oiC?d>XZxhJgASFmj$Nb3fdF-ne-mufU^ zXjG{t4zOAdZ)09T19x|sJ~YL!U^mS5vMecNsrjycFc8`;J=Uv=$Ib_ zH>9n`rMd<7Xy4-E8Bb%u5}Xu8CI+g!d^w1s1U!)+HFt;xOa@{=zI^TM>2pNVl{9SN zg#Xe0_x{-IEAEuBP1d~FV*<*BGib=JpO(sEaCW#k+GQl`giZVLaXUese*QZZcz$eg zal3p(;8wra>*RP1{`>J0<@O#DVU*ElKrO4VX+>^TJLgy z<|6PWS|)Zvpau*gn?gvaS6KEW%X^B(`=f6wPVZZTE|GRN#S!(#9EvOo?GL3CS-uDY zu>eA%SId15vgjSvnBxYg`&6Xv)3GtG>k%hmLD|?vwOF=FyH8-`Fl=(i9O! z<7SBy3ew^Q$m{ORpQFeV@Nz~+`qmGt!f<3%x#i;*)YgV`{e)a+n>ZScw5jSWKI$8d3P2xL zba@*VWtj|6IrAvTWdd3077PuJ4EE0tRtusgF_NGd z?$XN#vopx*T@+Z4cLO}onZM1BdlJbAC{;|?^l%N(An13p6gT>GVhnnj!Oj-qr*Ew)~7u?w`KKfMTEnbVc_Cm z+3`+T6x&oL&S?YaarLysMZ;-n=qW8+Zv!f%^|4NmW43#5)tW{#IF^dUa(|`u+nsf= z`_z=gjR&;bcqUxCrJ1Fu%bw2G$W!g}6$B|iXn`MX;3l}8$SzW)J#~TI>XAE+OX*-_bF;)+|;0swV-JbQh zN9zgxXjc#)gS7T&!tR{Wlf}yOd@1RCMjqUB8CQ)vC7dibKLO7+TvI`d^!@+i>Mf(% z-kSDdpcE;^i(6=+6e(JqKq3KY4g(u!_Z0Bsfs z_99AE2<1K|z3+Y~;o+@!JnFGxOoY%F2br=@8SSTiogR>m-rg) zdeKyQ{$A+$-dT|oZY^31?Xzd_OUm9~{p_2Qv~VqZ(j0W6YyJUrquIWSp&@Paw#}Z0 zjGKewVM9ZaoQgrVqLUx}XKR+mfl)v}k1@EHYC-;XP&Qy^feO&be+4E)|Hz9~;oo^o zIi&I&4V5vwHJ4*>K?0v$bT^4>Q6)tT$yyX!do^){gC_ubcHMLq)^4?qDs%&GS>~2% zQ8mAzW1NPiJnRNTj@o7nW^i2=N=FzkZu$NBDMLKdS1+naRX^Q!i0mVG6>pg#(^P~c z>w5+id5J#-%kaGzc~mLif(+G7Bcc+xjHp3GG3rCK6EG)HUL#doFnM0v*7vUf6tsWV zr}xfJgU1PW=j)r)`qTJX%(SlJQll5H&+&?edL>OS#&%MzTNP)R9{|#gwOmqVlo`#C z&zQV;xuwZUPPT*zMBCLTgwPPd7Ly29_0m^ltvxps{Wyg7l@TS0eY@FsX1_hE%1xsC z=mHiWJKI52`H61~G}#>AxRQnwi4kbGaDX2)*!njIY=(G*UW;P)nTst4{v@Uk>{HB5 zPJLJXRbwtf!{%6L++o@;T~=K^VbHF?>n3dg!O{1Vs7_!x2tB5oY_{4`Z>$hB1TA^5K;!8J{Hlv* zQAg*>YHe9*%qMni4VPV`6l-rexhI={%4(h_HuNP|`tJ%qL}i~GIu`ZXOniUI(*HY4 zq2(r{Bh@Sbl#p+z^6{xfD6tdAX1QkfD}NL$zkinB6?)(n_S%Wu5CIi-i4XLv;<<1d zU!xdr%H5bRi@?@mWy2}-$o7?L=3>-dpzYgfkul*sjP~2IO z6I%~|Ugz?2w4t1%ch`ywlWx{NftlczaMZkjf|Z|S>tU5!;= z-z@&ymUqbgbTj1O+FEKyjFcmi*|Nl)+n!#krPS6{<9m%VF~RY}K2CkO;A3Eq(?p(b{Ilk+TkP8GA|IG%d4S*J9mFGF*zLAIj5 zf+}TCl*D$aKOt#j75?Ien%!qo*yCbV;DKGnMsw{`mBGwFh05|R5>@DPZHJ3c$guB4 zE{1JAFj!(>E@9bpP-Q}9rN0B75PxRBW@!F!m^^&O{uqO$|Pp+2HTR_d7n_gTKKWuqH&z4#Xq;@30b zd7Az2a^8ZED=4qmz=yBvIT{8ZDI-+i(uLjfN&|uWUo1`aH22lMMN`{&E2%U!VUxn? z?CNCqJt6q&S)M*yEV|qAY)9Ofp_XR{E~8cUpaXk_j6$dOlymgaC}O$N5vkDwfwKJN zp+vGG;XRMa>G8tcRN?lKoz{jPF{_r{UfxSc^N(5>_#?;}wD6IXWQ;5{lq1+OdX7lp zwv|(FP3J7IM5p@=ZTz#fs4X7Urpz{-u_k0()2cfKc5Et=ugpGm%<}zTkH96$(FlAS zj;QOSh%N-)ZhtDPYjvLGxLf;yIBlGA7Y<{-53)xUJ}l{#m%&5-VGuo+9BCog@W58D zUB)tFjayv$Eg+jX=8*o#(f~A0A|5jF0Z=tAH)U{0A#!vU?0i%b)san9rDobBToA^EkQ-+MaBGqDHYqB(OKJE6GCd&u4l@gUWsUEM=ilA@FqN~cE&cST?^uXy2 z^@sdv^sD|;A{f7~Uyr>;;gV=Kumx^sgh7G#oO&Fy%M55(HGe7+z@*@5aph9t9ZmmBADJn+?274J&{) z*Mqi|3zcVC9k9a5ILEN?=xSCsm$Q(75NE0I+v#H2wgaiFv67}Ixd^rc1+6o0Hnl!O ztvg}Ev2DTn0nK0=)A!({bIQ>Q0j)xGQRSSLF%jKtK0Y_CtF*?-3i0O7fClN7^P3=C zo_B%gyy<$kY$MXBdF&}I;L(~>EB9xJ7j%*y%jsF!kO(TysfB_y30afA-|Q)E&i6Kl zp*NW!3Mwo9C~NUE))BPjt7Le|%R&YVya+-hZSz3IQ1J^F^lPVJAmo?9SEKgCHP-Vz z_*JH`$tE(~4D4tiJXsfNoj^M>rSZJ3P(`Ifdh5$z;K6WK&= zALb#2!OkCgkxIKZ-N=asYwmeYgeVm_-uOsM)%#M58PN}#_LmznQKJCRsA-0i-=57z z{Pjbd1Z4Q@{0VG@Bf1#%iwcOoJ7}qaxBK+1wZPg~__JIf@7KK3<%!4=d8fO(;>P>LqBN4mDbcVQ?MMJ=hiK+ubIZRsLA`(j?=6k z(WwZn>GZUnw_IO3^;q^MG~3257nuNW-UFa9RCzifVZUl)hSY?2LvfQ0Z_CttqdUgN zw#x1qIViV(a(Oz)Hu*L{`gS!krb5nvZLE|FM!z$O2)OP+6zs;v?Rqo3h_qQZ@I27y z{pj1LA#ljJENE=Kbq2~Xse<<5J1C0tbBrs4v7Zy3xZV|q=#yP+l9wTVi&k@7moRde zw)%lb(bsBc#NOrM{+obfesJ=9;?4QicH)g9eQFCNqF{{4Og(T3o?jI#`}%e__+1#! z5=7PL_Y87TO3@4d!1=%nGosvh+Ym%VH5I!^pCZSY!^&UE4 zdeKMO50!KCU-n4p-+s2qJFL>3_T47L)SqDL%!23HyevFkn zmC)4(Xvqr@=u=c&{ce_hiXgZmMw%7ZJ1zJrwC|y~wcOL+`@kekIhmM;l|!qwxi*N03EQiPR2EHIyPt6(faWWQ*-@WdMKZ zQ60F!R_$p?iPZ&Dd4{Xg8%a-br0@m=#pf<-Z=^?FB2~+fju*;~`RZhGQEt>Y&nKfk zKDQq&!-SB($1Nt1M0cfisnV_*KG>8)jknt}7dpT2U%2_c$uBsp5C4@$Uhn$&e7|r= zhAUIa&*=u)AQ!O$1L}I~&xP&%^Bhr`Js1|eR^QOk)@9zuwZ5`YJuc>3c+sdKv5tiy z6!1^5gn|_qh!WDWOc)n6Ve!=eI*{Dbt96mGQHc4KgMmdr4{{>It1e#=s5{TQbaL+6 z;-tmY@lexqx~{9RRpqR~FJn6LIIUq;QpZ3ttEqT=NRlF~74Xw$B;rzpL+y{GT2`ud zJy8c`et-JakdU}zrIMVa;bxC@H=U5>pNplP$LJ_=-A>XfjH&j9M#@Z#g4&0T%a{)9 z1V)COB*yRmQKydw1y*g_;Dk%#4m1`2)?JNaiptt*9m6~|T2X(tUe`D*T&AFH!r6W% zwr#i8Z8zPieHtO=ZEjA0<`I<1@%vzkFDh;mJ>@#SfSbu45dJo~bE7>F8}0pwmiZU z9_Gv4Dvf$1{!dPbg8niTg(?vlk$)PvsZHJEN=D6+W3Xfy-M7;Sc4jh-IbNN#yA>22vw>0ag^?H@q0`JS)sIeK^VJW#$VlEe} zqHY7$fRa>b#qaeEh3w?XkmZ5641;xz@>SL@c~x7=C9tN=U8+|>I9ridlTl+U ze=B8P2j%HiuccMWs?S#E-nma~NkJj7H~1HO`@nlWg5sBe@BBO@JtJR_(h_y{#2_tJ zr-HbBJ0kANYo*;DhJ&IChFUX`aZf2LzHk$IkZF5va4xM#rCrpxn%E$uP5$Sj*VOf98B5>*&^j}Kilhor~vJAuup$&}Vs z783ACwH~JtQH`UxxrU%O*Ju&7H8m{yH6yYUk9C~=3Js1&c;d!(pTBzVAt5ZpZpP>A z8!gOozg{Jopr!7!HgmZSEQ=f`b5qD2JU>5#>t*%Q&J@uc=(v0J`$oF@zLpl6w+Ek7 z&ZNR6MOUhS!ev7#sWv|hU{jw)tnvZ3!ruRl8U26Y(a%=^zB3DO%gc21#P=cPI~VIq z@W)00>bMpQd8kcwg7MRkFpC4j8NR_E+VS-x)fQJjh<91r%b!b*r~?%@+7FAOn8=apN{B~RJ}-gKpIz_gDoRcOU&N)5hETl zcnkHuxO&2)&orUd+PXyF+ofZU6A@`3S&O*SFUc*wsWv$AS>ir7fb}q&?~l_pUKX=RTf?3A>i% zB`^MYXUzu_SW2psLs0{(z~nRjj1G{?}1#c=2FOkXtf3#O&Y1%Ou28a)Ds$!6S2=qhyXmP!%_?Z z6x0C1KW&MiV6(a|+h^0L{}N6y0FaNwRSrz*tft`^pf(Zf|7qbfV${Nqw6?3=Zp#;I zI?mO~Bwu<+wDVxd5{%ff4slvitCy}GZ19VwS$dq`biEhN?n&NlYH7{X*chBkKscWN zSb!lk2VQiN=O-@Sc#5lsTvZ&+R&#k8>68>~7NbsOoy?FURCwgRjE!iOeRw%L%T?*` z$AON{`&q9if!t{I7ifw#s>#a;+Q&cIXnK{|GcupHF9cHF+;8birj4A}d@EEY2k+o6 z4Rau{L{oi6o-g4;oLl^W)54${{{v1+yr+Zw~ub0`;0*|)8i`d4P=R$*pyd(@CW_?-KPo^e*G|>DUeohMr=&DTug>*ppzbt8VVq=j%-U@ZMw~$CZCaRA##i;+q zJ04RjS9G?TLsqzE_$a21Fj06t^fVSM>Nd?Sl51JRvAtMwdhZ7 zWrPCdJC3X;&qRpc+!!%yO+uP0vw)@GQN}sY$$kftT%zqYh1vr7$}C+C;0gLNV`uOl zPvGlSxlg0>4jWTh!1)dMRXg8Cynu?M(LDu>LgTEZDKJBPI%(Ubv%+q&{;pYO zQe$cXaAXaL$fq}E>!T;=zZ2m|kC6%h%`4n6!pFd*cpu+A6y=7MH%uOl-VMVoiQO0= zQF)q?-yXPX5ZP^9y0O+YXh3S%pDeGTyC|%L7a|D%0hliEYWw(ur zL|*(G=>Gl;%>;8~QP^!SkWL_QTh^cU1iXYl0qZ!vXr{V6^!0{*1wr^7d+-eO#_9M# z6JD;{Q(cH4^^Vw)^Xh~<=d#v|D;Hs?P(<%6R$F>i2_{r-%wN;n`?*;r%vr8TIKg`m zdMw&P-S6^fLEp1zti%ePYpRuxR=hEca^p&JYxpF`UE=U?d} zaBttf70WS_CUR80l#XBfC_#YLDCyVnf~q=lo0MorPt#>YThh%}p!TQx)d*NbXlu5Q zIg;Ike(vmBXuB;oPJmotjld;PClT#I++ci=15#C&!n+Rrl0^G#fr z;`~l&$slxia}FIu9&`1nu>UBNW-><8mObYQUrt^YLL`fQn_y=}x6gxZ3=4Ofc2%CA zbguXr)x7x}J!@j^(M^Xp>m&5|k;+v_tg4~dE|-a;VujOghH=Ee1h!qiIu;p!L~5_G zn@eh^KlwIvdUYakZ;odBLd}-h1=>N+K)}g>YM`I&EM0lUV;fBUA_47Rp7HxTv_txf zSOB4YfU|=N1<-ZrWz{LO(uS5;>+Ats%66WsjN+|#4@jau+Iehhk%l?JxzloHjM{1S zQ$6L{?B|A{F@Cxd_0x_sc4ScP(dsz#q$y8a$bXm`*2J{loLKG7XlAEI$X{38uoQaZ zKX&V+84OR=%qf%QEa(`r-YS)OID3$f-r=~e_e9It;6|P^`8#ZWO&T*0LfY~Dp@u0n zv77Eq-r?gVqh;VQ;p(aidF?e~@=k)>+9?+pMP?w$($~R~lfTO_cdVcNGB^3nH8oF; zo2Cu;^P!L*U6CnX0LaX|8FU=&EvWPiap`*i&x9|=VfUx;A}r$;HLP1lPo#dTEbi)t zW@%(>;&giOO&CA)Iwd}ID@QM(m8`g*(Sq0s7Y zeU}x|YNK*FuP@UhJ&=^czGN7C%I=nTRwC^~vPwpItS}~@qqMuSkJXWhePc^XYs<3< zzYB++4r(Ohg0nx=7^ZKs2qoQ>vYK4<^B1ZOW7LCZeBfT#NA@SBw5zp+P!$lGPi~vI zu0{UyX-=6Iu$?lGJG%R6UrT7b(;7Y~dKdd&$r1{B>ni|T($$;SJM=K!yhJgqy3LrC zp+BQu^_rnebw*l=;<`)+8rBh@F|w+vQv0pWS>fihIBvEj%KWjN^Swl}=yv$doOTFz zhv!G30r-XUTmIeAo3EpJf=rH;to7^9h@*Bs`1+)rKM1gzP^qF|$%uo`e`|flom5Rq zd@&G>mfapd5Pg2WgQsZWEUg@IsMv;C<%c`oOmN13e9E)(Qf&SV5m8lJ%bJUa{xOuq zV2a(?)eGH~=V z^QQB>hXlzmI*CI*OV@@@P`5Uwtef?chqFdZ^@{*LLZxh*cyiCoD@LS~rIV+*z0dy0 zdeaPT>v4WAx9kwl)itK;xDOpIz(7axNsOF(33VLMpVf^|=Zuk$YXn8-Fb`Wv)|JZFLKFp|Qxr+UY z55JPa|8a9VftLuWwQ)3!ab-K`$E7y=p;$}O-QOZ$Xa5H0a&N7?6E~elaIN=7Z*+## zOSFWsWab#+u-bjYH5#=EeaT>m{gd9TrHXssa!d-gy%{_zqOJu5>t~5MwS`>kII;8645!EflDbe*w8*$m&Pz=tBu&{Li>i<; zIU3ZYo<|)87w2$pma^?4$XU7Xey#Uvv~Crr?GiWZw$(XU73U*RzDG%J!w^qe#7Av2 z1KeRJ{Fw~V#k1~PnnBGpFF)&GRCU)K?bhS2n^s3wW&Ux6Zb3Gvl{1?g*l+eO7de?V9(IG>S%Ya zuT9qP2+r(h`lXzeDVQ`t;pQ|K#AdoyZOjDCO6`WOi0)8?vfw1M_zKbKjU?STSIiiN_I`38e3Hjhww zP}8%DBb(cvfM6E3l}%|Upf50^c4IuG_AEDQQ(sNBY!$YZ-mOCcd6Jlbm+VDK43umlJQepQ=Wd>{WLF*+c(Mt`hxBGpuIA6d)4(SRp6f1#>?p?G za;q-emJ9aPl#8h{h;PuBu{!Hx3*+nBoD|xopQs9%Sy~!~Z>fKrz=AU3&)y>RP4b;=2PpPgRue20chjx72ez3t6JaQ;v zS*qTa6qH6;@P!=VC5kW7fwiJGyFBKJuYHdE_51DJjl|wO|5s-J9#Dg=UF@8hvO#N_ z=iFH?ub?+u)RNiCY5YDZDPih&QTvIzNZXh|FckYR56nzY)4~UdXIwZsy)taD^J4c} zP?F|I|5Y_Z4E(rudL!N;FM-|?olAFTd}Lvr@yo{h@2?R;C_>3!3vP+ zA0lYKHrF&Lt$vf|3?5CkuN?gD4m4cqN?F@Pm6c_4i6V=8j6+AmM{p?Ut-7Tqj;s@~ zwI8fc*yn4D?8Q5U?BD(fVXVE$Xz(-H3kO#LlTykavy;wP>R1#F? zsA!qQf1dL1hu@6;_%Sc6Womk#zjil4r5Wyhe2D9HoLTSOUDB!tO}rO$p_sGUZMx`e zcq6lBa3t7o@JJERUKN$AI*Ea+V5A24Jz)PzeR{c}yvnjBTr7&Hg`{U*Ul5FJ`xMcr z!8Zb&eWB<=IVra`$63?ky~us!JDG=5L&0qlO^#KS=q{hdSsUuhv0d+YM}xJkXZRO( zNcIY%y4x((A*0R1%c3InL<+>8`8sl40nrf~UN`Ex@%)G3JSDz)FX6Jbk(tJ&xj*!x zUiG!>9(c(mhZeU7lrjCQ5oR`N zEzb8W4R144q&4*M2>ki_`Ess*k+U$fRPC>~R3R7iTs}BQjZ_OcKOeF2(xLbD62_bT$;g>7~)P%qx8!aK9LJzLMVW==v$zzAGf1UjWqERN zF4`PbIY{7P1ty?in$O5MlYRBHG@Xl3+Jir}I~-gB-ayQPKUv35+5Jznf@!iyB@>DKs5aQ7HhA^ec1euoU}h7*}-!+|xS}2AX^{ z@pQ5_kyH3nDja;bX%l%k*>QIdr3W6?w>i%`wUnKaR4t0SEx1@U5|iYb z-=0Xlfc{+GMdIU6YCds~#eAlHe)}~QY(w1qy(eC{Fg0R$?cU%+n%f=BC-2t9^pEQ_ zCKNzmj&`ry_}b!(kGIPo{eLo2BkA`P;BEyAt#hFQ#&)1xQqt}0s$OuaY#ux#ZGrc} zsR!J^x}2!8z&Gr@V#zS6_j-l`pugj!bEY3#ZX=c|32 z#M#!)eNzvvpJ!GHqwzheZ|yn1#@%}Lsh8`PS+5GG_EfB?7<_w0@clWOwf)zAbILdG zPBlIAE>_G$YAmJ7^vFniud+mctEwgy#;b#-=+3B(61fCkyo#Rq?Ru9k@Pq9`4$*CS z==-6qjI{8=`o&=}%d}~A%(;Ow8T)t;}VveMjZ>_m64 zg7?q_bC|LZ&XD6)sJQ>7!Tg2s3!?>*dWtQu8Ez=oBXR0?GFWUO+~@gGgXOU^UzLhi zgz=hIRyBHoEoT{FCMFq0j>PfCe{rWKxd zne1~jUh&D6{cb{&1Kl*I{+>(ypJ`6pUjkF>1QXBA(v>!?)6`Q4Cs)b?E3~fIMd@}5 zjL(}gQc=9ta(uEyKr?B_4x^dJOhv-GWST`E$WVD?Y9+6yCZ2#6$XNh+7{9M$uHul1 zMS3lPa+q3(npk-;1}Cti%ZQ9AqGpnP<2%(+WInMoDryHYK`t#-v9y!O;l!TKp4TMI zP-Kl|_lRfisL8yqWv+lB-<<5kY(W`0E5^UuQSmP4L-vkl)WVI{r)`o}N`DlNXNiVq z?Sjda;uO0C+JD7Nu2PF)SJw?ha9G>uk?u=W_byC& zh5;4MnU0#z-d;Bq8&}!6R8F3W$?Zn+hU|sK$3?yP_~(H}@R>~XZ|z$yh-dY;MUzFY z?ep${D{u{1+iqpxQ&GdYwRn%)y>Inp&8nAnQSU+c?nY&o>0wm|tF)p3z8G5T?djdt zV3SnJ0JfOlIQhR)7{C^Kr5N}Y6;G`tfk}}AtBITTO-wqGQiyd#cT0m72hr90PZ}Cp z7)M_#(xGYz(&yvV4SX9cgdjSB<5wf$pqU;=x6z>haf(9LDKc+m;GUX}E@H^(4@n=C zwJco5L%YniXg;B&XB!WiBc#!HK4l}MWzy(h3y~Uoy6h?jl}cw-s~vhG)=}!^kep>o z2}sklQO6t@rQv#eDDcab8=1aV9qDN>@Br{VYpJGvbi&J$fYO~ zxlvnzjx6{p_(&q~(b8v6%r zHw&Y?-}WEfwh51ZBov)?Dvstv(;Un=)ArM@HIz)}`nKHh8~hH2C2Nt)VOD*3VTOL1d65-eIjdtB7U#iIk2t@KFmv#?T}HrV zf3DjJx!}L(H;K`Rw!zUfE@)SXdRnyD>x_p{oJN_Z5Drx5l;t|gw?ie+Da9e(cgsw(I$-!mOva08{mDi5Nr8|rv#CJc=B;mk7p!}u+n*YcG z^8?NmwH_Shf`nCqfqTop1&QAKhT0ZYnKT}w<2?b(@{f@jJr|+(-*+PST*?=jfSei= zF%V$!p(3%CZ@2u9!XNu>|9=@PnD`BuDP8sNpPoN0=i0ehTzDhLM3AeIHe7 zq{H=X0;X$#R99$ULBp^8@!r8u2nVZkREFxuVd_zX3?V7|{k}wYhvLShu_LB0)GX+y z7aU|hf>BG7iIm~GrzFxpmaNJnacGGLMql&pZ5|qJR5KJ|L<=MaW@j6FHzUolnkx(B zb+m^iCG?3@)65?mbJ4NL{r$2x1uh;C_lS01Q_Vg)U>5RX^tT@AJ+I^E(L_eQa*IPr zA9jvzkCgn2tE;IS5$^^!I$3z_ZeoEu?{ojH!KJx#s&zl37vEl@zWT$$cHv~WH5Hs; zN_%zl=P|;Jksw+s939Dsbl$&hq9J~h8R^ilXUZ1{z9?%GUxItu^c&i`@_mJDC=d9{ zY~C%h7Xl}H4h}PJcZtS&jCIQ6Dxtt6mxkT>!gC=n+x$8ky8TVzyCNZqX|Yv;?`yj` zv=%N8DYzMHc0&Y)DYLLQwK#hfLy7%9HIbMurYp^$8Q-0#VC#BLEtUaFoTM*Ma#`2a9g4*&af0O=ZH! zt7!3eL!=1thKWu8&lR@g52FpVso=94(ovTJ1O2X9?yA>0$ByP(=5?-()YDT1%W0dx zLbVHS7h9pHc*~Jl^OkDr2dfJ%d3y)dAjkf6|zu!3d?rW zR}1-e5A#u1GXy1oXB)&z35S;%?~tP6&`94!{M}+E(doW z_bF~Y1E_*;3qY9#2e&IC{RrL%(lQ&pC?OpO?UUa+SrKYddtvAS&WzZb?JVc>T74S$ zsW;)BDDb*Z3P1Uu>n#NH`L6md4&RBiq_tn?{Q%wdEs(paBw6*8a(4@Y)G+E*YOi9? z$l(knh-BDS%y^WA%vERkpSIhCFZ;8T3*(}f@eRCmR{N0iqw!^+=%Jr=z+^=iu4 zA5m4f7zpwY(=?jX=u}MTauy0X-r-0smL1V|--0!qF1lSrX@0Ie+(vjgyDLE(EURo+ zO;{~|m}Cb7l#Q8xwtvM^c+}T_b4#v+{Pd5>xWtL#W_aR>;t!#3rk&Qy#>%tr1ESy~ zsfmjxQ?9zFgLaA}iX!zDYB~TMeTsRSTPG%cH`Dm$eabyhnJjNTtky==Y1hu-*hp`; z?^ISF%1n0oh)hs~dB6N)7;TU<)h1f93GF)%8HLn{-*SnCU+ShObR&C4tz`Wz%qz+A zA||l?WARD=1cK=EpS_<`;T^wA`7KsHB==w@soAIYIDS`df!n^1I1l3!%xnH-sj|8RiQXd>tULsCU$W7L!;y`xos8~*Ll0UQUYAJoebk$7e=AgH!4edCK`qg4*M7LGR z(5qXHklCTBO{!5I0lH25kyCa5mbi0hI*q|nBBYV&uu({L1w9b)MQH`svb@Xb)XTWXkGcL(Qx0t{aGN zhI9*!-8~DZO~+PWCq4ERg&s@Cm(cO8p_3oo!4F`#j!cjZ($tH>W^p9IIkwX5$+6B6 z@Xn@y6rbVK1;TBeiN8>#V-t9=)Jt#}Rx?(mL|4I4SaJ7Am8^99k;Tv})G?QMh16(^ z+Y2xZ8{qSXP?nzAYu=f7q)o5Qp2WxPRu_aEe*C@Bk>MmX?MsI^&BXq7*J}$9z{Wvq zmdv6h4f`PbKPqG&-)VFJr&Cj?7+UaR>Kl1&tD%Om5sUD7xbg1a4ET$be0WPefU!sC z0fSb6VYRFrENppA96k#2WJo!iD22Sjx2nt)IxN!N33XOW;HSGcW&zrcklVG zU$SnZXKt%y;mSPf<|+}v%g8j)h^?X4@bpDbSc6KrZON`6SR#vBVzj5z}Yt;x^B(>-P zF~8Pp$rNOYYBTSmk*f#ydioTq8m|1zR2Q3MyxAu6eg;~WV|_bRo3*M?y*0sgbP7E%js@ODdwL6E5!=ABDw@aF8znxk)LRY;LD{S6^~w~>h_%Nm|P zZ~`tiE+t9U;c3%2U=A-g!EDfXEScL^dpkB_fyHjlIRArfpwe?%jK@tj$@f<=iLX4F z^pE~v0Bq^+?H{j*PM5}CyGK1*wdgR{ae+vI$!_24tUGN;zJx{5oD4xkah}EafpOqtmhqF{@ET;hJ_QqxXSxV7z5M z!um;8mx4Qum~Xvzj^MP@o#FN2p(@V0$(6s=Q3x4LHo;IZmBo4 z2{7ckT`u|7>F{Zjko)Y*s^Ac*M09u9kDJG75v*gUlndzUKaK{?3dZN-tLpQUfz zkwUu7f5=!^T{t!j^6I`c-|w$Z-$j@_$!U=OtA$Io=e2AC1TtQ2pwMU9@7VwyIyp3# zS?V$!A{Lz9`~3D<`LXnae@>r zg7!WCy|7W6fPy2y;AAMDSOI%ppZpGA%|pE8s>x^)szU+1@fjcGd?rpv@ZBA4LmSDK zYP_-BZsm!TBg&FnY5q}OSH9NQ_Fw?CzkMy0eU|nth)%R9kv#u1!5iP4#Ab*7r+FL~ zMr>%LW%);#Y!@7`hdbEB&lSD%D3O6WE9*kn!;BJ;hWYV3u@FpA-R^i&*=S8oH{tA`@sZeFlhJS@N6@{d&j+6Zh9zsE1rss4U45X)KyD@Ovr)-Lv zDXmqx;yhaDrEiJe@o9->OI3W#GZNRe+Pv0nt>QbNCQ99@PA&{~*uQmz)_M5C(vNJs;LA&(n2wGfTnT7MFEFjmy4ytr zN4V$U^frecR=;BO=^+JtEuOIUv3x)dtWVrM4m$RwVng@$i^V=cVjhBSaP;((bX^W6 z#pYmluGA`mBKeWtQ|T^hWmvS1>{7D%#L9h>vymn&jvbo;!iyN8ulHk1YOah5zm++- z*fCqXx7Ve)Wp2!<+W!a8?qlriI9}zhbRB>GKi|Up)n~?GQsSV8i-OQAEUUO!)mWw7 z9jf@xkR8dNV0QKaJ<>y8+~uq@P2{>c-_KN)!c@RY5uvSvdSRfZhR5WsqA;h7hXx?{h(7!w}xnCK;nLiyR*GMi(;YrFj0aW(l8Iey`ruT?f}wF&{ChgIw@ z7X$S=za0*deDlwhC%}?M`(Xba>_Go~(#ZLosPG;Vl&?)8#Ui2ccVOj@LKvf3u8>;e zqUHBXg6)4YvA}e{8QtSL4~K!oFrugPGFqeY{ja3)JWVwco>TNZH$z+XlA)V*X%?jp zLBbX(?5bgl9666@vC607Ti2N?&R+dLrPQX6$L^y?38-^84$@1Np)YFDAWZxR-F}(s zN8qUP5uYI7-%Nn-o@k~8A)jOLx?21)6d*FJmsEnEg&MG)p@N_@&R=T}OXK~BCFV16&e`rot%&S$7MT0_4wz~qutyZ_4;^am)fqsn|C&yxo9nNz2n z;TY&PM;&H4oj=+f9bXh^936fCHQ>A4L8XR4Kx8APWYgvTe%uLga?o=smf)_7MxrSu zScfy;&0;x7I*ULbZ5Q{klA!kZNxbBKqg=}4Y|FRm5{f;?wdcr2`#-q{e)F4_{I2;v z#JFyk_+OR;NX7n1wi#tk3(oEz4KAlS)Dud;oiK}}JsIkIe}#DiczpaKPEI6tm{6vQ zLeTwdC6i5ruG?QuAm#-Jx?aZKy1HHbdcrQZ1QMKKinfZXz@z2GL3Xk>k zcQ3JJ#P61A$U9(JbU*;q$L%0QqD{gR8Nl#3R$*^QFKm_X47cZFRm=zB*XAbD(vKns z5p#O25aCM5b?WM#LP2djo8t!fvsKd+AlQvDg7EibFTh&VX4f$$G{P#}AF3M9^Zq z^?pIVimEEs!h!R}`qk{t=Zj5OI@PZyw3D`4(vpwvW1PTGTu)C#)0to)9*Fs@el1_y*?J_y9!>_^1H=^sPqh?W_xSboYVDv- zTCPc!l*E9~c6s^igxd5-H=367e6vZuZ|s#qL~&aoOv@vuM|Z8@TIHLRtZxE_%A@2^ zU!nv!`*mVSSgSZpsL5i7&Yj`M7Iy98`}`v!az7L$O7izO#s6s4e>URu_UGd_y-vxB zKe}h@J;e7ojfK~h<(nJ97oF)LuUx-l&}vr^E->p-6zGiT62sLMi9g7jJaHsG`tHz_ z!p(QSvH4Xbuux=tto`f!Fjo833|hKhE9Xa2oM)eywq%5994bbwc0gsQYeN+eli(DwY|Sa zC+8I_r-*GR#^X`N8UAcSv~yppQF|MFTlEas)g zvy`DZH4ik=pkZ7X`D>S(`+Z0`Ke6e7REJjOMOv+Mx0ZF3=*%hQTAG+k#wZOBr&;)B zz06}9y|cFx->C0MR`R_l?)#0l(g&URDHh?h$W9E|vYJW5KONOnxVd=KkGEs7Kg#n- zUO()jjSY(m(RGd#|Mh$x=cj+W(37b59{vRmLo32BJvAV1U&f#PZN87n517RM4H81C z@;w*r4-O%X71ivBR2niID!#9=!f1sjuYC!w0!-Y69cp%e+5f0o$3!2!o>RBE90t`) zt3~DD@($Ty8etqkx~{gF+%vo_HU>R>xlehm;NABKxfXAiI^o&1H>M9spWcaa6b}V9 z)(Xn^8F0KiD)1|&->!I!|3zpB7C_GoCU|{nq&9Ro(()*<{NBf4bpmJ@#{CZqPZl&4 zf^;gObPADZ3;19DX)p>*@7xIt)r-b&B31s!hX1qq@bU9(`NV0i#j-M&?`~g4SCwEyEG7O{&Rt}*Ag;x@jfoUggZR5 z--Q|o`oEj^KL^PTMG1+R(Y>V18qBObT6n(_-1BN~DzN1QFY(fFb+ydmjW`h zbaxG10!nvx3rI-Kh=NKth=6p1v^0WJ(%m2}-5uWr)Ysqt^U?eGFn74;?6daTYwr`6 zHY293<#D@xg!*A-MZ}=IyTh0m-7nU&Cj=$WOB!j8ctQ^-__}!VU<XkHKwZhCKWSr+`Ho6+lHyq_JiZoNt%sr5xjCaVKpF+N=q< ztCc27m$xq}gT2yN!$==U9?CX9;{R%k6T6+%<)@hy>0S(Pe_Z{h^wBzs=lrV25faUU zGp`?t$kg{qvw6PSinzJJ)!N1^U0Uz#@S_xiG3pIj3>BXQmU#&sAape10HNcvmmmE_ zz}n+XlV$b1(-UON*eMQoL;ss`?1VK;VHj3?f+;c1du&$T)B&wLB(qzZRta_ z=h-!p6)*3KVyg&NS&EZfyIWRB#YT#V_#Br;k}B?-Uo0l}_nUMYa}dv{yc%OU1=!6o8L;wZ zDQe({H%eu;G&tYgNZzM;Xg)@#{<~3ZlCn{!k(8cEq5X@Uo2onimwQO%|AG(Ns0m*3 zVmE?pP4EZbA7}-Oa~zs3Zdc7EJ-d_1f+^*jvYNIWmSfk+W(*FnXuy$LX`DgwF^GPq zrGGKBm&}CW<*-6d1lHFRtXFx0UiZz_Z(#CQ=*%6Y^ReBMjI#akJQlCS(BNcs7ug2w zfp2*&BX|#AL0ztG4chYjS!O=P$?p4Iq&tGb(Vggzwvb?eccI``8Xx$UO?w9s{{s&o zdOtZcHPrQ1$)l@X-rul|v&TaI?!hvmlu;&b2Bg^Tc zGd#)_JO%!!wHW)EhUhxx4=p73O%hA@t9>NK%WVaS+FDXhD@@ECR&bcl)M;NT5k%Jt zEzOPHvnvW{-svcOVC#~#)-0;Af(+`Df?aWkQ-ni*mUVvp@aawMdz7Q?#~C&0OSHw5u7i(Lm}XdF)5&gP4p=XB$|!QT#mmM^Zc9>+ssU0&wtMm4y0 z!A353)sjRf0`;581jTX3iOgN;Je_GCs`k9qke6Gd&RZ60-1{MeEeEZwcNZg8h*aQ8 zLCcdm>!|3RnQ!T0#9ZDnFDer?VC&n#GA%^?_gvGR& z#*X|Tw(~K*;4}s*X(li_2^d}KQ#YCL-2uW?cbQKsZ#pMVq$hD7af`qBtH}JY!>Vfq zcQS$US|-8&?9u{);dU5o_oJc=PU|X7-~0RB@wS}rG$?ol%M0bJba0J5`J(NNSXLUU z;x_uj<4@7!BcRWNndeYe+14+-33`mI!}lvcaPE5$Xx{neTy<1%KD85LNrAvJhMx#FtCXxWw3JRkF6lA;Cur4$^|+BieX9$ z)%PEn8Tr@ixK``CsJFXUCU{a5lnC0AI+e3V* zJHM0oa3z>{#v-+1haKJt<#*)2v~%kY6!1p2JG3oaxiiO{De>JFq2J^^aH>71f*3xu zH1?$U@tGdYSw7@wc_;)Hww8L=9-Odk5#{>OA*eS%B&&L_1%<9p9Dx!EK8p(raM_Lz z$d{gW+r_|`(R;r=MP7rn@@F|vEfu7~a}2BNe~1mR0zlY`wN9%$Y!Th&Y28qq60$9n zM53sWK3OQTjM3Bstgl$8pt}%OcUt_u?mBrb{Ae|t9|BpGY*vHe>9$2E1*Ea%Ml7o_ zB=z-tzDXJCgH67GJ5=A6_G#-8#Mx$s>szgJ6y6r4a$vsV?pmr}B$^AYDs9)QExtF!Z;^_!2 zXm|afW=P$NUO@7$dnFPzr;J_ixAgcA$n0E@l#ykj9F>zu=67qfr2#KMz8Ederf^sh7DXAJI^vl?H_j@z9T&Gd*Z!9{`Z6&qBt1y!lOHR_lEwD zwJE}&YaAu>3EU|JFM}-Gmm*zlh4^Cbv$pO%6_8KmwtWPLQ-QW>9^w$U?w32XZU*=M zGy?YCu)$L%a^fn;+7|uk?{S&!-E*j%C#I#w8VY>J!4=g%-j;3^>_Yc&H_OrF5@O#$ z*4mX3)-}j*g~Vgl%uW0~{5pUchH(#HAb;SNjjT{$d0D@RsISQpEATx)rME4O@;9Aq ze}sh@H!K(Qg8tV(As>)c-I;LB+BBIGUB<$eFCK0mtEBhhjFGZD^Vlp7Z=y=){3WKc z*JRF3pD?DPQST6eiaqB_wS-M%g5*(^{}p8*49_;GdzjMZ zDbao8*R*h3ibU=W2Ez@tLXIfmk&#o^>=|W_R#Jx7f-#9WYQjl%Wi`9^JUC*2C8^{< zeaJ=TGjZC$w}gs1XLs!-;Sk~-;j2$i*!I-(EyuBN^qC%}HzRUBPKv6H9QCc#|j^#yFPCO!$BUv+wN+YH2Fcccx%ywyBI>uM7d#09d%?FO)cv0SrEI~7Um za8+)py*Et)vq143b=i&7eEWCf?=~SK-H&r>RHy%g=^%wqza^Wh_4tV`)k>b{Oz$>{NEi{^Y>1e28(~fPfl2FextW z#%R)!yPpa!&KlD!W&(#_FLm{G&GY83VYUV z{Iq8zJ|hzIdPQcP#HDl}}5g*p$`@iFekrGrpaN(zaFwNp( zz{OKmg#X0|;wp!!9Oyge7j4Tq?j+A2U>qz~3b@l$|K?d`$rW3weJ`-N4RQBM}bGl5k;U?dx<#beQ|wzeNMbSXg>At5gjd+QDCA zT>q!>3-~2^x8l0c+|LO~-DW1S0bVNlpuUzmo!(AH1^lyEznjH6k3kpiMOGf$4V%gx zBcfn%?R9~dXD~Hgq5qp5nP$PT3U#~PGj>z-KSe}zX=ub{$n6wXi4*{xx{StNJgIv`>KFRtR?xT~v5MT%~Y*qQB5|c!I-ANUk0r@8z-($x*`? zUh*`nGtHHIeMfU$8_bzGbN*Y>2H=j24HpJ7x5OuNDBNO4 zsNtx967iyd@Y!aTX^$6r(0T?cy}DlN3o%B?U;j}5wqcq1?I@zLp$|0zrd7jSkgkzk zNeDna&9s`J=a5`)c4Y-421@F;%4?var=Ul%3L?785ML5JQ2N?Dpq-S5vV(C& zV`V6~@d^94{E`5}yCh3y)1@MJcPWiIiT-y1mjo|-TEnz*_(^7ta<5|&hac|K*E3t$ z50at;jutko&PE~#<w+6k+aK*ZO7SI{CL6NN%Ue`HmxaTr^Nu*P%mygmmy zOuY3-l#&b?xi4R~xy;5Z43-HD7PcZZc9COLor=;cjwp!?xlw!^6Dv*a+cfRN5qY^M zUXi|*CZRA(Z(PI4+o8RrhM2Maa)LH3*cqH^u%`bN2Db&r<49kk>8yVWol967(E<2bwlt%g{JI@=fuGQYD5j&6Dl zjTAV{sY7I@{}>ZrfKnam3p0U>$4v@kqujvD5DKyls*rp55#6K=(E&sC-!dNpVyZr6 ziH>Euo>aQtk5WTY4`y^tC}a-hGl#POyC;}?P+G}zLpCTtFDxi+TPFh8cdb}{Ny>Aa zTfdJHAf0_qAT%>)oMPpCB2LTKs3$7;XP_S;$|4bn5)LJNIS6bcCXxDIo;H%34YJ*9 z?<%*a`W~;G7I;!lOPtD<{4lc;*V;`T~>ze zAaCRBy%1w*VEvhySk*Fs0c<|_lapL0y9>B0&rb$ji`iUILiZ`ib7;3@0+=u;uPRJl zPvaho#%zk%9h_SP))B&E09=Jj8A`^M>2N8W8KeiJ&F`=v5~W}K!0nHNx^i1p^0aw9 zv7B>7_#3Vr6`*o_4h@nG6^mUHJCLo1*m8f};@T__2-uwkNcpWP-}DxmXT2{(`~?;h zg@~az9&d*3{a}o>{g|vrkRtx=GjO*c)#qFre|D*vRU;17PqGh?Mg?T^hLt}CM^}J$80)>C0E$+sXQeTyzl~+fG1FJjp^r-`1a{n4NyR`y!=Sn@zL00 z@ApL|y}+~~U`YgUQzXK@m6*AB-@S@yZ!vE2d@c8B3Cllm`?`Tx=C|0B<(guVne2@G z#AcK!JcxwYj5~X8>R_0?db{T2=)%U`ECm7p1B%SJ7Li0y^ls{UFE_R%G%&l*kky|m zOwgle(|6CQhlQxTlELD5NKmEcoZ?GlrF|+g~N6g!MEcLBY^mAax8g%u@?b78>l&%+hG`Vmn&^Gub&9TzRu#HQP{HxQ_2f?3;0t>F?C0dQTHD;|E=X-3pRKdmZi6p zt5+#OriJ^am6!}3Gz)_D20S>xa^;!%sq-bzVRT3n4}w3*5ZL`{#ciyYmnxUsaN8am z$Q_xUWG^Uz-msJrWy=l-)LJOL7g-b|`0YJJ{;=Km1THVGwHRxV;?utza5EYd9~<9k zC<+Ptzy3h9h4WMV`!=*O3_SYyLLgwL-nFattby&;c8x_~^|DO&0w4Z>HG|1$1rPa2dETNc}YIaKf8ur&9K>e-IVH05BEVSLlW)Et&CWdi4%WUL7;T#xc zLve_}8M<>q(uP1DAFkd2wZW;$^}Ob&>em!Bkhi~(OLcGAo6Z7w;E%@uBO~J=F4A}D zb@jG8wT^p?ortayOaa{S8g{J?filOe7Wv9UJ%4h*(VMq3CEs@-4X}TRd+bWS#pNWI z9)vP~D~sP6gOo32sfrZi$~N*IXTnncEvdQ78g|pp*M!s1ppvr~DW$3Eu-VR>h*qwc zw0`7quCwC{3B_7*UTkjWHQcsMGI@`L3n0f2E6j)1=k|HoDwh*pdEvpwsTE0|@q z9-hT}FQR@^<1G!sY(PcKb=5}b-$Rz)1Z(U}%6N{Hhs4P7Ll=h&Dev`k7L@Bp>8*2| zr-a+KB~#0MjwAr8pRk|EGTIhH1(ikKXYd~MEMh#sl-nN~ub1g`y&8VWgm6DC1W2}? zx%~*{n{6W07V1>Ge?+7rUZM;C_$_iNZFFKq|Jjj_s!V*hqhN8s+%7cXB1 zwAEdW%BrrGprZZ{Re!n*Dvb#uvokK5e#ktc*_l$~7POi?klKR!%;o2TkxCC$@SrL0 zQh4f0y-9XB6zY?zvmkCWT}74@9quT==ATW~=qa826|G5KVsVzuvIrQs4K998bTGWh zs-Sz|wO6dhJ=(is!lr))t_MtI7h!5tv_fj*6@!F$Yqi_!Gik`#6nU|oGV#`eY?V|J zMv@Tv0Z;~)uH)I3Z7!Yoz_sT#&AK1Ow+f&T*so)eKF~Z<|6(f^aSibm&?}HA^t0Rk z!*x={Y&7N zaQ|fsnalCA9%0Ch+3D2bI)BlCC1SO(^-Q}EJ#C}bs0%b;Gklj8nahiZ+hdV0< z)>~IlZEt2)@5)r9Nh$ZygUjAvz3w_Ly773!bBLiT=xSy-=uuDDydZq^@yzQAqpqA?l3gCEJDq7M2PMr#y2#u?1Y_X$uF8*>m=n6#RpwYW z1qnz;b*?+F7}ZN5z|{$R$9}FG*c6~?3*msa(_voz^KW3DNVz`KYeWnqFP~Yxc;%T! z#eVZBUsR%bUh9^`nlugyY>yIrmj7BYgW9R%qE^FgSFrUsgC!ziUMUjalay+VbeC@1 zW5UT?pUwKRT9u|@cB~z<14%EQrAos~x{5)n$Ah{`|I%`*fj44`nYK*5yD#=499s(l zgQkI`#+($6*(TJF^4(2Occmtrun@uh%%5!yD}Tidn^`5lMe$;QijG%i4U4=ZJ(i5! zOyRC#X>&$V+*MKsJP3pgnYBhtJCsGLrfMjgqtj@Wb-Xd=&4mf)c#1;|4NR%M$UOR6;43{OBxn z3Fca-_GIZ|sK}78blCa%SpfHHQr-PxkwPt!9HkP0E^O$hHy{>_6<0->yk#Km+Fp(! zP?U8eLwy={_*3@4MDA>BeVFTGWNA=p8CefAA2~46%($$pX_}q7Pu;y;f`3p@lKizX z91rDuGl$`x*3WGrC!_UF3I8b6Z2}AVuGpe4bMSGAaoT?KuMzFe<^3A8{oKl4$_CLO)b)D&urbq@y!OO7QvK#wV zs=etL(hXu|YfN2?Y4#Ek+&GRmqfR+enusfX*GErv%{l`vJHzsC05}POxal?6ji?ho z3vz89gWUboT8Iz`Q`l2M_A#DzxFs9^qc>$jQb(2?+|k%Wn=gE*zDHZWGO?d5_gyZ+ zwOwm4=S#7nlRDcfi@*l8qqZpsPMKM}n zrSG3U548DUz1%wQ-TI_G96x;Il#Rzp3<17`BJ+%2<1*e>%Q_J+^GeY8JczuD_#I$i zM^3oeMGfA9<|$njcKTM|__i>p9rzE-B{r5gx7*kNuIpJ=oR57eNd{=2U|EBg*0KKjEt5iq#nT(!Ti2vJF_90?S_3;*_HIA?Qs;Upd#&;iEjpgWArSOfF+X z#hdZHLT=-pdR9~Dsv1BH4BK*k1j?U=I+`M;9mFooS(oaEDA#-#Dt@Pk+uE5}3HZI1 z_S#i=W^#=>EziPC<<3EsN&->SNC1PA0rg9JTiTgrt2B}^Nr_=UD;+xAnP`(rk{KqR zovpr*X#(eUh4LCqTc5M4nq03IG5!E#M&iNxIy14Jjx=_E(p_!?ie6**lFwa-op0zc zs63MO=7v^kes41qX~5-;*%1j?Gg~S)u#pD1i%>s&DHe;V=WuSYT(!-2>=)67B$aZ)3+wIJ(|P-aKH`p(7$E(c zppr!g`pXRANg^)jY`$Mnzt|=61ap6$Oj;L*Z|rq}^WyS~*6vZq17*|oUMI&=>Gy-g zX0-<$ykzeWUrxl8yXISObbJ??nb_TVkWvm#y0Bh;WLIKlRyORX&2V?=pa=oU>MCgh zYO2mvb3_``&vTDLD?;KL`7%{7+faAC>A{scI_1@ytV_4u7|}kz$loO1ewVg9 zcs$Y5%@uvs`D5gPoZ4CHj@d|uk6wP1@V0^ATq#;95fb-;~mwD>4XRC~y?X*2;< zpn{1pTx>_J#Ob{3Nzx0C&TlkyFB>QiZ5RuNiCXnbi$n|bN_m|ik3Yg#z1fL*NW!Ox*j9Bj;uSt`7icq@o_)dK{!g+WNFBlrqLTtLmo?O}$ zQ%ZYqUG3ix2z~`|JW8FL?B3w_rpl|Xrim>&Xv70=b}S%dxtAYl;X6 z8LR{K`8C4`;;BFE-IqRR>;poNUL0wCcfS;YM?cKPF z86RgO33V-Jg_irvR%0;cnTq^g&^zj$`#V^EB1n&A&h~2W(&t^2R=c6(tUFbiR7iiq zq1C$f6*vKMTM@KECCY6o6Q7Cbb>Sa}MgTp+)BL=!N~f(=8iArGEQFE3`*M@GeLuzS z2U0rZqBy8OW08^#1oRw>ko5;KiRXJfG4G?%!j#xfA|i~n0JER!=f#-%9viU@1~V}h z>ajX4bZ#VS(@z)k^-mfc;-hE+gAaQ) zon18_coat1KK_b!qb1-p;Dyae>0LPnxet~tMt`^*0g((9kA)sXZ?t01rX*t}Ork$B z`bCcd373T`g`HI-KRhK?q8_IkwIQ||`vD5@tKPD-a)spgUKHe3WHp?|%A98s_B8k_ z#jz<8uOU{kC#@Zr3JZzs+FH}8wmLl2G>aAc*`u;{S+-iS60{#E{x~U6 zW|*z)(RCJ!$(W9aLj53<*HXNp0#N2vGtKyO-tVAhIs1mkrf(j}?|eoN07%x09>SBm z6}>DUJ5-SOvD|6#{BBVRI+=)b>hO|JLD}LE2~OZdTi2cHbHkMJe5drMb*VmGp4L0Y z0>zhQr%w!@`9@DsPj1khaO{~>y-Vq`*xGXd_cK97`KOwKlG)(E%M5knl4C2Se8LVp zM$@0%1}Gs!lcXO^!6i-KJuO1s{&7cm6sq8HC)f85c3)fDO0Id{5k(S?t@;3DNd*w2!a~KO z3VBP@Nz@&vLL`Id?Znp@`DBII8drRh(MS8iUKZ^?gfyTry1VXTE*KxyIT;XqncB$I-?|a^9kaB~Hl|5V~&=K*G4JOZa2GX8}dRUK0uWZR>;bl&uT?VvEW_ zo9l1fIf&EVwIs_IES?OOh@4I2iWd2J*Id9)b*N&-cqcg~`Xg&F!YqPf+l}jsH{ZRN zc|`-5*wSM1>ST3w%v(QFWVHD_nf}2I5IDsRw>}Kv>nSD|3D%Hma5!b6{fSgCC?yCj zscuQv13a4O#AMX_)qIJxwNE68)4bb&_*Y8`CmLQb%UPP>h?DMzEF*WIud_3tlHf|l zIPSnj|MXuB1ktsGS#o`?-qjsdrR8V?;|}uA^Kw?5z{0|s-L4<60240jSe3RqGTbPsLd)TgF<@}gx3HvO4o0pOrr(i-L;}Pzve?t42scy!~PuRu8#&Ap|lRMG8?KcP}c?M-Doqv1J z9rxe2KMd`K83E$tfBivC26UQq23-)GSW%a|3)zWT+zCt1qaSv%9x z!u%`5;fGZoDQ}glRp0js`W&=9fqNYJHBGOk)jnGNvRVLdkC(Wh29j)p#->^_cY*s9qK%}^BgeDK+s!M0h+SS|Z(rblCLieA`zUTsipp0Mk{wkQ>AE*A-nuU<`K_>nf3zy5UP#wA89Qw z>C(<@y2{tTpcJv7+A^->3@;z4dgpO_12Z>}StlScGK+}59$|-@Q0V05ZEfs*t{A+s z8bnTk9c zxRUqLeF>JH_0Xc8a-&50HT&`Tm8ta!Ek3*GY#S&9_v|1%bes7GaADxGj4Esv8QPD! zf3yN3Sdh+fH6z@_^u_G+B=n?Dw;#xqLOB}(v^9EZyGmIFK{WM5P&>7E4v3d(+H_REuBf($7woMJa)lL7ORaoGCtO$PP%z+5K~ z$;f406)m##e8RE;oVOW;OhRJ?cjC~*#%ZRV*Ig;d5CA`nU z|GGnA>WE_{H744$hK~P9AuyI@I81#wn&}~|`9V9z)tax33ITK-(+Q)L!@q> z0^tR*xIDyeyYHmL58A&T^Gw#u2!~(@PfW!A*X9VK2HC9K#F*T@@>_`&1~^? zk(wOg7Z!es>tO-b#IYd}cI6RfI3$yrcJJ2$g6Fp6L&s967)WD~OuSL_z&vbo2 zx}CSf+UCKOzI}&P5z~;qYv4*o`6lhfS%*SYtL)iR5Qk^=JNJXP5>eDw+wP=F$+EBh zEA?zAKzZ}+BW5g0E@B8zZfh!GC~(4R^k-R{T3Jp0^7`@H<{?WcpFzqMU^cYBHjF^!STaYlZ3<8^%8)pnx)YwU4jYMDG>RuU^mga;=4DDaJW+ z!FNy!sLZA@mMYpu*zF~|o%{i61U6C4BDGqX%?oxt%Rs0U5RfdQ651yzKC`8cyKIdv zPxIlLpy-RW_^r8tfP1;l()=N zj&ae>u!BPjLOxb$Br2D-+N-twS|>5WBN%(s%oJ_^!(~RV)dj=i4NGJqbv?_3KBl9N zSNpg5$IEl)bkU*I0|6EP;E#&l@oGRL8LuRtc)@v(_gCbMrbsIymIM+;#SbWm%uw@0p6to);8lUrlQzy~~Na15XFqN2?%pPXwiHcuGE_5y#-9^_srh z;u^o&eHogsVDr^FQd}$PZ~Q>Ezcm9~0rrgC-LKwUJd%^~;@M%+T@9tb3;+ z@eu>%CL_^vLo-=)5d^nrd4S&*s+N~9?fKL!K~rkkj2#dX$h7@$xsi|6AOtEZ%|@ki zJ|{mLkQ$Oqcf}g1K|9gCPS02S;))3`uci_Vc2_y(or?0jv}6o~9hG_zWALl>7)Ote_oo(2Pzaj#HVHdvXlS>MbW91g|y= z#6zo2Z3^gQYEHq}B!ApzRtSDC<_R;OW{{%r;VUocN6GpA7{p|JbSKl(8*HhjOC#w- z-gRyq5T{!>Ptt8WEf1&`L@##FzNPO4*!Pb2sjM)wqoGBYi&hnpBrrjOB@+xQj%M!> zkn^5-T%%-f_1(iGqfh!wTGiXS#ckwqRYr8txv_;y9Ntux+>UocO{#zxXUo1|Q%&tZ z5*=EKWU8=V`C)?3oJ{vwLHP?O=hkiQ29-dE%~Zxc&jQX7>N?lmw}jUe-gp4w`pIqW zktJFf8j0XX+jy^GHqn_~_{k?5(^kaRQ4O*~?wRYT`VN&-hRrntFJ)Oy)K#q6r$%Qp zYGq_EOZA+)$Yn26;@*x^&GCB&y6PU~gM+NM-<^1tDG2Kx%ha5Jv4Ps}Ez`})B2E=o z8Es7wUY6x8W~Bx!snfQV%YY1Oq)1ZE-K)z=8iA z#cuwLrFp|S(}a1L6Zg5s4(-dShb!!Qp2CI0B8S3;XiVQY8*BY+3Y*8{AGfyAs_tdW z>{YHVICnF6EIBBap^%g>*A`o}w@|e^rfi7O-WkK~B$1~*CY#dHpR3LNbJ~Pah3>iP z!->MlhvVn=4a#b*9?JAb{ss7f?}ysZdR8t>c8=fiR_~;av*GA?J$V1~hh^iAri| z!ahQJDy+;PS)h!j_#p_x2jB87--wyn8!6f7)I0-cDi&}p4VHliGlMi`Pno&P-P9Dd&9;(<>YR;!Rgf0G4>Y`0 zA=ge>%V5}vs~naTWed`&v|ylgYv@RfP&>S*(-FC`RelJRRipu=Hf+p4u!6zd zkht^Rw~BBs{7pHI4Na!MGD|TTR5|&Gmt52h)&tpSuyRoSlsp?Q!|iwU39>QG@?xve z)$jA$S{LLmFWmidZ!uZgY^O(L@zkdCM-_Gr57L~D`YtfHA`Z^AIMS!eV++Le2xI{! zf9`;GjVuG$yL(*6%@vE*c#2E-?kvT}8E;Jq37EeT_l*ful65eOD?GNH52Alu;Ki&r z&vB!gZ?U}%egu@LDj5qF$J*Z2t*(~6-0pkS;X22V-u0qL$YrhW-NC+oUTQ=i%R&^K%ue`P_#sq!DmYZDpQqamWieip*ox3(mkB=)w zkTl6RdiLbhnXoJ^9cg~B_~~e~g7tv5(;=Gt7@jP(9=xpgP+{20Bud0fS|e_COCHUq zmul}BI?lz`s1=hsa+HLC;Wv-HzRVKCWz&`~Wrg=>bi;g>>t6M|?;GN}w~kZ~=j9Ba zn|s>#I=+-nitK&U$nW5$It#P2ZY9$W3hD9b^GseRJ2^a*?$#~0GwrPC2`c)~ZK?W% zKnBQS;DQ@eQ*qE*_cd6=BFuYp^}H3 zL#;Ng0l}eVOdSu73CBK!OQ(5kEMT)-LjvXiHl>WA)ev-QJ#4|@w>Sui6=9y?mawL% z?C5%7yEsKe(5g)Z6|DxUV~2TAF9r>|kLMjlC*g#kLM+y$Ds9iL91oRLUpGlXaJV}B zI!4nPyo+h;8K&*$eBq3=a^GnqMuOg(ND>x3acsm*3=V@Z90H>KicsI{?pgx|Yu ztUf_+Os*pLW$Ey`rbEJLyfUGO$XI=u^d~mNF`)oLU>1|+sZh-bXF+}qu}w1@5VC>u ziu#Tg6$-v^7Y~>1mNvq*S~1XbdTr#^CWDr(21_RU-mxIeikMu00;xZy05pek5gfV@l(sP9%r>IkLE~$)~Q0(5gAXv7p|Cv zzjead5Et-88=Rat6X@v2H0PH;DLppVw{o$}Ts9N_<3k8=LsSwT_WsO?V(YMs{M?a8 z^>*bW_;(EmetjfG4UQe^6$wKN^sY<7+_}}5vl@sVH2b3?WGC&oU0n{p8oLeJm5sEX zre3}<(Q}qgB?IlYV}pTgRNL?>e^XD4zD9S`aeqlez1b$L{lm+#q_Qaz%9+U#>J~_6Ps?&LjLV3voic*Uf&6KfY;*`syWNdf%OJ z^4vGY;l92N`suo!8maH=e)=kg>SB&Au?PK)SkI4xn*5j`aRYD@7I4o1FsnS_x}H2` zAvPMfY(`9CKWd!Y`aLW4YR1`Bb)cjW) z<0S-b7|%yKL?|;@r`8PF#t-PQAis@CLIXkiHIM0;r!|vQZaq=7Fh12}{vs0>&{Llv zU1Uh$2rT#2==T!~V`)DkSHx7nASMWzs(mNJ)V|awY?*pl_~Ae*aZumPvyQgS&0oIl za~Kswav~fYw{q`V%eg}hw`cQ8-naC85t9Ekw99wmROQ%ZVTSpU=e9Bcg^0p&acxIT zOY67}O{<1$>f8M}p|g(xfgB2Ioa|?mnFq z@bYVX2HurtNOB_K*n1qHa$fN>oSKfnjQ1~^f!F8+ec|orTK=Zb(iYinpN6$jw2Ahl|{Nn6pCh<}z(W@uj^YbdD6+8cb{XdqyDNMwlZ_k*? zZ*rVR5mx>Fu+bO1;9q*45}RFr<&kA(kf>6>ao=p8l!^Gwv?##hq=Otv(@Z#R$=W+* zc$1sfeGnI^##T@Zug31AC0X(;X9mH$$64GJZncx!k<%N#W#(^OK6H~e|Hm_53=CzS zr+f0+>PG|)($zpWF7w|3OP8+GB}3HL;y;aYI?wBN?aX#H2i%nTXiSjA0X}B!=FrL% zH3S%gY4`KMNIxs5IK`|L;t6!u@p7=ERVWeswekZrz{>ORTTr#kgK`mXQPU-@p&tjj>i?;q8eVG)2FPlRWTYSy} z6nC$drwP7a+8;;8c{~oZkB_D%s-KtxTllm zJ{+9a&HME~gPY1hvg|CAYzKsRRrc8aXvDHYSVos`2LCIi%1w21#p^1AFF=}yM<>)Z zoM;P*Q#f29RTNzVK!Gv|n^k*8RkPYIzyd_`bOd$5K;uMX?9E(E88}V>3`S) z>oPv&^l5R+AQJleo&0ur008=Q%|;?2!&0me z%Q2nok3T=R*r%ausf+$f7mtb&(uZBJF#M^0CqO-t;{TX@&Ql3_1#lAYfP zR}E>^ymgct`+m`b2nYxo7&E$fe*AVlQ+@qYE3DqrkDNidQZWvmQ0BW0@gcL@(&&CIz0?DiQ6FrKIFWv>LLMjxqci}Sxx(!z4#31s!z9?R&d*vOvj9PUGxt$As zyM?O3-+BM%k%psYmA>-o(!oyuJoFcKnAq&feo(&Yi2d0qXK>eNVW9N5QHm?aUqIXI zqwV6?*R56nyitO(R}SPvDV1NbIjsI6(drJQ_i|~)UQI(p$~AQ~;=PMmR%)mU8-~e$ z_<_v2!msCIUW*M+*@s3R|4xD+!60pKD@|Fg2A57p^^=grlA52%*AscC@~~HB4c)Y3 zWhKz*s1A`1daIFXFAfHXWRn1@!=xgdrF0#hz;vA$R+vb&-8I9jzTMD=R1f8BejmOM0w$&y?d+uK2WlcPw$jz&qi8 zpDAnTxDz_wu0B=iPG@d>Glc=r!#*;RU9dt=n_QyKW&2sjvj+K* + + + + 4.0.0 + + + org.apache.activemq.examples.federation + broker-federation + 2.11.0-SNAPSHOT + + + federated-address-downstream + jar + ActiveMQ Artemis Downstream Federated Address Example + + + ${project.basedir}/../../../.. + + + + + org.apache.activemq.examples.federation + federated-address + ${project.version} + + + + + + + org.apache.activemq + artemis-maven-plugin + + + create0 + + create + + + ${noServer} + ${basedir}/target/server0 + ${basedir}/target/classes/activemq/server0 + + -Djava.net.preferIPv4Stack=true + + + + create1 + + create + + + ${noServer} + ${basedir}/target/server1 + ${basedir}/target/classes/activemq/server1 + + -Djava.net.preferIPv4Stack=true + + + + create2 + + create + + + ${noServer} + ${basedir}/target/server2 + ${basedir}/target/classes/activemq/server2 + + -Djava.net.preferIPv4Stack=true + + + + start0 + + cli + + + ${noServer} + true + ${basedir}/target/server0 + tcp://localhost:61616 + + run + + eu-west-1 + + + + start1 + + cli + + + ${noServer} + true + ${basedir}/target/server1 + tcp://localhost:61617 + + run + + eu-east-1 + + + + start2 + + cli + + + ${noServer} + true + ${basedir}/target/server2 + tcp://localhost:61618 + + run + + us-central-1 + + + + runClient + + runClient + + + org.apache.activemq.artemis.jms.example.FederatedAddressDownstreamExample + + + + stop0 + + cli + + + ${noServer} + ${basedir}/target/server0 + + stop + + + + + stop1 + + cli + + + ${noServer} + ${basedir}/target/server1 + + stop + + + + + stop2 + + cli + + + ${noServer} + ${basedir}/target/server2 + + stop + + + + + + + org.apache.activemq.examples.federation + federated-address-downstream + ${project.version} + + + + + org.apache.maven.plugins + maven-clean-plugin + + + + + + release + + + + com.vladsch.flexmark + markdown-page-generator-plugin + + + + + + diff --git a/examples/features/federation/federated-address-downstream/readme.md b/examples/features/federation/federated-address-downstream/readme.md new file mode 100644 index 0000000000..d89db44af8 --- /dev/null +++ b/examples/features/federation/federated-address-downstream/readme.md @@ -0,0 +1,34 @@ +# Federated Address Example + +To run the example, simply type **mvn verify** from this directory, or **mvn -PnoServer verify** if you want to start and create the broker manually. + +This example demonstrates a core multicast address deployed on three different brokers. The three brokers are configured to form a federated address mesh. + +In the example we name the brokers, eu-west, eu-east and us-central to give an idea of the use case. + +![EU West, EU East and US Central Diagram](eu-west-east-us-central.png) + +The following is then carried out: + +1. create a consumer on the queue on each node, and we create a producer on only one of the nodes. + +2. send some messages via the producer on EU West, and we verify that **all** the consumers receive the sent messages, in essence multicasting the messages within and accross brokers. + +3. Next then verify the same on US Central. + +4. Next then verify the same on EU East. + + + +In other words, we are showing how with Federated Address, ActiveMQ Artemis **replicates** sent messages to all addresses and subsequently delivered to all all consumers, regardless if the consumer is local or is on a distant broker. Decoupling the location where producers and consumers need to be. + +The config that defines the federation you can see in the broker.xml for each broker is within the following tags. You will note upstreams are different in each as well as the federation name, which has to be globally unique. + +``` + + ... + +``` + + +For more information on ActiveMQ Artemis Federation please see the federation section of the user manual. \ No newline at end of file diff --git a/examples/features/federation/federated-address-downstream/src/main/java/org/apache/activemq/artemis/jms/example/FederatedAddressDownstreamExample.java b/examples/features/federation/federated-address-downstream/src/main/java/org/apache/activemq/artemis/jms/example/FederatedAddressDownstreamExample.java new file mode 100644 index 0000000000..505b862398 --- /dev/null +++ b/examples/features/federation/federated-address-downstream/src/main/java/org/apache/activemq/artemis/jms/example/FederatedAddressDownstreamExample.java @@ -0,0 +1,29 @@ +/* + * 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.jms.example; + +/** + * A simple example that demonstrates multicast address replication between remote servers, + * using Address Federation downstream feature. + */ +public class FederatedAddressDownstreamExample { + + public static void main(final String[] args) throws Exception { + //Re-use the same Federated address test for upstream + FederatedAddressExample.main(args); + } +} diff --git a/examples/features/federation/federated-address-downstream/src/main/resources/activemq/server0/broker.xml b/examples/features/federation/federated-address-downstream/src/main/resources/activemq/server0/broker.xml new file mode 100644 index 0000000000..73c774c398 --- /dev/null +++ b/examples/features/federation/federated-address-downstream/src/main/resources/activemq/server0/broker.xml @@ -0,0 +1,100 @@ + + + + + + eu-west-1-master + + ./data/bindings + + ./data/journal + + ./data/largemessages + + ./data/paging + + + + tcp://localhost:61616 + tcp://localhost:61616 + tcp://localhost:61617 + tcp://localhost:61618 + + + + + tcp://localhost:61616 + + + + + + + + 1000 + + eu-east-1-connector + + + netty-connector + + + 1000 + + us-central-1-connector + + + netty-connector + + + + + + + + + + + + + + + + + + + + + + + + + + + + +