private static void HandleLogging(
ConfigurationRuntime runtime,
XmlElement element)
{
var nodeIterator = DOMElementEnumerator.Create(element.ChildNodes);
while (nodeIterator.MoveNext()) {
var subElement = nodeIterator.Current;
switch (subElement.Name) {
case "execution-path": {
var valueText = GetRequiredAttribute(subElement, "enabled");
var value = bool.Parse(valueText);
runtime.Logging.IsEnableExecutionDebug = value;
break;
}
case "timer-debug": {
var valueText = GetRequiredAttribute(subElement, "enabled");
var value = bool.Parse(valueText);
runtime.Logging.IsEnableTimerDebug = value;
break;
}
case "audit":
runtime.Logging.AuditPattern = GetOptionalAttribute(subElement, "pattern");
break;
}
}
}
private static void HandleTimeSource(
ConfigurationRuntime runtime,
XmlElement element)
{
var nodeIterator = DOMElementEnumerator.Create(element.ChildNodes);
while (nodeIterator.MoveNext()) {
var subElement = nodeIterator.Current;
if (subElement.Name == "time-source-type") {
var valueText = GetRequiredAttribute(subElement, "value");
if (valueText == null) {
throw new ConfigurationException("No value attribute supplied for time-source element");
}
TimeSourceType timeSourceType;
valueText = valueText.ToUpperInvariant().Trim();
switch (valueText) {
case "NANO":
timeSourceType = TimeSourceType.NANO;
break;
case "MILLI":
timeSourceType = TimeSourceType.MILLI;
break;
default:
throw new ConfigurationException(
"Value attribute for time-source element invalid, " +
"expected one of the following keywords: nano, milli");
}
runtime.TimeSource.TimeSourceType = timeSourceType;
}
}
}
/// <summary>
/// Configure the runtime section from a provided element
/// </summary>
/// <param name="runtime">runtime section</param>
/// <param name="runtimeElement">element</param>
public static void DoConfigure(
ConfigurationRuntime runtime,
XmlElement runtimeElement)
{
var eventTypeNodeIterator = DOMElementEnumerator.Create(runtimeElement.ChildNodes);
while (eventTypeNodeIterator.MoveNext()) {
var element = eventTypeNodeIterator.Current;
var nodeName = element.Name;
switch (nodeName) {
case "plugin-loader":
HandlePluginLoaders(runtime, element);
break;
case "threading":
HandleThreading(runtime, element);
break;
case "logging":
HandleLogging(runtime, element);
break;
case "variables":
HandleVariables(runtime, element);
break;
case "time-source":
HandleTimeSource(runtime, element);
break;
case "metrics-reporting":
HandleMetricsReporting(runtime, element);
break;
case "exceptionHandling":
HandleExceptionHandling(runtime, element);
break;
case "conditionHandling":
HandleConditionHandling(runtime, element);
break;
case "patterns":
HandlePatterns(runtime, element);
break;
case "match-recognize":
HandleMatchRecognize(runtime, element);
break;
case "expression":
HandleExpression(runtime, element);
break;
case "execution":
HandleExecution(runtime, element);
break;
}
}
}
private static void HandleMetricsReporting(
ConfigurationRuntime runtime,
XmlElement element)
{
ParseOptionalBoolean(element, "enabled", b => runtime.MetricsReporting.WithMetricsReporting(b));
var runtimeInterval = GetOptionalAttribute(element, "runtime-interval");
if (runtimeInterval != null) {
runtime.MetricsReporting.RuntimeInterval = long.Parse(runtimeInterval);
}
var statementInterval = GetOptionalAttribute(element, "statement-interval");
if (statementInterval != null) {
runtime.MetricsReporting.StatementInterval = long.Parse(statementInterval);
}
var threading = GetOptionalAttribute(element, "threading");
if (threading != null) {
runtime.MetricsReporting.IsThreading = bool.Parse(threading);
}
var runtimeMetrics = GetOptionalAttribute(element, "runtime-metrics");
if (runtimeMetrics != null) {
runtime.MetricsReporting.IsRuntimeMetrics = bool.Parse(runtimeMetrics);
}
var nodeIterator = DOMElementEnumerator.Create(element.ChildNodes);
while (nodeIterator.MoveNext()) {
var subElement = nodeIterator.Current;
if (subElement.Name == "stmtgroup") {
var name = GetRequiredAttribute(subElement, "name");
var interval = long.Parse(GetRequiredAttribute(subElement, "interval"));
var metrics = new ConfigurationRuntimeMetricsReporting.StmtGroupMetrics();
metrics.Interval = interval;
runtime.MetricsReporting.AddStmtGroup(name, metrics);
var defaultInclude = GetOptionalAttribute(subElement, "default-include");
if (defaultInclude != null) {
metrics.IsDefaultInclude = bool.Parse(defaultInclude);
}
var numStmts = GetOptionalAttribute(subElement, "num-stmts");
if (numStmts != null) {
metrics.NumStatements = int.Parse(numStmts);
}
var reportInactive = GetOptionalAttribute(subElement, "report-inactive");
if (reportInactive != null) {
metrics.IsReportInactive = bool.Parse(reportInactive);
}
HandleMetricsReportingPatterns(metrics, subElement);
}
}
}
private static void HandleExceptionHandling(
ConfigurationRuntime runtime,
XmlElement element)
{
runtime.ExceptionHandling.AddClasses(GetHandlerFactories(element));
var enableUndeployRethrowStr = GetOptionalAttribute(element, "undeploy-rethrow-policy");
if (enableUndeployRethrowStr != null) {
runtime.ExceptionHandling.UndeployRethrowPolicy =
EnumHelper.Parse<UndeployRethrowPolicy>(enableUndeployRethrowStr);
}
}
private static void HandleExpression(
ConfigurationRuntime runtime,
XmlElement element)
{
ParseOptionalBoolean(element, "self-subselect-preeval", b => runtime.Expression.IsSelfSubselectPreeval = b);
var timeZoneStr = GetOptionalAttribute(element, "time-zone");
if (timeZoneStr != null) {
var timeZone = TimeZoneHelper.GetTimeZoneInfo(timeZoneStr);
runtime.Expression.TimeZone = timeZone;
}
}
private static void HandleVariables(
ConfigurationRuntime runtime,
XmlElement element)
{
var nodeIterator = DOMElementEnumerator.Create(element.ChildNodes);
while (nodeIterator.MoveNext()) {
var subElement = nodeIterator.Current;
if (subElement.Name == "msec-version-release") {
var valueText = GetRequiredAttribute(subElement, "value");
var value = long.Parse(valueText);
runtime.Variables.MsecVersionRelease = value;
}
}
}
private static void HandleExecution(
ConfigurationRuntime runtime,
XmlElement parentElement)
{
ParseOptionalBoolean(parentElement, "prioritized", b => runtime.Execution.IsPrioritized = b);
ParseOptionalBoolean(parentElement, "fairlock", b => runtime.Execution.IsFairlock = b);
ParseOptionalBoolean(parentElement, "disable-locking", b => runtime.Execution.IsDisableLocking = b);
var filterServiceProfileStr = GetOptionalAttribute(parentElement, "filter-service-profile");
if (filterServiceProfileStr != null) {
var profile = EnumHelper.Parse<FilterServiceProfile>(filterServiceProfileStr);
runtime.Execution.FilterServiceProfile = profile;
}
var declExprValueCacheSizeStr = GetOptionalAttribute(parentElement, "declared-expr-value-cache-size");
if (declExprValueCacheSizeStr != null) {
runtime.Execution.DeclaredExprValueCacheSize = int.Parse(declExprValueCacheSizeStr);
}
}
private static void HandlePatterns(
ConfigurationRuntime runtime,
XmlElement element)
{
var nodeIterator = DOMElementEnumerator.Create(element.ChildNodes);
while (nodeIterator.MoveNext()) {
var subElement = nodeIterator.Current;
if (subElement.Name == "max-subexpression") {
var valueText = GetRequiredAttribute(subElement, "value");
var value = long.Parse(valueText);
runtime.Patterns.MaxSubexpressions = value;
var preventText = GetOptionalAttribute(subElement, "prevent-start");
if (preventText != null) {
runtime.Patterns.IsMaxSubexpressionPreventStart = bool.Parse(preventText);
}
}
}
}
private static void HandlePluginLoaders(
ConfigurationRuntime configuration,
XmlElement element)
{
var loaderName = GetRequiredAttribute(element, "name");
var className = GetRequiredAttribute(element, "class-name");
var properties = new Properties();
string configXML = null;
var nodeIterator = DOMElementEnumerator.Create(element.ChildNodes);
while (nodeIterator.MoveNext()) {
var subElement = nodeIterator.Current;
switch (subElement.Name) {
case "init-arg": {
var name = GetRequiredAttribute(subElement, "name");
var value = GetRequiredAttribute(subElement, "value");
properties.Put(name, value);
break;
}
case "config-xml": {
var nodeIter = DOMElementEnumerator.Create(subElement.ChildNodes);
if (!nodeIter.MoveNext()) {
throw new ConfigurationException(
"Error handling config-xml for plug-in loader '" +
loaderName +
"', no child node found under initializer element, expecting an element node");
}
configXML = nodeIter.Current.OuterXml;
break;
}
}
}
configuration.AddPluginLoader(loaderName, className, properties, configXML);
}
private static void HandleThreading(
ConfigurationRuntime runtime,
XmlElement element)
{
ParseOptionalBoolean(element, "runtime-fairlock", b => runtime.Threading.IsRuntimeFairlock = b);
var nodeIterator = DOMElementEnumerator.Create(element.ChildNodes);
while (nodeIterator.MoveNext()) {
var subElement = nodeIterator.Current;
switch (subElement.Name) {
case "listener-dispatch": {
var preserveOrderText = GetRequiredAttribute(subElement, "preserve-order");
var preserveOrder = bool.Parse(preserveOrderText);
runtime.Threading.IsListenerDispatchPreserveOrder = preserveOrder;
if (subElement.Attributes.GetNamedItem("timeout-msec") != null) {
var timeoutMSecText = subElement.Attributes.GetNamedItem("timeout-msec").InnerText;
var timeoutMSec = long.Parse(timeoutMSecText);
runtime.Threading.ListenerDispatchTimeout = timeoutMSec;
}
if (subElement.Attributes.GetNamedItem("locking") != null) {
var value = subElement.Attributes.GetNamedItem("locking").InnerText;
runtime.Threading.ListenerDispatchLocking = EnumHelper.Parse<Locking>(value);
}
break;
}
case "insert-into-dispatch": {
var preserveOrderText = GetRequiredAttribute(subElement, "preserve-order");
var preserveOrder = bool.Parse(preserveOrderText);
runtime.Threading.IsInsertIntoDispatchPreserveOrder = preserveOrder;
if (subElement.Attributes.GetNamedItem("timeout-msec") != null) {
var timeoutMSecText = subElement.Attributes.GetNamedItem("timeout-msec").InnerText;
var timeoutMSec = int.Parse(timeoutMSecText);
runtime.Threading.InsertIntoDispatchTimeout = timeoutMSec;
}
if (subElement.Attributes.GetNamedItem("locking") != null) {
var value = subElement.Attributes.GetNamedItem("locking").InnerText;
runtime.Threading.InsertIntoDispatchLocking = EnumHelper.Parse<Locking>(value);
}
break;
}
case "named-window-consumer-dispatch": {
var preserveOrderText = GetRequiredAttribute(subElement, "preserve-order");
var preserveOrder = bool.Parse(preserveOrderText);
runtime.Threading.IsNamedWindowConsumerDispatchPreserveOrder = preserveOrder;
if (subElement.Attributes.GetNamedItem("timeout-msec") != null) {
var timeoutMSecText = subElement.Attributes.GetNamedItem("timeout-msec").InnerText;
var timeoutMSec = int.Parse(timeoutMSecText);
runtime.Threading.NamedWindowConsumerDispatchTimeout = timeoutMSec;
}
if (subElement.Attributes.GetNamedItem("locking") != null) {
var value = subElement.Attributes.GetNamedItem("locking").InnerText;
runtime.Threading.NamedWindowConsumerDispatchLocking = EnumHelper.Parse<Locking>(value);
}
break;
}
case "internal-timer": {
var enabledText = GetRequiredAttribute(subElement, "enabled");
var enabled = bool.Parse(enabledText);
var msecResolutionText = GetRequiredAttribute(subElement, "msec-resolution");
var msecResolution = long.Parse(msecResolutionText);
runtime.Threading.IsInternalTimerEnabled = enabled;
runtime.Threading.InternalTimerMsecResolution = msecResolution;
break;
}
case "threadpool-inbound": {
var result = ParseThreadPoolConfig(subElement);
runtime.Threading.IsThreadPoolInbound = result.IsEnabled;
runtime.Threading.ThreadPoolInboundNumThreads = result.NumThreads;
runtime.Threading.ThreadPoolInboundCapacity = result.Capacity;
break;
}
case "threadpool-outbound": {
var result = ParseThreadPoolConfig(subElement);
runtime.Threading.IsThreadPoolOutbound = result.IsEnabled;
runtime.Threading.ThreadPoolOutboundNumThreads = result.NumThreads;
runtime.Threading.ThreadPoolOutboundCapacity = result.Capacity;
break;
}
case "threadpool-timerexec": {
var result = ParseThreadPoolConfig(subElement);
runtime.Threading.IsThreadPoolTimerExec = result.IsEnabled;
runtime.Threading.ThreadPoolTimerExecNumThreads = result.NumThreads;
runtime.Threading.ThreadPoolTimerExecCapacity = result.Capacity;
break;
}
case "threadpool-routeexec": {
var result = ParseThreadPoolConfig(subElement);
runtime.Threading.IsThreadPoolRouteExec = result.IsEnabled;
runtime.Threading.ThreadPoolRouteExecNumThreads = result.NumThreads;
runtime.Threading.ThreadPoolRouteExecCapacity = result.Capacity;
break;
}
}
}
}
private static void HandleConditionHandling(
ConfigurationRuntime runtime,
XmlElement element)
{
runtime.ConditionHandling.AddClasses(GetHandlerFactories(element));
}
