public ServiceResponse<?> checkAccessability() { if (managementDisabled) { return new ServiceResponse<Void>(ServiceResponse.ResponseType.FAILURE, "KIE Server management api is disabled"); } return null; }
/** * Checks whether the specified {@code ServiceResponse} contains the expected result type. In case the type is different, * {@code KieServicesClientException} is thrown. This catches the errors early, before returning the result from the client. * Without this check users could experience {@code ClassCastException} when retrieving the result that does not have * the expected type. */ protected void checkResultType(ServiceResponse<?> serviceResponse, Class<?> expectedResultType) { Object actualResult = serviceResponse.getResult(); if ( actualResult != null && !expectedResultType.isInstance( actualResult ) ) { throw new KieServicesException( "Error while creating service response! The actual result type " + serviceResponse.getResult().getClass() + " does not match the expected type " + expectedResultType + "!" ); } }
@Override public void messageReceived( IoSession session, Object message ) throws Exception { String completeMessage = message.toString(); logger.debug("Received message '{}'", completeMessage); if( completeMessage.trim().equalsIgnoreCase("quit") || completeMessage.trim().equalsIgnoreCase("exit") ) { session.close(false); return; } String[] elements = completeMessage.split("\\|"); logger.debug("Container id {}", elements[0]); try { ServiceResponse<String> result = batchCommandService.callContainer(elements[0], elements[1], MarshallingFormat.JSON, null); if (result.getType().equals(ServiceResponse.ResponseType.SUCCESS)) { session.write(result.getResult()); logger.debug("Successful message written with content '{}'", result.getResult()); } else { session.write(result.getMsg()); logger.debug("Failure message written with content '{}'", result.getMsg()); } } catch (Exception e) { } } }
@Override public ServiceResponse<ExecutionResults> executeCommandsWithResults(String id, String payload) { if( config.isRest() ) { return makeHttpPostRequestAndCreateServiceResponse( loadBalancer.getUrl() + "/containers/instances/" + id, payload, (Class) ExecutionResultImpl.class); } else { CommandScript script = new CommandScript( Collections.singletonList((KieServerCommand) new CallContainerCommand(id, payload)) ); ServiceResponse response = executeJmsCommand( script, null, null, id ).getResponses().get( 0 ); if (shouldReturnWithNullResponse(response)) { return null; } if (response.getResult() instanceof String) { response.setResult(deserialize((String) response.getResult(), (Class) ExecutionResultImpl.class)); } return response; } }
protected void collectContainerInfo(ContainerSpec containerSpec, KieServicesClient client, Container container) { // collect up to date information ServiceResponse<KieContainerResource> serviceResponse = client.getContainerInfo(containerSpec.getId()); if (serviceResponse.getType().equals(ServiceResponse.ResponseType.SUCCESS)) { KieContainerResource containerResource = serviceResponse.getResult(); container.setResolvedReleasedId(containerResource.getResolvedReleaseId() == null ? containerResource.getReleaseId() : containerResource.getResolvedReleaseId()); container.setMessages(containerResource.getMessages()); } }
private ServiceResponse<KieScannerResource> disposeScanner(String id, KieContainerInstanceImpl kci) { List<Message> messages = getMessagesForContainer(id); messages.clear(); if (kci.getScanner() == null) { return new ServiceResponse<KieScannerResource>(ServiceResponse.ResponseType.SUCCESS, "Invalid call. Scanner already disposed.", getScannerResource(kci)); } if (KieScannerStatus.STARTED.equals(mapScannerStatus(kci)) || KieScannerStatus.SCANNING.equals(mapScannerStatus(kci))) { ServiceResponse<KieScannerResource> response = stopScanner(id, kci); if (ResponseType.FAILURE.equals(response.getType())) { return response; } } kci.disposeScanner(); messages.add(new Message(Severity.INFO, "Kie scanner successfully disposed (shut down).")); return new ServiceResponse<KieScannerResource>(ServiceResponse.ResponseType.SUCCESS, "Kie scanner successfully disposed (shut down).", getScannerResource(kci)); }
protected boolean shouldReturnWithNullResponse(ServiceResponse<?> serviceResponse) { if (serviceResponse != null && ServiceResponse.ResponseType.NO_RESPONSE.equals(serviceResponse.getType())){ logger.debug("Returning null as the response type is NO_RESPONSE"); return true; } return false; }
@Test public void testUpdateContainerWithActiveProcessInstance() throws Exception { Long processInstanceId = processClient.startProcess(CONTAINER_ID, PROCESS_ID_USERTASK); try { ServiceResponse<ReleaseId> updateReleaseId = client.updateReleaseId(CONTAINER_ID, releaseId101); KieServerAssert.assertFailure(updateReleaseId); assertEquals("Update of container forbidden - there are active process instances for container " + CONTAINER_ID, updateReleaseId.getMsg()); } finally { processClient.abortProcessInstance(CONTAINER_ID, processInstanceId); } }
@Test public void testGetContainersRemoteOperationWhenResponseTypeIsNotSUCCESS() { doReturn(containerResource).when(response).getResult(); doReturn(response).when(client).getContainerInfo(any()); doReturn(ServiceResponse.ResponseType.FAILURE).when(response).getType(); final KieServerInstanceManager.RemoteKieServerOperation<Void> operation = instanceManager.getContainersRemoteOperation(serverTemplate, containerSpec); operation.doOperation(client, container); verify(container, never()).setContainerSpecId(any()); verify(container, never()).setContainerName(any()); verify(container, never()).setResolvedReleasedId(any()); verify(container, never()).setServerTemplateId(any()); verify(container, never()).setStatus(any()); verify(container, never()).setMessages(any()); }
private ServiceResponse<KieScannerResource> disposeScanner(String id, KieScannerResource resource, KieContainerInstance kci) { if (kci.getScanner() == null) { return new ServiceResponse<KieScannerResource>(ServiceResponse.ResponseType.SUCCESS, "Invalid call. Scanner already disposed. ", getScannerResource(kci)); } if (KieScannerStatus.STARTED.equals(mapStatus(kci.getScanner().getStatus())) || KieScannerStatus.SCANNING.equals(mapStatus(kci.getScanner().getStatus()))) { ServiceResponse<KieScannerResource> response = stopScanner(id, resource, kci); if (ResponseType.FAILURE.equals(response.getType())) { return response; } } kci.getScanner().shutdown(); kci.setScanner(null); return new ServiceResponse<KieScannerResource>(ServiceResponse.ResponseType.SUCCESS, "Kie scanner successfully shutdown.", getScannerResource(kci)); }
@Override public Response createContainer(HttpHeaders headers, String id, KieContainerResource container) { ServiceResponse<KieContainerResource> response = server.createContainer(id, container); if( response.getType() == ServiceResponse.ResponseType.SUCCESS ) { return createCorrectVariant(response, headers, Status.CREATED); } return createCorrectVariant(response, headers, Status.BAD_REQUEST); }
@Override public ServiceResponse<ExecutionResults> executeCommandsWithResults(String id, Command<?> cmd) { if( config.isRest() ) { return makeHttpPostRequestAndCreateServiceResponse( loadBalancer.getUrl() + "/containers/instances/" + id, cmd, (Class)ExecutionResultImpl.class, getHeaders(cmd) ); } else { CommandScript script = new CommandScript( Collections.singletonList( (KieServerCommand) new CallContainerCommand( id, serialize(cmd) ) ) ); ServiceResponse response = executeJmsCommand( script, cmd.getClass().getName(), null, id ).getResponses().get( 0 ); if (shouldReturnWithNullResponse(response)) { return null; } if (response.getResult() instanceof String) { response.setResult(deserialize((String) response.getResult(), (Class) ExecutionResultImpl.class)); } return response; } }
/** * Checks whether the specified {@code ServiceResponse} contains the expected result type. In case the type is different, * {@code KieServicesClientException} is thrown. This catches the errors early, before returning the result from the client. * Without this check users could experience {@code ClassCastException} when retrieving the result that does not have * the expected type. */ private void checkResultType(ServiceResponse<?> serviceResponse, Class<?> expectedResultType) { Object actualResult = serviceResponse.getResult(); if ( actualResult != null && !expectedResultType.isInstance( actualResult ) ) { throw new KieServicesException( "Error while creating service response! The actual result type " + serviceResponse.getResult().getClass() + " does not match the expected type " + expectedResultType + "!" ); } }
@Test public void testGetContainersRemoteOperationWhenResponseTypeIsSUCCESS() { doReturn(containerResource).when(response).getResult(); doReturn(response).when(client).getContainerInfo(any()); doReturn(ServiceResponse.ResponseType.SUCCESS).when(response).getType(); final KieServerInstanceManager.RemoteKieServerOperation<Void> operation = instanceManager.getContainersRemoteOperation(serverTemplate, containerSpec); operation.doOperation(client, container); verify(container).setContainerSpecId(containerResource.getContainerId()); verify(container).setContainerName(containerResource.getContainerId()); verify(container).setResolvedReleasedId(containerResource.getReleaseId()); verify(container).setServerTemplateId(serverTemplate.getId()); verify(container).setStatus(containerResource.getStatus()); verify(container).setMessages(containerResource.getMessages()); }
public ServiceResponse<Void> disposeSolver(String containerId, String solverId) { try { SolverInstanceContext sic = internalDisposeSolver(containerId, solverId); if (sic != null) { return new ServiceResponse<>(ServiceResponse.ResponseType.SUCCESS, "Solver '" + solverId + "' successfully disposed from container '" + containerId + "'", null); } return new ServiceResponse<>(ServiceResponse.ResponseType.FAILURE, "Solver '" + solverId + "' from container '" + containerId + "' not found.", null); } catch (Exception e) { logger.error("Error disposing solver '" + solverId + "' from container '" + containerId + "'", e); return new ServiceResponse<>(ServiceResponse.ResponseType.FAILURE, "Error disposing solver '" + solverId + "' from container '" + containerId + "'. Message: " + e.getMessage(), null); } }
@Test public void testNotAllowedDisposeContainerDueToActiveProcessInstances() throws Exception { KieServerAssert.assertSuccess(client.createContainer(CONTAINER_ID, new KieContainerResource(CONTAINER_ID, releaseId))); Map<String, Object> parameters = new HashMap<String, Object>(); parameters.put("stringData", "waiting for signal"); parameters.put("personData", createPersonInstance(USER_JOHN)); Long processInstanceId = processClient.startProcess(CONTAINER_ID, PROCESS_ID_USERTASK, parameters); // dispose not allowed as there is active process instance ServiceResponse<Void> disposeContainerResponse = client.disposeContainer(CONTAINER_ID); assertEquals(ServiceResponse.ResponseType.FAILURE, disposeContainerResponse.getType()); String failureMessage = disposeContainerResponse.getMsg(); assertEquals(DISPOSE_FAILURE_MSG, failureMessage); // after failed dispose container should be fully operational and in started state ServiceResponse<KieContainerResource> containerResponse = client.getContainerInfo(CONTAINER_ID); assertEquals(ServiceResponse.ResponseType.SUCCESS, containerResponse.getType()); KieContainerResource container = containerResponse.getResult(); assertNotNull(container); assertEquals(KieContainerStatus.STARTED, container.getStatus()); // let's abort the active instance processClient.abortProcessInstance(CONTAINER_ID, processInstanceId); // and now proceed with dispose again which must be successful disposeContainerResponse = client.disposeContainer(CONTAINER_ID); assertEquals(ServiceResponse.ResponseType.SUCCESS, disposeContainerResponse.getType()); } }
private ServiceResponse<KieScannerResource> startScanner(String id, KieScannerResource resource, KieContainerInstance kci) { if (kci.getScanner() == null) { ServiceResponse<KieScannerResource> response = createScanner(id, kci); if (ResponseType.FAILURE.equals(response.getType())) { return response; } } if (KieScannerStatus.STOPPED.equals(mapStatus(kci.getScanner().getStatus())) && resource.getPollInterval() != null) { kci.getScanner().start(resource.getPollInterval()); return new ServiceResponse<KieScannerResource>(ServiceResponse.ResponseType.SUCCESS, "Kie scanner successfully created.", getScannerResource(kci)); } else if (!KieScannerStatus.STOPPED.equals(mapStatus(kci.getScanner().getStatus()))) { return new ServiceResponse<KieScannerResource>(ServiceResponse.ResponseType.FAILURE, "Invalid kie scanner status: " + mapStatus(kci.getScanner().getStatus()), getScannerResource(kci)); } else if (resource.getPollInterval() == null) { return new ServiceResponse<KieScannerResource>(ServiceResponse.ResponseType.FAILURE, "Invalid polling interval: " + resource.getPollInterval(), getScannerResource(kci)); } return new ServiceResponse<KieScannerResource>(ServiceResponse.ResponseType.FAILURE, "Unknown error starting scanner. Scanner was not started." + resource, getScannerResource(kci)); }