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);
}
