diff options
Diffstat (limited to 'sca-java-1.x/tags/1.2/modules/assembly/src/main/java/org/apache/tuscany/sca/assembly/builder/impl')
15 files changed, 4644 insertions, 0 deletions
diff --git a/sca-java-1.x/tags/1.2/modules/assembly/src/main/java/org/apache/tuscany/sca/assembly/builder/impl/BindingPolicyComputer.java b/sca-java-1.x/tags/1.2/modules/assembly/src/main/java/org/apache/tuscany/sca/assembly/builder/impl/BindingPolicyComputer.java new file mode 100644 index 0000000000..265846e23f --- /dev/null +++ b/sca-java-1.x/tags/1.2/modules/assembly/src/main/java/org/apache/tuscany/sca/assembly/builder/impl/BindingPolicyComputer.java @@ -0,0 +1,263 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ + +package org.apache.tuscany.sca.assembly.builder.impl; + +import java.util.ArrayList; +import java.util.Hashtable; +import java.util.List; + +import javax.xml.namespace.QName; + +import org.apache.tuscany.sca.assembly.Base; +import org.apache.tuscany.sca.assembly.Binding; +import org.apache.tuscany.sca.assembly.ConfiguredOperation; +import org.apache.tuscany.sca.assembly.Contract; +import org.apache.tuscany.sca.assembly.OperationsConfigurator; +import org.apache.tuscany.sca.assembly.Service; +import org.apache.tuscany.sca.policy.Intent; +import org.apache.tuscany.sca.policy.IntentAttachPoint; +import org.apache.tuscany.sca.policy.IntentAttachPointType; +import org.apache.tuscany.sca.policy.PolicySet; +import org.apache.tuscany.sca.policy.PolicySetAttachPoint; +import org.apache.tuscany.sca.policy.util.PolicyComputationUtils; +import org.apache.tuscany.sca.policy.util.PolicyValidationException; + +/** + * Policy computation methods pertaining to computing Binding policies + */ +public class BindingPolicyComputer extends PolicyComputer { + + public BindingPolicyComputer() { + super(); + } + + public void computeBindingIntentsAndPolicySets(Contract contract) throws PolicyValidationException { + for (Binding binding : contract.getBindings()) { + if (binding instanceof PolicySetAttachPoint) { + computeIntents((IntentAttachPoint)binding, contract.getRequiredIntents()); + + aggregateAndPruneApplicablePolicySets(contract.getApplicablePolicySets(), + ((PolicySetAttachPoint)binding).getApplicablePolicySets()); + + computePolicySets((PolicySetAttachPoint)binding, contract.getPolicySets()); + + if ( binding instanceof OperationsConfigurator && + contract instanceof OperationsConfigurator ) { + //add or merge service operations to the binding + addInheritedOpConfOnBindings((OperationsConfigurator)contract, + (OperationsConfigurator)binding, + (PolicySetAttachPoint)binding); + + computeIntentsForOperations((IntentAttachPoint)binding); + computePolicySetsForOperations(contract.getApplicablePolicySets(), + (PolicySetAttachPoint)binding); + } + } + } + + if ( contract.getCallback() != null ) { + for (Binding binding : contract.getCallback().getBindings()) { + if (binding instanceof PolicySetAttachPoint) { + computeIntents((IntentAttachPoint)binding, contract.getCallback().getRequiredIntents()); + + aggregateAndPruneApplicablePolicySets(contract.getApplicablePolicySets(), + ((PolicySetAttachPoint)binding).getApplicablePolicySets()); + + computePolicySets((PolicySetAttachPoint)binding, contract.getCallback().getPolicySets()); + } + } + } + } + + + private void computeIntents(IntentAttachPoint policiedBinding, List<Intent> inheritedIntents) + throws PolicyValidationException { + //since the parent component could also contain intents that apply to implementation + //and binding elements within, we filter out only those that apply to this binding type + List<Intent> prunedIntents = computeInheritableIntents(policiedBinding.getType(), + inheritedIntents); + policiedBinding.getRequiredIntents().addAll(prunedIntents); + + normalizeIntents(policiedBinding); + } + + + private void computePolicySets(PolicySetAttachPoint policiedBinding, + List<PolicySet> inheritedPolicySets) throws PolicyValidationException { + + List<PolicySet> prunedPolicySets = computeInheritablePolicySets(inheritedPolicySets, + policiedBinding.getApplicablePolicySets()); + policiedBinding.getPolicySets().addAll(prunedPolicySets); + normalizePolicySets(policiedBinding); + } + + public void determineApplicableBindingPolicySets(Contract source, Contract target) throws PolicyComputationException { + List<Intent> intentsCopy = null; + for (Binding aBinding : source.getBindings()) { + if (aBinding instanceof PolicySetAttachPoint) { + PolicySetAttachPoint policiedBinding = (PolicySetAttachPoint)aBinding; + IntentAttachPointType bindingType = policiedBinding.getType(); + + + intentsCopy = new ArrayList<Intent>(policiedBinding.getRequiredIntents()); + // add the target component's intents to the reference binding + if (target != null) { + for (Intent intent : target.getRequiredIntents()) { + if (!policiedBinding.getRequiredIntents().contains(intent)) { + for (QName constrained : intent.getConstrains()) { + if (bindingType != null && bindingType.getName().getNamespaceURI() + .equals(constrained.getNamespaceURI()) + && bindingType.getName().getLocalPart().startsWith(constrained + .getLocalPart())) { + policiedBinding.getRequiredIntents().add(intent); + break; + } + } + } + } + } + + //trim intents specified in operations. First check for policysets specified on the operation + //and then in the parent implementation + if ( aBinding instanceof OperationsConfigurator ) { + OperationsConfigurator opConfigurator = (OperationsConfigurator)aBinding; + + for ( ConfiguredOperation confOp : opConfigurator.getConfiguredOperations() ) { + List<Intent> opsIntentsCopy = new ArrayList<Intent>(confOp.getRequiredIntents()); + + trimInherentlyProvidedIntents(policiedBinding.getType(), + confOp.getRequiredIntents()); + trimProvidedIntents(confOp.getRequiredIntents(), confOp.getPolicySets()); + trimProvidedIntents(confOp.getRequiredIntents(), policiedBinding.getPolicySets()); + + determineApplicableDomainPolicySets(policiedBinding.getApplicablePolicySets(), + confOp, + policiedBinding.getType()); + + if (confOp.getRequiredIntents().size() > 0) { + new PolicyComputationException("The following are unfulfilled intents for operations configured in " + + "binding - " + aBinding.getName() + "\nUnfulfilled Intents = " + + confOp.getRequiredIntents()); + } + + //the intents list could have been trimmed when matching for policysets + //since the bindings may need the original set of intents we copy that back + confOp.getRequiredIntents().clear(); + confOp.getRequiredIntents().addAll(opsIntentsCopy); + + } + } + + trimInherentlyProvidedIntents(policiedBinding.getType(), + policiedBinding.getRequiredIntents()); + trimProvidedIntents(policiedBinding.getRequiredIntents(), policiedBinding + .getPolicySets()); + + // determine additional policysets that match remaining intents + // TODO: resolved to domain policy registry and attach suitable + // policy sets to the binding + // for now using the SCA Definitions instead of registry + // if there are intents that are not provided by any policy set + // throw a warning + determineApplicableDomainPolicySets(source, policiedBinding); + + //the intents list could have been trimmed when matching for policysets + //since the bindings may need the original set of intents we copy that back + policiedBinding.getRequiredIntents().clear(); + policiedBinding.getRequiredIntents().addAll(intentsCopy); + + } + } + } + + private void determineApplicableDomainPolicySets(Contract contract, + PolicySetAttachPoint policiedBinding) + throws PolicyComputationException { + //if ( domainPolicySets != null) { + determineApplicableDomainPolicySets(policiedBinding.getApplicablePolicySets(), + policiedBinding, + policiedBinding.getType()); + + if ( policiedBinding.getRequiredIntents().size() > 0 ) { + if ( contract instanceof Service ) { + throw new PolicyComputationException("The following are unfulfilled intents for " + + "binding in service - " + contract.getName() + "\nUnfulfilled Intents = " + + policiedBinding.getRequiredIntents()); + } else { + throw new PolicyComputationException("The are unfulfilled intents for " + + "binding in reference - " + contract.getName() + "\nUnfulfilled Intents = " + + policiedBinding.getRequiredIntents()); + } + } + //} + } + + private void addInheritedOpConfOnBindings(OperationsConfigurator source, + OperationsConfigurator target, + PolicySetAttachPoint attachPoint) throws PolicyValidationException { + boolean found = false; + + List<ConfiguredOperation> additionalOperations = new ArrayList<ConfiguredOperation>(); + for ( ConfiguredOperation sourceConfOp : source.getConfiguredOperations() ) { + for ( ConfiguredOperation targetConfOp : target.getConfiguredOperations() ) { + if ( sourceConfOp.getName().equals(targetConfOp.getName())) { + List<Intent> prunedIntents = computeInheritableIntents(attachPoint.getType(), + sourceConfOp.getRequiredIntents()); + PolicyComputationUtils.addInheritedIntents(prunedIntents, + targetConfOp.getRequiredIntents()); + + List<PolicySet> prunedPolicySets = computeInheritablePolicySets(sourceConfOp.getPolicySets(), + attachPoint.getApplicablePolicySets()); + PolicyComputationUtils.addInheritedPolicySets(prunedPolicySets, targetConfOp.getPolicySets(), true); + found = true; + break; + } + } + + if ( !found ) { + additionalOperations.add(sourceConfOp); + } + } + + if ( !additionalOperations.isEmpty() ) { + target.getConfiguredOperations().addAll(additionalOperations); + } + } + + /*private void addInheritedOpConfOnBindings(Contract contract) { + for ( Binding binding : contract.getBindings() ) { + if ( binding instanceof OperationsConfigurator ) { + addInheritedOperationConfigurations(contract, (OperationsConfigurator)binding); + } + } + }*/ + + private void aggregateAndPruneApplicablePolicySets(List<PolicySet> source, List<PolicySet> target) { + target.addAll(source); + //strip duplicates + Hashtable<QName, PolicySet> policySetTable = new Hashtable<QName, PolicySet>(); + for ( PolicySet policySet : target ) { + policySetTable.put(policySet.getName(), policySet); + } + + target.clear(); + target.addAll(policySetTable.values()); + } +} diff --git a/sca-java-1.x/tags/1.2/modules/assembly/src/main/java/org/apache/tuscany/sca/assembly/builder/impl/BindingUtil.java b/sca-java-1.x/tags/1.2/modules/assembly/src/main/java/org/apache/tuscany/sca/assembly/builder/impl/BindingUtil.java new file mode 100644 index 0000000000..c1a4605f83 --- /dev/null +++ b/sca-java-1.x/tags/1.2/modules/assembly/src/main/java/org/apache/tuscany/sca/assembly/builder/impl/BindingUtil.java @@ -0,0 +1,143 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ +package org.apache.tuscany.sca.assembly.builder.impl; + +import java.util.ArrayList; +import java.util.List; + +import org.apache.tuscany.sca.assembly.Binding; +import org.apache.tuscany.sca.assembly.Component; +import org.apache.tuscany.sca.assembly.ComponentReference; +import org.apache.tuscany.sca.assembly.ComponentService; +import org.apache.tuscany.sca.assembly.OptimizableBinding; +import org.apache.tuscany.sca.assembly.Reference; +import org.apache.tuscany.sca.assembly.SCABinding; +import org.apache.tuscany.sca.policy.PolicySet; +import org.apache.tuscany.sca.policy.PolicySetAttachPoint; + +/** + * This class encapsulates utility methods to deal with binding definitions + */ +class BindingUtil { + private static boolean hasCompatiblePolicySets(Binding refBinding, Binding svcBinding) { + boolean isCompatible = true;; + if ( refBinding instanceof PolicySetAttachPoint && svcBinding instanceof PolicySetAttachPoint ) { + //TODO : need to add more compatibility checks at the policy attachment levels + for ( PolicySet svcPolicySet : ((PolicySetAttachPoint)svcBinding).getPolicySets() ) { + isCompatible = false; + for ( PolicySet refPolicySet : ((PolicySetAttachPoint)refBinding).getPolicySets() ) { + if ( svcPolicySet.equals(refPolicySet) ) { + isCompatible = true; + break; + } + } + //if there exists no matching policy set in the reference binding + if ( !isCompatible ) { + return isCompatible; + } + } + } + return isCompatible; + } + + + public static Binding matchBinding(Component component, ComponentService service, List<Binding> source, List<Binding> target) { + List<Binding> matched = new ArrayList<Binding>(); + // Find the corresponding bindings from the service side + for (Binding binding : source) { + for (Binding serviceBinding : target) { + if (binding.getClass() == serviceBinding.getClass() && + hasCompatiblePolicySets(binding, serviceBinding)) { + + try { + Binding cloned = (Binding)binding.clone(); + + //Customise the binding name to make it unique + // regardless of how many bindings or targets there are + if ( component != null){ + cloned.setName(binding.getName() + "#" + component.getName() + "/" + serviceBinding.getName()); + } else { + cloned.setName(binding.getName() + "#" + serviceBinding.getName()); + } + + // Set the binding URI to the URI of the target service + // that has been matched + if (binding.getURI() == null) { + cloned.setURI(serviceBinding.getURI()); + } + + if (binding instanceof OptimizableBinding) { + OptimizableBinding endpoint = ((OptimizableBinding)cloned); + endpoint.setTargetComponent(component); + endpoint.setTargetComponentService(service); + endpoint.setTargetBinding(serviceBinding); + } + + matched.add(cloned); + break; + } catch (Exception ex) { + // do nothing + } + } + } + } + if (matched.isEmpty()) { + // No matching binding + return null; + } else { + for (Binding binding : matched) { + // If binding.sca is present, use it + if (SCABinding.class.isInstance(binding)) { + return binding; + } + } + // Use the first one + return matched.get(0); + } + } + + /** + * Choose a binding for the reference based on the bindings available on the + * service + * + * @param reference The component reference + * @param service The component service + * @return Resolved binding + */ + static Binding resolveBindings(ComponentReference reference, Component component, ComponentService service) { + List<Binding> source = reference.getBindings(); + List<Binding> target = service.getBindings(); + + return matchBinding(component, service, source, target); + + } + + + /** + * @param reference + * @param service + * @return + */ + static Binding resolveCallbackBindings(ComponentReference reference, Component component, ComponentService service) { + List<Binding> source = reference.getCallback().getBindings(); + List<Binding> target = service.getCallback().getBindings(); + + return matchBinding(component, service, source, target); + } +} diff --git a/sca-java-1.x/tags/1.2/modules/assembly/src/main/java/org/apache/tuscany/sca/assembly/builder/impl/CompositeBuilderImpl.java b/sca-java-1.x/tags/1.2/modules/assembly/src/main/java/org/apache/tuscany/sca/assembly/builder/impl/CompositeBuilderImpl.java new file mode 100644 index 0000000000..ef9d65b37c --- /dev/null +++ b/sca-java-1.x/tags/1.2/modules/assembly/src/main/java/org/apache/tuscany/sca/assembly/builder/impl/CompositeBuilderImpl.java @@ -0,0 +1,109 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ +package org.apache.tuscany.sca.assembly.builder.impl; + +import java.util.logging.Level; +import java.util.logging.Logger; + +import org.apache.tuscany.sca.assembly.AssemblyFactory; +import org.apache.tuscany.sca.assembly.Composite; +import org.apache.tuscany.sca.assembly.SCABindingFactory; +import org.apache.tuscany.sca.assembly.builder.CompositeBuilder; +import org.apache.tuscany.sca.assembly.builder.CompositeBuilderException; +import org.apache.tuscany.sca.assembly.builder.CompositeBuilderMonitor; +import org.apache.tuscany.sca.assembly.builder.Problem; +import org.apache.tuscany.sca.assembly.builder.Problem.Severity; +import org.apache.tuscany.sca.interfacedef.InterfaceContractMapper; +import org.apache.tuscany.sca.policy.IntentAttachPointTypeFactory; + +/** + * A builder that handles the configuration of the components inside a composite + * and the wiring of component references to component services. + * + * @version $Rev$ $Date$ + */ +public class CompositeBuilderImpl implements CompositeBuilder { + private final static Logger logger = Logger.getLogger(CompositeBuilderImpl.class.getName()); + private CompositeIncludeBuilderImpl includeBuilder; + private CompositeWireBuilderImpl wireBuilder; + private CompositeCloneBuilderImpl cloneBuilder; + private CompositeConfigurationBuilderImpl configurationBuilder; + + /** + * Constructs a new composite util. + * + * @param assemblyFactory + * @param interfaceContractMapper + */ + public CompositeBuilderImpl(AssemblyFactory assemblyFactory, + SCABindingFactory scaBindingFactory, + IntentAttachPointTypeFactory intentAttachPointTypeFactory, + InterfaceContractMapper interfaceContractMapper, + CompositeBuilderMonitor monitor) { + + if (monitor == null) { + // Create a default monitor that logs using the JDK logger. + monitor = new CompositeBuilderMonitor() { + public void problem(Problem problem) { + if (problem.getSeverity() == Severity.INFO) { + logger.info(problem.toString()); + } else if (problem.getSeverity() == Severity.WARNING) { + logger.warning(problem.toString()); + } else if (problem.getSeverity() == Severity.ERROR) { + if (problem.getCause() != null) { + logger.log(Level.SEVERE, problem.toString(), problem.getCause()); + } else { + logger.severe(problem.toString()); + } + } + } + }; + } + + includeBuilder = new CompositeIncludeBuilderImpl(monitor); + wireBuilder = new CompositeWireBuilderImpl(assemblyFactory, interfaceContractMapper, monitor); + cloneBuilder = new CompositeCloneBuilderImpl(monitor); + configurationBuilder = new CompositeConfigurationBuilderImpl(assemblyFactory, scaBindingFactory, intentAttachPointTypeFactory, interfaceContractMapper, monitor); + } + + public void build(Composite composite) throws CompositeBuilderException { + + // Collect and fuse includes + includeBuilder.fuseIncludes(composite); + + // Expand nested composites + cloneBuilder.expandCompositeImplementations(composite); + + // Configure all components + configurationBuilder.configureComponents(composite); + + // Wire the composite + wireBuilder.wireComposite(composite); + + // Activate composite services + configurationBuilder.activateCompositeServices(composite); + + // Wire composite references + wireBuilder.wireCompositeReferences(composite); + + // Fuse nested composites + //cloneBuilder.fuseCompositeImplementations(composite); + } + +} diff --git a/sca-java-1.x/tags/1.2/modules/assembly/src/main/java/org/apache/tuscany/sca/assembly/builder/impl/CompositeCloneBuilderImpl.java b/sca-java-1.x/tags/1.2/modules/assembly/src/main/java/org/apache/tuscany/sca/assembly/builder/impl/CompositeCloneBuilderImpl.java new file mode 100644 index 0000000000..fee8e02f4e --- /dev/null +++ b/sca-java-1.x/tags/1.2/modules/assembly/src/main/java/org/apache/tuscany/sca/assembly/builder/impl/CompositeCloneBuilderImpl.java @@ -0,0 +1,107 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ + +package org.apache.tuscany.sca.assembly.builder.impl; + +import java.util.ArrayList; +import java.util.Iterator; +import java.util.List; + +import org.apache.tuscany.sca.assembly.Component; +import org.apache.tuscany.sca.assembly.Composite; +import org.apache.tuscany.sca.assembly.Implementation; +import org.apache.tuscany.sca.assembly.builder.CompositeBuilderMonitor; + +public class CompositeCloneBuilderImpl { + + public CompositeCloneBuilderImpl(CompositeBuilderMonitor monitor) { + } + + /** + * Expand composite component implementations. + * + * @param composite + * @param problems + */ + public void expandCompositeImplementations(Composite composite) { + for (Component component : composite.getComponents()) { + Implementation implementation = component.getImplementation(); + if (implementation instanceof Composite) { + + Composite compositeImplementation = (Composite)implementation; + Composite clone; + try { + clone = (Composite)compositeImplementation.clone(); + } catch (CloneNotSupportedException e) { + throw new RuntimeException(e); + } + component.setImplementation(clone); + expandCompositeImplementations(clone); + } + } + } + + /** + * Collect all nested composite implementations in a graph of composites. + * + * @param composite + * @param nested + */ + private void collectNestedComposites(Composite composite, List<Composite> nested) { + for (Component component : composite.getComponents()) { + Implementation implementation = component.getImplementation(); + if (implementation instanceof Composite) { + Composite nestedComposite = (Composite)implementation; + nested.add(nestedComposite); + collectNestedComposites(nestedComposite, nested); + } + } + } + + /** + * Fuse nested composites into a top level composite. + * + * @param composite + */ + public void fuseCompositeImplementations(Composite composite) { + + // First collect all nested composites + List<Composite> nested = new ArrayList<Composite>(); + collectNestedComposites(composite, nested); + + // Then add all the non-composite components they contain + for (Composite nestedComposite : nested) { + for (Component component: nestedComposite.getComponents()) { + Implementation implementation = component.getImplementation(); + if (!(implementation instanceof Composite)) { + composite.getComponents().add(component); + } + } + } + + // Clear the initial list of composite components + for (Iterator<Component> i = composite.getComponents().iterator(); i.hasNext();) { + Component component = i.next(); + if (component.getImplementation() instanceof Composite) { + i.remove(); + } + } + } + +} diff --git a/sca-java-1.x/tags/1.2/modules/assembly/src/main/java/org/apache/tuscany/sca/assembly/builder/impl/CompositeConfigurationBuilderImpl.java b/sca-java-1.x/tags/1.2/modules/assembly/src/main/java/org/apache/tuscany/sca/assembly/builder/impl/CompositeConfigurationBuilderImpl.java new file mode 100644 index 0000000000..f536b35140 --- /dev/null +++ b/sca-java-1.x/tags/1.2/modules/assembly/src/main/java/org/apache/tuscany/sca/assembly/builder/impl/CompositeConfigurationBuilderImpl.java @@ -0,0 +1,1403 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ + +package org.apache.tuscany.sca.assembly.builder.impl; + +import java.net.URI; +import java.net.URISyntaxException; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +import javax.xml.namespace.QName; + +import org.apache.tuscany.sca.assembly.AssemblyFactory; +import org.apache.tuscany.sca.assembly.Binding; +import org.apache.tuscany.sca.assembly.Component; +import org.apache.tuscany.sca.assembly.ComponentProperty; +import org.apache.tuscany.sca.assembly.ComponentReference; +import org.apache.tuscany.sca.assembly.ComponentService; +import org.apache.tuscany.sca.assembly.Composite; +import org.apache.tuscany.sca.assembly.CompositeService; +import org.apache.tuscany.sca.assembly.Implementation; +import org.apache.tuscany.sca.assembly.Property; +import org.apache.tuscany.sca.assembly.Reference; +import org.apache.tuscany.sca.assembly.SCABinding; +import org.apache.tuscany.sca.assembly.SCABindingFactory; +import org.apache.tuscany.sca.assembly.Service; +import org.apache.tuscany.sca.assembly.builder.ComponentPreProcessor; +import org.apache.tuscany.sca.assembly.builder.CompositeBuilderException; +import org.apache.tuscany.sca.assembly.builder.CompositeBuilderMonitor; +import org.apache.tuscany.sca.assembly.builder.Problem.Severity; +import org.apache.tuscany.sca.interfacedef.InterfaceContract; +import org.apache.tuscany.sca.interfacedef.InterfaceContractMapper; +import org.apache.tuscany.sca.policy.IntentAttachPointType; +import org.apache.tuscany.sca.policy.IntentAttachPointTypeFactory; +import org.apache.tuscany.sca.policy.PolicySetAttachPoint; + +public class CompositeConfigurationBuilderImpl { + private final static String SCA10_NS = "http://www.osoa.org/xmlns/sca/1.0"; + private final static String BINDING_SCA = "binding.sca"; + private final static QName BINDING_SCA_QNAME = new QName(SCA10_NS, BINDING_SCA); + + private AssemblyFactory assemblyFactory; + private SCABindingFactory scaBindingFactory; + private CompositeBuilderMonitor monitor; + private InterfaceContractMapper interfaceContractMapper; + private IntentAttachPointTypeFactory intentAttachPointTypeFactory; + + + public CompositeConfigurationBuilderImpl(AssemblyFactory assemblyFactory, + SCABindingFactory scaBindingFactory, + IntentAttachPointTypeFactory intentAttachPointTypeFactory, + InterfaceContractMapper interfaceContractMapper, + CompositeBuilderMonitor monitor) { + this.assemblyFactory = assemblyFactory; + this.scaBindingFactory = scaBindingFactory; + this.intentAttachPointTypeFactory = intentAttachPointTypeFactory; + this.interfaceContractMapper = interfaceContractMapper; + this.monitor = monitor; + } + + /** + * Configure components in the composite. + * + * @param composite + * @param problems + */ + public void configureComponents(Composite composite) throws CompositeBuilderException { + configureComponents(composite, null); + configureSourcedProperties(composite, null); + configureBindingURIs(composite, null, null); + } + + /** + * Configure components in the composite. + * + * @param composite + * @param uri + * @param problems + */ + private void configureComponents(Composite composite, String uri) { + String parentURI = uri; + + // Process nested composites recursively + for (Component component : composite.getComponents()) { + + // Initialize component URI + String componentURI; + if (parentURI == null) { + componentURI = component.getName(); + } else { + componentURI = URI.create(parentURI + '/').resolve(component.getName()).toString(); + } + component.setURI(componentURI); + + Implementation implementation = component.getImplementation(); + if (implementation instanceof Composite) { + + // Process nested composite + configureComponents((Composite)implementation, componentURI); + } + } + + // Initialize service bindings + List<Service> compositeServices = composite.getServices(); + for (Service service : compositeServices) { + // Set default binding names + + // Create default SCA binding + if (service.getBindings().isEmpty()) { + SCABinding scaBinding = createSCABinding(); + service.getBindings().add(scaBinding); + } + + // Initialize binding names and URIs + for (Binding binding : service.getBindings()) { + + // Binding name defaults to the service name + if (binding.getName() == null) { + binding.setName(service.getName()); + } + } + + if (service.getCallback() != null) { + for (Binding binding : service.getCallback().getBindings()) { + if (binding.getName() == null) { + binding.setName(service.getName()); + } + } + } + } + + // Initialize reference bindings + for (Reference reference : composite.getReferences()) { + // Create default SCA binding + if (reference.getBindings().isEmpty()) { + SCABinding scaBinding = createSCABinding(); + reference.getBindings().add(scaBinding); + } + + // Set binding names + for (Binding binding : reference.getBindings()) { + if (binding.getName() == null) { + binding.setName(reference.getName()); + } + } + + if (reference.getCallback() != null) { + for (Binding binding : reference.getCallback().getBindings()) { + if (binding.getName() == null) { + binding.setName(reference.getName()); + } + } + } + } + + // Initialize all component services and references + Map<String, Component> components = new HashMap<String, Component>(); + for (Component component : composite.getComponents()) { + + // Index all components and check for duplicates + if (components.containsKey(component.getName())) { + warning("Duplicate component name: " + composite.getName() + + " : " + + component.getName(), composite); + } else { + components.put(component.getName(), component); + } + + // Propagate the autowire flag from the composite to components + if (component.getAutowire() == null) { + component.setAutowire(composite.getAutowire()); + } + + if (component.getImplementation() instanceof ComponentPreProcessor) { + ((ComponentPreProcessor)component.getImplementation()).preProcess(component); + } + + // Index properties, services and references + Map<String, Service> services = new HashMap<String, Service>(); + Map<String, Reference> references = new HashMap<String, Reference>(); + Map<String, Property> properties = new HashMap<String, Property>(); + indexImplementationPropertiesServicesAndReferences(component, + services, + references, + properties); + + // Index component services, references and properties + // Also check for duplicates + Map<String, ComponentService> componentServices = + new HashMap<String, ComponentService>(); + Map<String, ComponentReference> componentReferences = + new HashMap<String, ComponentReference>(); + Map<String, ComponentProperty> componentProperties = + new HashMap<String, ComponentProperty>(); + indexComponentPropertiesServicesAndReferences(component, + componentServices, + componentReferences, + componentProperties); + + // Reconcile component services/references/properties and + // implementation services/references and create component + // services/references/properties for the services/references + // declared by the implementation + reconcileServices(component, services, componentServices); + reconcileReferences(component, references, componentReferences); + reconcileProperties(component, properties, componentProperties); + + // Configure or create callback services for component's references + // with callbacks + configureCallbackServices(component, componentServices); + + // Configure or create callback references for component's services + // with callbacks + configureCallbackReferences(component, componentReferences); + + // Create self references to the component's services +// if (!(component.getImplementation() instanceof Composite)) { +// createSelfReferences(component); +// } + + // Initialize service bindings + for (ComponentService componentService : component.getServices()) { + + // Create default SCA binding + if (componentService.getBindings().isEmpty()) { + SCABinding scaBinding = createSCABinding(); + componentService.getBindings().add(scaBinding); + } + + // Set binding names + for (Binding binding : componentService.getBindings()) { + + // Binding name defaults to the service name + if (binding.getName() == null) { + binding.setName(componentService.getName()); + } + } + if (componentService.getCallback() != null) { + for (Binding binding : componentService.getCallback().getBindings()) { + if (binding.getName() == null) { + binding.setName(componentService.getName()); + } + } + } + } + + // Initialize reference bindings + for (ComponentReference componentReference : component.getReferences()) { + + // Create default SCA binding + if (componentReference.getBindings().isEmpty()) { + SCABinding scaBinding = createSCABinding(); + componentReference.getBindings().add(scaBinding); + } + + // Set binding names + for (Binding binding : componentReference.getBindings()) { + if (binding.getName() == null) { + binding.setName(componentReference.getName()); + } + } + if (componentReference.getCallback() != null) { + for (Binding binding : componentReference.getCallback().getBindings()) { + if (binding.getName() == null) { + binding.setName(componentReference.getName()); + } + } + } + } + } + } + + /** + * Report a warning. + * + * @param problems + * @param message + * @param model + */ + private void warning(String message, Object model) { + monitor.problem(new ProblemImpl(Severity.WARNING, message, model)); + } + + /** + * Reconcile component properties and the properties defined by the + * component type. + * + * @param component + * @param properties + * @param componentProperties + * @param problems + */ + private void reconcileProperties(Component component, + Map<String, Property> properties, + Map<String, ComponentProperty> componentProperties) { + + // Connect component properties to their properties + for (ComponentProperty componentProperty : component.getProperties()) { + Property property = properties.get(componentProperty.getName()); + if (property != null) { + componentProperty.setProperty(property); + } else { + warning("Property not found for component property: " + component.getName() + + "/" + + componentProperty.getName(), component); + } + } + + // Create component properties for all properties + if (component.getImplementation() != null) { + for (Property property : component.getImplementation().getProperties()) { + if (!componentProperties.containsKey(property.getName())) { + ComponentProperty componentProperty = assemblyFactory.createComponentProperty(); + componentProperty.setName(property.getName()); + componentProperty.setMany(property.isMany()); + componentProperty.setXSDElement(property.getXSDElement()); + componentProperty.setXSDType(property.getXSDType()); + componentProperty.setProperty(property); + component.getProperties().add(componentProperty); + } + } + } + + // Reconcile component properties and their properties + for (ComponentProperty componentProperty : component.getProperties()) { + Property property = componentProperty.getProperty(); + if (property != null) { + + // Check that a component property does not override the + // mustSupply attribute + if (!property.isMustSupply() && componentProperty.isMustSupply()) { + warning("Component property mustSupply attribute incompatible with property: " + component + .getName() + + "/" + + componentProperty.getName(), + component); + } + + // Default to the mustSupply attribute specified on the property + if (!componentProperty.isMustSupply()) + componentProperty.setMustSupply(property.isMustSupply()); + + // Default to the value specified on the property + if (componentProperty.getValue() == null) { + componentProperty.setValue(property.getValue()); + } + + // Override the property value for the composite + if(component.getImplementation() instanceof Composite) { + property.setValue(componentProperty.getValue()); + } + + // Check that a value is supplied + if (componentProperty.getValue() == null && property.isMustSupply()) { + warning("No value configured on a mustSupply property: " + component.getName() + + "/" + + componentProperty.getName(), component); + } + + // Check that a a component property does not override the + // many attribute + if (!property.isMany() && componentProperty.isMany()) { + warning("Component property many attribute incompatible with property: " + component + .getName() + + "/" + + componentProperty.getName(), + component); + } + + // Default to the many attribute defined on the property + componentProperty.setMany(property.isMany()); + + // Default to the type and element defined on the property + if (componentProperty.getXSDType() == null) { + componentProperty.setXSDType(property.getXSDType()); + } + if (componentProperty.getXSDElement() == null) { + componentProperty.setXSDElement(property.getXSDElement()); + } + + // Check that a type or element are specified + if (componentProperty.getXSDElement() == null && componentProperty.getXSDType() == null) { + warning("No type specified on component property: " + component.getName() + + "/" + + componentProperty.getName(), component); + } + } + } + } + + /** + * Reconcile component references with the references defined on the + * component type. + * + * @param component + * @param references + * @param componentReferences + * @param problems + */ + private void reconcileReferences(Component component, + Map<String, Reference> references, + Map<String, ComponentReference> componentReferences) { + + // Connect each component reference to the corresponding reference + for (ComponentReference componentReference : component.getReferences()) { + if (componentReference.getReference() != null || componentReference.isCallback()) { + continue; + } + Reference reference = references.get(componentReference.getName()); + if (reference != null) { + componentReference.setReference(reference); + } else { + if (!componentReference.getName().startsWith("$self$.")) { + warning("Reference not found for component reference: " + component.getName() + + "/" + + componentReference.getName(), component); + } + } + } + + // Create a component reference for each reference + if (component.getImplementation() != null) { + for (Reference reference : component.getImplementation().getReferences()) { + if (!componentReferences.containsKey(reference.getName())) { + ComponentReference componentReference = + assemblyFactory.createComponentReference(); + componentReference.setIsCallback(reference.isCallback()); + componentReference.setName(reference.getName()); + componentReference.setReference(reference); + component.getReferences().add(componentReference); + } + } + } + + // Reconcile each component reference with its reference + for (ComponentReference componentReference : component.getReferences()) { + Reference reference = componentReference.getReference(); + if (reference != null) { + // Reconcile multiplicity + if (componentReference.getMultiplicity() != null) { + if (!ReferenceUtil.isValidMultiplicityOverride(reference.getMultiplicity(), + componentReference + .getMultiplicity())) { + warning("Component reference multiplicity incompatible with reference multiplicity: " + component + .getName() + + "/" + + componentReference.getName(), + component); + } + } else { + componentReference.setMultiplicity(reference.getMultiplicity()); + } + + // Reconcile interface + if (componentReference.getInterfaceContract() != null) { + if (!componentReference.getInterfaceContract().equals(reference + .getInterfaceContract())) { + if (!interfaceContractMapper.isCompatible(reference.getInterfaceContract(), + componentReference + .getInterfaceContract())) { + warning("Component reference interface incompatible with reference interface: " + component + .getName() + + "/" + + componentReference.getName(), + component); + } + } + } else { + componentReference.setInterfaceContract(reference.getInterfaceContract()); + } + + // Reconcile bindings + if (componentReference.getBindings().isEmpty()) { + componentReference.getBindings().addAll(reference.getBindings()); + } + + // Reconcile callback bindings + if (componentReference.getCallback() == null) { + componentReference.setCallback(reference.getCallback()); + if (componentReference.getCallback() == null) { + // Create an empty callback to avoid null check + componentReference.setCallback(assemblyFactory.createCallback()); + } + + } else if (componentReference.getCallback().getBindings().isEmpty() && reference + .getCallback() != null) { + componentReference.getCallback().getBindings().addAll(reference.getCallback() + .getBindings()); + } + + // Propagate autowire setting from the component + if (componentReference.getAutowire() == null) { + componentReference.setAutowire(component.getAutowire()); + } + + // Reconcile targets + if (componentReference.getTargets().isEmpty()) { + componentReference.getTargets().addAll(reference.getTargets()); + } + } + } + } + + /** + * Reconcile component services and services defined on the component type. + * + * @param component + * @param services + * @param componentServices + * @param problems + */ + private void reconcileServices(Component component, + Map<String, Service> services, + Map<String, ComponentService> componentServices) { + + // Connect each component service to the corresponding service + for (ComponentService componentService : component.getServices()) { + if (componentService.getService() != null || componentService.isCallback()) { + continue; + } + Service service = services.get(componentService.getName()); + if (service != null) { + componentService.setService(service); + } else { + warning("Service not found for component service: " + component.getName() + + "/" + + componentService.getName(), component); + } + } + + // Create a component service for each service + if (component.getImplementation() != null) { + for (Service service : component.getImplementation().getServices()) { + if (!componentServices.containsKey(service.getName())) { + ComponentService componentService = assemblyFactory.createComponentService(); + componentService.setIsCallback(service.isCallback()); + String name = service.getName(); + componentService.setName(name); + componentService.setService(service); + component.getServices().add(componentService); + componentServices.put(name, componentService); + } + } + } + + //Reconcile each component service with its service + for (ComponentService componentService : component.getServices()) { + Service service = componentService.getService(); + if (service != null) { + // Reconcile interface + if (componentService.getInterfaceContract() != null) { + if (!componentService.getInterfaceContract().equals(service + .getInterfaceContract())) { + if (!interfaceContractMapper.isCompatible(componentService + .getInterfaceContract(), service.getInterfaceContract())) { + warning("Component service interface incompatible with service interface: " + component + .getName() + + "/" + + componentService.getName(), + component); + } + } + } else { + componentService.setInterfaceContract(service.getInterfaceContract()); + } + + // Reconcile bindings + if (componentService.getBindings().isEmpty()) { + componentService.getBindings().addAll(service.getBindings()); + } + + // Reconcile callback bindings + if (componentService.getCallback() == null) { + componentService.setCallback(service.getCallback()); + if (componentService.getCallback() == null) { + // Create an empty callback to avoid null check + componentService.setCallback(assemblyFactory.createCallback()); + } + } else if (componentService.getCallback().getBindings().isEmpty() && service + .getCallback() != null) { + componentService.getCallback().getBindings().addAll(service.getCallback() + .getBindings()); + } + } + } + } + + private void indexComponentPropertiesServicesAndReferences(Component component, + Map<String, ComponentService> componentServices, + Map<String, ComponentReference> componentReferences, + Map<String, ComponentProperty> componentProperties) { + for (ComponentService componentService : component.getServices()) { + if (componentServices.containsKey(componentService.getName())) { + warning("Duplicate component service name: " + component.getName() + + "/" + + componentService.getName(), component); + } else { + componentServices.put(componentService.getName(), componentService); + } + } + for (ComponentReference componentReference : component.getReferences()) { + if (componentReferences.containsKey(componentReference.getName())) { + warning("Duplicate component reference name: " + component.getName() + + "/" + + componentReference.getName(), component); + } else { + componentReferences.put(componentReference.getName(), componentReference); + } + } + for (ComponentProperty componentProperty : component.getProperties()) { + if (componentProperties.containsKey(componentProperty.getName())) { + warning("Duplicate component property name: " + component.getName() + + "/" + + componentProperty.getName(), component); + } else { + componentProperties.put(componentProperty.getName(), componentProperty); + } + } + + } + + private void indexImplementationPropertiesServicesAndReferences(Component component, + Map<String, Service> services, + Map<String, Reference> references, + Map<String, Property> properties) { + // First check that the component has a resolved implementation + Implementation implementation = component.getImplementation(); + if (implementation == null) { + + // A component must have an implementation + warning("No implementation for component: " + component.getName(), component); + + } else if (implementation.isUnresolved()) { + + // The implementation must be fully resolved + warning("Component implementation not found: " + component.getName() + + " : " + + implementation.getURI(), component); + + } else { + + // Index properties, services and references, also check for + // duplicates + for (Property property : implementation.getProperties()) { + if (properties.containsKey(property.getName())) { + warning("Duplicate property name: " + component.getName() + + "/" + + property.getName(), component); + } else { + properties.put(property.getName(), property); + } + } + for (Service service : implementation.getServices()) { + if (services.containsKey(service.getName())) { + warning("Duplicate service name: " + component.getName() + + "/" + + service.getName(), component); + } else { + services.put(service.getName(), service); + } + } + for (Reference reference : implementation.getReferences()) { + if (references.containsKey(reference.getName())) { + warning("Duplicate reference name: " + component.getName() + + "/" + + reference.getName(), component); + } else { + references.put(reference.getName(), reference); + } + } + } + + } + + /** + * For all the references with callbacks, create a corresponding callback + * service. + * + * @param component + */ + private void configureCallbackServices(Component component, + Map<String, ComponentService> componentServices) { + for (ComponentReference reference : component.getReferences()) { + if (reference.getInterfaceContract() != null && // can be null in + // unit tests + reference.getInterfaceContract().getCallbackInterface() != null) { + ComponentService service = + componentServices.get(reference.getName()); + if (service == null) { + service = createCallbackService(component, reference); + } + if (reference.getCallback() != null) { + if (service.getBindings().isEmpty()) { + service.getBindings().addAll(reference.getCallback().getBindings()); + } + } + reference.setCallbackService(service); + } + } + } + + /** + * Create a callback service for a component reference + * + * @param component + * @param reference + */ + private ComponentService createCallbackService(Component component, ComponentReference reference) { + ComponentService componentService = assemblyFactory.createComponentService(); + componentService.setIsCallback(true); + componentService.setName(reference.getName()); + try { + InterfaceContract contract = + (InterfaceContract)reference.getInterfaceContract().clone(); + contract.setInterface(contract.getCallbackInterface()); + contract.setCallbackInterface(null); + componentService.setInterfaceContract(contract); + } catch (CloneNotSupportedException e) { + // will not happen + } + Reference implReference = reference.getReference(); + if (implReference != null) { + Service implService = assemblyFactory.createService(); + implService.setName(implReference.getName()); + try { + InterfaceContract implContract = + (InterfaceContract)implReference.getInterfaceContract().clone(); + implContract.setInterface(implContract.getCallbackInterface()); + implContract.setCallbackInterface(null); + implService.setInterfaceContract(implContract); + } catch (CloneNotSupportedException e) { + // will not happen + } + componentService.setService(implService); + } + component.getServices().add(componentService); + return componentService; + } + + /** + * For all the services with callbacks, create a corresponding callback + * reference. + * + * @param component + */ + private void configureCallbackReferences(Component component, + Map<String, ComponentReference> componentReferences) { + for (ComponentService service : component.getServices()) { + if (service.getInterfaceContract() != null && // can be null in + // unit tests + service.getInterfaceContract().getCallbackInterface() != null) { + ComponentReference reference = + componentReferences.get(service.getName()); + if (reference == null) { + reference = createCallbackReference(component, service); + } + if (service.getCallback() != null) { + if (reference.getBindings().isEmpty()) { + reference.getBindings().addAll(service.getCallback().getBindings()); + } + } + service.setCallbackReference(reference); + } + } + } + + /** + * Create a callback reference for a component service + * + * @param component + * @param service + */ + private ComponentReference createCallbackReference(Component component, ComponentService service) { + ComponentReference componentReference = assemblyFactory.createComponentReference(); + componentReference.setIsCallback(true); + componentReference.setName(service.getName()); + try { + InterfaceContract contract = (InterfaceContract)service.getInterfaceContract().clone(); + contract.setInterface(contract.getCallbackInterface()); + contract.setCallbackInterface(null); + componentReference.setInterfaceContract(contract); + } catch (CloneNotSupportedException e) { + // will not happen + } + Service implService = service.getService(); + if (implService != null) { + Reference implReference = assemblyFactory.createReference(); + implReference.setName(implService.getName()); + try { + InterfaceContract implContract = + (InterfaceContract)implService.getInterfaceContract().clone(); + implContract.setInterface(implContract.getCallbackInterface()); + implContract.setCallbackInterface(null); + implReference.setInterfaceContract(implContract); + } catch (CloneNotSupportedException e) { + // will not happen + } + componentReference.setReference(implReference); + } + component.getReferences().add(componentReference); + return componentReference; + } + + /** + * Activate composite services in nested composites. + * + * @param composite + * @param problems + */ + public void activateCompositeServices(Composite composite) { + + // Process nested composites recursively + activateNestedCompositeServices(composite); + + // Process top level composite services + for (Service service : composite.getServices()) { + CompositeService compositeService = (CompositeService)service; + + // Get the inner most promoted service + ComponentService promotedService = getPromotedComponentService(compositeService); + if (promotedService != null) { + Component promotedComponent = getPromotedComponent(compositeService); + + // Default to use the interface from the promoted service + if (compositeService.getInterfaceContract() == null && promotedService.getInterfaceContract() != null) { + compositeService.setInterfaceContract(promotedService.getInterfaceContract()); + } + + // Create a new component service to represent this composite + // service on the promoted component + ComponentService newComponentService = assemblyFactory.createComponentService(); + newComponentService.setName("$promoted$." + compositeService.getName()); + promotedComponent.getServices().add(newComponentService); + newComponentService.setService(promotedService.getService()); + newComponentService.getBindings().addAll(compositeService.getBindings()); + newComponentService.setInterfaceContract(compositeService.getInterfaceContract()); + if (compositeService.getInterfaceContract() != null && compositeService + .getInterfaceContract().getCallbackInterface() != null) { + newComponentService.setCallback(assemblyFactory.createCallback()); + if (compositeService.getCallback() != null) { + newComponentService.getCallback().getBindings().addAll(compositeService + .getCallback().getBindings()); + } + } + + // Change the composite service to now promote the newly + // created component service directly + compositeService.setPromotedComponent(promotedComponent); + compositeService.setPromotedService(newComponentService); + } + } + } + + /** + * Activate composite services in nested composites. + * + * @param composite + * @param problems + */ + public void activateNestedCompositeServices(Composite composite) { + + // Process nested composites recursively + for (Component component : composite.getComponents()) { + Implementation implementation = component.getImplementation(); + if (implementation instanceof Composite) { + + // First process nested composites + activateNestedCompositeServices((Composite)implementation); + + // Process the component services declared on components + // in this composite + for (ComponentService componentService : component.getServices()) { + Service implService = componentService.getService(); + if (implService != null && implService instanceof CompositeService) { + CompositeService compositeService = (CompositeService)implService; + + // Get the inner most promoted service + ComponentService promotedService = + getPromotedComponentService(compositeService); + if (promotedService != null) { + Component promotedComponent = getPromotedComponent(compositeService); + + // Default to use the interface from the promoted + // service + if (compositeService.getInterfaceContract() == null) { + compositeService.setInterfaceContract(promotedService + .getInterfaceContract()); + } + if (componentService.getInterfaceContract() == null) { + componentService.setInterfaceContract(promotedService + .getInterfaceContract()); + } + + // Create a new component service to represent this + // composite service on the promoted component + ComponentService newComponentService = + assemblyFactory.createComponentService(); + newComponentService.setName("$promoted$." + compositeService.getName()); + promotedComponent.getServices().add(newComponentService); + newComponentService.setService(promotedService.getService()); + newComponentService.getBindings() + .addAll(compositeService.getBindings()); + newComponentService.setInterfaceContract(compositeService + .getInterfaceContract()); + if (compositeService.getInterfaceContract() != null && compositeService + .getInterfaceContract().getCallbackInterface() != null) { + newComponentService.setCallback(assemblyFactory.createCallback()); + if (compositeService.getCallback() != null) { + newComponentService.getCallback().getBindings() + .addAll(compositeService.getCallback().getBindings()); + } + } + + // Change the composite service to now promote the + // newly created component service directly + compositeService.setPromotedComponent(promotedComponent); + compositeService.setPromotedService(newComponentService); + } + } + } + } + } + } + + /** + * @param composite + */ + private void configureSourcedProperties(Composite composite, List<ComponentProperty> propertySettings) { + // Resolve properties + Map<String, Property> compositeProperties = new HashMap<String, Property>(); + ComponentProperty componentProperty = null; + for (Property p : composite.getProperties()) { + componentProperty = getComponentPropertyByName(p.getName(), propertySettings); + if (componentProperty != null) { + compositeProperties.put(p.getName(), componentProperty); + } else { + compositeProperties.put(p.getName(), p); + } + } + + for (Component component : composite.getComponents()) { + try { + PropertyUtil.sourceComponentProperties(compositeProperties, component); + } catch (Exception e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } + Implementation impl = component.getImplementation(); + if (impl instanceof Composite) { + configureSourcedProperties((Composite)impl, component.getProperties()); + } + } + } + + /** + * Follow a service promotion chain down to the inner most (non composite) + * component service. + * + * @param topCompositeService + * @return + */ + static ComponentService getPromotedComponentService(CompositeService compositeService) { + ComponentService componentService = compositeService.getPromotedService(); + if (componentService != null) { + Service service = componentService.getService(); + if (componentService.getName() != null && service instanceof CompositeService) { + + // Continue to follow the service promotion chain + return getPromotedComponentService((CompositeService)service); + + } else { + + // Found a non-composite service + return componentService; + } + } else { + + // No promoted service + return null; + } + } + + /** + * Follow a service promotion chain down to the inner most (non composite) + * component. + * + * @param compositeService + * @return + */ + private static Component getPromotedComponent(CompositeService compositeService) { + ComponentService componentService = compositeService.getPromotedService(); + if (componentService != null) { + Service service = componentService.getService(); + if (componentService.getName() != null && service instanceof CompositeService) { + + // Continue to follow the service promotion chain + return getPromotedComponent((CompositeService)service); + + } else { + + // Found a non-composite service + return compositeService.getPromotedComponent(); + } + } else { + + // No promoted service + return null; + } + } + + private ComponentProperty getComponentPropertyByName(String propertyName, List<ComponentProperty> properties) { + if (properties != null) { + for (ComponentProperty aProperty : properties) { + if (aProperty.getName().equals(propertyName)) { + return aProperty; + } + } + } + return null; + } + + private SCABinding createSCABinding() { + SCABinding scaBinding = scaBindingFactory.createSCABinding(); + IntentAttachPointType bindingType = intentAttachPointTypeFactory.createBindingType(); + bindingType.setName(BINDING_SCA_QNAME); + bindingType.setUnresolved(true); + ((PolicySetAttachPoint)scaBinding).setType(bindingType); + + return scaBinding; + } + + /** + * Fully resolve the binding URIs based on available information. This includes information + * from the ".composite" files, from resources associated with the binding, e.g. WSDL files, + * from any associated policies and from the default information for each binding type. + * + * TODO: Share the URL calculation algorithm with the configureComponents() method above + * although keeping the configureComponents() methods signature as is because when + * a composite is actually build in a node the node default information is currently + * available + * + * @param composite the composite to be configured + * @param uri the path to the composite provided through any nested composite component implementations + * @param defaultBindings list of default binding configurations + */ + public void configureBindingURIs(Composite composite, String uri, List<Binding> defaultBindings) throws CompositeBuilderException { + + String parentComponentURI = uri; + + // Process nested composites recursively + for (Component component : composite.getComponents()) { + + // Initialize component URI + String componentURI; + if (parentComponentURI == null) { + componentURI = component.getName(); + } else { + componentURI = URI.create(parentComponentURI + '/').resolve(component.getName()).toString(); + } + component.setURI(componentURI); + + Implementation implementation = component.getImplementation(); + if (implementation instanceof Composite) { + + // Process nested composite + configureBindingURIs((Composite)implementation, componentURI, defaultBindings); + } + } + + // Initialize composite service binding URIs + List<Service> compositeServices = composite.getServices(); + for (Service service : compositeServices) { + // Set default binding names + + // Create default SCA binding + if (service.getBindings().isEmpty()) { + SCABinding scaBinding = createSCABinding(); + service.getBindings().add(scaBinding); + } + + // Initialize binding names and URIs + for (Binding binding : service.getBindings()) { + constructBindingName(service, binding); + constructBindingURI(parentComponentURI, composite, service, binding, defaultBindings); + } + } + + // Initialize component service binding URIs + for (Component component : composite.getComponents()) { + + // Index properties, services and references + Map<String, Service> services = new HashMap<String, Service>(); + Map<String, Reference> references = new HashMap<String, Reference>(); + Map<String, Property> properties = new HashMap<String, Property>(); + indexImplementationPropertiesServicesAndReferences(component, + services, + references, + properties); + + // Index component services, references and properties + // Also check for duplicates + Map<String, ComponentService> componentServices = + new HashMap<String, ComponentService>(); + Map<String, ComponentReference> componentReferences = + new HashMap<String, ComponentReference>(); + Map<String, ComponentProperty> componentProperties = + new HashMap<String, ComponentProperty>(); + indexComponentPropertiesServicesAndReferences(component, + componentServices, + componentReferences, + componentProperties); + + // Reconcile component services/references/properties and + // implementation services/references and create component + // services/references/properties for the services/references + // declared by the implementation + reconcileServices(component, services, componentServices); + reconcileReferences(component, references, componentReferences); + reconcileProperties(component, properties, componentProperties); + + for (ComponentService service : component.getServices()) { + + // Create default SCA binding + if (service.getBindings().isEmpty()) { + SCABinding scaBinding = createSCABinding(); + service.getBindings().add(scaBinding); + } + + // Initialize binding names and URIs + for (Binding binding : service.getBindings()) { + + constructBindingName(service, binding); + constructBindingURI(component, service, binding, defaultBindings); + } + } + } + } + + /** + * If a binding name is not provided by the user construct it based on the service name + * + * @param service + * @param binding + */ + private void constructBindingName(Service service, Binding binding) throws CompositeBuilderException{ + + // set the default binding name if one is required + // if there is no name on the binding then set it to the service name + if (binding.getName() == null){ + binding.setName(service.getName()); + } + + // Check that multiple bindings do not have the same name + for (Binding otherBinding : service.getBindings()) { + if (otherBinding == binding) { + // Skip the current binding + continue; + } + if (binding.getClass() != otherBinding.getClass()) { + // Look for a binding of the same type + continue; + } + if (binding.getName().equals(otherBinding.getName())) { + warning("Multiple bindings for service " + + service.getName() + + " have the same binding type and name " + + binding.getName() + + ". Tuscany SCA can't create unique URIs to differentiate these bindings ", binding); + } + } + } + + /** + * URI construction for composite bindings based on Assembly spec section 1.7.2, This method + * assumes that the component URI part of the binding URI is formed from the part to the + * composite in question and just calls the generic constructBindingURI method with this + * information + * + * @param parentComponentURI + * @param composite + * @param service + * @param binding + * @param defaultBindings + */ + private void constructBindingURI(String parentComponentURI, Composite composite, Service service, Binding binding, List<Binding> defaultBindings) + throws CompositeBuilderException{ + // This is a composite service so there is no component to provide a component URI + // The path to this composite (through nested composites) is used. + boolean includeBindingName = composite.getServices().size() != 1; + constructBindingURI(parentComponentURI, service, binding, includeBindingName, defaultBindings); + } + + /** + * URI construction for component bindings based on Assembly spec section 1.7.2. This method + * calculates the component URI part based on component information before calling the generic + * constructBindingURI method + * + * @param component the component that holds the service + * @param service the service that holds the binding + * @param binding the binding for which the URI is being constructed + * @param defaultBindings the list of default binding configurations + */ + private void constructBindingURI(Component component, Service service, Binding binding, List<Binding> defaultBindings) + throws CompositeBuilderException{ + boolean includeBindingName = component.getServices().size() != 1; + constructBindingURI(component.getURI(), service, binding, includeBindingName, defaultBindings); + } + + /** + * Generic URI construction for bindings based on Assembly spec section 1.7.2 + * + * @param componentURIString the string version of the URI part that comes from the component name + * @param service the service in question + * @param binding the binding for which the URI is being constructed + * @param includeBindingName when set true the serviceBindingURI part should be used + * @param defaultBindings the list of default binding configurations + * @throws CompositeBuilderException + */ + private void constructBindingURI(String componentURIString, Service service, Binding binding, boolean includeBindingName, List<Binding> defaultBindings) + throws CompositeBuilderException{ + + try { + // calculate the service binding URI + URI bindingURI; + if (binding.getURI() != null){ + bindingURI = new URI(binding.getURI()); + + // if the user has provided an absolute binding URI then use it + if (bindingURI.isAbsolute()){ + binding.setURI(bindingURI.toString()); + return; + } + } else { + bindingURI = null; + } + + // Get the service binding name + URI bindingName; + if (binding.getName() != null) { + bindingName = new URI(binding.getName()); + } else { + bindingName = new URI(""); + } + + // calculate the component URI + URI componentURI; + if (componentURIString != null) { + componentURI = new URI(addSlashToPath(componentURIString)); + } else { + componentURI = null; + } + + // if the user has provided an absolute component URI then use it + if (componentURI != null && componentURI.isAbsolute()){ + binding.setURI(constructBindingURI(null, componentURI, bindingURI, includeBindingName, bindingName)); + return; + } + + // calculate the base URI + + // get the protocol for this binding/URI +/* some code that allows binding specific code to run. Being discussed on ML + BindingURICalculator uriCalculator = bindingURICalcualtorExtensionPoint.getBindingURICalculator(binding); + + if (uriCalculator != null){ + String protocol = uriCalculator.getProtocol(binding); + + // find the default binding with the right protocol + Binding defaultBinding = nodeInfo.getBindingDefault(binding, protocol); + + if (defaultBinding != null){ + baseURI = new URI(defaultBinding.getURI()); + } else { + baseURI = null; + } + + } else { + baseURI = null; + } +*/ + // as a simpler alternative to the above commented out code. + URI baseURI = null; + if (defaultBindings != null) { + for (Binding defaultBinding : defaultBindings){ + if (binding.getClass() == defaultBinding.getClass()){ + baseURI = new URI(addSlashToPath(defaultBinding.getURI())); + break; + } + } + } + + binding.setURI(constructBindingURI(baseURI, componentURI, bindingURI, includeBindingName, bindingName)); + } catch (URISyntaxException ex) { + warning("URLSyntaxException when creating binding URI at component " + + componentURIString + + " service " + + service.getName() + + " binding " + + binding.getName(), + ex); + } + } + + /** + * Use to ensure that URI paths end in "/" as here we want to maintain the + * last path element of an base URI when other URI are resolved against it. This is + * not the default behaviour of URI resolution as defined in RFC 2369 + * + * @param path the path string to which the "/" is to be added + * @return the resulting path with a "/" added if it not already there + */ + private String addSlashToPath(String path){ + if (path.endsWith("/")){ + return path; + } else { + return path + "/"; + } + } + + /** + * Concatenate binding URI parts together based on Assembly spec section 1.7.2 + * + * @param baseURI the base of the binding URI + * @param componentURI the middle part of the binding uri derived from the component name + * @param bindingURI the end part of the binding uri + * @param includeBindingName when set true the binding name part should be used + * @param bindingName the binding name + * @return the resulting URI as a string + */ + private String constructBindingURI(URI baseURI, URI componentURI, URI bindingURI, boolean includeBindingName, URI bindingName){ + String uriString; + + if (baseURI == null) { + if (componentURI == null){ + if (bindingURI != null ) { + uriString = bindingURI.toString(); + } else { + uriString = bindingName.toString(); + } + } else { + if (bindingURI != null ) { + uriString = componentURI.resolve(bindingURI).toString(); + } else { + if (includeBindingName) { + uriString = componentURI.resolve(bindingName).toString(); + } else { + uriString = componentURI.toString(); + } + } + } + } else { + if (componentURI == null){ + if (bindingURI != null ) { + uriString = baseURI.resolve(bindingURI).toString(); + } else { + if (includeBindingName) { + uriString = baseURI.resolve(bindingName).toString(); + } else { + uriString = baseURI.toString(); + } + } + } else { + if (bindingURI != null ) { + uriString = baseURI.resolve(componentURI).resolve(bindingURI).toString(); + } else { + if (includeBindingName) { + uriString = baseURI.resolve(componentURI).resolve(bindingName).toString(); + } else { + uriString = baseURI.resolve(componentURI).toString(); + } + } + } + } + + // tidy up by removing any trailing "/" + if (uriString.endsWith("/")){ + uriString = uriString.substring(0, uriString.length()-1); + } + + URI uri = URI.create(uriString); + if (!uri.isAbsolute()) { + uri = URI.create("/").resolve(uri); + } + return uri.toString(); + } +} diff --git a/sca-java-1.x/tags/1.2/modules/assembly/src/main/java/org/apache/tuscany/sca/assembly/builder/impl/CompositeIncludeBuilderImpl.java b/sca-java-1.x/tags/1.2/modules/assembly/src/main/java/org/apache/tuscany/sca/assembly/builder/impl/CompositeIncludeBuilderImpl.java new file mode 100644 index 0000000000..ced482dbf6 --- /dev/null +++ b/sca-java-1.x/tags/1.2/modules/assembly/src/main/java/org/apache/tuscany/sca/assembly/builder/impl/CompositeIncludeBuilderImpl.java @@ -0,0 +1,81 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ + +package org.apache.tuscany.sca.assembly.builder.impl; + +import java.util.ArrayList; +import java.util.List; + +import org.apache.tuscany.sca.assembly.Composite; +import org.apache.tuscany.sca.assembly.builder.CompositeBuilderMonitor; +import org.apache.tuscany.sca.policy.PolicySetAttachPoint; + +public class CompositeIncludeBuilderImpl { + + public CompositeIncludeBuilderImpl(CompositeBuilderMonitor monitor) { + } + + /** + * Collect all includes in a graph of includes. + * + * @param composite + * @param includes + */ + private void collectIncludes(Composite composite, List<Composite> includes) { + for (Composite include : composite.getIncludes()) { + includes.add(include); + collectIncludes(include, includes); + } + } + + /** + * Copy a list of includes into a composite. + * + * @param composite + */ + public void fuseIncludes(Composite composite) { + + // First collect all includes + List<Composite> includes = new ArrayList<Composite>(); + collectIncludes(composite, includes); + + // Then clone them + for (Composite include : includes) { + Composite clone; + try { + clone = (Composite)include.clone(); + } catch (CloneNotSupportedException e) { + throw new RuntimeException(e); + } + composite.getComponents().addAll(clone.getComponents()); + composite.getServices().addAll(clone.getServices()); + composite.getReferences().addAll(clone.getReferences()); + composite.getProperties().addAll(clone.getProperties()); + composite.getWires().addAll(clone.getWires()); + if ( composite instanceof PolicySetAttachPoint ) { + ((PolicySetAttachPoint)composite).getPolicySets().addAll(((PolicySetAttachPoint)clone).getPolicySets()); + ((PolicySetAttachPoint)composite).getRequiredIntents().addAll(((PolicySetAttachPoint)clone).getRequiredIntents()); + } + } + + // Clear the list of includes + composite.getIncludes().clear(); + } + +} diff --git a/sca-java-1.x/tags/1.2/modules/assembly/src/main/java/org/apache/tuscany/sca/assembly/builder/impl/CompositeWireBuilderImpl.java b/sca-java-1.x/tags/1.2/modules/assembly/src/main/java/org/apache/tuscany/sca/assembly/builder/impl/CompositeWireBuilderImpl.java new file mode 100644 index 0000000000..2096bbd651 --- /dev/null +++ b/sca-java-1.x/tags/1.2/modules/assembly/src/main/java/org/apache/tuscany/sca/assembly/builder/impl/CompositeWireBuilderImpl.java @@ -0,0 +1,1021 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ + +package org.apache.tuscany.sca.assembly.builder.impl; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.HashSet; +import java.util.List; +import java.util.Map; +import java.util.Set; + +import org.apache.tuscany.sca.assembly.AssemblyFactory; +import org.apache.tuscany.sca.assembly.Binding; +import org.apache.tuscany.sca.assembly.Component; +import org.apache.tuscany.sca.assembly.ComponentReference; +import org.apache.tuscany.sca.assembly.ComponentService; +import org.apache.tuscany.sca.assembly.Composite; +import org.apache.tuscany.sca.assembly.CompositeReference; +import org.apache.tuscany.sca.assembly.CompositeService; +import org.apache.tuscany.sca.assembly.ConfiguredOperation; +import org.apache.tuscany.sca.assembly.Implementation; +import org.apache.tuscany.sca.assembly.Multiplicity; +import org.apache.tuscany.sca.assembly.OperationsConfigurator; +import org.apache.tuscany.sca.assembly.OptimizableBinding; +import org.apache.tuscany.sca.assembly.Reference; +import org.apache.tuscany.sca.assembly.SCABinding; +import org.apache.tuscany.sca.assembly.Service; +import org.apache.tuscany.sca.assembly.Wire; +import org.apache.tuscany.sca.assembly.builder.CompositeBuilderMonitor; +import org.apache.tuscany.sca.assembly.builder.Problem.Severity; +import org.apache.tuscany.sca.interfacedef.InterfaceContractMapper; +import org.apache.tuscany.sca.policy.PolicySet; +import org.apache.tuscany.sca.policy.util.PolicyComputationUtils; + +public class CompositeWireBuilderImpl { + + private CompositeBuilderMonitor monitor; + private AssemblyFactory assemblyFactory; + private InterfaceContractMapper interfaceContractMapper; + + private BindingPolicyComputer bindingPolicyComputer = null; + private ImplementationPolicyComputer implPolicyComputer = null; + + //Represents a target component and service + private class Target { + Component component; + ComponentService service; + + Target(Component component, ComponentService service) { + this.component = component; + this.service = service; + } + + Component getComponent() { + return component; + } + + ComponentService getService() { + return service; + } + }; + + public CompositeWireBuilderImpl(AssemblyFactory assemblyFactory, InterfaceContractMapper interfaceContractMapper, CompositeBuilderMonitor monitor) { + this.assemblyFactory = assemblyFactory; + this.interfaceContractMapper = interfaceContractMapper; + this.monitor = monitor; + + this.bindingPolicyComputer = new BindingPolicyComputer(); + this.implPolicyComputer = new ImplementationPolicyComputer(); + } + + /** + * Wire component references to component services and connect promoted + * services/references to component services/references inside a composite. + * + * @param composite + */ + public void wireComposite(Composite composite) { + + // Wire nested composites recursively + for (Component component : composite.getComponents()) { + Implementation implementation = component.getImplementation(); + if (implementation instanceof Composite) { + wireComposite((Composite)implementation); + } + } + + // Index components, services and references + Map<String, Component> components = new HashMap<String, Component>(); + Map<String, ComponentService> componentServices = new HashMap<String, ComponentService>(); + Map<String, ComponentReference> componentReferences = new HashMap<String, ComponentReference>(); + indexComponentsServicesAndReferences(composite, components, componentServices, componentReferences); + + // Connect composite services and references to the component + // services and references that they promote + connectCompositeServices(composite, components, componentServices); + connectCompositeReferences(composite, componentReferences); + + // Compute the policies before connecting component references + computePolicies(composite); + + // Connect component references as described in wires + connectWires(composite, componentServices, componentReferences); + + // Connect component references to their targets + connectComponentReferences(composite, components, componentServices, componentReferences); + + // Validate that references are wired or promoted, according + // to their multiplicity + for (ComponentReference componentReference : componentReferences.values()) { + if (!ReferenceUtil.validateMultiplicityAndTargets(componentReference.getMultiplicity(), componentReference + .getTargets(), componentReference.getBindings())) { + if (componentReference.getTargets().isEmpty()) { + + // No warning if the reference is promoted out of the current composite + boolean promoted = false; + for (Reference reference : composite.getReferences()) { + CompositeReference compositeReference = (CompositeReference)reference; + if (compositeReference.getPromotedReferences().contains(componentReference)) { + promoted = true; + break; + } + } + if (!promoted && !componentReference.isCallback()) { + warning("No targets for reference: " + componentReference.getName(), composite); + } + } else { + warning("Too many targets on reference: " + componentReference.getName(), composite); + } + } + } + } + + /** + * Index components, services and references inside a composite. + * @param composite + * @param components + * @param componentServices + * @param componentReferences + */ + private void indexComponentsServicesAndReferences(Composite composite, + Map<String, Component> components, + Map<String, ComponentService> componentServices, + Map<String, ComponentReference> componentReferences) { + + for (Component component : composite.getComponents()) { + + // Index components by name + components.put(component.getName(), component); + + ComponentService nonCallbackService = null; + int nonCallbackServices = 0; + for (ComponentService componentService : component.getServices()) { + + // Index component services by component name / service name + String uri = component.getName() + '/' + componentService.getName(); + componentServices.put(uri, componentService); + if (!componentService.isCallback()) { + + // Check how many non callback services we have + if (nonCallbackServices == 0) { + nonCallbackService = componentService; + } + nonCallbackServices++; + } + } + if (nonCallbackServices == 1) { + // If we have a single non callback service, index it by + // component name as well + componentServices.put(component.getName(), nonCallbackService); + } + + // Index references by component name / reference name + for (ComponentReference componentReference : component.getReferences()) { + String uri = component.getName() + '/' + componentReference.getName(); + componentReferences.put(uri, componentReference); + } + } + } + + /** + * Report a warning. + * + * @param problems + * @param message + * @param model + */ + private void warning(String message, Object model) { + monitor.problem(new ProblemImpl(Severity.WARNING, message, model)); + } + + /** + * Connect composite services to the component services that they promote. + * + * @param composite + * @param componentServices + * @param problems + */ + private void connectCompositeServices(Composite composite, + Map<String, Component> components, + Map<String, ComponentService> componentServices) { + + // Propagate interfaces from inner composite components' services to + // their component services + for (Component component : composite.getComponents()) { + if (component.getImplementation() instanceof Composite) { + for (ComponentService componentService : component.getServices()) { + Service service = componentService.getService(); + if (service != null) { + if (componentService.getInterfaceContract() == null) { + componentService.setInterfaceContract(service.getInterfaceContract()); + } + } + } + } + } + + // Connect composite services to the component services that they + // promote + for (Service service : composite.getServices()) { + CompositeService compositeService = (CompositeService)service; + ComponentService componentService = compositeService.getPromotedService(); + if (componentService != null && componentService.isUnresolved()) { + + String promotedComponentName = compositeService.getPromotedComponent().getName(); + String promotedServiceName; + if (componentService.getName() != null) { + promotedServiceName = promotedComponentName + '/' + componentService.getName(); + } else { + promotedServiceName = promotedComponentName; + } + ComponentService promotedService = componentServices.get(promotedServiceName); + if (promotedService != null) { + + // Point to the resolved component + Component promotedComponent = components.get(promotedComponentName); + compositeService.setPromotedComponent(promotedComponent); + + // Point to the resolved component service + compositeService.setPromotedService(promotedService); + + // Use the interface contract from the component service if + // none is specified on the composite service + if (compositeService.getInterfaceContract() == null) { + compositeService.setInterfaceContract(promotedService.getInterfaceContract()); + } + + } else { + warning("Promoted component service not found: " + promotedServiceName, composite); + } + } + } + + } + + /** + * Resolves promoted references. + * + * @param composite + * @param componentReferences + * @param problems + */ + private void connectCompositeReferences(Composite composite, Map<String, ComponentReference> componentReferences) { + + // Propagate interfaces from inner composite components' references to + // their component references + for (Component component : composite.getComponents()) { + if (component.getImplementation() instanceof Composite) { + for (ComponentReference componentReference : component.getReferences()) { + Reference reference = componentReference.getReference(); + if (reference != null) { + if (componentReference.getInterfaceContract() == null) { + componentReference.setInterfaceContract(reference.getInterfaceContract()); + } + } + } + } + } + + // Connect composite references to the component references + // that they promote + for (Reference reference : composite.getReferences()) { + CompositeReference compositeReference = (CompositeReference)reference; + List<ComponentReference> promotedReferences = compositeReference.getPromotedReferences(); + for (int i = 0, n = promotedReferences.size(); i < n; i++) { + ComponentReference componentReference = promotedReferences.get(i); + if (componentReference.isUnresolved()) { + String componentReferenceName = componentReference.getName(); + componentReference = componentReferences.get(componentReferenceName); + if (componentReference != null) { + + // Point to the resolved component reference + promotedReferences.set(i, componentReference); + + // Use the interface contract from the component + // reference if none + // is specified on the composite reference + if (compositeReference.getInterfaceContract() == null) { + compositeReference.setInterfaceContract(componentReference.getInterfaceContract()); + } + + } else { + warning("Promoted component reference not found: " + componentReferenceName, composite); + } + } + } + } + } + + private List<Target> createComponentReferenceTargets(Composite composite, + Map<String, Component> components, + Map<String, ComponentService> componentServices, + ComponentReference componentReference) { + List<Target> targets = new ArrayList<Target>(); + + if (componentReference.getAutowire() == Boolean.TRUE) { + + // Find suitable targets in the current composite for an + // autowired reference + Multiplicity multiplicity = componentReference.getMultiplicity(); + for (Component targetComponent : composite.getComponents()) { + for (ComponentService targetComponentService : targetComponent.getServices()) { + if (componentReference.getInterfaceContract() == null || + interfaceContractMapper.isCompatible(componentReference.getInterfaceContract(), targetComponentService.getInterfaceContract())) { + Target target = new Target(targetComponent, targetComponentService); + targets.add(target); + if (multiplicity == Multiplicity.ZERO_ONE || multiplicity == Multiplicity.ONE_ONE) { + break; + } + } + } + } + + if (multiplicity == Multiplicity.ONE_N || multiplicity == Multiplicity.ONE_ONE) { + if (targets.size() == 0) { + warning("No target services found for the component reference to be autowired: " + componentReference + .getName(), + componentReference); + } + } + + } else if (!componentReference.getTargets().isEmpty()) { + + // Resolve targets specified on the component reference + for (ComponentService componentService : componentReference.getTargets()) { + + // Resolve the target component and service + String name = componentService.getName(); + ComponentService targetComponentService = componentServices.get(name); + Component targetComponent; + int s = name.indexOf('/'); + if (s == -1) { + targetComponent = components.get(name); + } else { + targetComponent = components.get(name.substring(0, s)); + } + + if (targetComponentService != null) { + + // Check that the target component service provides + // a superset of the component reference interface + if (componentReference.getInterfaceContract() == null || + interfaceContractMapper.isCompatible(componentReference.getInterfaceContract(), targetComponentService.getInterfaceContract())) { + + Target target = new Target(targetComponent, targetComponentService); + targets.add(target); + + // mark the reference target as resolved. Used later when we are looking to + // see if an sca binding is associated with a resolved target or not + componentService.setUnresolved(false); + } else { + warning("Incompatible interfaces on component reference and target: " + componentReference + .getName() + + " : " + + componentService.getName(), + composite); + } + } else { + // add all the reference bindings into the target so that they + // can be used for comparison when the target is resolved at runtime + componentService.getBindings().addAll(componentReference.getBindings()); + + // The bindings will be cloned back into the reference when the + // target is finally resolved. + + warning("Component reference target not found, it might be a remote service: " + componentService.getName(), composite); + } + } + } else if (componentReference.getReference() != null) { + + // Resolve targets from the corresponding reference in the + // componentType + for (ComponentService componentService : componentReference.getReference().getTargets()) { + + // Resolve the target component and service + String name = componentService.getName(); + ComponentService targetComponentService = componentServices.get(name); + Component targetComponent; + int s = name.indexOf('/'); + if (s == -1) { + targetComponent = components.get(name); + } else { + targetComponent = components.get(name.substring(0, s)); + } + + if (targetComponentService != null) { + + // Check that the target component service provides + // a superset of + // the component reference interface + if (componentReference.getInterfaceContract() == null || + interfaceContractMapper.isCompatible(componentReference.getInterfaceContract(), targetComponentService.getInterfaceContract())) { + + Target target = new Target(targetComponent, targetComponentService); + targets.add(target); + + // mark the reference target as resolved. Used later when we are looking to + // see if an sca binding is associated with a resolved target or not + componentService.setUnresolved(false); + } else { + warning("Incompatible interfaces on component reference and target: " + componentReference + .getName() + + " : " + + componentService.getName(), + composite); + } + } else { + // add all the reference bindings into the target so that they + // can be used for comparison when the target is resolved at runtime + componentService.getBindings().addAll(componentReference.getBindings()); + + // The bindings will be cloned back into the reference when the + // target is finally resolved. + + warning("Component reference target from component type not found, it might be a remote service: " + componentService.getName(), composite); + } + } + } + return targets; + } + + + /** + * Connect references to their targets. + * + * @param composite + * @param componentServices + * @param componentReferences + * @param problems + */ + private void connectComponentReferences(Composite composite, + Map<String, Component> components, + Map<String, ComponentService> componentServices, + Map<String, ComponentReference> componentReferences) { + for (ComponentReference componentReference : componentReferences.values()) { + + List<Target> targets = createComponentReferenceTargets(composite, + components, + componentServices, + componentReference); + + // Select the reference bindings matching the target service bindings + List<Binding> selectedBindings = new ArrayList<Binding>(); + + // Handle callback + boolean bidirectional = false; + if (componentReference.getInterfaceContract() != null && componentReference.getInterfaceContract().getCallbackInterface() != null) { + bidirectional = true; + } + List<Binding> selectedCallbackBindings = bidirectional ? new ArrayList<Binding>() : null; + + for (Target target : targets) { + + Component targetComponent = target.getComponent(); + ComponentService targetComponentService = target.getService(); + if (targetComponentService.getService() instanceof CompositeService) { + CompositeService compositeService = (CompositeService) targetComponentService.getService(); + // Find the promoted component service + targetComponentService = CompositeConfigurationBuilderImpl.getPromotedComponentService(compositeService); + } + + try { + bindingPolicyComputer.determineApplicableBindingPolicySets(componentReference, targetComponentService); + } catch ( Exception e ) { + warning("Policy related exception: " + e, e); + //throw new RuntimeException(e); + } + + // Match the binding against the bindings of the target service + Binding selected = BindingUtil.resolveBindings(componentReference, targetComponent, targetComponentService); + if (selected == null) { + warning("Component reference doesn't have a matching binding", componentReference); + } else { + selectedBindings.add(selected); + } + if (bidirectional) { + Binding selectedCallback = BindingUtil.resolveCallbackBindings(componentReference, targetComponent, targetComponentService); + if (selectedCallback != null) { + selectedCallbackBindings.add(selectedCallback); + } + } + } + + if (!targets.isEmpty()) { + + // Add all the effective bindings + componentReference.getBindings().clear(); + componentReference.getBindings().addAll(selectedBindings); + if (bidirectional) { + componentReference.getCallback().getBindings().clear(); + componentReference.getCallback().getBindings().addAll(selectedCallbackBindings); + } + } + + // Need to tidy up the reference binding list. The situation so far... + // Wired reference (1 or more targets are specified) + // Binding.uri = null - remove as its left over from target resolution + // the binding will have been moved to the target from where + // it will be resolved later + // Binding.uri != null - the reference was resolved + // Unwired reference (0 targets) + // Binding.uri = null - Either a callback reference or the reference is yet to be wired + // either manually or via autowire so leave the binding where it is + // Binding.uri != null - from the composite file so leave it + if (componentReference.getTargets().size() > 0){ + List<Binding> bindingsToRemove = new ArrayList<Binding>(); + for(Binding binding : componentReference.getBindings()){ + if(binding.getURI() == null){ + bindingsToRemove.add(binding); + } + } + + componentReference.getBindings().removeAll(bindingsToRemove); + } + } + } + + /** + * Resolve wires and connect the sources to their targets + * + * @param composite + * @param componentServices + * @param componentReferences + * @param problems + */ + private void connectWires(Composite composite, + Map<String, ComponentService> componentServices, + Map<String, ComponentReference> componentReferences) { + + // For each wire, resolve the source reference, the target service, and + // add it to the list of targets of the reference + List<Wire> wires = composite.getWires(); + for (int i = 0, n = wires.size(); i < n; i++) { + Wire wire = wires.get(i); + + ComponentReference resolvedReference; + ComponentService resolvedService; + + // Resolve the source reference + ComponentReference source = wire.getSource(); + if (source != null && source.isUnresolved()) { + resolvedReference = componentReferences.get(source.getName()); + if (resolvedReference != null) { + wire.setSource(resolvedReference); + } else { + warning("Wire source not found: " + source.getName(), composite); + } + } else { + resolvedReference = wire.getSource(); + } + + // Resolve the target service + ComponentService target = wire.getTarget(); + if (target != null && target.isUnresolved()) { + resolvedService = componentServices.get(target.getName()); + if (resolvedService != null) { + wire.setTarget(target); + } else { + warning("Wire target not found: " + source.getName(), composite); + } + } else { + resolvedService = wire.getTarget(); + } + + // Add the target service to the list of targets of the + // reference + if (resolvedReference != null && resolvedService != null) { + // Check that the target component service provides + // a superset of + // the component reference interface + if (resolvedReference.getInterfaceContract() == null || interfaceContractMapper + .isCompatible(resolvedReference.getInterfaceContract(), resolvedService.getInterfaceContract())) { + + //resolvedReference.getTargets().add(resolvedService); + resolvedReference.getTargets().add(wire.getTarget()); + } else { + warning("Incompatible interfaces on wire source and target: " + source.getName() + + " : " + + target.getName(), composite); + } + } + } + + // Clear the list of wires + composite.getWires().clear(); + } + + /** + * Wire composite references in nested composites. + * + * @param composite + * @param problems + */ + public void wireCompositeReferences(Composite composite) { + + // Process nested composites recursively + for (Component component : composite.getComponents()) { + Implementation implementation = component.getImplementation(); + if (implementation instanceof Composite) { + wireCompositeReferences((Composite)implementation); + } + } + + // Process composite references declared in this composite + for (Reference reference : composite.getReferences()) { + CompositeReference compositeReference = (CompositeReference)reference; + List<ComponentReference> promotedReferences = getPromotedComponentReferences(compositeReference); + for (ComponentReference promotedReference : promotedReferences) { + + reconcileReferenceBindings(compositeReference, promotedReference); + if (compositeReference.getInterfaceContract() != null && // can be null in unit tests + compositeReference.getInterfaceContract().getCallbackInterface() != null) { + SCABinding scaCallbackBinding = promotedReference.getCallbackBinding(SCABinding.class); + if (promotedReference.getCallback() != null) { + promotedReference.getCallback().getBindings().clear(); + } else { + promotedReference.setCallback(assemblyFactory.createCallback()); + } + if (scaCallbackBinding != null) { + promotedReference.getCallback().getBindings().add(scaCallbackBinding); + } + if (compositeReference.getCallback() != null) { + promotedReference.getCallback().getBindings().addAll(compositeReference.getCallback() + .getBindings()); + } + } + } + } + + // Process the component references declared on components + // in this composite + for (Component component : composite.getComponents()) { + Implementation implementation = component.getImplementation(); + if (implementation instanceof Composite) { + for (ComponentReference componentReference : component.getReferences()) { + Reference implReference = componentReference.getReference(); + if (implReference != null && implReference instanceof CompositeReference) { + CompositeReference compositeReference = (CompositeReference)implReference; + List<ComponentReference> promotedReferences = + getPromotedComponentReferences(compositeReference); + for (ComponentReference promotedReference : promotedReferences) { + + // Override the configuration of the promoted reference + reconcileReferenceBindings(componentReference, promotedReference); + if (componentReference.getInterfaceContract() != null && // can be null in unit tests + componentReference.getInterfaceContract().getCallbackInterface() != null) { + SCABinding scaCallbackBinding = promotedReference.getCallbackBinding(SCABinding.class); + if (promotedReference.getCallback() != null) { + promotedReference.getCallback().getBindings().clear(); + } else { + promotedReference.setCallback(assemblyFactory.createCallback()); + } + if (scaCallbackBinding != null) { + promotedReference.getCallback().getBindings().add(scaCallbackBinding); + } + if (componentReference.getCallback() != null) { + promotedReference.getCallback().getBindings().addAll(componentReference + .getCallback().getBindings()); + } + } + + // Wire the promoted reference to the actual + // non-composite component services + if (promotedReference.getMultiplicity() == Multiplicity.ONE_ONE || promotedReference + .getMultiplicity() == Multiplicity.ONE_ONE) { + // promotedReference.getTargets().clear(); + } + for (ComponentService target : componentReference.getTargets()) { + if (target.getService() instanceof CompositeService) { + + // Wire to the actual component service + // promoted by a composite service + CompositeService compositeService = (CompositeService)target.getService(); + // Find the promoted component service + ComponentService componentService = CompositeConfigurationBuilderImpl.getPromotedComponentService(compositeService); + if (componentService != null) { + promotedReference.getTargets().add(componentService); + } + } else { + + // Wire to a non-composite target service + promotedReference.getTargets().add(target); + } + } + } + } + } + } else { + for (ComponentReference componentReference : component.getReferences()) { + + // Wire the component reference to the actual + // non-composite component services + List<ComponentService> targets = componentReference.getTargets(); + for (int i = 0, n = targets.size(); i < n; i++) { + ComponentService target = targets.get(i); + if (target.getService() instanceof CompositeService) { + + // Wire to the actual component service + // promoted by a composite service + CompositeService compositeService = (CompositeService)target.getService(); + ComponentService componentService = compositeService.getPromotedService(); + if (componentService != null) { + targets.set(i, componentService); + } + } + } + } + } + } + } + + /** + * Follow a reference promotion chain down to the inner most (non composite) + * component references. + * + * @param compositeReference + * @return + */ + private List<ComponentReference> getPromotedComponentReferences(CompositeReference compositeReference) { + List<ComponentReference> componentReferences = new ArrayList<ComponentReference>(); + collectPromotedComponentReferences(compositeReference, componentReferences); + return componentReferences; + } + + /** + * Follow a reference promotion chain down to the inner most (non composite) + * component references. + * + * @param compositeReference + * @param componentReferences + * @return + */ + private void collectPromotedComponentReferences(CompositeReference compositeReference, + List<ComponentReference> componentReferences) { + for (ComponentReference componentReference : compositeReference.getPromotedReferences()) { + Reference reference = componentReference.getReference(); + if (reference instanceof CompositeReference) { + + // Continue to follow the reference promotion chain + collectPromotedComponentReferences((CompositeReference)reference, componentReferences); + + } else if (reference != null) { + + // Found a non-composite reference + componentReferences.add(componentReference); + } + } + } + + /** + * Override the bindings for a promoted reference from an outer component + * reference + * + * @param reference + * @param promotedReference + */ + private void reconcileReferenceBindings(Reference reference, ComponentReference promotedReference) { + Set<Binding> bindings = new HashSet<Binding>(); + bindings.addAll(promotedReference.getBindings()); + bindings.addAll(reference.getBindings()); + promotedReference.getBindings().clear(); + for (Binding binding : bindings) { + if ((!(binding instanceof OptimizableBinding)) || binding.getURI() != null) { + promotedReference.getBindings().add(binding); + } + } + if (promotedReference.getMultiplicity() == Multiplicity.ONE_ONE || promotedReference.getMultiplicity() == Multiplicity.ZERO_ONE) { + if (promotedReference.getBindings().size() > 1) { + warning("Component reference " + promotedReference.getName() + " has more than one wires", + promotedReference); + } + } + Set<Binding> callbackBindings = new HashSet<Binding>(); + if (promotedReference.getCallback() != null) { + callbackBindings.addAll(promotedReference.getCallback().getBindings()); + } + if (reference.getCallback() != null) { + callbackBindings.addAll(reference.getCallback().getBindings()); + } + promotedReference.setCallback(assemblyFactory.createCallback()); + for (Binding binding : callbackBindings) { + if ((!(binding instanceof OptimizableBinding)) || binding.getURI() != null) { + promotedReference.getCallback().getBindings().add(binding); + } + } + } + + private void addPoliciesFromPromotedService(CompositeService compositeService) { + //inherit intents and policies from promoted service + PolicyComputationUtils.addInheritedIntents(compositeService.getPromotedService().getRequiredIntents(), + compositeService.getRequiredIntents()); + PolicyComputationUtils.addInheritedPolicySets(compositeService.getPromotedService().getPolicySets(), + compositeService.getPolicySets(), true); + addInheritedOperationConfigurations(compositeService.getPromotedService(), compositeService); + } + + private void addPoliciesFromPromotedReference(CompositeReference compositeReference) { + for ( Reference promotedReference : compositeReference.getPromotedReferences() ) { + PolicyComputationUtils.addInheritedIntents(promotedReference.getRequiredIntents(), + compositeReference.getRequiredIntents()); + + PolicyComputationUtils.addInheritedPolicySets(promotedReference.getPolicySets(), + compositeReference.getPolicySets(), true); + addInheritedOperationConfigurations(promotedReference, compositeReference); + } + } + + + public void computePolicies(Composite composite) { + + //compute policies for composite service bindings + for (Service service : composite.getServices()) { + addPoliciesFromPromotedService((CompositeService)service); + try { + //compute the intents for operations under service element + bindingPolicyComputer.computeIntentsForOperations(service); + //add or merge service operations to the binding + //addInheritedOpConfOnBindings(service); + bindingPolicyComputer.computeBindingIntentsAndPolicySets(service); + bindingPolicyComputer.determineApplicableBindingPolicySets(service, null); + } catch ( Exception e ) { + warning("Policy related exception: " + e, e); + //throw new RuntimeException(e); + } + + } + + for (Reference reference : composite.getReferences()) { + CompositeReference compReference = (CompositeReference)reference; + addPoliciesFromPromotedReference(compReference); + try { + //compute the intents for operations under service element + bindingPolicyComputer.computeIntentsForOperations(reference); + //addInheritedOpConfOnBindings(reference); + + if (compReference.getCallback() != null) { + PolicyComputationUtils.addInheritedIntents(compReference.getRequiredIntents(), + compReference.getCallback().getRequiredIntents()); + PolicyComputationUtils.addInheritedPolicySets(compReference.getPolicySets(), + compReference.getCallback().getPolicySets(), + false); + } + + bindingPolicyComputer.computeBindingIntentsAndPolicySets(reference); + bindingPolicyComputer.determineApplicableBindingPolicySets(reference, null); + } catch ( Exception e ) { + warning("Policy related exception: " + e, e); + //throw new RuntimeException(e); + } + } + + for (Component component : composite.getComponents()) { + Implementation implemenation = component.getImplementation(); + try { + implPolicyComputer.computeImplementationIntentsAndPolicySets(implemenation, component); + } catch ( Exception e ) { + warning("Policy related exception: " + e, e); + //throw new RuntimeException(e); + } + + for (ComponentService componentService : component.getServices()) { + Service service = componentService.getService(); + if (service != null) { + // reconcile intents and policysets from componentType + PolicyComputationUtils.addInheritedIntents(service.getRequiredIntents(), componentService.getRequiredIntents()); + PolicyComputationUtils.addInheritedPolicySets(service.getPolicySets(), componentService.getPolicySets(), true); + + //reconcile intents and policysets for operations + boolean notFound; + List<ConfiguredOperation> opsFromComponentType = new ArrayList<ConfiguredOperation>(); + for ( ConfiguredOperation ctsConfOp : service.getConfiguredOperations() ) { + notFound = true; + for ( ConfiguredOperation csConfOp : componentService.getConfiguredOperations() ) { + if ( csConfOp.getName().equals(ctsConfOp.getName()) ) { + PolicyComputationUtils.addInheritedIntents(ctsConfOp.getRequiredIntents(), csConfOp.getRequiredIntents()); + PolicyComputationUtils.addInheritedPolicySets(ctsConfOp.getPolicySets(), csConfOp.getPolicySets(), true); + notFound = false; + } + } + + if ( notFound ) { + opsFromComponentType.add(ctsConfOp); + } + } + componentService.getConfiguredOperations().addAll(opsFromComponentType); + } + + if ( componentService.getCallback() != null ) { + PolicyComputationUtils.addInheritedIntents(componentService.getRequiredIntents(), + componentService.getCallback().getRequiredIntents()); + PolicyComputationUtils.addInheritedPolicySets(componentService.getPolicySets(), + componentService.getCallback().getPolicySets(), + false); + } + + try { + //compute the intents for operations under service element + bindingPolicyComputer.computeIntentsForOperations(componentService); + //compute intents and policyset for each binding + //addInheritedOpConfOnBindings(componentService); + bindingPolicyComputer.computeBindingIntentsAndPolicySets(componentService); + bindingPolicyComputer.determineApplicableBindingPolicySets(componentService, null); + + if ( componentService.getCallback() != null ) { + PolicyComputationUtils.addInheritedIntents(componentService.getRequiredIntents(), + componentService.getCallback().getRequiredIntents()); + PolicyComputationUtils.addInheritedPolicySets(componentService.getPolicySets(), + componentService.getCallback().getPolicySets(), + false); + } + } catch ( Exception e ) { + warning("Policy related exception: " + e, e); + //throw new RuntimeException(e); + } + } + + for (ComponentReference componentReference : component.getReferences()) { + Reference reference = componentReference.getReference(); + if (reference != null) { + // reconcile intents and policysets + PolicyComputationUtils.addInheritedIntents(reference.getRequiredIntents(), componentReference.getRequiredIntents()); + PolicyComputationUtils.addInheritedPolicySets(reference.getPolicySets(), componentReference.getPolicySets(), true); + } + + if ( componentReference.getCallback() != null ) { + PolicyComputationUtils.addInheritedIntents(componentReference.getRequiredIntents(), + componentReference.getCallback().getRequiredIntents()); + PolicyComputationUtils.addInheritedPolicySets(componentReference.getPolicySets(), + componentReference.getCallback().getPolicySets(), + false); + } + + try { + //compute the intents for operations under reference element + bindingPolicyComputer.computeIntentsForOperations(componentReference); + //compute intents and policyset for each binding + //addInheritedOpConfOnBindings(componentReference); + bindingPolicyComputer.computeBindingIntentsAndPolicySets(componentReference); + bindingPolicyComputer.determineApplicableBindingPolicySets(componentReference, null); + + + if ( componentReference.getCallback() != null ) { + PolicyComputationUtils.addInheritedIntents(componentReference.getRequiredIntents(), + componentReference.getCallback().getRequiredIntents()); + PolicyComputationUtils.addInheritedPolicySets(componentReference.getPolicySets(), + componentReference.getCallback().getPolicySets(), + false); + } + } catch ( Exception e ) { + warning("Policy related exception: " + e, e); + //throw new RuntimeException(e); + } + } + } + } + + private void addInheritedOperationConfigurations(OperationsConfigurator source, + OperationsConfigurator target) { + boolean found = false; + + List<ConfiguredOperation> additionalOperations = new ArrayList<ConfiguredOperation>(); + for ( ConfiguredOperation sourceConfOp : source.getConfiguredOperations() ) { + for ( ConfiguredOperation targetConfOp : target.getConfiguredOperations() ) { + if ( sourceConfOp.getName().equals(targetConfOp.getName())) { + PolicyComputationUtils.addInheritedIntents(sourceConfOp.getRequiredIntents(), + targetConfOp.getRequiredIntents()); + PolicyComputationUtils.addInheritedPolicySets(sourceConfOp.getPolicySets(), + targetConfOp.getPolicySets(), true); + found = true; + break; + } + } + + if ( !found ) { + additionalOperations.add(sourceConfOp); + } + } + + if ( !additionalOperations.isEmpty() ) { + target.getConfiguredOperations().addAll(additionalOperations); + } + } + +} diff --git a/sca-java-1.x/tags/1.2/modules/assembly/src/main/java/org/apache/tuscany/sca/assembly/builder/impl/DomainWireBuilderImpl.java b/sca-java-1.x/tags/1.2/modules/assembly/src/main/java/org/apache/tuscany/sca/assembly/builder/impl/DomainWireBuilderImpl.java new file mode 100644 index 0000000000..07e26d0fc6 --- /dev/null +++ b/sca-java-1.x/tags/1.2/modules/assembly/src/main/java/org/apache/tuscany/sca/assembly/builder/impl/DomainWireBuilderImpl.java @@ -0,0 +1,290 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ + +package org.apache.tuscany.sca.assembly.builder.impl; + +import java.util.ArrayList; +import java.util.List; + +import org.apache.tuscany.sca.assembly.AssemblyFactory; +import org.apache.tuscany.sca.assembly.Binding; +import org.apache.tuscany.sca.assembly.Component; +import org.apache.tuscany.sca.assembly.ComponentReference; +import org.apache.tuscany.sca.assembly.ComponentService; +import org.apache.tuscany.sca.assembly.Composite; +import org.apache.tuscany.sca.assembly.Reference; +import org.apache.tuscany.sca.assembly.SCABindingFactory; +import org.apache.tuscany.sca.assembly.Service; +import org.apache.tuscany.sca.assembly.builder.CompositeBuilderMonitor; +import org.apache.tuscany.sca.assembly.builder.DomainBuilder; +import org.apache.tuscany.sca.interfacedef.InterfaceContractMapper; +import org.apache.tuscany.sca.policy.IntentAttachPointTypeFactory; +import org.apache.tuscany.sca.policy.PolicySet; + +public class DomainWireBuilderImpl implements DomainBuilder { + + private CompositeWireBuilderImpl wireBuilder; + + public DomainWireBuilderImpl(AssemblyFactory assemblyFactory, + SCABindingFactory scaBindingFactory, + IntentAttachPointTypeFactory intentAttachPointTypeFactory, + InterfaceContractMapper interfaceContractMapper, + CompositeBuilderMonitor monitor) { + wireBuilder = new CompositeWireBuilderImpl(assemblyFactory, interfaceContractMapper, monitor); + } + + public String getComponentNameFromReference(String referenceName){ + // Extract the component name + String componentName = referenceName; + int i = referenceName.indexOf('/'); + if (i != -1) { + componentName = referenceName.substring(0, i); + } + + return componentName; + } + + public String getServiceNameFromReference(String referenceName){ + // Extract the component name + String serviceName = null; + int i = referenceName.indexOf('/'); + if (i != -1) { + serviceName = referenceName.substring(i + 1); + + } + return serviceName; + } + + + public List<Reference> findReferenceForService(Composite composite, String serviceName){ + + List<Reference> referenceList = new ArrayList<Reference>(); + + String componentName = getComponentNameFromReference(serviceName); + + for (Reference reference: composite.getReferences()) { + for (ComponentService componentService : reference.getTargets()){ + if (componentService.getName().equals(serviceName) || + componentService.getName().equals(componentName)) { + referenceList.add(reference); + } + } + } + + for (Component component: composite.getComponents()) { + for (ComponentReference reference: component.getReferences()) { + for (ComponentService componentService : reference.getTargets()){ + if (componentService.getName().equals(serviceName) || + componentService.getName().equals(componentName)) { + referenceList.add(reference); + } + } + } + } + + return referenceList; + } + + public List<Reference> findDomainLevelReferenceForService(Composite composite, String referenceName){ + List<Reference> referenceList = new ArrayList<Reference>(); + + for (Composite tmpComposite : composite.getIncludes()) { + List<Reference> tmpReferenceList = findReferenceForService(tmpComposite, referenceName); + + referenceList.addAll(tmpReferenceList); + } + + return referenceList; + } + + public Service findServiceForReference(Composite composite, String referenceName){ + + String componentName = getComponentNameFromReference(referenceName); + String serviceName = getServiceNameFromReference(referenceName); + + for (Service service: composite.getServices()) { + if (service.getName().equals(serviceName)){ + return service; + } + } + + for (Component component: composite.getComponents()) { + if (component.getName().equals(componentName)){ + if (component.getServices().size() > 1) { + for (Service service: component.getServices()) { + if (service.getName().equals(serviceName)){ + return service; + } + } + } else if (component.getServices().size() == 1) { + return component.getServices().get(0); + } + } + } + + return null; + } + + public Service findDomainLevelService(Composite composite, String referenceName){ + Service service = null; + + for (Composite tmpComposite : composite.getIncludes()) { + service = findServiceForReference(tmpComposite, referenceName); + if (service != null) { + break; + } + } + + return service; + } + + public void updateDomainLevelServiceURI(Composite domainLevelComposite, String referenceName, String bindingClassName, String URI){ + + String componentName = getComponentNameFromReference(referenceName); + String serviceName = getServiceNameFromReference(referenceName); + + // get the named service + Service service = null; + for(Composite composite : domainLevelComposite.getIncludes()) { + service = findServiceForReference(composite, referenceName); + if (service != null){ + break; + } + } + + if (service != null) { + // find the named binding + for (Binding binding : service.getBindings()){ + if (binding.getClass().getName().equals(bindingClassName)){ + binding.setURI(URI); + break; + } + } + } + } + + public List<Composite> wireDomain(Composite domainLevelComposite){ + List<Composite> changedComposites = new ArrayList<Composite>(); + + // process wires + + // autowire + + // wire by impl? + + // process all wired references + for(Composite composite : domainLevelComposite.getIncludes()) { + boolean compositeChanged = false; + for(Component component : composite.getComponents()){ + for (Reference reference : component.getReferences()){ + for (ComponentService targetService : reference.getTargets()){ + String targetName = targetService.getName(); + String componentName = getComponentNameFromReference(targetName); + String serviceName = getServiceNameFromReference(targetName); + + Service service = null; + Component serviceComponent = null; + + // find the real target service in the domain + for(Composite tmpComposite : domainLevelComposite.getIncludes()) { + for (Component tmpComponent: tmpComposite.getComponents()) { + if (tmpComponent.getName().equals(componentName)){ + serviceComponent = tmpComponent; + if (tmpComponent.getServices().size() > 1) { + for (Service tmpService: tmpComponent.getServices()) { + if (tmpService.getName().equals(serviceName)){ + service = tmpService; + break; + } + } + } else if (tmpComponent.getServices().size() == 1) { + service = tmpComponent.getServices().get(0); + break; + } + } + } + } + + if ( targetService.isUnresolved()){ + + if (service != null){ + // Find the binding already in use for this target + Binding binding = null; + + for (Binding tmpBinding : reference.getBindings()){ + if ((tmpBinding.getName() != null) && + (tmpBinding.getName().startsWith(reference.getName() + "#" + targetName))){ + binding = tmpBinding; + } + } + + // Resolve the binding that should be used for this target + // TODO - hang onto the old bindings at the domain level, i.e. + // don't rely on the target objects as we still need the + // bindings if we are going to do autowiring + List<Binding> source = targetService.getBindings(); + List<Binding> target = service.getBindings(); + Binding newBinding = BindingUtil.matchBinding(serviceComponent, (ComponentService)service, source, target); + + // update the existing binding to the new binding if required + if (newBinding != null) { + if (binding != null){ + // there is a binding already so see if the URI has changed + if ((binding.getURI() == null) || + (!binding.getURI().equals(newBinding.getURI()))){ + binding.setURI(newBinding.getURI()); + compositeChanged = true; + } + } else { + // this is a newly configured binding so add it + reference.getBindings().add(newBinding); + compositeChanged = true; + } + } + } else { + // Do nothing - the target service hasn't been contributed yet + } + } else { + // find the reference binding with the right name + for (Binding refBinding : reference.getBindings()){ + if ((refBinding.getName() != null) && + (refBinding.getName().startsWith(reference.getName() + "#" + targetName))){ + // find the matching service binding + for (Binding serviceBinding : service.getBindings()){ + if (refBinding.getClass() == serviceBinding.getClass()){ + refBinding.setURI(serviceBinding.getURI()); + } + } + } + } + } + } + } + } + + if (compositeChanged) { + changedComposites.add(composite); + } + } + + return changedComposites; + } + + +} diff --git a/sca-java-1.x/tags/1.2/modules/assembly/src/main/java/org/apache/tuscany/sca/assembly/builder/impl/ImplementationPolicyComputer.java b/sca-java-1.x/tags/1.2/modules/assembly/src/main/java/org/apache/tuscany/sca/assembly/builder/impl/ImplementationPolicyComputer.java new file mode 100644 index 0000000000..ba4cec0fc9 --- /dev/null +++ b/sca-java-1.x/tags/1.2/modules/assembly/src/main/java/org/apache/tuscany/sca/assembly/builder/impl/ImplementationPolicyComputer.java @@ -0,0 +1,134 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ + +package org.apache.tuscany.sca.assembly.builder.impl; + +import java.util.ArrayList; +import java.util.List; + +import org.apache.tuscany.sca.assembly.Component; +import org.apache.tuscany.sca.assembly.ConfiguredOperation; +import org.apache.tuscany.sca.assembly.Implementation; +import org.apache.tuscany.sca.assembly.OperationsConfigurator; +import org.apache.tuscany.sca.policy.Intent; +import org.apache.tuscany.sca.policy.IntentAttachPoint; +import org.apache.tuscany.sca.policy.PolicySet; +import org.apache.tuscany.sca.policy.PolicySetAttachPoint; +import org.apache.tuscany.sca.policy.util.PolicyValidationException; + +/** + * Policy computation methods pertaining to computing Implementation Policies + */ +public class ImplementationPolicyComputer extends PolicyComputer { + + public ImplementationPolicyComputer() { + super(); + } + + public void computeImplementationIntentsAndPolicySets(Implementation implementation, Component parent) + throws PolicyValidationException, PolicyComputationException { + if ( implementation instanceof PolicySetAttachPoint ) { + PolicySetAttachPoint policiedImplementation = (PolicySetAttachPoint)implementation; + //since for an implementation the component has its policy intents and policysets its possible + //that there are some intents there that does not constrain the implementation.. so prune + List<Intent> prunedIntents = computeInheritableIntents(policiedImplementation.getType(), + parent.getRequiredIntents()); + parent.getRequiredIntents().clear(); + parent.getRequiredIntents().addAll(prunedIntents); + normalizeIntents(parent); + + computeIntentsForOperations((OperationsConfigurator)parent, + (IntentAttachPoint)implementation, + parent.getRequiredIntents()); + + + List<PolicySet> prunedPolicySets = computeInheritablePolicySets(parent.getPolicySets(), + parent.getApplicablePolicySets()); + parent.getPolicySets().clear(); + parent.getPolicySets().addAll(prunedPolicySets); + normalizePolicySets(parent); + computePolicySetsForOperations(parent.getApplicablePolicySets(), + (OperationsConfigurator)parent, + (PolicySetAttachPoint)implementation); + + determineApplicableImplementationPolicySets(parent); + } + } + + private void determineApplicableImplementationPolicySets(Component component) throws PolicyComputationException { + List<Intent> intentsCopy = null; + if ( component.getImplementation() instanceof PolicySetAttachPoint ) { + PolicySetAttachPoint policiedImplementation = (PolicySetAttachPoint)component.getImplementation(); + + //trim intents specified in operations. First check for policysets specified on the operation + //and then in the parent implementation + if ( component instanceof OperationsConfigurator ) { + OperationsConfigurator opConfigurator = (OperationsConfigurator)component; + + for ( ConfiguredOperation confOp : opConfigurator.getConfiguredOperations() ) { + intentsCopy = new ArrayList<Intent>(confOp.getRequiredIntents()); + trimInherentlyProvidedIntents(policiedImplementation.getType(), + confOp.getRequiredIntents()); + trimProvidedIntents(confOp.getRequiredIntents(), confOp.getPolicySets()); + trimProvidedIntents(confOp.getRequiredIntents(), component.getPolicySets()); + + determineApplicableDomainPolicySets(component.getApplicablePolicySets(), + confOp, + policiedImplementation.getType()); + + if (confOp.getRequiredIntents().size() > 0) { + new PolicyComputationException("The following are unfulfilled intents for operations configured in " + + "component implementation - " + component.getName() + "\nUnfulfilled Intents = " + + confOp.getRequiredIntents()); + } + + //the intents list could have been trimmed when matching for policysets + //since the implementation may need the original set of intents we copy that back + confOp.getRequiredIntents().clear(); + confOp.getRequiredIntents().addAll(intentsCopy); + } + } + + intentsCopy = new ArrayList<Intent>(component.getRequiredIntents()); + trimInherentlyProvidedIntents(policiedImplementation.getType(), + component.getRequiredIntents()); + trimProvidedIntents(component.getRequiredIntents(), component.getPolicySets()); + + //determine additional policysets that match remaining intents + //if there are intents that are not provided by any policy set throw a warning + //TODO: resolved to domain policy registry and attach suitable policy sets to the implementation + //...for now using the SCA Definitions instead of registry + //if ( domainPolicySets != null) { + determineApplicableDomainPolicySets(component.getApplicablePolicySets(), + component, + policiedImplementation.getType()); + + if (component.getRequiredIntents().size() > 0) { + throw new PolicyComputationException("The following are unfulfilled intents for component implementation - " + component + .getName() + "\nUnfulfilled Intents = " + component.getRequiredIntents()); + } + //} + + //the intents list could have been trimmed when matching for policysets + //since the bindings may need the original set of intents we copy that back + component.getRequiredIntents().clear(); + component.getRequiredIntents().addAll(intentsCopy); + } + } +} diff --git a/sca-java-1.x/tags/1.2/modules/assembly/src/main/java/org/apache/tuscany/sca/assembly/builder/impl/PolicyComputationException.java b/sca-java-1.x/tags/1.2/modules/assembly/src/main/java/org/apache/tuscany/sca/assembly/builder/impl/PolicyComputationException.java new file mode 100644 index 0000000000..86bd2a6449 --- /dev/null +++ b/sca-java-1.x/tags/1.2/modules/assembly/src/main/java/org/apache/tuscany/sca/assembly/builder/impl/PolicyComputationException.java @@ -0,0 +1,36 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ + +package org.apache.tuscany.sca.assembly.builder.impl; + +/** + * Exception to be throw for invalid policy intents / policysets + */ +public class PolicyComputationException extends Exception { + private static final long serialVersionUID = 506979037642587755L; + + public PolicyComputationException(String message) { + super(message); + } + + public PolicyComputationException(Throwable e) { + super(e); + } + +} diff --git a/sca-java-1.x/tags/1.2/modules/assembly/src/main/java/org/apache/tuscany/sca/assembly/builder/impl/PolicyComputer.java b/sca-java-1.x/tags/1.2/modules/assembly/src/main/java/org/apache/tuscany/sca/assembly/builder/impl/PolicyComputer.java new file mode 100644 index 0000000000..6003b3f67d --- /dev/null +++ b/sca-java-1.x/tags/1.2/modules/assembly/src/main/java/org/apache/tuscany/sca/assembly/builder/impl/PolicyComputer.java @@ -0,0 +1,373 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ + +package org.apache.tuscany.sca.assembly.builder.impl; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +import javax.xml.namespace.QName; + +import org.apache.tuscany.sca.assembly.Base; +import org.apache.tuscany.sca.assembly.ConfiguredOperation; +import org.apache.tuscany.sca.assembly.OperationsConfigurator; +import org.apache.tuscany.sca.policy.Intent; +import org.apache.tuscany.sca.policy.IntentAttachPoint; +import org.apache.tuscany.sca.policy.IntentAttachPointType; +import org.apache.tuscany.sca.policy.PolicySet; +import org.apache.tuscany.sca.policy.PolicySetAttachPoint; +import org.apache.tuscany.sca.policy.ProfileIntent; +import org.apache.tuscany.sca.policy.QualifiedIntent; +import org.apache.tuscany.sca.policy.util.PolicyValidationException; +import org.apache.tuscany.sca.policy.util.PolicyValidationUtils; + +/** + * This class contains policy computation methods common to computing implementation and binding policies + */ +public abstract class PolicyComputer { + + protected PolicyComputer() { + + } + + protected List<Intent> computeInheritableIntents(IntentAttachPointType attachPointType, + List<Intent> inheritableIntents) throws PolicyValidationException { + List<Intent> validInheritableIntents = new ArrayList<Intent>(); + + //expand profile intents in inherited intents + expandProfileIntents(inheritableIntents); + + //validate if inherited intent applies to the attachpoint (binding / implementation) and + //only add such intents to the attachpoint (binding / implementation) + for (Intent intent : inheritableIntents) { + if ( !intent.isUnresolved() ) { + for (QName constrained : intent.getConstrains()) { + if ( PolicyValidationUtils.isConstrained(constrained, attachPointType)) { + validInheritableIntents.add(intent); + break; + } + } + } else { + throw new PolicyValidationException("Policy Intent '" + intent.getName() + "' is not defined in this domain"); + } + } + + return validInheritableIntents; + } + + protected void expandProfileIntents(List<Intent> intents) { + List<Intent> expandedIntents = null; + if ( intents.size() > 0 ) { + expandedIntents = findAndExpandProfileIntents(intents); + intents.clear(); + intents.addAll(expandedIntents); + } + } + + protected void normalizeIntents(IntentAttachPoint intentAttachPoint) { + //expand profile intents specified in the attachpoint (binding / implementation) + expandProfileIntents(intentAttachPoint.getRequiredIntents()); + + //remove duplicates and ... + //where qualified form of intent exists retain it and remove the qualifiable intent + filterDuplicatesAndQualifiableIntents(intentAttachPoint); + } + + protected void trimInherentlyProvidedIntents(IntentAttachPointType attachPointType, List<Intent>intents) { + //exclude intents that are inherently supported by the + //attachpoint-type (binding-type / implementation-type) + List<Intent> requiredIntents = new ArrayList<Intent>(intents); + for ( Intent intent : requiredIntents ) { + if ( isProvidedInherently(attachPointType, intent) ) { + intents.remove(intent); + } + } + } + + + protected void computeIntentsForOperations(IntentAttachPoint intentAttachPoint) throws PolicyValidationException { + if ( intentAttachPoint instanceof OperationsConfigurator ) { + computeIntentsForOperations((OperationsConfigurator)intentAttachPoint, + intentAttachPoint, + intentAttachPoint.getRequiredIntents()); + } + } + + protected void computeIntentsForOperations(OperationsConfigurator opConfigurator, + IntentAttachPoint intentAttachPoint, + List<Intent> parentIntents) throws PolicyValidationException { + IntentAttachPointType attachPointType = intentAttachPoint.getType(); + + boolean found = false; + for ( ConfiguredOperation confOp : opConfigurator.getConfiguredOperations() ) { + //expand profile intents specified on operations + expandProfileIntents(confOp.getRequiredIntents()); + + //validateIntents(confOp, attachPointType); + + //add intents specified for parent intent attach point (binding / implementation) + //wherever its not overriden in the operation + Intent tempIntent = null; + List<Intent> attachPointOpIntents = new ArrayList<Intent>(); + for (Intent anIntent : parentIntents) { + found = false; + + tempIntent = anIntent; + while ( tempIntent instanceof QualifiedIntent ) { + tempIntent = ((QualifiedIntent)tempIntent).getQualifiableIntent(); + } + + for ( Intent opIntent : confOp.getRequiredIntents() ) { + if ( opIntent.getName().getLocalPart().startsWith(tempIntent.getName().getLocalPart())) { + found = true; + break; + } + } + + if ( !found ) { + attachPointOpIntents.add(anIntent); + } + } + + confOp.getRequiredIntents().addAll(attachPointOpIntents); + + //remove duplicates and ... + //where qualified form of intent exists retain it and remove the qualifiable intent + filterDuplicatesAndQualifiableIntents(confOp); + + //exclude intents that are inherently supported by the parent + //attachpoint-type (binding-type / implementation-type) + if ( attachPointType != null ) { + List<Intent> requiredIntents = new ArrayList<Intent>(confOp.getRequiredIntents()); + for ( Intent intent : requiredIntents ) { + if ( isProvidedInherently(attachPointType, intent) ) { + confOp.getRequiredIntents().remove(intent); + } + } + } + } + } + + protected List<PolicySet> computeInheritablePolicySets(List<PolicySet> inheritablePolicySets, + List<PolicySet> applicablePolicySets) + throws PolicyValidationException { + List<PolicySet> validInheritablePolicySets = new ArrayList<PolicySet>(); + for (PolicySet policySet : inheritablePolicySets) { + if ( !policySet.isUnresolved() ) { + if ( applicablePolicySets.contains(policySet) ) { + validInheritablePolicySets.add(policySet); + } + } else { + throw new PolicyValidationException("Policy Set '" + policySet.getName() + + "' is not defined in this domain "); + } + } + + return validInheritablePolicySets; + } + + protected void normalizePolicySets(PolicySetAttachPoint policySetAttachPoint ) { + //get rid of duplicate entries + HashMap<QName, PolicySet> policySetTable = new HashMap<QName, PolicySet>(); + for ( PolicySet policySet : policySetAttachPoint.getPolicySets() ) { + policySetTable.put(policySet.getName(), policySet); + } + + policySetAttachPoint.getPolicySets().clear(); + policySetAttachPoint.getPolicySets().addAll(policySetTable.values()); + + //expand profile intents + for ( PolicySet policySet : policySetAttachPoint.getPolicySets() ) { + expandProfileIntents(policySet.getProvidedIntents()); + } + } + + protected void computePolicySetsForOperations(List<PolicySet> applicablePolicySets, + PolicySetAttachPoint policySetAttachPoint) + throws PolicyValidationException { + if ( policySetAttachPoint instanceof OperationsConfigurator ) { + computePolicySetsForOperations(applicablePolicySets, + (OperationsConfigurator)policySetAttachPoint, + policySetAttachPoint); + } + + } + + protected void computePolicySetsForOperations(List<PolicySet> applicablePolicySets, + OperationsConfigurator opConfigurator, + PolicySetAttachPoint policySetAttachPoint) + throws PolicyValidationException { + //String appliesTo = null; + //String scdlFragment = ""; + HashMap<QName, PolicySet> policySetTable = new HashMap<QName, PolicySet>(); + IntentAttachPointType attachPointType = policySetAttachPoint.getType(); + + for ( ConfiguredOperation confOp : opConfigurator.getConfiguredOperations() ) { + //validate policysets specified for the attachPoint + for (PolicySet policySet : confOp.getPolicySets()) { + if ( !policySet.isUnresolved() ) { + //appliesTo = policySet.getAppliesTo(); + + //if (!PolicyValidationUtils.isPolicySetApplicable(scdlFragment, appliesTo, attachPointType)) { + if (!applicablePolicySets.contains(policySet)) { + throw new PolicyValidationException("Policy Set '" + policySet.getName() + + " specified for operation " + confOp.getName() + + "' does not constrain extension type " + + attachPointType.getName()); + + } + } else { + throw new PolicyValidationException("Policy Set '" + policySet.getName() + + " specified for operation " + confOp.getName() + + "' is not defined in this domain "); + } + } + + //get rid of duplicate entries + for ( PolicySet policySet : confOp.getPolicySets() ) { + policySetTable.put(policySet.getName(), policySet); + } + + confOp.getPolicySets().clear(); + confOp.getPolicySets().addAll(policySetTable.values()); + policySetTable.clear(); + + //expand profile intents + for ( PolicySet policySet : confOp.getPolicySets() ) { + expandProfileIntents(policySet.getProvidedIntents()); + } + } + } + + + protected void trimProvidedIntents(List<Intent> requiredIntents, List<PolicySet> policySets) { + for ( PolicySet policySet : policySets ) { + trimProvidedIntents(requiredIntents, policySet); + } + } + + protected void determineApplicableDomainPolicySets(List<PolicySet> applicablePolicySets, + PolicySetAttachPoint policySetAttachPoint, + IntentAttachPointType intentAttachPointType) { + + if (policySetAttachPoint.getRequiredIntents().size() > 0) { + //since the set of applicable policysets for this attachpoint is known + //we only need to check in that list if there is a policyset that matches + for (PolicySet policySet : applicablePolicySets) { + int prevSize = policySetAttachPoint.getRequiredIntents().size(); + trimProvidedIntents(policySetAttachPoint.getRequiredIntents(), policySet); + // if any intent was trimmed off, then this policyset must + // be attached to the intent attachpoint's policyset + if (prevSize != policySetAttachPoint.getRequiredIntents().size()) { + policySetAttachPoint.getPolicySets().add(policySet); + } + } + } + } + + private List<Intent> findAndExpandProfileIntents(List<Intent> intents) { + List<Intent> expandedIntents = new ArrayList<Intent>(); + for ( Intent intent : intents ) { + if ( intent instanceof ProfileIntent ) { + ProfileIntent profileIntent = (ProfileIntent)intent; + List<Intent> requiredIntents = profileIntent.getRequiredIntents(); + expandedIntents.addAll(findAndExpandProfileIntents(requiredIntents)); + } else { + expandedIntents.add(intent); + } + } + return expandedIntents; + } + + private boolean isProvidedInherently(IntentAttachPointType attachPointType, Intent intent) { + return ( attachPointType != null && + (( attachPointType.getAlwaysProvidedIntents() != null && + attachPointType.getAlwaysProvidedIntents().contains(intent) ) || + ( attachPointType.getMayProvideIntents() != null && + attachPointType.getMayProvideIntents().contains(intent) ) + ) ); + } + + private void trimProvidedIntents(List<Intent> requiredIntents, PolicySet policySet) { + for ( Intent providedIntent : policySet.getProvidedIntents() ) { + if ( requiredIntents.contains(providedIntent) ) { + requiredIntents.remove(providedIntent); + } + } + + for ( Intent mappedIntent : policySet.getMappedPolicies().keySet() ) { + if ( requiredIntents.contains(mappedIntent) ) { + requiredIntents.remove(mappedIntent); + } + } + } + + private void filterDuplicatesAndQualifiableIntents(IntentAttachPoint intentAttachPoint) { + //remove duplicates + Map<QName, Intent> intentsTable = new HashMap<QName, Intent>(); + for ( Intent intent : intentAttachPoint.getRequiredIntents() ) { + intentsTable.put(intent.getName(), intent); + } + + //where qualified form of intent exists retain it and remove the qualifiable intent + Map<QName, Intent> intentsTableCopy = new HashMap<QName, Intent>(intentsTable); + //if qualified form of intent exists remove the unqualified form + for ( Intent intent : intentsTableCopy.values() ) { + if ( intent instanceof QualifiedIntent ) { + QualifiedIntent qualifiedIntent = (QualifiedIntent)intent; + if ( intentsTable.get(qualifiedIntent.getQualifiableIntent().getName()) != null ) { + intentsTable.remove(qualifiedIntent.getQualifiableIntent().getName()); + } + } + } + intentAttachPoint.getRequiredIntents().clear(); + intentAttachPoint.getRequiredIntents().addAll(intentsTable.values()); + } + + private void validateIntents(ConfiguredOperation confOp, IntentAttachPointType attachPointType) throws PolicyValidationException { + boolean found = false; + if ( attachPointType != null ) { + //validate intents specified against the parent (binding / implementation) + found = false; + for (Intent intent : confOp.getRequiredIntents()) { + if ( !intent.isUnresolved() ) { + for (QName constrained : intent.getConstrains()) { + if (PolicyValidationUtils.isConstrained(constrained, attachPointType)) { + found = true; + break; + } + } + + if (!found) { + throw new PolicyValidationException("Policy Intent '" + intent.getName() + + " specified for operation " + confOp.getName() + + "' does not constrain extension type " + + attachPointType.getName()); + } + } else { + throw new PolicyValidationException("Policy Intent '" + intent.getName() + + " specified for operation " + confOp.getName() + + "' is not defined in this domain "); + } + } + } + } +} diff --git a/sca-java-1.x/tags/1.2/modules/assembly/src/main/java/org/apache/tuscany/sca/assembly/builder/impl/PrintUtil.java b/sca-java-1.x/tags/1.2/modules/assembly/src/main/java/org/apache/tuscany/sca/assembly/builder/impl/PrintUtil.java new file mode 100644 index 0000000000..efd10bfe9a --- /dev/null +++ b/sca-java-1.x/tags/1.2/modules/assembly/src/main/java/org/apache/tuscany/sca/assembly/builder/impl/PrintUtil.java @@ -0,0 +1,273 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ +package org.apache.tuscany.sca.assembly.builder.impl; + +import java.beans.BeanInfo; +import java.beans.IntrospectionException; +import java.beans.Introspector; +import java.beans.PropertyDescriptor; +import java.io.OutputStream; +import java.io.OutputStreamWriter; +import java.io.PrintWriter; +import java.lang.reflect.Field; +import java.lang.reflect.Method; +import java.security.AccessController; +import java.security.PrivilegedAction; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.HashSet; +import java.util.List; +import java.util.Set; + +import org.w3c.dom.Node; + +/** + * A simple print utility class to help print model instances. + * + * @version $Rev$ $Date$ + */ +class PrintUtil { + private boolean useGetters = false; + private PrintWriter out; + private int indent; + + public PrintUtil(PrintWriter out, boolean useGetters) { + this.out = out; + this.useGetters = useGetters; + } + + public PrintUtil(OutputStream out) { + this.out = new PrintWriter(new OutputStreamWriter(out), true); + } + + void indent() { + for (int i = 0; i < indent; i++) { + out.print(" "); + } + } + + /** + * Print an object. + * + * @param object + */ + public void print(Object object) { + Set<Integer> objects = new HashSet<Integer>(); + print(object, objects); + } + + /** + * Print an object. + * + * @param object + */ + private void print(Object object, Set<Integer> printed) { + if (object == null) { + return; + } + int id = System.identityHashCode(object); + if (printed.contains(id)) { + + // If we've already printed an object, print just it's hashcode + indent(); + out.println(object.getClass().getName() + "@" + id); + } else { + printed.add(id); + try { + + // Print the object class name + indent(); + out.println(object.getClass().getSimpleName() + " {"); + + // Get the object's properties + ValueAccessor accessor = useGetters ? new PropertyAccessor(object) : new FieldAccessor(object); + for (int i = 0; i < accessor.size(); i++) { + try { + + // Get the value of each property + Object value = accessor.getValue(i); + if (value != null) { + + // Convert array value into a list + if (value.getClass().isArray()) { + value = Arrays.asList((Object[])value); + } + + // Print elements in a list + if (value instanceof List) { + if (!((List)value).isEmpty()) { + indent++; + indent(); + out.println(accessor.getName(i) + "= ["); + + // Print each element, recursively + for (Object element : (List)value) { + indent++; + print(element, printed); + indent--; + } + indent(); + out.println(" ]"); + indent--; + } + } else { + Class<?> valueClass = value.getClass(); + + // Print a primitive, java built in type or + // enum, using toString() + if (valueClass.isPrimitive() || valueClass.getName().startsWith("java.") + || valueClass.getName().startsWith("javax.") + || valueClass.isEnum()) { + if (!accessor.getName(i).equals("class")) { + if (!(Boolean.FALSE.equals(value))) { + indent++; + indent(); + out.println(accessor.getName(i) + "=" + value.toString()); + indent--; + } + } + } else if (value instanceof Node) { + indent++; + indent(); + out.println(accessor.getName(i) + "=" + value.toString()); + indent--; + } else { + + // Print an object, recursively + indent++; + indent(); + out.println(accessor.getName(i) + "= {"); + indent++; + print(value, printed); + indent--; + indent(); + out.println("}"); + indent--; + } + } + } + } catch (Exception e) { + } + } + indent(); + out.println("}"); + } catch (Exception e) { + indent(); + out.println(e); + } + } + } + + public static interface ValueAccessor { + int size(); + + String getName(int i); + + Object getValue(int i) throws Exception; + } + + /** + * Java field reflection based value accessor + */ + private static class FieldAccessor implements ValueAccessor { + + private Object object; + private List<Field> fields; + + public FieldAccessor(Object object) { + this.fields = getAllFields(object.getClass()); + this.object = object; + } + + public String getName(int i) { + return fields.get(i).getName(); + } + + public Object getValue(int i) throws Exception { + return fields.get(i).get(object); + } + + public int size() { + return fields.size(); + } + + } + + /** + * JavaBean-based value accessor + */ + private static class PropertyAccessor implements ValueAccessor { + + private Object object; + private PropertyDescriptor[] fields; + + public PropertyAccessor(Object object) throws IntrospectionException { + BeanInfo beanInfo = Introspector.getBeanInfo(object.getClass()); + this.fields = beanInfo.getPropertyDescriptors(); + this.object = object; + } + + public String getName(int i) { + return fields[i].getName(); + } + + public Object getValue(int i) throws Exception { + Method getter = fields[i].getReadMethod(); + if (getter != null) { + return getter.invoke(object); + } + return null; + } + + public int size() { + return fields.length; + } + + } + + /** + * Returns a collection of fields declared by a class + * or one of its supertypes + */ + private static List<Field> getAllFields(Class<?> clazz) { + return getAllFields(clazz, new ArrayList<Field>()); + } + + /** + * Recursively evaluates the type hierachy to return all fields + */ + private static List<Field> getAllFields(Class<?> clazz, List<Field> fields) { + if (clazz == null || clazz.isArray() || Object.class.equals(clazz)) { + return fields; + } + fields = getAllFields(clazz.getSuperclass(), fields); + Field[] declaredFields = clazz.getDeclaredFields(); + for (final Field field : declaredFields) { + AccessController.doPrivileged(new PrivilegedAction<Object>() { + public Object run() { + field.setAccessible(true); // ignore Java accessibility + return null; + } + }); + fields.add(field); + } + return fields; + } + +} diff --git a/sca-java-1.x/tags/1.2/modules/assembly/src/main/java/org/apache/tuscany/sca/assembly/builder/impl/ProblemImpl.java b/sca-java-1.x/tags/1.2/modules/assembly/src/main/java/org/apache/tuscany/sca/assembly/builder/impl/ProblemImpl.java new file mode 100644 index 0000000000..b572b67ced --- /dev/null +++ b/sca-java-1.x/tags/1.2/modules/assembly/src/main/java/org/apache/tuscany/sca/assembly/builder/impl/ProblemImpl.java @@ -0,0 +1,112 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ + +package org.apache.tuscany.sca.assembly.builder.impl; + +import org.apache.tuscany.sca.assembly.builder.Problem; + +/** + * Reports a composite assembly problem. + * + * @version $Rev$ $Date$ + */ +public class ProblemImpl implements Problem { + + private String message; + private Severity severity; + private Object model; + private Object resource; + private Exception cause; + + /** + * Constructs a new problem. + * + * @param severity + * @param message + * @param model + */ + public ProblemImpl(Severity severity, String message, Object model) { + this.severity = severity; + this.message = message; + this.model = model; + } + + /** + * Constructs a new problem. + * + * @param severity + * @param message + * @param model + * @param resource + */ + public ProblemImpl(Severity severity, String message, Object model, Object resource) { + this.severity = severity; + this.message = message; + this.model = model; + this.resource = resource; + } + + /** + * Constructs a new problem. + * + * @param severity + * @param message + * @param cause + */ + public ProblemImpl(Severity severity, String message, Exception cause) { + this.severity = severity; + this.message = message; + this.cause = cause; + } + + public Severity getSeverity() { + return severity; + } + + public String getMessage() { + return message; + } + + public Object getModel() { + return model; + } + + public Object getResource() { + return resource; + } + + public Exception getCause() { + return cause; + } + + @Override + public String toString() { + StringBuffer sb = new StringBuffer(); + if (message != null) { + sb.append(message); + } + if (resource != null) { + if (sb.length() != 0) { + sb.append(" - "); + } + sb.append(resource.toString()); + } + return sb.toString(); + } +} diff --git a/sca-java-1.x/tags/1.2/modules/assembly/src/main/java/org/apache/tuscany/sca/assembly/builder/impl/PropertyUtil.java b/sca-java-1.x/tags/1.2/modules/assembly/src/main/java/org/apache/tuscany/sca/assembly/builder/impl/PropertyUtil.java new file mode 100644 index 0000000000..1007286e40 --- /dev/null +++ b/sca-java-1.x/tags/1.2/modules/assembly/src/main/java/org/apache/tuscany/sca/assembly/builder/impl/PropertyUtil.java @@ -0,0 +1,205 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ +package org.apache.tuscany.sca.assembly.builder.impl; + +import java.io.IOException; +import java.io.InputStream; +import java.net.MalformedURLException; +import java.net.URI; +import java.net.URL; +import java.net.URLConnection; +import java.util.Arrays; +import java.util.Collections; +import java.util.Iterator; +import java.util.List; +import java.util.Map; + +import javax.xml.XMLConstants; +import javax.xml.namespace.NamespaceContext; +import javax.xml.parsers.DocumentBuilderFactory; +import javax.xml.parsers.ParserConfigurationException; +import javax.xml.transform.Source; +import javax.xml.transform.TransformerException; +import javax.xml.transform.TransformerFactory; +import javax.xml.transform.dom.DOMResult; +import javax.xml.transform.sax.SAXSource; +import javax.xml.xpath.XPathConstants; +import javax.xml.xpath.XPathExpression; +import javax.xml.xpath.XPathExpressionException; +import javax.xml.xpath.XPathFactory; + +import org.apache.tuscany.sca.assembly.Component; +import org.apache.tuscany.sca.assembly.ComponentProperty; +import org.apache.tuscany.sca.assembly.Property; +import org.apache.tuscany.sca.assembly.builder.CompositeBuilderException; +import org.w3c.dom.Document; +import org.w3c.dom.Node; +import org.xml.sax.InputSource; + +/** + * Utility class to deal with processing of component properties that are taking values from the parent + * composite's properties or an external file. + */ +public class PropertyUtil { + private static final XPathFactory XPATH_FACTORY = XPathFactory.newInstance(); + private static final DocumentBuilderFactory DOC_BUILDER_FACTORY = DocumentBuilderFactory.newInstance(); + private static final TransformerFactory TRANSFORMER_FACTORY = TransformerFactory.newInstance(); + + static private Document evaluate(Document node, XPathExpression expression) + throws XPathExpressionException, ParserConfigurationException { + + Node value = node.getDocumentElement(); + Node result = (Node)expression.evaluate(value, XPathConstants.NODE); + if (result == null) { + return null; + } + + // TODO: How to wrap the result into a Document? + Document document = DOC_BUILDER_FACTORY.newDocumentBuilder().newDocument(); + if (result instanceof Document) { + return (Document)result; + } else { + //Element root = document.createElementNS(null, "value"); + //document.appendChild(root); + document.appendChild(document.importNode(result, true)); + return document; + } + } + + static private Document loadFromFile(String file) throws MalformedURLException, IOException, + TransformerException, ParserConfigurationException { + URI uri = URI.create(file); + // URI resolution for relative uris is done when the composite is resolved. + URL url = uri.toURL(); + URLConnection connection = url.openConnection(); + connection.setUseCaches(false); + InputStream is = null; + try { + is = connection.getInputStream(); + + Source streamSource = new SAXSource(new InputSource(is)); + DOMResult result = new DOMResult(); + javax.xml.transform.Transformer transformer = TRANSFORMER_FACTORY.newTransformer(); + transformer.transform(streamSource, result); + + return (Document)result.getNode(); + } finally { + if (is != null) { + is.close(); + } + } + } + + static void sourceComponentProperties(Map<String, Property> compositeProperties, + Component componentDefinition) throws CompositeBuilderException, + ParserConfigurationException, + XPathExpressionException, + TransformerException, + IOException { + + List<ComponentProperty> componentProperties = componentDefinition.getProperties(); + for (ComponentProperty aProperty : componentProperties) { + String source = aProperty.getSource(); + String file = aProperty.getFile(); + if (source != null) { + // $<name>/... + int index = source.indexOf('/'); + if (index == -1) { + // Tolerating $prop + source = source + "/"; + index = source.length() - 1; + } + if (source.charAt(0) == '$') { + String name = source.substring(1, index); + Property compositeProp = compositeProperties.get(name); + if (compositeProp == null) { + throw new CompositeBuilderException("The 'source' cannot be resolved to a composite property: " + source); + } + + Document compositePropDefValues = (Document)compositeProp.getValue(); + + // FIXME: How to deal with namespaces? + Document node = evaluate(compositePropDefValues, aProperty.getSourceXPathExpression()); + + if (node != null) { + aProperty.setValue(node); + } + } else { + throw new CompositeBuilderException("The 'source' has an invalid value: " + source); + } + } else if (file != null) { + aProperty.setValue(loadFromFile(aProperty.getFile())); + + } + } + } + + private static class DOMNamespaceContext implements NamespaceContext { + private Node node; + + /** + * @param node + */ + public DOMNamespaceContext(Node node) { + super(); + this.node = node; + } + + public String getNamespaceURI(String prefix) { + if (prefix == null) { + throw new IllegalArgumentException("Prefix is null"); + } else if (XMLConstants.XML_NS_PREFIX.equals(prefix)) { + return XMLConstants.XML_NS_URI; + } else if (XMLConstants.XMLNS_ATTRIBUTE.equals(prefix)) { + return XMLConstants.XMLNS_ATTRIBUTE_NS_URI; + } + String ns = node.lookupNamespaceURI(prefix); + return ns == null ? XMLConstants.NULL_NS_URI : ns; + } + + public String getPrefix(String namespaceURI) { + if (namespaceURI == null) { + throw new IllegalArgumentException("Namespace URI is null"); + } else if (XMLConstants.XML_NS_URI.equals(namespaceURI)) { + return XMLConstants.XML_NS_PREFIX; + } else if (XMLConstants.XMLNS_ATTRIBUTE_NS_URI.equals(namespaceURI)) { + return XMLConstants.XMLNS_ATTRIBUTE; + } + return node.lookupPrefix(namespaceURI); + } + + public Iterator<?> getPrefixes(String namespaceURI) { + // Not implemented + if (namespaceURI == null) { + throw new IllegalArgumentException("Namespace URI is null"); + } else if (XMLConstants.XML_NS_URI.equals(namespaceURI)) { + return Arrays.asList(XMLConstants.XML_NS_PREFIX).iterator(); + } else if (XMLConstants.XMLNS_ATTRIBUTE_NS_URI.equals(namespaceURI)) { + return Arrays.asList(XMLConstants.XMLNS_ATTRIBUTE).iterator(); + } + String prefix = getPrefix(namespaceURI); + if (prefix == null) { + return Collections.emptyList().iterator(); + } + return Arrays.asList(prefix).iterator(); + } + + } + +} diff --git a/sca-java-1.x/tags/1.2/modules/assembly/src/main/java/org/apache/tuscany/sca/assembly/builder/impl/ReferenceUtil.java b/sca-java-1.x/tags/1.2/modules/assembly/src/main/java/org/apache/tuscany/sca/assembly/builder/impl/ReferenceUtil.java new file mode 100644 index 0000000000..a4599e96f6 --- /dev/null +++ b/sca-java-1.x/tags/1.2/modules/assembly/src/main/java/org/apache/tuscany/sca/assembly/builder/impl/ReferenceUtil.java @@ -0,0 +1,94 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ +package org.apache.tuscany.sca.assembly.builder.impl; + +import java.util.List; + +import org.apache.tuscany.sca.assembly.Binding; +import org.apache.tuscany.sca.assembly.Multiplicity; +import org.apache.tuscany.sca.assembly.OptimizableBinding; + +/** + * This class encapsulates utility methods to deal with reference definitions + * + */ +class ReferenceUtil { + static boolean isValidMultiplicityOverride(Multiplicity definedMul, Multiplicity overridenMul) { + if (definedMul != overridenMul) { + switch (definedMul) { + case ZERO_N: + return overridenMul == Multiplicity.ZERO_ONE; + case ONE_N: + return overridenMul == Multiplicity.ONE_ONE; + default: + return false; + } + } else { + return true; + } + } + + static boolean validateMultiplicityAndTargets(Multiplicity multiplicity, + List<?> targets, List<Binding> bindings) { + + // Count targets + int count = targets.size(); + + //FIXME workaround, this validation is sometimes invoked too early + // before we get a chance to init the multiplicity attribute + if (multiplicity == null) { + return true; + } + + switch (multiplicity) { + case ZERO_N: + break; + case ZERO_ONE: + if (count > 1) { + return false; + } + break; + case ONE_ONE: + if (count != 1) { + if (count == 0) { + for (Binding binding: bindings) { + if (!(binding instanceof OptimizableBinding) || binding.getURI()!=null) { + return true; + } + } + } + return false; + } + break; + case ONE_N: + if (count < 1) { + if (count == 0) { + for (Binding binding: bindings) { + if (!(binding instanceof OptimizableBinding) || binding.getURI()!=null) { + return true; + } + } + } + return false; + } + break; + } + return true; + } +} |