List<Container> updateContainerProcessConfig(final ProcessConfig processConfig, final Capability capability, final ServerTemplate serverTemplate, final ContainerSpec containerSpec) { containerSpec.getConfigs().put(capability, processConfig); return kieServerInstanceManager.upgradeContainer(serverTemplate, containerSpec); }
@Test public void testSetRuleConfigAttributesWhenRuleConfigIsNull() { final Map<?, ?> configs = mock(Map.class); doReturn(null).when(configs).get(Capability.RULE); doReturn(configs).when(containerSpec).getConfigs(); instanceManager.setRuleConfigAttributes(containerSpec, containerResource); verify(containerResource, never()).setScanner(any()); }
private ContainerSpec copy(final ContainerSpec origin, final String newServerTemplateId, final String newServerTemplateName) { final Map<Capability, ContainerConfig> configMap = origin.getConfigs(); for (Map.Entry<Capability, ContainerConfig> entry : origin.getConfigs().entrySet()) { configMap.put(entry.getKey(), copy(entry.getValue())); } return new ContainerSpec(origin.getId(), origin.getContainerName(), new ServerTemplateKey(newServerTemplateId, newServerTemplateName), new ReleaseId(origin.getReleasedId()), origin.getStatus(), configMap); }
void setRuleConfigAttributes(final ContainerSpec containerSpec, final KieContainerResource containerResource) { final ContainerConfig containerConfig = containerSpec.getConfigs().get(Capability.RULE); if (containerConfig != null) { final RuleConfig ruleConfig = (RuleConfig) containerConfig; final KieScannerResource scannerResource = new KieScannerResource(); scannerResource.setPollInterval(ruleConfig.getPollInterval()); scannerResource.setStatus(ruleConfig.getScannerStatus()); containerResource.setScanner(scannerResource); } }
@Test public void testUpdateContainerProcessConfig() { final SpecManagementServiceImpl specManagementService = (SpecManagementServiceImpl) this.specManagementService; final ProcessConfig processConfig = mock(ProcessConfig.class); final Capability capability = Capability.PROCESS; final ServerTemplate serverTemplate = mock(ServerTemplate.class); final ContainerSpec containerSpec = mock(ContainerSpec.class); final Map<Capability, ProcessConfig> configs = spy(new HashMap<>()); final List<?> expectedContainers = mock(List.class); doReturn(configs).when(containerSpec).getConfigs(); doReturn(expectedContainers).when(kieServerInstanceManager).upgradeContainer(serverTemplate, containerSpec); final List<Container> actualContainers = specManagementService.updateContainerProcessConfig(processConfig, capability, serverTemplate, containerSpec); assertEquals(expectedContainers, actualContainers); }
@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()); }
@Test public void testSetRuleConfigAttributesWhenRuleConfigIsNotNull() { final Map<?, ?> configs = mock(Map.class); final RuleConfig containerConfig = mock(RuleConfig.class); final ArgumentCaptor<KieScannerResource> scannerResourceCaptor = ArgumentCaptor.forClass(KieScannerResource.class); final Long pollInterval = 1L; final KieScannerStatus scannerStatus = KieScannerStatus.CREATED; doReturn(pollInterval).when(containerConfig).getPollInterval(); doReturn(scannerStatus).when(containerConfig).getScannerStatus(); doReturn(containerConfig).when(configs).get(Capability.RULE); doReturn(configs).when(containerSpec).getConfigs(); instanceManager.setRuleConfigAttributes(containerSpec, containerResource); verify(containerResource).setScanner(scannerResourceCaptor.capture()); final KieScannerResource scannerResource = scannerResourceCaptor.getValue(); assertEquals(pollInterval, scannerResource.getPollInterval()); assertEquals(scannerStatus, scannerResource.getStatus()); }
@Test public void testUpdateContainerConfigWhenAffectedContainersIsEmpty() { final SpecManagementServiceImpl specManagementService = spy((SpecManagementServiceImpl) this.specManagementService); final String serverTemplateId = "serverTemplateId"; final String containerSpecId = "containerSpecId"; final Capability capability = Capability.PROCESS; final ContainerConfig containerConfig = mock(ContainerConfig.class); final ServerTemplate serverTemplate = mock(ServerTemplate.class); final ContainerSpec containerSpec = mock(ContainerSpec.class); final Map<Capability, ContainerConfig> configs = spy(new HashMap<>()); final List<?> expectedContainers = new ArrayList<>(); specManagementService.setTemplateStorage(templateStorage); specManagementService.setNotificationService(notificationService); doReturn(serverTemplate).when(templateStorage).load(serverTemplateId); doReturn(containerSpec).when(serverTemplate).getContainerSpec(containerSpecId); doReturn(expectedContainers).when(specManagementService).updateContainerConfig(capability, containerConfig, serverTemplate, containerSpec); doReturn(configs).when(containerSpec).getConfigs(); specManagementService.updateContainerConfig(serverTemplateId, containerSpecId, capability, containerConfig); verify(specManagementService).logInfo("Update of container configuration resulted in no changes to containers running on kie-servers"); verify(specManagementService, never()).logDebug(any(), any()); verify(configs).put(capability, containerConfig); verify(templateStorage).update(serverTemplate); verify(notificationService).notify(any(ServerTemplateUpdated.class)); }
@Override public synchronized void updateContainerConfig(final String serverTemplateId, final String containerSpecId, final Capability capability, final ContainerConfig containerConfig) { final ServerTemplate serverTemplate = templateStorage.load(serverTemplateId); if (serverTemplate == null) { throw new KieServerControllerIllegalArgumentException("No server template found for id " + serverTemplateId); } final ContainerSpec containerSpec = serverTemplate.getContainerSpec(containerSpecId); if (containerSpec == null) { throw new KieServerControllerIllegalArgumentException("No container spec found for id " + containerSpecId + " within server template with id " + serverTemplateId); } final List<Container> affectedContainers = updateContainerConfig(capability, containerConfig, serverTemplate, containerSpec); if (affectedContainers.isEmpty()) { logInfo("Update of container configuration resulted in no changes to containers running on kie-servers"); } affectedContainers.forEach(ac -> { logDebug("Container {} on server {} was affected by a change in the scanner", ac.getContainerSpecId(), ac.getServerInstanceKey()); }); containerSpec.getConfigs().put(capability, containerConfig); templateStorage.update(serverTemplate); notificationService.notify(new ServerTemplateUpdated(serverTemplate)); }
@Override public void startScanner(final ContainerSpecKey containerSpecKey, final Long interval) { ServerTemplate serverTemplate = templateStorage.load(containerSpecKey.getServerTemplateKey().getId()); if (serverTemplate == null) { throw new KieServerControllerIllegalArgumentException("No server template found for id " + containerSpecKey.getServerTemplateKey().getId()); } ContainerSpec containerSpec = serverTemplate.getContainerSpec(containerSpecKey.getId()); if (containerSpec == null) { throw new KieServerControllerIllegalArgumentException("No container spec found for id " + containerSpecKey.getId()); } ContainerConfig containerConfig = containerSpec.getConfigs().get(Capability.RULE); if (containerConfig == null) { containerConfig = new RuleConfig(); containerSpec.getConfigs().put(Capability.RULE, containerConfig); } ((RuleConfig) containerConfig).setPollInterval(interval); ((RuleConfig) containerConfig).setScannerStatus(KieScannerStatus.STARTED); templateStorage.update(serverTemplate); List<Container> containers = kieServerInstanceManager.startScanner(serverTemplate, containerSpec, interval); notificationService.notify(serverTemplate, containerSpec, containers); }
@Override public void stopScanner(final ContainerSpecKey containerSpecKey) { ServerTemplate serverTemplate = templateStorage.load(containerSpecKey.getServerTemplateKey().getId()); if (serverTemplate == null) { throw new KieServerControllerIllegalArgumentException("No server template found for id " + containerSpecKey.getServerTemplateKey().getId()); } ContainerSpec containerSpec = serverTemplate.getContainerSpec(containerSpecKey.getId()); if (containerSpec == null) { throw new KieServerControllerIllegalArgumentException("No container spec found for id " + containerSpecKey.getId()); } ContainerConfig containerConfig = containerSpec.getConfigs().get(Capability.RULE); if (containerConfig == null) { containerConfig = new RuleConfig(); containerSpec.getConfigs().put(Capability.RULE, containerConfig); } if(((RuleConfig) containerConfig).getScannerStatus() == KieScannerStatus.STOPPED){ return; } ((RuleConfig) containerConfig).setPollInterval(null); ((RuleConfig) containerConfig).setScannerStatus(KieScannerStatus.STOPPED); templateStorage.update(serverTemplate); List<Container> containers = kieServerInstanceManager.stopScanner(serverTemplate, containerSpec); notificationService.notify(serverTemplate, containerSpec, containers); }
@Test public void testStopScanner() { List<Container> fakeResult = new ArrayList<Container>(); fakeResult.add(container); when(kieServerInstanceManager.stopScanner(any(ServerTemplate.class), any(ContainerSpec.class))).thenReturn(fakeResult); ruleCapabilitiesService.stopScanner(containerSpec); verify(kieServerInstanceManager, times(1)).stopScanner(any(ServerTemplate.class), any(ContainerSpec.class)); ServerTemplate updated = specManagementService.getServerTemplate(serverTemplate.getId()); Collection<ContainerSpec> containerSpecs = updated.getContainersSpec(); assertNotNull(containerSpecs); assertEquals(1, containerSpecs.size()); ContainerSpec updatedContainer = containerSpecs.iterator().next(); assertNotNull(updatedContainer); ContainerConfig ruleConfig = updatedContainer.getConfigs().get(Capability.RULE); assertNotNull(ruleConfig); assertTrue(ruleConfig instanceof RuleConfig); RuleConfig ruleCg = (RuleConfig) ruleConfig; assertEquals(KieScannerStatus.STOPPED, ruleCg.getScannerStatus()); assertNull(ruleCg.getPollInterval()); }
@Test public void testMakeContainerResourceWhenConfigsIsNull() { final String id = "id"; final ReleaseId releaseId = mock(ReleaseId.class); final ReleaseId resolvedReleasedId = mock(ReleaseId.class); final KieContainerStatus status = KieContainerStatus.CREATING; final String containerName = "containerName"; final Collection<Message> messages = new ArrayList<>(); doReturn(id).when(containerSpec).getId(); doReturn(releaseId).when(containerSpec).getReleasedId(); doReturn(resolvedReleasedId).when(container).getResolvedReleasedId(); doReturn(status).when(container).getStatus(); doReturn(containerName).when(containerSpec).getContainerName(); doReturn(messages).when(container).getMessages(); doReturn(null).when(containerSpec).getConfigs(); final KieContainerResource resource = instanceManager.makeContainerResource(container, containerSpec); assertEquals(id, resource.getContainerId()); assertEquals(releaseId, resource.getReleaseId()); assertEquals(resolvedReleasedId, resource.getResolvedReleaseId()); assertEquals(status, resource.getStatus()); assertEquals(containerName, resource.getContainerAlias()); assertEquals(messages, resource.getMessages()); verify(instanceManager, never()).setRuleConfigAttributes(any(), any()); verify(instanceManager, never()).setProcessConfigAttributes(any(), any()); }
@Test public void testMakeContainerResourceWhenConfigsIsNotNull() { final String id = "id"; final ReleaseId releaseId = mock(ReleaseId.class); final ReleaseId resolvedReleasedId = mock(ReleaseId.class); final KieContainerStatus status = KieContainerStatus.CREATING; final String containerName = "containerName"; final Collection<Message> messages = new ArrayList<>(); final Map<?, ?> configs = mock(Map.class); doReturn(id).when(containerSpec).getId(); doReturn(releaseId).when(containerSpec).getReleasedId(); doReturn(resolvedReleasedId).when(container).getResolvedReleasedId(); doReturn(status).when(container).getStatus(); doReturn(containerName).when(containerSpec).getContainerName(); doReturn(messages).when(container).getMessages(); doReturn(configs).when(containerSpec).getConfigs(); final KieContainerResource resource = instanceManager.makeContainerResource(container, containerSpec); assertEquals(id, resource.getContainerId()); assertEquals(releaseId, resource.getReleaseId()); assertEquals(resolvedReleasedId, resource.getResolvedReleaseId()); assertEquals(status, resource.getStatus()); assertEquals(containerName, resource.getContainerAlias()); assertEquals(messages, resource.getMessages()); verify(instanceManager).setRuleConfigAttributes(containerSpec, resource); verify(instanceManager).setProcessConfigAttributes(containerSpec, resource); }
void setProcessConfigAttributes(final ContainerSpec containerSpec, final KieContainerResource containerResource) { final ContainerConfig containerConfig = containerSpec.getConfigs().get(Capability.PROCESS); if (containerConfig != null) { final ProcessConfig processConfig = (ProcessConfig) containerConfig; containerResource.addConfigItem(makeKieServerConfigItem(KieServerConstants.CAPABILITY_BPM, KieServerConstants.PCFG_KIE_BASE, processConfig.getKBase())); containerResource.addConfigItem(makeKieServerConfigItem(KieServerConstants.CAPABILITY_BPM, KieServerConstants.PCFG_KIE_SESSION, processConfig.getKSession())); containerResource.addConfigItem(makeKieServerConfigItem(KieServerConstants.CAPABILITY_BPM, KieServerConstants.PCFG_MERGE_MODE, processConfig.getMergeMode())); containerResource.addConfigItem(makeKieServerConfigItem(KieServerConstants.CAPABILITY_BPM, KieServerConstants.PCFG_RUNTIME_STRATEGY, processConfig.getRuntimeStrategy())); } }
@Test public void testStartScanner() { List<Container> fakeResult = new ArrayList<Container>(); fakeResult.add(container); when(kieServerInstanceManager.startScanner(any(ServerTemplate.class), any(ContainerSpec.class), anyLong())).thenReturn(fakeResult); ruleCapabilitiesService.startScanner(containerSpec, 100l); verify(kieServerInstanceManager, times(1)).startScanner(any(ServerTemplate.class), any(ContainerSpec.class), anyLong()); ServerTemplate updated = specManagementService.getServerTemplate(serverTemplate.getId()); Collection<ContainerSpec> containerSpecs = updated.getContainersSpec(); assertNotNull(containerSpecs); assertEquals(1, containerSpecs.size()); ContainerSpec updatedContainer = containerSpecs.iterator().next(); assertNotNull(updatedContainer); ContainerConfig ruleConfig = updatedContainer.getConfigs().get(Capability.RULE); assertNotNull(ruleConfig); assertTrue(ruleConfig instanceof RuleConfig); RuleConfig ruleCg = (RuleConfig) ruleConfig; assertEquals(KieScannerStatus.STARTED, ruleCg.getScannerStatus()); assertEquals(100l, ruleCg.getPollInterval().longValue()); }
@Test public void testSetProcessConfigAttributesWhenProcessConfigIsNotNull() { final Map<?, ?> configs = mock(Map.class); final ProcessConfig processConfig = new ProcessConfig("runtimeStrategy", "kBase", "kSession", "mergeMode"); final KieContainerResource containerResource = spy(new KieContainerResource()); final List<KieServerConfigItem> actualConfigItems = containerResource.getConfigItems(); final KieServerConfigItem expectedConfigItem0 = configItem(KieServerConstants.CAPABILITY_BPM, KieServerConstants.PCFG_KIE_BASE, processConfig.getKBase()); final KieServerConfigItem expectedConfigItem1 = configItem(KieServerConstants.CAPABILITY_BPM, KieServerConstants.PCFG_KIE_SESSION, processConfig.getKSession()); final KieServerConfigItem expectedConfigItem2 = configItem(KieServerConstants.CAPABILITY_BPM, KieServerConstants.PCFG_MERGE_MODE, processConfig.getMergeMode()); final KieServerConfigItem expectedConfigItem3 = configItem(KieServerConstants.CAPABILITY_BPM, KieServerConstants.PCFG_RUNTIME_STRATEGY, processConfig.getRuntimeStrategy()); doReturn(processConfig).when(configs).get(Capability.PROCESS); doReturn(configs).when(containerSpec).getConfigs(); instanceManager.setProcessConfigAttributes(containerSpec, containerResource); assertEquals(expectedConfigItem0, actualConfigItems.get(0)); assertEquals(expectedConfigItem1, actualConfigItems.get(1)); assertEquals(expectedConfigItem2, actualConfigItems.get(2)); assertEquals(expectedConfigItem3, actualConfigItems.get(3)); assertEquals(4, actualConfigItems.size()); }
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; }
private void updateView(final Collection<Container> containers) { containerStatusEmptyPresenter.setup(containerSpec); containerRemoteStatusPresenter.setup(containerSpec, containers); view.clear(); if (isEmpty(containers)) { view.setStatus(containerStatusEmptyPresenter.getView()); } else { view.setStatus(containerRemoteStatusPresenter.getView()); } view.setContainerName(containerSpec.getContainerName()); view.setGroupIp(containerSpec.getReleasedId().getGroupId()); view.setArtifactId(containerSpec.getReleasedId().getArtifactId()); containerRulesConfigPresenter.setVersion(containerSpec.getReleasedId().getVersion()); containerProcessConfigPresenter.disable(); updateStatus(containerSpec.getStatus() != null ? containerSpec.getStatus() : KieContainerStatus.STOPPED); for (Map.Entry<Capability, ContainerConfig> entry : containerSpec.getConfigs().entrySet()) { switch (entry.getKey()) { case RULE: setupRuleConfig((RuleConfig) entry.getValue()); break; case PROCESS: setupProcessConfig((ProcessConfig) entry.getValue()); break; } } }
assertEquals("kie server name", spec.getServerTemplateKey().getName()); assertEquals(KieContainerStatus.STARTED, spec.getStatus()); assertEquals(0, spec.getConfigs().size());