Example #1
0
        private void toolStripButtonLoadConifg_Click(object sender, EventArgs e)
        {
            if (this.cbxtoolStripSelectObejct.ComboBox.SelectedIndex >= 0)
            {
                if (this.openFileDialogInputUIConfig.ShowDialog() == DialogResult.OK)
                {
                    FormUISetting uis = XmlConfigReader.GetConfig <FormUISetting>(this.openFileDialogInputUIConfig.FileName);

                    ITable    selectTable = this.cbxtoolStripSelectObejct.ComboBox.SelectedValue as MyMeta.ITable;
                    IDatabase database    = selectTable.Database;

                    for (int i = 0; i < this.cbxtoolStripSelectObejct.ComboBox.Items.Count; i++)
                    {
                        ITable table = (ITable)this.cbxtoolStripSelectObejct.ComboBox.Items[i];
                        if (table.Name == uis.TableName)
                        {
                            this.cbxtoolStripSelectObejct.ComboBox.SelectedIndex = i;
                            break;
                        }
                    }

                    this.dataGridViewField.DataSource = uis.Items;
                }
            }
        }
        /// <summary>
        /// Initialize a registered cache given by the ID.
        /// </summary>
        /// <param name="cacheId">A string identifier of configuration.</param>
        static public CacheServerConfig GetConfigDom(string cacheId, string filePath, bool inProc)
        {
            try
            {
                XmlConfigReader   configReader = new XmlConfigReader(filePath, cacheId);
                CacheServerConfig config       = configReader.GetConfigDom();
                CultureInfo       cultureInfo  = Thread.CurrentThread.CurrentCulture;
                if (config == null)
                {
                    return(config);
                }

                if (!inProc)
                {
                    inProc = config.InProc;
                }

                if (inProc)
                {
                    return(config);
                }
                return(null);
            }



            catch (ManagementException)
            {
                throw;
            }
            catch (Exception e)
            {
                throw new ManagementException(e.Message, e);
            }
        }
        public void Read_NoDevice()
        {
            var xmlConfigReader = new XmlConfigReader("_TestData\\config_no_device.xml");
            var settings        = xmlConfigReader.Read();

            Assert.Empty(settings);
        }
        static public bool SetupConfigSystem(string configFilePath)
        {
            ModManager.ApplicationExit += ModManagerApplicationExit;
            LoggingManager.SendMessage("ConfigManager - Setting up config system...");
            if (!File.Exists(configFilePath))
            {
                LoggingManager.SendMessage("ConfingManager - No plugins.config found, creating one from scratch");
            }

            s_sConfigFilePath = configFilePath;
            FileStream config = null;

            try
            {
                config          = File.Open(configFilePath, FileMode.OpenOrCreate, FileAccess.Read, FileShare.Read);
                s_pluginsConfig = XmlConfigReader.Read(config);
            }
            catch (Exception e)
            {
                LoggingManager.SendMessage("ConfigManager - Failed to set up config system from file: " + configFilePath);
                LoggingManager.HandleException(e);
                return(false);
            }
            finally
            {
                if (config != null)
                {
                    config.Close();
                }
            }
            LoggingManager.SendMessage("ConfigManager - Config system set up successfully!");
            return(true);
        }
Example #5
0
        /// <summary>
        /// Initialize a registered cache given by the ID.
        /// </summary>
        /// <param name="cacheId">A string identifier of configuration.</param>
        static public ArrayList GetCacheConfig(string cacheId, string filePath, bool inProc)
        {
            try
            {
                XmlConfigReader configReader = new XmlConfigReader(filePath, cacheId);
                ArrayList       propsList    = configReader.PropertiesList;
                ArrayList       configsList  = CacheConfig.GetConfigs(propsList, DEF_TCP_PORT);

                foreach (CacheConfig config in configsList)
                {
                    if (!inProc)
                    {
                        inProc = config.UseInProc;
                    }
                    break;
                }

                if (inProc)
                {
                    return(configsList);
                }
                return(null);
            }

            catch (ManagementException)
            {
                throw;
            }
            catch (Exception e)
            {
                throw new ManagementException(e.Message, e);
            }
        }
Example #6
0
        private void toolStripButtonLoadConifg_Click(object sender, EventArgs e)
        {
            if ((cbxtoolStripSelectDataBase.ComboBox.SelectedIndex >= 0) &&
                (cbxtoolStripSelectObejct.ComboBox.SelectedIndex >= 0))
            {
                if (openFileDialogInputUIConfig.ShowDialog() == DialogResult.OK)
                {
                    var uis = XmlConfigReader.GetConfig <FormUISetting>(openFileDialogInputUIConfig.FileName);

                    var database = cbxtoolStripSelectDataBase.ComboBox.SelectedValue as IDatabase;

                    for (int i = 0; i < cbxtoolStripSelectObejct.ComboBox.Items.Count; i++)
                    {
                        var table = (ITable)cbxtoolStripSelectObejct.ComboBox.Items[i];
                        if (table.Name == uis.TableName)
                        {
                            cbxtoolStripSelectObejct.ComboBox.SelectedIndex = i;
                            break;
                        }
                    }

                    dataGridViewField.DataSource = uis.Items;
                }
            }
        }
        public void Read_DeviceWithoutMapping()
        {
            var xmlConfigReader = new XmlConfigReader("_TestData\\config_device_without_mapping.xml");
            var settings        = xmlConfigReader.Read();

            Assert.Single(settings);
            Assert.Equal("Dings", settings.First().Name);
            Assert.Empty(settings.First().Mapping);
        }
Example #8
0
        /// <summary>
        /// Creates a cache object by reading in cofiguration parameters from a .NET XML file.
        /// </summary>
        /// <param name="configFileName">Name and/or path of the configuration file.</param>
        /// <param name="configSection">Name and/or ID of the section in the configuration file.</param>
        /// <param name="itemAdded">item added handler</param>
        /// <param name="itemRemoved">item removed handler</param>
        /// <param name="itemUpdated">item updated handler</param>
        /// <param name="cacheMiss">cache miss handler</param>
        /// <param name="cacheCleared">cache cleared handler</param>
        /// <returns>return the Cache object</returns>
        static public Cache CreateFromXmlConfig(string configFileName,
                                                string configSection,
                                                CustomRemoveCallback customRemove,
                                                CustomUpdateCallback customUpdate)
        {
            ConfigReader xmlReader = new XmlConfigReader(configFileName, configSection);

            return(CreateFromProperties(xmlReader.Properties, customRemove, customUpdate));
        }
        public void Read_OneDevice()
        {
            var xmlConfigReader = new XmlConfigReader("_TestData\\config_one_device.xml");
            var settings        = xmlConfigReader.Read();

            Assert.Single(settings);
            Assert.Equal("Dings", settings.First().Name);
            Assert.Equal(2, settings.First().Mapping.Count);
            Assert.Contains(new KeyValuePair <int, int>(1, 111), settings.First().Mapping);
            Assert.Contains(new KeyValuePair <int, int>(2, 222), settings.First().Mapping);
        }
Example #10
0
        private void toolStripButtonSaveConfig_Click(object sender, EventArgs e)
        {
            if ((cbxtoolStripSelectDataBase.ComboBox.SelectedIndex >= 0) &&
                (cbxtoolStripSelectObejct.ComboBox.SelectedIndex >= 0))
            {
                var database    = cbxtoolStripSelectDataBase.ComboBox.SelectedValue as IDatabase;
                var selectTable = cbxtoolStripSelectObejct.ComboBox.SelectedValue as ITable;

                FormUISetting uis = GetFormUIConfig(database, selectTable);

                string pathKey = "Key|KilerCodeGeneration|UI|" + database.Name + "|" + selectTable.Name;

                XmlConfigReader.SetConfig <FormUISetting>(pathKey, uis, saveFileDialogInputUIConfig);
            }
        }
        public void Read_OneDevice()
        {
            var xmlConfigReader = new XmlConfigReader("_TestData\\config_one_device.xml");
            var settings        = xmlConfigReader.Read();

            var device = settings.FirstOrDefault();

            Assert.Single(settings);
            Assert.Equal("Sam", device.Name);

            Assert.Equal(4, device.Pins.Count());
            Assert.Contains(new Pin(1, 6, "Relay + LED", PinLogic.Negative), device.Pins);
            Assert.Contains(new Pin(2, 8, "Relay + LED", PinLogic.Positive), device.Pins);
            Assert.Contains(new Pin(3, 10, "Relay + LED", PinLogic.Positive), device.Pins);
            Assert.Contains(new Pin(4, 12, "Relay + LED", PinLogic.Positive), device.Pins);
        }
Example #12
0
        /// <summary>
        /// Initialize a registered cache given by the ID.
        /// </summary>
        /// <param name="cacheId">A string identifier of configuration.</param>
        static public ArrayList GetCacheConfig(string cacheId, string userId, string password, bool inProc)
        {
            if (FileName.Length == 0)
            {
                throw new ManagementException("Can not locate cache configuration file. Installation might be corrupt");
            }
            try
            {
                XmlConfigReader configReader = new XmlConfigReader(FileName, cacheId);
                ArrayList       propsList    = configReader.PropertiesList;
                ArrayList       configsList  = CacheConfig.GetConfigs(propsList);

                foreach (CacheConfig config in configsList)
                {
                    if (!inProc)
                    {
                        inProc = config.UseInProc;
                    }
                    break;
                }

                if (inProc)
                {
                    bool      isAuthorize = false;
                    Hashtable ht          = (Hashtable)propsList[0];
                    Hashtable cache       = (Hashtable)ht["cache"];

                    return(configsList);
                }
                return(null);
            }

            catch (SecurityException)
            {
                throw;
            }

            catch (ManagementException)
            {
                throw;
            }
            catch (Exception e)
            {
                throw new ManagementException(e.Message, e);
            }
        }
Example #13
0
 /// <summary>
 /// Initialize a registered cache given by the ID.
 /// </summary>
 /// <param name="cacheId">A string identifier of configuration.</param>
 static public CacheConfig GetCacheConfig(string cacheId)
 {
     if (FileName.Length == 0)
     {
         throw new ManagementException("Can not locate cache configuration file. Installation might be corrupt");
     }
     try
     {
         XmlConfigReader configReader = new XmlConfigReader(FileName, cacheId);
         return(CacheConfig.FromProperties(configReader.Properties));
     }
     catch (ManagementException)
     {
         throw;
     }
     catch (Exception e)
     {
         throw new ManagementException(e.Message, e);
     }
 }
Example #14
0
        public static void CourierStatusThread(object state)
        {
            var diagnosticService  = Program.Container.Resolve <IDiagnosticService>();
            var courierService     = Program.Container.Resolve <ICourierService>();
            var systemEventService = Program.Container.Resolve <ISystemEventService>();
            var timeout            = 30;

            int.TryParse(XmlConfigReader.GetValue("CourierStatusTimeoutBySecond"), out timeout);

            try
            {
                var listCourier = courierService.ListAll();
                var listUpdate  = new List <Courier>();

                //status online/ofline
                foreach (var courier in listCourier.Where(courier => (DateTime.UtcNow - courier.LastTime.GetValueOrDefault()).TotalSeconds >= timeout && courier.Status == (int)StatusCourier.Online))
                {
                    courier.Status = (int)StatusCourier.Offline;
                    listUpdate.Add(courier);
                    systemEventService.Add(EventMessage.CourierOffline, new Dictionary <EventMessageParam, string>()
                    {
                        { EventMessageParam.Courier, courier.User.LastName + " " + courier.User.FirstName + (string.IsNullOrEmpty(courier.User.MiddleName) ? "" : " " + courier.User.MiddleName) }
                    });
                }

                //reset request
                var current = DateTime.UtcNow;
                foreach (var courier in listCourier.Where(courier => courier.ServiceResetTime == null || (DateTime.UtcNow - courier.ServiceResetTime.GetValueOrDefault()).TotalSeconds >= 86400))
                {
                    courier.ServiceResetTime = current;
                    courier.CurrentReq       = 0;
                    listUpdate.Add(courier);
                }

                courierService.UpdateListCourierForService(listUpdate);
            }
            catch (Exception ex)
            {
                diagnosticService.Error(ex);
            }
        }
Example #15
0
        /// <summary>
        /// Initialize a registered cache given by the ID.
        /// </summary>
        /// <param name="cacheId">A string identifier of configuration.</param>
        static public ArrayList GetCacheConfig(string cacheId, string filePath, string userId, string password, bool inProc)
        {
            try
            {
                XmlConfigReader configReader = new XmlConfigReader(filePath, cacheId);
                ArrayList       propsList    = configReader.PropertiesList;
                ArrayList       configsList  = CacheConfig.GetConfigs(propsList, DEF_TCP_PORT);

                foreach (CacheConfig config in configsList)
                {
                    if (!inProc)
                    {
                        inProc = config.UseInProc;
                    }
                    break;
                }

                if (inProc)
                {
                    Hashtable ht    = (Hashtable)propsList[0];
                    Hashtable cache = (Hashtable)ht["cache"];

                    return(configsList);
                }
                return(null);
            }

            catch (SecurityException)
            {
                throw;
            }

            catch (ManagementException)
            {
                throw;
            }
            catch (Exception e)
            {
                throw new ManagementException(e.Message, e);
            }
        }
Example #16
0
        private void toolStripButtonSaveConfig_Click(object sender, EventArgs e)
        {
            if (this.cbxtoolStripSelectObejct.ComboBox.SelectedIndex >= 0)
            {
                ITable    selectTable = this.cbxtoolStripSelectObejct.ComboBox.SelectedValue as MyMeta.ITable;
                IDatabase database    = selectTable.Database;

                List <TableUIGenerationParams> tableUIGenerationParamsList = null;
                if (database != null && selectTable != null)
                {
                    tableUIGenerationParamsList = new List <TableUIGenerationParams>();
                    foreach (DataGridViewRow row in this.dataGridViewField.Rows)
                    {
                        TableUIGenerationParams tableUIGenerationParams = new TableUIGenerationParams();
                        tableUIGenerationParams.IsSelect     = (bool)row.Cells["colIsSelect"].Value;
                        tableUIGenerationParams.FieldName    = (string)row.Cells["colFieldName"].Value;
                        tableUIGenerationParams.FieldNameCn  = (string)row.Cells["colFieldNameCn"].Value;
                        tableUIGenerationParams.LanguageType = (string)row.Cells["colLanguageType"].Value;
                        tableUIGenerationParams.Size         = (int)row.Cells["colSize"].Value;
                        tableUIGenerationParams.IsAutoKey    = (bool)row.Cells["colIsAutoKey"].Value;
                        tableUIGenerationParams.InputType    = (string)row.Cells["colInputType"].Value;
                        tableUIGenerationParams.IsReqiured   = (bool)row.Cells["colIsReqiured"].Value;
                        tableUIGenerationParams.DefaultValue = (string)row.Cells["colDefaultValue"].Value;
                        tableUIGenerationParams.Items        = (string)row.Cells["colSelectItem"].Value;
                        tableUIGenerationParams.DbColumnName = (string)row.Cells["colIndexName"].Value;
                        tableUIGenerationParamsList.Add(tableUIGenerationParams);
                    }
                }

                FormUISetting uis = new FormUISetting();
                uis.TableName = selectTable.Name;
                uis.Items     = tableUIGenerationParamsList;


                string pathKey = "Key|KilerCodeGeneration|UI|" + database.Name + "|" + selectTable.Name;

                XmlConfigReader.SetConfig <FormUISetting>(pathKey, uis, this.saveFileDialogInputUIConfig);
            }
        }
        public IEnumerable <IController> Create()
        {
            string currentAssemblyFilePath      = new Uri(typeof(XmlConfigReader).Assembly.CodeBase).LocalPath;
            string currentAssemblyDirectoryPath = Path.GetDirectoryName(currentAssemblyFilePath);
            string schemaFilePath = currentAssemblyDirectoryPath + "\\config.xsd";
            string configFilePath = currentAssemblyDirectoryPath + "\\config.xml";

            var  validator = new XmlSchemaValidator(schemaFilePath, configFilePath);
            bool isValid   = validator.Validate();

            if (!isValid)
            {
                throw new ConfigurationErrorsException("Serial controller configuration is not valid.");
            }
            else
            {
                var xmlConfigReader = new XmlConfigReader(configFilePath);
                var devices         = xmlConfigReader.Read();

                return(devices.Select(x => new SerialController(x)).ToList());
            }
        }
Example #18
0
        /// <summary>
        /// Loads and returns all cache configurations from the configuration file.
        /// </summary>
        static public CacheConfig[] GetConfiguredCaches2()
        {
            if (FileName.Length == 0)
            {
                throw new ManagementException("Can not locate cache configuration file. Installation might be corrupt.");
            }
            try
            {
                XmlConfigReader xcr     = new XmlConfigReader("", "");
                IDictionary     propMap = null;

                propMap = xcr.GetProperties2(CacheConfigManager.FileName);

                ArrayList configList = new ArrayList();

                IDictionaryEnumerator ide = propMap.GetEnumerator();
                while (ide.MoveNext())
                {
                    IDictionary properties = (IDictionary)ide.Value;
                    configList.Add(CacheConfig.FromProperties2(properties));
                }

                CacheConfig[] configs = new CacheConfig[configList.Count];
                for (int i = 0; i < configList.Count; i++)
                {
                    configs[i] = configList[i] as CacheConfig;
                }

                return(configs);
            }
            catch (ManagementException)
            {
                throw;
            }
            catch (Exception e)
            {
                throw new ManagementException(e.Message, e);
            }
        }
Example #19
0
        /// <summary>
        /// Initialize a registered cache given by the ID.
        /// </summary>
        /// <param name="cacheId">A string identifier of configuration.</param>
        static public ArrayList GetCacheConfig(string cacheId, bool inProc)
        {
            if (FileName.Length == 0)
            {
                throw new ManagementException("Can not locate cache configuration file. Installation might be corrupt");
            }
            try
            {
                XmlConfigReader configReader = new XmlConfigReader(FileName, cacheId);
                ArrayList       propsList    = configReader.PropertiesList;
                ArrayList       configsList  = CacheConfig.GetConfigs(propsList);

                foreach (CacheConfig config in configsList)
                {
                    if (!inProc)
                    {
                        inProc = config.UseInProc;
                    }
                    break;
                }

                if (inProc)
                {
                    return(configsList);
                }
                return(null);
            }

            catch (ManagementException)
            {
                throw;
            }
            catch (Exception e)
            {
                throw new ManagementException(e.Message, e);
            }
        }
Example #20
0
        public IEnumerable <IController> Create()
        {
            string directoryPath  = getCurrentDirectoryPath();
            string schemaFilePath = directoryPath + "\\config.xsd";
            string configFilePath = directoryPath + "\\config.xml";

            var xmlSchemaValidator = new XmlSchemaValidator(schemaFilePath, configFilePath);

            bool isValid = xmlSchemaValidator.Validate(out string message);

            if (!isValid)
            {
                throw new ConfigurationErrorsException("Arduino controller configuration is not valid.");
            }

            var xmlConfigReader = new XmlConfigReader(configFilePath);
            var config          = xmlConfigReader.Read();

            return(config.Select(x =>
            {
                var majoro = findConnection(x.Name);
                return new ArduinoController(majoro, x);
            }));
        }
Example #21
0
        /// <summary>
        /// Creates a cache object by reading in cofiguration parameters from a .NET XML file.
        /// </summary>
        /// <param name="configFileName">Name and/or path of the configuration file.</param>
        /// <param name="configSection">Name and/or ID of the section in the configuration file.</param>
        /// <returns>return the Cache object</returns>
        static public Cache CreateFromXmlConfig(string configFileName, string configSection)
        {
            ConfigReader xmlReader = new XmlConfigReader(configFileName, configSection);

            return(CreateFromProperties(xmlReader.Properties, null, null));
        }
Example #22
0
 public ConfigSection(XmlConfigReader root, string path)
 {
     Root = root;
     Path = path;
 }
Example #23
0
        public static void RequestStatusThread(object state)
        {
            var diagnosticService  = Program.Container.Resolve <IDiagnosticService>();
            var systemEventService = Program.Container.Resolve <ISystemEventService>();

            var listRequestUpdate = new List <Request>();
            var timeout           = 600;

            int.TryParse(XmlConfigReader.GetValue("RequestStatusTimeoutBySecond"), out timeout);

            try
            {
                var requestService        = Program.Container.Resolve <IRequestService>();
                var requestHistoryService = Program.Container.Resolve <IRequestHistoryService>();

                var listRequest = requestService.Get(p => p.Status == (int)StatusRequest.Waiting || p.Status == (int)StatusRequest.Sent);
                foreach (var request in listRequest.Where(request => (DateTime.UtcNow - request.SendingTime.GetValueOrDefault()).TotalSeconds >= timeout))
                {
                    request.Status = (int)StatusRequest.Abandoned;
                    listRequestUpdate.Add(request);
                    systemEventService.Add(EventMessage.RequestAbandoned, new Dictionary <EventMessageParam, string>()
                    {
                        { EventMessageParam.Request, request.RequestNo },
                        { EventMessageParam.Courier, request.Courier.User.LastName + " " + request.Courier.User.FirstName + (string.IsNullOrEmpty(request.Courier.User.MiddleName) ? "" : " " + request.Courier.User.MiddleName) }
                    });
                }

                var listRequestNotSend = requestService.Get(p => p.Status == (int)StatusRequest.NotSent);
                foreach (var request in listRequestNotSend.Where(request => (DateTime.UtcNow - request.SendingTime.GetValueOrDefault()).TotalSeconds >= 0))
                {
                    request.Status = (int)StatusRequest.Sent;
                    listRequestUpdate.Add(request);
                    systemEventService.Add(EventMessage.RequestSent, new Dictionary <EventMessageParam, string>()
                    {
                        { EventMessageParam.Request, request.RequestNo },
                        { EventMessageParam.Courier, request.Courier.User.LastName + " " + request.Courier.User.FirstName + (string.IsNullOrEmpty(request.Courier.User.MiddleName) ? "" : " " + request.Courier.User.MiddleName) }
                    });
                }


                var history            = new List <RequestHistory>();
                var listRequestExpired = requestService.Get(p => p.Status != (int)StatusRequest.Cancelled && p.Status != (int)StatusRequest.Completed && !(p.IsExpired ?? false));
                foreach (var request in listRequestExpired.Where(request => (DateTime.UtcNow - request.CreatedOn.GetValueOrDefault()).TotalSeconds >= request.ExpiredTime.GetValueOrDefault(0)))
                {
                    request.IsExpired = true;
                    if (request.Courier.CurrentReq == request.Id)
                    {
                        request.Courier.CurrentReq = 0;
                    }
                    listRequestUpdate.Add(request);
                    //add to history
                    history.Add(new RequestHistory()
                    {
                        ActionType        = (int)HistoryRequestActionType.Expired,
                        Comment           = "Request expired",
                        CourierId         = request.CourierId.GetValueOrDefault(),
                        LastRequestStatus = request.Status,
                        TimeChanged       = DateTime.UtcNow,
                        RequestId         = request.Id
                    });
                    systemEventService.Add(EventMessage.RequestExpired, new Dictionary <EventMessageParam, string>()
                    {
                        { EventMessageParam.Request, request.RequestNo },
                        { EventMessageParam.Courier, request.Courier.User.LastName + " " + request.Courier.User.FirstName + (string.IsNullOrEmpty(request.Courier.User.MiddleName) ? "" : " " + request.Courier.User.MiddleName) }
                    });
                }

                requestService.UpdateListRequestForService(listRequestUpdate);
                requestHistoryService.AddListRequestHistoryForWindowsService(history);
            }
            catch (Exception ex)
            {
                diagnosticService.Error(ex);
            }
        }
Example #24
0
        static public CacheServerConfig GetUpdatedCacheConfig(string cacheId, string partId, string newNode, ref ArrayList affectedNodes, bool isJoining)
        {
            if (FileName.Length == 0)
            {
                throw new ManagementException("Can not locate cache configuration file. Installation might be corrupt");
            }

            try
            {
                XmlConfigReader   configReader = new XmlConfigReader(FileName, cacheId);
                CacheServerConfig config       = configReader.GetConfigDom();

                string   list  = config.Cluster.Channel.InitialHosts.ToLower();
                string[] nodes = list.Split(',');

                if (isJoining)
                {
                    foreach (string node in nodes)
                    {
                        string[] nodename = node.Split('[');
                        affectedNodes.Add(nodename[0]);
                    }

                    if (list.IndexOf(newNode) == -1)
                    {
                        list = list + "," + newNode + "[" + config.Cluster.Channel.TcpPort + "]";
                    }
                }
                else
                {
                    foreach (string node in nodes)
                    {
                        string[] nodename = node.Split('[');
                        if (nodename[0] != newNode)
                        {
                            affectedNodes.Add(nodename[0]);
                        }
                    }

                    list = string.Empty;
                    foreach (string node in affectedNodes)
                    {
                        if (list.Length == 0)
                        {
                            list = node + "[" + config.Cluster.Channel.TcpPort + "]";
                        }
                        else
                        {
                            list = list + "," + node + "[" + config.Cluster.Channel.TcpPort + "]";
                        }
                    }
                }

                config.Cluster.Channel.InitialHosts = list;

                return(config);
            }
            catch (ManagementException)
            {
                throw;
            }
            catch (Exception e)
            {
                throw new ManagementException(e.Message, e);
            }
        }
        public WebCrawlerModel()
        {
            IConfigReader configReader = new XmlConfigReader();

            ConfigData = LoadApplicationConfig(configReader);
        }