private String formatImport(Import imp) { StringBuilder sb = new StringBuilder(); sb.append( "'" ); sb.append(imp.getInstancePath()); sb.append( "' => { " ); sb.append( formatExportedVariables( imp.getExportedVars())); sb.append(" }"); return sb.toString(); }
@Test public void testToString() { Map<String,String> exportedVars = null; Import imp = new Import( "/root/node", "comp1", exportedVars ); Assert.assertNotNull( imp.toString()); exportedVars = new HashMap<String,String> (); imp = new Import( "/root/node", "comp1", exportedVars ); Assert.assertNotNull( imp.toString()); exportedVars.put( "comp.ip", "127.0.0.1" ); exportedVars.put( "comp.data", null ); imp = new Import( "/root/node", "comp1", exportedVars ); Assert.assertNotNull( imp.toString()); imp = new Import( new Instance( "my VM" )); Assert.assertEquals( "/my VM", imp.getInstancePath()); }
String componentName = importChanged.getComponentName(); sb.append(", importDiff => {" + (importAdded ? "added => {" : "removed => {")
Map<String,String> exportedVariables ) { Import imp = new Import( exportingInstancePath, exportingInstanceComponent ); if( exportedVariables != null && ! exportedVariables.isEmpty()) { imp.getExportedVars().put( entry.getKey(), entry.getValue()); imp.getExportedVars().put( importedVariable, exportedVariables.get( importedVariable ));
instancePaths.add( imp.getInstancePath()); MsgCmdAddImport fakeMsg = new MsgCmdAddImport( addedAppName, imp.getComponentName(), imp.getInstancePath(), imp.getExportedVars()); try { processMsgAddImport( fakeMsg );
@Test public void testFindImportByExportingInstance() { Collection<Import> imports = new HashSet<Import> (); imports.add( new Import( "/some/path", "comp1" )); imports.add( new Import( "/some/path/deeper", "comp1" )); imports.add( new Import( "/some/other-path", "comp1" )); Assert.assertNull( ImportHelpers.findImportByExportingInstance( null, null )); Assert.assertNull( ImportHelpers.findImportByExportingInstance( null, "/some/path" )); Assert.assertNull( ImportHelpers.findImportByExportingInstance( imports, null )); Assert.assertNull( ImportHelpers.findImportByExportingInstance( imports, "/wrong/path" )); Assert.assertEquals( "/some/path", ImportHelpers.findImportByExportingInstance( imports, "/some/path" ).getInstancePath()); Assert.assertEquals( "/some/path/deeper", ImportHelpers.findImportByExportingInstance( imports, "/some/path/deeper" ).getInstancePath()); } }
@Test public void testAddImport() { Map<String,Collection<Import>> prefixToImports = new HashMap<String,Collection<Import>> (); prefixToImports.put( "comp", new ArrayList<Import>( Arrays.asList( new Import( "/root1", "comp1" ), new Import( "/root2", "comp1" )))); Instance inst = new Instance( "inst" ); inst.getImports().putAll( prefixToImports ); Assert.assertEquals( 1, inst.getImports().keySet().size()); Assert.assertTrue( inst.getImports().keySet().contains( "comp" )); ImportHelpers.addImport( inst, "wow", new Import( "/root", "comp1" )); Assert.assertEquals( 2, inst.getImports().keySet().size()); Assert.assertTrue( inst.getImports().keySet().contains( "comp" )); Assert.assertTrue( inst.getImports().keySet().contains( "wow" )); Assert.assertEquals( 2, inst.getImports().get( "comp" ).size()); ImportHelpers.addImport( inst, "comp", new Import( "/root3", "comp1" )); Assert.assertEquals( 3, inst.getImports().get( "comp" ).size()); Assert.assertEquals( 2, inst.getImports().keySet().size()); // We cannot insert the same import twice ImportHelpers.addImport( inst, "comp", new Import( "/root3", "comp1" )); Assert.assertEquals( 3, inst.getImports().get( "comp" ).size()); Assert.assertEquals( 2, inst.getImports().keySet().size()); }
/** * Finds a specific import from the path of the instance that exports it. * @param imports a collection of imports (that can be null) * @param exportingInstancePath the path of the exporting instance * @return an import, or null if none was found */ public static Import findImportByExportingInstance( Collection<Import> imports, String exportingInstancePath ) { Import result = null; if( imports != null && exportingInstancePath != null ) { for( Import imp : imports ) { if( exportingInstancePath.equals( imp.getInstancePath())) { result = imp; break; } } } return result; } }
@Test public void testBuildTailoredImport_withWildcard() { String instancePath = "/whatever/this/is/a-test"; Component comp = new Component( "comp" ); comp.addImportedVariable( new ImportedVariable( "comp1.*", false, false )); comp.addImportedVariable( new ImportedVariable( "comp2.option", true, false )); Instance inst = new Instance( "inst" ).component( comp ); // Null map Import imp = ImportHelpers.buildTailoredImport( inst, instancePath, "comp", null ); Assert.assertEquals( instancePath, imp.getInstancePath()); Assert.assertEquals( 0, imp.getExportedVars().size()); // Empty map imp = ImportHelpers.buildTailoredImport( inst, instancePath, "comp", new HashMap<String,String> ()); Assert.assertEquals( 0, imp.getExportedVars().size()); // Map with various variable Map<String,String> map = new HashMap<String,String> (); map.put( "comp1.ip", "127.0.0.1" ); map.put( "comp2.option", "ciao!" ); map.put( "not.a.valid.variable", "yeah" ); map.put( null, "null" ); map.put( "", "hop" ); imp = ImportHelpers.buildTailoredImport( inst, instancePath, "comp", map ); Assert.assertEquals( instancePath, imp.getInstancePath()); Assert.assertEquals( 2, imp.getExportedVars().size()); Assert.assertEquals( "comp", imp.getComponentName()); Assert.assertEquals( "127.0.0.1", imp.getExportedVars().get( "comp1.ip" )); Assert.assertEquals( "ciao!", imp.getExportedVars().get( "comp2.option" )); }
@Test public void testUpdateImports() { Map<String,Collection<Import>> prefixToImports = new HashMap<String,Collection<Import>> (); prefixToImports.put( "comp", Arrays.asList( new Import( "/root1", "comp1" ), new Import( "/root2", "comp1" ))); Instance inst = new Instance( "inst" ); Assert.assertEquals( 0, inst.getImports().size()); ImportHelpers.updateImports( inst, prefixToImports ); Assert.assertEquals( 1, inst.getImports().size()); Iterator<Import> iterator = inst.getImports().get( "comp" ).iterator(); Assert.assertEquals( "/root1", iterator.next().getInstancePath()); Assert.assertEquals( "/root2", iterator.next().getInstancePath()); Assert.assertFalse( iterator.hasNext()); prefixToImports.put( "comp", Arrays.asList( new Import( "/root1", "comp1" ))); ImportHelpers.updateImports( inst, prefixToImports ); Assert.assertEquals( 1, inst.getImports().size()); iterator = inst.getImports().get( "comp" ).iterator(); Assert.assertEquals( "/root1", iterator.next().getInstancePath()); Assert.assertFalse( iterator.hasNext()); ImportHelpers.updateImports( inst, null ); Assert.assertEquals( 0, inst.getImports().size()); }
imports.add( new Import( msg.getAddedInstancePath(), msg.getComponentOrFacetName(), msg.getExportedVariables()));
private void removeCachedExternalImport( MsgCmdRemoveImport msg ) { Collection<Import> imports = this.applicationNameToExternalExports.get( msg.getApplicationOrContextName()); if( imports != null ) { Import toRemove = null; for( Iterator<Import> it = imports.iterator(); it.hasNext() && toRemove == null; ) { Import cur = it.next(); if( cur.getInstancePath().equals( msg.getRemovedInstancePath())) toRemove = cur; } if( toRemove != null ) imports.remove( toRemove ); if( imports.isEmpty()) this.applicationNameToExternalExports.remove( msg.getApplicationOrContextName()); } }
@Test public void testBuildTailoredImport() { String instancePath = "/whatever/this/is/a-test"; Component comp = new Component( "comp" ); comp.addImportedVariable( new ImportedVariable( "comp1.port", false, false )); comp.addImportedVariable( new ImportedVariable( "comp1.ip", false, false )); comp.addImportedVariable( new ImportedVariable( "comp2.option", true, false )); Instance inst = new Instance( "inst" ).component( comp ); // Null map Import imp = ImportHelpers.buildTailoredImport( inst, instancePath, "comp", null ); Assert.assertEquals( instancePath, imp.getInstancePath()); Assert.assertEquals( 0, imp.getExportedVars().size()); // Empty map imp = ImportHelpers.buildTailoredImport( inst, instancePath, "comp", new HashMap<String,String> ()); Assert.assertEquals( 0, imp.getExportedVars().size()); // Map with various variable Map<String,String> map = new HashMap<String,String> (); map.put( "comp1.ip", "127.0.0.1" ); map.put( "comp2.option", "ciao!" ); map.put( "not.a.valid.variable", "yeah" ); map.put( null, "null" ); map.put( "", "hop" ); imp = ImportHelpers.buildTailoredImport( inst, instancePath, "comp", map ); Assert.assertEquals( instancePath, imp.getInstancePath()); Assert.assertEquals( 2, imp.getExportedVars().size()); Assert.assertEquals( "comp", imp.getComponentName()); Assert.assertEquals( "127.0.0.1", imp.getExportedVars().get( "comp1.ip" )); Assert.assertEquals( "ciao!", imp.getExportedVars().get( "comp2.option" )); }
@Test public void testHasAllRequiredImports_withWildcard() throws Exception { // Same test than "testHasAllRequiredImports_required" // but here, variable imports use a wild card. Component dbComponent = new Component( "database" ).installerName( "whatever" ); dbComponent.addExportedVariable( new ExportedVariable( "database.ip", null )); dbComponent.addExportedVariable( new ExportedVariable( "database.port", "3009" )); dbComponent.addExportedVariable( new ExportedVariable( "database.collection", "whatever" )); Component appServerComponent = new Component( "app-server" ).installerName( "whatever" ); appServerComponent.addExportedVariable( new ExportedVariable( "app-server.ip", null )); appServerComponent.addExportedVariable( new ExportedVariable( "app-server.port", "8009" )); appServerComponent.addImportedVariable( new ImportedVariable( "database.*", false, false )); Instance appServer = new Instance( "app server" ).component( appServerComponent ); appServer.overriddenExports.put( "app-server.ip", "192.168.1.15" ); appServer.setStatus( InstanceStatus.STARTING ); Instance database = new Instance( "database" ).component( dbComponent ); database.overriddenExports.put( "database.ip", "192.168.1.28" ); // The application server does not know about the database Assert.assertFalse( ImportHelpers.hasAllRequiredImports( appServer, Logger.getAnonymousLogger())); // The application server is now aware of the database ImportHelpers.addImport( appServer, "database", new Import( database )); Assert.assertTrue( ImportHelpers.hasAllRequiredImports( appServer, null )); appServer.getImports().clear(); Assert.assertFalse( ImportHelpers.hasAllRequiredImports( appServer, null )); }
@Test public void testHasAllRequiredImports_required() throws Exception { Component dbComponent = new Component( "database" ).installerName( "whatever" ); dbComponent.addExportedVariable( new ExportedVariable( "database.ip", null )); dbComponent.addExportedVariable( new ExportedVariable( "database.port", "3009" )); dbComponent.addExportedVariable( new ExportedVariable( "database.collection", "whatever" )); Component appServerComponent = new Component( "app-server" ).installerName( "whatever" ); appServerComponent.addExportedVariable( new ExportedVariable( "app-server.ip", null )); appServerComponent.addExportedVariable( new ExportedVariable( "app-server.port", "8009" )); appServerComponent.addImportedVariable( new ImportedVariable( "database.ip", false, false )); appServerComponent.addImportedVariable( new ImportedVariable( "database.port", false, false )); appServerComponent.addImportedVariable( new ImportedVariable( "database.collection", true, false )); Instance appServer = new Instance( "app server" ).component( appServerComponent ); appServer.overriddenExports.put( "app-server.ip", "192.168.1.15" ); appServer.setStatus( InstanceStatus.STARTING ); Instance database = new Instance( "database" ).component( dbComponent ); database.overriddenExports.put( "database.ip", "192.168.1.28" ); // The application server does not know about the database Assert.assertFalse( ImportHelpers.hasAllRequiredImports( appServer, Logger.getAnonymousLogger())); // The application server is now aware of the database ImportHelpers.addImport( appServer, "database", new Import( database )); Assert.assertTrue( ImportHelpers.hasAllRequiredImports( appServer, null )); appServer.getImports().clear(); Assert.assertFalse( ImportHelpers.hasAllRequiredImports( appServer, null )); }
@Test public void testHasAllRequiredImports_optional() throws Exception { Component clusterNodeComponent = new Component( "cluster" ).installerName( "whatever" ); clusterNodeComponent.addImportedVariable( new ImportedVariable( "cluster.ip", true, false )); clusterNodeComponent.addImportedVariable( new ImportedVariable( "cluster.port", true, false )); clusterNodeComponent.addExportedVariable( new ExportedVariable( "cluster.ip", null )); clusterNodeComponent.addExportedVariable( new ExportedVariable( "cluster.port", "9007" )); Instance i1 = new Instance( "inst 1" ).component( clusterNodeComponent ); i1.overriddenExports.put( "cluster.ip", "192.168.1.15" ); i1.setStatus( InstanceStatus.STARTING ); Instance i2 = new Instance( "inst 2" ).component( clusterNodeComponent ); i2.overriddenExports.put( "cluster.ip", "192.168.1.28" ); // The cluster node does not know about the other node Assert.assertTrue( ImportHelpers.hasAllRequiredImports( i1, null )); Assert.assertTrue( ImportHelpers.hasAllRequiredImports( i2, null )); // The node is now aware of another node ImportHelpers.addImport( i1, "cluster", new Import( i2 )); i1.setStatus( InstanceStatus.STARTING ); Assert.assertTrue( ImportHelpers.hasAllRequiredImports( i1, null )); Assert.assertTrue( ImportHelpers.hasAllRequiredImports( i2, null )); i1.getImports().clear(); Assert.assertTrue( ImportHelpers.hasAllRequiredImports( i1, null )); Assert.assertTrue( ImportHelpers.hasAllRequiredImports( i2, null )); }