@SuppressWarnings({"unchecked"}) public PhysicalConnectionTarget generateConnectionTarget(LogicalConsumer consumer) throws Fabric3Exception { SpringConsumer springConsumer = (SpringConsumer) consumer.getDefinition(); String beanName = springConsumer.getBeanName(); String methodName = springConsumer.getMethodName(); JavaType type = springConsumer.getType(); URI uri = consumer.getParent().getUri(); return new SpringConnectionTarget(beanName, methodName, type, uri); }
private <T> LogicalConsumer createConsumer(Class<T> type, URI channelUri) { JavaServiceContract contract = introspector.introspect(type); LogicalCompositeComponent domain = lcm.getDomainComposite(); String root = domain.getUri().toString(); LogicalComponent<NonManagedImplementation> logicalComponent = createComponent(Object.class, domain, root); DataType dataType = new JavaType(type); Consumer consumer = new Consumer("consumer", dataType, true); int pos = counter.getAndIncrement(); LogicalConsumer logicalConsumer = new LogicalConsumer(URI.create(root + "/F3Synthetic#consumer" + pos), consumer, logicalComponent); logicalConsumer.setServiceContract(contract); logicalConsumer.addSource(channelUri); return logicalConsumer; }
private void createConsumers(ComponentDefinition<?> definition, LogicalComponent<?> component, ComponentType componentType) { for (ConsumerDefinition consumer : componentType.getConsumers().values()) { String name = consumer.getName(); URI consumerUri = component.getUri().resolve('#' + name); LogicalConsumer logicalConsumer = new LogicalConsumer(consumerUri, consumer, component); // producer is configured in the component definition ComponentConsumer componentConsumer = definition.getConsumers().get(name); if (componentConsumer != null) { logicalConsumer.addIntents(componentConsumer.getIntents()); // TODO refactor this: URIs should be resolved to channels by a separate service that also handles promotion for (URI uri : componentConsumer.getSources()) { if (uri.isAbsolute()) { LogicalComponent<?> domain = component.getParent(); while (domain.getParent() != null) { domain = domain.getParent(); } logicalConsumer.addSource(URI.create(domain.getUri().toString() + "/" + uri.getAuthority())); } else { logicalConsumer.addSource(URI.create(component.getParent().getUri().toString() + "/" + uri.toString())); } } } component.addConsumer(logicalConsumer); } }
private PhysicalChannelConnection generateLocalConnection(LogicalConsumer consumer, LogicalChannel channel, PhysicalConnectionTarget target, ClassLoader classLoader) { // the channel does not have bindings, which means it is a local channel // construct a local connection to the channel URI uri = channel.getUri(); PhysicalConnectionSource source = new ChannelSource(uri, ChannelSide.CONSUMER); source.setSequence(consumer.getDefinition().getSequence()); source.setClassLoader(classLoader); Class<?> type = getType(consumer); boolean bound = channel.isBound(); return new PhysicalChannelConnection(uri, consumer.getUri(), source, target, type, bound); }
@SuppressWarnings({"unchecked"}) public void generateConnectionTarget(JavaConnectionTarget target, LogicalConsumer consumer) { // Create an injectable for the consumer. Note in cases where the consumer is a method that is connected via an event stream and is used to receive // events rather than act as a setter for a direct connection, the injector will never be activated. Injectable injectable = new Injectable(InjectableType.CONSUMER, consumer.getUri().getFragment()); target.setInjectable(injectable); LogicalComponent<? extends JavaImplementation> component = (LogicalComponent<? extends JavaImplementation>) consumer.getParent(); URI uri = component.getUri(); target.setUri(uri); ServiceContract serviceContract = consumer.getDefinition().getServiceContract(); Class<?> interfaze = serviceContract.getInterfaceClass(); target.setServiceInterface(interfaze); InjectingComponentType type = component.getDefinition().getImplementation().getComponentType(); AccessibleObject object = type.getConsumerSite(consumer.getUri().getFragment()); if (object == null) { // programming error throw new Fabric3Exception("Consumer not found on: " + consumer.getUri()); } target.setConsumerSite(object); }
@SuppressWarnings({"unchecked"}) public PhysicalConnectionTarget generateConnectionTarget(LogicalConsumer consumer) throws Fabric3Exception { SystemConnectionTarget target = new SystemConnectionTarget(); LogicalComponent<? extends SystemImplementation> component = (LogicalComponent<? extends SystemImplementation>) consumer.getParent(); URI uri = component.getUri(); target.setUri(uri); InjectingComponentType type = component.getDefinition().getImplementation().getComponentType(); AccessibleObject object = type.getConsumerSite(consumer.getUri().getFragment()); if (object == null) { // programming error throw new Fabric3Exception("Consumer not found on: " + consumer.getUri()); } target.setConsumerSite(object); return target; }
private void generateCommand(LogicalConsumer consumer, ChannelConnectionCommand command, boolean incremental) throws GenerationException { LogicalComponent<?> component = consumer.getParent(); QName deployable = consumer.getParent().getDeployable(); if (LogicalState.MARKED == component.getState()) { Map<LogicalChannel, ChannelDeliveryType> channels = new HashMap<LogicalChannel, ChannelDeliveryType>(); for (URI uri : consumer.getSources()) { LogicalChannel channel = InvocableGeneratorHelper.getChannelInHierarchy(uri, consumer); DisposeChannelCommand disposeCommand = channelGenerator.generateDispose(channel, deployable, CONSUMER); for (URI uri : consumer.getSources()) { LogicalChannel channel = InvocableGeneratorHelper.getChannelInHierarchy(uri, consumer); BuildChannelCommand buildCommand = channelGenerator.generateBuild(channel, deployable, CONSUMER);
public List<PhysicalChannelConnectionDefinition> generateConsumer(LogicalConsumer consumer, Map<LogicalChannel, ChannelDeliveryType> channels) throws GenerationException { List<PhysicalChannelConnectionDefinition> definitions = new ArrayList<PhysicalChannelConnectionDefinition>(); LogicalComponent<?> component = consumer.getParent(); ComponentGenerator<?> generator = getGenerator(component); PhysicalConnectionTargetDefinition targetDefinition = generator.generateConnectionTarget(consumer); URI classLoaderId = component.getDefinition().getContributionUri(); targetDefinition.setClassLoaderId(classLoaderId); PhysicalEventStreamDefinition eventStream = generateEventStream(consumer); generatePolicy(consumer, eventStream); for (Map.Entry<LogicalChannel, ChannelDeliveryType> entry : channels.entrySet()) { LogicalChannel channel = entry.getKey(); if (!channel.isBound()) { PhysicalChannelConnectionDefinition definition = generateConsumerConnection(consumer, channel, targetDefinition, classLoaderId, eventStream); definitions.add(definition); } else { PhysicalChannelConnectionDefinition consumerConnection = generateConsumerConnection(consumer, channel, targetDefinition, classLoaderId, eventStream); definitions.add(consumerConnection); ChannelDeliveryType deliveryType = entry.getValue(); PhysicalChannelConnectionDefinition bindingDefinition = generateConsumerBinding(consumer, channel, deliveryType, classLoaderId, eventStream); definitions.add(bindingDefinition); } } return definitions; }
private Class<?> getType(LogicalConsumer consumer) { Consumer<?> consumerDefinition = consumer.getDefinition(); return consumerDefinition.getType().getType(); }
private void createConsumers(Component<?> definition, LogicalComponent<?> logicalComponent, ComponentType componentType) { for (Consumer<ComponentType> consumer : componentType.getConsumers().values()) { String name = consumer.getName(); URI consumerUri = logicalComponent.getUri().resolve('#' + name); LogicalConsumer logicalConsumer = new LogicalConsumer(consumerUri, consumer, logicalComponent); // producer is configured in the logicalComponent definition Consumer<Component> componentConsumer = definition.getConsumers().get(name); if (componentConsumer != null) { for (URI uri : componentConsumer.getSources()) { addSource(logicalConsumer, uri, logicalComponent); } } else { for (URI uri : consumer.getSources()) { addSource(logicalConsumer, uri, logicalComponent); } } logicalConsumer.setServiceContract(consumer.getServiceContract()); logicalComponent.addConsumer(logicalConsumer); } }
private void addSource(LogicalConsumer logicalConsumer, URI uri, LogicalComponent<?> logicalComponent) { if (uri.isAbsolute()) { LogicalComponent<?> domain = logicalComponent.getParent(); while (domain.getParent() != null) { domain = domain.getParent(); } logicalConsumer.addSource(URI.create(domain.getUri().toString() + "/" + uri.getAuthority())); } else { logicalConsumer.addSource(URI.create(logicalComponent.getParent().getUri().toString() + "/" + uri.toString())); } }
public PhysicalConnectionTarget generateConnectionTarget(LogicalConsumer consumer) { Class<?> interfaze = consumer.getServiceContract().getInterfaceClass(); URI uri = URI.create("nonManaged" + ++counter); return new NonManagedConnectionTarget(uri, interfaze); }
private PhysicalChannelConnection generateLocalConnection(LogicalConsumer consumer, LogicalChannel channel, PhysicalConnectionTarget target, ClassLoader classLoader) { // the channel does not have bindings, which means it is a local channel // construct a local connection to the channel URI uri = channel.getUri(); PhysicalConnectionSource source = new ChannelSource(uri, ChannelSide.CONSUMER); source.setSequence(consumer.getDefinition().getSequence()); source.setClassLoader(classLoader); Class<?> type = getType(consumer); boolean bound = channel.isBound(); return new PhysicalChannelConnection(uri, consumer.getUri(), source, target, type, bound); }
private void generateCommand(LogicalConsumer consumer, ChannelConnectionCommand command) { LogicalComponent<?> component = consumer.getParent(); URI contributionUri = consumer.getParent().getDefinition().getContributionUri(); if (LogicalState.MARKED == component.getState()) { Map<LogicalChannel, DeliveryType> channels = new HashMap<>(); for (URI uri : consumer.getSources()) { LogicalChannel channel = InvocableGeneratorHelper.getChannelInHierarchy(uri, consumer); DisposeChannelCommand disposeCommand = channelGenerator.generateDispose(channel, contributionUri, CONSUMER); for (URI uri : consumer.getSources()) { LogicalChannel channel = InvocableGeneratorHelper.getChannelInHierarchy(uri, consumer); BuildChannelCommand buildCommand = channelGenerator.generateBuild(channel, contributionUri, CONSUMER);
public List<PhysicalChannelConnection> generateConsumer(LogicalConsumer consumer, Map<LogicalChannel, DeliveryType> channels) { LogicalComponent<?> component = consumer.getParent(); ComponentGenerator<?> generator = getGenerator(component); PhysicalConnectionTarget target = generator.generateConnectionTarget(consumer); URI classLoaderId = component.getDefinition().getContributionUri(); ClassLoader classLoader = classLoaderRegistry.getClassLoader(classLoaderId); target.setClassLoader(classLoader); if (isDirect(consumer, channels)) { target.setDirectConnection(true); return generateDirectConnections(consumer, channels, target, classLoader); } else { return generateConnections(consumer, channels, target, classLoader); } }
private Class<?> getType(LogicalConsumer consumer) { Consumer<?> consumerDefinition = consumer.getDefinition(); return consumerDefinition.getType().getType(); }
private void createConsumers(Component<?> definition, LogicalComponent<?> logicalComponent, ComponentType componentType) { for (Consumer<ComponentType> consumer : componentType.getConsumers().values()) { String name = consumer.getName(); URI consumerUri = logicalComponent.getUri().resolve('#' + name); LogicalConsumer logicalConsumer = new LogicalConsumer(consumerUri, consumer, logicalComponent); // producer is configured in the logicalComponent definition Consumer<Component> componentConsumer = definition.getConsumers().get(name); if (componentConsumer != null) { for (URI uri : componentConsumer.getSources()) { addSource(logicalConsumer, uri, logicalComponent); } } else { for (URI uri : consumer.getSources()) { addSource(logicalConsumer, uri, logicalComponent); } } logicalConsumer.setServiceContract(consumer.getServiceContract()); logicalComponent.addConsumer(logicalConsumer); } }
private void addSource(LogicalConsumer logicalConsumer, URI uri, LogicalComponent<?> logicalComponent) { if (uri.isAbsolute()) { LogicalComponent<?> domain = logicalComponent.getParent(); while (domain.getParent() != null) { domain = domain.getParent(); } logicalConsumer.addSource(URI.create(domain.getUri().toString() + "/" + uri.getAuthority())); } else { logicalConsumer.addSource(URI.create(logicalComponent.getParent().getUri().toString() + "/" + uri.toString())); } }
public PhysicalConnectionTarget generateConnectionTarget(LogicalConsumer consumer) { Class<?> interfaze = consumer.getServiceContract().getInterfaceClass(); URI uri = URI.create("nonManaged" + ++counter); return new NonManagedConnectionTarget(uri, interfaze); }