private void populateSection(ConfigSectionNode section) { if (token.Type != LaconfigTokenType.tBraceOpen) { errorAndAbort(LaconfigMsgCode.eSectionOpenBraceExpected); } fetchPrimary(); //skip { section started while (true) { if (token.Type == LaconfigTokenType.tBraceClose) { fetchPrimaryOrEOF(); //skip } section ended return; } if (token.Type != LaconfigTokenType.tIdentifier && token.Type != LaconfigTokenType.tStringLiteral) { errorAndAbort(LaconfigMsgCode.eSectionOrAttributeNameExpected); } var name = token.Text; fetchPrimary(); if (token.Type == LaconfigTokenType.tBraceOpen) //section w/o value { var subsection = section.AddChildNode(name, null); populateSection(subsection); } else if (token.Type == LaconfigTokenType.tEQ) //section with value or attribute { fetchPrimary(); //skip = if (token.Type != LaconfigTokenType.tIdentifier && token.Type != LaconfigTokenType.tStringLiteral && token.Type != LaconfigTokenType.tNull) { errorAndAbort(LaconfigMsgCode.eSectionOrAttributeValueExpected); } var value = token.Type == LaconfigTokenType.tNull ? null : token.Text; fetchPrimary(); //skip value if (token.Type == LaconfigTokenType.tBraceOpen) //section with value { var subsection = section.AddChildNode(name, value); populateSection(subsection); } else { section.AddAttributeNode(name, value); } } else { errorAndAbort(LaconfigMsgCode.eSyntaxError); } } }
/// <summary> /// Describes type including generic arguments /// </summary> public static void WriteType(Type t, ConfigSectionNode node) { node.AddAttributeNode("name-in-code", tname(t)); node.AddAttributeNode("name", t.Name); if (t == typeof(void)) { node.AddAttributeNode("void", true); return; } node.AddAttributeNode("ns", t.Namespace); node.AddAttributeNode("asm-q-name", t.AssemblyQualifiedName); node.AddAttributeNode("asm-name", t.Assembly.FullName); node.AddAttributeNode("intf", t.IsInterface); node.AddAttributeNode("valuetype", t.IsValueType); if (t.IsEnum) { var enode = node.AddChildNode("enum"); foreach (var name in Enum.GetNames(t)) { var inode = enode.AddChildNode("item"); inode.AddAttributeNode("key", name); inode.AddAttributeNode("value", (int)Enum.Parse(t, name)); } } if (t.IsGenericType) { var ganode = node.AddChildNode("generic-type-args"); foreach (var garg in t.GetGenericArguments()) { WriteType(garg, ganode.AddChildNode("type-arg")); } } }
private (Lazy <ConfigSectionNode> request, Lazy <ConfigSectionNode> response) writeCommon( string defTitle, string defDescription, MemberInfo info, ApiDocGenerator gen, ApiDocAttribute attr, ConfigSectionNode data) { MetadataUtils.AddMetadataTokenIdAttribute(data, info); var title = attr.Title.Default(defTitle); if (title.IsNotNullOrWhiteSpace()) { data.AddAttributeNode("title", title); } var descr = attr.Description.Default(defDescription); if (descr.IsNotNullOrWhiteSpace()) { data.AddAttributeNode("description", descr); } var drequest = new Lazy <ConfigSectionNode>(() => data.AddChildNode("request")); var dresponse = new Lazy <ConfigSectionNode>(() => data.AddChildNode("response")); writeCollection(attr.RequestHeaders, "header", drequest, ':'); writeCollection(attr.RequestQueryParameters, "param", drequest, '='); writeCollection(attr.ResponseHeaders, "header", dresponse, ':'); if (attr.Connection.IsNotNullOrWhiteSpace()) { data.AddAttributeNode("connection", attr.Connection); } if (attr.RequestBody.IsNotNullOrWhiteSpace()) { drequest.Value.AddAttributeNode("body", attr.RequestBody); } if (attr.ResponseContent.IsNotNullOrWhiteSpace()) { dresponse.Value.AddAttributeNode("content", attr.ResponseContent); } writeTypeCollection(attr.TypeSchemas, TYPE_REF, data, gen); return(drequest, dresponse); }
public override ConfigSectionNode ProvideMetadata(MemberInfo member, object instance, IMetadataGenerator context, ConfigSectionNode dataRoot, NodeOverrideRules overrideRules = null) { if (instance is ReleaseAttribute release) { var node = dataRoot.AddChildNode("release"); node.AddAttributeNode("type", release.Type); node.AddAttributeNode("utc", release.ReleaseTimestampUtc); node.AddAttributeNode("title", release.Title); if (release.Tags.IsNotNullOrWhiteSpace()) { node.AddAttributeNode("tags", release.Tags); } if (release.Description.IsNotNullOrWhiteSpace()) { node.AddAttributeNode("descr", release.Description); } if (context.DetailLevel > MetadataDetailLevel.Public) { if (release.Metadata.IsNotNullOrWhiteSpace()) { node.AddAttributeNode("meta", release.Metadata); } } } return(dataRoot); }
/// <summary> /// Adds nodes for InventoryAttributes /// </summary> public static void WriteInventoryAttributes(IEnumerable <InventoryAttribute> attrs, ConfigSectionNode root) { foreach (var attr in attrs) { var node = root.AddChildNode("item"); node.AddAttributeNode("tiers", attr.Tiers.ToString()); node.AddAttributeNode("concerns", attr.Concerns.ToString()); node.AddAttributeNode("schema", attr.Schema); node.AddAttributeNode("tech", attr.Technology); node.AddAttributeNode("tool", attr.Tool); if (attr.StartDate.HasValue) { node.AddAttributeNode("sdate", attr.StartDate.Value); } if (attr.EndDate.HasValue) { node.AddAttributeNode("edate", attr.EndDate.Value); } if (attr.Parameters != null) { node.AddChildNode("params", attr.Parameters); } } }
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); }
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); }
// 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); } }
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); }
/// <summary> /// Runs inventorization routine dumping result into config node /// </summary> public void Run(ConfigSectionNode root) { if (m_Startegies.Count == 0) { throw new InventorizationException(StringConsts.INVENTORIZATION_NEED_STRATEGY_ERROR); } foreach (var asm in m_Assemblies.Where(a => filter(a))) { var asmnode = root.AddChildNode("assembly"); asmnode.AddAttributeNode("name", asm.FullName); WriteInventoryAttributes(asm.GetCustomAttributes(typeof(InventoryAttribute), false).Cast <InventoryAttribute>(), asmnode.AddChildNode(ATTRIBUTES_NODE)); var types = asm.GetTypes(); foreach (var type in types.Where(t => filter(t)).OrderBy(t => t.FullName)) { var tnode = asmnode.AddChildNode("type"); tnode.AddAttributeNode("ns", type.Namespace); tnode.AddAttributeNode("name", type.Name); foreach (var strategy in m_Startegies) { strategy.Inventorize(type, tnode); } } } }
public VolumeMetadataBuilder SetCompressionSection(Action <ConfigSectionNode> compressionBuilder) { if (compressionBuilder == null) { return(this); } var compression = SectionSystem[VolumeMetadata.CONFIG_COMPRESSION_SECTION]; if (!compression.Exists) { compression = SectionSystem.AddChildNode(VolumeMetadata.CONFIG_COMPRESSION_SECTION); } compressionBuilder(compression); return(this); }
public void AddAddressee(Addressee addressee) { var aSection = m_Config.AddChildNode(CONFIG_A_SECT); aSection.AddAttributeNode(ATTR_NAME, addressee.Name); aSection.AddAttributeNode(ATTR_CHANNEL_NAME, addressee.ChannelName); aSection.AddAttributeNode(ATTR_CHANNEL_ADDRESS, addressee.ChannelAddress); }
/// <summary> /// Unconditionally installs a package - copies a set of files contained in the FileSystemDirectory assigning it some mnemonic name /// </summary> public void InstallPackage(PackageInfo package) { if (!m_InstallationStarted) { throw new AzosIOException(StringConsts.LOCAL_INSTALL_NOT_STARTED_INSTALL_PACKAGE_ERROR); } var path = m_RootPath; if (package.RelativePath.IsNotNullOrWhiteSpace()) { path = Path.Combine(path, package.RelativePath); IOUtils.EnsureAccessibleDirectory(path); } var packageName = package.Name; var source = package.Source; var manifest = package.Manifest; using (var lfs = new Local.LocalFileSystem(App)) using (var fss = lfs.StartSession(null)) { var targetDir = fss[path] as FileSystemDirectory; if (targetDir == null) { throw new AzosIOException(StringConsts.LOCAL_INSTALL_ROOT_PATH_NOT_FOUND_ERROR.Args(path)); } source.DeepCopyTo(targetDir, FileSystemDirectory.DirCopyFlags.FilesAndDirsOnly, filter: (item) => { var file = item as FileSystemFile; if (file == null) { return(true); } if (file.ParentPath == source.Path && file.Name == ManifestUtils.MANIFEST_FILE_NAME) { return(false); } return(true); } ); } var existing = this[packageName]; if (existing != null) { ((ConfigSectionNode)existing).Delete(); } m_Packages.AddChildNode(manifest); m_Modified = true; }
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)); if (!schema.TypedDocType.IsAbstract) { 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 { var targetName = context.GetSchemaDataTargetName(schema, doc); field(targetName, 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); }
// -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 && ((!m_InhibitSlashArg && argument.StartsWith(ARG_PREFIX_SLASH)) || argument.StartsWith(ARG_PREFIX_DASH))) { 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 ((!m_InhibitSlashArg && option.StartsWith(ARG_PREFIX_SLASH)) || option.StartsWith(ARG_PREFIX_DASH)) { 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 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 => !MANIFEST_FILE_NAME.EqualsIgnoreCase(fn))) { 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); } } }
// IConfigurationPersistent Members public void PersistConfiguration(ConfigSectionNode node) { var cn = node.AddChildNode(Grid.CONFIG_COLUMN_SECTION); cn.AddAttributeNode(Grid.CONFIG_ID_ATTR, m_ID); cn.AddAttributeNode(CONFIG_WIDTH_ATTR, m_Width); if (SortingAllowed) { cn.AddAttributeNode(CONFIG_SORT_ATTR, m_SortDirection); } }
public void AddAddressee(Addressee addressee) { var aSection = m_Config.AddChildNode(CONFIG_A_SECT); aSection.AddAttributeNode(ATTR_NAME, addressee.Name); aSection.AddAttributeNode(ATTR_CHANNEL_NAME, addressee.ChannelName); aSection.AddAttributeNode(ATTR_CHANNEL_ADDRESS, addressee.ChannelAddress); if (MessageBuilderChange != null) { MessageBuilderChange(this); } }
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); }
private void buildNode(ConfigSectionNode node, JsonDataMap map) { foreach (var kvp in map) { var cmap = kvp.Value as JsonDataMap; if (cmap != null) { buildNode(node.AddChildNode(kvp.Key), cmap); } else { node.AddAttributeNode(kvp.Key, kvp.Value); } } }
private void outError(ConfigSectionNode node, Exception error) { var nesting = 0; while (error != null) { node = node.AddChildNode("error", error.GetType().Name); node.AddAttributeNode("type", error.GetType().AssemblyQualifiedName); node.AddAttributeNode("nesting", nesting); node.AddAttributeNode("msg", error.Message); node.AddAttributeNode("stack", error.StackTrace); error = error.InnerException; nesting++; } }
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 VolumeMetadataBuilder SetApplicationSection(Action <ConfigSectionNode> applicationBuilder) { if (applicationBuilder == null) { return(this); } var application = Root[VolumeMetadata.CONFIG_APP_SECTION]; if (!application.Exists) { application = Root.AddChildNode(VolumeMetadata.CONFIG_APP_SECTION); } applicationBuilder(application); return(this); }
public void AddAddressee(Addressee addressee) { if (m_All == null) { m_All = new Addressee[] { addressee } } ; else { m_All = m_All.Concat(new Addressee[] { addressee }); } var aSection = m_Config.AddChildNode(CONFIG_A_SECT); aSection.AddAttributeNode(ATTR_NAME, addressee.Name); aSection.AddAttributeNode(ATTR_CHANNEL_NAME, addressee.ChannelName); aSection.AddAttributeNode(ATTR_CHANNEL_ADDRESS, addressee.ChannelAddress); }
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); }
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> /// Executes the source configuration script against the target (StopWatch is passed along to track timout adherence) /// </summary> 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; } }
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); } } } }
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 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 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); }
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 void field(string targetName, Schema.FieldDef def, IMetadataGenerator context, ConfigSectionNode data, TypedDoc doc) { var fname = def.GetBackendNameForTarget(targetName, 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); 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, targetName, null); if (lookup != null)//non-null blank lookup is treated as blank lookup overshadowing the hard-coded choices from .ValueList { if (nvlist.IsValueCreated) { nvlist.Value.DeleteAllAttributes(); } lookup.ForEach(item => nvlist.Value.AddAttributeNode(item.Key, item.Value)); } } }
// -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 void includeCommonConfig(ConfigSectionNode levelRoot) { var placeholder = levelRoot.AddChildNode(Guid.NewGuid().ToString()); placeholder.Configuration.Include(placeholder, m_CommonLevelConfig); }
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; }
// 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); }
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; }