public void CustomNLogFactoriesTest()
{
var nlogFactories = new NLogFactories();
nlogFactories.LayoutRendererFactory.RegisterDefinition("foo", typeof(FooLayoutRenderer));
nlogFactories.ConditionMethodFactory.RegisterDefinition("check", typeof(MyConditionMethods).GetMethod("CheckIt"));
var result = ConditionParser.ParseExpression("check('${foo}')", nlogFactories);
}
internal static LayoutRenderer[] CompileLayout(NLogFactories nlogFactories, Tokenizer sr, bool isNested, out string text)
{
var result = new List<LayoutRenderer>();
var literalBuf = new StringBuilder();
int ch;
int p0 = sr.Position;
while ((ch = sr.Peek()) != -1)
{
if (isNested && (ch == '}' || ch == ':'))
{
break;
}
sr.Read();
if (ch == '$' && sr.Peek() == '{')
{
if (literalBuf.Length > 0)
{
result.Add(new LiteralLayoutRenderer(literalBuf.ToString()));
literalBuf.Length = 0;
}
LayoutRenderer newLayoutRenderer = ParseLayoutRenderer(nlogFactories, sr);
if (CanBeConvertedToLiteral(newLayoutRenderer))
{
newLayoutRenderer = ConvertToLiteral(newLayoutRenderer);
}
// layout renderer
result.Add(newLayoutRenderer);
}
else
{
literalBuf.Append((char)ch);
}
}
if (literalBuf.Length > 0)
{
result.Add(new LiteralLayoutRenderer(literalBuf.ToString()));
literalBuf.Length = 0;
}
int p1 = sr.Position;
MergeLiterals(result);
text = sr.Substring(p0, p1);
return result.ToArray();
}
/// <summary>
/// Initializes static members of the NLogFactories class.
/// </summary>
static NLogFactories()
{
Default = new NLogFactories(typeof(Logger).Assembly);
}
/// <summary>
/// Implicitly converts the specified string to a <see cref="SimpleLayout"/>.
/// </summary>
/// <param name="layoutString">The layout string.</param>
/// <param name="nlogFactories">The NLog factories to use when resolving layout renderers.</param>
/// <returns>Instance of <see cref="SimpleLayout"/>.</returns>
public static Layout FromString(string layoutString, NLogFactories nlogFactories)
{
return new SimpleLayout(layoutString, nlogFactories);
}
/// <summary>
/// Parses the specified condition string and turns it into
/// <see cref="ConditionExpression"/> tree.
/// </summary>
/// <param name="expressionText">The expression to be parsed.</param>
/// <param name="nlogFactories">Instance of <see cref="NLogFactories"/> used to resolve references to condition methods and layout renderers.</param>
/// <returns>The root of the expression syntax tree which can be used to get the value of the condition in a specified context.</returns>
public static ConditionExpression ParseExpression(string expressionText, NLogFactories nlogFactories)
{
ConditionParser parser = new ConditionParser(expressionText, nlogFactories);
ConditionExpression expression = parser.ParseExpression();
if (!parser.tokenizer.IsEOF())
{
throw new ConditionParseException("Unexpected token: " + parser.tokenizer.TokenValue);
}
return expression;
}
/// <summary>
/// Initializes a new instance of the <see cref="ConditionParser" /> class.
/// </summary>
/// <param name="expressionText">The expression text.</param>
/// <param name="nlogFactories">Instance of <see cref="NLogFactories"/> used to resolve references to condition methods and layout renderers.</param>
private ConditionParser(string expressionText, NLogFactories nlogFactories)
{
this.nlogFactories = nlogFactories;
this.tokenizer.InitTokenizer(expressionText ?? string.Empty);
}
private static NLogFactories SetupConditionMethods()
{
var factories = new NLogFactories();
factories.ConditionMethodFactory.RegisterDefinition("GetGuid", typeof(MyConditionMethods).GetMethod("GetGuid"));
factories.ConditionMethodFactory.RegisterDefinition("ToInt16", typeof(MyConditionMethods).GetMethod("ToInt16"));
factories.ConditionMethodFactory.RegisterDefinition("ToInt32", typeof(MyConditionMethods).GetMethod("ToInt32"));
factories.ConditionMethodFactory.RegisterDefinition("ToInt64", typeof(MyConditionMethods).GetMethod("ToInt64"));
factories.ConditionMethodFactory.RegisterDefinition("ToDouble", typeof(MyConditionMethods).GetMethod("ToDouble"));
factories.ConditionMethodFactory.RegisterDefinition("ToSingle", typeof(MyConditionMethods).GetMethod("ToSingle"));
factories.ConditionMethodFactory.RegisterDefinition("ToDateTime", typeof(MyConditionMethods).GetMethod("ToDateTime"));
factories.ConditionMethodFactory.RegisterDefinition("ToDecimal", typeof(MyConditionMethods).GetMethod("ToDecimal"));
factories.ConditionMethodFactory.RegisterDefinition("IsValid", typeof(MyConditionMethods).GetMethod("IsValid"));
return factories;
}
public void LayoutRendererThrows()
{
NLogFactories nlogFactories = new NLogFactories();
nlogFactories.LayoutRendererFactory.RegisterDefinition("throwsException", typeof(ThrowsExceptionRenderer));
SimpleLayout l = new SimpleLayout("xx${throwsException}yy", nlogFactories);
string output = l.Render(LogEventInfo.CreateNullEvent());
Assert.AreEqual("xxyy", output);
}
public void LayoutRendererThrows2()
{
string internalLogOutput = RunAndCaptureInternalLog(
() =>
{
NLogFactories nlogFactories = new NLogFactories();
nlogFactories.LayoutRendererFactory.RegisterDefinition("throwsException", typeof(ThrowsExceptionRenderer));
SimpleLayout l = new SimpleLayout("xx${throwsException:msg1}yy${throwsException:msg2}zz", nlogFactories);
string output = l.Render(LogEventInfo.CreateNullEvent());
Assert.AreEqual("xxyyzz", output);
},
LogLevel.Warn);
Assert.IsTrue(internalLogOutput.IndexOf("msg1") >= 0, internalLogOutput);
Assert.IsTrue(internalLogOutput.IndexOf("msg2") >= 0, internalLogOutput);
}
static int Main(string[] args)
{
if (args.Length < 2)
{
Console.WriteLine("Usage: MakeNLogXSD outputfile.xsd path_to_doc.xml");
return 1;
}
var factories = new NLogFactories();
try
{
docXml.Load(args[1]);
for (int i = 2; i < args.Length; ++i)
{
try
{
Assembly asm = Assembly.Load(args[i]);
factories.RegisterItemsFromAssembly(asm, "");
}
catch (Exception ex)
{
Console.WriteLine("WARNING: {0}", ex.Message);
}
}
StringWriter sw = new StringWriter();
sw.Write("<root xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">");
XmlTextWriter xtw = new XmlTextWriter(sw);
xtw.Namespaces = false;
xtw.Formatting = Formatting.Indented;
typeDumped[typeof(object)] = 1;
typeDumped[typeof(Target)] = 1;
typeDumped[typeof(TargetWithLayout)] = 1;
typeDumped[typeof(TargetWithLayoutHeaderAndFooter)] = 1;
typeDumped[typeof(Layout)] = 1;
foreach (var target in factories.TargetFactory.AllRegisteredItems)
{
DumpType(xtw, target.Value);
}
foreach (var filter in factories.FilterFactory.AllRegisteredItems)
{
DumpType(xtw, filter.Value);
}
foreach (var layout in factories.LayoutFactory.AllRegisteredItems)
{
DumpType(xtw, layout.Value);
}
xtw.Flush();
sw.Write("</root>");
sw.Flush();
XmlDocument doc2 = new XmlDocument();
doc2.LoadXml(sw.ToString());
using (Stream templateStream = Assembly.GetEntryAssembly().GetManifestResourceStream("MakeNLogXSD.TemplateNLog.xsd"))
{
XmlDocument doc = new XmlDocument();
doc.Load(templateStream);
XmlNamespaceManager nsmgr = new XmlNamespaceManager(doc.NameTable);
nsmgr.AddNamespace("", "http://www.w3.org/2001/XMLSchema");
XmlNode n = doc.SelectSingleNode("//types-go-here");
foreach (XmlElement el in doc2.DocumentElement.ChildNodes)
{
XmlNode importedNode = doc.ImportNode(el, true);
n.ParentNode.InsertBefore(importedNode, n);
}
n.ParentNode.RemoveChild(n);
n = doc.SelectSingleNode("//filters-go-here");
foreach (var filter in factories.FilterFactory.AllRegisteredItems)
{
XmlElement el = doc.CreateElement("xs:element", XmlSchema.Namespace);
el.SetAttribute("name", filter.Key);
el.SetAttribute("type", SimpleTypeName(filter.Value));
n.ParentNode.InsertBefore(el, n);
}
n.ParentNode.RemoveChild(n);
Console.WriteLine("Saving schema to: {0}", args[0]);
doc.Save(args[0]);
return 0;
}
}
catch (Exception ex)
{
Console.WriteLine("ERROR: {0}", ex);
return 1;
}
}
public void MethodNameWithUnderscores()
{
var nlogFactories = new NLogFactories();
nlogFactories.LayoutRendererFactory.RegisterDefinition("foo", typeof(FooLayoutRenderer));
nlogFactories.ConditionMethodFactory.RegisterDefinition("__check__", typeof(MyConditionMethods).GetMethod("CheckIt"));
var result = ConditionParser.ParseExpression("__check__('${foo}')", nlogFactories);
}
internal SimpleLayout(LayoutRenderer[] renderers, string text, NLogFactories nlogFactories)
{
this.nlogFactories = nlogFactories;
this.SetRenderers(renderers, text);
}
/// <summary>
/// Initializes a new instance of the <see cref="SimpleLayout"/> class.
/// </summary>
/// <param name="txt">The layout string to parse.</param>
/// <param name="nlogFactories">The NLog factories to use when creating references to layout renderers.</param>
public SimpleLayout(string txt, NLogFactories nlogFactories)
{
this.nlogFactories = nlogFactories;
this.Text = txt;
}
private static LayoutRenderer ParseLayoutRenderer(NLogFactories nlogFactories, Tokenizer sr)
{
int ch = sr.Read();
Debug.Assert(ch == '{', "'{' expected in layout specification");
string name = ParseLayoutRendererName(sr);
LayoutRenderer lr = nlogFactories.LayoutRendererFactory.CreateInstance(name);
var wrappers = new Dictionary<Type, LayoutRenderer>();
var orderedWrappers = new List<LayoutRenderer>();
ch = sr.Read();
while (ch != -1 && ch != '}')
{
string parameterName = ParseParameterName(sr).Trim();
if (sr.Peek() == '=')
{
sr.Read(); // skip the '='
PropertyInfo pi;
LayoutRenderer parameterTarget = lr;
if (!PropertyHelper.TryGetPropertyInfo(lr, parameterName, out pi))
{
Type wrapperType;
if (nlogFactories.AmbientPropertyFactory.TryGetDefinition(parameterName, out wrapperType))
{
LayoutRenderer wrapperRenderer;
if (!wrappers.TryGetValue(wrapperType, out wrapperRenderer))
{
wrapperRenderer = nlogFactories.AmbientPropertyFactory.CreateInstance(parameterName);
wrappers[wrapperType] = wrapperRenderer;
orderedWrappers.Add(wrapperRenderer);
}
if (!PropertyHelper.TryGetPropertyInfo(wrapperRenderer, parameterName, out pi))
{
pi = null;
}
else
{
parameterTarget = wrapperRenderer;
}
}
}
if (pi == null)
{
ParseParameterValue(sr);
}
else
{
if (typeof(Layout).IsAssignableFrom(pi.PropertyType))
{
var nestedLayout = new SimpleLayout();
string txt;
LayoutRenderer[] renderers = CompileLayout(nlogFactories, sr, true, out txt);
nestedLayout.SetRenderers(renderers, txt);
pi.SetValue(parameterTarget, nestedLayout, null);
}
else
{
string value = ParseParameterValue(sr);
PropertyHelper.SetPropertyFromString(parameterTarget, parameterName, value, null);
}
}
}
else
{
// what we've just read is not a parameterName, but a value
// assign it to a default property (denoted by empty string)
PropertyInfo pi;
if (PropertyHelper.TryGetPropertyInfo(lr, string.Empty, out pi))
{
if (typeof(SimpleLayout) == pi.PropertyType)
{
pi.SetValue(lr, new SimpleLayout(parameterName), null);
}
else
{
string value = parameterName;
PropertyHelper.SetPropertyFromString(lr, pi.Name, value, null);
}
}
else
{
InternalLogger.Warn("{0} has no default property", lr.GetType().FullName);
}
}
ch = sr.Read();
}
lr = ApplyWrappers(nlogFactories, lr, orderedWrappers);
return lr;
}
private static LayoutRenderer ApplyWrappers(NLogFactories nlogFactories, LayoutRenderer lr, List<LayoutRenderer> orderedWrappers)
{
for (int i = orderedWrappers.Count - 1; i >= 0; --i)
{
var newRenderer = (WrapperLayoutRendererBase)orderedWrappers[i];
InternalLogger.Trace("Wrapping {0} with {1}", lr.GetType().Name, newRenderer.GetType().Name);
if (CanBeConvertedToLiteral(lr))
{
lr = ConvertToLiteral(lr);
}
newRenderer.Inner = new SimpleLayout(new[] { lr }, string.Empty, nlogFactories);
lr = newRenderer;
}
return lr;
}