Example #1
0
      /// <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;
          }

        }
      }
Example #2
0
        /// <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;
            }
        }
Example #3
0
        /// <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);
        }
Example #4
0
                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);
                }
Example #5
0
        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);
        }
Example #6
0
        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);
        }
Example #7
0
        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);
        }
Example #8
0
 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);
 }
Example #9
0
 private void doBLOCK(Stopwatch sw, ConfigSectionNode blockStatement, ConfigSectionNode target)
 {
     initStatement(blockStatement);
                         doNode(sw, blockStatement, target);
 }
 private Amount Convert(ConfigSectionNode config, string rateTable, Amount amount, string currencyISO)
 {
     var market = new ConfigBasedCurrencyMarket(config);
     return market.ConvertCurrency(rateTable, amount, currencyISO);
 }
Example #11
0
        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;
        }
Example #12
0
 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);
                         }
 }
Example #13
0
        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;
                }
        }
Example #14
0
        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);
                }
        }
Example #15
0
        // -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();
        }
Example #16
0
      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 Amount Convert(ConfigSectionNode config, Amount amount, string currencyISO)
 {
     return Convert(config, NO_RATE_TABLE, amount, currencyISO);
 }
Example #18
0
 /// <summary>
 /// Initializaes check list from assemblies 
 /// </summary>
 public CheckList(IEnumerable<Assembly> checkAssemblies, ConfigSectionNode config)
 {
   load(checkAssemblies, config);
 }
Example #19
0
        private void doIF(Stopwatch sw, ConfigSectionNode ifStatement, ConfigSectionNode target)
        {
            initStatement(ifStatement);

                                var condition = evaluateBooleanConditionExpression(ifStatement);
                                if (!condition) return;

                                doNode(sw, ifStatement, target);
        }
Example #20
0
 private void initStatement(ConfigSectionNode statement)
 {
     statement.m_Script_Statement = true;
 }
Example #21
0
        private void doLOOP(Stopwatch sw, ConfigSectionNode loopStatement, ConfigSectionNode target)
        {
            initStatement(loopStatement);

                                while(true)
                                {
                                    var condition = evaluateBooleanConditionExpression(loopStatement);
                                    if (!condition) break;

                                    doNode(sw, loopStatement, target);
                                }
        }
Example #22
0
 public void SetUp()
 {
     m_RootCfg = initConf();
 }
Example #23
0
        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;
        }
Example #24
0
 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);
     }
 }
Example #25
0
        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);
                                }
        }
Example #26
0
        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));
              }
        }
Example #27
0
        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);
             }
               }
        }
Example #28
0
        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;
        }
Example #29
0
File: Grid.cs Project: kinpro/nfx
      // 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);
      }
Example #30
0
        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;
        }