#9708

pending completion

Build # #9708

Build Type

push

travis_ci

Committed by

web-flow

Commit Message

[To rel/1.2] Enhance warning messages for ConfigNodeClient (#10722)

Signed-off-by: OneSizeFitQuorum <tanxinyu@apache.org>

Run Details

1 of 1 new or added line in 1 file covered. (100.0%)

79235 of 165170 relevant lines covered (47.97%)

0.48 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/protocol/rest/v2/impl/RestApiServiceImpl.java

/*
 * 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.rest.v2.impl;

import org.apache.iotdb.db.conf.IoTDBConfig;
import org.apache.iotdb.db.conf.IoTDBDescriptor;
import org.apache.iotdb.db.conf.rest.IoTDBRestServiceDescriptor;
import org.apache.iotdb.db.protocol.rest.handler.AuthorizationHandler;
import org.apache.iotdb.db.protocol.rest.utils.InsertTabletSortDataUtils;
import org.apache.iotdb.db.protocol.rest.v2.RestApiService;
import org.apache.iotdb.db.protocol.rest.v2.handler.ExceptionHandler;
import org.apache.iotdb.db.protocol.rest.v2.handler.ExecuteStatementHandler;
import org.apache.iotdb.db.protocol.rest.v2.handler.QueryDataSetHandler;
import org.apache.iotdb.db.protocol.rest.v2.handler.RequestValidationHandler;
import org.apache.iotdb.db.protocol.rest.v2.handler.StatementConstructionHandler;
import org.apache.iotdb.db.protocol.rest.v2.model.ExecutionStatus;
import org.apache.iotdb.db.protocol.rest.v2.model.InsertTabletRequest;
import org.apache.iotdb.db.protocol.rest.v2.model.SQL;
import org.apache.iotdb.db.protocol.session.SessionManager;
import org.apache.iotdb.db.queryengine.plan.Coordinator;
import org.apache.iotdb.db.queryengine.plan.analyze.ClusterPartitionFetcher;
import org.apache.iotdb.db.queryengine.plan.analyze.IPartitionFetcher;
import org.apache.iotdb.db.queryengine.plan.analyze.schema.ClusterSchemaFetcher;
import org.apache.iotdb.db.queryengine.plan.analyze.schema.ISchemaFetcher;
import org.apache.iotdb.db.queryengine.plan.execution.ExecutionResult;
import org.apache.iotdb.db.queryengine.plan.execution.IQueryExecution;
import org.apache.iotdb.db.queryengine.plan.parser.StatementGenerator;
import org.apache.iotdb.db.queryengine.plan.statement.Statement;
import org.apache.iotdb.db.queryengine.plan.statement.crud.InsertTabletStatement;
import org.apache.iotdb.db.utils.SetThreadName;
import org.apache.iotdb.rpc.TSStatusCode;

import javax.ws.rs.core.Response;
import javax.ws.rs.core.SecurityContext;

import java.time.ZoneId;

public class RestApiServiceImpl extends RestApiService {

  private static final IoTDBConfig config = IoTDBDescriptor.getInstance().getConfig();

  private static final Coordinator COORDINATOR = Coordinator.getInstance();

  private static final SessionManager SESSION_MANAGER = SessionManager.getInstance();

  private final IPartitionFetcher partitionFetcher;

  private final ISchemaFetcher schemaFetcher;
  private final AuthorizationHandler authorizationHandler;

  private final Integer defaultQueryRowLimit;

  public RestApiServiceImpl() {
    partitionFetcher = ClusterPartitionFetcher.getInstance();
    schemaFetcher = ClusterSchemaFetcher.getInstance();
    authorizationHandler = new AuthorizationHandler();
    defaultQueryRowLimit =
        IoTDBRestServiceDescriptor.getInstance().getConfig().getRestQueryDefaultRowSizeLimit();
  }

  @Override
  public Response executeNonQueryStatement(SQL sql, SecurityContext securityContext) {
    Long queryId = null;
    try {
      RequestValidationHandler.validateSQL(sql);

      Statement statement =
          StatementGenerator.createStatement(sql.getSql(), ZoneId.systemDefault());

      if (!ExecuteStatementHandler.validateStatement(statement)) {
        return Response.ok()
            .entity(
                new org.apache.iotdb.db.protocol.rest.model.ExecutionStatus()
                    .code(TSStatusCode.EXECUTE_STATEMENT_ERROR.getStatusCode())
                    .message(TSStatusCode.EXECUTE_STATEMENT_ERROR.name()))
            .build();
      }

      Response response = authorizationHandler.checkAuthority(securityContext, statement);
      if (response != null) {
        return response;
      }
      queryId = SESSION_MANAGER.requestQueryId();
      ExecutionResult result =
          COORDINATOR.execute(
              statement,
              queryId,
              null,
              sql.getSql(),
              partitionFetcher,
              schemaFetcher,
              config.getQueryTimeoutThreshold());

      return Response.ok()
          .entity(
              (result.status.code == TSStatusCode.SUCCESS_STATUS.getStatusCode()
                      || result.status.code == TSStatusCode.REDIRECTION_RECOMMEND.getStatusCode())
                  ? new ExecutionStatus()
                      .code(TSStatusCode.SUCCESS_STATUS.getStatusCode())
                      .message(TSStatusCode.SUCCESS_STATUS.name())
                  : new ExecutionStatus()
                      .code(result.status.getCode())
                      .message(result.status.getMessage()))
          .build();
    } catch (Exception e) {
      return Response.ok().entity(ExceptionHandler.tryCatchException(e)).build();
    } finally {
      if (queryId != null) {
        COORDINATOR.cleanupQueryExecution(queryId);
      }
    }
  }

  @Override
  public Response executeQueryStatement(SQL sql, SecurityContext securityContext) {
    Long queryId = null;
    try {
      RequestValidationHandler.validateSQL(sql);

      Statement statement =
          StatementGenerator.createStatement(sql.getSql(), ZoneId.systemDefault());

      if (ExecuteStatementHandler.validateStatement(statement)) {
        return Response.ok()
            .entity(
                new org.apache.iotdb.db.protocol.rest.model.ExecutionStatus()
                    .code(TSStatusCode.EXECUTE_STATEMENT_ERROR.getStatusCode())
                    .message(TSStatusCode.EXECUTE_STATEMENT_ERROR.name()))
            .build();
      }

      Response response = authorizationHandler.checkAuthority(securityContext, statement);
      if (response != null) {
        return response;
      }

      queryId = SESSION_MANAGER.requestQueryId();
      // create and cache dataset
      ExecutionResult result =
          COORDINATOR.execute(
              statement,
              queryId,
              null,
              sql.getSql(),
              partitionFetcher,
              schemaFetcher,
              config.getQueryTimeoutThreshold());
      if (result.status.code != TSStatusCode.SUCCESS_STATUS.getStatusCode()
          && result.status.code != TSStatusCode.REDIRECTION_RECOMMEND.getStatusCode()) {
        return Response.ok()
            .entity(
                new ExecutionStatus()
                    .code(result.status.getCode())
                    .message(result.status.getMessage()))
            .build();
      }
      IQueryExecution queryExecution = COORDINATOR.getQueryExecution(queryId);
      try (SetThreadName threadName = new SetThreadName(result.queryId.getId())) {
        return QueryDataSetHandler.fillQueryDataSet(
            queryExecution,
            statement,
            sql.getRowLimit() == null ? defaultQueryRowLimit : sql.getRowLimit());
      }
    } catch (Exception e) {
      return Response.ok().entity(ExceptionHandler.tryCatchException(e)).build();
    } finally {
      if (queryId != null) {
        COORDINATOR.cleanupQueryExecution(queryId);
      }
    }
  }

  @Override
  public Response insertTablet(
      InsertTabletRequest insertTabletRequest, SecurityContext securityContext) {
    Long queryId = null;
    try {
      RequestValidationHandler.validateInsertTabletRequest(insertTabletRequest);

      if (!InsertTabletSortDataUtils.checkSorted(insertTabletRequest.getTimestamps())) {
        int[] index =
            InsertTabletSortDataUtils.sortTimeStampList(insertTabletRequest.getTimestamps());
        insertTabletRequest.getTimestamps().sort(Long::compareTo);
        insertTabletRequest.setValues(
            InsertTabletSortDataUtils.sortList(
                insertTabletRequest.getValues(), index, insertTabletRequest.getDataTypes().size()));
      }

      InsertTabletStatement insertTabletStatement =
          StatementConstructionHandler.constructInsertTabletStatement(insertTabletRequest);

      Response response =
          authorizationHandler.checkAuthority(securityContext, insertTabletStatement);
      if (response != null) {
        return response;
      }
      queryId = SESSION_MANAGER.requestQueryId();
      ExecutionResult result =
          COORDINATOR.execute(
              insertTabletStatement,
              SESSION_MANAGER.requestQueryId(),
              null,
              "",
              partitionFetcher,
              schemaFetcher,
              config.getQueryTimeoutThreshold());

      return Response.ok()
          .entity(
              (result.status.code == TSStatusCode.SUCCESS_STATUS.getStatusCode()
                      || result.status.code == TSStatusCode.REDIRECTION_RECOMMEND.getStatusCode())
                  ? new ExecutionStatus()
                      .code(TSStatusCode.SUCCESS_STATUS.getStatusCode())
                      .message(TSStatusCode.SUCCESS_STATUS.name())
                  : new ExecutionStatus()
                      .code(result.status.getCode())
                      .message(result.status.getMessage()))
          .build();
    } catch (Exception e) {
      return Response.ok().entity(ExceptionHandler.tryCatchException(e)).build();
    } finally {
      if (queryId != null) {
        COORDINATOR.cleanupQueryExecution(queryId);
      }
    }
  }
}

1	/*
2	* Licensed to the Apache Software Foundation (ASF) under one or more
3	* contributor license agreements. See the NOTICE file distributed with
4	* this work for additional information regarding copyright ownership.
5	* The ASF licenses this file to You under the Apache License, Version 2.0
6	* (the "License"); you may not use this file except in compliance with
7	* the License. You may obtain a copy of the License at
8	*
9	* http://www.apache.org/licenses/LICENSE-2.0
10	*
11	* Unless required by applicable law or agreed to in writing, software
12	* distributed under the License is distributed on an "AS IS" BASIS,
13	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14	* See the License for the specific language governing permissions and
15	* limitations under the License.
16	*/
17
18	package org.apache.iotdb.db.protocol.rest.v2.impl;
19
20	import org.apache.iotdb.db.conf.IoTDBConfig;
21	import org.apache.iotdb.db.conf.IoTDBDescriptor;
22	import org.apache.iotdb.db.conf.rest.IoTDBRestServiceDescriptor;
23	import org.apache.iotdb.db.protocol.rest.handler.AuthorizationHandler;
24	import org.apache.iotdb.db.protocol.rest.utils.InsertTabletSortDataUtils;
25	import org.apache.iotdb.db.protocol.rest.v2.RestApiService;
26	import org.apache.iotdb.db.protocol.rest.v2.handler.ExceptionHandler;
27	import org.apache.iotdb.db.protocol.rest.v2.handler.ExecuteStatementHandler;
28	import org.apache.iotdb.db.protocol.rest.v2.handler.QueryDataSetHandler;
29	import org.apache.iotdb.db.protocol.rest.v2.handler.RequestValidationHandler;
30	import org.apache.iotdb.db.protocol.rest.v2.handler.StatementConstructionHandler;
31	import org.apache.iotdb.db.protocol.rest.v2.model.ExecutionStatus;
32	import org.apache.iotdb.db.protocol.rest.v2.model.InsertTabletRequest;
33	import org.apache.iotdb.db.protocol.rest.v2.model.SQL;
34	import org.apache.iotdb.db.protocol.session.SessionManager;
35	import org.apache.iotdb.db.queryengine.plan.Coordinator;
36	import org.apache.iotdb.db.queryengine.plan.analyze.ClusterPartitionFetcher;
37	import org.apache.iotdb.db.queryengine.plan.analyze.IPartitionFetcher;
38	import org.apache.iotdb.db.queryengine.plan.analyze.schema.ClusterSchemaFetcher;
39	import org.apache.iotdb.db.queryengine.plan.analyze.schema.ISchemaFetcher;
40	import org.apache.iotdb.db.queryengine.plan.execution.ExecutionResult;
41	import org.apache.iotdb.db.queryengine.plan.execution.IQueryExecution;
42	import org.apache.iotdb.db.queryengine.plan.parser.StatementGenerator;
43	import org.apache.iotdb.db.queryengine.plan.statement.Statement;
44	import org.apache.iotdb.db.queryengine.plan.statement.crud.InsertTabletStatement;
45	import org.apache.iotdb.db.utils.SetThreadName;
46	import org.apache.iotdb.rpc.TSStatusCode;
47
48	import javax.ws.rs.core.Response;
49	import javax.ws.rs.core.SecurityContext;
50
51	import java.time.ZoneId;
52
53	public class RestApiServiceImpl extends RestApiService {
54
55	private static final IoTDBConfig config = IoTDBDescriptor.getInstance().getConfig();	×
56
57	private static final Coordinator COORDINATOR = Coordinator.getInstance();	×
58
59	private static final SessionManager SESSION_MANAGER = SessionManager.getInstance();	×
60
61	private final IPartitionFetcher partitionFetcher;
62
63	private final ISchemaFetcher schemaFetcher;
64	private final AuthorizationHandler authorizationHandler;
65
66	private final Integer defaultQueryRowLimit;
67
68	public RestApiServiceImpl() {	×
69	partitionFetcher = ClusterPartitionFetcher.getInstance();	×
70	schemaFetcher = ClusterSchemaFetcher.getInstance();	×
71	authorizationHandler = new AuthorizationHandler();	×
72	defaultQueryRowLimit =	×
73	IoTDBRestServiceDescriptor.getInstance().getConfig().getRestQueryDefaultRowSizeLimit();	×
74	}	×
75
76	@Override
77	public Response executeNonQueryStatement(SQL sql, SecurityContext securityContext) {
78	Long queryId = null;	×
79	try {
80	RequestValidationHandler.validateSQL(sql);	×
81
82	Statement statement =	×
83	StatementGenerator.createStatement(sql.getSql(), ZoneId.systemDefault());	×
84
85	if (!ExecuteStatementHandler.validateStatement(statement)) {	×
86	return Response.ok()	×
87	.entity(	×
88	new org.apache.iotdb.db.protocol.rest.model.ExecutionStatus()
89	.code(TSStatusCode.EXECUTE_STATEMENT_ERROR.getStatusCode())	×
90	.message(TSStatusCode.EXECUTE_STATEMENT_ERROR.name()))	×
91	.build();	×
92	}
93
94	Response response = authorizationHandler.checkAuthority(securityContext, statement);	×
95	if (response != null) {	×
96	return response;	×
97	}
98	queryId = SESSION_MANAGER.requestQueryId();	×
99	ExecutionResult result =	×
100	COORDINATOR.execute(	×
101	statement,
102	queryId,	×
103	null,
104	sql.getSql(),	×
105	partitionFetcher,
106	schemaFetcher,
107	config.getQueryTimeoutThreshold());	×
108
109	return Response.ok()	×
110	.entity(	×
111	(result.status.code == TSStatusCode.SUCCESS_STATUS.getStatusCode()	×
112	\|\| result.status.code == TSStatusCode.REDIRECTION_RECOMMEND.getStatusCode())	×
113	? new ExecutionStatus()
114	.code(TSStatusCode.SUCCESS_STATUS.getStatusCode())	×
115	.message(TSStatusCode.SUCCESS_STATUS.name())	×
116	: new ExecutionStatus()
117	.code(result.status.getCode())	×
118	.message(result.status.getMessage()))	×
119	.build();	×
120	} catch (Exception e) {	×
121	return Response.ok().entity(ExceptionHandler.tryCatchException(e)).build();	×
122	} finally {
123	if (queryId != null) {	×
124	COORDINATOR.cleanupQueryExecution(queryId);	×
125	}
126	}
127	}
128
129	@Override
130	public Response executeQueryStatement(SQL sql, SecurityContext securityContext) {
131	Long queryId = null;	×
132	try {
133	RequestValidationHandler.validateSQL(sql);	×
134
135	Statement statement =	×
136	StatementGenerator.createStatement(sql.getSql(), ZoneId.systemDefault());	×
137
138	if (ExecuteStatementHandler.validateStatement(statement)) {	×
139	return Response.ok()	×
140	.entity(	×
141	new org.apache.iotdb.db.protocol.rest.model.ExecutionStatus()
142	.code(TSStatusCode.EXECUTE_STATEMENT_ERROR.getStatusCode())	×
143	.message(TSStatusCode.EXECUTE_STATEMENT_ERROR.name()))	×
144	.build();	×
145	}
146
147	Response response = authorizationHandler.checkAuthority(securityContext, statement);	×
148	if (response != null) {	×
149	return response;	×
150	}
151
152	queryId = SESSION_MANAGER.requestQueryId();	×
153	// create and cache dataset
154	ExecutionResult result =	×
155	COORDINATOR.execute(	×
156	statement,
157	queryId,	×
158	null,
159	sql.getSql(),	×
160	partitionFetcher,
161	schemaFetcher,
162	config.getQueryTimeoutThreshold());	×
163	if (result.status.code != TSStatusCode.SUCCESS_STATUS.getStatusCode()	×
164	&& result.status.code != TSStatusCode.REDIRECTION_RECOMMEND.getStatusCode()) {	×
165	return Response.ok()	×
166	.entity(	×
167	new ExecutionStatus()
168	.code(result.status.getCode())	×
169	.message(result.status.getMessage()))	×
170	.build();	×
171	}
172	IQueryExecution queryExecution = COORDINATOR.getQueryExecution(queryId);	×
173	try (SetThreadName threadName = new SetThreadName(result.queryId.getId())) {	×
174	return QueryDataSetHandler.fillQueryDataSet(	×
175	queryExecution,
176	statement,
177	sql.getRowLimit() == null ? defaultQueryRowLimit : sql.getRowLimit());	×
178	}
179	} catch (Exception e) {	×
180	return Response.ok().entity(ExceptionHandler.tryCatchException(e)).build();	×
181	} finally {
182	if (queryId != null) {	×
183	COORDINATOR.cleanupQueryExecution(queryId);	×
184	}
185	}
186	}
187
188	@Override
189	public Response insertTablet(
190	InsertTabletRequest insertTabletRequest, SecurityContext securityContext) {
191	Long queryId = null;	×
192	try {
193	RequestValidationHandler.validateInsertTabletRequest(insertTabletRequest);	×
194
195	if (!InsertTabletSortDataUtils.checkSorted(insertTabletRequest.getTimestamps())) {	×
196	int[] index =	×
197	InsertTabletSortDataUtils.sortTimeStampList(insertTabletRequest.getTimestamps());	×
198	insertTabletRequest.getTimestamps().sort(Long::compareTo);	×
199	insertTabletRequest.setValues(	×
200	InsertTabletSortDataUtils.sortList(	×
201	insertTabletRequest.getValues(), index, insertTabletRequest.getDataTypes().size()));	×
202	}
203
204	InsertTabletStatement insertTabletStatement =	×
205	StatementConstructionHandler.constructInsertTabletStatement(insertTabletRequest);	×
206
207	Response response =	×
208	authorizationHandler.checkAuthority(securityContext, insertTabletStatement);	×
209	if (response != null) {	×
210	return response;	×
211	}
212	queryId = SESSION_MANAGER.requestQueryId();	×
213	ExecutionResult result =	×
214	COORDINATOR.execute(	×
215	insertTabletStatement,
216	SESSION_MANAGER.requestQueryId(),	×
217	null,
218	"",
219	partitionFetcher,
220	schemaFetcher,
221	config.getQueryTimeoutThreshold());	×
222
223	return Response.ok()	×
224	.entity(	×
225	(result.status.code == TSStatusCode.SUCCESS_STATUS.getStatusCode()	×
226	\|\| result.status.code == TSStatusCode.REDIRECTION_RECOMMEND.getStatusCode())	×
227	? new ExecutionStatus()
228	.code(TSStatusCode.SUCCESS_STATUS.getStatusCode())	×
229	.message(TSStatusCode.SUCCESS_STATUS.name())	×
230	: new ExecutionStatus()
231	.code(result.status.getCode())	×
232	.message(result.status.getMessage()))	×
233	.build();	×
234	} catch (Exception e) {	×
235	return Response.ok().entity(ExceptionHandler.tryCatchException(e)).build();	×
236	} finally {
237	if (queryId != null) {	×
238	COORDINATOR.cleanupQueryExecution(queryId);	×
239	}
240	}
241	}
242	}

apache / iotdb / #9708

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous