This is an automated email from the ASF dual-hosted git repository.
davsclaus pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/camel.git
The following commit(s) were added to refs/heads/main by this push:
new e149f2c7b85c (#30248)
e149f2c7b85c is described below
commit e149f2c7b85c9d279e8310d5f28242d3f2ef2601
Author: allthingssecurity <[email protected]>
AuthorDate: Tue Nov 17 18:20:25 2026 +0530
(#30248)
In MQTT 5 a broker that refuses a subscription answers with a SUBACK whose
reason code is 0x80 or higher (3.9.3), for example 0x87 Not authorized.
Paho 1.2.5 completes the token of the subscribe with those reason codes
and throws nothing, and the consumer never looked at them: a route whose
subscription was refused started and received no message, and a refused
resubscribe after a reconnect counted as done.
The consumer now subscribes through one method that throws an
MqttException with the reason code when the SUBACK has a reason code of
0x80 or higher, on start, on the resubscribe after an automatic reconnect
and after its own reconnect. So a refused subscription is handled as a
subscribe that throws: the route does not start, and a refused
resubscribe restarts the route (own client) or logs an error (client
option). A failed subscribe after the consumer's own reconnect (a failed
message on a kept session, when the broker did not keep it) now restarts
the route too: that connect created a kept session, so the next reconnect
would find it and not subscribe. A granted QoS lower than the requested
one is not a failure.
The fake client of the Paho DST world answers IMqttToken.getReasonCodes
(the granted QoS for a subscribe; the fake broker refuses none) and
models MqttClient.disconnectForcibly(0, 0, false), which the
CAMEL-27041 fix calls. Test only: the world fails a seed on a token
method it does not model, so without it every seed of its default set
fails once the consumer reads the reason codes.
New PahoMqtt5SubscribeRefusedTest; upgrade guide entry.
- FakeMqtt: a forced disconnect fails an automatic reconnect attempt, and
MqttReconnectActionListener.onFailure reschedules the cycle, as in Paho
(before, the attempt returned and the cycle ended).
- FakeMqtt: a connect clears the connecting flag only when no forced
disconnect came during it, so an older connect cannot clear the flag of a
newer one and hide a 32110.
- FakeMqtt Javadoc: a SUBACK that refuses a subscription is not modelled.
- PahoMqtt5SubscribeRefusedTest waits with Awaitility instead of Mockito
timeout().
- Upgrade guide: `manualAcksEnabled` in backticks.
Co-Authored-By: Claude Opus 5.5 <[email protected]>
---
.../component/paho/mqtt5/PahoMqtt5Consumer.java | 41 +++-
.../paho/mqtt5/PahoMqtt5SubscribeRefusedTest.java | 207 +++++++++++++++++++++
.../camel/component/paho/mqtt5/dst/FakeMqtt.java | 51 ++++-
.../ROOT/pages/camel-4x-upgrade-guide-4_24.adoc | 9 +
4 files changed, 299 insertions(+), 9 deletions(-)
diff --git
a/components/camel-paho-mqtt5/src/main/java/org/apache/camel/component/paho/mqtt5/PahoMqtt5Consumer.java
b/components/camel-paho-mqtt5/src/main/java/org/apache/camel/component/paho/mqtt5/PahoMqtt5Consumer.java
index b0cd71b1d419..5a1531de39bf 100644
---
a/components/camel-paho-mqtt5/src/main/java/org/apache/camel/component/paho/mqtt5/PahoMqtt5Consumer.java
+++
b/components/camel-paho-mqtt5/src/main/java/org/apache/camel/component/paho/mqtt5/PahoMqtt5Consumer.java
@@ -33,6 +33,7 @@ import org.eclipse.paho.mqttv5.client.MqttClient;
import org.eclipse.paho.mqttv5.client.MqttConnectionOptions;
import org.eclipse.paho.mqttv5.common.MqttException;
import org.eclipse.paho.mqttv5.common.MqttMessage;
+import org.eclipse.paho.mqttv5.common.packet.MqttReturnCode;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@@ -105,7 +106,7 @@ public class PahoMqtt5Consumer extends DefaultConsumer {
}
LOG.debug("Subscribing client: {} to topic: {}", clientId,
getEndpoint().getTopic());
- client.subscribe(getEndpoint().getTopic(),
getEndpoint().getConfiguration().getQos());
+ subscribe(client);
} catch (Exception startException) {
shutdownReconnectExecutor();
MqttClient ownedClient = stopClient ? client : null;
@@ -243,7 +244,7 @@ public class PahoMqtt5Consumer extends DefaultConsumer {
return;
}
try {
- current.subscribe(getEndpoint().getTopic(),
getEndpoint().getConfiguration().getQos());
+ subscribe(current);
} catch (MqttException e) {
if (stopClient) {
LOG.warn("MQTT resubscribe failed on reconnect, restarting
route for recovery: {}",
@@ -258,6 +259,25 @@ public class PahoMqtt5Consumer extends DefaultConsumer {
}
}
+ /**
+ * Subscribes the client to the topic of the endpoint. Paho returns from
the subscribe once the SUBACK arrived, also
+ * when the broker refused the subscription: the reason code in the SUBACK
is then 0x80 or higher (MQTT 5, 3.9.3),
+ * and the broker sends no message of the topic. That is a failed
subscribe, as a subscribe that throws.
+ */
+ private void subscribe(MqttClient mqttClient) throws MqttException {
+ IMqttToken token = mqttClient.subscribe(getEndpoint().getTopic(),
getEndpoint().getConfiguration().getQos());
+ int[] reasonCodes = token != null ? token.getReasonCodes() : null;
+ if (reasonCodes != null) {
+ for (int reasonCode : reasonCodes) {
+ if (reasonCode >=
MqttReturnCode.RETURN_CODE_UNSPECIFIED_ERROR) {
+ LOG.debug("The broker refused the subscription of client:
{} to topic: {} with reason code: {}",
+ mqttClient.getClientId(),
getEndpoint().getTopic(), reasonCode);
+ throw new MqttException(reasonCode);
+ }
+ }
+ }
+ }
+
void onMessageArrived(String topic, MqttMessage message) {
Exchange exchange = createExchange(message, topic);
@@ -367,7 +387,7 @@ public class PahoMqtt5Consumer extends DefaultConsumer {
LOG.warn("The broker did not keep the session of client:
{}: the failed MQTT message and the other"
+ " unacknowledged ones are not delivered again;
subscribing again to topic: {}",
clientId, getEndpoint().getTopic());
- current.subscribe(getEndpoint().getTopic(),
getEndpoint().getConfiguration().getQos());
+ subscribeAfterReconnect(current);
}
}
} catch (Exception e) {
@@ -379,6 +399,21 @@ public class PahoMqtt5Consumer extends DefaultConsumer {
}
}
+ /**
+ * Subscribes again after the reconnect of {@link #reconnect(MqttClient)}
found no session. The connect created a
+ * session that the broker keeps, so a later reconnect finds it and does
not subscribe: a failed subscribe would
+ * leave the consumer connected without its subscription. The route is
restarted instead, as for a failed
+ * resubscribe after an automatic reconnect.
+ */
+ private void subscribeAfterReconnect(MqttClient current) {
+ try {
+ subscribe(current);
+ } catch (MqttException e) {
+ LOG.warn("MQTT subscribe failed after a reconnect, restarting
route for recovery: {}", e.getMessage(), e);
+ restartRouteAsync();
+ }
+ }
+
/**
* Schedules a reconnect after the backoff delay, unless one is already
scheduled or the consumer is stopping.
*/
diff --git
a/components/camel-paho-mqtt5/src/test/java/org/apache/camel/component/paho/mqtt5/PahoMqtt5SubscribeRefusedTest.java
b/components/camel-paho-mqtt5/src/test/java/org/apache/camel/component/paho/mqtt5/PahoMqtt5SubscribeRefusedTest.java
new file mode 100644
index 000000000000..d82780e953c4
--- /dev/null
+++
b/components/camel-paho-mqtt5/src/test/java/org/apache/camel/component/paho/mqtt5/PahoMqtt5SubscribeRefusedTest.java
@@ -0,0 +1,207 @@
+/*
+ * 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.camel.component.paho.mqtt5;
+
+import java.util.Map;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import org.apache.camel.Consumer;
+import org.apache.camel.Endpoint;
+import org.apache.camel.Processor;
+import org.apache.camel.ServiceStatus;
+import org.apache.camel.builder.RouteBuilder;
+import org.apache.camel.test.junit6.CamelTestSupport;
+import org.eclipse.paho.mqttv5.client.IMqttToken;
+import org.eclipse.paho.mqttv5.client.MqttCallback;
+import org.eclipse.paho.mqttv5.client.MqttClient;
+import org.eclipse.paho.mqttv5.client.MqttConnectionOptions;
+import org.eclipse.paho.mqttv5.common.MqttException;
+import org.eclipse.paho.mqttv5.common.MqttMessage;
+import org.eclipse.paho.mqttv5.common.packet.MqttReturnCode;
+import org.junit.jupiter.api.Test;
+import org.mockito.ArgumentCaptor;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.catchThrowable;
+import static org.awaitility.Awaitility.await;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.doAnswer;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+/**
+ * A broker that refuses a subscription answers with a SUBACK whose reason
code is 0x80 or higher (MQTT 5, 3.9.3), for
+ * example 0x87 Not authorized. Paho 1.2.5 returns from MqttClient.subscribe
all the same (it puts the reason codes on
+ * the token and throws nothing), and the broker then sends no message of the
topic.
+ */
+class PahoMqtt5SubscribeRefusedTest extends CamelTestSupport {
+
+ private static final String ROUTE_ID = "mqtt-consumer";
+
+ @Override
+ public boolean isUseAdviceWith() {
+ return true;
+ }
+
+ @Test
+ void routeDoesNotStartWhenTheBrokerRefusesTheSubscription() throws
Exception {
+ MqttClient client = mock(MqttClient.class);
+ when(client.isConnected()).thenReturn(true);
+ IMqttToken refused = token(MqttReturnCode.RETURN_CODE_NOT_AUTHORIZED);
+ when(client.subscribe("test", 2)).thenReturn(refused);
+ addRouteWithOwnedClient(client);
+
+ Throwable thrown = catchThrowable(context::start);
+
+
assertThat(thrown).rootCause().isInstanceOf(MqttException.class).hasMessageContaining("Not
authorized");
+ verify(client).disconnect();
+ verify(client).close(true);
+ }
+
+ @Test
+ void routeStartsWhenTheBrokerGrantsTheSubscription() throws Exception {
+ MqttClient client = mock(MqttClient.class);
+ when(client.isConnected()).thenReturn(true);
+ IMqttToken granted = token(MqttReturnCode.RETURN_CODE_MAX_QOS_2);
+ when(client.subscribe("test", 2)).thenReturn(granted);
+ addRouteWithOwnedClient(client);
+
+ context.start();
+
+
assertThat(context.getRouteController().getRouteStatus(ROUTE_ID)).isEqualTo(ServiceStatus.Started);
+ }
+
+ @Test
+ void refusedSubscriptionOnReconnectStopsTheRoute() throws Exception {
+ MqttClient client = mock(MqttClient.class);
+ when(client.isConnected()).thenReturn(true);
+ IMqttToken granted = token(MqttReturnCode.RETURN_CODE_MAX_QOS_2);
+ IMqttToken refused = token(MqttReturnCode.RETURN_CODE_NOT_AUTHORIZED);
+ when(client.subscribe("test", 2)).thenReturn(granted, refused,
refused);
+ addRouteWithOwnedClient(client);
+ context.start();
+ ArgumentCaptor<MqttCallback> callback =
ArgumentCaptor.forClass(MqttCallback.class);
+ verify(client).setCallback(callback.capture());
+
+ // the subscription is refused once the client reconnected: as for a
subscribe that throws, the route is
+ // restarted, and it does not start as long as the broker refuses the
subscription
+ callback.getValue().connectComplete(true, "tcp://localhost:1883");
+
+ // the stop of the restart closes the client, and so does the start
that fails
+ await().atMost(10, TimeUnit.SECONDS).untilAsserted(() ->
verify(client, times(2)).close(true));
+ verify(client, times(3)).subscribe("test", 2);
+ await().atMost(10, TimeUnit.SECONDS)
+ .untilAsserted(() ->
assertThat(context.getRouteController().getRouteStatus(ROUTE_ID))
+ .isEqualTo(ServiceStatus.Stopped));
+ }
+
+ @Test
+ void refusedSubscriptionAfterTheReconnectOfAFailedMessageStopsTheRoute()
throws Exception {
+ // a failed QoS 1 message on a session the broker keeps makes the
consumer reconnect; the broker did not keep the
+ // session, so the consumer subscribes again, and the broker refuses
it. That connect created a session, so a
+ // later reconnect would find it and not subscribe: the route is
restarted, as for a failed resubscribe
+ MqttClient client = mock(MqttClient.class);
+ AtomicBoolean connected = new AtomicBoolean();
+ when(client.isConnected()).thenAnswer(invocation -> connected.get());
+ doAnswer(invocation -> {
+ connected.set(true);
+ return null;
+ }).when(client).connect(any(MqttConnectionOptions.class));
+ doAnswer(invocation -> {
+ connected.set(false);
+ return null;
+ }).when(client).disconnect();
+ IMqttToken noSession = mock(IMqttToken.class);
+
when(client.connectWithResult(any(MqttConnectionOptions.class))).thenAnswer(invocation
-> {
+ connected.set(true);
+ return noSession;
+ });
+ IMqttToken granted = token(MqttReturnCode.RETURN_CODE_MAX_QOS_1);
+ IMqttToken refused = token(MqttReturnCode.RETURN_CODE_NOT_AUTHORIZED);
+ when(client.subscribe("test", 1)).thenReturn(granted, refused,
refused);
+ PahoMqtt5Configuration configuration = new PahoMqtt5Configuration();
+ configuration.setQos(1);
+ configuration.setManualAcksEnabled(true);
+ configuration.setCleanStart(false);
+ configuration.setSessionExpiryInterval(60);
+ addRouteWithOwnedClient(client, configuration);
+ context.start();
+ ArgumentCaptor<MqttCallback> callback =
ArgumentCaptor.forClass(MqttCallback.class);
+ verify(client).setCallback(callback.capture());
+ MqttMessage message = new MqttMessage("fail".getBytes());
+ message.setId(1);
+ message.setQos(1);
+
+ callback.getValue().messageArrived("test", message);
+
+ // the reconnect subscribes again (refused), the stop of the restart
closes the client, and so does the start
+ // that fails
+ await().atMost(10, TimeUnit.SECONDS)
+ .untilAsserted(() ->
verify(client).connectWithResult(any(MqttConnectionOptions.class)));
+ await().atMost(10, TimeUnit.SECONDS).untilAsserted(() ->
verify(client, times(2)).close(true));
+ verify(client, times(3)).subscribe("test", 1);
+ await().atMost(10, TimeUnit.SECONDS)
+ .untilAsserted(() ->
assertThat(context.getRouteController().getRouteStatus(ROUTE_ID))
+ .isEqualTo(ServiceStatus.Stopped));
+ }
+
+ private static IMqttToken token(int reasonCode) {
+ IMqttToken token = mock(IMqttToken.class);
+ when(token.getReasonCodes()).thenReturn(new int[] { reasonCode });
+ return token;
+ }
+
+ private void addRouteWithOwnedClient(MqttClient client) throws Exception {
+ addRouteWithOwnedClient(client, new PahoMqtt5Configuration());
+ }
+
+ private void addRouteWithOwnedClient(MqttClient client,
PahoMqtt5Configuration configuration) throws Exception {
+ configuration.setBrokerUrl("tcp://localhost:1883");
+ PahoMqtt5Component component = new PahoMqtt5Component(context) {
+ @Override
+ protected Endpoint createEndpoint(String uri, String remaining,
Map<String, Object> parameters) {
+ return new PahoMqtt5Endpoint(uri, remaining, this,
configuration.copy()) {
+ @Override
+ public Consumer createConsumer(Processor processor) throws
Exception {
+ PahoMqtt5Consumer consumer = new
PahoMqtt5Consumer(this, processor) {
+ @Override
+ MqttClient createClient() {
+ return client;
+ }
+ };
+ configureConsumer(consumer);
+ return consumer;
+ }
+ };
+ }
+ };
+ context.addComponent("paho-mqtt5-owned", component);
+ context.addRoutes(new RouteBuilder() {
+ @Override
+ public void configure() {
+ from("paho-mqtt5-owned:test").id(ROUTE_ID)
+ .filter(body().convertToString().isEqualTo("fail"))
+ .throwException(new IllegalStateException("Simulated
failure"))
+ .end()
+ .to("mock:result");
+ }
+ });
+ }
+}
diff --git
a/components/camel-paho-mqtt5/src/test/java/org/apache/camel/component/paho/mqtt5/dst/FakeMqtt.java
b/components/camel-paho-mqtt5/src/test/java/org/apache/camel/component/paho/mqtt5/dst/FakeMqtt.java
index c54638c47c7c..50e8532dc81f 100644
---
a/components/camel-paho-mqtt5/src/test/java/org/apache/camel/component/paho/mqtt5/dst/FakeMqtt.java
+++
b/components/camel-paho-mqtt5/src/test/java/org/apache/camel/component/paho/mqtt5/dst/FakeMqtt.java
@@ -68,7 +68,8 @@ import org.eclipse.paho.mqttv5.common.MqttMessage;
* persistence of the client, the quiesce of a disconnect, the bound of 10
messages of the queue of the callback thread,
* the reconnect delay that Paho keeps for all clients of the JVM (each client
has its own here), the order of
* connectComplete and the messages resent at the connect (separate tasks
here), the threads that Paho calls
- * connectComplete and disconnected on (tasks of the callback executor here),
and the reason codes of a SUBACK.
+ * connectComplete and disconnected on (tasks of the callback executor here),
and a SUBACK that refuses a subscription
+ * (the fake broker grants the QoS asked for, and the token reports it in
getReasonCodes).
* <p>
* Timing (the one-stack rule of the harness): every call of the client takes
a round trip and writes take effect at its
* start; deliveries are tasks of the callback thread, one at a time, in order.
@@ -365,6 +366,8 @@ final class FakeMqtt {
private boolean reconnecting;
private boolean disconnectedByUser;
private boolean connecting;
+ // counts the forced disconnects: a connect that was in progress when
one came fails
+ private int forcedDisconnects;
private boolean hung;
// [P] CommsCallback: the callback thread, its target and current
state, and its queue of received messages
private boolean callbackTarget;
@@ -418,12 +421,20 @@ final class FakeMqtt {
Integer rm = options.getReceiveMaximum();
receiveMaximum = rm == null ? 65535 : rm;
connecting = true;
+ int forced = forcedDisconnects;
boolean present;
try {
dst.block(latency(), "connect");
+ if (forced != forcedDisconnects) {
+ // [P] the forced disconnect shut the connection down: the
connect fails
+ throw new
MqttException(MqttClientException.REASON_CODE_CONNECTION_LOST);
+ }
present = connectToBroker();
} finally {
- connecting = false;
+ if (forced == forcedDisconnects) {
+ // after a forced disconnect a newer connect may be in
progress: its flag is not this one's to clear
+ connecting = false;
+ }
}
connectedFlag = true;
disconnectedByUser = false;
@@ -431,7 +442,7 @@ final class FakeMqtt {
// flag that MqttReconnectCallback.disconnected sets is not
cleared (MqttAsyncClient 1.2.5)
boolean reconnect = reconnecting;
callbackTask("connectComplete", () ->
callback.connectComplete(reconnect, URI));
- return token(present);
+ return token(present, 0);
}
@Override
@@ -459,7 +470,8 @@ final class FakeMqtt {
onSubscribed.run();
dst.trace("mqtt: subscribed with QoS " + qos);
pump();
- return token(false);
+ // [P] the SUBACK grants the QoS asked for (the fake broker
refuses no subscription)
+ return token(false, qos);
}
@Override
@@ -491,6 +503,24 @@ final class FakeMqtt {
dst.block(latency(), "disconnect");
}
+ /**
+ * [P] ClientComms.disconnectForcibly: sets DISCONNECTING whatever the
state and shuts the connection down, so a
+ * connect in progress fails and the client is DISCONNECTED (a close
no longer fails with 32110). Only the case
+ * the consumer uses is modelled: no DISCONNECT packet, on a client
that is connecting or disconnected.
+ */
+ @Override
+ public void disconnectForcibly(long quiesceTimeout, long
disconnectTimeout, boolean sendDisconnect)
+ throws MqttException {
+ checkOpen();
+ if (connectedFlag || sendDisconnect) {
+ violations.add("not modelled: disconnectForcibly of a
connected client or with a DISCONNECT packet");
+ throw new UnsupportedOperationException("disconnectForcibly");
+ }
+ dst.trace("mqtt: disconnectForcibly" + (connecting ? ", the
connect in progress fails" : ""));
+ forcedDisconnects++;
+ connecting = false;
+ }
+
boolean isClosed() {
return closed;
}
@@ -705,11 +735,17 @@ final class FakeMqtt {
return;
}
connecting = true;
+ int forced = forcedDisconnects;
try {
dst.block(latency(), "reconnect");
if (connectedFlag || closed || disconnectedByUser) {
return;
}
+ if (forced != forcedDisconnects) {
+ // [P] the forced disconnect fails this attempt, and
MqttReconnectActionListener.onFailure
+ // reschedules the cycle; a close does not stop it,
the next attempt after the close ends it
+ throw new
MqttException(MqttClientException.REASON_CODE_CONNECTION_LOST);
+ }
connectToBroker();
connectedFlag = true;
reconnectCycle = false;
@@ -718,15 +754,18 @@ final class FakeMqtt {
long max = Math.max(1000, options.getMaxReconnectDelay());
scheduleReconnect(Math.min(delay * 2, max));
} finally {
- connecting = false;
+ if (forced == forcedDisconnects) {
+ connecting = false;
+ }
}
});
}
- private IMqttToken token(boolean present) {
+ private IMqttToken token(boolean present, int reasonCode) {
return (IMqttToken)
Proxy.newProxyInstance(IMqttToken.class.getClassLoader(), new Class<?>[] {
IMqttToken.class },
(p, method, args) -> switch (method.getName()) {
case "getSessionPresent" -> present;
+ case "getReasonCodes" -> new int[] { reasonCode };
case "isComplete" -> true;
case "toString" -> "FakeMqtt.token";
case "hashCode" -> System.identityHashCode(p);
diff --git
a/docs/user-manual/modules/ROOT/pages/camel-4x-upgrade-guide-4_24.adoc
b/docs/user-manual/modules/ROOT/pages/camel-4x-upgrade-guide-4_24.adoc
index b50e31605e6b..1c67540b2533 100644
--- a/docs/user-manual/modules/ROOT/pages/camel-4x-upgrade-guide-4_24.adoc
+++ b/docs/user-manual/modules/ROOT/pages/camel-4x-upgrade-guide-4_24.adoc
@@ -8676,6 +8676,15 @@ message expiry interval, content type, response topic,
correlation data and user
a publish no longer modifies. A topic alias or subscription identifiers set in
the header object are not sent: the
client assigns topic aliases for its connection, and subscription identifiers
are sent by the server only.
+=== camel-paho-mqtt5 - a subscription the broker refuses fails the consumer
+
+The consumer now checks the reason code of the SUBACK. When the broker refuses
the subscription (a reason code of 0x80
+or higher, such as 0x87 Not authorized), the subscribe fails with an
`MqttException` that has that reason code, and
+the route does not start. When the subscription is refused after a reconnect
(an automatic reconnect of the client, or
+the reconnect after a failed message with `manualAcksEnabled`), the route is
restarted, and its start fails while the
+broker refuses the subscription; with a client given in the `client` option,
an error is logged. Before, Paho returned
+normally from such a subscribe, so the route started and received no message
of its topic.
+
=== camel-wal - the unconfirmed offsets of the previous run are replayed after
a restart
`WriteAheadResumeStrategy` now does what it is documented to do after a
restart: when the consumer starts and loads the