registeredIds = new HashSet<>();
13 | private final Object lock = new Object();
14 |
15 | private static final Logger LOGGER = LoggerFactory.getLogger(SharedResourceManager.class);
16 |
17 | SharedResourceManager(String type) {
18 | this.type = type;
19 | }
20 |
21 | abstract T create() throws Exception;
22 | abstract void close();
23 |
24 | /**
25 | * Register {@code key} to the shared resource.
26 | * If this is the first key to claim this shared resource, {@link #create()} the resource.
27 | * @param key the registration key of the caller that wants to use this resource
28 | * @return the shared resource
29 | * @throws Exception whatever exception that may be thrown by {@link #create()}
30 | */
31 | public T get(String key) throws Exception {
32 | synchronized (lock) {
33 | if (registeredIds.isEmpty()) {
34 | LOGGER.info("No {} exists, a new one will be created", type);
35 | sharedResource = create();
36 | } else {
37 | LOGGER.trace("A message {} already exists, reusing it", type);
38 | }
39 |
40 | registeredIds.add(key);
41 | }
42 |
43 | return sharedResource;
44 | }
45 |
46 | /**
47 | * De-register {@code key} from the shared resource.
48 | *
If this is the last {@code key} associated to the shared resource, {@link #close()} the resource.
49 | * @param key the registration key of the caller that is using the resource
50 | */
51 | public void release(String key) {
52 | synchronized (lock) {
53 | if (!registeredIds.contains(key)) return;
54 |
55 | if (registeredIds.size() <= 1) {
56 | LOGGER.info("{} is the last user, closing {}...", key, type);
57 | close();
58 | sharedResource = null;
59 | } else {
60 | LOGGER.info("{} is not the last user, persisting {}...", key, type);
61 | }
62 | registeredIds.remove(key);
63 | }
64 | }
65 | }
66 |
--------------------------------------------------------------------------------
/solace-spring-cloud-stream-binder-opentelemetry/solace-spring-cloud-stream-binder-instrumentation/src/main/java/com/solace/spring/cloud/stream/binder/instrumentation/SolaceBinderInstrumentationModule.java:
--------------------------------------------------------------------------------
1 | package com.solace.spring.cloud.stream.binder.instrumentation;
2 |
3 | import com.google.auto.service.AutoService;
4 | import io.opentelemetry.javaagent.extension.instrumentation.InstrumentationModule;
5 | import io.opentelemetry.javaagent.extension.instrumentation.TypeInstrumentation;
6 | import java.util.Arrays;
7 | import java.util.List;
8 |
9 | @AutoService(InstrumentationModule.class)
10 | public final class SolaceBinderInstrumentationModule extends InstrumentationModule {
11 |
12 | public SolaceBinderInstrumentationModule() {
13 | super("spring-cloud-stream-binder-solace-instrumentation");
14 | }
15 |
16 | @Override
17 | public int order() {
18 | return 1;
19 | }
20 |
21 | @Override
22 | public List typeInstrumentations() {
23 | return Arrays.asList(new SolaceBinderConsumerInstrumentation());
24 | }
25 |
26 | @Override
27 | public List getAdditionalHelperClassNames() {
28 | return Arrays.asList(
29 | //Solace Binder Consumer Instrumentation Classes
30 | SolaceBinderConsumerInstrumentation.class.getName(),
31 | SolaceBinderConsumerInstrumentation.InboundXMLMessageListenerProcessMessageMethodAdvice.class.getName(),
32 | SolaceBinderConsumerInstrumentation.MessageProducerSupportSendMessageMethodAdvice.class.getName(),
33 |
34 | //Other required classes from JCSMP Instrumentation
35 | "com.solace.messaging.trace.propagation.SolaceJCSMPTextMapGetter",
36 | "com.solace.messaging.trace.propagation.SolaceJCSMPTextMapSetter",
37 | "com.solace.messaging.trace.propagation.VersionInfo",
38 | "com.solace.messaging.trace.propagation.internal.SpanAttributes",
39 | "com.solace.messaging.trace.propagation.internal.MessagingOperation",
40 | "com.solace.messaging.trace.propagation.internal.MessagingAttribute",
41 | "com.solace.messaging.trace.propagation.internal.SpanContextUtil",
42 | "com.solace.messaging.trace.propagation.internal.TraceStateUtil",
43 | "com.solace.messaging.trace.propagation.internal.VersionInfoImpl",
44 | "com.solace.messaging.trace.propagation.internal.ClassLoaderReflectionUtil"
45 | );
46 | }
47 | }
--------------------------------------------------------------------------------
/solace-spring-cloud-stream-binder/solace-spring-cloud-stream-binder-core/src/test/java/com/solace/spring/cloud/stream/binder/health/base/SolaceHealthIndicatorTest.java:
--------------------------------------------------------------------------------
1 | package com.solace.spring.cloud.stream.binder.health.base;
2 |
3 | import com.solacesystems.jcsmp.FlowEvent;
4 | import com.solacesystems.jcsmp.FlowEventArgs;
5 | import org.junit.jupiter.api.BeforeEach;
6 | import org.junit.jupiter.api.Test;
7 | import org.springframework.boot.actuate.health.Health;
8 | import org.springframework.boot.actuate.health.Status;
9 |
10 | import static org.junit.jupiter.api.Assertions.assertEquals;
11 |
12 | class SolaceHealthIndicatorTest {
13 |
14 | private SolaceHealthIndicator solaceHealthIndicator;
15 |
16 | @BeforeEach
17 | void setUp() {
18 | this.solaceHealthIndicator = new SolaceHealthIndicator();
19 | }
20 |
21 | @Test
22 | void healthUp() {
23 | this.solaceHealthIndicator.healthUp();
24 | assertEquals(this.solaceHealthIndicator.health(), Health.up().build());
25 | }
26 |
27 | @Test
28 | void healthReconnecting() {
29 | this.solaceHealthIndicator.healthReconnecting(null);
30 | assertEquals(this.solaceHealthIndicator.health(), Health.status("RECONNECTING").build());
31 | }
32 |
33 | @Test
34 | void healthDown() {
35 | this.solaceHealthIndicator.healthDown(null);
36 | assertEquals(this.solaceHealthIndicator.health(), Health.down().build());
37 | }
38 |
39 | @Test
40 | void addFlowEventDetails() {
41 | // as SessionEventArgs constructor has package level access modifier, we have to test with FlowEventArgs only
42 | FlowEventArgs flowEventArgs = new FlowEventArgs(FlowEvent.FLOW_DOWN, "String_infoStr",
43 | new Exception("Test Exception"), 500);
44 | Health health = this.solaceHealthIndicator.addEventDetails(Health.down(),flowEventArgs).build();
45 |
46 | assertEquals(health.getStatus(), Status.DOWN);
47 | assertEquals(health.getDetails().get("error"), "java.lang.Exception: Test Exception");
48 | assertEquals(health.getDetails().get("responseCode"), 500);
49 | }
50 |
51 | @Test
52 | void getHealth() {
53 | this.solaceHealthIndicator.setHealth(Health.up().build());
54 | assertEquals(this.solaceHealthIndicator.health(), Health.up().build());
55 | }
56 |
57 | @Test
58 | void setHealth() {
59 | this.solaceHealthIndicator.setHealth(Health.down().build());
60 | assertEquals(this.solaceHealthIndicator.health(), Health.down().build());
61 | }
62 | }
--------------------------------------------------------------------------------
/.github/workflows/release.yml:
--------------------------------------------------------------------------------
1 | name: Release to Maven Central
2 |
3 | on:
4 | workflow_dispatch:
5 |
6 | jobs:
7 | release:
8 | runs-on: ubuntu-latest
9 | permissions:
10 | contents: write
11 | packages: write
12 | id-token: write
13 |
14 | steps:
15 | - name: Checkout repository
16 | uses: actions/checkout@v4
17 |
18 | - name: Set up JDK 17
19 | uses: actions/setup-java@v4
20 | with:
21 | java-version: "17"
22 | distribution: "zulu"
23 |
24 | - name: Retrieve secrets from Vault
25 | id: secrets
26 | uses: hashicorp/vault-action@v3
27 | continue-on-error: true
28 | with:
29 | url: "${{ secrets.VAULT_ADDR }}"
30 | role: "cicd-workflows-secret-read-role"
31 | method: jwt
32 | path: jwt-github
33 | jwtGithubAudience: https://github.com/${{ github.repository_owner }}
34 | exportToken: true
35 | secrets:
36 | secret/data/tools/githubactions PACKAGES_ADMIN_USER | PACKAGES_ADMIN_USER ;
37 | secret/data/tools/githubactions PACKAGES_ADMIN_TOKEN | PACKAGES_ADMIN_TOKEN ;
38 | secret/data/tools/githubactions MAVEN_GPG_KEY_PASSPHRASE | MAVEN_GPG_KEY_PASSPHRASE ;
39 | secret/data/tools/githubactions MAVEN_GPG_KEY | MAVEN_GPG_KEY ;
40 | secret/data/tools/githubactions MAVEN_USERNAME | MAVEN_USERNAME ;
41 | secret/data/tools/githubactions MAVEN_PASSWORD | MAVEN_PASSWORD ;
42 |
43 | - name: Import GPG key
44 | uses: crazy-max/ghaction-import-gpg@cb9bde2e2525e640591a934b1fd28eef1dcaf5e5 #v6.2.0
45 | with:
46 | gpg_private_key: ${{ steps.secrets.outputs.MAVEN_GPG_KEY }}
47 | passphrase: ${{ steps.secrets.outputs.MAVEN_GPG_KEY_PASSPHRASE }}
48 |
49 | - name: Add SSH Key for write access for commits
50 | uses: kielabokkie/ssh-key-and-known-hosts-action@v1
51 | with:
52 | ssh-private-key: ${{ secrets.COMMIT_KEY }}
53 | ssh-host: github.com
54 |
55 | - name: Configure Git author
56 | run: |
57 | git config --local user.email "action@github.com"
58 | git config --local user.name "GitHub Action"
59 |
60 | - name: Deploy to Maven Central
61 | run: |
62 | mvn -DreleaseTarget=central \
63 | -P releaseCentral \
64 | -s maven/settings.xml \
65 | release:prepare release:perform
66 |
--------------------------------------------------------------------------------
/solace-spring-cloud-stream-binder-opentelemetry/solace-spring-cloud-stream-binder-instrumentation-tests/src/test/java/com/solace/spring/cloud/stream/binder/instrumentation/springBootTests/app/ManualAckConfig.java:
--------------------------------------------------------------------------------
1 | package com.solace.spring.cloud.stream.binder.instrumentation.springBootTests.app;
2 |
3 | import java.util.function.Consumer;
4 | import java.util.function.Supplier;
5 | import org.slf4j.Logger;
6 | import org.slf4j.LoggerFactory;
7 | import org.springframework.context.annotation.Bean;
8 | import org.springframework.context.annotation.Profile;
9 | import org.springframework.integration.StaticMessageHeaderAccessor;
10 | import org.springframework.integration.acks.AckUtils;
11 | import org.springframework.integration.acks.AcknowledgmentCallback;
12 | import org.springframework.messaging.Message;
13 | import org.springframework.stereotype.Component;
14 |
15 | @Component
16 | @Profile("manualAck")
17 | public class ManualAckConfig {
18 |
19 | private static final Logger log = LoggerFactory.getLogger(ManualAckConfig.class);
20 |
21 | @Bean("manualAckFunction")
22 | @Profile("requeue")
23 | public Consumer> manualAckFunction1() {
24 | return message -> {
25 | log.info("Received: {}", message);
26 |
27 | // Disable Auto-Acknowledgement
28 | AcknowledgmentCallback ackCallback = StaticMessageHeaderAccessor.getAcknowledgmentCallback(
29 | message);
30 | ackCallback.noAutoAck();
31 |
32 | log.info("Requeue: {}", message);
33 |
34 | //Message will be redelivered max 2 times as consumer has configured queueMaxMsgRedelivery: 2
35 | AckUtils.requeue(ackCallback);
36 | };
37 | }
38 |
39 | @Bean("manualAckFunction")
40 | @Profile({"reject"})
41 | public Consumer> manualAckFunction2() {
42 | return message -> {
43 | log.info("Received: {}", message);
44 |
45 | // Disable Auto-Acknowledgement
46 | AcknowledgmentCallback ackCallback = StaticMessageHeaderAccessor.getAcknowledgmentCallback(
47 | message);
48 | ackCallback.noAutoAck();
49 |
50 | log.info("Reject: {}", message);
51 |
52 | //Message will not be redelivered. It will be moved to DMQ if one is configured.
53 | AckUtils.reject(ackCallback);
54 | };
55 | }
56 |
57 | @Bean
58 | public Supplier source1() {
59 | return () -> {
60 | String message = "Hello World!";
61 | log.info("Emitting: {}", message);
62 | return message;
63 | };
64 | }
65 | }
--------------------------------------------------------------------------------
/solace-spring-cloud-stream-binder/solace-spring-cloud-stream-binder-core/src/test/java/com/solace/spring/cloud/stream/binder/inbound/InboundXMLMessageListenerTest.java:
--------------------------------------------------------------------------------
1 | package com.solace.spring.cloud.stream.binder.inbound;
2 |
3 | import com.solace.spring.cloud.stream.binder.properties.SolaceConsumerProperties;
4 | import com.solace.spring.cloud.stream.binder.util.FlowReceiverContainer;
5 | import com.solace.spring.cloud.stream.binder.util.UnboundFlowReceiverContainerException;
6 | import com.solacesystems.jcsmp.JCSMPException;
7 | import com.solacesystems.jcsmp.StaleSessionException;
8 | import org.junit.jupiter.api.Test;
9 | import org.junit.jupiter.api.extension.ExtendWith;
10 | import org.mockito.Mock;
11 | import org.mockito.Mockito;
12 | import org.mockito.junit.jupiter.MockitoExtension;
13 | import org.springframework.boot.test.system.CapturedOutput;
14 | import org.springframework.boot.test.system.OutputCaptureExtension;
15 | import org.springframework.cloud.stream.binder.ExtendedConsumerProperties;
16 | import org.springframework.cloud.stream.provisioning.ConsumerDestination;
17 |
18 | import static org.assertj.core.api.Assertions.assertThat;
19 | import static org.mockito.Mockito.verify;
20 | import static org.mockito.Mockito.when;
21 |
22 | @ExtendWith(MockitoExtension.class)
23 | @ExtendWith(OutputCaptureExtension.class)
24 | public class InboundXMLMessageListenerTest {
25 |
26 | @Mock
27 | private ConsumerDestination consumerDestination;
28 |
29 | @Test
30 | public void testListenerIsStoppedOnStaleSessionException(@Mock FlowReceiverContainer flowReceiverContainer, CapturedOutput output)
31 | throws UnboundFlowReceiverContainerException, JCSMPException {
32 |
33 | when(flowReceiverContainer.receive(Mockito.anyInt()))
34 | .thenThrow(new StaleSessionException("Session has become stale", new JCSMPException("Specific JCSMP exception")));
35 |
36 | BasicInboundXMLMessageListener inboundXMLMessageListener = new BasicInboundXMLMessageListener(
37 | flowReceiverContainer, consumerDestination, new ExtendedConsumerProperties<>(new SolaceConsumerProperties()), null, null, null, null, null,
38 | null, null, false);
39 |
40 | inboundXMLMessageListener.run();
41 |
42 | assertThat(output)
43 | .contains("Session has lost connection")
44 | .contains("Closing flow receiver to destination");
45 |
46 | verify(flowReceiverContainer).unbind();
47 | }
48 | }
49 |
--------------------------------------------------------------------------------
/solace-spring-cloud-stream-binder/solace-spring-cloud-stream-binder-core/src/main/java/com/solace/spring/cloud/stream/binder/inbound/acknowledge/SolaceAckUtil.java:
--------------------------------------------------------------------------------
1 | package com.solace.spring.cloud.stream.binder.inbound.acknowledge;
2 |
3 | import com.solace.spring.cloud.stream.binder.util.SolaceAcknowledgmentException;
4 | import org.springframework.integration.acks.AcknowledgmentCallback;
5 |
6 | /**
7 | * Utility methods for acting on Solace implementation of {@link AcknowledgmentCallback}.
8 | */
9 | public class SolaceAckUtil {
10 |
11 | /**
12 | * Verify if the error queue is enabled for the related message consumer. Beneficial to a consumer
13 | * in client-ack mode. The application may simply want to verify if error queue is enabled without
14 | * actually moving the message to error queue.
15 | *
16 | * @param acknowledgmentCallback the AcknowledgmentCallback.
17 | * @return true if the error queue is enabled for the associated message consumer.
18 | */
19 | public static boolean isErrorQueueEnabled(AcknowledgmentCallback acknowledgmentCallback) {
20 | if (acknowledgmentCallback instanceof JCSMPAcknowledgementCallback jcsmpAcknowledgementCallback) {
21 | return jcsmpAcknowledgementCallback.isErrorQueueEnabled();
22 | } else if (acknowledgmentCallback instanceof JCSMPBatchAcknowledgementCallback batchAcknowledgementCallback) {
23 | return batchAcknowledgementCallback.isErrorQueueEnabled();
24 | }
25 |
26 | return false;
27 | }
28 |
29 | /**
30 | * Send the related message to the error queue if enabled for associated message consumer. This
31 | * could be specially useful for a consumer in client-ack mode
32 | *
33 | * @param ackCallback the AcknowledgmentCallback.
34 | * @return return true if error queue is enabled for the associated message consumer and the
35 | * message is successfully published to the error queue.
36 | * @throws SolaceAcknowledgmentException failed to send message to error queue.
37 | */
38 | public static boolean republishToErrorQueue(AcknowledgmentCallback ackCallback) {
39 | if (ackCallback.isAcknowledged()) {
40 | return false;
41 | }
42 |
43 | if (ackCallback instanceof JCSMPAcknowledgementCallback jcsmpAckCallback) {
44 | return jcsmpAckCallback.republishToErrorQueue();
45 | } else if (ackCallback instanceof JCSMPBatchAcknowledgementCallback jcsmpBatchAckCallback) {
46 | return jcsmpBatchAckCallback.republishToErrorQueue();
47 | }
48 |
49 | return false;
50 | }
51 | }
--------------------------------------------------------------------------------
/solace-spring-cloud-stream-binder/solace-spring-cloud-stream-binder-core/src/test/java/com/solace/spring/cloud/stream/binder/inbound/JCSMPMessageSourceTest.java:
--------------------------------------------------------------------------------
1 | package com.solace.spring.cloud.stream.binder.inbound;
2 |
3 | import static org.assertj.core.api.Assertions.assertThatThrownBy;
4 |
5 | import com.solace.spring.cloud.stream.binder.meter.SolaceMeterAccessor;
6 | import com.solace.spring.cloud.stream.binder.properties.SolaceConsumerProperties;
7 | import com.solace.spring.cloud.stream.binder.provisioning.SolaceConsumerDestination;
8 | import com.solacesystems.jcsmp.EndpointProperties;
9 | import com.solacesystems.jcsmp.JCSMPSession;
10 | import java.util.Map;
11 | import org.apache.commons.lang3.RandomStringUtils;
12 | import org.junit.jupiter.api.BeforeEach;
13 | import org.junit.jupiter.api.Test;
14 | import org.junit.jupiter.api.Timeout;
15 | import org.junit.jupiter.api.extension.ExtendWith;
16 | import org.mockito.Mock;
17 | import org.mockito.Mockito;
18 | import org.mockito.junit.jupiter.MockitoExtension;
19 | import org.springframework.cloud.stream.binder.ExtendedConsumerProperties;
20 |
21 | @Timeout(value = 10)
22 | @ExtendWith(MockitoExtension.class)
23 | class JCSMPMessageSourceTest {
24 |
25 | private JCSMPMessageSource messageSource;
26 | private ExtendedConsumerProperties consumerProperties;
27 | @Mock private JCSMPSession session;
28 | @Mock private BatchCollector batchCollector;
29 | @Mock private EndpointProperties endpointProperties;
30 | @Mock private SolaceMeterAccessor solaceMeterAccessor;
31 |
32 | @BeforeEach
33 | void init() {
34 | SolaceConsumerDestination dest = Mockito.mock(SolaceConsumerDestination.class);
35 | Mockito.when(dest.getName()).thenReturn("fake/topic");
36 |
37 | consumerProperties = new ExtendedConsumerProperties<>(new SolaceConsumerProperties());
38 | consumerProperties.populateBindingName(RandomStringUtils.randomAlphanumeric(100));
39 |
40 | messageSource = new JCSMPMessageSource(
41 | dest,
42 | session,
43 | batchCollector,
44 | consumerProperties,
45 | endpointProperties,
46 | solaceMeterAccessor
47 | );
48 | }
49 |
50 | @Test
51 | void test_startFailedForBadHeaderNameMapping() {
52 | consumerProperties.getExtension().setHeaderNameMapping(Map.of("k1", "v1", "k2", "v1"));
53 | assertThatThrownBy(() -> messageSource.start())
54 | .isInstanceOf(IllegalArgumentException.class)
55 | .hasMessageStartingWith(
56 | "Two or more keys map to the same header name in headerNameMapping");
57 | }
58 | }
--------------------------------------------------------------------------------
/solace-spring-cloud-stream-binder/solace-spring-cloud-stream-binder-core/src/test/java/com/solace/spring/cloud/stream/binder/inbound/JCSMPInboundChannelAdapterTest.java:
--------------------------------------------------------------------------------
1 | package com.solace.spring.cloud.stream.binder.inbound;
2 |
3 | import static org.assertj.core.api.Assertions.assertThatThrownBy;
4 |
5 | import com.solace.spring.cloud.stream.binder.meter.SolaceMeterAccessor;
6 | import com.solace.spring.cloud.stream.binder.properties.SolaceConsumerProperties;
7 | import com.solace.spring.cloud.stream.binder.provisioning.SolaceConsumerDestination;
8 | import com.solacesystems.jcsmp.EndpointProperties;
9 | import com.solacesystems.jcsmp.JCSMPSession;
10 | import java.util.Map;
11 | import org.apache.commons.lang3.RandomStringUtils;
12 | import org.junit.jupiter.api.BeforeEach;
13 | import org.junit.jupiter.api.Test;
14 | import org.junit.jupiter.api.Timeout;
15 | import org.junit.jupiter.api.extension.ExtendWith;
16 | import org.mockito.Mock;
17 | import org.mockito.Mockito;
18 | import org.mockito.junit.jupiter.MockitoExtension;
19 | import org.springframework.cloud.stream.binder.ExtendedConsumerProperties;
20 | import org.springframework.messaging.MessagingException;
21 |
22 | @Timeout(value = 10)
23 | @ExtendWith(MockitoExtension.class)
24 | class JCSMPInboundChannelAdapterTest {
25 |
26 | private JCSMPInboundChannelAdapter inboundChannelAdapter;
27 | private ExtendedConsumerProperties consumerProperties;
28 | @Mock private JCSMPSession session;
29 | @Mock private EndpointProperties endpointProperties;
30 | @Mock private SolaceMeterAccessor solaceMeterAccessor;
31 |
32 | @BeforeEach
33 | void init() {
34 | SolaceConsumerDestination dest = Mockito.mock(SolaceConsumerDestination.class);
35 | Mockito.when(dest.getName()).thenReturn("fake/topic");
36 |
37 | consumerProperties = new ExtendedConsumerProperties<>(new SolaceConsumerProperties());
38 | consumerProperties.populateBindingName(RandomStringUtils.randomAlphanumeric(100));
39 |
40 | inboundChannelAdapter = new JCSMPInboundChannelAdapter(
41 | dest,
42 | session,
43 | consumerProperties,
44 | endpointProperties,
45 | solaceMeterAccessor
46 | );
47 | }
48 |
49 | @Test
50 | void test_startFailedForBadHeaderNameMapping() {
51 | consumerProperties.getExtension().setHeaderNameMapping(Map.of("k1", "v1", "k2", "v1"));
52 | assertThatThrownBy(() -> inboundChannelAdapter.start())
53 | .isInstanceOf(IllegalArgumentException.class)
54 | .hasMessageStartingWith(
55 | "Two or more keys map to the same header name in headerNameMapping");
56 | }
57 | }
--------------------------------------------------------------------------------
/solace-spring-cloud-stream-binder/solace-spring-cloud-stream-binder/src/test/java/com/solace/spring/cloud/stream/binder/test/spring/BatchedMessageCollector.java:
--------------------------------------------------------------------------------
1 | package com.solace.spring.cloud.stream.binder.test.spring;
2 |
3 | import com.solace.spring.cloud.stream.binder.messaging.SolaceBinderHeaders;
4 | import org.springframework.integration.support.MessageBuilder;
5 |
6 | import java.util.ArrayList;
7 | import java.util.List;
8 | import java.util.Map;
9 | import java.util.Set;
10 | import java.util.function.BiConsumer;
11 | import java.util.function.BinaryOperator;
12 | import java.util.function.Function;
13 | import java.util.function.Supplier;
14 | import java.util.stream.Collector;
15 |
16 | public class BatchedMessageCollector implements Collector>, MessageBuilder>> {
17 | private final Function getPayload;
18 | private final Function> getHeaders;
19 |
20 | public BatchedMessageCollector(Function getPayload, Function> getHeaders) {
21 | this.getPayload = getPayload;
22 | this.getHeaders = getHeaders;
23 | }
24 |
25 |
26 | @Override
27 | public Supplier>> supplier() {
28 | return () -> MessageBuilder.>withPayload(new ArrayList<>())
29 | .setHeader(SolaceBinderHeaders.BATCHED_HEADERS, new ArrayList>());
30 | }
31 |
32 | @Override
33 | public BiConsumer>, T> accumulator() {
34 | return (builder, elem) -> {
35 | builder.getPayload().add(getPayload.apply(elem));
36 | @SuppressWarnings("unchecked")
37 | List> batchedHeaders = (List>) builder.getHeaders()
38 | .get(SolaceBinderHeaders.BATCHED_HEADERS);
39 | batchedHeaders.add(getHeaders.apply(elem));
40 | };
41 | }
42 |
43 | @Override
44 | public BinaryOperator>> combiner() {
45 | return (left, right) -> {
46 | @SuppressWarnings("unchecked")
47 | List> leftBatchedHeaders = (List>) left.getHeaders()
48 | .get(SolaceBinderHeaders.BATCHED_HEADERS);
49 | @SuppressWarnings("unchecked")
50 | List> rightBatchedHeaders = (List>) right.getHeaders()
51 | .get(SolaceBinderHeaders.BATCHED_HEADERS);
52 | leftBatchedHeaders.addAll(rightBatchedHeaders);
53 | left.getPayload().addAll(right.getPayload());
54 | return left;
55 | };
56 | }
57 |
58 | @Override
59 | public Function>, MessageBuilder>> finisher() {
60 | return b -> b;
61 | }
62 |
63 | @Override
64 | public Set characteristics() {
65 | return Set.of();
66 | }
67 | }
68 |
--------------------------------------------------------------------------------
/solace-spring-cloud-stream-binder/solace-spring-cloud-stream-binder-core/src/test/java/com/solace/spring/cloud/stream/binder/test/spring/BatchedMessageCollector.java:
--------------------------------------------------------------------------------
1 | package com.solace.spring.cloud.stream.binder.test.spring;
2 |
3 | import com.solace.spring.cloud.stream.binder.messaging.SolaceBinderHeaders;
4 | import org.springframework.integration.support.MessageBuilder;
5 |
6 | import java.util.ArrayList;
7 | import java.util.List;
8 | import java.util.Map;
9 | import java.util.Set;
10 | import java.util.function.BiConsumer;
11 | import java.util.function.BinaryOperator;
12 | import java.util.function.Function;
13 | import java.util.function.Supplier;
14 | import java.util.stream.Collector;
15 |
16 | public class BatchedMessageCollector implements Collector>, MessageBuilder>> {
17 | private final Function getPayload;
18 | private final Function> getHeaders;
19 |
20 | public BatchedMessageCollector(Function getPayload, Function> getHeaders) {
21 | this.getPayload = getPayload;
22 | this.getHeaders = getHeaders;
23 | }
24 |
25 |
26 | @Override
27 | public Supplier>> supplier() {
28 | return () -> MessageBuilder.>withPayload(new ArrayList<>())
29 | .setHeader(SolaceBinderHeaders.BATCHED_HEADERS, new ArrayList>());
30 | }
31 |
32 | @Override
33 | public BiConsumer>, T> accumulator() {
34 | return (builder, elem) -> {
35 | builder.getPayload().add(getPayload.apply(elem));
36 | @SuppressWarnings("unchecked")
37 | List> batchedHeaders = (List>) builder.getHeaders()
38 | .get(SolaceBinderHeaders.BATCHED_HEADERS);
39 | batchedHeaders.add(getHeaders.apply(elem));
40 | };
41 | }
42 |
43 | @Override
44 | public BinaryOperator>> combiner() {
45 | return (left, right) -> {
46 | @SuppressWarnings("unchecked")
47 | List> leftBatchedHeaders = (List>) left.getHeaders()
48 | .get(SolaceBinderHeaders.BATCHED_HEADERS);
49 | @SuppressWarnings("unchecked")
50 | List> rightBatchedHeaders = (List>) right.getHeaders()
51 | .get(SolaceBinderHeaders.BATCHED_HEADERS);
52 | leftBatchedHeaders.addAll(rightBatchedHeaders);
53 | left.getPayload().addAll(right.getPayload());
54 | return left;
55 | };
56 | }
57 |
58 | @Override
59 | public Function>, MessageBuilder>> finisher() {
60 | return b -> b;
61 | }
62 |
63 | @Override
64 | public Set characteristics() {
65 | return Set.of();
66 | }
67 | }
68 |
--------------------------------------------------------------------------------
/solace-spring-cloud-stream-binder/solace-spring-cloud-stream-binder-core/src/main/java/com/solace/spring/cloud/stream/binder/messaging/SolaceBinderHeaderMeta.java:
--------------------------------------------------------------------------------
1 | package com.solace.spring.cloud.stream.binder.messaging;
2 |
3 | import com.solace.spring.cloud.stream.binder.util.CorrelationData;
4 |
5 | import java.util.List;
6 | import java.util.Map;
7 | import java.util.stream.Collectors;
8 | import java.util.stream.Stream;
9 |
10 | public class SolaceBinderHeaderMeta implements HeaderMeta {
11 | public static final Map> META = Stream.of(new Object[][] {
12 | {SolaceBinderHeaders.PARTITION_KEY, new SolaceBinderHeaderMeta<>(String.class, false, true, Scope.WIRE)},
13 | {SolaceBinderHeaders.MESSAGE_VERSION, new SolaceBinderHeaderMeta<>(Integer.class, true, false, Scope.WIRE)},
14 | {SolaceBinderHeaders.SERIALIZED_PAYLOAD, new SolaceBinderHeaderMeta<>(Boolean.class, false, false, Scope.WIRE)},
15 | {SolaceBinderHeaders.SERIALIZED_HEADERS, new SolaceBinderHeaderMeta<>(String.class, false, false, Scope.WIRE)},
16 | {SolaceBinderHeaders.SERIALIZED_HEADERS_ENCODING, new SolaceBinderHeaderMeta<>(String.class, false, false, Scope.WIRE)},
17 | {SolaceBinderHeaders.CONFIRM_CORRELATION, new SolaceBinderHeaderMeta<>(CorrelationData.class, false, true, Scope.LOCAL)},
18 | {SolaceBinderHeaders.NULL_PAYLOAD, new SolaceBinderHeaderMeta<>(Boolean.class, true, false, Scope.LOCAL)},
19 | {SolaceBinderHeaders.BATCHED_HEADERS, new SolaceBinderHeaderMeta<>(List.class, true, true, Scope.LOCAL)},
20 | {SolaceBinderHeaders.TARGET_DESTINATION_TYPE, new SolaceBinderHeaderMeta<>(String.class, false, true, Scope.LOCAL)}
21 | }).collect(Collectors.toMap(d -> (String) d[0], d -> (SolaceBinderHeaderMeta) d[1]));
22 |
23 | private final Class type;
24 | private final boolean readable;
25 | private final boolean writable;
26 | private final Scope scope;
27 |
28 | public SolaceBinderHeaderMeta(Class type, boolean readable, boolean writable, Scope scope) {
29 | this.type = type;
30 | this.readable = readable;
31 | this.writable = writable;
32 | this.scope = scope;
33 | }
34 |
35 | @Override
36 | public Class getType() {
37 | return type;
38 | }
39 |
40 | /**
41 | * The readable property is only used by tests and doesn't necessarily reflect whether a header can be read by an application or not
42 | */
43 | @Override
44 | public boolean isReadable() {
45 | return readable;
46 | }
47 |
48 | /**
49 | * The writable property is only used by tests and doesn't necessarily reflect whether a header can be written by an application or not
50 | */
51 | @Override
52 | public boolean isWritable() {
53 | return writable;
54 | }
55 |
56 | @Override
57 | public Scope getScope() {
58 | return scope;
59 | }
60 | }
61 |
--------------------------------------------------------------------------------
/solace-spring-cloud-stream-binder/solace-spring-cloud-stream-binder-core/src/main/java/com/solace/spring/cloud/stream/binder/health/base/SolaceHealthIndicator.java:
--------------------------------------------------------------------------------
1 | package com.solace.spring.cloud.stream.binder.health.base;
2 |
3 | import org.apache.commons.lang3.StringUtils;
4 | import org.slf4j.Logger;
5 | import org.slf4j.LoggerFactory;
6 | import org.springframework.boot.actuate.health.Health;
7 | import org.springframework.boot.actuate.health.HealthIndicator;
8 | import org.springframework.boot.actuate.health.Status;
9 | import org.springframework.lang.Nullable;
10 |
11 | import java.lang.reflect.InvocationTargetException;
12 | import java.util.Optional;
13 |
14 | public class SolaceHealthIndicator implements HealthIndicator {
15 | private static final String STATUS_RECONNECTING = "RECONNECTING";
16 | private static final String INFO = "info";
17 | private static final String RESPONSE_CODE = "responseCode";
18 | private volatile Health health;
19 | private static final Logger LOGGER = LoggerFactory.getLogger(SolaceHealthIndicator.class);
20 |
21 | private static void logDebugStatus(String status) {
22 | LOGGER.debug("Solace connection/flow status is {}", status);
23 | }
24 | protected void healthUp() {
25 | health = Health.up().build();
26 | logDebugStatus(String.valueOf(Status.UP));
27 | }
28 | protected void healthReconnecting(@Nullable T eventArgs) {
29 | health = addEventDetails(Health.status(STATUS_RECONNECTING), eventArgs).build();
30 | logDebugStatus(STATUS_RECONNECTING);
31 | }
32 |
33 | protected void healthDown(@Nullable T eventArgs) {
34 | health = addEventDetails(Health.down(), eventArgs).build();
35 | logDebugStatus(String.valueOf(Status.DOWN));
36 | }
37 |
38 | public Health.Builder addEventDetails(Health.Builder builder, @Nullable T eventArgs) {
39 | if (eventArgs == null) {
40 | return builder;
41 | }
42 |
43 | try {
44 | Optional.ofNullable(eventArgs.getClass().getMethod("getException").invoke(eventArgs))
45 | .ifPresent(ex -> builder.withException((Throwable) ex));
46 | Optional.of(eventArgs.getClass().getMethod("getResponseCode").invoke(eventArgs))
47 | .filter(c -> ((int) c) != 0)
48 | .ifPresent(c -> builder.withDetail(RESPONSE_CODE, c));
49 | Optional.ofNullable(eventArgs.getClass().getMethod("getInfo").invoke(eventArgs))
50 | .filter(t -> StringUtils.isNotBlank(String.valueOf(t)))
51 | .ifPresent(info -> builder.withDetail(INFO, info));
52 | } catch (IllegalAccessException | InvocationTargetException | NoSuchMethodException e) {
53 | throw new RuntimeException(e);
54 | }
55 |
56 | return builder;
57 | }
58 |
59 | @Override
60 | public Health health() {
61 | return health;
62 | }
63 |
64 | void setHealth(Health health) {
65 | this.health = health;
66 | }
67 | }
--------------------------------------------------------------------------------
/solace-spring-cloud-stream-binder/solace-spring-cloud-stream-binder-core/src/main/java/com/solace/spring/cloud/stream/binder/health/indicators/SessionHealthIndicator.java:
--------------------------------------------------------------------------------
1 | package com.solace.spring.cloud.stream.binder.health.indicators;
2 |
3 | import com.solace.spring.cloud.stream.binder.health.base.SolaceHealthIndicator;
4 | import com.solace.spring.cloud.stream.binder.properties.SolaceSessionHealthProperties;
5 | import com.solacesystems.jcsmp.SessionEventArgs;
6 | import org.slf4j.Logger;
7 | import org.slf4j.LoggerFactory;
8 | import org.springframework.lang.Nullable;
9 |
10 | import java.util.Optional;
11 | import java.util.concurrent.atomic.AtomicInteger;
12 | import java.util.concurrent.locks.ReentrantLock;
13 |
14 | public class SessionHealthIndicator extends SolaceHealthIndicator {
15 | private final AtomicInteger reconnectCount = new AtomicInteger(0);
16 | private final SolaceSessionHealthProperties solaceHealthSessionProperties;
17 | private final ReentrantLock writeLock = new ReentrantLock();
18 | private static final Logger LOGGER = LoggerFactory.getLogger(SessionHealthIndicator.class);
19 |
20 | public SessionHealthIndicator(SolaceSessionHealthProperties solaceHealthSessionProperties) {
21 | this.solaceHealthSessionProperties = solaceHealthSessionProperties;
22 | }
23 |
24 | public void up() {
25 | writeLock.lock();
26 | try {
27 | LOGGER.trace("Reset reconnect count");
28 | this.reconnectCount.set(0);
29 | super.healthUp();
30 | } finally {
31 | writeLock.unlock();
32 | }
33 | }
34 |
35 | public void reconnecting(@Nullable SessionEventArgs eventArgs) {
36 | writeLock.lock();
37 | try {
38 | long reconnectAttempt = this.reconnectCount.incrementAndGet();
39 | if (Optional.of(this.solaceHealthSessionProperties.getReconnectAttemptsUntilDown())
40 | .filter(maxReconnectAttempts -> maxReconnectAttempts > 0)
41 | .filter(maxReconnectAttempts -> reconnectAttempt > maxReconnectAttempts)
42 | .isPresent()) {
43 | LOGGER.debug("Solace connection reconnect attempt {} > {}, changing state to down",
44 | reconnectAttempt, solaceHealthSessionProperties.getReconnectAttemptsUntilDown());
45 | this.down(eventArgs, false);
46 | return;
47 | }
48 |
49 | super.healthReconnecting(eventArgs);
50 | } finally {
51 | writeLock.unlock();
52 | }
53 | }
54 |
55 | public void down(@Nullable SessionEventArgs eventArgs) {
56 | down(eventArgs, true);
57 | }
58 |
59 | public void down(@Nullable SessionEventArgs eventArgs, boolean resetReconnectCount) {
60 | writeLock.lock();
61 | try {
62 | if (resetReconnectCount) {
63 | LOGGER.trace("Reset reconnect count");
64 | this.reconnectCount.set(0);
65 | }
66 | super.healthDown(eventArgs);
67 | } finally {
68 | writeLock.unlock();
69 | }
70 | }
71 | }
72 |
--------------------------------------------------------------------------------
/solace-spring-cloud-stream-binder/solace-spring-cloud-stream-binder-core/src/main/java/com/solace/spring/cloud/stream/binder/util/ErrorQueueInfrastructure.java:
--------------------------------------------------------------------------------
1 | package com.solace.spring.cloud.stream.binder.util;
2 |
3 | import com.solace.spring.cloud.stream.binder.properties.SolaceConsumerProperties;
4 | import com.solacesystems.jcsmp.JCSMPException;
5 | import com.solacesystems.jcsmp.JCSMPFactory;
6 | import com.solacesystems.jcsmp.Queue;
7 | import com.solacesystems.jcsmp.XMLMessage;
8 | import com.solacesystems.jcsmp.XMLMessageProducer;
9 | import org.slf4j.Logger;
10 | import org.slf4j.LoggerFactory;
11 | import org.springframework.messaging.MessagingException;
12 |
13 | public class ErrorQueueInfrastructure {
14 | private final JCSMPSessionProducerManager producerManager;
15 | private final String producerKey;
16 | private final String errorQueueName;
17 | private final SolaceConsumerProperties consumerProperties;
18 | private final XMLMessageMapper xmlMessageMapper = new XMLMessageMapper();
19 |
20 | private static final Logger LOGGER = LoggerFactory.getLogger(ErrorQueueInfrastructure.class);
21 |
22 | public ErrorQueueInfrastructure(JCSMPSessionProducerManager producerManager, String producerKey,
23 | String errorQueueName, SolaceConsumerProperties consumerProperties) {
24 | this.producerManager = producerManager;
25 | this.producerKey = producerKey;
26 | this.errorQueueName = errorQueueName;
27 | this.consumerProperties = consumerProperties;
28 | }
29 |
30 | public void send(MessageContainer messageContainer, ErrorQueueRepublishCorrelationKey key) throws JCSMPException {
31 | XMLMessage xmlMessage = xmlMessageMapper.mapError(messageContainer.getMessage(), consumerProperties);
32 | xmlMessage.setCorrelationKey(key);
33 | Queue queue = JCSMPFactory.onlyInstance().createQueue(errorQueueName);
34 | XMLMessageProducer producer;
35 | try {
36 | producer = producerManager.get(producerKey);
37 | } catch (Exception e) {
38 | MessagingException wrappedException = new MessagingException(
39 | String.format("Failed to get producer to send message %s to queue %s", xmlMessage.getMessageId(),
40 | errorQueueName), e);
41 | LOGGER.warn(wrappedException.getMessage(), e);
42 | throw wrappedException;
43 | }
44 |
45 | producer.send(xmlMessage, queue);
46 | }
47 |
48 | public ErrorQueueRepublishCorrelationKey createCorrelationKey(MessageContainer messageContainer,
49 | FlowReceiverContainer flowReceiverContainer) {
50 | return new ErrorQueueRepublishCorrelationKey(this, messageContainer, flowReceiverContainer);
51 | }
52 |
53 | public String getErrorQueueName() {
54 | return errorQueueName;
55 | }
56 |
57 | public long getMaxDeliveryAttempts() {
58 | return consumerProperties.getErrorQueueMaxDeliveryAttempts();
59 | }
60 | }
61 |
--------------------------------------------------------------------------------
/solace-spring-cloud-stream-binder/solace-spring-cloud-stream-binder-core/src/main/java/com/solace/spring/cloud/stream/binder/properties/SmfMessageWriterProperties.java:
--------------------------------------------------------------------------------
1 | package com.solace.spring.cloud.stream.binder.properties;
2 |
3 | import com.solace.spring.cloud.stream.binder.util.SmfMessageHeaderWriteCompatibility;
4 | import com.solace.spring.cloud.stream.binder.util.SmfMessagePayloadWriteCompatibility;
5 |
6 | import java.util.HashSet;
7 | import java.util.LinkedHashMap;
8 | import java.util.Map;
9 | import java.util.Objects;
10 | import java.util.Set;
11 |
12 | public class SmfMessageWriterProperties {
13 | private Set headerExclusions;
14 | private SmfMessageHeaderWriteCompatibility headerTypeCompatibility;
15 | private SmfMessagePayloadWriteCompatibility payloadTypeCompatibility;
16 | private boolean nonSerializableHeaderConvertToString;
17 | private final Map headerNameMapping;
18 |
19 | public SmfMessageWriterProperties(SolaceProducerProperties solaceProducerProperties) {
20 | this.headerExclusions = new HashSet<>(solaceProducerProperties.getHeaderExclusions());
21 | this.headerTypeCompatibility = solaceProducerProperties.getHeaderTypeCompatibility();
22 | this.payloadTypeCompatibility = solaceProducerProperties.getPayloadTypeCompatibility();
23 | this.nonSerializableHeaderConvertToString = solaceProducerProperties.isNonserializableHeaderConvertToString();
24 | this.headerNameMapping = new LinkedHashMap<>(Objects.requireNonNullElse(solaceProducerProperties.getHeaderNameMapping(), Map.of()));
25 | }
26 |
27 | public Set getHeaderExclusions() {
28 | return headerExclusions;
29 | }
30 |
31 | public void setHeaderExclusions(Set headerExclusions) {
32 | this.headerExclusions = headerExclusions;
33 | }
34 |
35 | public SmfMessageHeaderWriteCompatibility getHeaderTypeCompatibility() {
36 | return headerTypeCompatibility;
37 | }
38 |
39 | public void setHeaderTypeCompatibility(SmfMessageHeaderWriteCompatibility headerTypeCompatibility) {
40 | this.headerTypeCompatibility = headerTypeCompatibility;
41 | }
42 |
43 | public SmfMessagePayloadWriteCompatibility getPayloadTypeCompatibility() {
44 | return payloadTypeCompatibility;
45 | }
46 |
47 | public void setPayloadTypeCompatibility(SmfMessagePayloadWriteCompatibility payloadTypeCompatibility) {
48 | this.payloadTypeCompatibility = payloadTypeCompatibility;
49 | }
50 |
51 | public boolean isNonSerializableHeaderConvertToString() {
52 | return nonSerializableHeaderConvertToString;
53 | }
54 |
55 | public void setNonSerializableHeaderConvertToString(boolean nonSerializableHeaderConvertToString) {
56 | this.nonSerializableHeaderConvertToString = nonSerializableHeaderConvertToString;
57 | }
58 |
59 | public Map getHeaderNameMapping() {
60 | return headerNameMapping;
61 | }
62 | }
63 |
--------------------------------------------------------------------------------
/solace-spring-cloud-bom/README.md:
--------------------------------------------------------------------------------
1 | # Solace Spring Cloud Bill of Materials (BOM)
2 |
3 | ## Contents
4 |
5 | * [Overview](#overview)
6 | * [Spring Boot Version Compatibility](#spring-cloud-version-compatibility)
7 | * [Including the BOM](#including-the-bom)
8 |
9 | ## Overview
10 |
11 | The Solace Spring Cloud Bill of Materials (BOM) is a POM file which defines the versions of Solace Spring Cloud projects that are compatible to a particular version of Spring Cloud.
12 |
13 | Note that since Spring Cloud depends on Spring Boot, the Solace Spring Boot BOM will be included by default by this BOM.
14 |
15 | ## Spring Cloud Version Compatibility
16 |
17 | Consult the table below to determine which version of the BOM you need to use:
18 |
19 | | Spring Cloud | Solace Spring Cloud BOM | Spring Boot |
20 | |--------------|----------------------------|-------------|
21 | | Hoxton.SR1 | 1.0.0 | 2.2.x |
22 | | Hoxton.SR6 | 1.1.0 | 2.3.x |
23 | | 2020.0.1 | 2.0.0, 2.1.0, 2.2.0, 2.2.1 | 2.4.x |
24 | | 2021.0.1 | 2.3.0, 2.3.1, 2.3.2 | 2.6.x |
25 | | 2021.0.4 | 2.4.0 | 2.7.x |
26 | | 2021.0.6 | 2.5.0 | 2.7.x |
27 | | 2022.0.2 | 3.0.0 | 3.0.x |
28 | | 2022.0.4 | 3.1.0, 3.2.0 | 3.1.x |
29 | | 2023.0.1 | 4.0.0, 4.1.0 | 3.2.x |
30 | | 2023.0.2 | 4.2.0 | 3.3.x |
31 | | 2023.0.3 | 4.3.0, 4.4.0, 4.5.0, 4.6.0 | 3.3.x |
32 | | 2024.0.0 | 4.7.0, 4.8.0 | 3.4.x |
33 | | 2024.0.2 | 4.9.0 | 3.4.x |
34 | | 2025.0.0 | 4.10.0, 4.11.0 | 3.5.x |
35 | ## Including the BOM
36 |
37 | In addition to showing how to include the BOM, the following snippets also shows how to use "version-less" Solace dependencies (`spring-cloud-starter-stream-solace` in this case) when using the BOM.
38 |
39 | ### Using it with Maven
40 | ```xml
41 |
42 |
43 |
44 | com.solace.spring.cloud
45 | solace-spring-cloud-bom
46 | 4.11.0
47 | pom
48 | import
49 |
50 |
51 |
52 |
53 |
54 |
55 | com.solace.spring.cloud
56 | spring-cloud-starter-stream-solace
57 |
58 |
59 | ```
60 |
61 | ### Using it with Gradle
62 | ```groovy
63 | dependencies {
64 | implementation(platform("com.solace.spring.cloud:solace-spring-cloud-bom:4.11.0"))
65 | implementation("com.solace.spring.cloud:spring-cloud-starter-stream-solace")
66 | }
67 | ```
68 |
--------------------------------------------------------------------------------
/solace-spring-cloud-stream-binder/solace-spring-cloud-stream-binder/src/main/java/com/solace/spring/cloud/stream/binder/config/SolaceHealthIndicatorsConfiguration.java:
--------------------------------------------------------------------------------
1 | package com.solace.spring.cloud.stream.binder.config;
2 |
3 | import com.solace.spring.cloud.stream.binder.health.SolaceBinderHealthAccessor;
4 | import com.solace.spring.cloud.stream.binder.health.contributors.BindingsHealthContributor;
5 | import com.solace.spring.cloud.stream.binder.health.contributors.SolaceBinderHealthContributor;
6 | import com.solace.spring.cloud.stream.binder.health.handlers.SolaceSessionEventHandler;
7 | import com.solace.spring.cloud.stream.binder.health.indicators.SessionHealthIndicator;
8 | import com.solace.spring.cloud.stream.binder.properties.SolaceSessionHealthProperties;
9 | import com.solacesystems.jcsmp.JCSMPProperties;
10 | import com.solacesystems.jcsmp.SolaceSessionOAuth2TokenProvider;
11 | import jakarta.annotation.Nullable;
12 | import org.slf4j.Logger;
13 | import org.slf4j.LoggerFactory;
14 | import org.springframework.boot.actuate.autoconfigure.health.ConditionalOnEnabledHealthIndicator;
15 | import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
16 | import org.springframework.boot.context.properties.EnableConfigurationProperties;
17 | import org.springframework.context.annotation.Bean;
18 | import org.springframework.context.annotation.Configuration;
19 |
20 | @Configuration
21 | @ConditionalOnClass(name = "org.springframework.boot.actuate.health.HealthIndicator")
22 | @ConditionalOnEnabledHealthIndicator("binders")
23 | @EnableConfigurationProperties({SolaceSessionHealthProperties.class})
24 | public class SolaceHealthIndicatorsConfiguration {
25 | private static final Logger LOGGER = LoggerFactory.getLogger(SolaceHealthIndicatorsConfiguration.class);
26 |
27 | @Bean
28 | public SolaceBinderHealthAccessor solaceBinderHealthAccessor(
29 | SolaceBinderHealthContributor solaceBinderHealthContributor) {
30 | return new SolaceBinderHealthAccessor(solaceBinderHealthContributor);
31 | }
32 |
33 | @Bean
34 | public SolaceBinderHealthContributor solaceBinderHealthContributor(
35 | SolaceSessionHealthProperties solaceSessionHealthProperties) {
36 | LOGGER.debug("Creating Solace Connection Health Indicators Hierarchy");
37 | return new SolaceBinderHealthContributor(
38 | new SessionHealthIndicator(solaceSessionHealthProperties),
39 | new BindingsHealthContributor()
40 | );
41 | }
42 |
43 | @Bean
44 | public SolaceSessionEventHandler solaceSessionEventHandler(
45 | JCSMPProperties jcsmpProperties,
46 | @Nullable SolaceSessionOAuth2TokenProvider solaceSessionOAuth2TokenProvider,
47 | SolaceBinderHealthContributor healthContributor) {
48 | LOGGER.debug("Creating Solace Session Event Handler for monitoring Health");
49 | return new SolaceSessionEventHandler(jcsmpProperties, solaceSessionOAuth2TokenProvider, healthContributor.getSolaceSessionHealthIndicator());
50 | }
51 |
52 | }
53 |
--------------------------------------------------------------------------------
/solace-spring-cloud-stream-binder/solace-spring-cloud-stream-binder-core/src/main/java/com/solace/spring/cloud/stream/binder/util/ToStringer.java:
--------------------------------------------------------------------------------
1 | package com.solace.spring.cloud.stream.binder.util;
2 |
3 | import com.solacesystems.jcsmp.ConsumerFlowProperties;
4 | import com.solacesystems.jcsmp.Endpoint;
5 | import com.solacesystems.jcsmp.EndpointProperties;
6 |
7 | /**
8 | * To string utility for 3'rd party classes that do not override toString in a meaningful way, to be used for logging or debugging purposes
9 | */
10 | public final class ToStringer {
11 |
12 | /**
13 | * provides a simplified toString for {@link EndpointProperties}
14 | * @param ep to tbe turned to String
15 | * @return string representation of the object
16 | */
17 | public static String toString(EndpointProperties ep) {
18 | if (ep== null)
19 | return "EndpointProperties{NULL}";
20 | return "EndpointProperties{" +
21 | "mAccessType=" + ep.getAccessType() +
22 | ", mMaxMsgSize=" + ep.getMaxMsgSize() +
23 | ", mPermission=" + ep.getPermission() +
24 | '}';
25 | }
26 |
27 | /**
28 | * provides a simplified toString for {@link Endpoint}
29 | * @param e to tbe turned to String
30 | * @return string representation of the object
31 | */
32 | public static String toString(Endpoint e) {
33 | if (e==null)
34 | return "Endpoint{NULL}";
35 | return "Endpoint{" +
36 | " class:" + e.getClass()+
37 | " _name='" + e.getName() + '\'' +
38 | ", _durable=" + e.isDurable() +
39 | '}';
40 | }
41 |
42 | /**
43 | * provides a simplified toString for {@link ConsumerFlowProperties}
44 | * @param cfp to tbe turned to String
45 | * @return string representation of the object
46 | */
47 | public static String toString(ConsumerFlowProperties cfp) {
48 |
49 | return "ConsumerFlowProperties{" +
50 | "endpoint=" + toString(cfp.getEndpoint()) +
51 | ", newSubscription=" + cfp.getNewSubscription() +
52 | ", sqlSelector='" + cfp.getSelector() + '\'' +
53 | ", startState=" + cfp.isStartState() +
54 | ", noLocal=" + cfp.isNoLocal() +
55 | ", activeFlowIndication=" + cfp.isActiveFlowIndication() +
56 | ", ackMode='" + cfp.getAckMode() + '\'' +
57 | ", windowSize=" + cfp.getTransportWindowSize() +
58 | ", ackTimerMs=" + cfp.getAckTimerInMsecs() +
59 | ", ackThreshold=" + cfp.getAckThreshold() +
60 | ", reconnectTries=" + cfp.getReconnectTries() +
61 | ", outcomes=" + cfp.getRequiredSettlementOutcomes() +
62 | ", flowSessionProps=" + cfp.getFlowSessionProps() +
63 | ", segmentFlow=" + cfp.isSegmentFlow() +
64 | '}';
65 | }
66 |
67 | }
68 |
--------------------------------------------------------------------------------
/solace-spring-cloud-stream-binder/solace-spring-cloud-stream-binder-core/src/main/java/com/solace/spring/cloud/stream/binder/health/SolaceBinderHealthAccessor.java:
--------------------------------------------------------------------------------
1 | package com.solace.spring.cloud.stream.binder.health;
2 |
3 | import com.solace.spring.cloud.stream.binder.health.contributors.BindingHealthContributor;
4 | import com.solace.spring.cloud.stream.binder.health.contributors.FlowsHealthContributor;
5 | import com.solace.spring.cloud.stream.binder.health.contributors.SolaceBinderHealthContributor;
6 | import com.solace.spring.cloud.stream.binder.health.handlers.SolaceFlowHealthEventHandler;
7 | import com.solace.spring.cloud.stream.binder.health.indicators.FlowHealthIndicator;
8 | import com.solace.spring.cloud.stream.binder.util.FlowReceiverContainer;
9 |
10 | import java.util.Optional;
11 |
12 | /**
13 | * Proxy class for the Solace binder to access health components.
14 | * Always use this instead of directly using health components in Solace binder code.
15 | * Allows for the Solace binder to still function correctly without actuator on the classpath.
16 | */
17 | public class SolaceBinderHealthAccessor {
18 | private final SolaceBinderHealthContributor solaceBinderHealthContributor;
19 | private static final String FLOW_ID_CONCURRENCY_IDX_PREFIX = "flow-";
20 |
21 | public SolaceBinderHealthAccessor(SolaceBinderHealthContributor solaceBinderHealthContributor) {
22 | this.solaceBinderHealthContributor = solaceBinderHealthContributor;
23 | }
24 |
25 | public void addFlow(String bindingName, int concurrencyIdx, FlowReceiverContainer flowReceiverContainer) {
26 | FlowHealthIndicator flowHealthIndicator = new FlowHealthIndicator();
27 | Optional.ofNullable(solaceBinderHealthContributor.getSolaceBindingsHealthContributor())
28 | .map(b -> b.getContributor(bindingName))
29 | .orElseGet(() -> {
30 | BindingHealthContributor newBindingHealth = new BindingHealthContributor(new FlowsHealthContributor());
31 | solaceBinderHealthContributor.getSolaceBindingsHealthContributor()
32 | .addBindingContributor(bindingName, newBindingHealth);
33 | return newBindingHealth;
34 | })
35 | .getFlowsHealthContributor()
36 | .addFlowContributor(createFlowIdFromConcurrencyIdx(concurrencyIdx), flowHealthIndicator);
37 | flowReceiverContainer.setEventHandler(new SolaceFlowHealthEventHandler(
38 | flowReceiverContainer.getXMLMessageMapper(),
39 | flowReceiverContainer.getId().toString(),
40 | flowHealthIndicator));
41 | }
42 |
43 | public void removeFlow(String bindingName, int concurrencyIdx) {
44 | Optional.ofNullable(solaceBinderHealthContributor.getSolaceBindingsHealthContributor())
45 | .map(b -> b.getContributor(bindingName))
46 | .map(BindingHealthContributor::getFlowsHealthContributor)
47 | .ifPresent(b -> b.removeFlowContributor(createFlowIdFromConcurrencyIdx(concurrencyIdx)));
48 | }
49 |
50 | private String createFlowIdFromConcurrencyIdx(int concurrencyIdx) {
51 | return FLOW_ID_CONCURRENCY_IDX_PREFIX + concurrencyIdx;
52 | }
53 | }
54 |
--------------------------------------------------------------------------------
/solace-spring-cloud-stream-binder/solace-spring-cloud-stream-binder-core/src/main/java/com/solace/spring/cloud/stream/binder/inbound/acknowledge/TransactedJCSMPAcknowledgementCallback.java:
--------------------------------------------------------------------------------
1 | package com.solace.spring.cloud.stream.binder.inbound.acknowledge;
2 |
3 | import com.solace.spring.cloud.stream.binder.util.ErrorQueueInfrastructure;
4 | import com.solace.spring.cloud.stream.binder.util.SolaceAcknowledgmentException;
5 | import com.solacesystems.jcsmp.JCSMPException;
6 | import com.solacesystems.jcsmp.transaction.RollbackException;
7 | import com.solacesystems.jcsmp.transaction.TransactedSession;
8 | import org.slf4j.Logger;
9 | import org.slf4j.LoggerFactory;
10 | import org.springframework.integration.acks.AcknowledgmentCallback;
11 |
12 | class TransactedJCSMPAcknowledgementCallback implements AcknowledgmentCallback {
13 | private final TransactedSession transactedSession;
14 | private final ErrorQueueInfrastructure errorQueueInfrastructure;
15 | private final long creationThreadId = Thread.currentThread().getId();
16 | private boolean acknowledged = false;
17 | private static final Logger LOGGER = LoggerFactory.getLogger(TransactedJCSMPAcknowledgementCallback.class);
18 |
19 | TransactedJCSMPAcknowledgementCallback(TransactedSession transactedSession,
20 | ErrorQueueInfrastructure errorQueueInfrastructure) {
21 | this.transactedSession = transactedSession;
22 | this.errorQueueInfrastructure = errorQueueInfrastructure;
23 | }
24 |
25 | @Override
26 | public void acknowledge(Status status) {
27 | if (acknowledged) {
28 | LOGGER.debug("transaction is already resolved");
29 | return;
30 | }
31 |
32 | if (creationThreadId != Thread.currentThread().getId()) {
33 | throw new UnsupportedOperationException("Transactions must be resolved on the message handler's thread");
34 | }
35 |
36 | try {
37 | switch (status) {
38 | case ACCEPT -> {
39 | try {
40 | transactedSession.commit();
41 | } catch (JCSMPException e) {
42 | if (!(e instanceof RollbackException)) {
43 | try {
44 | LOGGER.debug("Rolling back transaction");
45 | transactedSession.rollback();
46 | } catch (JCSMPException e1) {
47 | e.addSuppressed(e1);
48 | }
49 | }
50 |
51 | throw e;
52 | }
53 | }
54 | case REJECT -> {
55 | if (!republishToErrorQueue()) {
56 | transactedSession.rollback();
57 | }
58 | }
59 | case REQUEUE -> transactedSession.rollback();
60 | }
61 | } catch (Exception e) {
62 | throw new SolaceAcknowledgmentException("Failed to resolve transaction", e);
63 | }
64 |
65 | acknowledged = true;
66 | }
67 |
68 | /**
69 | * Send the message to the error queue and acknowledge the message.
70 | *
71 | * @return {@code true} if successful, {@code false} if {@code errorQueueInfrastructure} is not
72 | * defined.
73 | */
74 | private boolean republishToErrorQueue() {
75 | return false; //TODO
76 | }
77 |
78 | @Override
79 | public boolean isAcknowledged() {
80 | return acknowledged;
81 | }
82 | }
83 |
--------------------------------------------------------------------------------
/solace-spring-cloud-stream-binder/solace-spring-cloud-stream-binder-core/src/main/java/com/solace/spring/cloud/stream/binder/provisioning/ExpressionContextRoot.java:
--------------------------------------------------------------------------------
1 | package com.solace.spring.cloud.stream.binder.provisioning;
2 |
3 | import com.solace.spring.cloud.stream.binder.properties.SolaceCommonProperties;
4 | import com.solace.spring.cloud.stream.binder.properties.SolaceConsumerProperties;
5 | import com.solace.spring.cloud.stream.binder.properties.SolaceProducerProperties;
6 | import org.springframework.cloud.stream.binder.ExtendedConsumerProperties;
7 | import org.springframework.cloud.stream.binder.ExtendedProducerProperties;
8 |
9 | /**
10 | * The context used to evaluate a queue name expression (SpEL)
11 | */
12 | public class ExpressionContextRoot {
13 |
14 | private final String group;
15 | private final String destination;
16 | private final boolean isAnonymous;
17 | private final Properties properties;
18 |
19 | public ExpressionContextRoot(String physicalGroupName, String destination, boolean isAnonymous, ExtendedConsumerProperties extendedProperties) {
20 | this.group = physicalGroupName;
21 | this.destination = destination;
22 | this.isAnonymous = isAnonymous;
23 | this.properties = new Properties<>(extendedProperties);
24 | }
25 |
26 | public ExpressionContextRoot(String groupName, String destination, ExtendedProducerProperties extendedProperties) {
27 | this.group = groupName;
28 | this.destination = destination;
29 | this.isAnonymous = false;
30 | this.properties = new Properties<>(extendedProperties);
31 | }
32 |
33 | public String getGroup() {
34 | return group;
35 | }
36 |
37 | public String getDestination() {
38 | return destination;
39 | }
40 |
41 | public boolean isAnonymous() {
42 | return isAnonymous;
43 | }
44 |
45 | public Properties getProperties() {
46 | return properties;
47 | }
48 |
49 | private static class Properties {
50 |
51 | private final SolaceCommonProperties solace;
52 | private final T spring;
53 |
54 | public Properties(T extendedProperties) {
55 | if (extendedProperties instanceof ExtendedConsumerProperties) {
56 | this.solace = (SolaceCommonProperties) ((ExtendedConsumerProperties) extendedProperties).getExtension();
57 | } else if (extendedProperties instanceof ExtendedProducerProperties) {
58 | this.solace = (SolaceCommonProperties) ((ExtendedProducerProperties) extendedProperties).getExtension();
59 | } else {
60 | throw new IllegalArgumentException("Unsupported argument type");
61 | }
62 | this.spring = extendedProperties;
63 | }
64 |
65 | public SolaceCommonProperties getSolace() {
66 | return solace;
67 | }
68 |
69 | public T getSpring() {
70 | return spring;
71 | }
72 | }
73 | }
74 |
--------------------------------------------------------------------------------