private void assertProcessInstance(Long pid, int processState, int slaStatus) { assertThat(pid).isNotNull(); ProcessInstance pi = queryClient.findProcessInstanceById(pid); assertThat(pi.getState()).isEqualTo(processState); assertThat(pi.getSlaCompliance()).isEqualTo(slaStatus); if (slaStatus != SLA_NA) { assertThat(pi.getSlaDueDate()).isCloseTo(new Date(), 30000); } }
@After public void abortAllProcesses() { List<Integer> status = new ArrayList<Integer>(); status.add(ProcessInstance.STATE_ACTIVE); List<org.kie.server.api.model.instance.ProcessInstance> activeInstances = queryClient.findProcessInstancesByStatus(status, 0, 100); if (activeInstances != null) { for (org.kie.server.api.model.instance.ProcessInstance instance : activeInstances) { processClient.abortProcessInstance(instance.getContainerId(), instance.getId()); } } }
List<VariableInstance> variables = queryServicesClient.findVariablesCurrentState(processInstanceId);
@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 testGetProcessInstanceDiagramSummaryCompletedStatus() { ProcessInstanceKey instanceKey = new ProcessInstanceKey(serverTemplateId, containerId, processInstanceId); String svgContent = "<svg></svg>"; Integer state = org.kie.api.runtime.process.ProcessInstance.STATE_COMPLETED; String processName = "process"; when(queryServicesClient.findProcessInstanceById(processInstanceId)).thenReturn(ProcessInstance.builder().id(processInstanceId).processId(processId).containerId(containerId).state(state).processName(processName).build()); when(processImageService.getProcessInstanceDiagram(serverTemplateId, containerId, processInstanceId)).thenReturn(svgContent); when(processServicesClient.getProcessDefinition(containerId, processId)).thenReturn(new ProcessDefinition()); ProcessInstanceDiagramSummary summary = service.getProcessInstanceDiagramSummary(instanceKey); assertEquals(processInstanceId, summary.getId()); assertEquals(processName, summary.getName()); assertEquals(svgContent, summary.getSvgContent()); assertNotNull(summary.getProcessDefinition()); assertThat(summary.getProcessDefinition().getNodes()).isEmpty(); assertThat(summary.getProcessDefinition().getTimers()).isEmpty(); assertThat(summary.getNodeInstances()).isEmpty(); assertThat(summary.getTimerInstances()).isEmpty(); verify(queryServicesClient, never()).findActiveNodeInstances(any(), any(), any()); verify(queryServicesClient, never()).findCompletedNodeInstances(any(), any(), any()); verify(processAdminServicesClient, never()).getTimerInstances(any(), any()); }
try { queryClient.registerQuery(query); List<QueryDefinition> queries = queryClient.getQueries(0, 100); assertEquals(query.getTarget(), registeredQuery.getTarget()); registeredQuery = queryClient.getQuery(query.getName()); assertEquals(query.getTarget(), registeredQuery.getTarget()); List<ProcessInstance> instances = queryClient.query(query.getName(), QueryServicesClient.QUERY_MAP_PI, 0, 10, ProcessInstance.class); assertNotNull(instances); assertEquals(5, instances.size()); queryClient.unregisterQuery(query.getName());
queryClient.setResponseHandler(responseHandler); queryClient.registerQuery(query); queryClient.setResponseHandler(new RequestReplyResponseHandler()); KieServerSynchronization.waitForQuery(queryClient, query); List<TaskInstance> tasks = queryClient.query(query.getName(), QueryServicesClient.QUERY_MAP_TASK, 0, 10, TaskInstance.class); assertThat(tasks).isNotNull().hasSize(1); Long taskId = tasks.get(0).getId(); queryClient.setResponseHandler(responseHandler); queryClient.replaceQuery(query); queryClient.setResponseHandler(new RequestReplyResponseHandler()); KieServerSynchronization.waitForQuery(queryClient, query); tasks = queryClient.query(query.getName(), QueryServicesClient.QUERY_MAP_TASK, 0, 10, TaskInstance.class); assertThat(tasks).isNotNull().isEmpty(); tasks = queryClient.query(query.getName(), QueryServicesClient.QUERY_MAP_TASK, 0, 10, TaskInstance.class); assertThat(tasks).isNotNull().hasSize(1); assertThat(tasks.get(0).getId()).isEqualTo(taskId); queryClient.setResponseHandler(new RequestReplyResponseHandler()); queryClient.unregisterQuery(query.getName()); throw e; queryClient.setResponseHandler(responseHandler); queryClient.unregisterQuery(query.getName());
(KieServicesClient client) -> { QueryServicesClient instanceQueryClient = client.getServicesClient(QueryServicesClient.class); QueryDefinition registered = instanceQueryClient.replaceQuery(queryDefinition); if (registered.getColumns() != null) { return queryClient.query( dataSetLookup.getDataSetUUID(), QueryServicesClient.QUERY_MAP_RAW, ); } catch (Exception e) { queryClient.unregisterQuery(dataSetLookup.getDataSetUUID()); throw new RuntimeException(e); return queryClient.query( dataSetLookup.getDataSetUUID(), QueryServicesClient.QUERY_MAP_RAW,
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()); } } }
@Test public void testProcessWithDecisionTask() throws Exception { Long processInstanceId = null; try { Map<String, Object> parameters = new HashMap<>(); parameters.put("age", 16); parameters.put("yearsOfService", 1); processInstanceId = processClient.startProcess(CONTAINER_ID, DECISION_PROCESS_ID, parameters); assertNotNull(processInstanceId); assertTrue(processInstanceId.longValue() > 0); ProcessInstance processInstance = queryClient.findProcessInstanceById(processInstanceId); assertNotNull(processInstance); assertEquals(org.kie.api.runtime.process.ProcessInstance.STATE_COMPLETED, processInstance.getState().intValue()); List<VariableInstance> variables = queryClient.findVariablesCurrentState(processInstanceId); assertNotNull(variables); assertEquals(4, variables.size()); Map<String, String> mappedVars = variables.stream().collect(Collectors.toMap(VariableInstance::getVariableName, VariableInstance::getValue)); assertEquals("27", mappedVars.get("vacationDays")); processInstanceId = null; } finally { if (processInstanceId != null) { processClient.abortProcessInstance(CONTAINER_ID, processInstanceId); } } }
@Override public List<ProcessSummary> getProcesses(String serverTemplateId, Integer page, Integer pageSize, String sort, Boolean sortOrder) { if (serverTemplateId == null || serverTemplateId.isEmpty()) { return emptyList(); } QueryServicesClient queryServicesClient = getClient(serverTemplateId, QueryServicesClient.class); List<ProcessDefinition> processes = queryServicesClient.findProcesses(page, pageSize, sort, sortOrder); return processes.stream().map(new ProcessSummaryMapper()).collect(toList()); }
@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; } }
List<NodeInstance> instances = queryClient.findActiveNodeInstances(processInstanceId, 0, 10); assertNotNull(instances); assertEquals(1, instances.size()); assertNotNull(nodeInstance.getDate()); nodeInstance = queryClient.findNodeInstanceByWorkItemId(processInstanceId, nodeInstance.getWorkItemId()); assertNodeInstance(expectedFirstTask, nodeInstance); assertNotNull(nodeInstance.getWorkItemId()); assertNotNull(nodeInstance.getDate()); instances = queryClient.findCompletedNodeInstances(processInstanceId, 0, 10); assertNotNull(instances); assertEquals(1, instances.size()); assertNotNull(nodeInstance.getDate()); instances = queryClient.findNodeInstances(processInstanceId, 0, 10); assertNotNull(instances); assertEquals(3, instances.size());
private void assertQueryDefinition(final QueryServicesClient client, final String name) { QueryDefinition qd = client.getQuery(name); assertNotNull(qd); }
List<ProcessInstance> returnedProcessInstances = new ArrayList<ProcessInstance>(); ProcessInstance instance = queryClient.findProcessInstanceById(processInstanceId); returnedProcessInstances.add(instance); instance = queryClient.findProcessInstanceByCorrelationKey(key); returnedProcessInstances.add(instance); List<ProcessInstance> processInstances = queryClient.findProcessInstancesByCorrelationKey(key, 0, 100); assertNotNull(processInstances);
@Test public void testPerformQueryRegularMode() { QueryFilterSpec filterSpec = new QueryFilterSpec(); ConsoleDataSetLookup dataSetLookup = Mockito.mock(ConsoleDataSetLookup.class); when(dataSetLookup.testMode()).thenReturn(false); when(dataSetLookup.getNumberOfRows()).thenReturn(10); when(dataSetLookup.getRowOffset()).thenReturn(1); when(dataSetLookup.getDataSetUUID()).thenReturn(""); kieServerDataSetProvider.performQuery(dataSetDef, dataSetLookup, queryServicesClient, filterSpec); verify(kieServerIntegration, times(0)).broadcastToKieServers(anyString(), any()); verify(dataSetLookup, times(1)).testMode(); verify(queryServicesClient).query(anyString(), anyString(), any(QueryFilterSpec.class), anyInt(), anyInt(), any()); }
@Override public List<NodeInstanceSummary> getProcessInstanceActiveNodes(ProcessInstanceKey processInstanceKey) { if (processInstanceKey == null || processInstanceKey.isValid() == false) { return emptyList(); } QueryServicesClient queryServicesClient = getClient(processInstanceKey.getServerTemplateId(), QueryServicesClient.class); List<NodeInstance> nodeInstances = queryServicesClient.findActiveNodeInstances(processInstanceKey.getProcessInstanceId(), 0, Integer.MAX_VALUE); return nodeInstances.stream().map(new NodeInstanceSummaryMapper()).collect(toList()); }
@Override public List<NodeInstanceSummary> getProcessInstanceCompletedNodes(ProcessInstanceKey processInstanceKey) { if (processInstanceKey == null || processInstanceKey.isValid() == false) { return emptyList(); } QueryServicesClient queryServicesClient = getClient(processInstanceKey.getServerTemplateId(), QueryServicesClient.class); List<NodeInstance> nodeInstances = queryServicesClient.findCompletedNodeInstances(processInstanceKey.getProcessInstanceId(), 0, Integer.MAX_VALUE); return nodeInstances.stream().map(new NodeInstanceSummaryMapper()).collect(toList()); }
List<VariableInstance> currentState = queryClient.findVariablesCurrentState(processInstanceId); assertNotNull(currentState); assertEquals(3, currentState.size()); List<VariableInstance> varHistory = queryClient.findVariableHistory(processInstanceId, "stringData", 0, 10); assertNotNull(varHistory); assertEquals(1, varHistory.size()); currentState = queryClient.findVariablesCurrentState(processInstanceId); assertNotNull(currentState); assertEquals(3, currentState.size()); varHistory = queryClient.findVariableHistory(processInstanceId, "stringData", 0, 10); assertNotNull(varHistory); assertEquals(2, varHistory.size());
@Override public ProcessInstanceSummary getProcessInstanceByCorrelationKey(String serverTemplateId, String correlationKey) { if (serverTemplateId == null || serverTemplateId.isEmpty()) { return null; } QueryServicesClient queryServicesClient = getClient(serverTemplateId, QueryServicesClient.class); ProcessInstance processInstance = queryServicesClient.findProcessInstanceByCorrelationKey(new CorrelationKey() { @Override public String toExternalForm() { return correlationKey; } @Override public List<CorrelationProperty<?>> getProperties() { return null; } @Override public String getName() { return correlationKey; } }); return new ProcessInstanceSummaryMapper(serverTemplateId).apply(processInstance); }