/** * Adds and collects properties for related Resource * * constructor */ private AppServerRelationProperties addRelation(String identifier, ResourceEntity resource, AbstractResourceRelationEntity resourceRelation, List<AppServerRelationProperties> list) { Map<String, FreeMarkerProperty> properties = collectResourceProperties(context, resource); // relation overrides properties properties.putAll(collectRelationProperties(context, resource, resourceRelation)); AppServerRelationProperties asrProperties = new AppServerRelationProperties(resource, properties, identifier, templateExceptionHandler); list.add(asrProperties); return asrProperties; }
private void addRelated(AmwResourceTemplateModel model, AppServerRelationProperties relation, AmwResourceTemplateModel parent) { Map<String, Map<String, AmwResourceTemplateModel>> transformConsumedProperties = transformRelated(relation.getConsumed(), parent); model.setConsumedResTypes(transformConsumedProperties); Map<String, Map<String, AmwResourceTemplateModel>> transformProvidedProperties = transformRelatedAndStop(relation.getProvided(), parent); model.setProvidedResTypes(transformProvidedProperties); }
private void decorateVersion(Map<Integer, ApplicationWithVersion> appsWithVersion, AppServerRelationProperties properties) { if(properties.getProperties().containsKey(VERSION)) { //if MavenVersion property exists and has a value do not overwrite with Version if (!properties.getProperties().containsKey(MAVEN_VERSION) || StringUtils.isBlank(properties.getProperties().get(MAVEN_VERSION).getCurrentValue())) { properties.getProperties().put(MAVEN_VERSION, properties.getProperties().get(VERSION)); } } if (appsWithVersion.containsKey(properties.getOwner().getId())) { ApplicationWithVersion applicationWithVersion = appsWithVersion.get(properties.getOwner() .getId()); if (StringUtils.isNotBlank(applicationWithVersion.getVersion())) { properties.getProperties().put(VERSION, new FreeMarkerProperty(applicationWithVersion.getVersion(), VERSION)); properties.getProperties().put(MAVEN_VERSION, new FreeMarkerProperty(applicationWithVersion.getVersion(), MAVEN_VERSION)); } } }
@Test public void testTemplatesInRelatedResources() throws TemplateModelException { AMWTemplateExceptionHandler templateExceptionHandler = new AMWTemplateExceptionHandler(); ResourceEntity owner = builder.resourceFor(APP); ResourceEntity ad = builder.resourceFor(AD); ConsumedResourceRelationEntity relation = builder.relationFor(owner.getName(), ad.getName()); AppServerRelationProperties appServerRelationProperties = new AppServerRelationProperties(context, owner, templateExceptionHandler); appServerRelationProperties.addConsumedRelation("active_directory", ad, relation); SetMultimap<ResourceEntity, GeneratedTemplate> templatesCache = LinkedHashMultimap.create(); templatesCache.put(ad, new GeneratedTemplate("name", "path", "content")); appServerRelationProperties.getConsumed().get(0).setTemplatesCache(templatesCache); appServerRelationProperties.setTemplatesCache(templatesCache); TemplateHashModel model = TestUtils.asHashModel(appServerRelationProperties.transformModel(), "active_directory", "templates", "name"); assertEquals("content", model.get("content").toString()); assertTrue(templateExceptionHandler.isSuccess()); }
@Test public void testMergeMergesAllConsumedInBothDirections() { AMWTemplateExceptionHandler templateExceptionHandler = new AMWTemplateExceptionHandler(); ResourceEntity owner = builder.resourceFor(APP); ResourceEntity slave = builder.resourceFor(AD); AppServerRelationProperties props1 = new AppServerRelationProperties(context, owner, templateExceptionHandler); AppServerRelationProperties props2 = new AppServerRelationProperties(context, owner, templateExceptionHandler); props1.addConsumedRelation("foo", slave, null); props1.merge(props2); assertEquals(1, props1.getConsumed().size()); assertEquals(1, props2.getConsumed().size()); AppServerRelationProperties props3 = new AppServerRelationProperties(context, owner, templateExceptionHandler); props3.merge(props2); assertEquals(1, props3.getConsumed().size()); assertEquals(1, props2.getConsumed().size()); assertEquals(1, props1.getConsumed().size()); assertTrue(templateExceptionHandler.isSuccess()); }
@Test public void testSingleAsAppRelation() { AMWTemplateExceptionHandler templateExceptionHandler = new AMWTemplateExceptionHandler(); AppServerRelationProperties properties = new AppServerRelationProperties(builder.context, builder.as, templateExceptionHandler); for (ConsumedResourceRelationEntity relation : builder.as.getConsumedMasterRelations()) { ResourceEntity slaveResource = relation.getSlaveResource(); properties.addConsumedRelation(slaveResource.getName(), slaveResource, relation); } assertEquals(1, properties.getConsumed().size()); assertEquals(0, properties.getProvided().size()); assertTrue(templateExceptionHandler.isSuccess()); }
@Test public void testOnlyConsumedResource() throws TemplateModelException { AMWTemplateExceptionHandler templateExceptionHandler = new AMWTemplateExceptionHandler(); ResourceEntity ad = builder.resourceFor(AD); ResourceEntity mail = builder.resourceFor(MAIL); builder.buildResourceProperty(ad, "foo", "bar"); ConsumedResourceRelationEntity relation = builder.buildConsumedRelation(ad, mail, ForeignableOwner.AMW); AppServerRelationProperties properties = new AppServerRelationProperties(context, ad, templateExceptionHandler); properties.addConsumedRelation("mailrelay", mail, relation); TemplateHashModel model = TestUtils.asHashModel(properties.transformModel(), "consumedResTypes", "Mail", "mailrelay"); assertEquals("mailrelay", model.get("name").toString()); assertTrue(templateExceptionHandler.isSuccess()); } }
@Test public void testTwoRelatedProvidedResourcesOfSameType() throws TemplateModelException { AMWTemplateExceptionHandler templateExceptionHandler = new AMWTemplateExceptionHandler(); ResourceEntity ws2 = builder.buildResource(builder.typeFor(WS.type), "ws2"); builder.buildProvidedRelation(builder.app, builder.ws, ForeignableOwner.AMW); builder.buildProvidedRelation(builder.app, ws2, ForeignableOwner.AMW); AppServerRelationProperties properties = new AppServerRelationProperties(builder.context, builder.app, templateExceptionHandler); for (ProvidedResourceRelationEntity relation : builder.app.getProvidedMasterRelations()) { ResourceEntity slaveResource = relation.getSlaveResource(); properties.addProvidedRelation(slaveResource.getName(), slaveResource, relation); } assertEquals(2, properties.getProvided().size()); AmwResourceTemplateModel hash = properties.transformModel(); assertEquals("app", hash.get("label").toString()); assertNull(hash.get("propertyTypes")); assertEquals(TestUtils.asHashModel(hash, "providedResTypes", "Webservice", "ws").get("label").toString(), "ws"); assertNull(TestUtils.asHashModel(hash, "providedResTypes", "Webservice", "ws").get("propertyTypes")); assertEquals(TestUtils.asHashModel(hash, "providedResTypes", "Webservice", "ws2").get("label").toString(), "ws2"); assertNull(TestUtils.asHashModel(hash, "providedResTypes", "Webservice", "ws2").get("propertyTypes")); hash = properties.transformModel(); assertTrue(templateExceptionHandler.isSuccess()); }
private Map<String, Map<String,AmwResourceTemplateModel>> transformRelatedInternal(List<AppServerRelationProperties> relations, boolean transformNested, AmwResourceTemplateModel parent) { Map<String, Map<String,AmwResourceTemplateModel>> map = Maps.newLinkedHashMap(); for (AppServerRelationProperties relation : relations) { ResourceEntity slave = relation.getOwner(); AmwResourceTemplateModel relationModel = relation.getPropertiesWithTemplates(parent); addAppServerNodeViaResolver(appServerNodeViaResolver, relation.resolver); relationModel.setAppServerNodeViaResolver(appServerNodeViaResolver); SoftlinkGenerationPackage generationPackage = relation.getSoftlinkPPIGenerationPackage(); if(generationPackage != null && generationPackage.getGenerationPackage()!= null && generationPackage.getPpiResourceEntity() != null){ GenerationSubPackage asPackage = generationPackage.getGenerationPackage().getGenerationSubPackages().get(generationPackage.getGenerationPackage(). addRelated(relationModel, relation, relationModel);
@Test public void testOnlyProvidedResource() throws TemplateModelException { AMWTemplateExceptionHandler templateExceptionHandler = new AMWTemplateExceptionHandler(); ResourceEntity ad = builder.resourceFor(AD); ResourceEntity mail = builder.resourceFor(MAIL); ProvidedResourceRelationEntity relation = builder.buildProvidedRelation(ad, mail, ForeignableOwner.AMW); AppServerRelationProperties properties = new AppServerRelationProperties(context, ad, templateExceptionHandler); properties.addProvidedRelation("mailrelay", mail, relation); TemplateHashModel model = TestUtils.asHashModel(properties.transformModel(), "providedResTypes", "Mail", "mailrelay"); assertEquals("mailrelay", model.get("name").toString()); assertTrue(templateExceptionHandler.isSuccess()); }
/** * @return s the Properties as Model */ public AmwResourceTemplateModel getPropertiesAsModel() { AmwResourceTemplateModel model = new AmwResourceTemplateModel(); if (properties != null) { model = properties.transformModel(); } if(parentGenerationSubPackage != null && parentGenerationSubPackage.getPackageGenerationUnit() != null){ AmwResourceTemplateModel parent = parentGenerationSubPackage.getPackageGenerationUnit().getPropertiesAsModel(); model.setParentResourceTemplateModel(parent); } return model; }
public void transform(AMWTemplateExceptionHandler templateExceptionHandler, AmwAppServerNodeModel model) { AppServerRelationProperties app = new AppServerRelationProperties(options.getContext().getContext(), getApplication(), templateExceptionHandler); AppServerRelationProperties appServer = new AppServerRelationProperties(options.getContext().getContext(), getApplicationServer(), templateExceptionHandler); model.setAppProperties(app.getProperties()); model.setAppServerProperties(appServer.getProperties()); List<Map<String, FreeMarkerProperty>> nodePropertyList = Lists.newArrayList(); model.setNodePropertyList(nodePropertyList); } }
private void merge(GenerationOptions options, GenerationPackage workSet, AppServerRelationProperties slaveProperties) { decorateVersion(options.getVersions(), slaveProperties); for (GenerationUnit unit : workSet.getAsSet()) { if (unit.getSlaveResource().equals(slaveProperties.getOwner())) { unit.getAppServerRelationProperties().merge(slaveProperties); } } }
/** * Transforms Properties into HashMap as used by Generator. */ public AmwResourceTemplateModel transformModel() { AmwResourceTemplateModel model = new AmwResourceTemplateModel(); model.setProperties(properties); model.setFunctions(functions); model.setResourceEntity(owner); Map<String, Map<String, AmwResourceTemplateModel>> transformConsumedRelated = transformRelated(consumed, model); model.setConsumedResTypes(transformConsumedRelated); model.setProvidedResTypes(transformRelated(provided, model)); model.setResourceTemplates(resourceTemplates); model.setResourceRelationTemplates(resourceRelationTemplates); AmwAppServerNodeModel amwAppServerNodeModel = new AmwAppServerNodeModel(); addAppServerNodeViaResolver(amwAppServerNodeModel, resolver); model.setAppServerNodeViaResolver(amwAppServerNodeModel); log.fine("transforming: " + getOwner()); return model; }
private Map<String, GeneratedTemplate> getGeneratedTemplates() { Map<String, GeneratedTemplate> templates = Maps.newLinkedHashMap(); if (templatesCache != null && getOwner() != null) { for (GeneratedTemplate template : templatesCache.get(getOwner())) { templates.put(template.getName(), template); } } return templates; }
private AmwResourceTemplateModel getPropertiesWithTemplates(AmwResourceTemplateModel parent) { AmwResourceTemplateModel model = new AmwResourceTemplateModel(); model.setProperties(getProperties()); model.setFunctions(functions); model.setResourceEntity(owner); model.setParentResourceTemplateModel(parent); model.setResourceTemplates(resourceTemplates); model.setResourceRelationTemplates(resourceRelationTemplates); model.setTemplates(getGeneratedTemplates()); return model; }
private void handleProvidedRelations(GenerationPackage mainWorkSet, GenerationOptions options, ResourceEntity resource, AppServerRelationProperties properties, GenerationSubPackage resourceWorkSet) { Set<ProvidedResourceRelationEntity> providedMasterRelations = dependencyResolver.getProvidedMasterRelationsForRelease(resource, options.getContext().getTargetRelease()); List<ProvidedResourceRelationEntity> providedMasterRelationsSorted = new ArrayList<>( providedMasterRelations); Collections.sort(providedMasterRelationsSorted, AbstractResourceRelationEntity.COMPARE_BY_SLAVE_NAME); for (ProvidedResourceRelationEntity relation : providedMasterRelationsSorted) { ResourceEntity slave = relation.getSlaveResource(); log.info(" (provides): " + slave.getName()); String identifier = relation.getIdentifier(); AppServerRelationProperties slaveProperties = properties.addProvidedRelation(identifier, slave, relation); Set<TemplateDescriptorEntity> resourceTemplates = templatesForResource(options, slave); Set<TemplateDescriptorEntity> relationTemplates = templatesForRelation(options, relation); merge(options, mainWorkSet, slaveProperties); slaveProperties.setFunctions(functionService.getAllFunctionsForResource(slave)); GenerationUnit generationUnit = new GenerationUnit(slave, resource, slaveProperties, resourceTemplates, relationTemplates); generationUnit.setGlobalFunctionTemplates(options.getContext().getGlobalFunctions()); addUnit(resourceWorkSet, generationUnit); } }
private FreeMarkerProperty getPropertyFromUnit(GenerationUnit unit, String key) { return unit.getAppServerRelationProperties().getProperties().get(key); }
private AppServerRelationProperties propertiesFor(GenerationOptions options, ResourceEntity resource, AMWTemplateExceptionHandler templateExceptionHandler) { return new AppServerRelationProperties(options.getContext().getContext(), resource, templateExceptionHandler); }
private List<GenerationUnitGenerationResult> generateInternal(Set<GenerationUnit> work) throws IOException { List<GenerationUnitGenerationResult> results = new ArrayList<GenerationUnitGenerationResult>(); Set<String> currentTemplateNames = ImmutableSet.copyOf(templateFiles.keySet()); for (GenerationUnit unit : work) { if(unit.isGenerateTemplates()){ log.fine("templatesCache: " + templatesCache); unit.getAppServerRelationProperties().setTemplatesCache(templatesCache); ResourceEntity resource = unit.getSlaveResource(); log.info("processing resource " + resource.getName()); GenerationUnitGenerationResult resourceTemplateResult = generateResourceTemplates(unit); addTemplatesToCache(resource, resourceTemplateResult.getGeneratedTemplates()); results.add(resourceTemplateResult); if (!unit.getRelationTemplates().isEmpty()) { GenerationUnitGenerationResult resourceRelationTemplateResult = generateResourceRelationTemplates(work, unit); addTemplatesToCache(resource, resourceRelationTemplateResult.getGeneratedTemplates()); results.add(resourceRelationTemplateResult); } if (templateFiles.keySet().size() != currentTemplateNames.size()) { log.info("templates: " + Joiner.on(", ").join(templateFiles.keySet())); currentTemplateNames = ImmutableSet.copyOf(templateFiles.keySet()); } } if (templateFiles.keySet().size() != currentTemplateNames.size()) { log.info("templates: " + Joiner.on(", ").join(templateFiles.keySet())); currentTemplateNames = ImmutableSet.copyOf(templateFiles.keySet()); } } return results; }