protected void loadAndRegisterQueryDefinitions(InputStream qdStream, org.kie.server.api.marshalling.Marshaller marshaller, String containerId) throws IOException { if (qdStream != null) { String qdString = IOUtils.toString(qdStream, Charset.forName("UTF-8")); try { QueryDefinition[] queryDefinitionList = marshaller.unmarshall(qdString, QueryDefinition[].class); List<String> queries = new ArrayList<>(); Arrays.asList(queryDefinitionList).forEach(qd -> { queryService.replaceQuery(QueryDataServiceBase.build(context, qd)); queries.add(qd.getName()); logger.debug("Registered '{}' query from container '{}' successfully", qd.getName(), containerId); }); if (containerId != null) { containerQueries.put(containerId, queries); } } catch (MarshallingException e) { logger.error("Error when unmarshalling query definitions from stream.", e); } } }
protected void registerQueriesWithRetry(String serverTemplateId, String serverInstanceId, Set<QueryDefinition> queryDefinitions) throws Exception{ long waitLimit = 5 * 60 * 1000; // default 5 min long elapsed = 0; QueryServicesClient queryClient = kieServerIntegration.getAdminServerClient(serverTemplateId).getServicesClient(QueryServicesClient.class); while (elapsed < waitLimit) { try { Iterator<QueryDefinition> definitionIt = queryDefinitions.iterator(); while (definitionIt.hasNext()) { QueryDefinition definition = definitionIt.next(); queryClient.replaceQuery(definition); LOGGER.info("Query definition {} (type {}) successfully registered on kie server '{}'", definition.getName(), definition.getTarget(), serverInstanceId); // remove successfully stored definition to avoid duplicated reads in case of intermediate error definitionIt.remove(); } event.fire(new KieServerDataSetRegistered(serverInstanceId, serverTemplateId)); return; } catch (KieServicesException | KieServerHttpRequestException e) { // unable to register, might still be booting Thread.sleep(500); elapsed += 500; // get admin client with forced check of endpoints as they might have been banned (marked as failed) queryClient = kieServerIntegration.getAdminServerClientCheckEndpoints(serverTemplateId).getServicesClient(QueryServicesClient.class); LOGGER.debug("Cannot reach KIE Server, elapsed time while waiting '{}', max time '{}' error {}", elapsed, waitLimit, e.getMessage()); } } }
private void assertKjarOneQuery(QueryDefinition registeredQuery) { Assertions.assertThat(registeredQuery).isNotNull(); Assertions.assertThat(registeredQuery.getName()).isEqualTo(KJAR_ONE_REGISTERED_QUERY); Assertions.assertThat(registeredQuery.getSource()).isEqualTo("${org.kie.server.persistence.ds}"); Assertions.assertThat(registeredQuery.getExpression()).isEqualTo("select * from ProcessInstanceLog"); Assertions.assertThat(registeredQuery.getTarget()).isEqualTo("PROCESS"); }
private void assertKjarOneUpdatedQuery(QueryDefinition registeredQuery) { Assertions.assertThat(registeredQuery).isNotNull(); Assertions.assertThat(registeredQuery.getName()).isEqualTo(KJAR_ONE_UPDATED_FIRST_REGISTERED_QUERY); Assertions.assertThat(registeredQuery.getSource()).isEqualTo("${org.kie.server.persistence.ds}"); Assertions.assertThat(registeredQuery.getExpression()).isEqualTo("select * from NodeInstanceLog"); Assertions.assertThat(registeredQuery.getTarget()).isEqualTo("CUSTOM"); }
private void assertKjarWithDuplicateQueriesResultQuery(QueryDefinition registeredQuery) { Assertions.assertThat(registeredQuery).isNotNull(); Assertions.assertThat(registeredQuery.getName()).isEqualTo(KJAR_DUPLICATE_QUERIES_REGISTERED_QUERY); Assertions.assertThat(registeredQuery.getSource()).isEqualTo("${org.kie.server.persistence.ds}"); Assertions.assertThat(registeredQuery.getExpression()).isEqualTo("select * from AuditTaskImpl where status = 'InProgress'"); Assertions.assertThat(registeredQuery.getTarget()).isEqualTo("CUSTOM"); }
private void assertKjarTwoQuery(QueryDefinition registeredQuery) { Assertions.assertThat(registeredQuery).isNotNull(); Assertions.assertThat(registeredQuery.getName()).isEqualTo(KJAR_TWO_REGISTERED_QUERY); Assertions.assertThat(registeredQuery.getSource()).isEqualTo("${org.kie.server.persistence.ds}"); Assertions.assertThat(registeredQuery.getExpression()).isEqualTo("select * from VariableInstanceLog"); Assertions.assertThat(registeredQuery.getTarget()).isEqualTo("CUSTOM"); }
@Override public QueryDefinition replaceQuery(QueryDefinition queryDefinition) { QueryDefinition result = null; if (config.isRest()) { Map<String, Object> valuesMap = new HashMap<String, Object>(); valuesMap.put(QUERY_NAME, queryDefinition.getName()); result = makeHttpPutRequestAndCreateCustomResponse(build(loadBalancer.getUrl(), QUERY_DEF_URI + "/" + REPLACE_QUERY_DEF_PUT_URI, valuesMap), queryDefinition, QueryDefinition.class, new HashMap<String, String>()); } else { CommandScript script = new CommandScript(Collections.singletonList((KieServerCommand) new DescriptorCommand("QueryDataService", "replaceQuery", serialize(queryDefinition), marshaller.getFormat().getType(), new Object[]{queryDefinition.getName()}))); ServiceResponse<QueryDefinition> response = (ServiceResponse<QueryDefinition>) executeJmsCommand(script, DescriptorCommand.class.getName(), "BPM").getResponses().get(0); throwExceptionOnFailure(response); if (shouldReturnWithNullResponse(response)) { return null; } result = response.getResult(); } return result; }
@Override public QueryDefinition registerQuery(QueryDefinition queryDefinition) { QueryDefinition result = null; if (config.isRest()) { Map<String, Object> valuesMap = new HashMap<String, Object>(); valuesMap.put(QUERY_NAME, queryDefinition.getName()); result = makeHttpPostRequestAndCreateCustomResponse(build(loadBalancer.getUrl(), QUERY_DEF_URI + "/" + CREATE_QUERY_DEF_POST_URI, valuesMap), queryDefinition, QueryDefinition.class); } else { CommandScript script = new CommandScript(Collections.singletonList((KieServerCommand) new DescriptorCommand("QueryDataService", "registerQuery", serialize(queryDefinition), marshaller.getFormat().getType(), new Object[]{queryDefinition.getName()}))); ServiceResponse<QueryDefinition> response = (ServiceResponse<QueryDefinition>) executeJmsCommand(script, DescriptorCommand.class.getName(), "BPM").getResponses().get(0); throwExceptionOnFailure(response); if (shouldReturnWithNullResponse(response)) { return null; } result = response.getResult(); } return result; }
@Override public QueryDefinition replaceQuery(QueryDefinition queryDefinition) { CommandScript script = new CommandScript(Collections.singletonList((KieServerCommand) new DescriptorCommand("QueryDataService", "replaceQuery", WebSocketUtils.marshal(queryDefinition), MarshallingFormat.JSON.toString(), new Object[]{queryDefinition.getName()}))); sendCommandToAllSessions(script, new WebSocketServiceResponse(true, (message) -> { WebSocketUtils.unmarshal(message, ServiceResponsesList.class); return null; })).getResponses(); return queryDefinition; }
protected void registerDataSetDefinition(final QueryDefinition queryDefinition, final Consumer<RemoteDataSetDefBuilder> consumer) { RemoteDataSetDefBuilder builder = RemoteDataSetDefBuilder.get() .uuid(queryDefinition.getName()) .name(queryDefinition.getTarget() + "-" + queryDefinition.getName()) .queryTarget(queryDefinition.getTarget()) .dataSource(queryDefinition.getSource()) .dbSQL(queryDefinition.getExpression(), false); consumer.accept(builder); DataSetDef dataSetDef = builder.buildDef(); dataSetDef.setPublic(false); dataSetDef.setProvider(KieServerDataSetProvider.TYPE); dataSetDefRegistry.registerDataSetDef(dataSetDef); LOGGER.info("Data Set registered {}", dataSetDef); } }
protected static SqlQueryDefinition build(KieServerRegistry context, QueryDefinition queryDefinition) { SqlQueryDefinition actualDefinition = new SqlQueryDefinition(queryDefinition.getName(), queryDefinition.getSource()); actualDefinition.setExpression(queryDefinition.getExpression()); actualDefinition.setTarget(org.jbpm.services.api.query.model.QueryDefinition.Target.valueOf(queryDefinition.getTarget())); return actualDefinition; } }
@Test public void testGetProcessInstancesWithQueryDataServiceUsingCustomQueryBuilder() throws Exception { Map<String, Object> parameters = new HashMap<String, Object>(); parameters.put("stringData", "waiting for signal"); parameters.put("personData", createPersonInstance(USER_JOHN)); List<Long> processInstanceIds = createProcessInstances(parameters); QueryDefinition query = createQueryDefinition("CUSTOM"); try { queryClient.registerQuery(query); Map<String, Object> params = new HashMap<String, Object>(); params.put("min", processInstanceIds.get(4)); params.put("max", processInstanceIds.get(0)); List<ProcessInstance> instances = queryClient.query(query.getName(), QueryServicesClient.QUERY_MAP_PI, "test", params, 0, 10, ProcessInstance.class); assertNotNull(instances); assertEquals(2, instances.size()); } finally { abortProcessInstances(processInstanceIds); queryClient.unregisterQuery(query.getName()); } }
@Test public void testQueryDataServiceUsingCustomQueryBuilderFilterSpecWithOrderByClause() throws Exception { Map<String, Object> parameters = new HashMap<String, Object>(); parameters.put("stringData", "waiting for signal"); parameters.put("personData", createPersonInstance(USER_JOHN)); List<Long> processInstanceIds = createProcessInstances(parameters); QueryDefinition query = createQueryDefinition("CUSTOM"); try { queryClient.registerQuery(query); Map<String, Object> params = new HashMap<String, Object>(); params.put("min", processInstanceIds.get(1)); params.put("max", processInstanceIds.get(0)); params.put(KieServerConstants.QUERY_ORDER_BY_CLAUSE, "processId asc , processInstanceId desc"); List<ProcessInstance> instances = queryClient.query(query.getName(), QueryServicesClient.QUERY_MAP_PI, "test", params, 0, 10, ProcessInstance.class); assertNotNull(instances); assertEquals(5, instances.size()); long pi1 = instances.get(0).getId(); long pi2 = instances.get(1).getId(); // since sort order is descending first should be instance id which is bigger then second assertTrue(pi1 + " not greater than " + pi2, pi1 > pi2); } finally { abortProcessInstances(processInstanceIds); queryClient.unregisterQuery(query.getName()); } }
@Test public void testGetProcessInstancesWithQueryDataServiceUsingCustomQueryBuilderAndCustomParameters() throws Exception { Map<String, Object> parameters = new HashMap<String, Object>(); parameters.put("stringData", "waiting for signal"); parameters.put("personData", createPersonInstance(USER_JOHN)); List<Long> processInstanceIds = createProcessInstances(parameters); QueryDefinition query = createQueryDefinition("CUSTOM"); try { queryClient.registerQuery(query); Map<String, Object> params = new HashMap<String, Object>(); params.put("customparams", Arrays.asList(createCustomParameterInstance("min", processInstanceIds.get(4)), createCustomParameterInstance("max", processInstanceIds.get(0)))); List<ProcessInstance> instances = queryClient.query(CONTAINER_ID, query.getName(), QueryServicesClient.QUERY_MAP_PI, "test", params, 0, 10, ProcessInstance.class); assertNotNull(instances); assertEquals(2, instances.size()); } finally { abortProcessInstances(processInstanceIds); queryClient.unregisterQuery(query.getName()); } }
@Test public void testGetProcessInstancesWithQueryDataServiceUsingCustomMapper() throws Exception { Map<String, Object> parameters = new HashMap<String, Object>(); parameters.put("stringData", "waiting for signal"); parameters.put("personData", createPersonInstance(USER_JOHN)); List<Long> processInstanceIds = createProcessInstances(parameters); QueryDefinition query = createQueryDefinition("CUSTOM"); try { queryClient.registerQuery(query); List<ProcessInstance> instances = queryClient.query(query.getName(), "CustomMapper", 0, 10, ProcessInstance.class); assertNotNull(instances); assertEquals(5, instances.size()); List<Long> found = collectInstances(instances); assertEquals(processInstanceIds, found); instances = queryClient.query(query.getName(), "CustomMapper", 0, 3, ProcessInstance.class); assertNotNull(instances); assertEquals(3, instances.size()); instances = queryClient.query(query.getName(), "CustomMapper", "status", 1, 3, ProcessInstance.class); assertNotNull(instances); assertEquals(2, instances.size()); } finally { abortProcessInstances(processInstanceIds); queryClient.unregisterQuery(query.getName()); } }
@Test public void testInvalidQuery() { QueryDefinition query = new QueryDefinition(); query.setName("invalidQuery"); query.setSource(System.getProperty("org.kie.server.persistence.ds", "jdbc/jbpm-ds")); query.setExpression("this is an invalid query"); query.setTarget("CUSTOM"); try { assertClientException( () -> queryClient.registerQuery(query), 500, "Can't get metadata on specified data set: invalidQuery"); assertClientException( () -> queryClient.getQuery(query.getName()), 404, "Could not find query definition with name \"" + query.getName() + "\"", "Query invalidQuery not found"); } catch (Throwable e) { try { queryClient.unregisterQuery(query.getName()); } catch (KieServicesException ex) { // expected in case the query wasn't registered } throw e; } }
@Test public void testGetProcessInstancesWithOrderByClause() throws Exception { Map<String, Object> parameters = new HashMap<String, Object>(); parameters.put("stringData", "waiting for signal"); parameters.put("personData", createPersonInstance(USER_JOHN)); List<Long> processInstanceIds = createProcessInstances(parameters); QueryDefinition query = createQueryDefinition("CUSTOM"); try { queryClient.registerQuery(query); List<ProcessInstance> instances = queryClient.query(query.getName(), QueryServicesClient.QUERY_MAP_PI, "processId asc, processInstanceId desc", 0, 10, ProcessInstance.class); assertNotNull(instances); assertEquals(5, instances.size()); List<Long> found = collectInstances(instances); assertEquals(processInstanceIds, found); long pi1 = instances.get(0).getId(); long pi2 = instances.get(1).getId(); // since sort order is descending first should be instance id which is bigger then second assertTrue(pi1 + " not greater than " + pi2, pi1 > pi2); } finally { abortProcessInstances(processInstanceIds); queryClient.unregisterQuery(query.getName()); } }
@Test public void testGetProcessInstanceCustomWithoutVarsMapper() throws Exception { Map<String, Object> parameters = new HashMap<String, Object>(); parameters.put("stringData", "waiting for signal"); parameters.put("personData", createPersonInstance(CONTAINER_ID)); Long pid = processClient.startProcess(CONTAINER_ID, PROCESS_ID_USERTASK, parameters); QueryDefinition query = new QueryDefinition(); query.setName("jbpmProcessSearch"); query.setSource(System.getProperty("org.kie.server.persistence.ds", "jdbc/jbpm-ds")); query.setExpression("select p.PROCESSINSTANCEID, p.PROCESSID, p.PROCESSNAME, p.PROCESSVERSION, p.STATUS, p.EXTERNALID, " + "pr.STARTDATE as START_DATE, p.USER_IDENTITY, p.PROCESSINSTANCEDESCRIPTION, p.CORRELATIONKEY, " + "p.PARENTPROCESSINSTANCEID, pr.LASTMODIFICATIONDATE from PROCESSINSTANCELOG p " + "inner join PROCESSINSTANCEINFO pr on p.PROCESSINSTANCEID = pr.INSTANCEID"); query.setTarget("CUSTOM"); try { queryClient.registerQuery(query); List<ProcessInstanceCustomVars> instance = queryClient.query(query.getName(), QueryServicesClient.QUERY_MAP_PI_CUSTOM, 0, 10, ProcessInstanceCustomVars.class); assertNotNull(instance); assertEquals(1, instance.size()); assertNull(instance.get(0).getVariables()); } finally { processClient.abortProcessInstance(CONTAINER_ID, pid); queryClient.unregisterQuery(query.getName()); } }
@Test public void testGetTasksWithPotentialOwnerDoubleGroup() throws Exception { changeUser(USER_JOHN); Long pidOne = processClient.startProcess(CONTAINER_ID, PROCESS_ID_USERTASK_DOUBLE_GROUP); Long pidTwo = processClient.startProcess(CONTAINER_ID, PROCESS_ID_USERTASK_DOUBLE_GROUP); QueryDefinition query = getTasksWithPotentialOwnerQueryDefinition(); try { queryClient.registerQuery(query); List<org.kie.server.api.model.instance.TaskSummary> test = taskClient.findTasksAssignedAsPotentialOwner(USER_JOHN, 0, 10); assertNotNull(test); assertEquals(2, test.size()); QueryFilterSpec filterSpec = new QueryFilterSpecBuilder().in("processInstanceId", Arrays.asList(pidOne, pidTwo)).get(); List<TaskInstance> tasks = queryClient.query(query.getName(), QueryServicesClient.QUERY_MAP_TASK, filterSpec, 0, 10, TaskInstance.class); assertNotNull(tasks); assertEquals(2, tasks.size()); } finally { processClient.abortProcessInstance(CONTAINER_ID, pidOne); processClient.abortProcessInstance(CONTAINER_ID, pidTwo); queryClient.unregisterQuery(query.getName()); changeUser(USER_YODA); } }
@Test public void testQueryDefinitionsFromKjar() throws Exception { String expectedResolvedDS = System.getProperty("org.kie.server.persistence.ds", "jdbc/jbpm-ds"); QueryDefinition registeredQuery = queryClient.getQuery("first-query"); assertNotNull(registeredQuery); assertEquals("first-query", registeredQuery.getName()); assertEquals(expectedResolvedDS, registeredQuery.getSource()); assertEquals("select * from ProcessInstanceLog", registeredQuery.getExpression()); assertEquals("PROCESS", registeredQuery.getTarget()); registeredQuery = queryClient.getQuery("second-query"); assertNotNull(registeredQuery); assertEquals("second-query", registeredQuery.getName()); assertEquals(expectedResolvedDS, registeredQuery.getSource()); assertEquals("select * from NodeInstanceLog", registeredQuery.getExpression()); assertEquals("CUSTOM", registeredQuery.getTarget()); }