Exemple #1
0
        public void ToStringTest()
        {
            XmlDocument doc = NiniDoc();

            AddSection(doc, "Pets");
            AddKey(doc, "Pets", "cat", "Muffy");
            AddKey(doc, "Pets", "dog", "Rover");

            DotNetConfigSource source =
                new DotNetConfigSource(DocumentToReader(doc));
            string eol = Environment.NewLine;

            string compare = "<?xml version=\"1.0\" encoding=\"utf-16\"?>" + eol
                             + "<configuration>" + eol
                             + "  <configSections>" + eol
                             + "    <section name=\"Pets\" "
                             + "type=\"System.Configuration.NameValueSectionHandler\" />" + eol
                             + "  </configSections>" + eol
                             + "  <Pets>" + eol
                             + "    <add key=\"cat\" value=\"Muffy\" />" + eol
                             + "    <add key=\"dog\" value=\"Rover\" />" + eol
                             + "  </Pets>" + eol
                             + "</configuration>";

            Assert.AreEqual(compare, source.ToString());
        }
Exemple #2
0
        public void SetAndSave()
        {
            string filePath = "Test.xml";

            XmlDocument doc = NiniDoc();

            AddSection(doc, "NewSection");
            AddKey(doc, "NewSection", "dog", "Rover");
            AddKey(doc, "NewSection", "cat", "Muffy");
            doc.Save(filePath);

            DotNetConfigSource source = new DotNetConfigSource(filePath);

            IConfig config = source.Configs["NewSection"];

            Assert.AreEqual("Rover", config.Get("dog"));
            Assert.AreEqual("Muffy", config.Get("cat"));

            config.Set("dog", "Spots");
            config.Set("cat", "Misha");
            config.Set("DoesNotExist", "SomeValue");

            Assert.AreEqual("Spots", config.Get("dog"));
            Assert.AreEqual("Misha", config.Get("cat"));
            Assert.AreEqual("SomeValue", config.Get("DoesNotExist"));
            source.Save();

            source = new DotNetConfigSource(filePath);
            config = source.Configs["NewSection"];
            Assert.AreEqual("Spots", config.Get("dog"));
            Assert.AreEqual("Misha", config.Get("cat"));
            Assert.AreEqual("SomeValue", config.Get("DoesNotExist"));

            File.Delete(filePath);
        }
        public override void Start(string[] args)
        {
            IKernel k = NinjectFactory.getKernel <DynamicLoaderModule>();

            BindableHost.Host   = Host;
            BindableWorld.World = World;

            k.Bind <IHost>().To <BindableHost>().InSingletonScope();
            k.Bind <IWorld>().To <BindableWorld>().InSingletonScope();

            string configFile = AppDomain.CurrentDomain.SetupInformation.ConfigurationFile;

            if (!File.Exists(configFile))
            {
                throw new Exception("Unable to start MRM system. No config file found at '" + Path.GetFullPath(configFile) + "'.");
            }
            IConfig config = new DotNetConfigSource(configFile).Configs["Bootstrap"];

            if (config == null)
            {
                throw new Exception("Unable to start MRM system. No 'Bootstrap' section found in config file '" + Path.GetFullPath(configFile) + "'.");
            }

            string queueLibrary = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, config.GetString(QUEUE + ASSEMBLY, typeof(AsynchQueueFactory).Assembly.Location));
            string queueType    = config.GetString(QUEUE + CLASS, typeof(AsynchQueueFactory).FullName);

            k.Get <IDynamicLoaderModule>().BindDynamic(typeof(IAsynchQueueFactory), queueLibrary, queueType, true);

            Start(k, config, configFile, Host.Object.GlobalID, true);
        }
        private static void FileAndSaveTest()
        {
            var source = new DotNetConfigSource(DotNetConfigSource.GetFullConfigPath());
            var config = source.Configs["appSettings"];

            config = source.Configs["Pets"];
            AssertEquals("rover", config.Get("dog"));
            AssertEquals("muffy", config.Get("cat"));
            Assert(config.Get("not here") == null, "Should not be present");

            config.Set("dog", "Spots");
            config.Set("cat", "Misha");

            AssertEquals("Spots", config.Get("dog"));
            AssertEquals("Misha", config.Get("cat"));

            // Cannot perform save yet until technical issues resolved

            /*
             * string fileName = "DotNetConfigSourceTests.exe.config";
             * source.Save ();
             *
             * source = new DotNetConfigSource ();
             * config = source.Configs["Pets"];
             * AssertEquals ("Spots", config.Get ("dog"));
             * AssertEquals ("Misha", config.Get ("cat"));
             *
             * File.Delete (fileName);
             */
        }
Exemple #5
0
        public void NoConfigSectionsNode()
        {
            string filePath = "AppSettings.xml";

            // Create an XML document with no configSections node
            XmlDocument doc = new XmlDocument();

            doc.LoadXml("<configuration></configuration>");

            XmlNode node = doc.CreateElement("appSettings");

            doc.DocumentElement.AppendChild(node);
            AddKey(doc, "appSettings", "Test", "Hello");


            doc.Save(filePath);

            DotNetConfigSource source = new DotNetConfigSource(filePath);

            IConfig config = source.Configs["appSettings"];

            Assert.AreEqual("Hello", config.GetString("Test"));

            File.Delete(filePath);
        }
Exemple #6
0
        public void LoadReader()
        {
            XmlDocument doc = NiniDoc();

            AddSection(doc, "Pets");
            AddKey(doc, "Pets", "cat", "muffy");
            AddKey(doc, "Pets", "dog", "rover");
            AddKey(doc, "Pets", "bird", "tweety");

            DotNetConfigSource source =
                new DotNetConfigSource(DocumentToReader(doc));

            IConfig config = source.Configs["Pets"];

            Assert.AreEqual(3, config.GetKeys().Length);
            Assert.AreEqual("rover", config.Get("dog"));

            config.Set("dog", "new name");
            config.Remove("bird");

            source.Load(DocumentToReader(doc));

            config = source.Configs["Pets"];
            Assert.AreEqual(3, config.GetKeys().Length);
            Assert.AreEqual("rover", config.Get("dog"));
        }
Exemple #7
0
        public void SaveToStream()
        {
            string     filePath = "SaveToStream.ini";
            FileStream stream   = new FileStream(filePath, FileMode.Create);

            // Create a new document and save to stream
            DotNetConfigSource source = new DotNetConfigSource();
            IConfig            config = source.AddConfig("Pets");

            config.Set("dog", "rover");
            config.Set("cat", "muffy");
            source.Save(stream);
            stream.Close();

            DotNetConfigSource newSource = new DotNetConfigSource(filePath);

            config = newSource.Configs["Pets"];
            Assert.IsNotNull(config);
            Assert.AreEqual(2, config.GetKeys().Length);
            Assert.AreEqual("rover", config.GetString("dog"));
            Assert.AreEqual("muffy", config.GetString("cat"));

            stream.Close();

            File.Delete(filePath);
        }
Exemple #8
0
        public void EmptyConstructor()
        {
            string             filePath = "EmptyConstructor.xml";
            DotNetConfigSource source   = new DotNetConfigSource();

            IConfig config = source.AddConfig("Pets");

            config.Set("cat", "Muffy");
            config.Set("dog", "Rover");
            config.Set("bird", "Tweety");
            source.Save(filePath);

            Assert.AreEqual(3, config.GetKeys().Length);
            Assert.AreEqual("Muffy", config.Get("cat"));
            Assert.AreEqual("Rover", config.Get("dog"));
            Assert.AreEqual("Tweety", config.Get("bird"));

            source = new DotNetConfigSource(filePath);
            config = source.Configs["Pets"];

            Assert.AreEqual(3, config.GetKeys().Length);
            Assert.AreEqual("Muffy", config.Get("cat"));
            Assert.AreEqual("Rover", config.Get("dog"));
            Assert.AreEqual("Tweety", config.Get("bird"));

            File.Delete(filePath);
        }
Exemple #9
0
        /*
         * public static Form StartGui(IConfig config, ViewerProxy form, Func<Form> createForm) {
         *  if (Thread.CurrentThread.GetApartmentState() == ApartmentState.STA) {
         *      Form f = createForm();
         *      StartProxyClient(config, form, f);
         *      f.ShowDialog();
         *      return f;
         *  } else {
         *      object createLock = new object();
         *      Form f = null;
         *      bool started = false;
         *      Thread t = new Thread(() => {
         *          f = createForm();
         *          lock (createLock)
         *              MonitorChanged.PulseAll(createLock);
         *          started = true;
         *          StartProxyClient(config, form, f);
         *          f.ShowDialog();
         *      });
         *      t.SetApartmentState(ApartmentState.STA);
         *      t.Begin();
         *      if (!started)
         *          lock (createLock)
         *              MonitorChanged.Wait(createLock);
         *      return f;
         *  }
         * }
         *
         * private static void StartProxyClient(IConfig config, ViewerProxy form, Form f) {
         *  f.VisibleChanged += (source, args) => {
         *      if (!f.Visible)
         *          return;
         *      bool autostartProxy = Get(config, "AutoStartProxy", false);
         *      bool autostartClient = Get(config, "AutoStartClient", false);
         *
         *      if (autostartProxy || autostartClient)
         *          while (!form.StartProxy())
         *              form.ProxyConfig.ProxyPort++;
         *      if (autostartClient)
         *          form.StartClient();
         *  };
         * }
         */

        public static IConfigSource AddFile(IConfigSource config, string file)
        {
            if (File.Exists(file) && Path.GetExtension(file).ToUpper().Equals(".CONFIG"))
            {
                try {
                    DotNetConfigSource dotnet = new DotNetConfigSource(file);
                    //config.Merge(dotnet);
                    dotnet.Merge(config);
                    return(dotnet);
                } catch (Exception e) {
                    Logger.Warn("Unable to load app configuration file " + file + "'." + e.Message + ".\n" + e.StackTrace);
                }
            }
            else if (File.Exists(file) && Path.GetExtension(file).ToUpper().Equals(".INI"))
            {
                try {
                    IniDocument     doc = new IniDocument(file, IniFileType.WindowsStyle);
                    IniConfigSource ini = new IniConfigSource(doc);
                    //config.Merge(ini);
                    ini.Merge(config);
                    return(ini);
                } catch (Exception e) {
                    Logger.Warn("Unable to load ini configuration file " + file + "'." + e.Message + ".\n" + e.StackTrace);
                }
            }
            return(config);
        }
Exemple #10
0
        public void SaveNewSection()
        {
            string filePath = "Test.xml";

            XmlDocument doc = NiniDoc();

            AddSection(doc, "NewSection");
            AddKey(doc, "NewSection", "dog", "Rover");
            AddKey(doc, "NewSection", "cat", "Muffy");
            doc.Save(filePath);

            DotNetConfigSource source = new DotNetConfigSource(filePath);
            IConfig            config = source.AddConfig("test");

            Assert.IsNotNull(source.Configs["test"]);
            source.Save();

            source = new DotNetConfigSource(filePath);
            config = source.Configs["NewSection"];
            Assert.AreEqual("Rover", config.Get("dog"));
            Assert.AreEqual("Muffy", config.Get("cat"));
            Assert.IsNotNull(source.Configs["test"]);

            File.Delete(filePath);
        }
Exemple #11
0
        /// <summary>
        /// Creates a new config file.
        /// </summary>
        private void CreateNewFile()
        {
            string type = null;;

            if (IsArg("set-type"))
            {
                type = GetArg("set-type").ToLower();
            }
            else
            {
                ThrowError("You must supply a type (--set-type)");
            }

            switch (type)
            {
            case "ini":
                IniConfigSource iniSource = new IniConfigSource();
                iniSource.Save(configPath);
                break;

            case "xml":
                XmlConfigSource xmlSource = new XmlConfigSource();
                xmlSource.Save(configPath);
                break;

            case "config":
                DotNetConfigSource dotnetSource = new DotNetConfigSource();
                dotnetSource.Save(configPath);
                break;

            default:
                ThrowError("Unknown type");
                break;
            }
        }
Exemple #12
0
        public void ReplaceText()
        {
            XmlDocument doc = NiniDoc();

            AddSection(doc, "Test");
            AddKey(doc, "Test", "author", "Brent");
            AddKey(doc, "Test", "domain", "${protocol}://nini.sf.net/");
            AddKey(doc, "Test", "apache", "Apache implements ${protocol}");
            AddKey(doc, "Test", "developer", "author of Nini: ${author} !");
            AddKey(doc, "Test", "love", "We love the ${protocol} protocol");
            AddKey(doc, "Test", "combination", "${author} likes ${protocol}");
            AddKey(doc, "Test", "fact", "fact: ${apache}");
            AddKey(doc, "Test", "protocol", "http");

            DotNetConfigSource source =
                new DotNetConfigSource(DocumentToReader(doc));

            source.ReplaceKeyValues();

            IConfig config = source.Configs["Test"];

            Assert.AreEqual("http", config.Get("protocol"));
            Assert.AreEqual("fact: Apache implements http", config.Get("fact"));
            Assert.AreEqual("http://nini.sf.net/", config.Get("domain"));
            Assert.AreEqual("Apache implements http", config.Get("apache"));
            Assert.AreEqual("We love the http protocol", config.Get("love"));
            Assert.AreEqual("author of Nini: Brent !", config.Get("developer"));
            Assert.AreEqual("Brent likes http", config.Get("combination"));
        }
Exemple #13
0
        public void SaveToWriter()
        {
            string newPath = "TestNew.xml";

            XmlDocument doc = NiniDoc();

            AddSection(doc, "Pets");
            AddKey(doc, "Pets", "cat", "Muffy");
            AddKey(doc, "Pets", "dog", "Rover");

            DotNetConfigSource source =
                new DotNetConfigSource(DocumentToReader(doc));
            IConfig config = source.Configs["Pets"];

            Assert.AreEqual("Rover", config.Get("dog"));
            Assert.AreEqual("Muffy", config.Get("cat"));

            StreamWriter textWriter = new StreamWriter(newPath);

            source.Save(textWriter);
            textWriter.Close();              // save to disk

            source = new DotNetConfigSource(newPath);
            config = source.Configs["Pets"];
            Assert.AreEqual("Rover", config.Get("dog"));
            Assert.AreEqual("Muffy", config.Get("cat"));

            File.Delete(newPath);
        }
Exemple #14
0
        public void SaveToNewPath()
        {
            string filePath = "Test.xml";
            string newPath  = "TestNew.xml";

            XmlDocument doc = NiniDoc();

            AddSection(doc, "Pets");
            AddKey(doc, "Pets", "cat", "Muffy");
            AddKey(doc, "Pets", "dog", "Rover");
            doc.Save(filePath);

            DotNetConfigSource source = new DotNetConfigSource(filePath);
            IConfig            config = source.Configs["Pets"];

            Assert.AreEqual("Rover", config.Get("dog"));
            Assert.AreEqual("Muffy", config.Get("cat"));

            source.Save(newPath);

            source = new DotNetConfigSource(newPath);
            config = source.Configs["Pets"];
            Assert.AreEqual("Rover", config.Get("dog"));
            Assert.AreEqual("Muffy", config.Get("cat"));

            File.Delete(filePath);
            File.Delete(newPath);
        }
Exemple #15
0
        public void MergeAndSave()
        {
            string xmlFileName = "NiniConfig.xml";

            XmlDocument doc = NiniDoc();

            AddSection(doc, "Pets");
            AddKey(doc, "Pets", "cat", "Muffy");
            AddKey(doc, "Pets", "dog", "Rover");
            AddKey(doc, "Pets", "bird", "Tweety");
            doc.Save(xmlFileName);

            StringWriter writer = new StringWriter();

            writer.WriteLine("[Pets]");
            writer.WriteLine("cat = Becky");              // overwrite
            writer.WriteLine("lizard = Saurus");          // new
            writer.WriteLine("[People]");
            writer.WriteLine(" woman = Jane");
            writer.WriteLine(" man = John");
            IniConfigSource iniSource = new IniConfigSource
                                            (new StringReader(writer.ToString()));

            DotNetConfigSource xmlSource = new DotNetConfigSource(xmlFileName);

            xmlSource.Merge(iniSource);

            IConfig config = xmlSource.Configs["Pets"];

            Assert.AreEqual(4, config.GetKeys().Length);
            Assert.AreEqual("Becky", config.Get("cat"));
            Assert.AreEqual("Rover", config.Get("dog"));
            Assert.AreEqual("Saurus", config.Get("lizard"));

            config = xmlSource.Configs["People"];
            Assert.AreEqual(2, config.GetKeys().Length);
            Assert.AreEqual("Jane", config.Get("woman"));
            Assert.AreEqual("John", config.Get("man"));

            config.Set("woman", "Tara");
            config.Set("man", "Quentin");

            xmlSource.Save();

            xmlSource = new DotNetConfigSource(xmlFileName);

            config = xmlSource.Configs["Pets"];
            Assert.AreEqual(4, config.GetKeys().Length);
            Assert.AreEqual("Becky", config.Get("cat"));
            Assert.AreEqual("Rover", config.Get("dog"));
            Assert.AreEqual("Saurus", config.Get("lizard"));

            config = xmlSource.Configs["People"];
            Assert.AreEqual(2, config.GetKeys().Length);
            Assert.AreEqual("Tara", config.Get("woman"));
            Assert.AreEqual("Quentin", config.Get("man"));

            File.Delete(xmlFileName);
        }
Exemple #16
0
 public WinterNationals2011PairsScorer()
 {
     InitializeComponent();
     m_configParameters = new DotNetConfigSource(DotNetConfigSource.GetFullConfigPath());
     getFieldName("GoogleSiteName");
     Globals.m_rootDirectory = Directory.GetCurrentDirectory();
     loadEventPageMapping();
 }
        /// <summary>Prevents a default instance of the <see cref="MudEngineAttributes"/> class from being created.</summary>
        private MudEngineAttributes()
        {
            string path = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);

            path        = Path.Combine(path, "mud.config");
            this.config = new DotNetConfigSource(path);
            this.GetConfigSettings();
        }
Exemple #18
0
        private static string GetMudName()
        {
            string path = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);

            path = Path.Combine(path, "mud.config");
            var config = new DotNetConfigSource(path);

            string mudName = config.Configs["EngineAttributes"].GetString("name");

            return(mudName);
        }
Exemple #19
0
        static AppConfig()
        {
            var userConfigFile = Path.Combine(ApplicationData, "user.config");

            if (!File.Exists(userConfigFile))
            {
                File.Copy(DotNetConfigSource.GetFullConfigPath(), userConfigFile);
            }

            configSource = new DotNetConfigSource(userConfigFile);
            appSettings  = configSource.Configs ["appSettings"];
        }
Exemple #20
0
        public void SetFolder(string folder)
        {
            DotNetConfigSource source = new DotNetConfigSource();
            IConfig            cfg    = source.Configs["Config"];

            if (cfg == null)
            {
                cfg = source.Configs.Add("Config");
            }

            cfg.Set("ConfigFolder", folder);
            source.Save(AppDomain.CurrentDomain.SetupInformation.ConfigurationFile);
        }
        private void applicationList_SelectedIndexChanged(object sender, EventArgs e)
        {
            string        file   = Path.GetFullPath(Path.Combine(Environment.CurrentDirectory, "../" + applicationList.SelectedItem + ".exe.config"));
            IConfigSource src    = new DotNetConfigSource(file);
            string        folder = "Configs/Test";

            if (src.Configs["Config"] != null)
            {
                folder = src.Configs["Config"].Get("ConfigFolder", folder).Substring(8).TrimEnd('/', '\\');
            }

            folderList.SelectedItem = folderList.Items.OfType <string>().FirstOrDefault(f => f == folder);
        }
        private static void FileTest()
        {
            var source = new DotNetConfigSource(DotNetConfigSource.GetFullConfigPath());
            var config = source.Configs["appSettings"];

            Assert(config != null, "IConfig is null");
            AssertEquals("My App", config.Get("App Name"));

            config = source.Configs["Pets"];
            AssertEquals("rover", config.Get("dog"));
            AssertEquals("muffy", config.Get("cat"));
            Assert(config.Get("not here") == null, "Should not be present");
        }
        private static void WebTest()
        {
            var sections = new string[] { "appSettings", "Pets" };
            var source   = new DotNetConfigSource(sections);
            var config   = source.Configs["appSettings"];

            Assert(config != null, "IConfig is null");
            AssertEquals("My App", config.Get("App Name"));

            config = source.Configs["Pets"];
            AssertEquals("rover", config.Get("dog"));
            AssertEquals("muffy", config.Get("cat"));
            Assert(config.Get("not here") == null, "Should not be present");
        }
        private void bindButton_Click(object sender, EventArgs e)
        {
            string             configFile = Path.Combine("..", applicationList.SelectedItem + ".exe.config");
            string             configPath = Path.GetFullPath(Path.Combine(Environment.CurrentDirectory, configFile));
            DotNetConfigSource source     = new DotNetConfigSource(configPath);
            IConfig            cfg        = source.Configs["Config"];

            if (cfg == null)
            {
                cfg = source.Configs.Add("Config");
            }

            cfg.Set("ConfigFolder", "Configs/" + folderList.SelectedItem);
            source.Save(configPath);
        }
Exemple #25
0
        public void Reload()
        {
            string             filePath = "ReloadDot.xml";
            DotNetConfigSource source   = new DotNetConfigSource();

            IConfig petConfig = source.AddConfig("Pets");

            petConfig.Set("cat", "Muffy");
            petConfig.Set("dog", "Rover");
            IConfig weatherConfig = source.AddConfig("Weather");

            weatherConfig.Set("skies", "cloudy");
            weatherConfig.Set("precipitation", "rain");
            source.Save(filePath);

            Assert.AreEqual(2, petConfig.GetKeys().Length);
            Assert.AreEqual("Muffy", petConfig.Get("cat"));
            Assert.AreEqual(2, source.Configs.Count);

            DotNetConfigSource newSource = new DotNetConfigSource(filePath);

            IConfig compareConfig = newSource.Configs["Pets"];

            Assert.AreEqual(2, compareConfig.GetKeys().Length);
            Assert.AreEqual("Muffy", compareConfig.Get("cat"));
            Assert.IsTrue(compareConfig == newSource.Configs["Pets"],
                          "References before are not equal");

            // Set the new values to source
            source.Configs["Pets"].Set("cat", "Misha");
            source.Configs["Pets"].Set("lizard", "Lizzy");
            source.Configs["Pets"].Set("hampster", "Surly");
            source.Configs["Pets"].Remove("dog");
            source.Configs.Remove(weatherConfig);
            source.Save();              // saves new value

            // Reload the new source and check for changes
            newSource.Reload();
            Assert.IsTrue(compareConfig == newSource.Configs["Pets"],
                          "References after are not equal");
            Assert.AreEqual(1, newSource.Configs.Count);
            Assert.AreEqual(3, newSource.Configs["Pets"].GetKeys().Length);
            Assert.AreEqual("Lizzy", newSource.Configs["Pets"].Get("lizard"));
            Assert.AreEqual("Misha", newSource.Configs["Pets"].Get("cat"));
            Assert.IsNull(newSource.Configs["Pets"].Get("dog"));

            File.Delete(filePath);
        }
Exemple #26
0
        public void GetConfig()
        {
            XmlDocument doc = NiniDoc();

            AddSection(doc, "Pets");
            AddKey(doc, "Pets", "cat", "muffy");
            AddKey(doc, "Pets", "dog", "rover");
            AddKey(doc, "Pets", "bird", "tweety");

            DotNetConfigSource source =
                new DotNetConfigSource(DocumentToReader(doc));

            IConfig config = source.Configs["Pets"];

            Assert.AreEqual("Pets", config.Name);
            Assert.AreEqual(3, config.GetKeys().Length);
            Assert.AreEqual(source, config.ConfigSource);
        }
Exemple #27
0
        public void GetString()
        {
            XmlDocument doc = NiniDoc();

            AddSection(doc, "Pets");
            AddKey(doc, "Pets", "cat", "muffy");
            AddKey(doc, "Pets", "dog", "rover");
            AddKey(doc, "Pets", "bird", "tweety");

            DotNetConfigSource source =
                new DotNetConfigSource(DocumentToReader(doc));
            IConfig config = source.Configs["Pets"];

            Assert.AreEqual("muffy", config.Get("cat"));
            Assert.AreEqual("rover", config.Get("dog"));
            Assert.AreEqual("muffy", config.GetString("cat"));
            Assert.AreEqual("rover", config.GetString("dog"));
            Assert.AreEqual("my default", config.Get("Not Here", "my default"));
            Assert.IsNull(config.Get("Not Here 2"));
        }
Exemple #28
0
        static Config()
        {
            AppConfigRoot = new Nini.Config.DotNetConfigSource(DotNetConfigSource.GetFullConfigPath());
            AppSettings   = AppConfigRoot.Configs["appSettings"];

            bool          hasExtraConfig  = false;
            IConfigSource extraConfigRoot = null;

            if (File.Exists(ExtraConfigFile))
            {
                hasExtraConfig  = true;
                ExtraConfigRoot = new Nini.Config.XmlConfigSource(ExtraConfigFile);
                extraConfigRoot = ExtraConfigRoot;
            }
            if (File.Exists(PrivateExtraConfigFile))
            {
                hasExtraConfig         = true;
                PrivateExtraConfigRoot = new Nini.Config.XmlConfigSource(PrivateExtraConfigFile);
                if (extraConfigRoot != null)
                {
                    extraConfigRoot.Merge(PrivateExtraConfigRoot);
                }
                else
                {
                    extraConfigRoot = PrivateExtraConfigRoot;
                }
            }

            if (hasExtraConfig)
            {
                ExtraConfig        = extraConfigRoot.Configs["Settings"];
                RconServerAddress  = ExtraConfig.GetString("RconServerAddress");
                RconServerPort     = ExtraConfig.GetInt("RconServerPort");
                RconServerPassword = ExtraConfig.GetString("RconServerPassword");
            }
            else
            {
                throw new ApplicationException("Can't find config file: " + ExtraConfigFile);
            }
        }
Exemple #29
0
        /// <summary>
        /// Loads a sourc from file.
        /// </summary>
        private IConfigSource LoadSource(string path)
        {
            IConfigSource result    = null;
            string        extension = null;

            if (IsArg("set-type"))
            {
                extension = "." + GetArg("set-type").ToLower();
            }
            else
            {
                FileInfo info = new FileInfo(path);
                extension = info.Extension;
            }

            switch (extension)
            {
            case ".ini":
                result = new IniConfigSource(path);
                break;

            case ".config":
                result = new DotNetConfigSource(path);
                break;

            case ".xml":
                result = new XmlConfigSource(path);
                break;

            default:
                ThrowError("Unknown config file type");
                break;
            }
            if (verbose)
            {
                PrintLine("Loaded config: " + result.GetType().Name);
            }

            return(result);
        }
Exemple #30
0
        public void GetInt()
        {
            XmlDocument doc = NiniDoc();

            AddSection(doc, "Pets");
            AddKey(doc, "Pets", "value 1", "49588");

            DotNetConfigSource source =
                new DotNetConfigSource(DocumentToReader(doc));

            IConfig config = source.Configs["Pets"];

            Assert.AreEqual(49588, config.GetInt("value 1"));
            Assert.AreEqual(12345, config.GetInt("Not Here", 12345));

            try
            {
                config.GetInt("Not Here Also");
                Assert.Fail();
            }
            catch
            {
            }
        }