From: Erik Brakkee <erik@brakkee.org>
Date: Sun, 20 Apr 2008 21:54:37 +0000 (+0000)
Subject: Less duplication of validation and start. Validation should be a dry-run
X-Git-Tag: wamblee-utils-0.7~767
X-Git-Url: http://wamblee.org/gitweb/?a=commitdiff_plain;h=463048842cf881c2ba688a4d5c7549edad00fbaa;p=utils

Less duplication of validation and start. Validation should be a dry-run
of starting.
---

diff --git a/system/general/src/main/java/org/wamblee/system/core/Container.java b/system/general/src/main/java/org/wamblee/system/core/Container.java
index b9056971..8e98755b 100644
--- a/system/general/src/main/java/org/wamblee/system/core/Container.java
+++ b/system/general/src/main/java/org/wamblee/system/core/Container.java
@@ -78,13 +78,12 @@ public class Container extends AbstractComponent<Scope> {
             ProvidedInterface[] aProvided, RequiredInterface[] aRequired) {
         super(aName, aProvided, aRequired);
         _components = new ArrayList<Component>();
-       
+
         _componentNames = new HashSet<String>();
         _sealed = false;
         for (Component component : aComponents) {
             addComponent(component);
         }
-        validate();
     }
 
     public Container(String aName) {
@@ -144,46 +143,28 @@ public class Container extends AbstractComponent<Scope> {
             required.addAll(Arrays.asList(component.getRequiredInterfaces()));
         }
 
-        validateProvidedInterfaces(provided);
+        validateProvidedInterfacesArePresent(provided);
 
         validateRequiredInterfaces(required);
 
-        List<RequiredInterface> reallyRequired = validateRequiredProvidedMatch(
-                provided, required);
-
-        String missingRequired = "";
-        for (RequiredInterface service : reallyRequired) {
-            missingRequired += service + "\n";
-        }
-        if (missingRequired.length() > 0) {
-            throw new SystemAssemblyException(getName()
-                    + ": missing required services\n" + missingRequired);
-        }
+        addProvidersOfRequiredInterfaces(provided);
+        validateRequiredProvidedMatch(provided, required);
     }
 
-    private List<RequiredInterface> validateRequiredProvidedMatch(
+    /**
+     * 
+     * @param aProvided
+     *            All provided interfaces.
+     * @param aRequired
+     *            All required interfaces.
+     * @return
+     */
+    private void validateRequiredProvidedMatch(
             List<ProvidedInterface> aProvided, List<RequiredInterface> aRequired) {
-        List<RequiredInterface> reallyRequired = new ArrayList<RequiredInterface>(
-                aRequired);
-        // Compute all required interfaces that are not provided
-
-        for (ProvidedInterface service : aProvided) {
-            List<RequiredInterface> fulfilled = Arrays
-                    .asList(filterRequiredServices(service, reallyRequired));
-            reallyRequired.removeAll(fulfilled);
-        }
-        // Now remove all optional interfaces from the list.
-        for (Iterator<RequiredInterface> i = reallyRequired.iterator(); i
-                .hasNext();) {
-            RequiredInterface req = i.next();
-            if (req.isOptional()) {
-                i.remove();
-            }
+
+        for (Component component : _components) {
+            initializeProvidersForRequiredInterfaces(aProvided, component, true);
         }
-        // Now the remaining interfaces should be covered by the required
-        // list.
-        reallyRequired.removeAll(Arrays.asList(getRequiredInterfaces()));
-        return reallyRequired;
     }
 
     private void validateRequiredInterfaces(List<RequiredInterface> aRequired) {
@@ -216,7 +197,8 @@ public class Container extends AbstractComponent<Scope> {
         }
     }
 
-    private void validateProvidedInterfaces(List<ProvidedInterface> aProvided) {
+    private void validateProvidedInterfacesArePresent(
+            List<ProvidedInterface> aProvided) {
         for (ProvidedInterface service : getProvidedInterfaces()) {
             // TODO provided interfaces by components could be
             // provide subclasses or implementations of the
@@ -270,26 +252,13 @@ public class Container extends AbstractComponent<Scope> {
 
         List<ProvidedInterface> allProvided = new ArrayList<ProvidedInterface>();
 
-        // all interfaces from the required list of this container are
-        // provided to the components inside it.
-        RequiredInterface[] required = getRequiredInterfaces();
-        for (RequiredInterface intf : required) {
-            ProvidedInterface provider = intf.getProvider();
-            if (provider != null) {
-                allProvided.add(provider);
-            } else {
-                if (!intf.isOptional()) {
-                    throw new SystemAssemblyException(getQualifiedName()
-                            + ": required interface '" + intf
-                            + "' is not provided");
-                }
-            }
-        }
+        addProvidersOfRequiredInterfaces(allProvided);
 
         List<Component> started = new ArrayList<Component>();
         for (Component component : _components) {
             try {
-                checkAllRequiredServicesAlreadyProvided(allProvided, component);
+                initializeProvidersForRequiredInterfaces(allProvided,
+                        component, false);
 
                 // Start the service.
                 Object runtime = component.start(scope);
@@ -312,6 +281,25 @@ public class Container extends AbstractComponent<Scope> {
         return scope;
     }
 
+    private void addProvidersOfRequiredInterfaces(
+            List<ProvidedInterface> allProvided) {
+        // all interfaces from the required list of this container are
+        // provided to the components inside it.
+        RequiredInterface[] required = getRequiredInterfaces();
+        for (RequiredInterface intf : required) {
+            ProvidedInterface provider = intf.getProvider();
+            if (provider != null) {
+                allProvided.add(provider);
+            } else {
+                if (!intf.isOptional()) {
+                    throw new SystemAssemblyException(getQualifiedName()
+                            + ": required interface '" + intf
+                            + "' is not provided");
+                }
+            }
+        }
+    }
+
     private void stopAlreadyStartedComponents(List<Component> aStarted,
             Scope aScope) {
         // an exception occurred, stop the successfully started
@@ -326,8 +314,20 @@ public class Container extends AbstractComponent<Scope> {
         }
     }
 
-    private void checkAllRequiredServicesAlreadyProvided(
-            List<ProvidedInterface> aAllProvided, Component aComponent) {
+    /**
+     * Sets the provided interface or a component.
+     * 
+     * @param aAllProvided
+     *            All available provided interfaces.
+     * @param aComponent
+     *            Component whose required interfaces we are looking at.
+     * @param aValidateOnly
+     *            If true then the provider will not be set for required
+     *            interfaces.
+     */
+    private void initializeProvidersForRequiredInterfaces(
+            List<ProvidedInterface> aAllProvided, Component aComponent,
+            boolean aValidateOnly) {
         // Check if all required services are already provided by
         // earlier
         // systems.
@@ -336,7 +336,9 @@ public class Container extends AbstractComponent<Scope> {
             ProvidedInterface[] filtered = filterProvidedServices(descriptor,
                     aAllProvided);
             if (filtered.length == 1) {
-                descriptor.setProvider(filtered[0]);
+                if (!aValidateOnly) {
+                    descriptor.setProvider(filtered[0]);
+                }
             } else if (filtered.length > 1) {
                 throw new SystemAssemblyException(
                         "Service '"
diff --git a/system/general/src/test/java/org/wamblee/system/core/ContainerTest.java b/system/general/src/test/java/org/wamblee/system/core/ContainerTest.java
index 8b6c61e8..90723ed1 100644
--- a/system/general/src/test/java/org/wamblee/system/core/ContainerTest.java
+++ b/system/general/src/test/java/org/wamblee/system/core/ContainerTest.java
@@ -84,7 +84,6 @@ public class ContainerTest extends TestCase {
 		Container container = new Container("root", new Component[] {
 				environment, application }, new ProvidedInterface[0],
 				new RequiredInterface[0]);
-
 		Scope scope = container.start();
 		assertTrue(container.isSealed());
 		AssertionUtils.assertEquals(new String[] { "start.environment",
@@ -164,6 +163,7 @@ public class ContainerTest extends TestCase {
 					new ProvidedInterface[] { new DefaultProvidedInterface(
 							"float", Float.class) },
 					new DefaultRequiredInterface[0]);
+			system.validate(); 
 		} catch (SystemAssemblyException e) {
 			return;
 		}