/** * Converts imports to a human-readable text. * @param importedVariables a non-null set of imported variables * @return a non-null list of string, one entry per import */ private List<String> convertImports( Collection<ImportedVariable> importedVariables ) { List<String> result = new ArrayList<> (); for( ImportedVariable var : importedVariables ) { String componentOrFacet = VariableHelpers.parseVariableName( var.getName()).getKey(); String s = applyLink( var.getName(), componentOrFacet ); s += var.isOptional() ? this.messages.get( "optional" ) : this.messages.get( "required" ); //$NON-NLS-1$ //$NON-NLS-2$ if( var.isExternal()) s += this.messages.get( "external" ); //$NON-NLS-1$ result.add( s ); } return result; }
private void processComponent( BlockComponent block ) { ComponentData data = this.componentNameToComponentData.get( block.getName()); if( data != null ) { data.blocks.add( block ); } else { data = new ComponentData(); data.object = new Component( block.getName()); data.object.exportedVariables.putAll( ModelUtils.getExportedVariables( block )); data.object.setInstallerName( ModelUtils.getPropertyValue( block, ParsingConstants.PROPERTY_COMPONENT_INSTALLER )); for( String s : ModelUtils.getPropertyValues( block, ParsingConstants.PROPERTY_COMPONENT_IMPORTS )) { Boolean optional = s.toLowerCase().endsWith( ParsingConstants.PROPERTY_COMPONENT_OPTIONAL_IMPORT ); if( optional ) s = s.substring( 0, s.length() - ParsingConstants.PROPERTY_COMPONENT_OPTIONAL_IMPORT.length()).trim(); Boolean external = s.toLowerCase().startsWith( ParsingConstants.PROPERTY_COMPONENT_EXTERNAL_IMPORT ); if( external ) s = s.substring( ParsingConstants.PROPERTY_COMPONENT_EXTERNAL_IMPORT.length()).trim(); data.object.addImportedVariable( new ImportedVariable( s, optional, external )); } data.extendedComponentName = ModelUtils.getPropertyValue( block, ParsingConstants.PROPERTY_GRAPH_EXTENDS ); data.childrenNames.addAll( ModelUtils.getPropertyValues( block, ParsingConstants.PROPERTY_GRAPH_CHILDREN )); data.facetNames.addAll( ModelUtils.getPropertyValues( block, ParsingConstants.PROPERTY_COMPONENT_FACETS )); data.blocks.add( block ); this.componentNameToComponentData.put( block.getName(), data ); } }
@Test public void testEqualsAndHashCode() { ImportedVariable var1 = new ImportedVariable( "test", false, false ); ImportedVariable var2 = new ImportedVariable( "test", true, true ); HashSet<ImportedVariable> set = new HashSet<>( 2 ); set.add( var1 ); set.add( var2 ); Assert.assertEquals( 1, set.size()); Assert.assertEquals( var1, var2 ); Assert.assertFalse( var1.equals( new Object())); Assert.assertFalse( var1.equals( new ImportedVariable( "test2", false, false ))); Assert.assertTrue( new ImportedVariable().hashCode() > 0 ); }
/** * Finds the component dependencies for a given component. * @param component a component * @return a non-null map (key = component name, value = true if the dependency is optional, false otherwise) */ public static Map<String,Boolean> findComponentDependenciesFor( Component component ) { Map<String,Boolean> map = new HashMap<> (); for( ImportedVariable var : findAllImportedVariables( component ).values()) { String componentOrFacet = VariableHelpers.parseVariableName( var.getName()).getKey(); Boolean b = map.get( componentOrFacet ); if( b == null || b ) map.put( componentOrFacet, var.isOptional()); } return map; }
/** * Finds the prefixes of the external variables for a given application or template. * <p> * If this list is not empty, it means this application depends on * other ones. * </p> * * @param app an application or an application template * @return a non-null application */ public static Set<String> findPrefixesForExternalImports( AbstractApplication app ) { Set<String> result = new TreeSet<> (); for( Component c : ComponentHelpers.findAllComponents( app )) { for( ImportedVariable var : ComponentHelpers.findAllImportedVariables( c ).values()) { if( ! var.isExternal()) continue; String prefix = VariableHelpers.parseVariableName( var.getName()).getKey(); result.add( prefix ); } } return result; }
@Test public void testExternalImport() throws Exception { File f = TestUtils.findTestFile( "/configurations/valid/component-external-imports.graph" ); FromGraphDefinition fromDef = new FromGraphDefinition( f.getParentFile()); Graphs graphs = fromDef.buildGraphs( f ); Assert.assertEquals( 0, fromDef.getErrors().size()); Component componentA = ComponentHelpers.findComponent( graphs, "A" ); Assert.assertTrue( componentA.exportedVariables.containsKey( "port" )); Assert.assertTrue( componentA.exportedVariables.containsKey( "ip" )); Map<String,String> exportedVariables = ComponentHelpers.findAllExportedVariables( componentA ); Assert.assertTrue( exportedVariables.containsKey( "A.port" )); Assert.assertTrue( exportedVariables.containsKey( "A.ip" )); ImportedVariable var = componentA.importedVariables.get( "A.port" ); Assert.assertNotNull( var ); Assert.assertTrue( var.isOptional()); Assert.assertFalse( var.isExternal()); var = componentA.importedVariables.get( "A.ip" ); Assert.assertNotNull( var ); Assert.assertTrue( var.isOptional()); Assert.assertFalse( var.isExternal()); var = componentA.importedVariables.get( "App.toto" ); Assert.assertNotNull( var ); Assert.assertFalse( var.isOptional()); Assert.assertTrue( var.isExternal()); var = componentA.importedVariables.get( "App2.ip" ); Assert.assertNotNull( var ); Assert.assertTrue( var.isOptional()); Assert.assertTrue( var.isExternal()); }
@Test public void testFindPrefixesForExternalImports() { TestApplication app = new TestApplication(); ImportedVariable var1 = new ImportedVariable( "something.else", true, true ); ImportedVariable var2 = new ImportedVariable( "other.stuff", true, true ); app.getWar().getComponent().importedVariables.put( var1.getName(), var1 ); app.getWar().getComponent().importedVariables.put( var2.getName(), var2 ); Set<String> prefixes = VariableHelpers.findPrefixesForExternalImports( app ); Assert.assertEquals( 2, prefixes.size()); Assert.assertTrue( prefixes.contains( "other" )); Assert.assertTrue( prefixes.contains( "something" )); }
/** * A convenience method to add an imported variable. * @param var a non-null variable */ public void addImportedVariable( ImportedVariable var ) { this.importedVariables.put( var.getName(), var ); } }
root.addChild( serverWithApp ); serverWithApp.addImportedVariable( new ImportedVariable( "database.ip", false, false )); serverWithApp.addImportedVariable( new ImportedVariable( "database.port", true, false )); serverWithApp.addExportedVariable( new ExportedVariable( "url", "something" )); serverWithAnotherApp.addImportedVariable( new ImportedVariable( "database.port", false, false )); serverWithAnotherApp.addImportedVariable( new ImportedVariable( "whatever", false, false )); Assert.assertTrue( imports.containsKey( "database.ip" )); Assert.assertTrue( imports.containsKey( "database.port" )); Assert.assertTrue( imports.get( "database.port" ).isOptional()); Assert.assertFalse( imports.get( "database.ip" ).isOptional()); Assert.assertTrue( imports.containsKey( "database.port" )); Assert.assertTrue( imports.containsKey( "whatever" )); Assert.assertFalse( imports.get( "database.ip" ).isOptional()); Assert.assertFalse( imports.get( "database.port" ).isOptional()); Assert.assertFalse( imports.get( "whatever" ).isOptional());
@Test public void testSelfOptionalImports() throws Exception { File f = TestUtils.findTestFile( "/configurations/valid/component-optional-imports.graph" ); FromGraphDefinition fromDef = new FromGraphDefinition( f.getParentFile()); Graphs graphs = fromDef.buildGraphs( f ); Assert.assertEquals( 0, fromDef.getErrors().size()); Component componentA = ComponentHelpers.findComponent( graphs, "A" ); Assert.assertTrue( componentA.exportedVariables.containsKey( "port" )); Assert.assertTrue( componentA.exportedVariables.containsKey( "ip" )); Map<String,String> exportedVariables = ComponentHelpers.findAllExportedVariables( componentA ); Assert.assertTrue( exportedVariables.containsKey( "A.port" )); Assert.assertTrue( exportedVariables.containsKey( "A.ip" )); ImportedVariable var = componentA.importedVariables.get( "A.port" ); Assert.assertNotNull( var ); Assert.assertTrue( var.isOptional()); var = componentA.importedVariables.get( "A.ip" ); Assert.assertNotNull( var ); Assert.assertTrue( var.isOptional()); }
@Test public void testToString() { ImportedVariable var = new ImportedVariable( "test", false, false ); Assert.assertEquals( "test", var.toString()); } }
/** * Builds a list of messaging contexts. * @param domain the domain * @param applicationName the name of the agent's application * @param instance the current instance * @param thoseThat whether we target "those that import" or "those that export" * @return a non-null list */ public static Collection<MessagingContext> forImportedVariables( String domain, String applicationName, Instance instance, ThoseThat thoseThat ) { Map<String,MessagingContext> result = new HashMap<> (); for( ImportedVariable var : ComponentHelpers.findAllImportedVariables( instance.getComponent()).values()) { String componentOrApplicationTemplateName = VariableHelpers.parseVariableName( var.getName()).getKey(); if( result.containsKey( componentOrApplicationTemplateName )) continue; // When we import a variable, it is either internal or external, but not both! RecipientKind kind = var.isExternal() ? RecipientKind.INTER_APP : RecipientKind.AGENTS; MessagingContext ctx = new MessagingContext( kind, domain, componentOrApplicationTemplateName, thoseThat, applicationName ); result.put( componentOrApplicationTemplateName, ctx ); } return result.values(); }
Assert.assertFalse( childComponent.importedVariables.get( "VM.config" ).isOptional()); Assert.assertFalse( childComponent.importedVariables.get( "VM.config" ).isExternal()); Assert.assertFalse( childComponent.importedVariables.get( "App1.test" ).isOptional()); Assert.assertTrue( childComponent.importedVariables.get( "App1.test" ).isExternal());
ImportedVariable var = new ImportedVariable( "tpl2.ext-ip", false, true ); app1.getTomcat().getComponent().importedVariables.put( var.getName(), var );
/** * Finds the component and facet names that prefix the variables an instance requires. * <p> * Only the mandatory variables are returned. Optional imports are not considered by this method. * </p> * * @param instance an instance * @return a non-null set with all the component and facet names this instance imports */ public static Set<String> findPrefixesForMandatoryImportedVariables( Instance instance ) { Set<String> result = new HashSet<> (); for( ImportedVariable var : ComponentHelpers.findAllImportedVariables( instance.getComponent()).values()) { if( ! var.isOptional()) result.add( VariableHelpers.parseVariableName( var.getName()).getKey()); } return result; }
/** * Finds the component and facet names that prefix the variables an instance imports. * @param instance an instance * @return a non-null set with all the component and facet names this instance imports */ public static Set<String> findPrefixesForImportedVariables( Instance instance ) { Set<String> result = new HashSet<> (); for( ImportedVariable var : ComponentHelpers.findAllImportedVariables( instance.getComponent()).values()) result.add( VariableHelpers.parseVariableName( var.getName()).getKey()); return result; }
Assert.assertTrue( serverComponent.importedVariables.get( "db.ip" ).isOptional()); Assert.assertNotNull( serverComponent.importedVariables.get( "db.port" )); Assert.assertTrue( serverComponent.importedVariables.get( "db.port" ).isOptional()); Assert.assertTrue( imports.get( "db.ip" ).isOptional()); Assert.assertNotNull( imports.get( "db.port" )); Assert.assertTrue( imports.get( "db.port" ).isOptional()); Assert.assertFalse( myServerComponent.importedVariables.get( "db.ip" ).isOptional()); Assert.assertNull( myServerComponent.importedVariables.get( "db.port" )); Assert.assertEquals( 2, imports.size()); Assert.assertNotNull( imports.get( "db.ip" )); Assert.assertFalse( imports.get( "db.ip" ).isOptional()); Assert.assertNotNull( imports.get( "db.port" )); Assert.assertTrue( imports.get( "db.port" ).isOptional());
/** * Converts imports to a human-readable text. * @param importedVariables a non-null set of imported variables * @return a non-null list of string, one entry per import */ private List<String> convertImports( Collection<ImportedVariable> importedVariables ) { List<String> result = new ArrayList<> (); for( ImportedVariable var : importedVariables ) { String componentOrFacet = VariableHelpers.parseVariableName( var.getName()).getKey(); String s = applyLink( var.getName(), componentOrFacet ); s += var.isOptional() ? this.messages.get( "optional" ) : this.messages.get( "required" ); //$NON-NLS-1$ //$NON-NLS-2$ if( var.isExternal()) s += this.messages.get( "external" ); //$NON-NLS-1$ result.add( s ); } return result; }
/** * Builds a list of messaging contexts. * @param domain the domain * @param applicationName the name of the agent's application * @param instance the current instance * @param thoseThat whether we target "those that import" or "those that export" * @return a non-null list */ public static Collection<MessagingContext> forImportedVariables( String domain, String applicationName, Instance instance, ThoseThat thoseThat ) { Map<String,MessagingContext> result = new HashMap<> (); for( ImportedVariable var : ComponentHelpers.findAllImportedVariables( instance.getComponent()).values()) { String componentOrApplicationTemplateName = VariableHelpers.parseVariableName( var.getName()).getKey(); if( result.containsKey( componentOrApplicationTemplateName )) continue; // When we import a variable, it is either internal or external, but not both! RecipientKind kind = var.isExternal() ? RecipientKind.INTER_APP : RecipientKind.AGENTS; MessagingContext ctx = new MessagingContext( kind, domain, componentOrApplicationTemplateName, thoseThat, applicationName ); result.put( componentOrApplicationTemplateName, ctx ); } return result.values(); }
@Test public void testFindPrefixesForMandatoryImportedVariables() { Component component = new Component( "comp" ); component.addImportedVariable( new ImportedVariable( "comp.ip", false, false )); component.addImportedVariable( new ImportedVariable( "comp.split.property", false, false )); component.addImportedVariable( new ImportedVariable( "comp.port", false, false )); component.addImportedVariable( new ImportedVariable( "facet.desc", true, false )); component.addImportedVariable( new ImportedVariable( "facet-n.prop1", true, false )); component.addImportedVariable( new ImportedVariable( "facet-n.prop2", false, false )); Instance instance = new Instance( "inst" ).component( component ); Set<String> prefixes = VariableHelpers.findPrefixesForMandatoryImportedVariables( instance ); Assert.assertEquals( 2, prefixes.size()); Assert.assertTrue( prefixes.contains( "comp" )); Assert.assertTrue( prefixes.contains( "facet-n" )); component.importedVariables.clear(); prefixes = VariableHelpers.findPrefixesForMandatoryImportedVariables( instance ); Assert.assertEquals( 0, prefixes.size()); }