public PhysicalWireTarget generateTarget(LogicalService service) throws Fabric3Exception { if (!(service.getDefinition() instanceof SpringService)) { // programming error throw new Fabric3Exception("Expected service type: " + service.getDefinition().getClass().getName()); } SpringService springService = (SpringService) service.getDefinition(); ServiceContract contract = springService.getServiceContract(); if (!(contract instanceof JavaServiceContract)) { // Spring service contracts are always defined by Java interfaces throw new Fabric3Exception("Unexpected interface type for " + service.getUri() + ": " + contract.getClass().getName()); } String target = springService.getTarget(); String interfaceName = contract.getQualifiedInterfaceName(); URI uri = service.getUri(); return new SpringWireTarget(target, interfaceName, uri); }
LogicalComponent<?> leafComponent = leafService.getParent(); List<LogicalBinding<?>> bindings = new ArrayList<LogicalBinding<?>>(); List<LogicalBinding<?>> callbackBindings = new ArrayList<LogicalBinding<?>>(); if (service.getBindings().isEmpty()) { service.overrideBindings(bindings); service.overrideCallbackBindings(callbackBindings); } else { bindings = new ArrayList<LogicalBinding<?>>(); bindings.addAll(service.getBindings()); callbackBindings = new ArrayList<LogicalBinding<?>>(); callbackBindings.addAll(service.getCallbackBindings()); if (service.getIntents().isEmpty()) { service.addIntents(intents); } else { intents = new HashSet<QName>(); intents.addAll(service.getIntents()); if (service.getPolicySets().isEmpty()) { service.addPolicySets(policySets); } else { policySets = new HashSet<QName>(); policySets.addAll(service.getPolicySets()); service.setLeafComponent(leafComponent); service.setLeafService(leafService);
String name = service.getName(); URI serviceUri = component.getUri().resolve('#' + name); LogicalService logicalService = new LogicalService(serviceUri, service, component); logicalService.setPromotedUri(URI.create(uriBase + service.getPromote())); logicalService.addBinding(logicalBinding); for (BindingDefinition binding : serviceCallbackBindings) { LogicalBinding<BindingDefinition> logicalBinding = new LogicalBinding<BindingDefinition>(binding, logicalService); logicalService.addCallbackBinding(logicalBinding); bindings.add(logicalBinding); logicalService.overrideBindings(bindings); callbackBindings.add(logicalBinding); logicalService.overrideCallbackBindings(callbackBindings); logicalService.addIntents(componentService.getIntents());
public PhysicalTargetDefinition generateTarget(LogicalService service, EffectivePolicy policy) throws GenerationException { if (!(service.getLeafService().getDefinition() instanceof SpringService)) { // programming error throw new GenerationException("Expected service type: " + service.getDefinition().getClass().getName()); } SpringService springService = (SpringService) service.getLeafService().getDefinition(); ServiceContract contract = springService.getServiceContract(); if (!(contract instanceof JavaServiceContract)) { // Spring service contracts are always defined by Java interfaces throw new GenerationException("Unexpected interface type for " + service.getUri() + ": " + contract.getClass().getName()); } String target = springService.getTarget(); String interfaceName = contract.getQualifiedInterfaceName(); URI uri = service.getUri(); return new SpringTargetDefinition(target, interfaceName, uri); }
public void bind(LogicalWire wire) throws BindingSelectionException { LogicalReference source = wire.getSource().getLeafReference(); LogicalService target = wire.getTarget().getLeafService(); QName deployable = source.getParent().getDeployable(); LogicalBinding<ZeroMQBindingDefinition> referenceBinding = new LogicalBinding<ZeroMQBindingDefinition>(referenceDefinition, source, deployable); referenceDefinition.setTargetUri(URI.create(UriHelper.getBaseName(target.getUri()))); referenceBinding.setAssigned(true); source.addBinding(referenceBinding); LogicalBinding<ZeroMQBindingDefinition> serviceBinding = new LogicalBinding<ZeroMQBindingDefinition>(serviceDefinition, target, deployable); serviceBinding.setAssigned(true); target.addBinding(serviceBinding); ServiceContract targetContract = target.getDefinition().getServiceContract(); if (targetContract.getCallbackContract() != null) { new LogicalBinding<ZeroMQBindingDefinition>(callbackServiceDefinition, target, deployable); callbackServiceBinding.setAssigned(true); target.addCallbackBinding(callbackServiceBinding);
/** * Adds a the resolved service * * @param service the service to add */ public void addService(LogicalService service) { services.put(service.getUri().getFragment(), service); }
private void generatePhysicalWires(LogicalComponent<?> component, ConnectionCommand command) { for (LogicalService service : component.getServices()) { if (service.getBindings().isEmpty()) { continue; ServiceContract callbackContract = service.getServiceContract().getCallbackContract(); LogicalBinding<?> callbackBinding = null; URI callbackUri = null; if (callbackContract != null) { List<LogicalBinding<?>> callbackBindings = service.getCallbackBindings(); String uri = service.getUri().toString(); throw new UnsupportedOperationException("The runtime requires exactly one callback binding to be specified on service: " + uri); for (LogicalBinding<?> binding : service.getBindings()) { if (binding.getState() == LogicalState.NEW || binding.getState() == LogicalState.MARKED) { PhysicalWire physicalWire = wireGenerator.generateService(binding, callbackUri);
private <S extends LogicalComponent<?>> URI generateCallbackUri(S source, ServiceContract contract, String referenceName) { LogicalService candidate = null; for (LogicalService entry : source.getServices()) { MatchResult result = matcher.isAssignableFrom(contract, entry.getServiceContract(), false); if (result.isAssignable()) { candidate = entry; break; } } if (candidate == null) { String name = contract.getInterfaceName(); URI uri = source.getUri(); throw new Fabric3Exception("Callback service not found: " + name + " on component: " + uri + " originating from reference :" + referenceName); } return URI.create(source.getUri().toString() + "#" + candidate.getDefinition().getName()); }
/** * Validates the reference and service contracts match. * * @param reference the reference * @param service the service * @param context the logical context */ private void validateContracts(LogicalReference reference, LogicalService service, InstantiationContext context) { ServiceContract referenceContract = reference.getServiceContract(); ServiceContract serviceContract = service.getServiceContract(); MatchResult result = matcher.isAssignableFrom(referenceContract, serviceContract, true); if (!result.isAssignable()) { URI serviceUri = service.getUri(); String message = result.getError(); IncompatibleContracts error = new IncompatibleContracts(reference, serviceUri, message); context.addError(error); } }
@SuppressWarnings("unchecked") private void generateCallbackBindings(LogicalService service) { for (LogicalBinding<?> logicalBinding : service.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.generateServiceCallback(logicalBinding); definition.setParent(service.getDefinition()); LogicalBinding<?> logicalCallback = new LogicalBinding(definition, service); service.addCallbackBinding(logicalCallback); } }
checkService(binding); LogicalService service = (LogicalService) binding.getParent(); LogicalComponent<?> component = service.getLeafComponent(); ServiceContract contract = service.getLeafService().getServiceContract(); List<LogicalOperation> operations = service.getOperations(); targetDefinition.setClassLoaderId(service.getParent().getDefinition().getContributionUri()); targetDefinition.setCallbackUri(callbackUri); sourceDefinition.setClassLoaderId(service.getParent().getDefinition().getContributionUri());
ServiceContract targetContract = service.getServiceContract(); if (targetContract == null) { throw new AssertionError("No service contract specified on service: " + service.getUri()); boolean intentsMatch = true; for (QName intent : logicalReference.getIntents()) { if (!service.getIntents().contains(intent)) { intentsMatch = false; break; QName deployable = target.getParent().getDeployable(); for (LogicalWire existingWire : existingWires) { if (LogicalState.PROVISIONED == existingWire.getTarget().getLeafComponent().getState()) { existingWire.setState(LogicalState.NEW);
public <T extends Binding> PhysicalWire generateService(LogicalBinding<T> binding, URI callbackUri) { checkService(binding); LogicalService service = (LogicalService) binding.getParent(); LogicalComponent<?> component = service.getParent(); ServiceContract contract = service.getServiceContract(); List<LogicalOperation> operations = service.getOperations(); // generate the metadata used to attach the physical wire to the target component ComponentGenerator targetGenerator = getGenerator(component); PhysicalWireTarget target = targetGenerator.generateTarget(service); URI targetUri = service.getParent().getDefinition().getContributionUri(); target.setClassLoader(classLoaderRegistry.getClassLoader(targetUri)); target.setCallbackUri(callbackUri); // generate the metadata used to attach the physical wire to the source transport WireBindingGenerator<T> sourceGenerator = getGenerator(binding); PhysicalWireSource source = sourceGenerator.generateSource(binding, contract, operations); URI sourceUri = service.getParent().getDefinition().getContributionUri(); source.setClassLoader(classLoaderRegistry.getClassLoader(sourceUri)); // generate the metadata for interceptors that are attached to wire invocation chains, e.g. policy implemented by an interceptor Set<PhysicalOperation> physicalOperations = operationGenerator.generateOperations(operations); PhysicalWire physicalWire = new PhysicalWire(source, target, physicalOperations); boolean optimizable = source.isOptimizable() && target.isOptimizable() && checkOptimization(contract, physicalOperations); physicalWire.setOptimizable(optimizable); return physicalWire; }
private void raiseNoServiceError(LogicalService service, URI uri, InstantiationContext context) { LogicalComponent<?> parent = service.getParent(); String msg = "No services available on component: " + uri; NoServiceOnComponent error = new NoServiceOnComponent(msg, parent); context.addError(error); }
for (LogicalOperation operation : service.getCallbackOperations()) { if (containsTransactionIntent(operation.getIntents())) { return true; for (LogicalOperation operation : service.getOperations()) { if (containsTransactionIntent(operation.getIntents())) { return true; LogicalComponent<?> parent = service.getParent(); while (parent != null) { if (containsTransactionIntent(parent.getIntents())) {
void resolve(LogicalService logicalService, InstantiationContext context) { URI promotedUri = logicalService.getPromotedUri(); String promotedServiceName = promotedUri.getFragment(); LogicalCompositeComponent composite = (LogicalCompositeComponent) logicalService.getParent(); LogicalComponent<?> promotedComponent = composite.getComponent(promotedComponentUri); raiseAmbiguousServiceError(logicalService, promotedComponentUri, context); } else { logicalService.setPromotedUri(componentServices.iterator().next().getUri());
/** * Updates the list of services with the promotion hierarchy for the given service. The list is populated in reverse order so that the leaf * (promoted) service is stored last. * * @param service the current service to ascend from * @param services the list */ private void getPromotionHierarchy(LogicalService service, LinkedList<LogicalService> services) { LogicalComponent<CompositeImplementation> parent = service.getParent().getParent(); URI serviceUri = service.getUri(); for (LogicalService promotion : parent.getServices()) { URI targetUri = promotion.getPromotedUri(); if (targetUri.getFragment() == null) { // no service specified if (targetUri.equals(UriHelper.getDefragmentedName(serviceUri))) { services.addFirst(promotion); if (parent.getParent() != null) { getPromotionHierarchy(promotion, services); } } } else { if (targetUri.equals(serviceUri)) { services.addFirst(promotion); if (parent.getParent() != null) { getPromotionHierarchy(promotion, services); } } } } }
target.getBindings().clear(); provider.bind(wire); if (source.getLeafReference().getBindings().isEmpty()) { throw new BindingSelectionException("Binding provider error. Provider did not set a binding for the reference: " + type); if (target.getLeafService().getBindings().isEmpty()) { QName type = result.getType(); throw new BindingSelectionException("Binding provider error. Provider did not set a binding for the service: " + type); if (!target.getBindings().isEmpty()) { wire.setTargetBinding(target.getBindings().get(0)); } else { wire.setTargetBinding(target.getLeafService().getBindings().get(0)); URI targetUri = target.getUri(); throw new NoSCABindingProviderException("No SCA binding provider suitable for creating wire from " + sourceUri + " to " + targetUri, results);
processIntents(service.getIntents(), aggregatedIntents); LogicalComponent<?> parent = service.getParent(); LogicalCompositeComponent compositeParent = (LogicalCompositeComponent) parent; for (LogicalService logicalService : compositeParent.getServices()) { if (logicalService.getPromotedUri().equals(currentService.getUri())) { processIntents(logicalService.getIntents(), aggregatedIntents); currentService = logicalService;
@SuppressWarnings({"unchecked"}) public PhysicalWireSource generateCallbackSource(LogicalService service) { JavaWireSource source = new JavaWireSource(); JavaServiceContract callbackContract = (JavaServiceContract) service.getDefinition().getServiceContract().getCallbackContract(); LogicalComponent<JavaImplementation> component = (LogicalComponent<JavaImplementation>) service.getParent(); generationHelper.generateCallbackWireSource(source, component, callbackContract); return source; }