protected override void DoParse(XmlElement element, ParserContext parserContext, ObjectDefinitionBuilder builder) { builder.AddPropertyReference(TxNamespaceUtils.TRANSACTION_MANAGER_PROPERTY, GetAttributeValue(element, TxNamespaceUtils.TRANSACTION_MANAGER_ATTRIBUTE)); XmlNodeList txAttributes = element.SelectNodes("*[local-name()='attributes' and namespace-uri()='" + element.NamespaceURI + "']"); if (txAttributes.Count > 1 ) { parserContext.ReaderContext.ReportException(element, "tx advice", "Element <attributes> is allowed at most once inside element <advice>"); } else if (txAttributes.Count == 1) { //using xml defined source XmlElement attributeSourceElement = txAttributes[0] as XmlElement; AbstractObjectDefinition attributeSourceDefinition = ParseAttributeSource(attributeSourceElement, parserContext); builder.AddPropertyValue(TxNamespaceUtils.TRANSACTION_ATTRIBUTE_SOURCE, attributeSourceDefinition); } else { //Assume attibutes source ObjectDefinitionBuilder txAttributeSourceBuilder = parserContext.ParserHelper.CreateRootObjectDefinitionBuilder(typeof (AttributesTransactionAttributeSource)); builder.AddPropertyValue(TxNamespaceUtils.TRANSACTION_ATTRIBUTE_SOURCE, txAttributeSourceBuilder.ObjectDefinition); } }
public ManagedList ParseInterceptors(XmlElement element, ParserContext parserContext) { ManagedList interceptors = new ManagedList(); foreach(XmlNode child in element.ChildNodes) { /* TODO: * check full elementname (incl. NamespaceUri) */ if (child.NodeType == XmlNodeType.Element) { XmlElement childElement = (XmlElement) child; string localName = child.LocalName; if ("object".Equals(localName)) { ObjectDefinitionHolder holder = parserContext.ParserHelper.ParseObjectDefinitionElement(childElement); interceptors.Add(holder); } else if ("ref".Equals(localName)) { string reference = childElement.GetAttribute("object"); interceptors.Add(new RuntimeObjectReference(reference)); } else { if (!parsers.ContainsKey(localName)) { parserContext.ReaderContext.ReportException(childElement, localName, "unsupported interceptor element"); } IObjectDefinitionRegisteringParser parser = parsers[localName]; string interceptorObjectName = parser.Parse(childElement, parserContext); interceptors.Add(new RuntimeObjectReference(interceptorObjectName)); } } } return interceptors; }
protected override ObjectDefinitionBuilder ParseHandler(XmlElement element, ParserContext parserContext) { ObjectDefinitionBuilder builder = ObjectDefinitionBuilder.GenericObjectDefinition(IntegrationNamespaceUtils.FILTER_PACKAGE + ".MessageFilter"); builder.AddConstructorArgReference(ParseSelector(element, parserContext)); IntegrationNamespaceUtils.SetValueIfAttributeDefined(builder, element, "throw-exception-on-rejection"); return builder; }
public IObjectDefinition ParseElement(XmlElement element, ParserContext parserContext) { IObjectDefinitionFactory factory = parserContext.ReaderContext.ObjectDefinitionFactory; AssertUtils.ArgumentNotNull(factory, "factory"); string id = element.GetAttribute(ObjectNames.MongoConventionProfileId); string defaultId = StringUtils.HasText(id) ? id : ObjectNames.MongoConventionProfileDefaultId; ObjectDefinitionBuilder builder = ObjectDefinitionBuilder.GenericObjectDefinition(typeof(ConventionProfileFactory)); SetConvention(element, builder, ObjectNames.ConventionProfileDefaultValue, ConventionProfileFactory.DefaultValueConventionProperty); SetConvention(element, builder, ObjectNames.ConventionProfileElementName, ConventionProfileFactory.ElementNameConventionProperty); SetConvention(element, builder, ObjectNames.ConventionProfileExtraElementsMember, ConventionProfileFactory.ExtraElementsMemberConventionProperty); SetConvention(element, builder, ObjectNames.ConventionProfileIdGenerator, ConventionProfileFactory.IdGeneratorConventionProperty); SetConvention(element, builder, ObjectNames.ConventionProfileIdMember, ConventionProfileFactory.IdMemberConventionProperty); SetConvention(element, builder, ObjectNames.ConventionProfileIgnoreExtraElements, ConventionProfileFactory.IgnoreExtraElementsConventionProperty); SetConvention(element, builder, ObjectNames.ConventionProfileIgnoreIfDefault, ConventionProfileFactory.IgnoreIfDefaultConventionProperty); SetConvention(element, builder, ObjectNames.ConventionProfileIgnoreIfNull, ConventionProfileFactory.IgnoreIfNullConventionProperty); SetConvention(element, builder, ObjectNames.ConventionProfileMemberFinder, ConventionProfileFactory.MemberFinderConventionProperty); SetConvention(element, builder, ObjectNames.ConventionProfileSerializationOptions, ConventionProfileFactory.SerializationOptionsConventionProperty); parserContext.Registry.RegisterObjectDefinition(defaultId, builder.ObjectDefinition); return null; }
private ObjectDefinitionHolder ParseTestObjectDefinition(XmlElement rootElement, ParserContext parserContext) { MutablePropertyValues properties = new MutablePropertyValues(); XmlNodeList childNodes = rootElement.ChildNodes; //Get all properties (from non whitespace nodes) foreach (XmlNode childNode in childNodes) { if (XmlNodeType.Whitespace != childNode.NodeType) { properties.Add(new PropertyValue(childNode.LocalName, childNode.InnerText)); } } IConfigurableObjectDefinition od = new RootObjectDefinition(typeof (TestObject), null, properties); od.IsSingleton = false; //HardCoded for now. string id = "testObject"; //id = ObjectDefinitionReaderUtils.GenerateObjectName(od, reader.ObjectReader.Registry); return new ObjectDefinitionHolder(od, id); }
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; }
/// <summary>The do parse.</summary> /// <param name="element">The element.</param> /// <param name="parserContext">The parser context.</param> /// <param name="builder">The builder.</param> protected override void DoParse(XmlElement element, ParserContext parserContext, ObjectDefinitionBuilder builder) { var parser = new ObjectDefinitionParserHelper(parserContext); var map = parser.ParseMapElement(element, builder.RawObjectDefinition); builder.AddPropertyValue("SourceDictionary", map); }
/// <summary> /// Central template method to actually parse the supplied XmlElement /// into one or more IObjectDefinitions. /// </summary> /// <param name="element">The element that is to be parsed into one or more <see cref="IObjectDefinition"/>s</param> /// <param name="parserContext">The the object encapsulating the current state of the parsing process; /// provides access to a <see cref="IObjectDefinitionRegistry"/></param> /// <returns> /// The primary IObjectDefinition resulting from the parsing of the supplied XmlElement /// </returns> protected override AbstractObjectDefinition ParseInternal(XmlElement element, ParserContext parserContext) { ConfigureAutoProxyCreator(parserContext, element); //Create the TransactionAttributeSource RootObjectDefinition sourceDef = new RootObjectDefinition(typeof(AttributesTransactionAttributeSource)); sourceDef.Role = ObjectRole.ROLE_INFRASTRUCTURE; string sourceName = parserContext.ReaderContext.RegisterWithGeneratedName(sourceDef); //Create the TransactionInterceptor definition. RootObjectDefinition interceptorDefinition = new RootObjectDefinition(typeof(TransactionInterceptor)); interceptorDefinition.Role = ObjectRole.ROLE_INFRASTRUCTURE; RegisterTransactionManager(element, interceptorDefinition); interceptorDefinition.PropertyValues.Add(TxNamespaceUtils.TRANSACTION_ATTRIBUTE_SOURCE, new RuntimeObjectReference(sourceName)); String interceptorName = parserContext.ReaderContext.RegisterWithGeneratedName(interceptorDefinition); // Create the TransactionAttributeSourceAdvisor definition. RootObjectDefinition advisorDef = new RootObjectDefinition(typeof(ObjectFactoryTransactionAttributeSourceAdvisor)); advisorDef.Role = ObjectRole.ROLE_INFRASTRUCTURE; advisorDef.PropertyValues.Add("transactionAttributeSource", new RuntimeObjectReference(sourceName)); advisorDef.PropertyValues.Add("adviceObjectName", interceptorName); if (element.HasAttribute(ORDER)) { advisorDef.PropertyValues.Add(ORDER, GetAttributeValue(element, ORDER)); } return advisorDef; }
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; }
protected override ObjectDefinitionBuilder ParseHandler(XmlElement element, ParserContext parserContext) { ObjectDefinitionBuilder builder = ObjectDefinitionBuilder.GenericObjectDefinition(IntegrationNamespaceUtils.AGGREGATOR_PACKAGE + ".MethodInvokingAggregator"); string refatr = element.GetAttribute(RefAttribute); if(!StringUtils.HasText(refatr)) { parserContext.ReaderContext.ReportException(element, element.Name, "The '" + RefAttribute + "' attribute is required."); } builder.AddConstructorArgReference(refatr); if(StringUtils.HasText(element.GetAttribute(MethodAttribute))) { string method = element.GetAttribute(MethodAttribute); builder.AddConstructorArg(method); } IntegrationNamespaceUtils.SetReferenceIfAttributeDefined(builder, element, DiscardChannelAttribute); IntegrationNamespaceUtils.SetValueIfAttributeDefined(builder, element, SendTimeoutAttribute); IntegrationNamespaceUtils.SetValueIfAttributeDefined(builder, element, SendPartialResultOnTimeoutAttribute); IntegrationNamespaceUtils.SetValueIfAttributeDefined(builder, element, ReaperIntervalAttribute); IntegrationNamespaceUtils.SetValueIfAttributeDefined(builder, element, TrackedCorrelationIdCapacityAttribute); IntegrationNamespaceUtils.SetValueIfAttributeDefined(builder, element, "auto-startup"); IntegrationNamespaceUtils.SetValueIfAttributeDefined(builder, element, TimeoutAttribute); string completionStrategyRef = element.GetAttribute(CompletionStrategyRefAttribute); string completionStrategyMethod = element.GetAttribute(CompletionStrategyMethodAttribute); if(StringUtils.HasText(completionStrategyRef)) { if(StringUtils.HasText(completionStrategyMethod)) { string adapterBeanName = CreateCompletionStrategyAdapter( completionStrategyRef, completionStrategyMethod, parserContext); builder.AddPropertyReference(CompletionStrategyProperty, adapterBeanName); } else { builder.AddPropertyReference(CompletionStrategyProperty, completionStrategyRef); } } return builder; }
/// <summary> /// Parse the specified element and register any resulting /// IObjectDefinitions with the IObjectDefinitionRegistry that is /// embedded in the supplied ParserContext. /// </summary> /// <param name="element">The element to be parsed into one or more IObjectDefinitions</param> /// <param name="parserContext">The object encapsulating the current state of the parsing /// process.</param> /// <returns> /// The primary IObjectDefinition (can be null as explained above) /// </returns> /// <remarks> /// Implementations should return the primary IObjectDefinition /// that results from the parse phase if they wish to used nested /// inside (for example) a <code><property></code> tag. /// <para>Implementations may return null if they will not /// be used in a nested scenario. /// </para> /// </remarks> public override IObjectDefinition ParseElement(XmlElement element, ParserContext parserContext) { ParseElementCalled = true; ObjectDefinitionHolder holder = ParseTestObjectDefinition(element, parserContext); ObjectDefinitionReaderUtils.RegisterObjectDefinition(holder, parserContext.Registry); return null; }
protected override ObjectDefinitionBuilder ParseHandler(XmlElement element, ParserContext parserContext) { ObjectDefinitionBuilder builder = ObjectDefinitionBuilder.GenericObjectDefinition(typeof(NmsOutboundGateway)); builder.AddPropertyReference("connectionFactory", element.GetAttribute("connection-factory")); String requestDestination = element.GetAttribute("request-destination"); String requestDestinationName = element.GetAttribute("request-destination-name"); if (!(StringUtils.HasText(requestDestination) ^ StringUtils.HasText(requestDestinationName))) { parserContext.ReaderContext.ReportException(element, "request-destination or request-destination-name", "Exactly one of the 'request-destination' or 'request-destination-name' attributes is required."); } if (StringUtils.HasText(requestDestination)) { builder.AddPropertyReference("requestDestination", requestDestination); } else if (StringUtils.HasText(requestDestinationName)) { builder.AddPropertyValue("requestDestinationName", requestDestinationName); } IntegrationNamespaceUtils.SetReferenceIfAttributeDefined(builder, element, "reply-destination"); IntegrationNamespaceUtils.SetValueIfAttributeDefined(builder, element, "reply-destination-name"); IntegrationNamespaceUtils.SetReferenceIfAttributeDefined(builder, element, "reply-channel"); IntegrationNamespaceUtils.SetReferenceIfAttributeDefined(builder, element, "message-converter"); IntegrationNamespaceUtils.SetReferenceIfAttributeDefined(builder, element, "header-mapper"); IntegrationNamespaceUtils.SetValueIfAttributeDefined(builder, element, "extract-request-payload"); IntegrationNamespaceUtils.SetValueIfAttributeDefined(builder, element, "extract-reply-payload"); IntegrationNamespaceUtils.SetValueIfAttributeDefined(builder, element, "receive-timeout"); IntegrationNamespaceUtils.SetValueIfAttributeDefined(builder, element, "pub-sub-domain"); IntegrationNamespaceUtils.SetValueIfAttributeDefined(builder, element, "delivery-mode"); IntegrationNamespaceUtils.SetValueIfAttributeDefined(builder, element, "time-to-live"); IntegrationNamespaceUtils.SetValueIfAttributeDefined(builder, element, "priority"); return builder; }
public void WhenConfigFileIsNotValid() { // const string xml = @"<?xml version='1.0' encoding='UTF-8' ?> //<objects xmlns='http://www.springframework.net' xmlns:v='http://www.springframework.net/validation'> // <v:required test='#this'> // <v:message id='error.airportCode.required' providers='summary'/> // <v:action type='Spring.Validation.Actions.ExpressionAction, Spring.Core' when='true'/> // </v:required> //</objects> //"; XmlDocument doc = GetValidatedXmlResource("_WhenConfigFileIsNotValid.xml"); MockObjectDefinitionRegistry registry = new MockObjectDefinitionRegistry(); IObjectDefinitionDocumentReader reader = new DefaultObjectDefinitionDocumentReader(); XmlReaderContext readerContext = new XmlReaderContext(null, new XmlObjectDefinitionReader(registry)); ObjectDefinitionParserHelper helper = new ObjectDefinitionParserHelper(readerContext); helper.InitDefaults(doc.DocumentElement); ParserContext parserContext = new ParserContext(helper.ReaderContext, helper); ValidationNamespaceParser parser = new ValidationNamespaceParser(); foreach (XmlElement element in doc.DocumentElement.ChildNodes) { if (element.NamespaceURI == "http://www.springframework.net/validation") { parser.ParseElement(element, parserContext); } } }
protected override void DoParse(XmlElement element, ParserContext parserContext, ObjectDefinitionBuilder builder) { if(!StringUtils.HasText(element.GetAttribute("id"))) { parserContext.ReaderContext.ReportException(element, element.Name, "id is required"); } ParseSelectorChain(builder, element, parserContext); }
protected override AbstractObjectDefinition ParseInternal(XmlElement element, ParserContext parserContext) { string channelName = element.GetAttribute("channel"); if(!StringUtils.HasText(channelName)) { channelName = CreateDirectChannel(element, parserContext); } return DoParse(element, parserContext, channelName); }
protected static string ParseUrl(XmlElement element, ParserContext parserContext) { string url = element.GetAttribute("url"); if(!StringUtils.HasText(url)) { parserContext.ReaderContext.ReportException(element, "url", "The 'url' attribute is required."); } return url; }
/// <summary>The parse binding.</summary> /// <param name="exchangeName">The exchange name.</param> /// <param name="binding">The binding.</param> /// <param name="parserContext">The parser context.</param> /// <returns>The Spring.Objects.Factory.Support.AbstractObjectDefinition.</returns> protected override AbstractObjectDefinition ParseBinding(string exchangeName, XmlElement binding, ParserContext parserContext) { var builder = ObjectDefinitionBuilder.GenericObjectDefinition(typeof(BindingFactoryObject)); this.ParseDestination(binding, parserContext, builder); builder.AddPropertyValue("Exchange", new TypedStringValue(exchangeName)); builder.AddPropertyValue("Arguments", new Dictionary<string, object>()); return builder.ObjectDefinition; }
private static string ParseChild(XmlElement element, ParserContext parserContext, IObjectDefinition parentDefinition) { IObjectDefinition def = parserContext.ParserHelper.ParseCustomElement(element, parentDefinition); if(def == null) { parserContext.ReaderContext.ReportException(element, element.Name, "child ObjectDefinition must not be null"); } return parserContext.ReaderContext.RegisterWithGeneratedName(def); }
/// <summary> /// Parse a template definition from the templating namespace /// </summary> /// <param name="element">the root element defining the templating object</param> /// <param name="parserContext">the parser context</param> /// <returns></returns> private IConfigurableObjectDefinition ParseTemplateDefinition(XmlElement element, ParserContext parserContext) { switch (element.LocalName) { case TemplateDefinitionConstants.NVelocityElement: return ParseNVelocityEngine(element, parserContext); default: throw new ArgumentException(string.Format("undefined element for templating namespace: {0}", element.LocalName)); } }
protected override void DoParse(XmlElement element, ParserContext parserContext, ObjectDefinitionBuilder builder) { base.DoParse(element, builder); //TODO investigate setting of scope on client cache //builder.AddPropertyValue("Scope", "some value"); //TODO check if .NET client has any 'data policy' settings. ParsingUtils.SetPropertyValue(element, builder, "name", "name"); ParsingUtils.SetPropertyValue(element, builder, "pool-name", "poolName"); String cacheRef = element.GetAttribute("cache-ref"); // add cache reference (fallback to default if nothing is specified) builder.AddPropertyReference("cache", (StringUtils.HasText(cacheRef) ? cacheRef : "gemfire-cache")); // client region attributes String regionAttributesRef = element.GetAttribute("attributes-ref"); if (StringUtils.HasText(regionAttributesRef)) { ObjectDefinitionBuilder attrBuilder = ObjectDefinitionBuilder.GenericObjectDefinition(typeof(RegionAttributesFactoryObject)); builder.AddPropertyReference("attributes", regionAttributesRef); } ManagedList interests = new ManagedList(); XmlNodeList subElements = element.ChildNodes; for (int i = 0; i < subElements.Count; i++) { XmlNode subElement = subElements.Item(i); if (subElement.NodeType == XmlNodeType.Element) { string name = subElement.LocalName; if ("cache-listener".Equals(name)) { builder.AddPropertyValue("cacheListeners", ParseCacheListener(parserContext, (XmlElement)subElement, builder)); } else if ("regex-interest".Equals(name)) { interests.Add(ParseRegexInterest(parserContext, (XmlElement)subElement)); } else if ("key-interest".Equals(name)) { interests.Add(ParseKeyInterest(parserContext, (XmlElement)subElement)); } else if ("all-keys-interest".Equals(name)) { interests.Add(ParseAllKeysInterest(parserContext, (XmlElement) subElement)); } } } if (subElements.Count > 0) { builder.AddPropertyValue("interests", interests); } }
/// <summary> /// Parse the specified XmlElement and register the resulting /// ObjectDefinitions with the <see cref="P:Spring.Objects.Factory.Xml.ParserContext.Registry"/> IObjectDefinitionRegistry /// embedded in the supplied <see cref="T:Spring.Objects.Factory.Xml.ParserContext"/> /// </summary> /// <param name="element">The element to be parsed.</param> /// <param name="parserContext">The object encapsulating the current state of the parsing process. /// Provides access to a IObjectDefinitionRegistry</param> /// <returns>The primary object definition.</returns> /// <remarks> /// <p> /// This method is never invoked if the parser is namespace aware /// and was called to process the root node. /// </p> /// </remarks> public IObjectDefinition ParseElement(XmlElement element, ParserContext parserContext) { IObjectDefinitionRegistry registry = parserContext.ReaderContext.Registry; AssertUtils.ArgumentNotNull(registry, "registry"); AttributeConfigUtils.RegisterAttributeConfigProcessors(registry); return null; }
protected override string ResolveId(XmlElement element, AbstractObjectDefinition definition, ParserContext parserContext) { String name = base.ResolveId(element, definition, parserContext); if (!StringUtils.HasText(name)) { name = "gemfire-pool"; } return name; }
/// <see cref="INamespaceParser"/> public override IObjectDefinition ParseElement(XmlElement element, ParserContext parserContext) { string name = element.GetAttribute(ObjectDefinitionConstants.IdAttribute); IConfigurableObjectDefinition templateDefinition = ParseTemplateDefinition(element, parserContext); if (!StringUtils.HasText(name)) { name = ObjectDefinitionReaderUtils.GenerateObjectName(templateDefinition, parserContext.Registry); } parserContext.Registry.RegisterObjectDefinition(name, templateDefinition); return null; }
/// <summary>The parse bindings.</summary> /// <param name="element">The element.</param> /// <param name="parserContext">The parser context.</param> /// <param name="builder">The builder.</param> /// <param name="exchangeName">The exchange name.</param> protected override void ParseBindings(XmlElement element, ParserContext parserContext, ObjectDefinitionBuilder builder, string exchangeName) { var backingType = element.GetAttribute(BACKING_TYPE_ATTRIBUTE); var bindings = element.SelectChildElementByTagName(DIRECT_BINDINGS_ELE); if (bindings != null && ExchangeTypes.Direct != backingType) { parserContext.ReaderContext.ReportFatalException(element, "Cannot have direct-bindings if backing-type not 'direct'"); } if (bindings == null) { bindings = element.SelectChildElementByTagName(TOPIC_BINDINGS_ELE); if (bindings != null && !ExchangeTypes.Topic.Equals(backingType)) { parserContext.ReaderContext.ReportFatalException(element, "Cannot have topic-bindings if backing-type not 'topic'"); } } if (bindings == null) { bindings = element.SelectChildElementByTagName(TOPIC_FANOUT_ELE); if (bindings != null && !ExchangeTypes.Fanout.Equals(backingType)) { parserContext.ReaderContext.ReportFatalException(element, "Cannot have fanout-bindings if backing-type not 'fanout'"); } } if (bindings == null) { bindings = element.SelectChildElementByTagName(TOPIC_HEADERS_ELE); if (bindings != null && !ExchangeTypes.Headers.Equals(backingType)) { parserContext.ReaderContext.ReportFatalException(element, "Cannot have headers-bindings if backing-type not 'headers'"); } } if (!string.IsNullOrWhiteSpace(backingType)) { if (ExchangeTypes.Direct.Equals(backingType)) { this.DoParseBindings(parserContext, exchangeName, bindings, new DirectExchangeParser()); } else if (ExchangeTypes.Topic.Equals(backingType)) { this.DoParseBindings(parserContext, exchangeName, bindings, new TopicExchangeParser()); } else if (ExchangeTypes.Fanout.Equals(backingType)) { this.DoParseBindings(parserContext, exchangeName, bindings, new FanoutExchangeParser()); } else if (ExchangeTypes.Headers.Equals(backingType)) { this.DoParseBindings(parserContext, exchangeName, bindings, new HeadersExchangeParser()); } } }
/// <summary>The do parse.</summary> /// <param name="element">The element.</param> /// <param name="parserContext">The parser context.</param> /// <param name="builder">The builder.</param> protected override void DoParse(XmlElement element, ParserContext parserContext, ObjectDefinitionBuilder builder) { var connectionFactoryRef = element.GetAttribute(CONNECTION_FACTORY_ATTRIBUTE); if (string.IsNullOrWhiteSpace(connectionFactoryRef)) { parserContext.ReaderContext.ReportFatalException(element, "A '" + CONNECTION_FACTORY_ATTRIBUTE + "' attribute must be set."); } if (!string.IsNullOrWhiteSpace(connectionFactoryRef)) { // Use constructor with connectionFactory parameter builder.AddConstructorArgReference(connectionFactoryRef); } NamespaceUtils.SetValueIfAttributeDefined(builder, element, CHANNEL_TRANSACTED_ATTRIBUTE); NamespaceUtils.SetValueIfAttributeDefined(builder, element, QUEUE_ATTRIBUTE); NamespaceUtils.SetValueIfAttributeDefined(builder, element, EXCHANGE_ATTRIBUTE); NamespaceUtils.SetValueIfAttributeDefined(builder, element, ROUTING_KEY_ATTRIBUTE); NamespaceUtils.SetValueIfAttributeDefined(builder, element, REPLY_TIMEOUT_ATTRIBUTE); NamespaceUtils.SetValueIfAttributeDefined(builder, element, ENCODING_ATTRIBUTE); NamespaceUtils.SetReferenceIfAttributeDefined(builder, element, MESSAGE_CONVERTER_ATTRIBUTE); NamespaceUtils.SetReferenceIfAttributeDefined(builder, element, REPLY_QUEUE_ATTRIBUTE); NamespaceUtils.SetValueIfAttributeDefined(builder, element, MANDATORY_ATTRIBUTE); NamespaceUtils.SetValueIfAttributeDefined(builder, element, IMMEDIATE_ATTRIBUTE); NamespaceUtils.SetReferenceIfAttributeDefined(builder, element, RETURN_CALLBACK_ATTRIBUTE); NamespaceUtils.SetReferenceIfAttributeDefined(builder, element, CONFIRM_CALLBACK_ATTRIBUTE); IObjectDefinition replyContainer = null; XmlElement childElement = null; var childElements = element.SelectChildElementsByTagName(LISTENER_ELEMENT); if (childElements.Count > 0) { childElement = childElements[0] as XmlElement; } if (childElement != null) { replyContainer = this.ParseListener(childElement, element, parserContext); if (replyContainer != null) { replyContainer.PropertyValues.Add("MessageListener", new RuntimeObjectReference(element.GetAttribute(ID_ATTRIBUTE))); var replyContainerName = element.GetAttribute(ID_ATTRIBUTE) + ".ReplyListener"; parserContext.Registry.RegisterObjectDefinition(replyContainerName, replyContainer); } } if (replyContainer == null && element.HasAttribute(REPLY_QUEUE_ATTRIBUTE)) { parserContext.ReaderContext.ReportFatalException(element, "For template '" + element.GetAttribute(ID_ATTRIBUTE) + "', when specifying a reply-queue, a <reply-listener/> element is required"); } else if (replyContainer != null && !element.HasAttribute(REPLY_QUEUE_ATTRIBUTE)) { parserContext.ReaderContext.ReportFatalException(element, "For template '" + element.GetAttribute(ID_ATTRIBUTE) + "', a <reply-listener/> element is not allowed if no 'reply-queue' is supplied"); } }
protected override string ParseAndRegisterConsumer(XmlElement element, ParserContext parserContext) { string consumerRef = element.GetAttribute("ref"); if(!StringUtils.HasText(consumerRef)) { parserContext.ReaderContext.ReportException(element, element.Name, "The 'ref' attribute is required."); } if(element.HasAttribute("method")) { consumerRef = parserContext.ReaderContext.RegisterWithGeneratedName(ParseConsumer(element, parserContext)); } return consumerRef; }
/// <summary> /// Parse the specified XmlElement and register the resulting /// ObjectDefinitions with the <see cref="P:Spring.Objects.Factory.Xml.ParserContext.Registry"/> IObjectDefinitionRegistry /// embedded in the supplied <see cref="T:Spring.Objects.Factory.Xml.ParserContext"/> /// </summary> /// <param name="element">The element to be parsed.</param> /// <param name="parserContext">TThe object encapsulating the current state of the parsing process. /// Provides access to a IObjectDefinitionRegistry</param> /// <returns>The primary object definition.</returns> /// <remarks> /// <p> /// This method is never invoked if the parser is namespace aware /// and was called to process the root node. /// </p> /// </remarks> public IObjectDefinition ParseElement(XmlElement element, ParserContext parserContext) { AssemblyObjectDefinitionScanner scanner = ConfigureScanner(parserContext, element); IObjectDefinitionRegistry registry = parserContext.Registry; // Actually scan for objects definitions and register them. scanner.ScanAndRegisterTypes(registry); RegisterComponents(element, registry); return null; }
protected override string ResolveId(XmlElement element, AbstractObjectDefinition definition, ParserContext parserContext) { string id = base.ResolveId(element, definition, parserContext); if(!StringUtils.HasText(id)) { id = element.GetAttribute("name"); } if(!StringUtils.HasText(id)) { id = parserContext.ReaderContext.GenerateObjectName(definition); } return id; }
protected override ObjectDefinitionBuilder BuildObjectDefinition(XmlElement element, ParserContext parserContext) { ObjectDefinitionBuilder builder = ObjectDefinitionBuilder.GenericObjectDefinition(IntegrationNamespaceUtils.CHANNEL_PACKAGE + ".PublishSubscribeChannel"); string taskExecutorRef = element.GetAttribute("task-executor"); if(StringUtils.HasText(taskExecutorRef)) { builder.AddConstructorArgReference(taskExecutorRef); } IntegrationNamespaceUtils.SetReferenceIfAttributeDefined(builder, element, "error-handler"); IntegrationNamespaceUtils.SetValueIfAttributeDefined(builder, element, "apply-sequence"); return builder; }
/// <summary> /// Configures the scanner. /// </summary> /// <param name="parserContext">The parser context.</param> /// <param name="element">The element.</param> /// <returns></returns> protected virtual AssemblyObjectDefinitionScanner ConfigureScanner(ParserContext parserContext, XmlElement element) { var scanner = new AssemblyObjectDefinitionScanner(); ParseBaseAssembliesAttribute(scanner, element); ParseNameGeneratorAttribute(scanner, element); ParseTypeFilters(scanner, element); scanner.Defaults = parserContext.ParserHelper.Defaults; return scanner; }
public IObjectDefinition ParseElement(XmlElement element, ParserContext parserContext) { return(odParser.ParseElement(element, parserContext)); }
public ObjectDefinitionHolder Decorate(XmlNode node, ObjectDefinitionHolder definition, ParserContext parserContext) { return(null); }
/// <summary> /// Resolves the ID for the supplied <see cref="IObjectDefinition"/>. /// </summary> /// <remarks> /// When using <see cref="ShouldGenerateId"/> generation, a name is generated automatically. /// Otherwise, the ID is extracted from the "id" attribute, potentially with a /// <see cref="ShouldGenerateIdAsFallback"/> fallback to a generated id. /// </remarks> /// <param name="element">The element that the object definition has been built from.</param> /// <param name="definition">The object definition to be registered.</param> /// <param name="parserContext">The the object encapsulating the current state of the parsing process; /// provides access to a <see cref="IObjectDefinitionRegistry"/> </param> /// <returns>the resolved id</returns> /// <exception cref="ObjectDefinitionStoreException"> /// if no unique name could be generated for the given object definition /// </exception> protected virtual string ResolveId(XmlElement element, AbstractObjectDefinition definition, ParserContext parserContext) { if (ShouldGenerateId) { return(parserContext.ReaderContext.GenerateObjectName(definition)); } else { string id = GetAttributeValue(element, ID_ATTRIBUTE); if (!StringUtils.HasText(id) && ShouldGenerateIdAsFallback) { id = parserContext.ReaderContext.GenerateObjectName(definition); } return(id); } }
/// <summary> /// Central template method to actually parse the supplied XmlElement /// into one or more IObjectDefinitions. /// </summary> /// <param name="element">The element that is to be parsed into one or more <see cref="IObjectDefinition"/>s</param> /// <param name="parserContext">The the object encapsulating the current state of the parsing process; /// provides access to a <see cref="IObjectDefinitionRegistry"/> </param> /// <returns>The primary IObjectDefinition resulting from the parsing of the supplied XmlElement</returns> protected abstract AbstractObjectDefinition ParseInternal(XmlElement element, ParserContext parserContext);
/// <summary> /// Parse a standard object definition into a /// <see cref="Spring.Objects.Factory.Config.ObjectDefinitionHolder"/>, /// including object name and aliases. /// </summary> /// <param name="element">The element containing the object definition.</param> /// <param name="containingDefinition">The containing object definition if <paramref name="element"/> is a nested element.</param> /// <returns> /// The parsed object definition wrapped within an /// <see cref="Spring.Objects.Factory.Config.ObjectDefinitionHolder"/> /// instance. /// </returns> /// <remarks> /// <para> /// Object elements specify their canonical name via the "id" attribute /// and their aliases as a delimited "name" attribute. /// </para> /// <para> /// If no "id" is specified, uses the first name in the "name" attribute /// as the canonical name, registering all others as aliases. /// </para> /// </remarks> public ObjectDefinitionHolder ParseObjectDefinitionElement(XmlElement element, IObjectDefinition containingDefinition) { string id = GetAttributeValue(element, ObjectDefinitionConstants.IdAttribute); string nameAttr = GetAttributeValue(element, ObjectDefinitionConstants.NameAttribute); ArrayList aliases = new ArrayList(); if (StringUtils.HasText(nameAttr)) { aliases.AddRange(GetObjectNames(nameAttr)); } // if we ain't got an id, check if object is page definition or assign any existing (first) alias... string objectName = id; if (StringUtils.IsNullOrEmpty(objectName)) { if (aliases.Count > 0) { objectName = (string)aliases[0]; aliases.RemoveAt(0); if (log.IsDebugEnabled) { log.Debug(string.Format("No XML 'id' specified using '{0}' as object name and '{1}' as aliases", objectName, string.Join(",", (string[])aliases.ToArray(typeof(string))))); } } } objectName = PostProcessObjectNameAndAliases(objectName, aliases, element, containingDefinition); if (containingDefinition == null) { CheckNameUniqueness(objectName, aliases, element); } ParserContext parserContext = new ParserContext(this, containingDefinition); IConfigurableObjectDefinition definition = objectsNamespaceParser.ParseObjectDefinitionElement(element, objectName, parserContext); if (definition != null) { if (StringUtils.IsNullOrEmpty(objectName)) { if (containingDefinition != null) { objectName = ObjectDefinitionReaderUtils.GenerateObjectName(definition, readerContext.Registry, true); } else { objectName = readerContext.GenerateObjectName(definition); // Register an alias for the plain object type name, if possible. string objectTypeName = definition.ObjectTypeName; if (objectTypeName != null && objectName.StartsWith(objectTypeName) && objectName.Length > objectTypeName.Length && !readerContext.Registry.IsObjectNameInUse(objectTypeName)) { aliases.Add(objectTypeName); } } #region Instrumentation if (log.IsDebugEnabled) { log.Debug(string.Format( "Neither XML '{0}' nor '{1}' specified - using generated object name [{2}]", ObjectDefinitionConstants.IdAttribute, ObjectDefinitionConstants.NameAttribute, objectName)); } #endregion } string[] aliasesArray = (string[])aliases.ToArray(typeof(string)); return(CreateObjectDefinitionHolder(element, definition, objectName, aliasesArray)); } return(null); }