/** * Constructor. * * @param source the reference source * @param promotedComponentUri the promoted component URI. */ public AmbiguousReference(LogicalReference source, URI promotedComponentUri) { super(source.getParent().getUri(), source.getParent().getDefinition().getContributionUri(), Collections.singletonList(source)); this.referenceUri = source.getUri(); this.promotedComponentUri = promotedComponentUri; }
public PhysicalSourceDefinition generateSource(LogicalReference reference, EffectivePolicy policy) throws GenerationException { ServiceContract contract = reference.getLeafReference().getServiceContract(); if (!(contract instanceof JavaServiceContract)) { // Spring reference contracts are always defined by Java interfaces throw new GenerationException("Unexpected interface type for " + reference.getUri() + ": " + contract.getClass().getName()); } String interfaze = contract.getQualifiedInterfaceName(); URI uri = reference.getParent().getUri(); String referenceName = reference.getDefinition().getName(); return new SpringSourceDefinition(referenceName, interfaze, uri); }
@SuppressWarnings("unchecked") private void generateCallbackBindings(LogicalReference reference) { for (LogicalBinding<?> logicalBinding : reference.getBindings()) { CallbackBindingGenerator generator = generators.get(logicalBinding.getDefinition().getClass()); if (generator == null) { throw new Fabric3Exception("Callback generator not found for:" + logicalBinding.getDefinition().getType()); } Binding definition = generator.generateReferenceCallback(logicalBinding); definition.setParent(reference.getDefinition()); LogicalBinding<?> logicalCallback = new LogicalBinding(definition, reference); reference.addCallbackBinding(logicalCallback); } }
public PhysicalWireSource generateSource(LogicalReference reference) { Class<?> interfaze = reference.getServiceContract().getInterfaceClass(); return new NonManagedWireSource(reference.getUri(), interfaze); }
if (reference.getParent().getAutowire() == Autowire.ON || !reference.getBindings().isEmpty() || reference.getAutowire() == Autowire.ON || reference.getComponentReference() != null) { // Reference should not be configured in the component. Multiplicity multiplicity = reference.getDefinition().getMultiplicity(); switch (multiplicity) { case ONE_N: if (targets.size() < 1) { URI referenceName = reference.getUri(); InvalidNumberOfTargets error = new InvalidNumberOfTargets("At least one target must be configured for reference: " + referenceName, reference); case ONE_ONE: if (targets.size() < 1) { URI referenceName = reference.getUri(); InvalidNumberOfTargets error = new InvalidNumberOfTargets("At least one target must be configured for reference " + "(no targets configured): " + referenceName, reference); return false; } else if (targets.size() > 1) { URI referenceName = reference.getUri(); InvalidNumberOfTargets error = new InvalidNumberOfTargets("Only one target must be configured for reference " + "(multiple targets configured via promotions): " case ZERO_ONE: if (targets.size() > 1) { URI referenceName = reference.getUri(); InvalidNumberOfTargets error = new InvalidNumberOfTargets("At most one target must be configured for reference "
public void bind(LogicalWire wire) throws BindingSelectionException { LogicalReference source = wire.getSource().getLeafReference(); LogicalService target = wire.getTarget().getLeafService(); QName deployable = source.getParent().getDeployable(); LogicalBinding<JmsBindingDefinition> referenceBinding = new LogicalBinding<JmsBindingDefinition>(referenceDefinition, source, deployable); referenceBinding.setAssigned(true); source.addBinding(referenceBinding); String callbackQueue = source.getUri().toString(); boolean callbackXa = isXA(target, true); new LogicalBinding<JmsBindingDefinition>(callbackReferenceDefinition, source, deployable); callbackReferenceBinding.setAssigned(true); source.addCallbackBinding(callbackReferenceBinding); JmsBindingDefinition callbackServiceDefinition = createBindingDefinition(callbackQueue, false, false); // XA not enabled on service side callback
public <T extends Binding> PhysicalWire generateReference(LogicalBinding<T> binding) { checkReference(binding); LogicalReference reference = (LogicalReference) binding.getParent(); LogicalComponent component = reference.getParent(); ServiceContract contract = reference.getServiceContract(); ServiceContract callbackContract = contract.getCallbackContract(); List<LogicalOperation> operations = reference.getOperations(); if (callbackContract != null) { Reference<ComponentType> referenceDefinition = reference.getDefinition(); URI callbackUri = generateCallbackUri(component, callbackContract, referenceDefinition.getName()); target.setCallbackUri(callbackUri);
private void generateBindings(LogicalReference reference, LogicalComponent<?> component, ConnectionCommand command) { boolean reinjection = isBoundReinjection(reference); for (LogicalBinding<?> logicalBinding : reference.getBindings()) { generateBinding(component, logicalBinding, command, reinjection, false); } if (reference.getServiceContract().getCallbackContract() != null) { boolean bindings = reference.isBound(); if (bindings) { List<LogicalBinding<?>> callbackBindings = reference.getCallbackBindings(); if (callbackBindings.isEmpty()) { // generate callback bindings as some transports do not require an explicit callback binding configuration on the reference generateCallbackBindings(reference); } if (callbackBindings.size() != 1) { // if the reference is explicitly bound, it must have one callback binding String uri = reference.getUri().toString(); throw new UnsupportedOperationException("The runtime requires exactly one callback binding to be specified on reference: " + uri); } LogicalBinding<?> callbackBinding = callbackBindings.get(0); generateBinding(component, callbackBinding, command, reinjection, true); } } }
public List<LogicalService> resolve(LogicalReference reference, LogicalCompositeComponent composite) { List<LogicalService> candidates = new ArrayList<>(); ServiceContract contract = reference.getServiceContract(); Multiplicity refMultiplicity = reference.getDefinition().getMultiplicity(); boolean multiplicity = Multiplicity.ZERO_N.equals(refMultiplicity) || Multiplicity.ONE_N.equals(refMultiplicity); for (LogicalComponent<?> child : composite.getComponents()) { if (reference.getParent() == child) {
private void generateBindings(LogicalReference reference, LogicalComponent<?> component, boolean incremental, ConnectionCommand command) throws GenerationException { boolean reinjection = isBoundReinjection(reference, incremental); for (LogicalBinding<?> logicalBinding : reference.getBindings()) { if (logicalBinding.getDefinition() instanceof SCABinding) { // skip SCA binding continue; } generateBinding(component, logicalBinding, command, incremental, reinjection, false); } if (reference.getServiceContract().getCallbackContract() != null) { boolean bindings = reference.isConcreteBound(); if (bindings) { List<LogicalBinding<?>> callbackBindings = reference.getCallbackBindings(); if (callbackBindings.isEmpty()) { // generate callback bindings as some transports do not require an explicit callback binding configuration on the reference generateCallbackBindings(reference); } if (callbackBindings.size() != 1) { // if the reference is explicitly bound, it must have one callback binding String uri = reference.getUri().toString(); throw new UnsupportedOperationException("The runtime requires exactly one callback binding to be specified on reference: " + uri); } LogicalBinding<?> callbackBinding = callbackBindings.get(0); generateBinding(component, callbackBinding, command, incremental, reinjection, true); } } }
public <T extends Binding> PhysicalWire generateReferenceCallback(LogicalBinding<T> binding) { checkReference(binding); LogicalReference reference = (LogicalReference) binding.getParent(); LogicalComponent<?> component = reference.getParent(); ServiceContract contract = reference.getServiceContract(); ServiceContract callbackContract = contract.getCallbackContract(); LogicalService callbackService = component.getService(callbackContract.getInterfaceName()); List<LogicalOperation> operations = reference.getCallbackOperations(); // generate the metadata used to attach the physical callback wire to the source transport WireBindingGenerator<T> sourceGenerator = getGenerator(binding); PhysicalWireSource source = sourceGenerator.generateSource(binding, callbackContract, operations); URI sourceUri = binding.getParent().getParent().getDefinition().getContributionUri(); source.setClassLoader(classLoaderRegistry.getClassLoader(sourceUri)); // generate the metadata used to attach the physical callback wire to the target component ComponentGenerator targetGenerator = getGenerator(component); PhysicalWireTarget target = targetGenerator.generateTarget(callbackService); URI targetUri = callbackService.getParent().getDefinition().getContributionUri(); target.setClassLoader(classLoaderRegistry.getClassLoader(targetUri)); target.setCallback(true); Set<PhysicalOperation> operation = operationGenerator.generateOperations(operations); return new PhysicalWire(source, target, operation); }
public PolicyResult resolveRemoteCallbackPolicies(LogicalWire wire) throws PolicyResolutionException { LogicalReference reference = wire.getSource(); LogicalComponent target = reference.getParent(); ServiceContract referenceContract = reference.getServiceContract(); ServiceContract referenceCallbackContract = referenceContract.getCallbackContract(); LogicalBinding<?> referenceBinding = reference.getCallbackBindings().get(0); LogicalService callbackService = target.getService(referenceCallbackContract.getInterfaceName()); List<LogicalOperation> operations = reference.getCallbackOperations(); LogicalBinding<LocalBindingDefinition> sourceBinding = new LogicalBinding<>(LocalBindingDefinition.INSTANCE, callbackService); return resolvePolicies(operations, sourceBinding, referenceBinding, null, target); }
public void generateWireSource(JavaWireSource source, LogicalReference reference) { URI uri = reference.getUri(); JavaServiceContract serviceContract = (JavaServiceContract) reference.getDefinition().getServiceContract(); source.setUri(uri); source.setInjectable(new Injectable(InjectableType.REFERENCE, uri.getFragment())); source.setInterfaceClass(serviceContract.getInterfaceClass()); // assume for now that any wire from a Java component can be optimized source.setOptimizable(true); if (reference.getDefinition().isKeyed()) { source.setKeyed(true); DataType type = reference.getDefinition().getKeyDataType(); String className = type.getType().getName(); source.setKeyClassName(className); } }
AbstractReference referenceDefinition = reference.getDefinition(); if (referenceDefinition.getAutowire() == Autowire.INHERITED) { reference.setAutowire(autowire); } else { autowire = referenceDefinition.getAutowire(); if (reference.getBindings().isEmpty()) { List<LogicalBinding<?>> newBindings = new ArrayList<LogicalBinding<?>>(); reference.overrideBindings(newBindings); } else { bindings = new ArrayList<LogicalBinding<?>>(); bindings.addAll(reference.getBindings()); if (reference.getIntents().isEmpty()) { reference.addIntents(intents); } else { intents = new HashSet<QName>(); intents.addAll(reference.getIntents()); if (reference.getPolicySets().isEmpty()) { reference.addPolicySets(policySets); } else { policySets = new HashSet<QName>(); policySets.addAll(reference.getPolicySets()); reference.setLeafReference(leafReference);
public PolicyResult resolveLocalCallbackPolicies(LogicalWire wire) throws PolicyResolutionException { LogicalReference reference = wire.getSource(); LogicalService service = wire.getTarget(); LogicalComponent<?> targetComponent = reference.getParent(); ServiceContract referenceCallbackContract = reference.getServiceContract().getCallbackContract(); LogicalService callbackService = targetComponent.getService(referenceCallbackContract.getInterfaceName()); LogicalBinding<LocalBindingDefinition> sourceBinding = new LogicalBinding<>(LocalBindingDefinition.INSTANCE, callbackService); LogicalBinding<LocalBindingDefinition> targetBinding = new LogicalBinding<>(LocalBindingDefinition.INSTANCE, reference); LogicalComponent sourceComponent = service.getLeafComponent(); return resolvePolicies(service.getCallbackOperations(), sourceBinding, targetBinding, sourceComponent, targetComponent); }
/** * Gets the explicit reference associated with this logical reference. * * @return Component reference if defined, otherwise null. */ public Reference<Component> getComponentReference() { return getParent().getDefinition().getReferences().get(getDefinition().getName()); }
private void resolveReferences(LogicalComponent<?> component, InstantiationContext context) { LogicalCompositeComponent parent = component.getParent(); for (LogicalReference reference : component.getReferences()) { if (reference.isBound()) { // reference is targeted using binding.sca or is explicitly bound so it should not be autowired continue; } Multiplicity multiplicityValue = reference.getDefinition().getMultiplicity(); boolean refMultiplicity = multiplicityValue.equals(Multiplicity.ZERO_N) || multiplicityValue.equals(Multiplicity.ONE_N); if (refMultiplicity || !reference.isResolved()) { // Only resolve references that have not been resolved or ones that are multiplicities since the latter may be reinjected. // Explicitly set the reference to unresolved, since if it was a multiplicity it may have been previously resolved. reference.setResolved(false); resolveReference(reference, parent, context); } } }
private boolean isBoundReinjection(LogicalReference logicalReference, boolean incremental) { Multiplicity multiplicity = logicalReference.getDefinition().getMultiplicity(); if (incremental && multiplicity == Multiplicity.ZERO_N || multiplicity == Multiplicity.ONE_N) { for (LogicalBinding<?> binding : logicalReference.getBindings()) { if (binding.getState() == LogicalState.NEW || binding.getState() == LogicalState.MARKED) { return true; } } } return false; }
private boolean isWireReinjection(LogicalReference logicalReference) { Multiplicity multiplicity = logicalReference.getDefinition().getMultiplicity(); if (multiplicity == Multiplicity.ZERO_N || multiplicity == Multiplicity.ONE_N) { for (LogicalWire wire : logicalReference.getWires()) { LogicalComponent<?> targetComponent = wire.getTarget().getParent(); // check the source and target sides since a target may have been added or removed if (wire.getState() == LogicalState.NEW || wire.getState() == LogicalState.MARKED || targetComponent.getState() == LogicalState.NEW || targetComponent.getState() == LogicalState.MARKED) { return true; } } } return false; }