This is an automated email from the ASF dual-hosted git repository.
jt2594838 pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/iotdb.git
The following commit(s) were added to refs/heads/master by this push:
new 47b08dcab22 Fix unsubscribe failures when DataNodes are offline
(#19222)
47b08dcab22 is described below
commit 47b08dcab22072359e7d96e2bf4d5311b630bdbc
Author: Caideyipi <[email protected]>
AuthorDate: Thu Nov 12 18:49:16 2026 +0800
Fix unsubscribe failures when DataNodes are offline (#19222)
---
.../async/DataNodeTransportFailureUtils.java | 92 +++++
.../async/handlers/rpc/PipePushMetaRPCHandler.java | 10 +-
.../ConsumerGroupPushMetaRPCHandler.java | 11 +-
.../procedure/env/ConfigNodeProcedureEnv.java | 23 +-
.../AbstractOperateSubscriptionProcedure.java | 14 +
.../consumer/AlterConsumerGroupProcedure.java | 50 ++-
.../subscription/DropSubscriptionProcedure.java | 23 +-
.../procedure/env/ConfigNodeProcedureEnvTest.java | 59 ++++
.../DropSubscriptionProcedureTest.java | 382 ++++++++++++++++++++-
9 files changed, 641 insertions(+), 23 deletions(-)
diff --git
a/iotdb-core/confignode/src/main/java/org/apache/iotdb/confignode/client/async/DataNodeTransportFailureUtils.java
b/iotdb-core/confignode/src/main/java/org/apache/iotdb/confignode/client/async/DataNodeTransportFailureUtils.java
new file mode 100644
index 00000000000..13b7fda78ca
--- /dev/null
+++
b/iotdb-core/confignode/src/main/java/org/apache/iotdb/confignode/client/async/DataNodeTransportFailureUtils.java
@@ -0,0 +1,92 @@
+/*
+ * 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.iotdb.confignode.client.async;
+
+import org.apache.iotdb.common.rpc.thrift.TSStatus;
+import org.apache.iotdb.rpc.TSStatusCode;
+
+import org.apache.thrift.TApplicationException;
+import org.apache.thrift.protocol.TProtocolException;
+import org.apache.thrift.transport.TTransportException;
+
+import java.net.SocketException;
+import java.net.SocketTimeoutException;
+import java.nio.channels.ClosedChannelException;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.IdentityHashMap;
+import java.util.List;
+import java.util.Set;
+import java.util.concurrent.TimeoutException;
+
+public final class DataNodeTransportFailureUtils {
+
+ private static final int TRANSPORT_FAILURE_STATUS_CODE =
+ TSStatusCode.CAN_NOT_CONNECT_DATANODE.getStatusCode();
+
+ private DataNodeTransportFailureUtils() {}
+
+ public static boolean isTransportException(final Exception exception) {
+ final Set<Throwable> visited = Collections.newSetFromMap(new
IdentityHashMap<>());
+ for (Throwable cause = exception;
+ cause != null && visited.add(cause);
+ cause = cause.getCause()) {
+ if (cause instanceof TApplicationException || cause instanceof
TProtocolException) {
+ return false;
+ }
+ if (cause instanceof TTransportException) {
+ final int type = ((TTransportException) cause).getType();
+ // Corrupt frames and opening an already-open transport are not
connection failures.
+ return type == TTransportException.UNKNOWN
+ || type == TTransportException.NOT_OPEN
+ || type == TTransportException.TIMED_OUT
+ || type == TTransportException.END_OF_FILE;
+ }
+ if (cause instanceof SocketException
+ || cause instanceof SocketTimeoutException
+ || cause instanceof ClosedChannelException
+ || cause instanceof TimeoutException) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ public static TSStatus markTransportFailure(final TSStatus status) {
+ // CN-local provenance: preserve the metadata error code used by existing
callers.
+ final List<TSStatus> subStatus = new ArrayList<>();
+ if (status.isSetSubStatus() && status.getSubStatus() != null) {
+ subStatus.addAll(status.getSubStatus());
+ }
+ subStatus.add(new TSStatus(TRANSPORT_FAILURE_STATUS_CODE));
+ status.setSubStatus(subStatus);
+ return status;
+ }
+
+ public static boolean isTransportFailure(final TSStatus status) {
+ return status != null
+ && status.isSetSubStatus()
+ && status.getSubStatus() != null
+ && status.getSubStatus().stream()
+ .anyMatch(
+ subStatus ->
+ subStatus != null && subStatus.getCode() ==
TRANSPORT_FAILURE_STATUS_CODE);
+ }
+}
diff --git
a/iotdb-core/confignode/src/main/java/org/apache/iotdb/confignode/client/async/handlers/rpc/PipePushMetaRPCHandler.java
b/iotdb-core/confignode/src/main/java/org/apache/iotdb/confignode/client/async/handlers/rpc/PipePushMetaRPCHandler.java
index 41186a72887..7558d58ef64 100644
---
a/iotdb-core/confignode/src/main/java/org/apache/iotdb/confignode/client/async/handlers/rpc/PipePushMetaRPCHandler.java
+++
b/iotdb-core/confignode/src/main/java/org/apache/iotdb/confignode/client/async/handlers/rpc/PipePushMetaRPCHandler.java
@@ -20,7 +20,9 @@
package org.apache.iotdb.confignode.client.async.handlers.rpc;
import org.apache.iotdb.common.rpc.thrift.TDataNodeLocation;
+import org.apache.iotdb.common.rpc.thrift.TSStatus;
import org.apache.iotdb.confignode.client.async.CnToDnAsyncRequestType;
+import org.apache.iotdb.confignode.client.async.DataNodeTransportFailureUtils;
import org.apache.iotdb.confignode.i18n.ConfigNodeMessages;
import org.apache.iotdb.mpp.rpc.thrift.TPushPipeMetaResp;
import org.apache.iotdb.rpc.RpcUtils;
@@ -78,9 +80,11 @@ public class PipePushMetaRPCHandler extends
DataNodeAsyncRequestRPCHandler<TPush
String.valueOf(e.getMessage()));
LOGGER.warn(errorMsg);
- responseMap.put(
- requestId,
- new
TPushPipeMetaResp(RpcUtils.getStatus(TSStatusCode.PIPE_PUSH_META_ERROR,
errorMsg)));
+ final TSStatus status =
RpcUtils.getStatus(TSStatusCode.PIPE_PUSH_META_ERROR, errorMsg);
+ if (DataNodeTransportFailureUtils.isTransportException(e)) {
+ DataNodeTransportFailureUtils.markTransportFailure(status);
+ }
+ responseMap.put(requestId, new TPushPipeMetaResp(status));
// Always CountDown
countDownLatch.countDown();
diff --git
a/iotdb-core/confignode/src/main/java/org/apache/iotdb/confignode/client/async/handlers/rpc/subscription/ConsumerGroupPushMetaRPCHandler.java
b/iotdb-core/confignode/src/main/java/org/apache/iotdb/confignode/client/async/handlers/rpc/subscription/ConsumerGroupPushMetaRPCHandler.java
index 00a372fd41f..c6f46468f9d 100644
---
a/iotdb-core/confignode/src/main/java/org/apache/iotdb/confignode/client/async/handlers/rpc/subscription/ConsumerGroupPushMetaRPCHandler.java
+++
b/iotdb-core/confignode/src/main/java/org/apache/iotdb/confignode/client/async/handlers/rpc/subscription/ConsumerGroupPushMetaRPCHandler.java
@@ -20,7 +20,9 @@
package org.apache.iotdb.confignode.client.async.handlers.rpc.subscription;
import org.apache.iotdb.common.rpc.thrift.TDataNodeLocation;
+import org.apache.iotdb.common.rpc.thrift.TSStatus;
import org.apache.iotdb.confignode.client.async.CnToDnAsyncRequestType;
+import org.apache.iotdb.confignode.client.async.DataNodeTransportFailureUtils;
import
org.apache.iotdb.confignode.client.async.handlers.rpc.DataNodeAsyncRequestRPCHandler;
import org.apache.iotdb.confignode.i18n.ConfigNodeMessages;
import org.apache.iotdb.mpp.rpc.thrift.TPushConsumerGroupMetaResp;
@@ -77,10 +79,11 @@ public class ConsumerGroupPushMetaRPCHandler
String.valueOf(e.getMessage()));
LOGGER.warn(errorMsg);
- responseMap.put(
- requestId,
- new TPushConsumerGroupMetaResp(
- RpcUtils.getStatus(TSStatusCode.CONSUMER_PUSH_META_ERROR,
errorMsg)));
+ final TSStatus status =
RpcUtils.getStatus(TSStatusCode.CONSUMER_PUSH_META_ERROR, errorMsg);
+ if (DataNodeTransportFailureUtils.isTransportException(e)) {
+ DataNodeTransportFailureUtils.markTransportFailure(status);
+ }
+ responseMap.put(requestId, new TPushConsumerGroupMetaResp(status));
countDownLatch.countDown();
}
diff --git
a/iotdb-core/confignode/src/main/java/org/apache/iotdb/confignode/procedure/env/ConfigNodeProcedureEnv.java
b/iotdb-core/confignode/src/main/java/org/apache/iotdb/confignode/procedure/env/ConfigNodeProcedureEnv.java
index f9e52eb1caa..8fd27ab0fc0 100644
---
a/iotdb-core/confignode/src/main/java/org/apache/iotdb/confignode/procedure/env/ConfigNodeProcedureEnv.java
+++
b/iotdb-core/confignode/src/main/java/org/apache/iotdb/confignode/procedure/env/ConfigNodeProcedureEnv.java
@@ -35,6 +35,7 @@ import org.apache.iotdb.commons.trigger.TriggerInformation;
import org.apache.iotdb.confignode.client.CnToCnNodeRequestType;
import org.apache.iotdb.confignode.client.async.CnToDnAsyncRequestType;
import
org.apache.iotdb.confignode.client.async.CnToDnInternalServiceAsyncRequestManager;
+import org.apache.iotdb.confignode.client.async.DataNodeTransportFailureUtils;
import
org.apache.iotdb.confignode.client.async.handlers.DataNodeAsyncRequestContext;
import org.apache.iotdb.confignode.client.sync.SyncConfigNodeClientPool;
import
org.apache.iotdb.confignode.consensus.request.write.confignode.RemoveConfigNodePlan;
@@ -1099,11 +1100,12 @@ public class ConfigNodeProcedureEnv {
.putIfAbsent(
dataNodeId,
new TPushPipeMetaResp(
- createMetadataTimeoutStatus(
- clientHandler.getRequestType(),
- dataNodeId,
- TSStatusCode.PIPE_PUSH_META_ERROR,
- timeoutInMs))));
+ DataNodeTransportFailureUtils.markTransportFailure(
+ createMetadataTimeoutStatus(
+ clientHandler.getRequestType(),
+ dataNodeId,
+ TSStatusCode.PIPE_PUSH_META_ERROR,
+ timeoutInMs)))));
}
private static void fillMissingTopicPushMetaResponses(
@@ -1137,11 +1139,12 @@ public class ConfigNodeProcedureEnv {
.putIfAbsent(
dataNodeId,
new TPushConsumerGroupMetaResp(
- createMetadataTimeoutStatus(
- clientHandler.getRequestType(),
- dataNodeId,
- TSStatusCode.CONSUMER_PUSH_META_ERROR,
- timeoutInMs))));
+ DataNodeTransportFailureUtils.markTransportFailure(
+ createMetadataTimeoutStatus(
+ clientHandler.getRequestType(),
+ dataNodeId,
+ TSStatusCode.CONSUMER_PUSH_META_ERROR,
+ timeoutInMs)))));
}
private static void fillMissingPullCommitProgressResponses(
diff --git
a/iotdb-core/confignode/src/main/java/org/apache/iotdb/confignode/procedure/impl/subscription/AbstractOperateSubscriptionProcedure.java
b/iotdb-core/confignode/src/main/java/org/apache/iotdb/confignode/procedure/impl/subscription/AbstractOperateSubscriptionProcedure.java
index 579ddd5aafb..258e68be341 100644
---
a/iotdb-core/confignode/src/main/java/org/apache/iotdb/confignode/procedure/impl/subscription/AbstractOperateSubscriptionProcedure.java
+++
b/iotdb-core/confignode/src/main/java/org/apache/iotdb/confignode/procedure/impl/subscription/AbstractOperateSubscriptionProcedure.java
@@ -19,8 +19,10 @@
package org.apache.iotdb.confignode.procedure.impl.subscription;
+import org.apache.iotdb.common.rpc.thrift.TSStatus;
import org.apache.iotdb.commons.subscription.meta.consumer.ConsumerGroupMeta;
import org.apache.iotdb.commons.subscription.meta.topic.TopicMeta;
+import org.apache.iotdb.confignode.client.async.DataNodeTransportFailureUtils;
import org.apache.iotdb.confignode.i18n.ProcedureMessages;
import org.apache.iotdb.confignode.persistence.subscription.SubscriptionInfo;
import org.apache.iotdb.confignode.procedure.env.ConfigNodeProcedureEnv;
@@ -333,6 +335,18 @@ public abstract class AbstractOperateSubscriptionProcedure
protected abstract void
rollbackFromOperateOnDataNodes(ConfigNodeProcedureEnv env)
throws SubscriptionException, IOException;
+ protected static boolean isOfflineDataNodeTransportFailure(
+ final ConfigNodeProcedureEnv env,
+ final int dataNodeId,
+ final TSStatus status,
+ final int metadataPushErrorCode,
+ final boolean hasExceptionMessages) {
+ return status.getCode() == metadataPushErrorCode
+ && DataNodeTransportFailureUtils.isTransportFailure(status)
+ && !hasExceptionMessages
+ &&
env.getConfigManager().getLoadManager().getNodeStatus(dataNodeId).isOffline();
+ }
+
/**
* Pushing all the topicMeta's to all the dataNodes.
*
diff --git
a/iotdb-core/confignode/src/main/java/org/apache/iotdb/confignode/procedure/impl/subscription/consumer/AlterConsumerGroupProcedure.java
b/iotdb-core/confignode/src/main/java/org/apache/iotdb/confignode/procedure/impl/subscription/consumer/AlterConsumerGroupProcedure.java
index 7222b1963be..330f8010637 100644
---
a/iotdb-core/confignode/src/main/java/org/apache/iotdb/confignode/procedure/impl/subscription/consumer/AlterConsumerGroupProcedure.java
+++
b/iotdb-core/confignode/src/main/java/org/apache/iotdb/confignode/procedure/impl/subscription/consumer/AlterConsumerGroupProcedure.java
@@ -127,6 +127,17 @@ public class AlterConsumerGroupProcedure extends
AbstractOperateSubscriptionProc
@Override
public void executeFromOperateOnDataNodes(ConfigNodeProcedureEnv env)
throws SubscriptionException, IOException {
+ executeFromOperateOnDataNodes(env, false);
+ }
+
+ public void
executeFromOperateOnDataNodesForUnsubscribe(ConfigNodeProcedureEnv env)
+ throws SubscriptionException, IOException {
+ executeFromOperateOnDataNodes(env, true);
+ }
+
+ private void executeFromOperateOnDataNodes(
+ ConfigNodeProcedureEnv env, boolean
ignoreOfflineDataNodeTransportFailures)
+ throws SubscriptionException, IOException {
LOGGER.info(
ProcedureMessages.ALTERCONSUMERGROUPPROCEDURE_EXECUTEFROMOPERATEONDATANODES,
updatedConsumerGroupMeta.getConsumerGroupId());
@@ -138,7 +149,19 @@ public class AlterConsumerGroupProcedure extends
AbstractOperateSubscriptionProc
.getSubscriptionReadyDataNodeTracker()
.recordSinglePush(existingConsumerGroupMeta, updatedConsumerGroupMeta,
responseMap);
final List<TSStatus> statuses =
-
responseMap.values().stream().map(TPushConsumerGroupMetaResp::getStatus).toList();
+ responseMap.entrySet().stream()
+ .filter(
+ entry ->
+ !ignoreOfflineDataNodeTransportFailures
+ || !isOfflineDataNodeTransportFailure(
+ env,
+ entry.getKey(),
+ entry.getValue().getStatus(),
+
TSStatusCode.CONSUMER_PUSH_META_ERROR.getStatusCode(),
+ entry.getValue().isSetExceptionMessages()
+ &&
!entry.getValue().getExceptionMessages().isEmpty()))
+ .map(entry -> entry.getValue().getStatus())
+ .toList();
if (RpcUtils.squashResponseStatusList(statuses).getCode()
!= TSStatusCode.SUCCESS_STATUS.getStatusCode()) {
// throw exception instead of logging warn, do not rely on metadata
synchronization
@@ -188,6 +211,17 @@ public class AlterConsumerGroupProcedure extends
AbstractOperateSubscriptionProc
@Override
public void rollbackFromOperateOnDataNodes(ConfigNodeProcedureEnv env)
throws SubscriptionException, IOException {
+ rollbackFromOperateOnDataNodes(env, false);
+ }
+
+ public void
rollbackFromOperateOnDataNodesForUnsubscribe(ConfigNodeProcedureEnv env)
+ throws SubscriptionException, IOException {
+ rollbackFromOperateOnDataNodes(env, true);
+ }
+
+ private void rollbackFromOperateOnDataNodes(
+ ConfigNodeProcedureEnv env, boolean
ignoreOfflineDataNodeTransportFailures)
+ throws SubscriptionException, IOException {
LOGGER.info(ProcedureMessages.ALTERCONSUMERGROUPPROCEDURE_ROLLBACKFROMOPERATEONDATANODES);
final Map<Integer, TPushConsumerGroupMetaResp> responseMap =
@@ -197,7 +231,19 @@ public class AlterConsumerGroupProcedure extends
AbstractOperateSubscriptionProc
.getSubscriptionReadyDataNodeTracker()
.recordSinglePush(updatedConsumerGroupMeta, existingConsumerGroupMeta,
responseMap);
final List<TSStatus> statuses =
-
responseMap.values().stream().map(TPushConsumerGroupMetaResp::getStatus).toList();
+ responseMap.entrySet().stream()
+ .filter(
+ entry ->
+ !ignoreOfflineDataNodeTransportFailures
+ || !isOfflineDataNodeTransportFailure(
+ env,
+ entry.getKey(),
+ entry.getValue().getStatus(),
+
TSStatusCode.CONSUMER_PUSH_META_ERROR.getStatusCode(),
+ entry.getValue().isSetExceptionMessages()
+ &&
!entry.getValue().getExceptionMessages().isEmpty()))
+ .map(entry -> entry.getValue().getStatus())
+ .toList();
if (RpcUtils.squashResponseStatusList(statuses).getCode()
!= TSStatusCode.SUCCESS_STATUS.getStatusCode()) {
// throw exception instead of logging warn, do not rely on metadata
synchronization
diff --git
a/iotdb-core/confignode/src/main/java/org/apache/iotdb/confignode/procedure/impl/subscription/subscription/DropSubscriptionProcedure.java
b/iotdb-core/confignode/src/main/java/org/apache/iotdb/confignode/procedure/impl/subscription/subscription/DropSubscriptionProcedure.java
index f2ff6b7301b..cdb731e1bfa 100644
---
a/iotdb-core/confignode/src/main/java/org/apache/iotdb/confignode/procedure/impl/subscription/subscription/DropSubscriptionProcedure.java
+++
b/iotdb-core/confignode/src/main/java/org/apache/iotdb/confignode/procedure/impl/subscription/subscription/DropSubscriptionProcedure.java
@@ -38,6 +38,7 @@ import
org.apache.iotdb.confignode.procedure.impl.subscription.topic.AlterTopicP
import org.apache.iotdb.confignode.procedure.store.ProcedureType;
import org.apache.iotdb.confignode.rpc.thrift.TUnsubscribeReq;
import org.apache.iotdb.consensus.exception.ConsensusException;
+import org.apache.iotdb.mpp.rpc.thrift.TPushPipeMetaResp;
import org.apache.iotdb.rpc.TSStatusCode;
import org.apache.iotdb.rpc.subscription.exception.SubscriptionException;
@@ -49,8 +50,10 @@ import java.io.DataOutputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.util.ArrayList;
+import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
+import java.util.Map;
import java.util.Objects;
import java.util.Set;
import java.util.stream.Collectors;
@@ -190,9 +193,23 @@ public class DropSubscriptionProcedure extends
AbstractOperateSubscriptionAndPip
if (!dropPipeProcedures.isEmpty()) {
// An empty Pipe metadata batch triggers full reconciliation and drops
every local Pipe.
+ final Map<Integer, TPushPipeMetaResp> responseMap =
+ dropMultiPipeOnDataNodes(dropPipeProcedures, env);
+ final Map<Integer, TPushPipeMetaResp> responseMapToCheck = new
HashMap<>(responseMap);
+ responseMapToCheck
+ .entrySet()
+ .removeIf(
+ entry ->
+ isOfflineDataNodeTransportFailure(
+ env,
+ entry.getKey(),
+ entry.getValue().getStatus(),
+ TSStatusCode.PIPE_PUSH_META_ERROR.getStatusCode(),
+ entry.getValue().isSetExceptionMessages()
+ &&
!entry.getValue().getExceptionMessages().isEmpty()));
final String exceptionMessage =
AbstractOperatePipeProcedureV2.parsePushPipeMetaExceptionForPipe(
- null, dropMultiPipeOnDataNodes(dropPipeProcedures, env));
+ null, responseMapToCheck);
if (!exceptionMessage.isEmpty()) {
// throw exception instead of logging warn, do not rely on metadata
synchronization
throw new SubscriptionException(
@@ -208,7 +225,7 @@ public class DropSubscriptionProcedure extends
AbstractOperateSubscriptionAndPip
}
// Push consumer group meta to data nodes
- alterConsumerGroupProcedure.executeFromOperateOnDataNodes(env);
+
alterConsumerGroupProcedure.executeFromOperateOnDataNodesForUnsubscribe(env);
}
@Override
@@ -233,7 +250,7 @@ public class DropSubscriptionProcedure extends
AbstractOperateSubscriptionAndPip
LOGGER.info(ProcedureMessages.DROPSUBSCRIPTIONPROCEDURE_ROLLBACKFROMOPERATEONDATANODES);
// Rollback AlterConsumerGroupProcedure
- alterConsumerGroupProcedure.rollbackFromOperateOnDataNodes(env);
+
alterConsumerGroupProcedure.rollbackFromOperateOnDataNodesForUnsubscribe(env);
// Do nothing to rollback DropPipeProcedureV2s
}
diff --git
a/iotdb-core/confignode/src/test/java/org/apache/iotdb/confignode/procedure/env/ConfigNodeProcedureEnvTest.java
b/iotdb-core/confignode/src/test/java/org/apache/iotdb/confignode/procedure/env/ConfigNodeProcedureEnvTest.java
index 7691eb45848..1d9a6ea7632 100644
---
a/iotdb-core/confignode/src/test/java/org/apache/iotdb/confignode/procedure/env/ConfigNodeProcedureEnvTest.java
+++
b/iotdb-core/confignode/src/test/java/org/apache/iotdb/confignode/procedure/env/ConfigNodeProcedureEnvTest.java
@@ -19,15 +19,26 @@
package org.apache.iotdb.confignode.procedure.env;
+import org.apache.iotdb.common.rpc.thrift.TDataNodeLocation;
+import org.apache.iotdb.common.rpc.thrift.TSStatus;
import org.apache.iotdb.commons.cluster.NodeStatus;
+import org.apache.iotdb.confignode.client.async.CnToDnAsyncRequestType;
+import org.apache.iotdb.confignode.client.async.DataNodeTransportFailureUtils;
+import
org.apache.iotdb.confignode.client.async.handlers.DataNodeAsyncRequestContext;
import org.apache.iotdb.confignode.manager.ConfigManager;
import org.apache.iotdb.confignode.manager.load.LoadManager;
import org.apache.iotdb.confignode.procedure.scheduler.ProcedureScheduler;
+import org.apache.iotdb.mpp.rpc.thrift.TPushConsumerGroupMetaResp;
+import org.apache.iotdb.mpp.rpc.thrift.TPushPipeMetaResp;
+import org.apache.iotdb.rpc.TSStatusCode;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
+import java.lang.reflect.Method;
+import java.util.Map;
+
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
@@ -90,4 +101,52 @@ public class ConfigNodeProcedureEnvTest {
Assert.assertFalse(env.isRuntimeActiveWriterNode(-1));
}
+
+ @Test
+ public void testMissingPipeResponsesAreMarkedAsTransportTimeouts() throws
Exception {
+ final DataNodeAsyncRequestContext<Object, TPushPipeMetaResp> context =
+ new DataNodeAsyncRequestContext<>(
+ CnToDnAsyncRequestType.PIPE_PUSH_MULTI_META,
+ Map.of(1, new TDataNodeLocation(), 2, new TDataNodeLocation()));
+ final TPushPipeMetaResp rejected =
+ new TPushPipeMetaResp(new
TSStatus(TSStatusCode.PIPE_PUSH_META_ERROR.getStatusCode()));
+ context.getResponseMap().put(2, rejected);
+
+ fillMissingResponses("fillMissingPipePushMetaResponses", context);
+
+ Assert.assertTrue(
+ DataNodeTransportFailureUtils.isTransportFailure(
+ context.getResponseMap().get(1).getStatus()));
+ Assert.assertSame(rejected, context.getResponseMap().get(2));
+
Assert.assertFalse(DataNodeTransportFailureUtils.isTransportFailure(rejected.getStatus()));
+ }
+
+ @Test
+ public void testMissingConsumerGroupResponsesAreMarkedAsTransportTimeouts()
throws Exception {
+ final DataNodeAsyncRequestContext<Object, TPushConsumerGroupMetaResp>
context =
+ new DataNodeAsyncRequestContext<>(
+ CnToDnAsyncRequestType.CONSUMER_GROUP_PUSH_SINGLE_META,
+ Map.of(1, new TDataNodeLocation(), 2, new TDataNodeLocation()));
+ final TPushConsumerGroupMetaResp rejected =
+ new TPushConsumerGroupMetaResp(
+ new
TSStatus(TSStatusCode.CONSUMER_PUSH_META_ERROR.getStatusCode()));
+ context.getResponseMap().put(2, rejected);
+
+ fillMissingResponses("fillMissingConsumerGroupPushMetaResponses", context);
+
+ Assert.assertTrue(
+ DataNodeTransportFailureUtils.isTransportFailure(
+ context.getResponseMap().get(1).getStatus()));
+ Assert.assertSame(rejected, context.getResponseMap().get(2));
+
Assert.assertFalse(DataNodeTransportFailureUtils.isTransportFailure(rejected.getStatus()));
+ }
+
+ private static void fillMissingResponses(
+ final String methodName, final DataNodeAsyncRequestContext<?, ?>
context) throws Exception {
+ final Method method =
+ ConfigNodeProcedureEnv.class.getDeclaredMethod(
+ methodName, DataNodeAsyncRequestContext.class, long.class);
+ method.setAccessible(true);
+ method.invoke(null, context, 1L);
+ }
}
diff --git
a/iotdb-core/confignode/src/test/java/org/apache/iotdb/confignode/procedure/impl/subscription/subscription/DropSubscriptionProcedureTest.java
b/iotdb-core/confignode/src/test/java/org/apache/iotdb/confignode/procedure/impl/subscription/subscription/DropSubscriptionProcedureTest.java
index 3dea42d1e82..aec605b6532 100644
---
a/iotdb-core/confignode/src/test/java/org/apache/iotdb/confignode/procedure/impl/subscription/subscription/DropSubscriptionProcedureTest.java
+++
b/iotdb-core/confignode/src/test/java/org/apache/iotdb/confignode/procedure/impl/subscription/subscription/DropSubscriptionProcedureTest.java
@@ -19,12 +19,21 @@
package org.apache.iotdb.confignode.procedure.impl.subscription.subscription;
+import org.apache.iotdb.common.rpc.thrift.TDataNodeLocation;
import org.apache.iotdb.common.rpc.thrift.TSStatus;
+import org.apache.iotdb.commons.cluster.NodeStatus;
import org.apache.iotdb.commons.subscription.meta.consumer.ConsumerGroupMeta;
import org.apache.iotdb.commons.subscription.meta.consumer.ConsumerMeta;
import org.apache.iotdb.commons.subscription.meta.topic.TopicMeta;
+import org.apache.iotdb.confignode.client.async.CnToDnAsyncRequestType;
+import org.apache.iotdb.confignode.client.async.DataNodeTransportFailureUtils;
+import
org.apache.iotdb.confignode.client.async.handlers.rpc.PipePushMetaRPCHandler;
+import
org.apache.iotdb.confignode.client.async.handlers.rpc.subscription.ConsumerGroupPushMetaRPCHandler;
import org.apache.iotdb.confignode.manager.ConfigManager;
import org.apache.iotdb.confignode.manager.consensus.ConsensusManager;
+import org.apache.iotdb.confignode.manager.load.LoadManager;
+import org.apache.iotdb.confignode.manager.subscription.SubscriptionManager;
+import
org.apache.iotdb.confignode.manager.subscription.SubscriptionReadyDataNodeTracker;
import org.apache.iotdb.confignode.persistence.pipe.PipeTaskInfo;
import org.apache.iotdb.confignode.persistence.subscription.SubscriptionInfo;
import org.apache.iotdb.confignode.procedure.env.ConfigNodeProcedureEnv;
@@ -32,10 +41,17 @@ import
org.apache.iotdb.confignode.procedure.impl.pipe.task.DropPipeProcedureV2;
import
org.apache.iotdb.confignode.procedure.impl.subscription.consumer.AlterConsumerGroupProcedure;
import org.apache.iotdb.confignode.procedure.store.ProcedureFactory;
import org.apache.iotdb.confignode.rpc.thrift.TUnsubscribeReq;
+import org.apache.iotdb.mpp.rpc.thrift.TPushConsumerGroupMetaResp;
+import
org.apache.iotdb.mpp.rpc.thrift.TPushConsumerGroupMetaRespExceptionMessage;
+import org.apache.iotdb.mpp.rpc.thrift.TPushPipeMetaResp;
+import org.apache.iotdb.mpp.rpc.thrift.TPushPipeMetaRespExceptionMessage;
import org.apache.iotdb.rpc.TSStatusCode;
import org.apache.iotdb.rpc.subscription.config.TopicConstant;
import org.apache.iotdb.rpc.subscription.exception.SubscriptionException;
+import org.apache.thrift.TApplicationException;
+import org.apache.thrift.protocol.TProtocolException;
+import org.apache.thrift.transport.TTransportException;
import org.apache.tsfile.utils.PublicBAOS;
import org.junit.Assert;
import org.junit.Test;
@@ -43,6 +59,8 @@ import org.mockito.Mockito;
import java.io.DataOutputStream;
import java.lang.reflect.Field;
+import java.net.ConnectException;
+import java.net.SocketTimeoutException;
import java.nio.ByteBuffer;
import java.util.ArrayList;
import java.util.Collections;
@@ -51,12 +69,97 @@ import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeoutException;
import java.util.concurrent.atomic.AtomicReference;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.fail;
public class DropSubscriptionProcedureTest {
+ @Test
+ public void transportFailureClassificationShouldUseExceptionTypes() {
+ Assert.assertTrue(
+ DataNodeTransportFailureUtils.isTransportException(
+ new TTransportException("connection refused")));
+ Assert.assertTrue(
+ DataNodeTransportFailureUtils.isTransportException(new
ConnectException("connection")));
+ Assert.assertTrue(
+ DataNodeTransportFailureUtils.isTransportException(new
TimeoutException("timeout")));
+ Assert.assertTrue(
+ DataNodeTransportFailureUtils.isTransportException(new
SocketTimeoutException("timeout")));
+ Assert.assertTrue(
+ DataNodeTransportFailureUtils.isTransportException(
+ new RuntimeException(new TimeoutException("timeout"))));
+ Assert.assertFalse(
+ DataNodeTransportFailureUtils.isTransportException(
+ new IllegalStateException("local failure")));
+ Assert.assertFalse(
+ DataNodeTransportFailureUtils.isTransportException(
+ new TApplicationException("remote application failure")));
+ Assert.assertFalse(
+ DataNodeTransportFailureUtils.isTransportException(
+ new TProtocolException("invalid reply")));
+ Assert.assertFalse(
+ DataNodeTransportFailureUtils.isTransportException(
+ new TTransportException(TTransportException.CORRUPTED_DATA,
"invalid frame")));
+ }
+
+ @Test
+ public void metadataRpcHandlersShouldMarkOnlyTransportFailures() {
+ final TDataNodeLocation target = new TDataNodeLocation().setDataNodeId(1);
+ final Map<Integer, TDataNodeLocation> targetMap =
Collections.singletonMap(1, target);
+ for (final Exception exception :
+ new Exception[] {
+ new ConnectException("connection refused"),
+ new TimeoutException("request timed out"),
+ new TTransportException(TTransportException.END_OF_FILE, "connection
closed"),
+ new IllegalStateException("local dispatch failure"),
+ new TApplicationException("remote application failure"),
+ new TProtocolException("invalid reply"),
+ new TTransportException(TTransportException.CORRUPTED_DATA, "invalid
frame")
+ }) {
+ final Map<Integer, TPushPipeMetaResp> pipeResponses = new HashMap<>();
+ new PipePushMetaRPCHandler(
+ CnToDnAsyncRequestType.PIPE_PUSH_MULTI_META,
+ 1,
+ target,
+ targetMap,
+ pipeResponses,
+ new CountDownLatch(1))
+ .onError(exception);
+ final boolean expectedTransportFailure =
+ exception instanceof ConnectException
+ || exception instanceof TimeoutException
+ || (exception instanceof TTransportException
+ && ((TTransportException) exception).getType()
+ == TTransportException.END_OF_FILE);
+ assertEquals(
+ expectedTransportFailure,
+
DataNodeTransportFailureUtils.isTransportFailure(pipeResponses.get(1).getStatus()));
+ assertEquals(
+ TSStatusCode.PIPE_PUSH_META_ERROR.getStatusCode(),
+ pipeResponses.get(1).getStatus().getCode());
+
+ final Map<Integer, TPushConsumerGroupMetaResp> consumerGroupResponses =
new HashMap<>();
+ new ConsumerGroupPushMetaRPCHandler(
+ CnToDnAsyncRequestType.CONSUMER_GROUP_PUSH_SINGLE_META,
+ 1,
+ target,
+ targetMap,
+ consumerGroupResponses,
+ new CountDownLatch(1))
+ .onError(exception);
+ assertEquals(
+ expectedTransportFailure,
+ DataNodeTransportFailureUtils.isTransportFailure(
+ consumerGroupResponses.get(1).getStatus()));
+ assertEquals(
+ TSStatusCode.CONSUMER_PUSH_META_ERROR.getStatusCode(),
+ consumerGroupResponses.get(1).getStatus().getCode());
+ }
+ }
+
@Test
public void serializeDeserializeTest() {
PublicBAOS byteArrayOutputStream = new PublicBAOS();
@@ -146,7 +249,263 @@ public class DropSubscriptionProcedureTest {
Mockito.verify(env,
Mockito.never()).pushMultiPipeMetaToDataNodes(Mockito.anyList());
Mockito.verify(env,
Mockito.never()).dropMultiPipeOnDataNodes(Mockito.anyList());
-
Mockito.verify(alterConsumerGroupProcedure).executeFromOperateOnDataNodes(env);
+
Mockito.verify(alterConsumerGroupProcedure).executeFromOperateOnDataNodesForUnsubscribe(env);
+ }
+
+ @Test
+ public void
executeFromOperateOnDataNodesShouldIgnoreOfflinePipeTransportFailure()
+ throws Exception {
+ final DropSubscriptionProcedure procedure = new
DropSubscriptionProcedure();
+ final AlterConsumerGroupProcedure alterConsumerGroupProcedure =
+ Mockito.mock(AlterConsumerGroupProcedure.class);
+ procedure.setAlterConsumerGroupProcedure(alterConsumerGroupProcedure);
+
procedure.setDropPipeProcedures(Collections.singletonList(mockDropPipeProcedure("pipe")));
+
+ final ConfigNodeProcedureEnv env =
mockEnvWithNodeStatus(NodeStatus.Unknown);
+ Mockito.when(env.dropMultiPipeOnDataNodes(Mockito.anyList()))
+ .thenReturn(
+ Collections.singletonMap(
+ 1,
+ new TPushPipeMetaResp(
+ transportFailureStatus(
+ TSStatusCode.PIPE_PUSH_META_ERROR.getStatusCode(),
"Connection refused"))));
+
+ procedure.executeFromOperateOnDataNodes(env);
+
+
Mockito.verify(alterConsumerGroupProcedure).executeFromOperateOnDataNodesForUnsubscribe(env);
+ }
+
+ @Test
+ public void
executeFromOperateOnDataNodesShouldNotIgnoreOfflineUnmarkedError() throws
Exception {
+ final DropSubscriptionProcedure procedure = new
DropSubscriptionProcedure();
+
procedure.setAlterConsumerGroupProcedure(Mockito.mock(AlterConsumerGroupProcedure.class));
+
procedure.setDropPipeProcedures(Collections.singletonList(mockDropPipeProcedure("pipe")));
+
+ final ConfigNodeProcedureEnv env =
mockEnvWithNodeStatus(NodeStatus.Unknown);
+ Mockito.when(env.dropMultiPipeOnDataNodes(Mockito.anyList()))
+ .thenReturn(
+ Collections.singletonMap(
+ 1,
+ new TPushPipeMetaResp(
+ new
TSStatus(TSStatusCode.PIPE_PUSH_META_ERROR.getStatusCode())
+ .setMessage("local dispatch failure"))));
+
+ try {
+ procedure.executeFromOperateOnDataNodes(env);
+ fail("Expected an unmarked request failure to fail the unsubscribe");
+ } catch (SubscriptionException e) {
+ Assert.assertTrue(e.getMessage().contains("local dispatch failure"));
+ }
+ }
+
+ @Test
+ public void
executeFromOperateOnDataNodesShouldNotIgnoreOfflinePipeMetaRejection()
+ throws Exception {
+ final DropSubscriptionProcedure procedure = new
DropSubscriptionProcedure();
+ final AlterConsumerGroupProcedure alterConsumerGroupProcedure =
+ Mockito.mock(AlterConsumerGroupProcedure.class);
+ procedure.setAlterConsumerGroupProcedure(alterConsumerGroupProcedure);
+
procedure.setDropPipeProcedures(Collections.singletonList(mockDropPipeProcedure("pipe")));
+
+ final ConfigNodeProcedureEnv env =
mockEnvWithNodeStatus(NodeStatus.Unknown);
+ Mockito.when(env.dropMultiPipeOnDataNodes(Mockito.anyList()))
+ .thenReturn(
+ Collections.singletonMap(
+ 1,
+ new TPushPipeMetaResp(
+ new
TSStatus(TSStatusCode.PIPE_PUSH_META_ERROR.getStatusCode()))
+ .setExceptionMessages(
+ Collections.singletonList(
+ new TPushPipeMetaRespExceptionMessage(
+ "pipe", "metadata rejected",
System.currentTimeMillis())))));
+
+ try {
+ procedure.executeFromOperateOnDataNodes(env);
+ fail("Expected the DataNode's metadata rejection to fail the
unsubscribe");
+ } catch (SubscriptionException e) {
+ Assert.assertTrue(e.getMessage().contains("metadata rejected"));
+ }
+
+ Mockito.verify(alterConsumerGroupProcedure, Mockito.never())
+ .executeFromOperateOnDataNodesForUnsubscribe(Mockito.any());
+ }
+
+ @Test
+ public void
executeFromOperateOnDataNodesShouldNotIgnoreOnlinePipeTransportFailure()
+ throws Exception {
+ final DropSubscriptionProcedure procedure = new
DropSubscriptionProcedure();
+ final AlterConsumerGroupProcedure alterConsumerGroupProcedure =
+ Mockito.mock(AlterConsumerGroupProcedure.class);
+ procedure.setAlterConsumerGroupProcedure(alterConsumerGroupProcedure);
+
procedure.setDropPipeProcedures(Collections.singletonList(mockDropPipeProcedure("pipe")));
+
+ final ConfigNodeProcedureEnv env =
mockEnvWithNodeStatus(NodeStatus.Running);
+ Mockito.when(env.dropMultiPipeOnDataNodes(Mockito.anyList()))
+ .thenReturn(
+ Collections.singletonMap(
+ 1,
+ new TPushPipeMetaResp(
+ transportFailureStatus(
+ TSStatusCode.PIPE_PUSH_META_ERROR.getStatusCode(),
"Connection refused"))));
+
+ try {
+ procedure.executeFromOperateOnDataNodes(env);
+ fail("Expected a transport failure from an online DataNode to fail the
unsubscribe");
+ } catch (SubscriptionException e) {
+ Assert.assertTrue(e.getMessage().contains("Connection refused"));
+ }
+
+ Mockito.verify(alterConsumerGroupProcedure, Mockito.never())
+ .executeFromOperateOnDataNodesForUnsubscribe(Mockito.any());
+ }
+
+ @Test
+ public void
alterConsumerGroupShouldIgnoreOfflineTransportFailureWhenUnsubscribing()
+ throws Exception {
+ final ConsumerGroupMeta existingMeta =
+ new ConsumerGroupMeta("group", 1, new ConsumerMeta("consumer", 1,
Collections.emptyMap()));
+ existingMeta.addSubscription("consumer", Collections.singleton("topic"));
+ final ConsumerGroupMeta updatedMeta = existingMeta.deepCopy();
+ updatedMeta.removeSubscription("consumer", Collections.singleton("topic"));
+ final AlterConsumerGroupProcedure procedure = new
AlterConsumerGroupProcedure();
+ procedure.setExistingConsumerGroupMeta(existingMeta);
+ procedure.setUpdatedConsumerGroupMeta(updatedMeta);
+
+ final ConfigNodeProcedureEnv env =
mockEnvWithNodeStatus(NodeStatus.Unknown);
+ final ConfigManager configManager = env.getConfigManager();
+ final SubscriptionManager subscriptionManager =
Mockito.mock(SubscriptionManager.class);
+ final SubscriptionReadyDataNodeTracker readyDataNodeTracker =
+ new SubscriptionReadyDataNodeTracker();
+
Mockito.when(configManager.getSubscriptionManager()).thenReturn(subscriptionManager);
+ Mockito.when(subscriptionManager.getSubscriptionReadyDataNodeTracker())
+ .thenReturn(readyDataNodeTracker);
+ readyDataNodeTracker.replaceFromFullPush(
+ Collections.singletonList(existingMeta),
+ Collections.singletonMap(
+ 1,
+ new TPushConsumerGroupMetaResp(
+ new TSStatus(TSStatusCode.SUCCESS_STATUS.getStatusCode()))));
+
Mockito.when(env.pushSingleConsumerGroupOnDataNode(Mockito.any(ByteBuffer.class)))
+ .thenReturn(
+ Collections.singletonMap(
+ 1,
+ new TPushConsumerGroupMetaResp(
+ transportFailureStatus(
+ TSStatusCode.CONSUMER_PUSH_META_ERROR.getStatusCode(),
+ "Connection refused"))));
+
+ procedure.executeFromOperateOnDataNodesForUnsubscribe(env);
+ procedure.rollbackFromOperateOnDataNodesForUnsubscribe(env);
+
+ assertEquals(
+ Collections.emptyList(),
+ readyDataNodeTracker.getReadyDataNodeIds(
+ "topic", "group", existingMeta.visibleUnder(true),
Collections.singleton(1)));
+ }
+
+ @Test
+ public void
alterConsumerGroupShouldNotIgnoreOfflineUnmarkedErrorWhenUnsubscribing()
+ throws Exception {
+ final ConsumerGroupMeta existingMeta =
+ new ConsumerGroupMeta("group", 1, new ConsumerMeta("consumer", 1,
Collections.emptyMap()));
+ final AlterConsumerGroupProcedure procedure = new
AlterConsumerGroupProcedure();
+ procedure.setExistingConsumerGroupMeta(existingMeta);
+ procedure.setUpdatedConsumerGroupMeta(existingMeta.deepCopy());
+
+ final ConfigNodeProcedureEnv env =
mockEnvWithNodeStatus(NodeStatus.Unknown);
+ final SubscriptionManager subscriptionManager =
Mockito.mock(SubscriptionManager.class);
+
Mockito.when(env.getConfigManager().getSubscriptionManager()).thenReturn(subscriptionManager);
+ Mockito.when(subscriptionManager.getSubscriptionReadyDataNodeTracker())
+ .thenReturn(Mockito.mock(SubscriptionReadyDataNodeTracker.class));
+
Mockito.when(env.pushSingleConsumerGroupOnDataNode(Mockito.any(ByteBuffer.class)))
+ .thenReturn(
+ Collections.singletonMap(
+ 1,
+ new TPushConsumerGroupMetaResp(
+ new
TSStatus(TSStatusCode.CONSUMER_PUSH_META_ERROR.getStatusCode())
+ .setMessage("local dispatch failure"))));
+
+ try {
+ procedure.executeFromOperateOnDataNodesForUnsubscribe(env);
+ fail("Expected an unmarked request failure to fail the consumer group
update");
+ } catch (SubscriptionException e) {
+ Assert.assertTrue(e.getMessage().contains("local dispatch failure"));
+ }
+ Assert.assertThrows(
+ SubscriptionException.class,
+ () -> procedure.rollbackFromOperateOnDataNodesForUnsubscribe(env));
+ }
+
+ @Test
+ public void
alterConsumerGroupShouldNotIgnoreOnlineTransportFailureWhenUnsubscribing()
+ throws Exception {
+ final ConsumerGroupMeta existingMeta =
+ new ConsumerGroupMeta("group", 1, new ConsumerMeta("consumer", 1,
Collections.emptyMap()));
+ final AlterConsumerGroupProcedure procedure = new
AlterConsumerGroupProcedure();
+ procedure.setExistingConsumerGroupMeta(existingMeta);
+ procedure.setUpdatedConsumerGroupMeta(existingMeta.deepCopy());
+
+ final ConfigNodeProcedureEnv env =
mockEnvWithNodeStatus(NodeStatus.Running);
+ final SubscriptionManager subscriptionManager =
Mockito.mock(SubscriptionManager.class);
+
Mockito.when(env.getConfigManager().getSubscriptionManager()).thenReturn(subscriptionManager);
+ Mockito.when(subscriptionManager.getSubscriptionReadyDataNodeTracker())
+ .thenReturn(Mockito.mock(SubscriptionReadyDataNodeTracker.class));
+
Mockito.when(env.pushSingleConsumerGroupOnDataNode(Mockito.any(ByteBuffer.class)))
+ .thenReturn(
+ Collections.singletonMap(
+ 1,
+ new TPushConsumerGroupMetaResp(
+ transportFailureStatus(
+ TSStatusCode.CONSUMER_PUSH_META_ERROR.getStatusCode(),
+ "Connection refused"))));
+
+ try {
+ procedure.executeFromOperateOnDataNodesForUnsubscribe(env);
+ fail("Expected a transport failure from an online DataNode to fail the
update");
+ } catch (SubscriptionException e) {
+ Assert.assertTrue(e.getMessage().contains("Connection refused"));
+ }
+ Assert.assertThrows(
+ SubscriptionException.class,
+ () -> procedure.rollbackFromOperateOnDataNodesForUnsubscribe(env));
+ }
+
+ @Test
+ public void
alterConsumerGroupShouldNotIgnoreOfflineMetadataRejectionWhenUnsubscribing()
+ throws Exception {
+ final ConsumerGroupMeta existingMeta =
+ new ConsumerGroupMeta("group", 1, new ConsumerMeta("consumer", 1,
Collections.emptyMap()));
+ final ConsumerGroupMeta updatedMeta = existingMeta.deepCopy();
+ final AlterConsumerGroupProcedure procedure = new
AlterConsumerGroupProcedure();
+ procedure.setExistingConsumerGroupMeta(existingMeta);
+ procedure.setUpdatedConsumerGroupMeta(updatedMeta);
+
+ final ConfigNodeProcedureEnv env =
mockEnvWithNodeStatus(NodeStatus.Unknown);
+ final ConfigManager configManager = env.getConfigManager();
+ final SubscriptionManager subscriptionManager =
Mockito.mock(SubscriptionManager.class);
+
Mockito.when(configManager.getSubscriptionManager()).thenReturn(subscriptionManager);
+ Mockito.when(subscriptionManager.getSubscriptionReadyDataNodeTracker())
+ .thenReturn(Mockito.mock(SubscriptionReadyDataNodeTracker.class));
+
Mockito.when(env.pushSingleConsumerGroupOnDataNode(Mockito.any(ByteBuffer.class)))
+ .thenReturn(
+ Collections.singletonMap(
+ 1,
+ new TPushConsumerGroupMetaResp(
+ new
TSStatus(TSStatusCode.CONSUMER_PUSH_META_ERROR.getStatusCode()))
+ .setExceptionMessages(
+ Collections.singletonList(
+ new TPushConsumerGroupMetaRespExceptionMessage(
+ "group", "metadata rejected",
System.currentTimeMillis())))));
+
+ try {
+ procedure.executeFromOperateOnDataNodesForUnsubscribe(env);
+ fail("Expected the DataNode's metadata rejection to fail the consumer
group update");
+ } catch (SubscriptionException e) {
+ Assert.assertNotNull(e.getMessage());
+ }
+ Assert.assertThrows(
+ SubscriptionException.class,
+ () -> procedure.rollbackFromOperateOnDataNodesForUnsubscribe(env));
}
@Test
@@ -234,6 +593,27 @@ public class DropSubscriptionProcedureTest {
return env;
}
+ private static ConfigNodeProcedureEnv mockEnvWithNodeStatus(final NodeStatus
nodeStatus) {
+ final ConfigNodeProcedureEnv env =
Mockito.mock(ConfigNodeProcedureEnv.class);
+ final ConfigManager configManager = Mockito.mock(ConfigManager.class);
+ final LoadManager loadManager = Mockito.mock(LoadManager.class);
+ Mockito.when(env.getConfigManager()).thenReturn(configManager);
+ Mockito.when(configManager.getLoadManager()).thenReturn(loadManager);
+ Mockito.when(loadManager.getNodeStatus(1)).thenReturn(nodeStatus);
+ return env;
+ }
+
+ private static DropPipeProcedureV2 mockDropPipeProcedure(final String
pipeName) {
+ final DropPipeProcedureV2 procedure =
Mockito.mock(DropPipeProcedureV2.class);
+ Mockito.when(procedure.getPipeName()).thenReturn(pipeName);
+ return procedure;
+ }
+
+ private static TSStatus transportFailureStatus(final int statusCode, final
String message) {
+ return DataNodeTransportFailureUtils.markTransportFailure(
+ new TSStatus(statusCode).setMessage(message));
+ }
+
private static void setField(final Object target, final String fieldName,
final Object value)
throws Exception {
Class<?> clazz = target.getClass();