public void setTemplate(final ServerTemplate serverTemplate) { this.serverTemplate = checkNotNull("serverTemplate", serverTemplate); view.setTemplateName(serverTemplate.getName()); }
@Override public ServerTemplate store(ServerTemplate serverTemplate) { synchronized (store) { storeKeys.put(serverTemplate.getId(), new ServerTemplateKey(serverTemplate.getId(), serverTemplate.getName())); return store.put(serverTemplate.getId(), serverTemplate); } }
/** * Loads the map of server templates from the file pointed at by the templatesLocation */ @SuppressWarnings("unchecked") public synchronized void loadTemplateMapsFromFile() { ArrayList<ServerTemplate> templates = null; Map<String, ServerTemplate> newTemplateMap = new ConcurrentHashMap<>(); Map<String, ServerTemplateKey> newTemplateKeyMap = new ConcurrentHashMap<>(); try (FileReader reader = new FileReader(templatesLocation)) { templates = (ArrayList<ServerTemplate>)this.xstream.fromXML(reader); if (templates != null && !templates.isEmpty()) { templates.forEach(template -> { newTemplateKeyMap.put(template.getId(),new ServerTemplateKey(template.getId(),template.getName())); newTemplateMap.put(template.getId(),template); }); } templateKeyMap = newTemplateKeyMap; templateMap = newTemplateMap; } catch (FileNotFoundException e) { logger.warn("Unable to read server template maps from file {}. File does not exist.", templatesLocation); writeTemplateMap(); } catch (XStreamException e) { logger.warn("Unable to read server template maps from file {}. File corrupted. Possible concurrent update in progress.", templatesLocation); } catch (Throwable e) { logger.error("Unable to read server template maps from file",e); } }
@Override public ServerTemplate update(ServerTemplate serverTemplate) { ServerTemplate updated = null; synchronized (templateMap) { templateKeyMap.put(serverTemplate.getId(), new ServerTemplateKey(serverTemplate.getId(),serverTemplate.getName())); updated = templateMap.put(serverTemplate.getId(),serverTemplate); writeTemplateMap(); } return updated; }
@Override public ServerTemplate store(ServerTemplate serverTemplate) { ServerTemplate template = null; synchronized (templateMap) { templateKeyMap.put(serverTemplate.getId(), new ServerTemplateKey(serverTemplate.getId(), serverTemplate.getName())); template = templateMap.put(serverTemplate.getId(), serverTemplate); writeTemplateMap(); } return template; }
@BeforeClass public static void beforeClass() { templateMap = Maps.newConcurrentMap(); for (int x = 0; x < 3; x++) { StringBuilder templateName = new StringBuilder("test server : ").append(x); ServerTemplate template = createServerTemplateWithContainer(templateName.toString(),x+1); ServerTemplateKey key = new ServerTemplateKey(template.getId(), template.getName()); templateMap.put(key, template); } }
@Test public void testTemplate() { final ServerTemplate template = new ServerTemplate( "id", "name" ); presenter.setTemplate( template ); verify( view ).setTemplateName( template.getName() ); }
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 ); } }
@Test public void testOnServerTemplateUpdated() { final ServerTemplate serverTemplate = new ServerTemplate( "ServerTemplateKeyId", "ServerTemplateKeyName" ); presenter.onServerTemplateUpdated( new ServerTemplateUpdated( serverTemplate ) ); verify( view ).addTemplate( serverTemplate.getId(), serverTemplate.getName() ); }
@Test public void testSetupCapabilities() { final ServerTemplate serverTemplate = new ServerTemplate( "ServerTemplateKeyId", "ServerTemplateKeyName" ); serverTemplate.getCapabilities().add( Capability.PROCESS.toString() ); serverTemplate.getCapabilities().add( Capability.PLANNING.toString() ); serverTemplate.getCapabilities().add( Capability.RULE.toString() ); presenter.setup( serverTemplate, null ); assertEquals( serverTemplate, presenter.getCurrentServerTemplate() ); verify( view ).clear(); verify( view ).setTemplate( serverTemplate.getId(), serverTemplate.getName() ); verify( view ).setProcessCapability( true ); verify( view ).setRulesCapability( true ); verify( view ).setPlanningCapability( true ); }
protected List<Container> createContainers(KieContainerStatus status, List<Message> messages, int instances) { List<Container> containerList = new ArrayList<Container>(); for (int i = 0; i < instances; i++) { Container container = new Container("c" + i, "name" + i, new ServerInstanceKey(serverTemplate.getId(), serverTemplate.getName(), serverTemplate.getId(), "http://testurl.com"), messages, null, ""); container.setStatus(status); containerList.add(container); } return containerList; } }
verify( view ).setTemplate( serverTemplate.getId(), serverTemplate.getName() ); verify( view ).setProcessCapability( false ); verify( view ).setRulesCapability( false );
@Test public void testCreateServerTemplate() { ServerTemplate serverTemplate = new ServerTemplate(); serverTemplate.setName("test server"); serverTemplate.setId(UUID.randomUUID().toString()); specManagementService.saveServerTemplate(serverTemplate); ServerTemplateKeyList existing = specManagementService.listServerTemplateKeys(); assertNotNull(existing); assertEquals(1, existing.getServerTemplates().length); org.kie.server.controller.api.model.spec.ServerTemplateKey saved = existing.getServerTemplates()[0]; assertEquals(serverTemplate.getName(), saved.getName()); assertEquals(serverTemplate.getId(), saved.getId()); }
@Before public void prepare() { returnedContainers.clear(); serverTemplate = new ServerTemplate(); serverTemplate.setName("test server"); serverTemplate.setId(UUID.randomUUID().toString()); containerSpec = new ContainerSpec(); containerSpec.setId("test container"); containerSpec.setServerTemplateKey(new ServerTemplateKey(serverTemplate.getId(), serverTemplate.getName())); containerSpec.setReleasedId(new ReleaseId("org.kie", "kie-server-kjar", "1.0")); containerSpec.setStatus(KieContainerStatus.STOPPED); containerSpec.setConfigs(new HashMap<Capability, ContainerConfig>()); serverTemplate.addContainerSpec(containerSpec); this.kieServerInstanceManager = new AsyncKieServerInstanceManager(notificationService, containerUpdateEvent, executor) { @Override protected List<Container> callRemoteKieServerOperation(ServerTemplate serverTemplate, ContainerSpec containerSpec, RemoteKieServerOperation operation) { return returnedContainers; } }; this.kieServerInstanceManager.setExecutor(executor); }
@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()); }
@Override public synchronized void saveContainerSpec(String serverTemplateId, ContainerSpec containerSpec) { ServerTemplate serverTemplate = templateStorage.load(serverTemplateId); if (serverTemplate == null) { throw new KieServerControllerIllegalArgumentException("No server template found for id " + serverTemplateId); } if (serverTemplate.hasContainerSpec(containerSpec.getId())) { throw new KieServerControllerException("Server template with id " + serverTemplateId + " associated already with container " + containerSpec.getId()); } // make sure correct server template is set containerSpec.setServerTemplateKey(new ServerTemplateKey(serverTemplate.getId(), serverTemplate.getName())); serverTemplate.addContainerSpec(containerSpec); templateStorage.update(serverTemplate); notificationService.notify(new ServerTemplateUpdated(serverTemplate)); if (containerSpec.getStatus().equals(KieContainerStatus.STARTED)) { List<Container> containers = kieServerInstanceManager.startContainer(serverTemplate, containerSpec); notificationService.notify(serverTemplate, containerSpec, containers); } }
@Test public void testCreateAndDeleteServerTemplate() { ServerTemplate serverTemplate = new ServerTemplate(); serverTemplate.setName("test server"); serverTemplate.setId(UUID.randomUUID().toString()); specManagementService.saveServerTemplate(serverTemplate); ServerTemplateKeyList existing = specManagementService.listServerTemplateKeys(); assertNotNull(existing); assertEquals(1, existing.getServerTemplates().length); org.kie.server.controller.api.model.spec.ServerTemplateKey saved = existing.getServerTemplates()[0]; assertEquals(serverTemplate.getName(), saved.getName()); assertEquals(serverTemplate.getId(), saved.getId()); specManagementService.deleteServerTemplate(serverTemplate.getId()); existing = specManagementService.listServerTemplateKeys(); assertNotNull(existing); assertEquals(0, existing.getServerTemplates().length); }
@Override public synchronized void updateContainerSpec(final String serverTemplateId, final String containerId, final ContainerSpec containerSpec) { ServerTemplate serverTemplate = templateStorage.load(serverTemplateId); if (serverTemplate == null) { throw new KieServerControllerIllegalArgumentException("No server template found for id " + serverTemplateId); } if (!containerSpec.getId().equals(containerId)) { throw new KieServerControllerException("Cannot update container " + containerSpec.getId() + " on container " + containerId); } if (!serverTemplate.hasContainerSpec(containerSpec.getId())) { throw new KieServerControllerIllegalArgumentException("Server template with id " + serverTemplateId + " has no container with id " + containerSpec.getId()); } if (!serverTemplate.hasMatchingId(containerSpec.getServerTemplateKey())) { throw new KieServerControllerException("Cannot change container template key during update."); } // make sure correct server template is set containerSpec.setServerTemplateKey(new ServerTemplateKey(serverTemplate.getId(), serverTemplate.getName())); ContainerSpec currentVersion = serverTemplate.getContainerSpec(containerSpec.getId()); serverTemplate.deleteContainerSpec(currentVersion.getId()); serverTemplate.addContainerSpec(containerSpec); templateStorage.update(serverTemplate); notificationService.notify(new ServerTemplateUpdated(serverTemplate)); // in case container was started before it was update or update comes with status started update container in running servers if (currentVersion.getStatus().equals(KieContainerStatus.STARTED) || containerSpec.getStatus().equals(KieContainerStatus.STARTED)) { List<Container> containers = kieServerInstanceManager.upgradeAndStartContainer(serverTemplate, containerSpec); notificationService.notify(serverTemplate, containerSpec, containers); } }
containerSpec.setServerTemplateKey(new ServerTemplateKey(serverTemplate.getId(), serverTemplate.getName())); containerSpec.setReleasedId(new ReleaseId("org.kie", "kie-server-kjar", "1.0")); containerSpec.setStatus(KieContainerStatus.STOPPED);