protected void createExtraContainer() { KieContainerResource containerResource = new KieContainerResource(CONTAINER_ID_101, releaseId101); containerResource.setContainerAlias(CONTAINER_ALIAS); client.createContainer(CONTAINER_ID_101, containerResource); }
@Override public Void doOperation(KieServicesClient client, Container container) { final ServiceResponse<KieContainerResource> response = client.getContainerInfo(containerSpec.getId()); final KieContainerResource containerResource = response.getResult(); if (response.getType().equals(ServiceResponse.ResponseType.SUCCESS)) { container.setContainerSpecId(containerResource.getContainerId()); container.setContainerName(containerResource.getContainerAlias()); container.setResolvedReleasedId(containerResource.getResolvedReleaseId() == null ? containerResource.getReleaseId() : containerResource.getResolvedReleaseId()); container.setServerTemplateId(serverTemplate.getId()); container.setStatus(containerResource.getStatus()); container.setMessages(containerResource.getMessages()); } return null; } };
protected boolean updateReleaseId() { ReleaseId oldReleaseId = this.resource.getReleaseId(); ReleaseId oldResolvedReleaseId = this.resource.getResolvedReleaseId(); if ( kieContainer != null ) { this.resource.setReleaseId( new ReleaseId( kieContainer.getContainerReleaseId() ) ); this.resource.setResolvedReleaseId( new ReleaseId( kieContainer.getReleaseId() ) ); } if (releaseIdUpdated(oldReleaseId, this.resource.getReleaseId()) || releaseIdUpdated(oldResolvedReleaseId, this.resource.getResolvedReleaseId())) { disposeMarshallers(); return true; } return false; }
protected String getContainerAlias(KieContainerResource containerResource) { String alias = containerResource.getContainerAlias(); if (alias == null || alias.isEmpty()) { alias = containerResource.getReleaseId().getArtifactId(); } return alias; }
public KieContainerInstanceImpl(String containerId, KieContainerStatus status, InternalKieContainer kieContainer, ReleaseId releaseId, KieServerImpl kieServer) { super(); this.kieContainer = kieContainer; this.resource = new KieContainerResource(containerId, releaseId, status); // set the default scanner state to DISPOSED (which is the actual default state) // this way we don't need to do null checks all around for the scanner resource this.resource.setScanner(new KieScannerResource(KieScannerStatus.DISPOSED)); this.marshallers = new ConcurrentHashMap<MarshallingFormat, Marshaller>(); this.serviceContainer = new ConcurrentHashMap<String, Object>(); updateReleaseId(); this.scannerListener = new KieServerScannerEventListener(kieServer, this); }
public ServiceResponse<KieContainerResource> createContainer(String containerId, KieContainerResource container) { if (container == null || container.getReleaseId() == null) { logger.error("Error creating container. Release Id is null: " + container); return new ServiceResponse<KieContainerResource>(ServiceResponse.ResponseType.FAILURE, "Failed to create container " + containerId + ". Release Id is null: " + container + "."); container.setContainerId(containerId); ReleaseId releaseId = container.getReleaseId(); try { KieContainerInstanceImpl ci = new KieContainerInstanceImpl(containerId, KieContainerStatus.CREATING, null, releaseId, this); ci.getResource().setContainerAlias(container.getContainerAlias()); KieContainerInstanceImpl previous = null; if (kieContainer != null) { ci.setKieContainer(kieContainer); ci.getResource().setConfigItems(container.getConfigItems()); ci.getResource().setMessages(messages); logger.debug("Container {} (for release id {}) general initialization: DONE", containerId, releaseId); if (container.getScanner() != null) { ServiceResponse<KieScannerResource> scannerResponse = configureScanner(containerId, ci, container.getScanner()); if (ResponseType.FAILURE.equals(scannerResponse.getType())) { String errorMessage = "Failed to create scanner for container " + containerId + " with module " + releaseId + "."; messages.add(new Message(Severity.ERROR, errorMessage)); ci.getResource().setStatus(KieContainerStatus.FAILED); return new ServiceResponse<KieContainerResource>(ServiceResponse.ResponseType.FAILURE, errorMessage); ci.getResource().setStatus(KieContainerStatus.STARTED); logger.info("Container {} (for release id {}) successfully started", containerId, releaseId); container.setStatus(KieContainerStatus.STARTED);
for (ContainerSpec containerSpec : serverTemplate.getContainersSpec()) { KieContainerResource containerResource = new KieContainerResource(); containerResource.setContainerId(containerSpec.getId()); containerResource.setContainerAlias(containerSpec.getContainerName()); containerResource.setReleaseId(containerSpec.getReleasedId()); containerResource.setStatus(containerSpec.getStatus()); scannerResource.setStatus(ruleConfig.getScannerStatus()); containerResource.setScanner(scannerResource); configItem.setValue(processConfig.getKBase()); containerResource.addConfigItem(configItem); configItem.setValue(processConfig.getKSession()); containerResource.addConfigItem(configItem); configItem.setValue(processConfig.getMergeMode()); containerResource.addConfigItem(configItem); configItem.setValue(processConfig.getRuntimeStrategy()); containerResource.addConfigItem(configItem);
public KieContainerInstance(String containerId, KieContainerStatus status, InternalKieContainer kieContainer) { super(); this.kieContainer = kieContainer; this.resource = new KieContainerResource( containerId, null, status ); this.marshallers = new ConcurrentHashMap<MarshallingFormat, Marshaller>(); updateReleaseId(); }
KieContainerResource resource = new KieContainerResource("kie1", releaseId); ServiceResponse<KieContainerResource> response = client.createContainer("kie1", resource); assertSuccess(response); KieContainerResource container = response.getResult(); assertEquals("Container id", "kie1", container.getContainerId()); assertEquals("Release id", releaseId, container.getReleaseId()); assertEquals("Resolved release Id", releaseId, container.getResolvedReleaseId());
@Test public void testBasicJbpmRequest() throws Exception { KieContainerResource resource = new KieContainerResource(CONTAINER, releaseId); Map<String, Object> valuesMap = new HashMap<String, Object>(); valuesMap.put(CONTAINER_ID, resource.getContainerId()); valuesMap.put(PROCESS_ID, HUMAN_TASK_OWN_TYPE_ID); Response response = null; try { WebTarget clientRequest = newRequest(build(TestConfig.getKieServerHttpUrl(), PROCESS_URI + "/" + START_PROCESS_POST_URI, valuesMap)); logger.info( "[POST] " + clientRequest.getUri()); response = clientRequest.request().post(createEntity("")); Assert.assertEquals(Response.Status.CREATED.getStatusCode(), response.getStatus()); Assertions.assertThat((String)response.getHeaders().getFirst("Content-Type")).startsWith(getMediaType().toString()); JaxbLong pId = response.readEntity(JaxbLong.class); valuesMap.put(PROCESS_INST_ID, pId.unwrap()); clientRequest = newRequest(build(TestConfig.getKieServerHttpUrl(), PROCESS_URI + "/" + ABORT_PROCESS_INST_DEL_URI, valuesMap)); logger.info( "[DELETE] " + clientRequest.getUri()); response = clientRequest.request(getMediaType()).delete(); int noContentStatusCode = Response.Status.NO_CONTENT.getStatusCode(); int okStatusCode = Response.Status.OK.getStatusCode(); assertTrue("Wrong status code returned: " + response.getStatus(), response.getStatus() == noContentStatusCode || response.getStatus() == okStatusCode); } finally { if(response != null) { response.close(); } } }
@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 boolean accept(KieContainerResource kieContainerResource) { if (kieContainerResource == null) { throw new IllegalArgumentException("KieContainerResource can not be null!"); } // in case resolved release id exists, check against that ReleaseId resolvedReleaseId = kieContainerResource.getResolvedReleaseId(); if (resolvedReleaseId != null) { if (!releaseIdFilter.accept(resolvedReleaseId)) { return false; } } else { if (!releaseIdFilter.accept(kieContainerResource.getReleaseId())) { return false; } } KieContainerStatus status = kieContainerResource.getStatus(); if (status != null && !statusFilter.accept(status)) { return false; } // all sub-filters accepted the container, so it is a match return true; }
@Test public void testCreateEmptyContainer() { KieContainerResource containerResource = new KieContainerResource(CONTAINER_ID, releaseId); ServiceResponse<KieContainerResource> createContainer = client.createContainer(CONTAINER_ID, containerResource); KieServerAssert.assertSuccess(createContainer); List<Message> messages = createContainer.getResult().getMessages(); assertThat(messages).hasSize(1); assertThat(messages.get(0).getSeverity()).isEqualTo(Severity.INFO); } }
ReleaseId originalReleaseId = kci.getResource().getReleaseId(); Message updateMessage = updateKieContainerToVersion(kci, releaseId); if (updateMessage.getSeverity().equals(Severity.WARN)) { messages.add(updateMessage); return new ServiceResponse<ReleaseId>(ServiceResponse.ResponseType.FAILURE, "Error updating release id on container " + containerId + " to " + releaseId, kci.getResource().getReleaseId()); if (updateMessage.getSeverity().equals(Severity.WARN)) { messages.add(updateMessage); return new ServiceResponse<ReleaseId>(ServiceResponse.ResponseType.FAILURE, "Error reverting release id update on container " + containerId + " to original release id " + originalReleaseId, kci.getResource().getReleaseId()); messages.add(new Message(Severity.WARN, "Error updating release id on container " + containerId + " to " + releaseId + ", release id returned back to " + kci.getResource().getReleaseId())); return new ServiceResponse<ReleaseId>(ServiceResponse.ResponseType.FAILURE, "Error updating release id on container " + containerId + " to " + releaseId + ", release id returned back to " + kci.getResource().getReleaseId(), kci.getResource().getReleaseId()); List<KieContainerResource> containers = new ArrayList<>(); currentState.getContainers().forEach(containerResource -> { if (containerId.equals(containerResource.getContainerId())) { containerResource.setReleaseId(releaseId); containerResource.setResolvedReleaseId(new ReleaseId(kci.getKieContainer().getContainerReleaseId())); return new ServiceResponse<ReleaseId>(ServiceResponse.ResponseType.SUCCESS, "Release id successfully updated.", kci.getResource().getReleaseId()); } else { return new ServiceResponse<ReleaseId>(ServiceResponse.ResponseType.FAILURE, "Container " + containerId + " is not instantiated.");
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()); } }
KieContainerResource makeContainerResource(final Container container, final ContainerSpec containerSpec) { final KieContainerResource containerResource = new KieContainerResource(containerSpec.getId(), containerSpec.getReleasedId(), container.getResolvedReleasedId(), container.getStatus()); containerResource.setContainerAlias(containerSpec.getContainerName()); containerResource.setMessages((List<Message>) container.getMessages()); if (containerSpec.getConfigs() != null) { setRuleConfigAttributes(containerSpec, containerResource); setProcessConfigAttributes(containerSpec, containerResource); } return containerResource; }
public void installContainersSync(KieServerImpl kieServer, Set<KieContainerResource> containers, KieServerState currentState, KieServerSetup kieServerSetup) { logger.info("About to install containers '{}' on kie server '{}'", containers, kieServer); if (containers == null) { kieServer.markAsReady(); return; } for (KieContainerResource containerResource : containers) { if (KieContainerStatus.STARTED.equals(containerResource.getStatus())) { kieServer.createContainer(containerResource.getContainerId(), containerResource); } else if (KieContainerStatus.DEACTIVATED.equals(containerResource.getStatus())) { kieServer.createContainer(containerResource.getContainerId(), containerResource); kieServer.deactivateContainer(containerResource.getContainerId()); containerResource.setStatus(KieContainerStatus.DEACTIVATED); } } currentState.setContainers(containers); if (kieServerSetup.getServerConfig() != null) { currentState.setConfiguration(kieServerSetup.getServerConfig()); } kieServer.getServerRegistry().getStateRepository().store(KieServerEnvironment.getServerId(), currentState); kieServer.markAsReady(); } }
@Test public void testSetProcessConfigAttributesWhenProcessConfigIsNull() { final Map<?, ?> configs = mock(Map.class); final KieContainerResource containerResource = spy(new KieContainerResource()); final List<KieServerConfigItem> actualConfigItems = containerResource.getConfigItems(); doReturn(null).when(configs).get(Capability.PROCESS); doReturn(configs).when(containerSpec).getConfigs(); instanceManager.setProcessConfigAttributes(containerSpec, containerResource); assertEquals(0, actualConfigItems.size()); }
public ServiceResponse<ReleaseId> getContainerReleaseId(String id) { try { KieContainerInstanceImpl ci = context.getContainer(id); if (ci != null) { return new ServiceResponse<ReleaseId>(ServiceResponse.ResponseType.SUCCESS, "ReleaseId for container " + id, ci.getResource().getReleaseId()); } return new ServiceResponse<ReleaseId>(ServiceResponse.ResponseType.FAILURE, "Container " + id + " is not instantiated."); } catch (Exception e) { logger.error("Error retrieving releaseId for container '" + id + "'", e); return new ServiceResponse<ReleaseId>(ServiceResponse.ResponseType.FAILURE, "Error retrieving container releaseId: " + e.getClass().getName() + ": " + e.getMessage()); } }
@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()); } }