private void ParseSelectorChain(ObjectDefinitionBuilder builder, XmlElement element, ParserContext parserContext)
{
IntegrationNamespaceUtils.SetValueIfAttributeDefined(builder, element, "voting-strategy");
ManagedList selectors = new ManagedList();
selectors.ElementTypeName = typeof(IMessageSelector).FullName;
XmlNodeList childNodes = element.ChildNodes;
for (int i = 0; i < childNodes.Count; i++)
{
XmlNode child = childNodes.Item(i);
if (child.NodeType == XmlNodeType.Element)
{
string nodeName = child.LocalName;
if ("selector".Equals(nodeName))
{
string refatr = ((XmlElement)child).GetAttribute("ref");
selectors.Add(new RuntimeObjectReference(refatr));
}
else if ("selector-chain".Equals(nodeName))
{
ObjectDefinitionBuilder nestedBuilder = ObjectDefinitionBuilder.GenericObjectDefinition(GetObjectTypeName(null));
ParseSelectorChain(nestedBuilder, (XmlElement)child, parserContext);
string nestedBeanName = parserContext.ReaderContext.RegisterWithGeneratedName(nestedBuilder.ObjectDefinition);
selectors.Add(new RuntimeObjectReference(nestedBeanName));
}
}
}
builder.AddPropertyValue("selectors", selectors);
}
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);
}
/**
* Register an error channel in the given ObjectDefinitionRegistry if not yet present.
* The bean name for which this is checking is defined by the constant
* {@link IntegrationContextUtils#ERROR_CHANNEL_BEAN_NAME}.
*/
private void RegisterErrorChannelIfNecessary(IObjectDefinitionRegistry registry)
{
if (!registry.ContainsObjectDefinition(IntegrationContextUtils.ErrorChannelObjectName))
{
if (logger.IsInfoEnabled)
{
logger.Info("No bean named '" + IntegrationContextUtils.ErrorChannelObjectName +
"' has been explicitly defined. Therefore, a default PublishSubscribeChannel will be created.");
}
RootObjectDefinition errorChannelDef = new RootObjectDefinition();
errorChannelDef.ObjectTypeName = IntegrationNamespaceUtils.BASE_PACKAGE + ".Channel.PublishSubscribeChannel";
ObjectDefinitionHolder errorChannelHolder = new ObjectDefinitionHolder(errorChannelDef, IntegrationContextUtils.ErrorChannelObjectName);
ObjectDefinitionReaderUtils.RegisterObjectDefinition(errorChannelHolder, registry);
ObjectDefinitionBuilder loggingHandlerBuilder = ObjectDefinitionBuilder.GenericObjectDefinition(IntegrationNamespaceUtils.HANDLER_PACKAGE + ".LoggingHandler");
string loggingHandlerObjectName = ObjectDefinitionReaderUtils.GenerateObjectName(loggingHandlerBuilder.ObjectDefinition, registry);
loggingHandlerBuilder.AddConstructorArg("ERROR");
ObjectDefinitionHolder loggingHandlerHolder = new ObjectDefinitionHolder(loggingHandlerBuilder.ObjectDefinition, loggingHandlerObjectName);
ObjectDefinitionReaderUtils.RegisterObjectDefinition(loggingHandlerHolder, registry);
ObjectDefinitionBuilder loggingEndpointBuilder = ObjectDefinitionBuilder.GenericObjectDefinition(IntegrationNamespaceUtils.ENDPOINT_PACKAGE + ".EventDrivenConsumer");
loggingEndpointBuilder.AddConstructorArgReference(IntegrationContextUtils.ErrorChannelObjectName);
loggingEndpointBuilder.AddConstructorArgReference(loggingHandlerObjectName);
string loggingEndpointObjectName = ObjectDefinitionReaderUtils.GenerateObjectName(loggingEndpointBuilder.ObjectDefinition, registry);
ObjectDefinitionHolder loggingEndpointHolder = new ObjectDefinitionHolder(loggingEndpointBuilder.ObjectDefinition, loggingEndpointObjectName);
ObjectDefinitionReaderUtils.RegisterObjectDefinition(loggingEndpointHolder, registry);
}
}
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);
}
private IObjectDefinition RegisterMongoObjectDefinition(XmlElement element)
{
var mongoBuilder = ObjectDefinitionBuilder.GenericObjectDefinition(typeof(MongoFactoryObject));
string host = element.GetAttribute(ObjectNames.MongoDatabaseFactoryHost);
if (!StringUtils.HasText(host))
{
host = ObjectNames.MongoDatabaseFactoryDefaultHostname;
}
string port = element.GetAttribute(ObjectNames.MongoDatabaseFactoryPort);
if (!StringUtils.HasText(port))
{
port = ObjectNames.MongoDatabaseFactoryDefaultPort;
}
string url = string.Format("mongodb://{0}:{1}", host, port);
mongoBuilder.AddPropertyValue(MongoFactoryObject.UrlProperty, url);
mongoBuilder.RawObjectDefinition.Source = element;
return(mongoBuilder.ObjectDefinition);
}
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);
}
}
private object ParseAllKeysInterest(ParserContext parserContext, XmlElement subElement)
{
ObjectDefinitionBuilder keyInterestBuilder = ObjectDefinitionBuilder.GenericObjectDefinition(typeof(AllKeysInterest));
ParseCommonInterestAttr(subElement, keyInterestBuilder);
return(keyInterestBuilder.ObjectDefinition);
}
protected override AbstractObjectDefinition ParseConsumer(XmlElement element, ParserContext parserContext)
{
ObjectDefinitionBuilder builder = ObjectDefinitionBuilder.GenericObjectDefinition(IntegrationNamespaceUtils.HANDLER_PACKAGE + ".LoggingHandler");
builder.AddConstructorArg(element.GetAttribute("level"));
return(builder.ObjectDefinition);
}
public string Parse(XmlElement element, ParserContext parserContext)
{
ObjectDefinitionBuilder builder = ObjectDefinitionBuilder.GenericObjectDefinition(IntegrationNamespaceUtils.CHANNEL_INTERCEPTOR_PACKAGE + ".WireTap");
string targetRef = element.GetAttribute("channel");
if (!StringUtils.HasText(targetRef))
{
parserContext.ReaderContext.ReportException(element, "wire-tap", "The 'channel' attribute is required.");
}
builder.AddConstructorArgReference(targetRef);
string selectorRef = element.GetAttribute("selector");
if (StringUtils.HasText(selectorRef))
{
builder.AddConstructorArgReference(selectorRef);
}
// TODO check timeout
string timeout = element.GetAttribute("timeout");
if (StringUtils.HasText(timeout))
{
builder.AddPropertyValue("timeout", TimeSpan.Parse(timeout));
}
return(parserContext.ReaderContext.RegisterWithGeneratedName(builder.ObjectDefinition));
}
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);
}
public void ObjectDefinitionReplacementTest()
{
var appContext = (AbstractApplicationContext)applicationContext;
var objectDefinitionName = _dummyCalculator.GetType().FullName;
var originalObjectDefinition = appContext.GetObjectDefinition(objectDefinitionName);
var surrogateObjectDefinition = ObjectDefinitionBuilder.GenericObjectDefinition(
typeof(SurrogateFactoryObject))
.AddPropertyValue("TargetObjectType", typeof(ICalculator))
.ObjectDefinition;
appContext.ReplaceObjectDefinition(objectDefinitionName, surrogateObjectDefinition);
var surrogateObject = appContext.GetObject(objectDefinitionName);
Assert.AreNotSame(surrogateObject.GetType(), _dummyCalculator.GetType());
//Replace
appContext.ReplaceObjectDefinition(objectDefinitionName, originalObjectDefinition);
var originalObject = appContext.GetObject(objectDefinitionName);
Assert.AreNotSame(surrogateObject, originalObject);
Assert.AreSame(_dummyCalculator.GetType(), originalObject.GetType());
}
/**
* Parse an "interval-trigger" element
*/
private static string ParseIntervalTrigger(XmlElement element, ParserContext parserContext)
{
string interval = element.GetAttribute("interval");
if (!StringUtils.HasText(interval))
{
parserContext.ReaderContext.ReportException(element, element.Name, "the 'interval' attribute is required for an <interval-trigger/>");
}
//TimeUnit timeUnit = TimeUnit.valueOf(element.getAttribute("time-unit"));
ObjectDefinitionBuilder builder = ObjectDefinitionBuilder.GenericObjectDefinition(IntegrationNamespaceUtils.SCHEDULING_PACKAGE + ".IntervalTrigger");
//TODO MLP handle parsing of time-unit correctly, now hardcode use of 'seconds' via Spring.Core.TypeConversion.TimeSpanConverter
string timeUnit = element.GetAttribute("time-unit");
switch (timeUnit)
{
case "SECONDS":
interval = interval + "s";
break;
case "MILLISECONDS":
interval = interval + "ms";
break;
}
builder.AddConstructorArg(interval);
//builder.addConstructorArgValue(timeUnit);
IntegrationNamespaceUtils.SetValueIfAttributeDefined(builder, element, "initial-delay");
IntegrationNamespaceUtils.SetValueIfAttributeDefined(builder, element, "fixed-rate");
return(parserContext.ReaderContext.RegisterWithGeneratedName(builder.ObjectDefinition));
}
private string ParseMessageListenerContainer(XmlElement element, ParserContext parserContext)
{
if (element.HasAttribute("container"))
{
foreach (string containerAttribute in containerAttributes)
{
if (element.HasAttribute(containerAttribute))
{
parserContext.ReaderContext.ReportException(element, containerAttribute,
"The '" + containerAttribute +
"' attribute should not be provided when specifying a 'container' reference.");
}
}
return(element.GetAttribute("container"));
}
ObjectDefinitionBuilder builder = ObjectDefinitionBuilder.GenericObjectDefinition(typeof(SimpleMessageListenerContainer));
string destinationAttribute = this.expectReply ? "request-destination" : "destination";
string destinationNameAttribute = this.expectReply ? "request-destination-name" : "destination-name";
string destination = element.GetAttribute(destinationAttribute);
string destinationName = element.GetAttribute(destinationNameAttribute);
if (!(StringUtils.HasText(destination) ^ StringUtils.HasText(destinationName)))
{
parserContext.ReaderContext.ReportException(element, "destination or destination-name",
"Exactly one of '" + destinationAttribute + "' or '" + destinationNameAttribute + "' is required.");
}
builder.AddPropertyReference(NmsAdapterParserUtils.CONNECTION_FACTORY_PROPERTY,
NmsAdapterParserUtils.DetermineConnectionFactoryBeanName(element, parserContext));
if (StringUtils.HasText(destination))
{
builder.AddPropertyReference("destination", destination);
}
else
{
builder.AddPropertyValue("destinationName", destinationName);
}
AcknowledgementMode acknowledgementMode = NmsAdapterParserUtils.ParseAcknowledgementMode(element, parserContext);
if (acknowledgementMode.Equals(AcknowledgementMode.Transactional))
{
builder.AddPropertyValue("sessionTransacted", true);
}
else
{
builder.AddPropertyValue("sessionAcknowledgeMode", acknowledgementMode);
}
IntegrationNamespaceUtils.SetReferenceIfAttributeDefined(builder, element, "destination-resolver");
IntegrationNamespaceUtils.SetReferenceIfAttributeDefined(builder, element, "transaction-manager");
IntegrationNamespaceUtils.SetValueIfAttributeDefined(builder, element, "pub-sub-domain");
IntegrationNamespaceUtils.SetValueIfAttributeDefined(builder, element, "concurrent-consumers");
IntegrationNamespaceUtils.SetValueIfAttributeDefined(builder, element, "max-concurrent-consumers");
IntegrationNamespaceUtils.SetValueIfAttributeDefined(builder, element, "max-messages-per-task");
IntegrationNamespaceUtils.SetValueIfAttributeDefined(builder, element, "idle-task-execution-limit");
builder.AddPropertyValue("autoStartup", false);
return(parserContext.ReaderContext.RegisterWithGeneratedName(builder.ObjectDefinition));
}
private IObjectDefinition GetMongoUrl(string url)
{
ObjectDefinitionBuilder builder = ObjectDefinitionBuilder.GenericObjectDefinition(typeof(MongoUrl));
builder.AddConstructorArg(url);
return(builder.ObjectDefinition);
}
private object ParseConnection(XmlElement subElement)
{
ObjectDefinitionBuilder definitionBuilder = ObjectDefinitionBuilder.GenericObjectDefinition(typeof(PoolConnection));
ParsingUtils.SetPropertyValue(subElement, definitionBuilder, "host", "host");
ParsingUtils.SetPropertyValue(subElement, definitionBuilder, "port", "port");
return(definitionBuilder.ObjectDefinition);
}
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);
}
private static string CreateCompletionStrategyAdapter(string refatr, string method, ParserContext parserContext)
{
ObjectDefinitionBuilder builder = ObjectDefinitionBuilder.GenericObjectDefinition(IntegrationNamespaceUtils.AGGREGATOR_PACKAGE + ".CompletionStrategyAdapter");
builder.AddConstructorArgReference(refatr);
builder.AddConstructorArg(method);
return(parserContext.ReaderContext.RegisterWithGeneratedName(builder.ObjectDefinition));
}
/// <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 object ParseRegexInterest(ParserContext parserContext, XmlElement subElement)
{
ObjectDefinitionBuilder regexInterestBuilder = ObjectDefinitionBuilder.GenericObjectDefinition(typeof(RegexInterest));
ParseCommonInterestAttr(subElement, regexInterestBuilder);
ParsingUtils.SetPropertyValue(subElement, regexInterestBuilder, "pattern", "regex");
return(regexInterestBuilder.ObjectDefinition);
}
/// <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>
/// <remarks>
/// <p>This method is never invoked if the parser is namespace aware
/// and was called to process the root node.
/// </p>
/// </remarks>
/// <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>
public IObjectDefinition ParseElement(XmlElement element, ParserContext parserContext)
{
IObjectDefinitionFactory factory = parserContext.ReaderContext.ObjectDefinitionFactory;
AssertUtils.ArgumentNotNull(factory, "factory");
RegisterTypeConverters();
string id = element.GetAttribute(ObjectNames.MongoId);
string defaultId = StringUtils.HasText(id) ? id : ObjectNames.MongoDatabaseFactoryDefaultId;
string url = element.GetAttribute(ObjectNames.MongoDatabaseFactoryUrl);
string mongoRef = element.GetAttribute(ObjectNames.MongoDatabaseFactoryMongoRef);
string dbname = element.GetAttribute(ObjectNames.MongoDatabaseFactoryDbname);
ObjectDefinitionBuilder dbFactoryBuilder = ObjectDefinitionBuilder.GenericObjectDefinition(typeof(SimpleMongoDatabaseFactory));
IObjectDefinition userCredentials = GetUserCredentialsObjectDefinition(element);
ParseAttribute(element, dbFactoryBuilder, SimpleMongoDatabaseFactory.WriteConcernProperty, ObjectNames.MongoDatabaseFactoryWriteConcern);
if (StringUtils.HasText(url))
{
if (StringUtils.HasText(mongoRef) || StringUtils.HasText(dbname) || userCredentials != null)
{
parserContext.ReaderContext.ReportException(element, ObjectNames.DbFactory, "Configure either url or details individually!");
}
dbFactoryBuilder.AddConstructorArg(GetMongoUrl(url));
parserContext.Registry.RegisterObjectDefinition(defaultId, dbFactoryBuilder.ObjectDefinition);
return(null);
}
if (StringUtils.HasText(mongoRef))
{
dbFactoryBuilder.AddConstructorArgReference(mongoRef);
}
else
{
dbFactoryBuilder.AddConstructorArg(RegisterMongoObjectDefinition(element));
}
dbname = StringUtils.HasText(dbname) ? dbname : ObjectNames.MongoDatabaseFactoryDefaultDatabaseName;
dbFactoryBuilder.AddConstructorArg(dbname);
if (userCredentials != null)
{
dbFactoryBuilder.AddConstructorArg(userCredentials);
}
parserContext.Registry.RegisterObjectDefinition(defaultId, dbFactoryBuilder.ObjectDefinition);
return(null);
}
public void Register(Type type, AbstractApplicationContext context)
{
var builder = ObjectDefinitionBuilder.GenericObjectDefinition(type);
foreach (var action in _actions)
{
action(type, builder);
}
context.RegisterObjectDefinition(_nameResolver(type), builder.ObjectDefinition);
}
protected override ObjectDefinitionBuilder ParseHandler(XmlElement element, ParserContext parserContext)
{
ObjectDefinitionBuilder builder = ObjectDefinitionBuilder.GenericObjectDefinition(IntegrationNamespaceUtils.TRANSFORMER_PACKAGE + ".MessageTransformingHandler");
ObjectDefinitionBuilder transformerBuilder = ObjectDefinitionBuilder.GenericObjectDefinition(TransformerClassName);
ParseTransformer(element, parserContext, transformerBuilder);
string transformerBeanName = parserContext.ReaderContext.RegisterWithGeneratedName(transformerBuilder.ObjectDefinition);
builder.AddConstructorArgReference(transformerBeanName);
return(builder);
}
private object ParseKeyInterest(ParserContext parserContext, XmlElement subElement)
{
ObjectDefinitionBuilder keyInterestBuilder = ObjectDefinitionBuilder.GenericObjectDefinition(typeof(KeyInterest));
ParseCommonInterestAttr(subElement, keyInterestBuilder);
Object key = ParsingUtils.ParseRefOrNestedObjectDeclaration(parserContext, subElement, keyInterestBuilder, "key-ref");
keyInterestBuilder.AddConstructorArg(key);
return(keyInterestBuilder.ObjectDefinition);
}
private void RegisterDefaultConfiguringObjectFactoryPostProcessorIfNecessary(ParserContext parserContext)
{
if (!parserContext.Registry.IsObjectNameInUse(DEFAULT_CONFIGURING_POSTPROCESSOR_OBJECT_NAME))
{
ObjectDefinitionBuilder builder =
ObjectDefinitionBuilder.GenericObjectDefinition(IntegrationNamespaceUtils.CONFIG_XML_PACKAGE + "." +
DEFAULT_CONFIGURING_POSTPROCESSOR_SIMPLE_CLASS_NAME);
ObjectDefinitionHolder holder = new ObjectDefinitionHolder(builder.ObjectDefinition,
DEFAULT_CONFIGURING_POSTPROCESSOR_OBJECT_NAME);
ObjectDefinitionReaderUtils.RegisterObjectDefinition(holder, parserContext.Registry);
}
}
/**
* Parse a "cron-trigger" element
*/
private static string ParseCronTrigger(XmlElement element, ParserContext parserContext)
{
string cronExpression = element.GetAttribute("expression");
if (!StringUtils.HasText(cronExpression))
{
parserContext.ReaderContext.ReportException(element, element.Name, "the 'expression' attribute is required for a <cron-trigger/>");
}
ObjectDefinitionBuilder builder = ObjectDefinitionBuilder.GenericObjectDefinition(IntegrationNamespaceUtils.SCHEDULING_PACKAGE + ".CronTrigger");
builder.AddConstructorArg(cronExpression);
return(parserContext.ReaderContext.RegisterWithGeneratedName(builder.ObjectDefinition));
}
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);
}
protected override string ParseSource(XmlElement element, ParserContext parserContext)
{
ObjectDefinitionBuilder builder = ObjectDefinitionBuilder.GenericObjectDefinition(typeof(NmsDestinationPollingSource));
string nmsTemplate = element.GetAttribute(NmsAdapterParserUtils.NMS_TEMPLATE_ATTRIBUTE);
string destination = element.GetAttribute(NmsAdapterParserUtils.DESTINATION_ATTRIBUTE);
string destinationName = element.GetAttribute(NmsAdapterParserUtils.DESTINATION_NAME_ATTRIBUTE);
string headerMapper = element.GetAttribute(NmsAdapterParserUtils.HEADER_MAPPER_ATTRIBUTE);
if (StringUtils.HasText(nmsTemplate))
{
if (element.HasAttribute(NmsAdapterParserUtils.CONNECTION_FACTORY_ATTRIBUTE) ||
element.HasAttribute(NmsAdapterParserUtils.DESTINATION_NAME_ATTRIBUTE) ||
element.HasAttribute(NmsAdapterParserUtils.DESTINATION_ATTRIBUTE))
{
throw new ObjectCreationException(
"When providing '" + NmsAdapterParserUtils.NMS_TEMPLATE_ATTRIBUTE +
"', none of '" + NmsAdapterParserUtils.CONNECTION_FACTORY_ATTRIBUTE +
"', '" + NmsAdapterParserUtils.DESTINATION_ATTRIBUTE + "', or '" +
NmsAdapterParserUtils.DESTINATION_NAME_ATTRIBUTE + "' should be provided.");
}
builder.AddConstructorArgReference(nmsTemplate);
}
else if (StringUtils.HasText(destination) || StringUtils.HasText(destinationName))
{
builder.AddConstructorArgReference(NmsAdapterParserUtils.DetermineConnectionFactoryBeanName(element,
parserContext));
if (StringUtils.HasText(destination))
{
builder.AddConstructorArgReference(destination);
}
else if (StringUtils.HasText(destinationName))
{
builder.AddConstructorArg(destinationName);
}
}
else
{
throw new ObjectCreationException("either a '" + NmsAdapterParserUtils.NMS_TEMPLATE_ATTRIBUTE + "' or one of '" +
NmsAdapterParserUtils.DESTINATION_ATTRIBUTE + "' or '" + NmsAdapterParserUtils.DESTINATION_NAME_ATTRIBUTE +
"' attributes must be provided for a polling NMS adapter");
}
if (StringUtils.HasText(headerMapper))
{
builder.AddPropertyReference(NmsAdapterParserUtils.HEADER_MAPPER_PROPERTY, headerMapper);
}
IntegrationNamespaceUtils.SetValueIfAttributeDefined(builder, element, "extract-payload");
IntegrationNamespaceUtils.SetReferenceIfAttributeDefined(builder, element, "destination-resolver");
return(parserContext.ReaderContext.RegisterWithGeneratedName(builder.ObjectDefinition));
}
/// <summary>Adds the constructor arg parent ref if attribute defined.</summary>
/// <param name="builder">The builder.</param>
/// <param name="element">The element.</param>
/// <param name="attributeName">Name of the attribute.</param>
/// <returns><c>true</c> if [is attribute defined] [the specified element]; otherwise, <c>false</c>.</returns>
public static bool AddConstructorArgParentRefIfAttributeDefined(ObjectDefinitionBuilder builder, XmlElement element, string attributeName)
{
var value = element.GetAttribute(attributeName);
if (!string.IsNullOrWhiteSpace(value))
{
var child = ObjectDefinitionBuilder.GenericObjectDefinition();
child.RawObjectDefinition.ParentName = value;
builder.AddConstructorArg(child.ObjectDefinition);
return(true);
}
return(false);
}
protected override AbstractObjectDefinition ParseConsumer(XmlElement element, ParserContext parserContext)
{
ObjectDefinitionBuilder invokerBuilder = ObjectDefinitionBuilder.GenericObjectDefinition(IntegrationNamespaceUtils.HANDLER_PACKAGE + ".MethodInvokingMessageHandler");
invokerBuilder.AddConstructorArgReference(element.GetAttribute("ref"));
invokerBuilder.AddConstructorArg(element.GetAttribute("method"));
string order = element.GetAttribute("order");
if (StringUtils.HasText(order))
{
invokerBuilder.AddPropertyValue("order", order);
}
return(invokerBuilder.ObjectDefinition);
}
public void TestSchedulerAutoStartupFalse()
{
StaticApplicationContext context = new StaticApplicationContext();
ObjectDefinitionBuilder beanDefinition = ObjectDefinitionBuilder
.GenericObjectDefinition(typeof(SchedulerFactoryObject))
.AddPropertyValue("autoStartup", false);
context.RegisterObjectDefinition("scheduler", beanDefinition.ObjectDefinition);
IScheduler scheduler = (IScheduler)context.GetObject("scheduler", typeof(IScheduler));
Assert.IsFalse(scheduler.IsStarted);
context.Refresh();
Assert.IsFalse(scheduler.IsStarted);
}