@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) { } } }
protected void throwExceptionOnFailure(ServiceResponse<?> serviceResponse) { if (serviceResponse != null && ServiceResponse.ResponseType.FAILURE.equals(serviceResponse.getType())) { throw new KieServicesException(serviceResponse.getMsg()); } } }
protected void throwExceptionOnFailure(ServiceResponse<?> serviceResponse) { if (serviceResponse != null && ServiceResponse.ResponseType.FAILURE.equals(serviceResponse.getType())){ throw new KieServicesException(serviceResponse.getMsg()); } }
logger.debug("Non successful response '{}', returning null", response.getMsg()); return null;
throw new KieServicesException(reply.getMsg());
@Override public void apply(KieServerRegistry kieServerRegistry, KieServer kieServer) { DefaultRestControllerImpl controller = new DefaultRestControllerImpl(kieServerRegistry); List<String> containerAliases = kieServerRegistry.getContainerAliases(); if (containerAliases.isEmpty()) { logger.debug("No containers found, quiting"); return; } for (String alias : containerAliases) { List<KieContainerInstanceImpl> containerInstances = kieServerRegistry.getContainersForAlias(alias); if (containerInstances.isEmpty() || containerInstances.size() == 1) { logger.debug("Containers for alias {} are already on expected level (number of containers is {})", alias, containerInstances.size()); continue; } String latestContainerId = LatestContainerLocator.get().locateContainer(alias, containerInstances); final Map<String, String> report = new HashMap<>(); containerInstances.stream() .filter(kci -> !kci.getContainerId().equals(latestContainerId)) .filter(kci -> !kci.getStatus().equals(KieContainerStatus.CREATING)) .forEach(kci -> { ServiceResponse<Void> response = kieServer.disposeContainer(kci.getContainerId()); report.put(kci.getContainerId(), response.getType().toString()); logger.debug("Dispose of container {} completed with {} message {}", kci.getContainerId(), response.getType().toString(), response.getMsg()); if (response.getType().equals(ServiceResponse.ResponseType.SUCCESS)) { controller.stopContainer(kci.getContainerId()); } }); logger.info("KeepLatestContainerOnlyPolicy applied to {} successfully (report {})", alias, report); } }
@Override public Void doOperation(KieServicesClient client, Container container) { ServiceResponse<Void> response = client.disposeContainer(containerSpec.getId()); if (!response.getType().equals(ServiceResponse.ResponseType.SUCCESS)) { logger.debug("Container {} failed to stop on server instance {} due to {}", containerSpec.getId(), container.getUrl(), response.getMsg()); } collectContainerInfo(containerSpec, client, container); return null; } });
@Test public void testMakeUpgradeContainerOperationWhenResponseTypeIsNotSuccess() { final ServiceResponse.ResponseType responseType = ServiceResponse.ResponseType.FAILURE; final String containerId = "id"; final String url = "url"; final String msg = "msg"; final ReleaseId releaseId = mock(ReleaseId.class); doReturn(containerId).when(containerSpec).getId(); doReturn(releaseId).when(containerSpec).getReleasedId(); doReturn(containerResource).when(instanceManager).makeContainerResource(container, containerSpec); doReturn(response).when(client).updateReleaseId(containerId, releaseId); doReturn(responseType).when(response).getType(); doReturn(msg).when(response).getMsg(); doReturn(url).when(container).getUrl(); doNothing().when(instanceManager).collectContainerInfo(containerSpec, client, container); instanceManager.makeUpgradeContainerOperation(containerSpec).doOperation(client, container); verify(client, never()).createContainer(anyString(), any(KieContainerResource.class)); verify(client).updateReleaseId(containerId, releaseId); verify(instanceManager).collectContainerInfo(containerSpec, client, container); verify(instanceManager).log("Container {} failed to upgrade on server instance {} due to {}", containerId, url, msg); }
@Test public void testMakeUpgradeAndStartContainerOperationWhenResponseTypeIsNotSuccess() { final ServiceResponse.ResponseType responseType = ServiceResponse.ResponseType.FAILURE; final String containerId = "id"; final String url = "url"; final String msg = "msg"; final ReleaseId releaseId = mock(ReleaseId.class); doReturn(containerId).when(containerSpec).getId(); doReturn(releaseId).when(containerSpec).getReleasedId(); doReturn(containerResource).when(instanceManager).makeContainerResource(container, containerSpec); doReturn(response).when(client).updateReleaseId(containerId, releaseId); doReturn(responseType).when(response).getType(); doReturn(msg).when(response).getMsg(); doReturn(url).when(container).getUrl(); doNothing().when(instanceManager).collectContainerInfo(containerSpec, client, container); instanceManager.makeUpgradeAndStartContainerOperation(containerSpec).doOperation(client, container); verify(client).createContainer(containerId, containerResource); verify(client).updateReleaseId(containerId, releaseId); verify(instanceManager).collectContainerInfo(containerSpec, client, container); verify(instanceManager).log("Container {} failed to upgrade on server instance {} due to {}", containerId, url, msg); }
@Override public Void doOperation(KieServicesClient client, Container container) { KieScannerResource scannerResource = new KieScannerResource(); scannerResource.setPollInterval(null); scannerResource.setStatus(KieScannerStatus.SCANNING); ServiceResponse<KieScannerResource> response = client.updateScanner(containerSpec.getId(), scannerResource); if (!response.getType().equals(ServiceResponse.ResponseType.SUCCESS)) { logger.debug("Scanner (scan now) failed on server instance {} due to {}", container.getUrl(), response.getMsg()); } collectContainerInfo(containerSpec, client, container); return null; } });
private void assertForbiddenResponse(Response response) { assertNotNull(response); assertEquals(Response.Status.BAD_REQUEST.getStatusCode(), response.getStatus()); ServiceResponse<?> serviceResponse = marshaller.unmarshall((String) response.getEntity(), ServiceResponse.class); assertNotNull(serviceResponse); assertEquals(ResponseType.FAILURE, serviceResponse.getType()); assertEquals("KIE Server management api is disabled", serviceResponse.getMsg()); } }
@Override public Void doOperation(KieServicesClient client, Container container) { KieScannerResource scannerResource = new KieScannerResource(); scannerResource.setPollInterval(interval); scannerResource.setStatus(KieScannerStatus.STARTED); ServiceResponse<KieScannerResource> response = client.updateScanner(containerSpec.getId(), scannerResource); if (!response.getType().equals(ServiceResponse.ResponseType.SUCCESS)) { logger.debug("Scanner failed to start on server instance {} due to {}", container.getUrl(), response.getMsg()); } collectContainerInfo(containerSpec, client, container); return null; } });
private void remoteUpgradeContainer(final KieServicesClient client, final Container container, final ContainerSpec containerSpec) { final ServiceResponse<ReleaseId> response = client.updateReleaseId(containerSpec.getId(), containerSpec.getReleasedId()); if (response.getType() != ServiceResponse.ResponseType.SUCCESS) { log("Container {} failed to upgrade on server instance {} due to {}", containerSpec.getId(), container.getUrl(), response.getMsg()); } collectContainerInfo(containerSpec, client, container); }
@Override public Void doOperation(KieServicesClient client, Container container) { KieScannerResource scannerResource = new KieScannerResource(); scannerResource.setPollInterval(null); scannerResource.setStatus(KieScannerStatus.STOPPED); ServiceResponse<KieScannerResource> response = client.updateScanner(containerSpec.getId(), scannerResource); if (!response.getType().equals(ServiceResponse.ResponseType.SUCCESS)) { logger.debug("Scanner failed to stop on server instance {} due to {}", container.getUrl(), response.getMsg()); } collectContainerInfo(containerSpec, client, container); return null; } });
@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 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()); } }
Object wrappedResult = ModelWrapper.wrap(everyProblemFactChangeProcessedResponse.getResult()); response = new ServiceResponse<>(everyProblemFactChangeProcessedResponse.getType(), everyProblemFactChangeProcessedResponse.getMsg(), wrappedResult); } else {