Set<String> existingContainers(final ServerTemplate serverTemplate) { final Collection<ContainerSpec> containersSpec = serverTemplate.getContainersSpec(); return containersSpec .stream() .map(ContainerSpecKey::getId) .collect(Collectors.toSet()); }
public boolean hasContainerSpec(String containerSpecId) { for (ContainerSpec spec : getContainersSpec()) { if (containerSpecId.equals(spec.getId())) { return true; } } return false; }
public ContainerSpec getContainerSpec(String containerSpecId) { for (ContainerSpec spec : getContainersSpec()) { if (containerSpecId.equals(spec.getId())) { return spec; } } return null; }
public ContainerSpec getContainerSpec(String containerSpecId) { for (ContainerSpec spec : getContainersSpec()) { if (containerSpecId.equals(spec.getId())) { return spec; } } return null; }
public boolean hasContainerSpec(String containerSpecId) { for (ContainerSpec spec : getContainersSpec()) { if (containerSpecId.equals(spec.getId())) { return true; } } return false; }
private Map<String, Set<String>> containerNamesByServerTemplateIds(final Map<String, ServerTemplate> serverTemplatesIds) { return Maps.transformEntries(serverTemplatesIds, (id, server) -> FluentIterable.from(server.getContainersSpec()).transform(c -> c.getContainerName()).toSet() ); }
private void setup( final ServerTemplate serverTemplate, final String selectContainerId ) { this.view.setServerTemplate( serverTemplatePresenter.getView() ); ContainerSpec firstContainerSpec = null; if ( serverTemplate.getContainersSpec().isEmpty() ) { serverContainerEmptyPresenter.setTemplate( serverTemplate ); this.view.setContent( serverContainerEmptyPresenter.getView() ); firstContainerSpec = null; } else { if ( selectContainerId != null ) { for ( final ContainerSpec containerSpec : serverTemplate.getContainersSpec() ) { if ( containerSpec.getId().equals( selectContainerId ) ) { firstContainerSpec = containerSpec; break; } } } if ( firstContainerSpec == null ) { firstContainerSpec = serverTemplate.getContainersSpec().iterator().next(); } } serverTemplatePresenter.setup( serverTemplate, firstContainerSpec ); }
@Override public synchronized void copyServerTemplate(String serverTemplateId, String newServerTemplateId, String newServerTemplateName) { final ServerTemplate serverTemplate = templateStorage.load(serverTemplateId); if (serverTemplate == null) { throw new KieServerControllerIllegalArgumentException("No server template found for id " + serverTemplateId); } final Map<Capability, ServerConfig> configMap = new HashMap<Capability, ServerConfig>(serverTemplate.getConfigs().size()); for (final Map.Entry<Capability, ServerConfig> entry : serverTemplate.getConfigs().entrySet()) { configMap.put(entry.getKey(), copy(entry.getValue())); } final Collection<ContainerSpec> containerSpecs = new ArrayList<ContainerSpec>(serverTemplate.getContainersSpec().size()); for (final ContainerSpec entry : serverTemplate.getContainersSpec()) { containerSpecs.add(copy(entry, newServerTemplateId, newServerTemplateName)); } final ServerTemplate copy = new ServerTemplate(newServerTemplateId, newServerTemplateName, serverTemplate.getCapabilities(), configMap, containerSpecs); templateStorage.store(copy); }
@Override public ContainerSpecList listContainerSpec(String serverTemplateId) { ServerTemplate serverTemplate = templateStorage.load(serverTemplateId); if (serverTemplate == null) { throw new KieServerControllerIllegalArgumentException("No server template found for id " + serverTemplateId); } return new ContainerSpecList(serverTemplate.getContainersSpec()); }
protected void buildClientsForServer(ServerTemplate serverTemplate) { KieServicesClient kieServicesClient = createClientForTemplate(serverTemplate, null, getCredentialsProvider()); if (kieServicesClient != null) { serverTemplatesClients.put(serverTemplate.getId(), kieServicesClient); } if (serverTemplate.getContainersSpec() != null) { for (ContainerSpec containerSpec : serverTemplate.getContainersSpec()) { try { String key = serverTemplate.getId() + "|" + containerSpec.getId(); if (serverTemplatesClients.containsKey(key)) { logger.debug("KieServerClient for {} is already created", key); continue; } KieContainer kieContainer = kieServices.newKieContainer(containerSpec.getReleasedId()); KieServicesClient kieServicesClientForContainer = createClientForTemplate(serverTemplate, kieContainer.getClassLoader(), getCredentialsProvider()); if (kieServicesClient != null) { serverTemplatesClients.put(key, kieServicesClientForContainer); } } catch (Exception e) { logger.warn("Failed ot create kie server client for container {} due to {}", containerSpec.getId(), e.getMessage()); } } } // lastly create admin client KieServicesClient adminKieServicesClient = createClientForTemplate(serverTemplate, null, getAdminCredentialsProvider()); if (adminKieServicesClient != null) { adminClients.put(serverTemplate.getId(), adminKieServicesClient); } }
@Test public void testUpdateContainerConfigWhenContainerSpecIsNull() { final SpecManagementServiceImpl specManagementService = (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); specManagementService.setTemplateStorage(templateStorage); doReturn(serverTemplate).when(templateStorage).load(serverTemplateId); doReturn(null).when(serverTemplate).getContainersSpec(); expectedException.expect(KieServerControllerIllegalArgumentException.class); expectedException.expectMessage("No container spec found for id containerSpecId within server template with id serverTemplateId"); specManagementService.updateContainerConfig(serverTemplateId, containerSpecId, capability, containerConfig); }
public void setup( final ServerTemplate serverTemplate, final ContainerSpec firstContainerSpec ) { view.clear(); this.serverTemplate = serverTemplate; view.setTemplate( serverTemplate.getId(), serverTemplate.getName() ); view.setProcessCapability( serverTemplate.getCapabilities().contains( Capability.PROCESS.toString() ) ); view.setRulesCapability( serverTemplate.getCapabilities().contains( Capability.RULE.toString() ) ); view.setPlanningCapability( serverTemplate.getCapabilities().contains( Capability.PLANNING.toString() ) ); if ( firstContainerSpec != null ) { addContainer( firstContainerSpec ); for ( final ContainerSpec containerSpec : serverTemplate.getContainersSpec() ) { if ( !containerSpec.getId().equals( firstContainerSpec.getId() ) ) { addContainer( containerSpec ); } } containerSpecSelectedEvent.fire( new ContainerSpecSelected( firstContainerSpec ) ); } for ( final ServerInstanceKey serverInstanceKey : serverTemplate.getServerInstanceKeys() ) { addServerInstance( serverInstanceKey ); } }
@Override public synchronized void saveServerTemplate(ServerTemplate serverTemplate) { if (templateStorage.exists(serverTemplate.getId())) { templateStorage.update(serverTemplate); } else { templateStorage.store(serverTemplate); } notificationService.notify(new ServerTemplateUpdated(serverTemplate)); Collection<ContainerSpec> containerSpecs = serverTemplate.getContainersSpec(); if (containerSpecs != null && !containerSpecs.isEmpty()) { for (ContainerSpec containerSpec : containerSpecs) { if (containerSpec.getStatus().equals(KieContainerStatus.STARTED)) { List<Container> containers = kieServerInstanceManager.startContainer(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 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 testUpgradeContainerWhenContainerSpecStatusIsStarted() { final List<Container> fakeResult = new ArrayList<Container>() {{ add(container); }}; doReturn(fakeResult).when(kieServerInstanceManager).upgradeContainer(any(ServerTemplate.class), any(ContainerSpec.class)); containerSpec.setStatus(KieContainerStatus.STARTED); final ReleaseId initial = containerSpec.getReleasedId(); final ReleaseId upgradeTo = new ReleaseId("org.kie", "kie-server-kjar", "2.0"); ruleCapabilitiesService.upgradeContainer(containerSpec, upgradeTo); verify(kieServerInstanceManager).upgradeContainer(any(ServerTemplate.class), any(ContainerSpec.class)); final ServerTemplate updated = specManagementService.getServerTemplate(serverTemplate.getId()); final Collection<ContainerSpec> containerSpecs = updated.getContainersSpec(); assertNotNull(containerSpecs); assertEquals(1, containerSpecs.size()); ContainerSpec updatedContainer = containerSpecs.iterator().next(); assertNotNull(updatedContainer); assertNotNull(updatedContainer.getReleasedId()); assertNotEquals(initial, updatedContainer.getReleasedId()); assertEquals(upgradeTo, updatedContainer.getReleasedId()); assertEquals(updatedContainer.getStatus(), KieContainerStatus.STARTED); }
final Collection<ContainerSpec> containerSpecs = updated.getContainersSpec();
@Test public void testMigrationOfServerTemplateOnly() throws Exception { String serverTemplateId = "kie_server"; String oldServerTemplateContent = IOUtils.toString(this.getClass().getResourceAsStream("/kie-server-6.3-info-just-server.xml")); assertNotNull(oldServerTemplateContent); Path path = buildPath(serverTemplateId); assertNotNull(path); // let's store it in the old way -info.xml file ioService.write(path, oldServerTemplateContent); ServerTemplateMigration templateMigration = new ServerTemplateMigration(); templateMigration.migrate(path.getParent(), ioService, xstream, templateStorage); boolean exists = templateStorage.exists(serverTemplateId); assertTrue(exists); ServerTemplate fromStorage = templateStorage.load(serverTemplateId); assertNotNull(fromStorage); // verify server template assertEquals(serverTemplateId, fromStorage.getId()); assertEquals("kie server name", fromStorage.getName()); Collection<String> capabilities = fromStorage.getCapabilities(); assertNotNull(capabilities); assertEquals(0, capabilities.size()); // verify server instances (previously known as managedInstances) Collection<ServerInstanceKey> instances = fromStorage.getServerInstanceKeys(); assertNotNull(instances); assertEquals(0, instances.size()); // verify containers Collection<ContainerSpec> containerSpecs = fromStorage.getContainersSpec(); assertNotNull(containerSpecs); assertEquals(0, containerSpecs.size()); }
Collection<ContainerSpec> containerSpecs = fromStorage.getContainersSpec(); assertNotNull(containerSpecs); assertEquals(0, containerSpecs.size());
assertEquals(0, instances.size()); Collection<ContainerSpec> containerSpecs = fromStorage.getContainersSpec(); assertNotNull(containerSpecs); assertEquals(1, containerSpecs.size());