protected override AbstractObjectDefinition ParseInternal(XmlElement element, ParserContext parserContext)
        {
            ObjectDefinitionBuilder metadataBuilder = ObjectDefinitionBuilder.GenericObjectDefinition(IntegrationNamespaceUtils.SCHEDULING_PACKAGE + ".PollerMetadata");

            if (element.HasAttribute("ref"))
            {
                parserContext.ReaderContext.ReportException(element, element.Name, "the 'ref' attribute must not be present on a 'poller' element submitted to the parser");
            }
            ConfigureTrigger(element, metadataBuilder, parserContext);
            IntegrationNamespaceUtils.SetValueIfAttributeDefined(metadataBuilder, element, "max-messages-per-poll");
            XmlElement adviceChainElement = DomUtils.GetChildElementByTagName(element, "advice-chain");

            if (adviceChainElement != null)
            {
                ConfigureAdviceChain(adviceChainElement, metadataBuilder, parserContext);
            }
            XmlElement txElement = DomUtils.GetChildElementByTagName(element, "transactional");

            if (txElement != null)
            {
                ConfigureTransactionAttributes(txElement, metadataBuilder);
            }
            IntegrationNamespaceUtils.SetReferenceIfAttributeDefined(metadataBuilder, element, "task-executor");
            return(metadataBuilder.ObjectDefinition);
        }
        protected override ObjectDefinitionBuilder BuildObjectDefinition(XmlElement element, ParserContext parserContext)
        {
            ObjectDefinitionBuilder builder;
            XmlElement queueElement;

            if ((queueElement = DomUtils.GetChildElementByTagName(element, "queue")) != null)
            {
                builder = ObjectDefinitionBuilder.GenericObjectDefinition(IntegrationNamespaceUtils.CHANNEL_PACKAGE + ".QueueChannel");
                ParseQueueCapacity(builder, queueElement);
            }
            else if ((queueElement = DomUtils.GetChildElementByTagName(element, "priority-queue")) != null)
            {
                builder = ObjectDefinitionBuilder.GenericObjectDefinition(IntegrationNamespaceUtils.CHANNEL_PACKAGE + ".PriorityChannel");
                ParseQueueCapacity(builder, queueElement);
                string comparatorRef = queueElement.GetAttribute("comparator");
                if (StringUtils.HasText(comparatorRef))
                {
                    builder.AddConstructorArgReference(comparatorRef);
                }
            }
            else if (DomUtils.GetChildElementByTagName(element, "rendezvous-queue") != null)
            {
                builder = ObjectDefinitionBuilder.GenericObjectDefinition(IntegrationNamespaceUtils.CHANNEL_PACKAGE + ".RendezvousChannel");
            }
            else
            {
                builder = ObjectDefinitionBuilder.GenericObjectDefinition(IntegrationNamespaceUtils.CHANNEL_PACKAGE + ".DirectChannel");
            }
            return(builder);
        }
        protected override AbstractObjectDefinition DoParse(XmlElement element, ParserContext parserContext, string channelName)
        {
            XmlElement pollerElement        = DomUtils.GetChildElementByTagName(element, "poller");
            ObjectDefinitionBuilder builder = ObjectDefinitionBuilder.GenericObjectDefinition(IntegrationNamespaceUtils.CONFIG_PACKAGE + ".ConsumerEndpointFactoryObject");

            builder.AddConstructorArgReference(ParseAndRegisterConsumer(element, parserContext));
            if (pollerElement != null)
            {
                if (!StringUtils.HasText(channelName))
                {
                    parserContext.ReaderContext.ReportException(element, element.Name, "outbound channel adapter with a 'poller' requires a 'channel' to poll");
                }
                IntegrationNamespaceUtils.ConfigurePollerMetadata(pollerElement, builder, parserContext);
            }
            builder.AddPropertyValue("inputChannelName", channelName);
            return(builder.ObjectDefinition);
        }
        private static void ConfigureTrigger(XmlElement pollerElement, ObjectDefinitionBuilder targetBuilder, ParserContext parserContext)
        {
            string     triggerBeanName;
            XmlElement intervalElement = DomUtils.GetChildElementByTagName(pollerElement, "interval-trigger");

            if (intervalElement != null)
            {
                triggerBeanName = ParseIntervalTrigger(intervalElement, parserContext);
            }
            else
            {
                XmlElement cronElement = DomUtils.GetChildElementByTagName(pollerElement, "cron-trigger");
                if (cronElement == null)
                {
                    parserContext.ReaderContext.ReportException(pollerElement, pollerElement.Name, "A <poller> element must include either an <interval-trigger/> or <cron-trigger/> child element.");
                }
                triggerBeanName = ParseCronTrigger(cronElement, parserContext);
            }
            targetBuilder.AddPropertyReference("trigger", triggerBeanName);
        }
        protected override AbstractObjectDefinition DoParse(XmlElement element, ParserContext parserContext, string channelName)
        {
            string source = ParseSource(element, parserContext);

            if (!StringUtils.HasText(source))
            {
                parserContext.ReaderContext.ReportException(element, element.Name, "failed to parse source");
            }
            ObjectDefinitionBuilder adapterBuilder = ObjectDefinitionBuilder.GenericObjectDefinition(IntegrationNamespaceUtils.CONFIG_PACKAGE + ".SourcePollingChannelAdapterFactoryObject");

            adapterBuilder.AddPropertyReference("source", source);
            adapterBuilder.AddPropertyReference("outputChannel", channelName);
            XmlElement pollerElement = DomUtils.GetChildElementByTagName(element, "poller");

            if (pollerElement != null)
            {
                IntegrationNamespaceUtils.ConfigurePollerMetadata(pollerElement, adapterBuilder, parserContext);
            }
            IntegrationNamespaceUtils.SetValueIfAttributeDefined(adapterBuilder, element, "auto-startup");
            return(adapterBuilder.ObjectDefinition);
        }
Beispiel #6
0
        protected override AbstractObjectDefinition ParseInternal(XmlElement element, ParserContext parserContext)
        {
            ObjectDefinitionBuilder handlerBuilder = ParseHandler(element, parserContext);

            IntegrationNamespaceUtils.SetReferenceIfAttributeDefined(handlerBuilder, element, "output-channel");
            IntegrationNamespaceUtils.SetValueIfAttributeDefined(handlerBuilder, element, "order");
            AbstractObjectDefinition handlerBeanDefinition = handlerBuilder.ObjectDefinition;
            string inputChannelAttributeName = InputChannelAttributeName;

            if (!element.HasAttribute(inputChannelAttributeName))
            {
                if (!parserContext.IsNested)
                {
                    parserContext.ReaderContext.ReportException(element, element.Name, "The '" + inputChannelAttributeName
                                                                + "' attribute is required for top-level endpoint elements.");
                }
                return(handlerBeanDefinition);
            }
            ObjectDefinitionBuilder builder = ObjectDefinitionBuilder.GenericObjectDefinition(IntegrationNamespaceUtils.CONFIG_PACKAGE + ".ConsumerEndpointFactoryObject");
            string handlerBeanName          = parserContext.ReaderContext.RegisterWithGeneratedName(handlerBeanDefinition);

            builder.AddConstructorArgReference(handlerBeanName);
            string inputChannelName = element.GetAttribute(inputChannelAttributeName);

            if (!parserContext.Registry.ContainsObjectDefinition(inputChannelName))
            {
                ObjectDefinitionBuilder channelDef = ObjectDefinitionBuilder.GenericObjectDefinition(IntegrationNamespaceUtils.CHANNEL_PACKAGE + ".DirectChannel");
                ObjectDefinitionHolder  holder     = new ObjectDefinitionHolder(channelDef.ObjectDefinition, inputChannelName);
                ObjectDefinitionReaderUtils.RegisterObjectDefinition(holder, parserContext.Registry);
            }
            builder.AddPropertyValue("inputChannelName", inputChannelName);
            XmlElement pollerElement = DomUtils.GetChildElementByTagName(element, "poller");

            if (pollerElement != null)
            {
                IntegrationNamespaceUtils.ConfigurePollerMetadata(pollerElement, builder, parserContext);
            }
            IntegrationNamespaceUtils.SetValueIfAttributeDefined(builder, element, "auto-startup");
            return(builder.ObjectDefinition);
        }
Beispiel #7
0
        protected override AbstractObjectDefinition ParseInternal(XmlElement element, ParserContext parserContext)
        {
            ObjectDefinitionBuilder builder      = BuildObjectDefinition(element, parserContext);
            ManagedList             interceptors = null;
            XmlElement interceptorsElement       = DomUtils.GetChildElementByTagName(element, "interceptors");

            if (interceptorsElement != null)
            {
                ChannelInterceptorParser interceptorParser = new ChannelInterceptorParser();
                interceptors = interceptorParser.ParseInterceptors(interceptorsElement, new ParserContext(parserContext.ParserHelper, builder.RawObjectDefinition));
            }
            if (interceptors == null)
            {
                interceptors = new ManagedList();
            }

            string datatypeAttr = element.GetAttribute("datatype");

            if (StringUtils.HasText(datatypeAttr))
            {
                string[]             datatypes   = StringUtils.CommaDelimitedListToStringArray(datatypeAttr);
                RootObjectDefinition selectorDef = new RootObjectDefinition();
                selectorDef.ObjectTypeName = IntegrationNamespaceUtils.SELECTOR_PACKAGE + ".PayloadTypeSelector";
                selectorDef.ConstructorArgumentValues.AddGenericArgumentValue(datatypes);
                string selectorObjectName = parserContext.ReaderContext.RegisterWithGeneratedName(selectorDef);

                RootObjectDefinition interceptorDef = new RootObjectDefinition();
                interceptorDef.ObjectTypeName = IntegrationNamespaceUtils.CHANNEL_INTERCEPTOR_PACKAGE + ".MessageSelectingInterceptor";
                interceptorDef.ConstructorArgumentValues.AddGenericArgumentValue(new RuntimeObjectReference(selectorObjectName));
                string interceptorObjectName = parserContext.ReaderContext.RegisterWithGeneratedName(interceptorDef);

                interceptors.Add(new RuntimeObjectReference(interceptorObjectName));
            }

            builder.AddPropertyValue("interceptors", interceptors);
            return(builder.ObjectDefinition);
        }