/// <summary>
/// Takes optional args[] and root configuration. If configuration is null then
/// application is configured from a file co-located with entry-point assembly and
/// called the same name as assembly with '.config' extension, unless args are specified and "/config file"
/// switch is used in which case 'file' has to be locatable and readable.
/// </summary>
public BaseApplication(string[] args, ConfigSectionNode rootConfig)
{
lock(typeof(BaseApplication))
{
if (s_Instance != null) throw new WFormsException(StringConsts.APP_INSTANCE_ALREADY_CREATED_ERROR);
try
{
Configuration argsConfig;
if (args != null)
argsConfig = new CommandArgsConfiguration(args);
else
argsConfig = new MemoryConfiguration();
m_CommandArgs = argsConfig.Root;
m_ConfigRoot = rootConfig ?? GetConfiguration().Root;
InitApplication();
s_Instance = this;
}
catch
{
Destructor();
throw;
}
}
}
/// <summary>
/// Initializes local installation, tries to read local manifest from rootPath or localManifestDir if it is !=null
/// </summary>
public LocalInstallation(string rootPath, string localManifestDir = null)
{
if (rootPath.IsNullOrWhiteSpace())
throw new NFXIOException(StringConsts.ARGUMENT_ERROR + GetType().Name + ".ctor(rootPath==null|empty)");
var parent = Directory.GetParent(rootPath);
if (!parent.Exists)
throw new NFXIOException(StringConsts.LOCAL_INSTALL_ROOT_PATH_NOT_FOUND_ERROR.Args(parent.FullName));
m_RootPath = rootPath;
var manifestDir = localManifestDir.IsNotNullOrWhiteSpace() ? localManifestDir : m_RootPath;
if (Directory.Exists(manifestDir))
{
var fn = Path.Combine(manifestDir, ManifestUtils.MANIFEST_FILE_NAME);
if (File.Exists(fn))
try
{
m_Packages = new LaconicConfiguration(fn).Root;
}
catch(Exception error)
{
throw new NFXIOException(StringConsts.LOCAL_INSTALL_LOCAL_MANIFEST_READ_ERROR.Args(fn, error.ToMessageWithType()), error);
}
}
if (m_Packages==null)
{
var cfg = new LaconicConfiguration();
cfg.Create(ManifestUtils.CONFIG_PACKAGES_SECTION);
m_Packages = cfg.Root;
}
}
/// <summary>
/// Initializaes check list from assembly names separated by semicolons.
/// Optional path will be prepended to every assembly name
/// </summary>
public CheckList(string path, string checkAssemblies, ConfigSectionNode config)
{
path = path ?? string.Empty;
var anames = checkAssemblies.Split(';');
var al = new List<Assembly>();
foreach(var aname in anames)
al.Add(Assembly.LoadFrom(Path.Combine(path, aname)));
load(al, config);
}
private void reportCheck(ConfigSectionNode parent, BaseCheck check)
{
var node = parent.AddChildNode("check", null);
node.AddAttributeNode("name", check.Name);
node.AddAttributeNode("description", check.Description);
node.AddAttributeNode("skipped", check.Result.Skipped);
node.AddAttributeNode("successful", check.Result.Successful);
node.AddAttributeNode("error", check.Result.Exception!=null? check.Result.Exception.ToString() : string.Empty);
var keys = node.AddChildNode("results", null);
foreach(var kv in check.Result)
keys.AddChildNode(kv.Key, kv.Value);
}
public TestApplication(ConfigSectionNode cfgRoot = null)
{
this.ConfigRoot = cfgRoot;
Active = true;
StartTime = DateTime.Now;
Log = NOPLog.Instance;
Instrumentation = NOPInstrumentation.Instance;
Throttling = NOPThrottling.Instance;
DataStore = NOPDataStore.Instance;
ObjectStore = NOPObjectStore.Instance;
Glue = NOPGlue.Instance;
SecurityManager = NOPSecurityManager.Instance;
TimeSource = NFX.Time.DefaultTimeSource.Instance;
TimeLocation = new Time.TimeLocation();
EventTimer = NFX.Time.NOPEventTimer.Instance;
ApplicationModel.ExecutionContext.__SetApplicationLevelContext(this, null, null, NOPSession.Instance);
}
private void doBLOCK(Stopwatch sw, ConfigSectionNode blockStatement, ConfigSectionNode target)
{
initStatement(blockStatement);
doNode(sw, blockStatement, target);
}
private static void buildDirLevel(ConfigSectionNode pNode, FileSystemDirectory directory)
{
const int BUFF_SIZE = 64 * 1024;
foreach(var sdn in directory.SubDirectoryNames)
using(var sdir = directory.GetSubDirectory(sdn))
{
var dnode = pNode.AddChildNode(CONFIG_DIR_SECTION);
dnode.AddAttributeNode(CONFIG_NAME_ATTR, sdir.Name);
buildDirLevel(dnode, sdir);
}
foreach(var fn in directory.FileNames.Where(fn => !string.Equals(fn, MANIFEST_FILE_NAME, StringComparison.InvariantCultureIgnoreCase)))
using(var file = directory.GetFile(fn))
{
var fnode = pNode.AddChildNode(CONFIG_FILE_SECTION);
fnode.AddAttributeNode(CONFIG_NAME_ATTR, file.Name);
long size = 0;
var csum = new Adler32();
var buff = new byte[BUFF_SIZE];
using(var fs = file.FileStream)
while(true)
{
var read = fs.Read(buff, 0, BUFF_SIZE);
if (read<=0) break;
size += read;
csum.Add(buff, 0, read);
}
fnode.AddAttributeNode(CONFIG_SIZE_ATTR, size);
fnode.AddAttributeNode(CONFIG_CSUM_ATTR, csum.Value);
}
}
private ConfigSectionNode buildSection(string name, JSONDataMap sectData, ConfigSectionNode parent)
{
var value = sectData[SECTION_VALUE_ATTR].AsString();
ConfigSectionNode result = parent==null ? new ConfigSectionNode(this, null, name, value)
: parent.AddChildNode(name, value);
foreach(var kvp in sectData)
{
if (kvp.Value is JSONDataMap)
buildSection(kvp.Key, (JSONDataMap)kvp.Value, result);
else if (kvp.Value is JSONDataArray)
{
var lst = (JSONDataArray)kvp.Value;
foreach(var lnode in lst)
{
var lmap = lnode as JSONDataMap;
if (lmap==null)
throw new ConfigException(StringConsts.CONFIG_JSON_STRUCTURE_ERROR, new ConfigException("Bad structure: "+sectData.ToJSON()));
buildSection(kvp.Key, lmap, result);
}
}
else
result.AddAttributeNode(kvp.Key, kvp.Value);
}
return result;
}
private void initStatement(ConfigSectionNode statement)
{
statement.m_Script_Statement = true;
}
private void doCALL(Stopwatch sw, ConfigSectionNode callStatement, ConfigSectionNode target)
{
initStatement(callStatement);
var path = callStatement.Value;
var callTarget = callStatement.NavigateSection(path);
if (!callTarget.Exists)
throw new ConfigException(StringConsts.CONFIGURATION_SCRIPT_CALL_TARGET_PATH_ERROR.Args(callStatement.RootPath, path) );
doNode(sw, callTarget, target);
}
private ConfigSectionNode buildNode(XmlNode xnode, ConfigSectionNode parent)
{
ConfigSectionNode result;
if (xnode.NodeType == XmlNodeType.Text && parent != null)
{
parent.Value = xnode.Value;
return null;
}
if (parent != null)
result = parent.AddChildNode(xnode.Name, string.Empty);
else
result = new ConfigSectionNode(this, null, xnode.Name, string.Empty);
if (xnode.Attributes != null)
foreach (XmlAttribute xattr in xnode.Attributes)
result.AddAttributeNode(xattr.Name, xattr.Value);
foreach (XmlNode xn in xnode)
if (xn.NodeType != XmlNodeType.Comment)
buildNode(xn, result);
return result;
}
private void processIncludes(ConfigSectionNode node, HashSet<string> alreadyIncluded)
{
foreach(var includeNode in node.Children.Where(cn=>cn.IsSameName(CONFIG_INCLUDE_SECTION)))
{
var include = includeNode.Value;
if (!File.Exists(include))
{
foreach(var path in m_IncludePaths)
{
var fn = Path.Combine(path, include);
if (File.Exists(fn))
{
include = fn;
break;
}
}
}
if (!File.Exists(include))
throw new SchemaException(StringConsts.SCHEMA_INCLUDE_FILE_DOSNT_EXIST_ERROR + include);
if (alreadyIncluded.Contains(include))
throw new SchemaException(StringConsts.SCHEMA_INCLUDE_FILE_REFERENCED_MORE_THAN_ONCE_ERROR + include);
alreadyIncluded.Add( include );
var included = Configuration.ProviderLoadFromFile( include );
processIncludes(included.Root, alreadyIncluded);
includeNode.Configuration.Include(includeNode, included.Root);
}
}
public override ConfigSectionNode ProvideMetadata(MemberInfo member, object instance, IMetadataGenerator context, ConfigSectionNode dataRoot, NodeOverrideRules overrideRules = null)
{
var data = "score=110 description='Cars built in Japan' origin{_override=stop country=jap} z=1".AsLaconicConfig();
dataRoot.MergeAttributes(data);
dataRoot.MergeSections(data);
return(dataRoot);
}
public override ConfigSectionNode ProvideMetadata(MemberInfo member, object instance, IMetadataGenerator context, ConfigSectionNode dataRoot, NodeOverrideRules overrideRules = null)
{
var data = "score=40 description='Luxury item, but unreliable' origin{country=XYZYZ/*this will never take effect*/}".AsLaconicConfig();
dataRoot.MergeAttributes(data);
dataRoot.MergeSections(data);
return(dataRoot);
}
public override ConfigSectionNode ProvideMetadata(MemberInfo member, object instance, IMetadataGenerator context, ConfigSectionNode dataRoot, NodeOverrideRules overrideRules = null)
{
var data = "score=90 description='Very usable and decent quality' a=-900".AsLaconicConfig();
dataRoot.MergeAttributes(data);
dataRoot.MergeSections(data);
return(dataRoot);
}
public override ConfigSectionNode ProvideMetadata(MemberInfo member, object instance, IMetadataGenerator context, ConfigSectionNode dataRoot, NodeOverrideRules overrideRules = null)
{
var data = "a=123 b=789 score=100 description='Generic car' origin{_override=all country=world} z=0".AsLaconicConfig();
dataRoot.MergeAttributes(data);
dataRoot.MergeSections(data);
return(dataRoot);
}
private Amount Convert(ConfigSectionNode config, string rateTable, Amount amount, string currencyISO)
{
var market = new ConfigBasedCurrencyMarket(config);
return market.ConvertCurrency(rateTable, amount, currencyISO);
}
private Amount Convert(ConfigSectionNode config, Amount amount, string currencyISO)
{
return Convert(config, NO_RATE_TABLE, amount, currencyISO);
}
public void Inventorize(Type t, ConfigSectionNode root)
{
InventorizationManager.WriteInventoryAttributes(
t.GetCustomAttributes(typeof(InventoryAttribute), false).Cast <InventoryAttribute>(),
root.AddChildNode(InventorizationManager.ATTRIBUTES_NODE));
if (t.BaseType != null)
{
root.AddAttributeNode("base", t.BaseType.FullName);
}
root.AddAttributeNode("abstract", t.IsAbstract);
root.AddAttributeNode("class", t.IsClass);
root.AddAttributeNode("enum", t.IsEnum);
root.AddAttributeNode("intf", t.IsInterface);
root.AddAttributeNode("nested", t.IsNested);
root.AddAttributeNode("public", t.IsPublic);
root.AddAttributeNode("sealed", t.IsSealed);
root.AddAttributeNode("serializable", t.IsSerializable);
root.AddAttributeNode("valuetype", t.IsValueType);
root.AddAttributeNode("visible", t.IsVisible);
var members = t.GetMembers().Where(m => m.GetCustomAttributes(typeof(InventoryAttribute), false).Count() > 0);
foreach (var mem in members)
{
var mnode = root.AddChildNode("member");
mnode.AddAttributeNode("name", mem.Name);
mnode.AddAttributeNode("kind", mem.MemberType.ToString());
InventorizationManager.WriteInventoryAttributes(
mem.GetCustomAttributes(typeof(InventoryAttribute), false).Cast <InventoryAttribute>(),
mnode.AddChildNode(InventorizationManager.ATTRIBUTES_NODE));
if (mem is PropertyInfo)
{
var pinf = (PropertyInfo)mem;
mnode.AddAttributeNode("can-get", pinf.CanRead);
mnode.AddAttributeNode("can-set", pinf.CanWrite);
mnode.AddAttributeNode("type", pinf.PropertyType.FullName);
}
else
if (mem is FieldInfo)
{
var finf = (FieldInfo)mem;
mnode.AddAttributeNode("not-serialized", finf.IsNotSerialized);
mnode.AddAttributeNode("public", finf.IsPublic);
mnode.AddAttributeNode("private", finf.IsPrivate);
mnode.AddAttributeNode("static", finf.IsStatic);
mnode.AddAttributeNode("type", finf.FieldType.FullName);
}
else
if (mem is MethodInfo)
{
var minf = (MethodInfo)mem;
mnode.AddAttributeNode("virtual", minf.IsVirtual);
mnode.AddAttributeNode("public", minf.IsPublic);
mnode.AddAttributeNode("private", minf.IsPrivate);
mnode.AddAttributeNode("static", minf.IsStatic);
if (minf.ReturnType != null)
{
mnode.AddAttributeNode("return-type", minf.ReturnType.FullName);
}
}
}
}
protected virtual void DoNode(Stopwatch sw, ConfigSectionNode source, ConfigSectionNode target)
{
if (source == null || !source.Exists)
{
return;
}
if (target == null || !target.Exists)
{
return;
}
if (m_TimeoutMs > 0 && sw.ElapsedMilliseconds > m_TimeoutMs)
{
throw new ConfigException(StringConsts.CONFIGURATION_SCRIPT_TIMEOUT_ERROR.Args(m_TimeoutMs, source.RootPath));
}
ConfigSectionNode priorStatement = null;
foreach (var subSource in source.Children)
{
if (subSource.IsSameName(KeywordBLOCK))
{
DoBLOCK(sw, subSource, target);
}
else if (subSource.IsSameName(KeywordIF))
{
DoIF(sw, subSource, target);
}
else if (subSource.IsSameName(KeywordELSE))
{
DoELSE(sw, subSource, priorStatement, target);
}
else if (subSource.IsSameName(KeywordLOOP))
{
DoLOOP(sw, subSource, target);
}
else if (subSource.IsSameName(KeywordSET))
{
DoSET(sw, subSource);
}
else if (subSource.IsSameName(KeywordCALL))
{
DoCALL(sw, subSource, target);
}
else
{
var scriptOnly = false;
var scriptOnlyAttr = subSource.AttrByName(AttributeScriptOnly);
if (scriptOnlyAttr.Exists)
{
scriptOnly = scriptOnlyAttr.ValueAsBool(false);
}
if (!scriptOnly)
{
var underStatement = false;
var p = subSource;
while (p != null && p.Exists)
{
if (p.m_Script_Statement)
{
underStatement = true;
break;
}
p = p.Parent;
}
var newTarget = target.AddChildNode(subSource.EvaluateValueVariables(subSource.Name), underStatement ? subSource.Value : subSource.VerbatimValue);
CloneAttributes(subSource, newTarget, underStatement);
DoNode(sw, subSource, newTarget);
}
priorStatement = null;
continue;
}
priorStatement = subSource;
}
}
protected virtual void DoELSE(Stopwatch sw, ConfigSectionNode elseStatement, ConfigSectionNode priorStatement, ConfigSectionNode target)
{
if (priorStatement == null || !priorStatement.IsSameName(DEFAULT_KEYWORD_IF))
{
throw new ConfigException(StringConsts.CONFIGURATION_SCRIPT_ELSE_NOT_AFTER_IF_ERROR.Args(elseStatement.RootPath));
}
InitStatement(elseStatement);
var condition = priorStatement.m_Script_Bool_Condition_Result;
if (condition)
{
return;
}
DoNode(sw, elseStatement, target);
}
public override ConfigSectionNode ProvideMetadata(MemberInfo member, object instance, IMetadataGenerator context, ConfigSectionNode dataRoot, NodeOverrideRules overrideRules = null)
{
var data = "description='Honda motors'".AsLaconicConfig();
dataRoot.MergeAttributes(data);
dataRoot.MergeSections(data);
return(dataRoot);
}
/// <summary>
/// Takes optional application args[] and root configuration.
/// The args are parsed into CommandArgsConfiguration. If configuration is null then
/// application is configured from a file co-located with entry-point assembly and
/// called the same name as assembly with '.config' extension, unless args are specified and "/config file"
/// switch is used in which case 'file' has to be locatable and readable.
/// </summary>
public ServiceBaseApplication(string[] args, ConfigSectionNode rootConfig)
: this(false, args, rootConfig)
{
}
private void load(IEnumerable<Assembly> assemblies, ConfigSectionNode config)
{
foreach(var assembly in assemblies)
foreach(var type in assembly.GetExportedTypes().Where(t=>t.IsSubclassOf(typeof(BaseCheck))))
{
var check = Activator.CreateInstance(type) as BaseCheck;
if (config!=null)
check.Configure(config);
m_Checks.Add(check);
}
}
private void cloneAttributes(ConfigSectionNode from, ConfigSectionNode to, bool evaluate = false)
{
if (evaluate)
foreach(var atr in from.Attributes) to.AddAttributeNode(atr.Name, atr.Value);
else
foreach(var atr in from.Attributes) to.AddAttributeNode(atr.Name, atr.VerbatimValue);
}
public void SetUp()
{
m_Config = LACONF.AsLaconicConfig(handling: ConvertErrorHandling.Throw);
m_App = new ServiceBaseApplication(null, m_Config);
}
public SkyApplication(SystemApplicationType sysAppType, string[] args, ConfigSectionNode rootConfig)
: this(sysAppType, false, args, rootConfig)
{
}
/// <summary>
/// Initializaes check list from assemblies
/// </summary>
public CheckList(IEnumerable<Assembly> checkAssemblies, ConfigSectionNode config)
{
load(checkAssemblies, config);
}
public void SetUp()
{
m_RootCfg = initConf();
}
private ConfigSectionNode describe(Type tController, object instance, ApiDocGenerator.ControllerContext apictx, ConfigSectionNode dataRoot, NodeOverrideRules overrideRules)
{
var cdata = dataRoot.AddChildNode("scope");
var cattr = apictx.ApiDocAttr;
var docContent = tController.GetText(cattr.DocFile ?? "{0}.md".Args(tController.Name));
var ctlTitle = MarkdownUtils.GetTitle(docContent);
var ctlDescription = MarkdownUtils.GetTitleDescription(docContent);
(var drequest, var dresponse) = writeCommon(ctlTitle, ctlDescription, tController, apictx.Generator, cattr, cdata);
cdata.AddAttributeNode("uri-base", cattr.BaseUri);
cdata.AddAttributeNode("auth", cattr.Authentication);
cdata.AddAttributeNode("doc-content-tpl", docContent);
var allMethodContexts = apictx.Generator.GetApiMethods(tController, apictx.ApiDocAttr);
foreach (var mctx in allMethodContexts)
{
var edata = cdata.AddChildNode("endpoint");
(var mrequest, var mresponse) = writeCommon(null, null, mctx.Method, apictx.Generator, mctx.ApiEndpointDocAttr, edata);
var epuri = mctx.ApiEndpointDocAttr.Uri.AsString().Trim();
if (epuri.IsNullOrWhiteSpace())
{
// infer from action attribute
var action = mctx.Method.GetCustomAttributes <ActionBaseAttribute>().FirstOrDefault();
if (action != null)
{
epuri = action.Name;
}
if (epuri.IsNullOrWhiteSpace())
{
epuri = mctx.Method.Name;
}
}
if (!epuri.StartsWith("/"))
{
var bu = cattr.BaseUri.Trim();
if (!bu.EndsWith("/"))
{
bu += "/";
}
epuri = bu + epuri;
}
edata.AddAttributeNode("uri", epuri);
writeCollection(mctx.ApiEndpointDocAttr.Methods, "method", mrequest, ':');
//Get all method attributes except ApiDoc
var epattrs = mctx.Method
.GetCustomAttributes(true)
.Where(a => !(a is ApiDocAttribute) &&
!(a is ActionBaseAttribute) &&
!apictx.Generator.IgnoreTypePatterns.Any(ignore => a.GetType().FullName.MatchPattern(ignore))
);
writeInstanceCollection(epattrs.Where(a => !(a is IInstanceCustomMetadataProvider) ||
(a is IInstanceCustomMetadataProvider cip &&
cip.ShouldProvideInstanceMetadata(apictx.Generator, edata))).ToArray(), TYPE_REF, edata, apictx.Generator);
writeTypeCollection(epattrs.Select(a => a.GetType())
.Where(t => !apictx.Generator.IsWellKnownType(t))
.Distinct()
.ToArray(),
TYPE_REF, edata, apictx.Generator);//distinct attr types
//get method parameters
var epargs = mctx.Method.GetParameters()
.Where(pi => !pi.IsOut &&
!pi.ParameterType.IsByRef &&
!apictx.Generator.IsWellKnownType(pi.ParameterType) &&
!apictx.Generator.IgnoreTypePatterns.Any(ignore => pi.ParameterType.FullName.MatchPattern(ignore))
)
.Select(pi => pi.ParameterType).ToArray();
writeTypeCollection(epargs, TYPE_REF, edata, apictx.Generator);
//docAnchor
var docAnchor = mctx.ApiEndpointDocAttr.DocAnchor.Default("### " + epuri);
var epDocContent = MarkdownUtils.GetSectionContent(docContent, docAnchor);
edata.AddAttributeNode("doc-content-tpl", epDocContent);
//finally regenerate doc content expanding all variables
epDocContent = MarkdownUtils.EvaluateVariables(epDocContent, (v) =>
{
if (v.IsNullOrWhiteSpace())
{
return(v);
}
//Escape: ``{{a}}`` -> `{a}`
if (v.StartsWith("{") && v.EndsWith("}"))
{
return(v.Substring(1, v.Length - 2));
}
if (v.StartsWith("@"))
{
return($"`{{{v}}}`"); //do not expand TYPE spec here
}
//else navigate config path
return(edata.Navigate(v).Value);
});
edata.AddAttributeNode("doc-content", epDocContent);
}//all endpoints
//finally regenerate doc content expanding all variables for the controller
docContent = MarkdownUtils.EvaluateVariables(docContent, (v) =>
{
if (v.IsNullOrWhiteSpace())
{
return(v);
}
//Escape: ``{{a}}`` -> `{a}`
if (v.StartsWith("{") && v.EndsWith("}"))
{
return(v.Substring(1, v.Length - 2));
}
if (v.StartsWith("@"))
{
return($"`{{{v}}}`"); //do not expand TYPE spec here
}
//else navigate config path
return(cdata.Navigate(v).Value);
});
cdata.AddAttributeNode("doc-content", docContent);
return(cdata);
}
protected CommonApplicationLogic(bool allowNesting, Configuration cmdLineArgs, ConfigSectionNode rootConfig)
{
m_AllowNesting = allowNesting;
m_CommandArgs = (cmdLineArgs ?? new MemoryConfiguration()).Root;
m_ConfigRoot = rootConfig ?? GetConfiguration().Root;
}
/// <summary>
/// Initializaes check list from assemblies
/// </summary>
public CheckList(IEnumerable <Assembly> checkAssemblies, ConfigSectionNode config)
{
load(checkAssemblies, config);
}
private void includeCommonConfig(ConfigSectionNode levelRoot)
{
var placeholder = levelRoot.AddChildNode(Guid.NewGuid().ToString());
placeholder.Configuration.Include(placeholder, m_CommonLevelConfig);
}
public override ConfigSectionNode ProvideMetadata(MemberInfo member, object instance, IMetadataGenerator context, ConfigSectionNode dataRoot, NodeOverrideRules overrideRules = null)
{
var schema = instance as Schema;//is a sealed class by design
if (schema == null)
{
return(null);
}
var ndoc = dataRoot.AddChildNode("schema");
if (context.DetailLevel > MetadataDetailLevel.Public)
{
ndoc.AddAttributeNode("name", schema.Name);
}
else
{
ndoc.AddAttributeNode("name", schema.TypedDocType?.Name ?? schema.Name);
}
ndoc.AddAttributeNode("read-only", schema.ReadOnly);
TypedDoc doc = null;
if (schema.TypedDocType != null)
{
ndoc.AddAttributeNode("typed-doc-type", context.AddTypeToDescribe(schema.TypedDocType));
try
{ //this may fail because there may be constructor incompatibility, then we just can get instance-specific metadata
doc = Activator.CreateInstance(schema.TypedDocType, true) as TypedDoc;
context.App.InjectInto(doc);
}
catch { }
}
foreach (var def in schema)
{
var nfld = ndoc.AddChildNode("field");
try
{
field(def, context, nfld, doc);
}
catch (Exception error)
{
var err = new CustomMetadataException(StringConsts.METADATA_GENERATION_SCHEMA_FIELD_ERROR.Args(schema.Name, def.Name, error.ToMessageWithType()), error);
nfld.AddAttributeNode("--ERROR--", StringConsts.METADATA_GENERATION_SCHEMA_FIELD_ERROR.Args(schema.Name, def.Name, "<logged>"));
context.ReportError(Log.MessageType.CriticalAlert, err);
}
}
return(ndoc);
}
private void initStatement(ConfigSectionNode statement)
{
statement.m_Script_Statement = true;
}
private void field(Schema.FieldDef def, IMetadataGenerator context, ConfigSectionNode data, TypedDoc doc)
{
var fname = def.GetBackendNameForTarget(context.DataTargetName, out var fatr);
if (fatr == null)
{
return;
}
if (context.DetailLevel > MetadataDetailLevel.Public)
{
data.AddAttributeNode("prop-name", def.Name);
data.AddAttributeNode("prop-type", def.Type.AssemblyQualifiedName);
data.AddAttributeNode("non-ui", fatr.NonUI);
data.AddAttributeNode("is-arow", fatr.IsArow);
data.AddAttributeNode("store-flag", fatr.StoreFlag);
data.AddAttributeNode("backend-type", fatr.BackendType);
//try to disclose ALL metadata (as we are above PUBLIC)
if (fatr.Metadata != null && fatr.Metadata.Exists)
{
var metad = data.AddChildNode("meta");
metad.MergeSections(fatr.Metadata);
metad.MergeAttributes(fatr.Metadata);
}
}
else //try to disclose pub-only metadata
{
var pubSection = context.PublicMetadataSection;
if (fatr.Metadata != null && pubSection.IsNotNullOrWhiteSpace())
{
var metasrc = fatr.Metadata[pubSection];//<-- pub metadata only
if (metasrc.Exists)
{
var metad = data.AddChildNode("meta");
metad.MergeSections(metasrc);
metad.MergeAttributes(metasrc);
}
}
}
data.AddAttributeNode("name", fname);
data.AddAttributeNode("type", context.AddTypeToDescribe(def.Type));
data.AddAttributeNode("order", def.Order);
if (fatr.Description.IsNotNullOrWhiteSpace())
{
data.AddAttributeNode("description", fatr.Description);
}
data.AddAttributeNode("key", fatr.Key);
if (def.Type == typeof(string))
{
data.AddAttributeNode("kind", fatr.Kind);
}
data.AddAttributeNode("required", fatr.Required);
data.AddAttributeNode("visible", fatr.Required);
data.AddAttributeNode("case", fatr.CharCase);
if (fatr.Default != null)
{
data.AddAttributeNode("default", fatr.Default);
}
if (fatr.DisplayFormat.IsNotNullOrWhiteSpace())
{
data.AddAttributeNode("display-format", fatr.DisplayFormat);
}
if (fatr.FormatRegExp.IsNotNullOrWhiteSpace())
{
data.AddAttributeNode("format-reg-exp", fatr.FormatRegExp);
}
if (fatr.FormatDescription.IsNotNullOrWhiteSpace())
{
data.AddAttributeNode("format-description", fatr.FormatDescription);
}
if (fatr.Max != null)
{
data.AddAttributeNode("max", fatr.Max);
}
if (fatr.Min != null)
{
data.AddAttributeNode("min", fatr.Min);
}
if (fatr.MinLength > 0 || fatr.MaxLength > 0)
{
data.AddAttributeNode("min-len", fatr.MinLength);
}
if (fatr.MinLength > 0 || fatr.MaxLength > 0)
{
data.AddAttributeNode("max-len", fatr.MaxLength);
}
//add values from field attribute .ValueList property
var nvlist = new Lazy <ConfigSectionNode>(() => data.AddChildNode("value-list"));
if (fatr.HasValueList)
{
fatr.ParseValueList().ForEach(item => nvlist.Value.AddAttributeNode(item.Key, item.Value));
}
//if doc!=null call doc.GetClientFieldValueList on the instance to get values from Database lookups etc...
if (doc != null)
{
var lookup = doc.GetDynamicFieldValueList(def, context.DataTargetName, null);
if (lookup != null)
{
lookup.ForEach(item => nvlist.Value.AddAttributeNode(item.Key, item.Value));
}
}
}
protected virtual void DoBLOCK(Stopwatch sw, ConfigSectionNode blockStatement, ConfigSectionNode target)
{
InitStatement(blockStatement);
DoNode(sw, blockStatement, target);
}
public override ConfigSectionNode ProvideMetadata(MemberInfo member, object instance, IMetadataGenerator context, ConfigSectionNode dataRoot, NodeOverrideRules overrideRules = null)
{
var tdoc = member.NonNull(nameof(member)) as Type;
if (tdoc == null || !typeof(Doc).IsAssignableFrom(tdoc))
{
return(null);
}
var typed = tdoc.IsSubclassOf(typeof(TypedDoc));
var ndoc = dataRoot.AddChildNode("data-doc");
Schema schema;
if (instance is Doc doc)
{
schema = doc.Schema;
}
else if (typed)
{
schema = Schema.GetForTypedDoc(tdoc);
}
else
{
schema = null;
}
MetadataUtils.AddMetadataTokenIdAttribute(ndoc, tdoc);
ndoc.AddAttributeNode("kind", typed ? "typed" : "dynamic");
CustomMetadataAttribute.Apply(typeof(Schema), schema, context, ndoc, overrideRules);
return(ndoc);
}
protected virtual void InitStatement(ConfigSectionNode statement)
{
statement.m_Script_Statement = true;
}
public override ConfigSectionNode ProvideMetadata(MemberInfo member, object instance, IMetadataGenerator context, ConfigSectionNode dataRoot, NodeOverrideRules overrideRules = null)
{
if (member is Type tController && instance is ApiDocGenerator.ControllerContext apictx)
{
var apiAttr = tController.GetCustomAttribute <ApiControllerDocAttribute>();
if (apiAttr != null)
{
return(describe(tController, instance, apictx, dataRoot, overrideRules));
}
}
return(null);
}
// -arg1 -arg2 -arg3 opt1 opt2 -arg4 optA=v1 optB=v2
private void parseArgs()
{
m_Root = new ConfigSectionNode(this, null, ROOT_NODE_NAME, string.Empty);
var uargcnt = 1; //unknown arg length
for (int i = 0; i < m_Args.Length; )
{
var argument = m_Args[i];
if (argument.Length > 1 && (argument.StartsWith(ARG_PREFIX1) || argument.StartsWith(ARG_PREFIX2)))
{
argument = argument.Remove(0, 1);//get rid of prefix
var argNode = m_Root.AddChildNode(argument, null);
var uopcnt = 1;//unknown option length
for (i++; i < m_Args.Length; )//read args's options
{
var option = m_Args[i];
if (option.StartsWith(ARG_PREFIX1) || option.StartsWith(ARG_PREFIX2)) break;
i++;
var j = option.IndexOf(OPTION_EQ);
if (j < 0)
{
argNode.AddAttributeNode(string.Format("?{0}", uopcnt), option);
uopcnt++;
}
else
{
var name = option.Substring(0, j);
var val = (j < option.Length - 1) ? option.Substring(j + 1) : string.Empty;
if (string.IsNullOrEmpty(name))
{
name = string.Format("?{0}", uopcnt);
uopcnt++;
}
argNode.AddAttributeNode(name, val);
}
}
}
else
{
m_Root.AddAttributeNode(string.Format("?{0}", uargcnt), argument);
uargcnt++;
i++;
}
}
m_Root.ResetModified();
}
private ConfigSectionNode describe(Type tController, object instance, ApiDocGenerator.ControllerContext apictx, ConfigSectionNode dataRoot, NodeOverrideRules overrideRules)
{
var cdata = dataRoot.AddChildNode("scope");
var cattr = apictx.ApiDocAttr;
var docContent = tController.GetText(cattr.DocFile ?? "{0}.md".Args(tController.Name));
var ctlTitle = MarkdownUtils.GetTitle(docContent);
var ctlDescription = MarkdownUtils.GetTitleDescription(docContent);
(var drequest, var dresponse) = writeCommon(ctlTitle, ctlDescription, tController, apictx.Generator, cattr, cdata);
cdata.AddAttributeNode("uri-base", cattr.BaseUri);
cdata.AddAttributeNode("auth", cattr.Authentication);
cdata.AddAttributeNode("doc-content", docContent);
var allMethodContexts = apictx.Generator.GetApiMethods(tController, apictx.ApiDocAttr);
foreach (var mctx in allMethodContexts)
{
var edata = cdata.AddChildNode("endpoint");
(var mrequest, var mresponse) = writeCommon(null, null, mctx.Method, apictx.Generator, mctx.ApiEndpointDocAttr, edata);
var epuri = mctx.ApiEndpointDocAttr.Uri.AsString().Trim();
if (epuri.IsNullOrWhiteSpace())
{
// infer from action attribute
var action = mctx.Method.GetCustomAttributes <ActionBaseAttribute>().FirstOrDefault();
if (action != null)
{
epuri = action.Name;
}
if (epuri.IsNullOrWhiteSpace())
{
epuri = mctx.Method.Name;
}
}
if (!epuri.StartsWith("/"))
{
var bu = cattr.BaseUri.Trim();
if (!bu.EndsWith("/"))
{
bu += "/";
}
epuri = bu + epuri;
}
edata.AddAttributeNode("uri", epuri);
writeCollection(mctx.ApiEndpointDocAttr.Methods, "method", mrequest, ':');
//docAnchor
var docAnchor = mctx.ApiEndpointDocAttr.DocAnchor.Default("### " + epuri);
edata.AddAttributeNode("doc-content", MarkdownUtils.GetSectionContent(docContent, docAnchor));
//Get all method attributes except ApiDoc
var epattrs = mctx.Method
.GetCustomAttributes(true)
.Where(a => !(a is ApiDocAttribute) && !(a is ActionBaseAttribute));
writeInstanceCollection(epattrs.Where(a => !(a is IInstanceCustomMetadataProvider) ||
(a is IInstanceCustomMetadataProvider cip &&
cip.ShouldProvideInstanceMetadata(apictx.Generator, edata))).ToArray(), TYPE_REF, edata, apictx.Generator);
writeTypeCollection(epattrs.Select(a => a.GetType())
.Where(t => !apictx.Generator.IsWellKnownType(t))
.Distinct()
.ToArray(),
TYPE_REF, edata, apictx.Generator);//distinct attr types
//todo Get app parameters look for Docs and register them and also permissions
var epargs = mctx.Method.GetParameters()
.Where(pi => !pi.IsOut && !pi.ParameterType.IsByRef && !apictx.Generator.IsWellKnownType(pi.ParameterType))
.Select(pi => pi.ParameterType).ToArray();
writeTypeCollection(epargs, TYPE_REF, edata, apictx.Generator);
}
return(cdata);
}
private void buildDocNode(XmlDocument doc, XmlNode xnode, ConfigSectionNode node)
{
XmlNode xnew = doc.CreateElement(node.Name);
if (xnode != null)
xnode.AppendChild(xnew);
else
doc.AppendChild(xnew);
foreach (ConfigAttrNode anode in node.Attributes)
{
XmlNode xattr = doc.CreateNode(XmlNodeType.Attribute, anode.Name, string.Empty);
xattr.Value = anode.Value;
xnew.Attributes.SetNamedItem(xattr);
}
if (node.HasChildren)
{
foreach (ConfigSectionNode cnode in node.Children)
buildDocNode(doc, xnew, cnode);
}
else
{
xnew.AppendChild(doc.CreateTextNode(node.Value));
}
}
private void doIF(Stopwatch sw, ConfigSectionNode ifStatement, ConfigSectionNode target)
{
initStatement(ifStatement);
var condition = evaluateBooleanConditionExpression(ifStatement);
if (!condition) return;
doNode(sw, ifStatement, target);
}
public void Configure(IConfigSectionNode node)
{
var appRoot = node.NavigateSection("/" + ErlConsts.ERLANG_CONFIG_SECTION);
if (appRoot == null)
throw new ErlException(
StringConsts.CONFIGURATION_NAVIGATION_SECTION_REQUIRED_ERROR,
ErlConsts.ERLANG_CONFIG_SECTION);
// Configure global node variables
ErlAbstractNode.s_DefaultCookie = new ErlAtom(
appRoot.AttrByName(ErlConsts.ERLANG_COOKIE_ATTR)
.ValueAsString(ErlAbstractNode.s_DefaultCookie.Value));
ErlAbstractNode.s_UseShortNames =
appRoot.AttrByName(ErlConsts.ERLANG_SHORT_NAME_ATTR)
.ValueAsBool(ErlAbstractNode.s_UseShortNames);
ErlAbstractConnection.ConnectTimeout =
appRoot.AttrByName(ErlConsts.ERLANG_CONN_TIMEOUT_ATTR)
.ValueAsInt(ErlAbstractConnection.ConnectTimeout);
// Configure local node and remote connections
var cfg = new MemoryConfiguration();
cfg.CreateFromNode(appRoot);
var root = cfg.Root;
var nodes = root.Children
.Where(n => n.Name.EqualsIgnoreCase(ErlConsts.ERLANG_NODE_SECTION));
var localNodes = nodes.Where(n => n.AttrByName(ErlConsts.CONFIG_IS_LOCAL_ATTR).ValueAsBool()).ToArray();
if (localNodes.Length != 1)
throw new ErlException(StringConsts.ERL_CONFIG_SINGLE_NODE_ERROR, localNodes.Length);
var localNode = localNodes[0];
// Create and configure local node
s_Node = new ErlLocalNode(localNode.Value, localNode);
// Configure connections to all remote nodes
//m_AllNodes = nodes.Where(n => !n.AttrByName(ErlConsts.CONFIG_IS_LOCAL_ATTR).ValueAsBool());
m_AllNodes = root;
}
private void doNode(Stopwatch sw, ConfigSectionNode source, ConfigSectionNode target)
{
if (source==null || !source.Exists) return;
if (target==null || !target.Exists) return;
if (m_TimeoutMs>0 && sw.ElapsedMilliseconds > m_TimeoutMs)
throw new ConfigException(StringConsts.CONFIGURATION_SCRIPT_TIMEOUT_ERROR.Args(m_TimeoutMs, source.RootPath));
ConfigSectionNode priorStatement = null;
foreach(var subSource in source.Children)
{
if (subSource.IsSameName(KeywordBLOCK)) doBLOCK(sw, subSource, target);
else if (subSource.IsSameName(KeywordIF)) doIF (sw, subSource, target);
else if (subSource.IsSameName(KeywordELSE)) doELSE(sw, subSource, priorStatement, target);
else if (subSource.IsSameName(KeywordLOOP)) doLOOP(sw, subSource, target);
else if (subSource.IsSameName(KeywordSET)) doSET (sw, subSource);
else if (subSource.IsSameName(KeywordCALL)) doCALL(sw, subSource, target);
else
{
var scriptOnly = false;
var scriptOnlyAttr = subSource.AttrByName(AttributeScriptOnly);
if (scriptOnlyAttr.Exists)
scriptOnly = scriptOnlyAttr.ValueAsBool(false);
if (!scriptOnly)
{
var underStatement = false;
var p = subSource;
while(p!=null && p.Exists)
{
if (p.m_Script_Statement)
{
underStatement = true;
break;
}
p = p.Parent;
}
var newTarget = target.AddChildNode( subSource.EvaluateValueVariables( subSource.Name ), underStatement ? subSource.Value : subSource.VerbatimValue);
cloneAttributes(subSource, newTarget, underStatement);
doNode(sw, subSource, newTarget);
}
priorStatement = null;
continue;
}
priorStatement = subSource;
}
}
private void doBLOCK(Stopwatch sw, ConfigSectionNode blockStatement, ConfigSectionNode target)
{
initStatement(blockStatement);
doNode(sw, blockStatement, target);
}
private string evaluateAnyExpression(ConfigSectionNode exprContainer, string expression)
{
try
{
var evl = new Evaluator( expression );
return evl.Evaluate();
}
catch(Exception error)
{
throw new ConfigException(StringConsts.CONFIGURATION_SCRIPT_EXPRESSION_EVAL_ERROR.Args( expression,
exprContainer.RootPath,
error.ToMessageWithType()),
error);
}
}
private void doELSE(Stopwatch sw, ConfigSectionNode elseStatement, ConfigSectionNode priorStatement, ConfigSectionNode target)
{
if (priorStatement==null || !priorStatement.IsSameName(DEFAULT_KEYWORD_IF))
throw new ConfigException(StringConsts.CONFIGURATION_SCRIPT_ELSE_NOT_AFTER_IF_ERROR.Args(elseStatement.RootPath));
initStatement(elseStatement);
var condition = priorStatement.m_Script_Bool_Condition_Result;
if (condition) return;
doNode(sw, elseStatement, target);
}
/// <summary>
/// Takes optional application args[] and root configuration.
/// The args are parsed into CommandArgsConfiguration. If configuration is null then
/// application is configured from a file co-located with entry-point assembly and
/// called the same name as assembly with '.config' extension, unless args are specified and "/config file"
/// switch is used in which case 'file' has to be locatable and readable.
/// Pass allowNesting=true to nest other app container instances
/// </summary>
public ServiceBaseApplication(bool allowNesting, string[] args, ConfigSectionNode rootConfig)
: this(allowNesting, args == null ? null : new CommandArgsConfiguration(args), rootConfig)
{
}
private void doLOOP(Stopwatch sw, ConfigSectionNode loopStatement, ConfigSectionNode target)
{
initStatement(loopStatement);
while(true)
{
var condition = evaluateBooleanConditionExpression(loopStatement);
if (!condition) break;
doNode(sw, loopStatement, target);
}
}
public override ConfigSectionNode ProvideMetadata(MemberInfo member, object instance, IMetadataGenerator context, ConfigSectionNode dataRoot, NodeOverrideRules overrideRules = null)
{
var tperm = member.NonNull(nameof(member)) as Type;
if (tperm == null || !typeof(Permission).IsAssignableFrom(tperm))
{
return(null);
}
var node = dataRoot.AddChildNode("permission");
MetadataUtils.AddMetadataTokenIdAttribute(node, tperm);
if (instance is Permission perm)
{
node.AddAttributeNode("name", perm.Name);
node.AddAttributeNode("path", perm.Path);
node.AddAttributeNode("description", perm.Description);
node.AddAttributeNode("level", perm.Level);
}
else
{
node.AddAttributeNode("name", tperm.Name.Replace("Permission", string.Empty));
node.AddAttributeNode("ns", tperm.Namespace);
}
return(dataRoot);
}
private void doSET(Stopwatch sw, ConfigSectionNode setStatement)
{
initStatement(setStatement);
var path = setStatement.AttrByName("path").Value ?? StringConsts.NULL_STRING;
var to = setStatement.AttrByName("to").Value;
to = evaluateAnyExpression(setStatement, to);
var target = setStatement.Navigate(path);
if (!target.Exists)
throw new ConfigException(StringConsts.CONFIGURATION_SCRIPT_SET_PATH_ERROR.Args(setStatement.RootPath, path) );
target.Value = to;
}
/// <summary>
/// Tries to convert object to laconic config content and parse it. This is a shortcut to ObjectValueConversion.AsLaconicConfig(object)
/// </summary>
public static ConfigSectionNode AsLaconicConfig(this string val,
ConfigSectionNode dflt = null,
string wrapRootName = "azos",
Azos.Data.ConvertErrorHandling handling = Azos.Data.ConvertErrorHandling.ReturnDefault)
=> Azos.Data.ObjectValueConversion.AsLaconicConfig(val, dflt, wrapRootName, handling);
private bool evaluateBooleanConditionExpression(ConfigSectionNode exprContainer)
{
string expression = CoreConsts.UNKNOWN;
try
{
expression = exprContainer.Value;
var evl = new Evaluator( expression );
var evlResult = evl.Evaluate();
var condition = evlResult=="1" ||
evlResult.Equals("yes", StringComparison.InvariantCultureIgnoreCase) ||
evlResult.Equals("true", StringComparison.InvariantCultureIgnoreCase) ||
evlResult.Equals("t", StringComparison.InvariantCultureIgnoreCase);
exprContainer.m_Script_Bool_Condition_Result = condition;
return condition;
}
catch(Exception error)
{
throw new ConfigException(StringConsts.CONFIGURATION_SCRIPT_EXPRESSION_EVAL_ERROR.Args( expression,
exprContainer.RootPath,
error.ToMessageWithType()),
error);
}
}
/// <summary>
/// Takes optional application args[] and root configuration.
/// The args are parsed into CommandArgsConfiguration. If configuration is null then
/// application is configured from a file co-located with entry-point assembly and
/// called the same name as assembly with '.config' extension, unless args are specified and "/config file"
/// switch is used in which case 'file' has to be locatable and readable.
/// </summary>
public AzosApplication(string[] cmdArgs, ConfigSectionNode rootConfig = null)
: this(false, cmdArgs, rootConfig)
{
}
public void Inventorize(Type t, ConfigSectionNode root)
{
InventorizationManager.WriteInventoryAttributes(
t.GetCustomAttributes(typeof(InventoryAttribute), false).Cast<InventoryAttribute>(),
root.AddChildNode(InventorizationManager.ATTRIBUTES_NODE));
if (t.BaseType!=null)
root.AddAttributeNode("base", t.BaseType.FullName);
root.AddAttributeNode("abstract", t.IsAbstract);
root.AddAttributeNode("class", t.IsClass);
root.AddAttributeNode("enum", t.IsEnum);
root.AddAttributeNode("intf", t.IsInterface);
root.AddAttributeNode("nested", t.IsNested);
root.AddAttributeNode("public", t.IsPublic);
root.AddAttributeNode("sealed", t.IsSealed);
root.AddAttributeNode("serializable", t.IsSerializable);
root.AddAttributeNode("valuetype", t.IsValueType);
root.AddAttributeNode("visible", t.IsVisible);
var members = t.GetMembers().Where(m=>m.GetCustomAttributes(typeof(InventoryAttribute), false).Count()>0);
foreach(var mem in members)
{
var mnode = root.AddChildNode("member");
mnode.AddAttributeNode("name", mem.Name);
mnode.AddAttributeNode("kind", mem.MemberType.ToString());
InventorizationManager.WriteInventoryAttributes(
mem.GetCustomAttributes(typeof(InventoryAttribute), false).Cast<InventoryAttribute>(),
mnode.AddChildNode(InventorizationManager.ATTRIBUTES_NODE));
if (mem is PropertyInfo)
{
var pinf = (PropertyInfo)mem;
mnode.AddAttributeNode("can-get", pinf.CanRead);
mnode.AddAttributeNode("can-set", pinf.CanWrite);
mnode.AddAttributeNode("type", pinf.PropertyType.FullName);
}
else
if (mem is FieldInfo)
{
var finf = (FieldInfo)mem;
mnode.AddAttributeNode("not-serialized", finf.IsNotSerialized);
mnode.AddAttributeNode("public", finf.IsPublic);
mnode.AddAttributeNode("private", finf.IsPrivate);
mnode.AddAttributeNode("static", finf.IsStatic);
mnode.AddAttributeNode("type", finf.FieldType.FullName);
}
else
if (mem is MethodInfo)
{
var minf = (MethodInfo)mem;
mnode.AddAttributeNode("virtual", minf.IsVirtual);
mnode.AddAttributeNode("public", minf.IsPublic);
mnode.AddAttributeNode("private", minf.IsPrivate);
mnode.AddAttributeNode("static", minf.IsStatic);
if (minf.ReturnType!=null)
mnode.AddAttributeNode("return-type", minf.ReturnType.FullName);
}
}
}
/// <summary>
/// Takes optional application args[] and root configuration.
/// The args are parsed into CommandArgsConfiguration.
/// </summary>
public ServiceBaseApplication(string[] args, ConfigSectionNode rootConfig)
: this(null, args == null ? null : new CommandArgsConfiguration(args), rootConfig)
{
}
// IConfigurationPersistent Members
/// <summary>
/// Persists column configuration to config node. [grid] subnode will be created under specified node pr reused if one already exists
/// </summary>
public void PersistConfiguration(ConfigSectionNode node)
{
if (node==null) return;
ConfigSectionNode gnode = findSubNodeForThisGrid(node) as ConfigSectionNode; //see if node for this grid already exists
if (gnode!=null)//delete with all column defs that are different now
gnode.Delete();
gnode = node.AddChildNode(CONFIG_GRID_SECTION);
if (!string.IsNullOrEmpty(m_ID))
gnode.AddAttributeNode(CONFIG_ID_ATTR, ID);
foreach(var col in m_Columns)
col.PersistConfiguration(gnode);
}
/// <summary>
/// The base class does not implement this method. Override to persist row fields into config node
/// </summary>
public virtual void PersistConfiguration(ConfigSectionNode node)
{
throw new NotImplementedException();
}
