This is an automated email from the ASF dual-hosted git repository.
JackieTien97 pushed a commit to branch dev/1.3
in repository https://gitbox.apache.org/repos/asf/iotdb.git
The following commit(s) were added to refs/heads/dev/1.3 by this push:
new 013622816a0 [To dev/1.3] [CQ] Check READ_DATA permissions during
continuous query execution (#19234)
013622816a0 is described below
commit 013622816a0e5d6a20dd742caa34938037049b34
Author: Jackie Tien <[email protected]>
AuthorDate: Fri Nov 13 16:08:51 2026 +0800
[To dev/1.3] [CQ] Check READ_DATA permissions during continuous query
execution (#19234)
---
.../org/apache/iotdb/db/it/cq/IoTDBCQExecIT.java | 212 +++++++++++++++++++++
.../iotdb/db/i18n/DataNodeQueryMessages.java | 2 +
.../iotdb/db/i18n/DataNodeQueryMessages.java | 2 +
.../impl/DataNodeInternalRPCServiceImpl.java | 18 +-
.../plan/statement/crud/QueryStatement.java | 2 +-
.../impl/DataNodeInternalRPCServiceImplCQTest.java | 157 +++++++++++++++
6 files changed, 389 insertions(+), 4 deletions(-)
diff --git
a/integration-test/src/test/java/org/apache/iotdb/db/it/cq/IoTDBCQExecIT.java
b/integration-test/src/test/java/org/apache/iotdb/db/it/cq/IoTDBCQExecIT.java
index ea00bbfa646..0b39ce8566f 100644
---
a/integration-test/src/test/java/org/apache/iotdb/db/it/cq/IoTDBCQExecIT.java
+++
b/integration-test/src/test/java/org/apache/iotdb/db/it/cq/IoTDBCQExecIT.java
@@ -18,10 +18,18 @@
*/
package org.apache.iotdb.db.it.cq;
+import org.apache.iotdb.common.rpc.thrift.TEndPoint;
+import org.apache.iotdb.common.rpc.thrift.TSStatus;
+import org.apache.iotdb.commons.client.ClientPoolFactory;
+import org.apache.iotdb.commons.client.IClientManager;
+import org.apache.iotdb.commons.client.sync.SyncDataNodeInternalServiceClient;
import org.apache.iotdb.it.env.EnvFactory;
+import org.apache.iotdb.it.env.cluster.node.DataNodeWrapper;
import org.apache.iotdb.it.framework.IoTDBTestRunner;
import org.apache.iotdb.itbase.category.ClusterIT;
import org.apache.iotdb.itbase.category.LocalStandaloneIT;
+import org.apache.iotdb.mpp.rpc.thrift.TExecuteCQ;
+import org.apache.iotdb.rpc.TSStatusCode;
import org.junit.AfterClass;
import org.junit.BeforeClass;
@@ -31,11 +39,16 @@ import org.junit.runner.RunWith;
import java.sql.Connection;
import java.sql.ResultSet;
+import java.sql.SQLException;
import java.sql.Statement;
+import java.util.ArrayDeque;
+import java.util.Deque;
import java.util.concurrent.TimeUnit;
+import static org.apache.iotdb.db.it.utils.TestUtils.resultSetEqualTest;
import static org.apache.iotdb.itbase.constant.TestConstant.TIMESTAMP_STR;
import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
@RunWith(IoTDBTestRunner.class)
@@ -52,6 +65,205 @@ public class IoTDBCQExecIT {
EnvFactory.getEnv().cleanClusterEnvironment();
}
+ @Test
+ public void testCQExecutionWithReadDataPermission() throws Exception {
+ testCQExecutionWithReadDataPermission(false, false);
+ }
+
+ @Test
+ public void testCQExecutionWithReadDataPermissionAlignByDevice() throws
Exception {
+ testCQExecutionWithReadDataPermission(true, false);
+ }
+
+ @Test
+ public void testCQExecutionWithExplicitTargetReadDataPermission() throws
Exception {
+ testCQExecutionWithReadDataPermission(false, true);
+ }
+
+ @Test
+ public void
testCQExecutionWithExplicitTargetReadDataPermissionAlignByDevice() throws
Exception {
+ testCQExecutionWithReadDataPermission(true, true);
+ }
+
+ private void testCQExecutionWithReadDataPermission(boolean alignByDevice,
boolean explicitTargets)
+ throws Exception {
+ String cqId =
+ (explicitTargets ? "cq_exp_auth" : "cq_read_auth") + (alignByDevice ?
"_aligned" : "");
+ String database = "root." + cqId;
+ String username = cqId + "_user";
+ String password = "CQRead!Test2026";
+ String firstTarget = explicitTargets ? "m1" : "s1";
+ String secondTarget = explicitTargets ? "m2" : "s2";
+ String queryBody =
+ "SELECT "
+ + (explicitTargets ? "s1, s2" : "*")
+ + " INTO "
+ + database
+ + ".target("
+ + (explicitTargets ? "m1, m2" : "::")
+ + ") FROM "
+ + database
+ + ".source"
+ + (alignByDevice ? " ALIGN BY DEVICE" : "");
+ String resultQuery =
+ "SELECT " + firstTarget + ", " + secondTarget + " FROM " + database +
".target";
+ String resultHeader =
+ "Time,"
+ + database
+ + ".target."
+ + firstTarget
+ + ","
+ + database
+ + ".target."
+ + secondTarget
+ + ",";
+
+ IClientManager<TEndPoint, SyncDataNodeInternalServiceClient> clients =
+ new IClientManager.Factory<TEndPoint,
SyncDataNodeInternalServiceClient>()
+ .createClientManager(
+ new
ClientPoolFactory.SyncDataNodeInternalServiceClientPoolFactory());
+ try (Connection connection = EnvFactory.getEnv().getConnection();
+ Statement statement = connection.createStatement();
+ CQTestCleanup cleanup = new CQTestCleanup(statement)) {
+ statement.execute("CREATE USER " + username + " '" + password + "'");
+ cleanup.add("DROP USER " + username);
+ statement.execute("CREATE DATABASE " + database);
+ cleanup.add("DELETE DATABASE " + database);
+ statement.execute("CREATE TIMESERIES " + database + ".source.s1 WITH
DATATYPE=INT64");
+ statement.execute("CREATE TIMESERIES " + database + ".source.s2 WITH
DATATYPE=INT64");
+ statement.execute(
+ "CREATE TIMESERIES " + database + ".target." + firstTarget + " WITH
DATATYPE=INT64");
+ statement.execute(
+ "CREATE TIMESERIES " + database + ".target." + secondTarget + " WITH
DATATYPE=INT64");
+ statement.execute(
+ "INSERT INTO "
+ + database
+ + ".source(time, s1, s2) VALUES (1, 11, 21), (1001, 12, 22),
(2001, 13, 23), (3001, 14, 24)");
+ statement.execute("GRANT USE_CQ ON root.** TO USER " + username);
+ statement.execute("GRANT WRITE_DATA ON " + database + ".target.** TO
USER " + username);
+ statement.execute("GRANT READ_DATA ON " + database + ".source.s1 TO USER
" + username);
+
+ try (Connection userConnection =
EnvFactory.getEnv().getConnection(username, password);
+ Statement userStatement = userConnection.createStatement()) {
+ // Keep the scheduler idle and execute deterministic windows through
its DataNode RPC.
+ userStatement.execute(
+ "CREATE CQ "
+ + cqId
+ + " RESAMPLE EVERY 1s BOUNDARY "
+ + (System.currentTimeMillis() + TimeUnit.DAYS.toMillis(1))
+ + " BEGIN "
+ + queryBody
+ + " END");
+ cleanup.add("DROP CQ " + cqId);
+ }
+
+ TExecuteCQ request = new TExecuteCQ(queryBody, 0, 1000, 10000, "UTC",
cqId, username);
+ String[] expectedRows;
+ if (explicitTargets) {
+ String columnMismatch =
+ "the number of source columns and the number of target paths
should be the same";
+ executeCQOnAllDataNodes(clients, request, TSStatusCode.SEMANTIC_ERROR,
columnMismatch);
+ resultSetEqualTest(resultQuery, resultHeader, new String[0]);
+
+ // Explicit targets retain SELECT INTO's positional mapping. Restore
access and retry the
+ // same window, as the CQ scheduler does after an execution failure.
+ statement.execute("GRANT READ_DATA ON " + database + ".source.s2 TO
USER " + username);
+ executeCQOnAllDataNodes(clients, request, TSStatusCode.SUCCESS_STATUS,
null);
+ resultSetEqualTest(resultQuery, resultHeader, new String[]
{"1,11,21,"});
+
+ statement.execute("REVOKE READ_DATA ON " + database + ".source.s2 FROM
USER " + username);
+ request.setStartTime(1000).setEndTime(2000);
+ executeCQOnAllDataNodes(clients, request, TSStatusCode.SEMANTIC_ERROR,
columnMismatch);
+ resultSetEqualTest(resultQuery, resultHeader, new String[]
{"1,11,21,"});
+
+ statement.execute("GRANT READ_DATA ON " + database + ".source.s2 TO
USER " + username);
+ executeCQOnAllDataNodes(clients, request, TSStatusCode.SUCCESS_STATUS,
null);
+ expectedRows = new String[] {"1,11,21,", "1001,12,22,"};
+ } else {
+ executeCQOnAllDataNodes(clients, request, TSStatusCode.SUCCESS_STATUS,
null);
+ // The wildcard must not copy s2, for which the CQ owner has no
READ_DATA privilege.
+ resultSetEqualTest(resultQuery, resultHeader, new String[]
{"1,11,null,"});
+
+ statement.execute("REVOKE READ_DATA ON " + database + ".source.s1 FROM
USER " + username);
+ request.setStartTime(1000).setEndTime(2000);
+ executeCQOnAllDataNodes(clients, request, TSStatusCode.SUCCESS_STATUS,
null);
+ resultSetEqualTest(resultQuery, resultHeader, new String[]
{"1,11,null,"});
+
+ statement.execute("GRANT READ_DATA ON " + database + ".source.** TO
USER " + username);
+ request.setStartTime(2000).setEndTime(3000);
+ executeCQOnAllDataNodes(clients, request, TSStatusCode.SUCCESS_STATUS,
null);
+ expectedRows = new String[] {"1,11,null,", "2001,13,23,"};
+ }
+ resultSetEqualTest(resultQuery, resultHeader, expectedRows);
+
+ statement.execute("DROP USER " + username);
+ cleanup.remove("DROP USER " + username);
+ request.setStartTime(3000).setEndTime(4000);
+ executeCQOnAllDataNodes(clients, request,
TSStatusCode.EXECUTE_STATEMENT_ERROR, username);
+ resultSetEqualTest(resultQuery, resultHeader, expectedRows);
+ } finally {
+ clients.close();
+ }
+ }
+
+ private void executeCQOnAllDataNodes(
+ IClientManager<TEndPoint, SyncDataNodeInternalServiceClient> clients,
+ TExecuteCQ request,
+ TSStatusCode expectedStatus,
+ String expectedMessage)
+ throws Exception {
+ for (DataNodeWrapper dataNode :
EnvFactory.getEnv().getDataNodeWrapperList()) {
+ try (SyncDataNodeInternalServiceClient client =
+ clients.borrowClient(
+ new TEndPoint(dataNode.getInternalAddress(),
dataNode.getInternalPort()))) {
+ TSStatus status = client.executeCQ(request);
+ assertEquals(status.toString(), expectedStatus.getStatusCode(),
status.getCode());
+ if (expectedMessage != null) {
+ assertTrue(status.toString(), status.isSetMessage());
+ assertTrue(status.getMessage(),
status.getMessage().contains(expectedMessage));
+ }
+ }
+ }
+ }
+
+ private static class CQTestCleanup implements AutoCloseable {
+ private final Statement statement;
+ private final Deque<String> statements = new ArrayDeque<>();
+
+ private CQTestCleanup(Statement statement) {
+ this.statement = statement;
+ }
+
+ private void add(String sql) {
+ statements.push(sql);
+ }
+
+ private void remove(String sql) {
+ statements.remove(sql);
+ }
+
+ @Override
+ public void close() throws SQLException {
+ // Attempt every cleanup. Try-with-resources preserves the original test
failure and adds
+ // cleanup failures as suppressed exceptions.
+ SQLException failure = null;
+ for (String sql : statements) {
+ try {
+ statement.execute(sql);
+ } catch (SQLException e) {
+ if (failure == null) {
+ failure = e;
+ } else {
+ failure.addSuppressed(e);
+ }
+ }
+ }
+ if (failure != null) {
+ throw failure;
+ }
+ }
+ }
+
@Test
public void testCQExecution1() {
String insertTemplate =
diff --git
a/iotdb-core/datanode/src/main/i18n/en/org/apache/iotdb/db/i18n/DataNodeQueryMessages.java
b/iotdb-core/datanode/src/main/i18n/en/org/apache/iotdb/db/i18n/DataNodeQueryMessages.java
index 4c42be75b2c..073473b4742 100644
---
a/iotdb-core/datanode/src/main/i18n/en/org/apache/iotdb/db/i18n/DataNodeQueryMessages.java
+++
b/iotdb-core/datanode/src/main/i18n/en/org/apache/iotdb/db/i18n/DataNodeQueryMessages.java
@@ -69,4 +69,6 @@ public final class DataNodeQueryMessages {
"The database %s does not exist and auto-create-schema is disabled.";
public static final String LOG_DELETE_AFTER_LOADING_ARG_ERROR_C606A060 =
"Delete After Loading {} error.";
+ public static final String
LOG_FAILED_TO_AUTHORIZE_CQ_ARG_FOR_USER_ARG_ARG_B436A81F =
+ "Failed to authorize CQ {} for user {}: {}";
}
diff --git
a/iotdb-core/datanode/src/main/i18n/zh/org/apache/iotdb/db/i18n/DataNodeQueryMessages.java
b/iotdb-core/datanode/src/main/i18n/zh/org/apache/iotdb/db/i18n/DataNodeQueryMessages.java
index 182e3661398..370792a20cc 100644
---
a/iotdb-core/datanode/src/main/i18n/zh/org/apache/iotdb/db/i18n/DataNodeQueryMessages.java
+++
b/iotdb-core/datanode/src/main/i18n/zh/org/apache/iotdb/db/i18n/DataNodeQueryMessages.java
@@ -65,4 +65,6 @@ public final class DataNodeQueryMessages {
EXCEPTION_THE_DATABASE_ARG_DOES_NOT_EXIST_AND_AUTO_CREATE_SCHEMA_IS_DISABLED_28F8D49A
=
"数据库 %s 不存在,且 auto-create-schema 已禁用。";
public static final String LOG_DELETE_AFTER_LOADING_ARG_ERROR_C606A060 =
"加载后删除 {} 时出错。";
+ public static final String
LOG_FAILED_TO_AUTHORIZE_CQ_ARG_FOR_USER_ARG_ARG_B436A81F =
+ "CQ {} 的用户 {} 鉴权失败:{}";
}
diff --git
a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/protocol/thrift/impl/DataNodeInternalRPCServiceImpl.java
b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/protocol/thrift/impl/DataNodeInternalRPCServiceImpl.java
index 98f50349365..0b8a34d56ac 100644
---
a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/protocol/thrift/impl/DataNodeInternalRPCServiceImpl.java
+++
b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/protocol/thrift/impl/DataNodeInternalRPCServiceImpl.java
@@ -85,6 +85,7 @@ import org.apache.iotdb.db.conf.IoTDBDescriptor;
import org.apache.iotdb.db.consensus.DataRegionConsensusImpl;
import org.apache.iotdb.db.consensus.SchemaRegionConsensusImpl;
import org.apache.iotdb.db.exception.StorageEngineException;
+import org.apache.iotdb.db.i18n.DataNodeQueryMessages;
import org.apache.iotdb.db.partition.DataPartitionTableGenerator;
import org.apache.iotdb.db.pipe.agent.PipeDataNodeAgent;
import org.apache.iotdb.db.protocol.client.ConfigNodeInfo;
@@ -1526,12 +1527,12 @@ public class DataNodeInternalRPCServiceImpl implements
IDataNodeRPCService.Iface
SESSION_MANAGER.registerSession(session);
- SESSION_MANAGER.supplySession(
- session, req.getUsername(), ZoneId.of(req.getZoneId()),
ClientVersion.V_1_0);
-
String executedSQL = req.queryBody;
try {
+ SESSION_MANAGER.supplySession(
+ session, req.getUsername(), ZoneId.of(req.getZoneId()),
ClientVersion.V_1_0);
+
QueryStatement s =
(QueryStatement) StatementGenerator.createStatement(req.queryBody,
session.getZoneId());
if (s == null) {
@@ -1563,6 +1564,17 @@ public class DataNodeInternalRPCServiceImpl implements
IDataNodeRPCService.Iface
}
executedSQL = String.join(" ",
s.constructFormattedSQL().split("\n")).replaceAll(" +", " ");
+ // Refresh the owner's READ_DATA scope for each CQ execution.
+ TSStatus status = AuthorityChecker.checkAuthority(s, session);
+ if (status.getCode() != TSStatusCode.SUCCESS_STATUS.getStatusCode()) {
+ LOGGER.warn(
+
DataNodeQueryMessages.LOG_FAILED_TO_AUTHORIZE_CQ_ARG_FOR_USER_ARG_ARG_B436A81F,
+ req.getCqId(),
+ req.getUsername(),
+ status);
+ return status;
+ }
+
long queryId =
SESSION_MANAGER.requestQueryId(session,
SESSION_MANAGER.requestStatementId(session));
// Create and cache dataset
diff --git
a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/statement/crud/QueryStatement.java
b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/statement/crud/QueryStatement.java
index 6d36d4fd64e..1c41c21f461 100644
---
a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/statement/crud/QueryStatement.java
+++
b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/statement/crud/QueryStatement.java
@@ -225,7 +225,7 @@ public class QueryStatement extends
AuthorityInformationStatement {
AuthorityChecker.getAuthorizedPathTree(userName,
PrivilegeType.READ_DATA.ordinal());
}
} catch (AuthException e) {
- return new TSStatus(e.getCode().getStatusCode());
+ return new
TSStatus(e.getCode().getStatusCode()).setMessage(e.getMessage());
}
return new TSStatus(TSStatusCode.SUCCESS_STATUS.getStatusCode());
}
diff --git
a/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/protocol/thrift/impl/DataNodeInternalRPCServiceImplCQTest.java
b/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/protocol/thrift/impl/DataNodeInternalRPCServiceImplCQTest.java
new file mode 100644
index 00000000000..1db1c0eb5f6
--- /dev/null
+++
b/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/protocol/thrift/impl/DataNodeInternalRPCServiceImplCQTest.java
@@ -0,0 +1,157 @@
+/*
+ * 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.db.protocol.thrift.impl;
+
+import org.apache.iotdb.common.rpc.thrift.TSStatus;
+import org.apache.iotdb.commons.auth.AuthException;
+import org.apache.iotdb.commons.auth.entity.PrivilegeType;
+import org.apache.iotdb.commons.path.PartialPath;
+import org.apache.iotdb.commons.path.PathPatternTree;
+import org.apache.iotdb.db.auth.AuthorityChecker;
+import org.apache.iotdb.db.auth.IAuthorityFetcher;
+import org.apache.iotdb.db.conf.IoTDBDescriptor;
+import org.apache.iotdb.db.protocol.session.SessionManager;
+import org.apache.iotdb.db.queryengine.common.MPPQueryContext;
+import org.apache.iotdb.db.queryengine.common.schematree.ClusterSchemaTree;
+import org.apache.iotdb.db.queryengine.plan.Coordinator;
+import org.apache.iotdb.db.queryengine.plan.analyze.schema.ISchemaFetcher;
+import org.apache.iotdb.metrics.metricsets.system.SystemMetrics;
+import org.apache.iotdb.mpp.rpc.thrift.TExecuteCQ;
+import org.apache.iotdb.rpc.TSStatusCode;
+
+import org.apache.ratis.util.MemoizedSupplier;
+import org.junit.After;
+import org.junit.AfterClass;
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.mockito.ArgumentCaptor;
+import org.powermock.reflect.Whitebox;
+
+import java.lang.reflect.Field;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyBoolean;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyZeroInteractions;
+import static org.mockito.Mockito.when;
+
+public class DataNodeInternalRPCServiceImplCQTest {
+
+ private static final String USERNAME = "cq_unit_user";
+ private static int originalDataNodeId;
+
+ private MemoizedSupplier<IAuthorityFetcher> authorityFetcherSupplier;
+ private IAuthorityFetcher originalAuthorityFetcher;
+ private IAuthorityFetcher authorityFetcher;
+ private ISchemaFetcher schemaFetcher;
+ private DataNodeInternalRPCServiceImpl service;
+ private int originalQueryCount;
+
+ @BeforeClass
+ public static void setUpClass() {
+ originalDataNodeId =
IoTDBDescriptor.getInstance().getConfig().getDataNodeId();
+ IoTDBDescriptor.getInstance().getConfig().setDataNodeId(0);
+ }
+
+ @AfterClass
+ public static void tearDownClass() {
+
IoTDBDescriptor.getInstance().getConfig().setDataNodeId(originalDataNodeId);
+ }
+
+ @Before
+ public void setUp() throws Exception {
+ // AuthorityChecker has no access-control hook on this branch, so replace
its memoized
+ // authority fetcher for the duration of each test.
+ authorityFetcherSupplier =
+ Whitebox.getInternalState(AuthorityChecker.class, "authorityFetcher");
+ originalAuthorityFetcher = authorityFetcherSupplier.get();
+ authorityFetcher = mock(IAuthorityFetcher.class);
+ Whitebox.setInternalState(authorityFetcherSupplier, "value",
authorityFetcher);
+
+ service = new DataNodeInternalRPCServiceImpl(mock(SystemMetrics.class));
+ schemaFetcher = mock(ISchemaFetcher.class);
+ Field field =
DataNodeInternalRPCServiceImpl.class.getDeclaredField("schemaFetcher");
+ field.setAccessible(true);
+ field.set(service, schemaFetcher);
+ originalQueryCount = Coordinator.getInstance().getQueryExecutionMapSize();
+ }
+
+ @After
+ public void tearDown() {
+ Whitebox.setInternalState(authorityFetcherSupplier, "value",
originalAuthorityFetcher);
+ }
+
+ @Test
+ public void testAuthorizationFailureStopsBeforeQueryAnalysis() throws
Exception {
+ when(authorityFetcher.getAuthorizedPatternTree(USERNAME,
PrivilegeType.READ_DATA.ordinal()))
+ .thenThrow(new AuthException(TSStatusCode.NO_PERMISSION, "read
denied"));
+
+ TSStatus result = service.executeCQ(request());
+ assertEquals(result.toString(),
TSStatusCode.NO_PERMISSION.getStatusCode(), result.getCode());
+ assertEquals("read denied", result.getMessage());
+ assertOwnerIdentity();
+ verifyZeroInteractions(schemaFetcher);
+ assertSessionAndQueryCleanedUp();
+ }
+
+ @Test
+ public void testAuthorizedExecutionPropagatesOwnerIdentity() throws
Exception {
+ PathPatternTree authorizedScope = new PathPatternTree();
+ authorizedScope.appendPathPattern(new
PartialPath("root.cq_unit.source.**"));
+ authorizedScope.constructTree();
+ when(authorityFetcher.getAuthorizedPatternTree(USERNAME,
PrivilegeType.READ_DATA.ordinal()))
+ .thenReturn(authorizedScope);
+ when(schemaFetcher.fetchSchema(
+ any(PathPatternTree.class), anyBoolean(),
any(MPPQueryContext.class)))
+ .thenReturn(new ClusterSchemaTree());
+
+ TSStatus result = service.executeCQ(request());
+ assertEquals(result.toString(),
TSStatusCode.SUCCESS_STATUS.getStatusCode(), result.getCode());
+ assertOwnerIdentity();
+ ArgumentCaptor<MPPQueryContext> context =
ArgumentCaptor.forClass(MPPQueryContext.class);
+ verify(schemaFetcher).fetchSchema(any(PathPatternTree.class),
anyBoolean(), context.capture());
+ assertEquals(USERNAME, context.getValue().getSession().getUserName());
+ assertSessionAndQueryCleanedUp();
+ }
+
+ private void assertOwnerIdentity() throws Exception {
+ verify(authorityFetcher).getAuthorizedPatternTree(USERNAME,
PrivilegeType.READ_DATA.ordinal());
+ }
+
+ private void assertSessionAndQueryCleanedUp() {
+ assertNull(SessionManager.getInstance().getCurrSession());
+ assertEquals(originalQueryCount,
Coordinator.getInstance().getQueryExecutionMapSize());
+ }
+
+ private TExecuteCQ request() {
+ return new TExecuteCQ(
+ "SELECT s1 INTO root.cq_unit.target(::) FROM root.cq_unit.source",
+ 0,
+ 1000,
+ 10000,
+ "UTC",
+ "cq_unit",
+ USERNAME);
+ }
+}