Repository: lens Updated Branches: refs/heads/master dc6560fe2 -> 5a63a0796
LENS-1318: Query Resource in the lens server offers very limited information on the getAllQueries call Project: http://git-wip-us.apache.org/repos/asf/lens/repo Commit: http://git-wip-us.apache.org/repos/asf/lens/commit/5a63a079 Tree: http://git-wip-us.apache.org/repos/asf/lens/tree/5a63a079 Diff: http://git-wip-us.apache.org/repos/asf/lens/diff/5a63a079 Branch: refs/heads/master Commit: 5a63a079608c7186e0a8c91e8c6a23e049ea7279 Parents: dc6560f Author: Srikanth Sundarrajan <srik...@hotmail.com> Authored: Fri Sep 23 13:34:06 2016 +0530 Committer: Rajat Khandelwal <rajatgupt...@gmail.com> Committed: Fri Sep 23 13:34:06 2016 +0530 ---------------------------------------------------------------------- .../java/org/apache/lens/client/LensClient.java | 5 + .../org/apache/lens/client/LensStatement.java | 21 ++ .../server/api/query/QueryExecutionService.java | 19 ++ .../apache/lens/server/query/LensServerDAO.java | 89 ++++++-- .../server/query/QueryExecutionServiceImpl.java | 216 ++++++++++++++----- .../lens/server/query/QueryServiceResource.java | 32 +++ .../lens/server/query/TestQueryService.java | 34 +++ 7 files changed, 346 insertions(+), 70 deletions(-) ---------------------------------------------------------------------- http://git-wip-us.apache.org/repos/asf/lens/blob/5a63a079/lens-client/src/main/java/org/apache/lens/client/LensClient.java ---------------------------------------------------------------------- diff --git a/lens-client/src/main/java/org/apache/lens/client/LensClient.java b/lens-client/src/main/java/org/apache/lens/client/LensClient.java index 593cc08..e936798 100644 --- a/lens-client/src/main/java/org/apache/lens/client/LensClient.java +++ b/lens-client/src/main/java/org/apache/lens/client/LensClient.java @@ -336,6 +336,11 @@ public class LensClient implements AutoCloseable { return statement.getAllQueries(state, queryName, user, driver, fromDate, toDate); } + public List<LensQuery> getQueriesWithDetails(String state, String queryName, String user, String driver, + String fromDate, String toDate) { + return statement.getAllQueryDetails(state, queryName, user, driver, fromDate, toDate); + } + private void connectToLensServer() { log.debug("Connecting to lens server {}", new LensConnectionParams(conf)); connection = new LensConnection(new LensConnectionParams(conf)); http://git-wip-us.apache.org/repos/asf/lens/blob/5a63a079/lens-client/src/main/java/org/apache/lens/client/LensStatement.java ---------------------------------------------------------------------- diff --git a/lens-client/src/main/java/org/apache/lens/client/LensStatement.java b/lens-client/src/main/java/org/apache/lens/client/LensStatement.java index 0c0cf91..f943b23 100644 --- a/lens-client/src/main/java/org/apache/lens/client/LensStatement.java +++ b/lens-client/src/main/java/org/apache/lens/client/LensStatement.java @@ -578,6 +578,27 @@ public class LensStatement { } /** + * Gets the all queries with details. + * + * @param state the state + * @param queryName the query name + * @param user the user + * @param driver the driver name + * @param fromDate the from date + * @param toDate the to date + * @return the all queries as per criteria along with additional details + */ + public List<LensQuery> getAllQueryDetails(String state, String queryName, String user, String driver, + String fromDate, String toDate) { + WebTarget target = getQueryWebTarget(connection.buildClient()); + return target.queryParam("sessionid", connection.getSessionHandle()) + .queryParam("state", state).queryParam("queryName", queryName).queryParam("user", user) + .queryParam("driver", driver).queryParam("fromDate", fromDate).queryParam("toDate", toDate).request() + .get(new GenericType<List<LensQuery>>() { + }); + } + + /** * Gets the all prepared queries. * * @param userName the user name http://git-wip-us.apache.org/repos/asf/lens/blob/5a63a079/lens-server-api/src/main/java/org/apache/lens/server/api/query/QueryExecutionService.java ---------------------------------------------------------------------- diff --git a/lens-server-api/src/main/java/org/apache/lens/server/api/query/QueryExecutionService.java b/lens-server-api/src/main/java/org/apache/lens/server/api/query/QueryExecutionService.java index 575a236..da774fa 100644 --- a/lens-server-api/src/main/java/org/apache/lens/server/api/query/QueryExecutionService.java +++ b/lens-server-api/src/main/java/org/apache/lens/server/api/query/QueryExecutionService.java @@ -241,6 +241,25 @@ public interface QueryExecutionService extends LensService, SessionValidator { List<QueryHandle> getAllQueries(LensSessionHandle sessionHandle, String states, String user, String driver, String queryName, String fromDate, String toDate) throws LensException; + + /** + * Returns all the queries in the specified state, for the given user and matching query name. + * + * @param sessionHandle the session handle + * @param states return queries in these state. if null, all queries will be returned. Multiple states can + * be supplied separated by comma + * @param user Get queries submitted by a specific user. + * If this set to "all", queries of all users are returned + * @param driver Get queries submitted on a specific driver. + * @param queryName return queries containing the query name. If null, all queries will be returned + * @param fromDate start date of time range interval + * @param toDate end date of the time range interval + * @return List of Lens Query object + * @throws LensException the lens exception + */ + List<LensQuery> getAllQueryDetails(LensSessionHandle sessionHandle, String states, String user, String driver, + String queryName, String fromDate, String toDate) throws LensException; + /** * Returns all the prepared queries for the specified user. If no user is passed, queries of all users will be * returned. http://git-wip-us.apache.org/repos/asf/lens/blob/5a63a079/lens-server/src/main/java/org/apache/lens/server/query/LensServerDAO.java ---------------------------------------------------------------------- diff --git a/lens-server/src/main/java/org/apache/lens/server/query/LensServerDAO.java b/lens-server/src/main/java/org/apache/lens/server/query/LensServerDAO.java index 997b5a8..0aada40 100644 --- a/lens-server/src/main/java/org/apache/lens/server/query/LensServerDAO.java +++ b/lens-server/src/main/java/org/apache/lens/server/query/LensServerDAO.java @@ -40,6 +40,7 @@ import org.apache.commons.dbutils.BeanProcessor; import org.apache.commons.dbutils.DbUtils; import org.apache.commons.dbutils.QueryRunner; import org.apache.commons.dbutils.ResultSetHandler; +import org.apache.commons.dbutils.RowProcessor; import org.apache.commons.dbutils.handlers.BeanHandler; import org.apache.commons.lang3.StringUtils; import org.apache.hadoop.conf.Configuration; @@ -183,6 +184,54 @@ public class LensServerDAO { } } + private class NestedResultHandler<T> implements ResultSetHandler<T> { + + private final Class<T> type; + private final RowProcessor convert; + + public NestedResultHandler(Class<T> type, RowProcessor convert) { + this.type = type; + this.convert = convert; + } + + @Override + public T handle(ResultSet rs) throws SQLException { + return this.convert.toBean(rs, this.type); + } + } + + private class QueryHandleNestedHandler implements ResultSetHandler<QueryHandle> { + + @Override + public QueryHandle handle(ResultSet rs) throws SQLException { + try { + return QueryHandle.fromString(rs.getString(1)); + } catch (IllegalArgumentException exc) { + log.warn("Warning invalid query handle found in DB " + rs.getString(1)); + return null; + } + } + } + + /** + * Find finished queries. + * + * @param states the state + * @param user the user + * @param driverName the driver's fully qualified Name + * @param queryName the query name + * @param fromDate the from date + * @param toDate the to date + * @return the list + * @throws LensException the lens exception + */ + public List<FinishedLensQuery> findFinishedQueryDetails(List<QueryStatus.Status> states, String user, + String driverName, String queryName, long fromDate, long toDate) throws LensException { + ResultSetHandler<FinishedLensQuery> handler = new NestedResultHandler<>(FinishedLensQuery.class, + new BasicRowProcessor(new FinishedLensQueryBeanProcessor())); + return findInternal(states, user, driverName, queryName, fromDate, toDate, handler, "*"); + } + /** * Find finished queries. * @@ -197,11 +246,17 @@ public class LensServerDAO { */ public List<QueryHandle> findFinishedQueries(List<QueryStatus.Status> states, String user, String driverName, String queryName, long fromDate, long toDate) throws LensException { - StringBuilder builder = new StringBuilder("SELECT handle FROM finished_queries"); - List<Object> params = null; + + ResultSetHandler<QueryHandle> handler = new QueryHandleNestedHandler(); + return findInternal(states, user, driverName, queryName, fromDate, toDate, handler, "handle"); + } + + private <T> List<T> findInternal(List<QueryStatus.Status> states, String user, String driverName, String queryName, + long fromDate, long toDate, final ResultSetHandler<T> handler, String projection) throws LensException { + StringBuilder builder = new StringBuilder("SELECT " + projection + " FROM finished_queries"); + List<Object> params = new ArrayList<>(3); builder.append(" WHERE "); - List<String> filters = new ArrayList<String>(3); - params = new ArrayList<Object>(3); + List<String> filters = new ArrayList<>(3); if (states != null && !states.isEmpty()) { StringBuilder statusFilterBuilder = new StringBuilder("status in ("); @@ -234,19 +289,18 @@ public class LensServerDAO { params.add(toDate); builder.append(StringUtils.join(filters, " AND ")); - ResultSetHandler<List<QueryHandle>> resultSetHandler = new ResultSetHandler<List<QueryHandle>>() { + ResultSetHandler<List<T>> resultSetHandler = new ResultSetHandler<List<T>>() { @Override - public List<QueryHandle> handle(ResultSet resultSet) throws SQLException { - List<QueryHandle> queryHandleList = new ArrayList<QueryHandle>(); + public List<T> handle(ResultSet resultSet) throws SQLException { + List<T> results = new ArrayList<T>(); while (resultSet.next()) { - String handle = resultSet.getString(1); try { - queryHandleList.add(QueryHandle.fromString(handle)); - } catch (IllegalArgumentException exc) { - log.warn("Warning invalid query handle found in DB " + handle); + results.add(handler.handle(resultSet)); + } catch (RuntimeException e) { + log.warn("Unable to handle row " + LensServerDAO.toString(resultSet), e); } } - return queryHandleList; + return results; } }; @@ -259,4 +313,15 @@ public class LensServerDAO { } } + private static String toString(ResultSet resultSet) { + try { + StringBuilder builder = new StringBuilder(); + for (int index = 1; index <= resultSet.getMetaData().getColumnCount(); index++) { + builder.append(index > 1 ? ", " : "").append(resultSet.getString(index)); + } + return builder.toString(); + } catch (SQLException e) { + return "Error : " + e.getMessage(); + } + } } http://git-wip-us.apache.org/repos/asf/lens/blob/5a63a079/lens-server/src/main/java/org/apache/lens/server/query/QueryExecutionServiceImpl.java ---------------------------------------------------------------------- diff --git a/lens-server/src/main/java/org/apache/lens/server/query/QueryExecutionServiceImpl.java b/lens-server/src/main/java/org/apache/lens/server/query/QueryExecutionServiceImpl.java index dafe93d..0bb106e 100644 --- a/lens-server/src/main/java/org/apache/lens/server/query/QueryExecutionServiceImpl.java +++ b/lens-server/src/main/java/org/apache/lens/server/query/QueryExecutionServiceImpl.java @@ -2562,6 +2562,54 @@ public class QueryExecutionServiceImpl extends BaseLensService implements QueryE /* * (non-Javadoc) * + * @see org.apache.lens.server.api.query.QueryExecutionService#getAllQueryDetails( + * org.apache.lens.api.LensSessionHandle, java.lang.String, java.lang.String, + * java.lang.String, java.lang.String, long, long) + */ + @Override + public List<LensQuery> getAllQueryDetails(LensSessionHandle sessionHandle, String states, String userName, + String driver, String queryName, String fromDate, String toDate) throws LensException { + long fromTime = -1; + long toTime = Long.MAX_VALUE; + Date now = new Date(); + if (fromDate != null) { + fromTime = DateUtil.resolveDate(fromDate, now).getTime(); + } + if (toDate != null) { + toTime = DateUtil.resolveDate(toDate, now).getTime(); + } + validateTimeRange(fromTime, toTime); + try { + acquire(sessionHandle); + + if (StringUtils.isBlank(userName)) { + userName = getSession(sessionHandle).getLoggedInUser(); + } + Set<Status> statuses = getStatuses(states); + List<QueryHandle> inMemoryHandles = getQueriesInMemory(statuses, userName, driver, queryName, + fromTime, toTime); + Set<LensQuery> result = new HashSet<>(); + for (QueryHandle handle : inMemoryHandles) { + QueryContext ctx = allQueries.get(handle); + if (ctx == null) { + continue; + } + result.add(ctx.toLensQuery()); + } + + List<LensQuery> persistedQueries = getPersistedQueries(userName, driver, queryName, + fromTime, toTime, statuses); + result.addAll(persistedQueries); + + return new ArrayList<>(result); + } finally { + release(sessionHandle); + } + } + + /* + * (non-Javadoc) + * * @see org.apache.lens.server.api.query.QueryExecutionService#getAllQueries(org.apache.lens.api.LensSessionHandle, * java.lang.String, java.lang.String, java.lang.String, java.lang.String, long, long) */ @@ -2578,78 +2626,130 @@ public class QueryExecutionServiceImpl extends BaseLensService implements QueryE toTime = DateUtil.resolveDate(toDate, now).getTime(); } validateTimeRange(fromTime, toTime); - userName = UtilityMethods.removeDomain(userName); - Set<Status> statuses; + try { acquire(sessionHandle); - try { - if (StringUtils.isNotBlank(states)) { - statuses = Sets.newHashSet(); - for(String state: states.split(",")) { - statuses.add(Status.valueOf(state.trim().toUpperCase())); - } - } else { - statuses = Sets.newHashSet(Status.values()); - } - } catch (IllegalArgumentException e) { - throw new BadRequestException("Bad state argument passed, possible values are " + Status.values(), e); - } - boolean filterByQueryName = StringUtils.isNotBlank(queryName); - if (filterByQueryName) { - queryName = queryName.toLowerCase(); - } if (StringUtils.isBlank(userName)) { userName = getSession(sessionHandle).getLoggedInUser(); } - boolean filterByDriver = StringUtils.isNotBlank(driver); + Set<Status> statuses = getStatuses(states); + List<QueryHandle> result = getQueriesInMemory(statuses, userName, driver, queryName, + fromTime, toTime); + List<QueryHandle> persistedQueries = getPersistedQueryHandles(userName, driver, queryName, + fromTime, toTime, statuses); - List<QueryHandle> all = new ArrayList<QueryHandle>(allQueries.keySet()); - Iterator<QueryHandle> itr = all.iterator(); - while (itr.hasNext()) { - QueryHandle q = itr.next(); - QueryContext context = allQueries.get(q); - long querySubmitTime = context.getSubmissionTime(); - if ((!statuses.contains(context.getStatus().getStatus())) - || (filterByQueryName && !context.getQueryName().toLowerCase().contains(queryName)) - || (filterByDriver && !context.getSelectedDriver().getFullyQualifiedName().equalsIgnoreCase(driver)) - || (!"all".equalsIgnoreCase(userName) && !userName.equalsIgnoreCase(context.getSubmittedUser())) - || (!(fromTime <= querySubmitTime && querySubmitTime < toTime))) { - itr.remove(); - } + HashSet<QueryHandle> deduplicatedResults = new HashSet<>(result); + deduplicatedResults.addAll(persistedQueries); + return new ArrayList<>(deduplicatedResults); + } finally { + release(sessionHandle); + } + } + + private List<LensQuery> getPersistedQueries(String userName, String driver, String queryName, + long fromTime, long toTime, Set<Status> statuses) throws LensException { + // Unless user wants to get queries in 'non finished' state, get finished queries from DB as well + List<Status> finishedStatusesQueried = finishedStatuses(statuses); + if (finishedStatusesQueried == null || !finishedStatusesQueried.isEmpty()) { + if ("all".equalsIgnoreCase(userName)) { + userName = null; + } + List<FinishedLensQuery> results = lensServerDao.findFinishedQueryDetails(finishedStatusesQueried, + userName, driver, queryName, fromTime, toTime); + List<LensQuery> persistedQueries = new ArrayList<>(); + for (FinishedLensQuery finishedLensQuery : results) { + persistedQueries.add(finishedLensQuery.toQueryContext(conf, drivers.values()).toLensQuery()); + } + if (!persistedQueries.isEmpty()) { + log.info("Adding persisted queries {}", persistedQueries.size()); + return persistedQueries; } + } + return Collections.emptyList(); + } - // Unless user wants to get queries in 'non finished' state, get finished queries from DB as well - List<Status> finishedStatusesQueried = null; - if (statuses.size() != Status.values().length) { - finishedStatusesQueried = Lists.newArrayList(); - for (Status status: statuses) { - switch(status) { - case CANCELED: - case SUCCESSFUL: - case FAILED: - finishedStatusesQueried.add(status); - break; - default: - break; - } + private List<Status> finishedStatuses(Set<Status> statuses) { + List<Status> finishedStatusesQueried = null; + if (statuses.size() != Status.values().length) { + finishedStatusesQueried = Lists.newArrayList(); + for (Status status: statuses) { + switch(status) { + case CANCELED: + case SUCCESSFUL: + case FAILED: + finishedStatusesQueried.add(status); + break; + default: + break; } } - if (finishedStatusesQueried == null || !finishedStatusesQueried.isEmpty()) { - if ("all".equalsIgnoreCase(userName)) { - userName = null; - } - List<QueryHandle> persistedQueries = lensServerDao.findFinishedQueries(finishedStatusesQueried, userName, - driver, queryName, fromTime, toTime); - if (persistedQueries != null && !persistedQueries.isEmpty()) { - log.info("Adding persisted queries {}", persistedQueries.size()); - all.addAll(persistedQueries); + } + return finishedStatusesQueried; + } + + private List<QueryHandle> getPersistedQueryHandles(String userName, String driver, String queryName, + long fromTime, long toTime, Set<Status> statuses) throws LensException { + // Unless user wants to get queries in 'non finished' state, get finished queries from DB as well + List<Status> finishedStatusesQueried = finishedStatuses(statuses); + if (finishedStatusesQueried == null || !finishedStatusesQueried.isEmpty()) { + if ("all".equalsIgnoreCase(userName)) { + userName = null; + } + List<QueryHandle> persistedQueries = lensServerDao.findFinishedQueries(finishedStatusesQueried, userName, + driver, queryName, fromTime, toTime); + if (persistedQueries != null && !persistedQueries.isEmpty()) { + log.info("Adding persisted queries {}", persistedQueries.size()); + return persistedQueries; + } + } + return Collections.emptyList(); + } + + private List<QueryHandle> getQueriesInMemory(Set<Status> statuses, String userName, String driver, + String queryName, long fromTime, long toTime) throws LensException { + + userName = UtilityMethods.removeDomain(userName); + boolean filterByQueryName = StringUtils.isNotBlank(queryName); + if (filterByQueryName) { + queryName = queryName.toLowerCase(); + } + + boolean filterByDriver = StringUtils.isNotBlank(driver); + + List<QueryHandle> all = new ArrayList<QueryHandle>(allQueries.keySet()); + Iterator<QueryHandle> itr = all.iterator(); + while (itr.hasNext()) { + QueryHandle q = itr.next(); + QueryContext context = allQueries.get(q); + long querySubmitTime = context.getSubmissionTime(); + if ((!statuses.contains(context.getStatus().getStatus())) + || (filterByQueryName && !context.getQueryName().toLowerCase().contains(queryName)) + || (filterByDriver && !context.getSelectedDriver().getFullyQualifiedName().equalsIgnoreCase(driver)) + || (!"all".equalsIgnoreCase(userName) && !userName.equalsIgnoreCase(context.getSubmittedUser())) + || (!(fromTime <= querySubmitTime && querySubmitTime < toTime))) { + itr.remove(); + } + } + return all; + } + + private Set<Status> getStatuses(String states) { + Set<Status> statuses; + try { + if (StringUtils.isNotBlank(states)) { + statuses = Sets.newHashSet(); + for(String state: states.split(",")) { + statuses.add(Status.valueOf(state.trim().toUpperCase())); } + } else { + statuses = Sets.newHashSet(Status.values()); } - return all; - } finally { - release(sessionHandle); + } catch (IllegalArgumentException e) { + throw new BadRequestException("Bad state argument passed, possible values are " + + Arrays.toString(Status.values()), e); } + return statuses; } /* http://git-wip-us.apache.org/repos/asf/lens/blob/5a63a079/lens-server/src/main/java/org/apache/lens/server/query/QueryServiceResource.java ---------------------------------------------------------------------- diff --git a/lens-server/src/main/java/org/apache/lens/server/query/QueryServiceResource.java b/lens-server/src/main/java/org/apache/lens/server/query/QueryServiceResource.java index 4aa7872..d53fbbf 100644 --- a/lens-server/src/main/java/org/apache/lens/server/query/QueryServiceResource.java +++ b/lens-server/src/main/java/org/apache/lens/server/query/QueryServiceResource.java @@ -126,6 +126,38 @@ public class QueryServiceResource { } /** + * Get all the queries in the query server; can be filtered with state and queryName. This will by default only return + * queries submitted by the user that has started the session. To get queries of all users, set the searchAllUsers + * parameter to false. + * + * @param sessionid The sessionid in which queryName is working + * @param states If any state is passed, all the queries in that state will be returned, otherwise all queries will + * be returned. Possible states are {link QueryStatus.Status#values()}. Multiple states can be + * passed as comma separated string + * @param queryName If any queryName is passed, all the queries containing the queryName will be returned, otherwise + * all the queries will be returned + * @param user Returns queries submitted by this user. If set to "all", returns queries of all users. By default, + * returns queries of the current user. + * @param driver Get queries submitted on a specific driver. + * @param fromDate from date to search queries in a time range, the range is inclusive(submitTime >= fromDate) + * from date can be a long value indicating timestamp, or it can be in a format acceptable in + * time_range_in function. Notably: yyyy[-MM[-dd[-HH-[mm...]]]], or now based relative format + * @param toDate to date to search queries in a time range, the range is inclusive(toDate > submitTime) + * possible formats it can take is same as fromDate + * @return List of {@link LensQuery} objects + */ + @GET + @Path("queries/detail") + @Produces({MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON, MediaType.TEXT_PLAIN}) + public List<LensQuery> getAllQueryDetails(@QueryParam("sessionid") LensSessionHandle sessionid, + @QueryParam("state") String states, @QueryParam("queryName") String queryName, @QueryParam("user") String user, + @QueryParam("driver") String driver, @QueryParam("fromDate") String fromDate, @QueryParam("toDate") String toDate) + throws LensException { + validateSessionId(sessionid); + return queryServer.getAllQueryDetails(sessionid, states, user, driver, queryName, fromDate, toDate); + } + + /** * Submit the query for explain or execute or execute with a timeout. * * @param sessionid The session in which user is submitting the query. Any configuration set in the session will http://git-wip-us.apache.org/repos/asf/lens/blob/5a63a079/lens-server/src/test/java/org/apache/lens/server/query/TestQueryService.java ---------------------------------------------------------------------- diff --git a/lens-server/src/test/java/org/apache/lens/server/query/TestQueryService.java b/lens-server/src/test/java/org/apache/lens/server/query/TestQueryService.java index 45a753d..f755508 100644 --- a/lens-server/src/test/java/org/apache/lens/server/query/TestQueryService.java +++ b/lens-server/src/test/java/org/apache/lens/server/query/TestQueryService.java @@ -84,6 +84,7 @@ import org.glassfish.jersey.media.multipart.FormDataBodyPart; import org.glassfish.jersey.media.multipart.FormDataContentDisposition; import org.glassfish.jersey.media.multipart.FormDataMultiPart; import org.glassfish.jersey.test.TestProperties; +import org.junit.Assert; import org.testng.annotations.*; import com.codahale.metrics.MetricRegistry; @@ -1932,4 +1933,37 @@ public class TestQueryService extends LensJerseyTest { TestQueryNotifictaionResource.clearState(); } + + @Test + public void testGetQueryDetails() throws IOException, InterruptedException, LensException { + + UUID queryName = UUID.randomUUID(); + WebTarget target = target().path("queryapi/queries"); + final FormDataMultiPart mp = new FormDataMultiPart(); + mp.bodyPart(new FormDataBodyPart(FormDataContentDisposition.name("sessionid").build(), lensSessionId, + MediaType.APPLICATION_XML_TYPE)); + mp.bodyPart(new FormDataBodyPart(FormDataContentDisposition.name("query").build(), "select ID, IDSTR from " + + TEST_TABLE)); + mp.bodyPart(new FormDataBodyPart(FormDataContentDisposition.name("operation").build(), "execute_with_timeout")); + mp.bodyPart(new FormDataBodyPart(FormDataContentDisposition.name("timeoutmillis").build(), "300000")); + mp.bodyPart(new FormDataBodyPart(FormDataContentDisposition.name("queryName").build(), queryName.toString())); + mp.bodyPart(new FormDataBodyPart(FormDataContentDisposition.name("conf").fileName("conf").build(), new LensConf(), + MediaType.APPLICATION_XML_TYPE)); + + QueryHandleWithResultSet result = target.request(MediaType.APPLICATION_XML_TYPE) + .post(Entity.entity(mp, MediaType.MULTIPART_FORM_DATA_TYPE), + new GenericType<LensAPIResult<QueryHandleWithResultSet>>() {}).getData(); + assertNotNull(result.getQueryHandle()); + assertNotNull(result.getResult()); + + target = target().path("queryapi/queries/detail"); + List<LensQuery> results = target.queryParam("queryName", queryName) + .queryParam("sessionid", lensSessionId) + .request(MediaType.APPLICATION_XML_TYPE) + .get(new GenericType<List<LensQuery>>(){}); + Assert.assertNotNull(results); + Assert.assertEquals(1, results.size()); + Assert.assertEquals(queryName.toString(), results.get(0).getQueryName()); + Assert.assertEquals(result.getQueryHandle(), results.get(0).getQueryHandle()); + } }