public void generateConnectionSource(JavaConnectionSource source, LogicalProducer producer) { URI uri = producer.getUri(); source.setUri(uri); ServiceContract serviceContract = producer.getDefinition().getServiceContract(); Class<?> interfaze = serviceContract.getInterfaceClass(); source.setInjectable(new Injectable(InjectableType.PRODUCER, uri.getFragment())); source.setServiceInterface(interfaze); }
public PhysicalConnectionSourceDefinition generateConnectionSource(LogicalProducer producer) throws GenerationException { String producerName = producer.getDefinition().getName(); URI uri = producer.getParent().getUri(); ServiceContract serviceContract = producer.getDefinition().getServiceContract(); String interfaceName = serviceContract.getQualifiedInterfaceName(); return new SpringConnectionSourceDefinition(producerName, interfaceName, uri); }
private <T> LogicalProducer createProducer(Class<T> interfaze, URI channelUri) throws Fabric3Exception { JavaServiceContract contract = introspector.introspect(interfaze); LogicalCompositeComponent domain = lcm.getDomainComposite(); String root = domain.getUri().toString(); LogicalComponent<NonManagedImplementation> logicalComponent = createComponent(interfaze, domain, root); Producer producer = new Producer("producer", contract); int pos = counter.getAndIncrement(); LogicalProducer logicalProducer = new LogicalProducer(URI.create(root + "/F3Synthetic#producer" + pos), producer, logicalComponent); logicalProducer.setServiceContract(contract); logicalProducer.addTarget(channelUri); return logicalProducer; }
private Class<?> getType(LogicalProducer producer) { Operation operation = producer.getStreamOperation().getDefinition(); List<DataType> params = operation.getInputTypes(); if (params.size() != 1) { String interfaceName = producer.getServiceContract().getQualifiedInterfaceName(); throw new Fabric3Exception("A channel interface must have one parameter: operation " + operation.getName() + " on " + interfaceName); } return params.get(0).getType(); }
private void generateCommand(LogicalProducer producer, ChannelConnectionCommand command, boolean incremental) throws GenerationException { LogicalComponent<?> component = producer.getParent(); QName deployable = producer.getParent().getDeployable(); if (LogicalState.MARKED == component.getState()) { Map<LogicalChannel, ChannelDeliveryType> channels = new HashMap<LogicalChannel, ChannelDeliveryType>(); for (URI uri : producer.getTargets()) { LogicalChannel channel = InvocableGeneratorHelper.getChannelInHierarchy(uri, producer); DisposeChannelCommand disposeCommand = channelGenerator.generateDispose(channel, deployable, PRODUCER); for (URI uri : producer.getTargets()) { LogicalChannel channel = InvocableGeneratorHelper.getChannelInHierarchy(uri, producer); BuildChannelCommand buildCommand = channelGenerator.generateBuild(channel, deployable, PRODUCER);
@SuppressWarnings({"unchecked"}) public List<PhysicalChannelConnectionDefinition> generateProducer(LogicalProducer producer, Map<LogicalChannel, ChannelDeliveryType> channels) throws GenerationException { List<PhysicalChannelConnectionDefinition> definitions = new ArrayList<PhysicalChannelConnectionDefinition>(); LogicalComponent<?> component = producer.getParent(); ComponentGenerator<?> componentGenerator = getGenerator(component); PhysicalConnectionSourceDefinition sourceDefinition = componentGenerator.generateConnectionSource(producer); URI classLoaderId = component.getDefinition().getContributionUri(); sourceDefinition.setClassLoaderId(classLoaderId); PhysicalEventStreamDefinition eventStream = generate(producer.getStreamOperation()); for (Map.Entry<LogicalChannel, ChannelDeliveryType> entry : channels.entrySet()) { LogicalChannel channel = entry.getKey(); if (!channel.isBound()) { PhysicalChannelConnectionDefinition definition = generateProducerConnection(producer, channel, sourceDefinition, classLoaderId, eventStream); definitions.add(definition); } else { PhysicalChannelConnectionDefinition producerDefinition = generateProducerConnection(producer, channel, sourceDefinition, classLoaderId, eventStream); definitions.add(producerDefinition); ChannelDeliveryType deliveryType = entry.getValue(); PhysicalChannelConnectionDefinition bindingDefinition = generateProducerBinding(producer, channel, deliveryType, classLoaderId, eventStream); definitions.add(bindingDefinition); } } return definitions; }
private void createProducers(ComponentDefinition<?> definition, LogicalComponent<?> component, ComponentType componentType) { for (ProducerDefinition producer : componentType.getProducers().values()) { String name = producer.getName(); URI producerUri = component.getUri().resolve('#' + name); LogicalProducer logicalProducer = new LogicalProducer(producerUri, producer, component); // producer is configured in the component definition ComponentProducer componentProducer = definition.getProducers().get(name); if (componentProducer != null) { logicalProducer.addIntents(componentProducer.getIntents()); // TODO refactor this: URIs should be resolved to channels by a separate service that also handles promotion for (URI uri : componentProducer.getTargets()) { if (uri.isAbsolute()) { LogicalComponent<?> domain = component.getParent(); while (domain.getParent() != null) { domain = domain.getParent(); } logicalProducer.addTarget(URI.create(domain.getUri().toString() + "/" + uri.getAuthority())); } else { logicalProducer.addTarget(URI.create(component.getParent().getUri().toString() + "/" + uri.toString())); } } } component.addProducer(logicalProducer); } }
private <T> LogicalProducer createProducer(Class<T> interfaze, URI channelUri) throws InterfaceException { JavaServiceContract contract = introspector.introspect(interfaze); LogicalCompositeComponent domainComponent = lcm.getRootComponent(); String domainRoot = domainComponent.getUri().toString(); URI componentUri = URI.create(domainRoot + "/F3Synthetic"); InjectingComponentType componentType = new InjectingComponentType(); NonManagedImplementation implementation = new NonManagedImplementation(); implementation.setComponentType(componentType); ComponentDefinition<NonManagedImplementation> componentDefinition = new ComponentDefinition<>("F3Synthetic"); componentDefinition.setContributionUri(ContributionResolver.getContribution(interfaze)); componentDefinition.setImplementation(implementation); LogicalComponent<NonManagedImplementation> logicalComponent = new LogicalComponent<>(componentUri, componentDefinition, domainComponent); ProducerDefinition producerDefinition = new ProducerDefinition("producer", contract); LogicalProducer producer = new LogicalProducer(URI.create(domainRoot + "/F3Synthetic#producer"), producerDefinition, logicalComponent); producer.addTarget(channelUri); return producer; }
private PhysicalChannelConnectionDefinition generateProducerConnection(LogicalProducer producer, LogicalChannel channel, PhysicalConnectionSourceDefinition sourceDefinition, URI classLoaderId, PhysicalEventStreamDefinition eventStream) throws GenerationException { if (!channel.getZone().equals(producer.getParent().getZone()) && !channel.isBound()) { String name = channel.getDefinition().getName(); throw new GenerationException("Binding not configured on a channel where the producer is in a different zone: " + name); } PhysicalConnectionTargetDefinition targetDefinition = new ChannelTargetDefinition(channel.getUri(), ChannelSide.PRODUCER); targetDefinition.setClassLoaderId(classLoaderId); return new PhysicalChannelConnectionDefinition(sourceDefinition, targetDefinition, eventStream); }
private List<PhysicalChannelConnection> generateDirectConnections(LogicalProducer producer, Map<LogicalChannel, DeliveryType> channels, PhysicalConnectionSource source, ClassLoader classLoader) { List<PhysicalChannelConnection> connections = new ArrayList<>(); Class<?> type = producer.getDefinition().getServiceContract().getInterfaceClass(); for (Map.Entry<LogicalChannel, DeliveryType> entry : channels.entrySet()) { LogicalChannel channel = entry.getKey(); if (!channel.isBound()) { PhysicalChannelConnection producerConnection = generateLocalConnection(producer, type, channel, source, classLoader); connections.add(producerConnection); } else { DeliveryType deliveryType = entry.getValue(); PhysicalChannelConnection bindingConnection = generateDirectBoundConnection(producer, channel, deliveryType, classLoader, source); connections.add(bindingConnection); } } return connections; }
private void addTarget(LogicalProducer logicalProducer, URI uri, LogicalComponent<?> logicalComponent) { if (uri.isAbsolute()) { LogicalComponent<?> domain = logicalComponent.getParent(); while (domain.getParent() != null) { domain = domain.getParent(); } logicalProducer.addTarget(URI.create(domain.getUri().toString() + "/" + uri.getAuthority())); } else { logicalProducer.addTarget(URI.create(logicalComponent.getParent().getUri().toString() + "/" + uri.toString())); } }
private void createProducers(Component<?> component, LogicalComponent<?> logicalComponent, ComponentType componentType) { for (Producer<ComponentType> producer : componentType.getProducers().values()) { String name = producer.getName(); URI producerUri = logicalComponent.getUri().resolve('#' + name); LogicalProducer logicalProducer = new LogicalProducer(producerUri, producer, logicalComponent); // producer is configured in the logicalComponent definition Producer<Component> componentProducer = component.getProducers().get(name); if (componentProducer != null) { for (URI uri : componentProducer.getTargets()) { addTarget(logicalProducer, uri, logicalComponent); } } else { for (URI uri : producer.getTargets()) { addTarget(logicalProducer, uri, logicalComponent); } } logicalComponent.addProducer(logicalProducer); } }
public PhysicalConnectionSource generateConnectionSource(LogicalProducer producer) { Class<?> interfaze = producer.getServiceContract().getInterfaceClass(); URI uri = URI.create("nonManaged" + ++counter); return new NonManagedConnectionSource(uri, interfaze); }
public PhysicalConnectionTarget generateConnectionTarget(LogicalProducer producer, LogicalBinding<JmsBinding> binding, DeliveryType deliveryType) { URI uri = binding.getDefinition().getTargetUri(); JmsBindingMetadata metadata = binding.getDefinition().getJmsMetadata().snapshot(); JmsGeneratorHelper.generateDefaultFactoryConfiguration(metadata.getConnectionFactory(), SessionType.AUTO_ACKNOWLEDGE); DataType type = isJAXB(producer.getStreamOperation().getDefinition().getInputTypes().get(0)) ? PhysicalDataTypes.JAXB : PhysicalDataTypes.JAVA_TYPE; JmsConnectionTarget target = new JmsConnectionTarget(uri, metadata, type); if (provisioner != null) { provisioner.generateConnectionTarget(target); } return target; }
public int hashCode() { return getUri().hashCode(); }
private void generateCommand(LogicalProducer producer, ChannelConnectionCommand command) { LogicalComponent<?> component = producer.getParent(); URI contributionUri = producer.getParent().getDefinition().getContributionUri(); if (LogicalState.MARKED == component.getState()) { Map<LogicalChannel, DeliveryType> channels = new HashMap<>(); for (URI uri : producer.getTargets()) { LogicalChannel channel = InvocableGeneratorHelper.getChannelInHierarchy(uri, producer); DisposeChannelCommand disposeCommand = channelGenerator.generateDispose(channel, contributionUri, PRODUCER); for (URI uri : producer.getTargets()) { LogicalChannel channel = InvocableGeneratorHelper.getChannelInHierarchy(uri, producer); BuildChannelCommand buildCommand = channelGenerator.generateBuild(channel, contributionUri, PRODUCER);
@SuppressWarnings({"unchecked"}) public List<PhysicalChannelConnection> generateProducer(LogicalProducer producer, Map<LogicalChannel, DeliveryType> channels) { LogicalComponent<?> component = producer.getParent(); ComponentGenerator<?> componentGenerator = getGenerator(component); PhysicalConnectionSource source = componentGenerator.generateConnectionSource(producer); URI classLoaderId = component.getDefinition().getContributionUri(); ClassLoader classLoader = classLoaderRegistry.getClassLoader(classLoaderId); source.setClassLoader(classLoader); if (isDirect(producer, channels)) { source.setDirectConnection(true); return generateDirectConnections(producer, channels, source, classLoader); } else { return generateConnections(producer, channels, source, classLoader); } }
private Class<?> getType(LogicalProducer producer) { Operation operation = producer.getStreamOperation().getDefinition(); List<DataType> params = operation.getInputTypes(); if (params.size() != 1) { String interfaceName = producer.getServiceContract().getQualifiedInterfaceName(); throw new Fabric3Exception("A channel interface must have one parameter: operation " + operation.getName() + " on " + interfaceName); } return params.get(0).getType(); }
private List<PhysicalChannelConnection> generateDirectConnections(LogicalProducer producer, Map<LogicalChannel, DeliveryType> channels, PhysicalConnectionSource source, ClassLoader classLoader) { List<PhysicalChannelConnection> connections = new ArrayList<>(); Class<?> type = producer.getDefinition().getServiceContract().getInterfaceClass(); for (Map.Entry<LogicalChannel, DeliveryType> entry : channels.entrySet()) { LogicalChannel channel = entry.getKey(); if (!channel.isBound()) { PhysicalChannelConnection producerConnection = generateLocalConnection(producer, type, channel, source, classLoader); connections.add(producerConnection); } else { DeliveryType deliveryType = entry.getValue(); PhysicalChannelConnection bindingConnection = generateDirectBoundConnection(producer, channel, deliveryType, classLoader, source); connections.add(bindingConnection); } } return connections; }