예제 #1
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);
        }
		private static void FileAndSaveTest ()
		{
			DotNetConfigSource source = 
				new DotNetConfigSource (DotNetConfigSource.GetFullConfigPath ());
			IConfig 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);
			*/
		}
예제 #3
0
        public override void Start(string[] args)
        {
            Host.Object.Say("Starting MRM Meta System.");
            _k = NinjectFactory.getKernel<DynamicLoaderModule>();
            BindableHost.Host = Host;
            BindableWorld.World = World;

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

            string queueLibrary = typeof(AsynchQueueFactory).Assembly.Location;
            string queueType = typeof(AsynchQueueFactory).FullName;
            try {
                IConfig masterConfig = new DotNetConfigSource(AppDomain.CurrentDomain.SetupInformation.ConfigurationFile).Configs["Bootstrap"];
                queueLibrary = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, masterConfig.GetString(MRMSystem.QUEUE + MRMSystem.ASSEMBLY, queueLibrary));
                queueType = masterConfig.GetString(MRMSystem.QUEUE + MRMSystem.CLASS, queueType);
            } catch (Exception e) {
            }
            _k.Get<IDynamicLoaderModule>().BindDynamic(typeof(IAsynchQueueFactory), queueLibrary, queueType, true);

            World.OnChat += (world, chatArgs) => {
                lock (this) {
                    if (chatArgs.Channel == CHAN && chatArgs.Text.StartsWith(PING_ACK)) {
                        string configFile = chatArgs.Text.Split(new char[] { ':' }, 2)[1];
                        string baseFolder = Path.GetDirectoryName(AppDomain.CurrentDomain.SetupInformation.ConfigurationFile);
                        configFile = Path.Combine(baseFolder, configFile);
                        Console.WriteLine("Tying to start " + chatArgs.Sender.Name + " from " + configFile);
                        if (!File.Exists(configFile)) {
                            //throw new Exception("Unable to start MRM system. No config file found at '" + Path.GetFullPath(configFile) + "'.");
                            return;
                        }
                        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) + "'.");
                            return;
                        }

                        try {
                            UUID id = chatArgs.Sender.GlobalID;
                            MRMSystem system = new MRMSystem();
                            system.InitMiniModule(World, Host, UUID.Random());
                            system.Start(_k, config, configFile, id, false);

                            _liveSystems.Add(chatArgs.Sender.GlobalID, system);
                            _k.Get<IPrimFactory>()[id].OnWorldDelete += destroyedID => {
                                Stop(system);
                                system.Stop();
                                _liveSystems.Remove(id);
                            };
                        } catch (Exception e) {
                            log.Warn("Unable to start MRM system from " + chatArgs.Sender.Name + ". " + e);
                            Host.Object.Say("Unable to start MRM system from " + chatArgs.Sender.Name, 0, true, MRMChatTypeEnum.Region);
                        }
                    }
                }
            };
            Host.Object.Say(PING, CHAN, ChatTargetEnum.LSL);
        }
예제 #4
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;
        }
예제 #5
0
 /// <summary>
 /// Prevents a default instance of the <see cref="MudEngineAttributes"/> class from being created. 
 /// </summary>
 private MudEngineAttributes()
 {
     lock (syncRoot)
     {
         string path = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
         path = Path.Combine(path, "mud.config");
         this.config = new DotNetConfigSource(path);
         this.GetConfigSettings();
     }
 }
예제 #6
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 static void WebTest ()
		{
			string[] sections = new string[] { "appSettings", "Pets" };
			DotNetConfigSource source = new DotNetConfigSource (sections);
			IConfig 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 FileTest ()
		{
			DotNetConfigSource source = 
				new DotNetConfigSource (DotNetConfigSource.GetFullConfigPath ());
			IConfig 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");
		}
		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);
		}
		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"));
		}
		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
			{
			}
		}
        public LevelRangeWidget(string label, int low, int high)
        {
            IConfigSource config = new DotNetConfigSource(DotNetConfigSource.GetFullConfigPath());

            int entrySize = config.Configs["defaults"].GetInt("entrySize");
            int entryWidth = config.Configs["defaults"].GetInt("entryWidth");

            Low = new Entry(entrySize);
            Low.SetSizeRequest(entryWidth, Low.SizeRequest().Height);
            Low.WidthChars = entrySize;
            Low.IsEditable = false;
            Low.CanFocus = false;

            Label = new Label(label);
            Label.Justify = Justification.Center;
            Label.SetSizeRequest(150, Label.SizeRequest().Height);

            High = new Entry(entrySize);
            High.SetSizeRequest(entryWidth, High.SizeRequest().Height);
            High.WidthChars = entrySize;
            High.IsEditable = false;
            High.CanFocus = false;
        }
		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"));
		}
		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);
		}
		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);
		}
예제 #16
0
        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);
        }
예제 #17
0
        /// <summary>
        /// Load in all the configuration values from the XMRM section of various configuration sources.
        /// 
        /// The order is:
        /// 1 - the Opensim application config file.
        /// 2 - opensim.ini
        /// 3 - The parameters passed in in the body of the text are parsed
        /// [4] - any application config file pointed to by one of the previous 3 configs.
        /// 
        /// Each set of config values overrides the previous so if "ShadowCopy" is set to "true" in the opensim config file, opensim.ini and
        /// in the script but "false" in the config file the final value will be false.
        /// </summary>
        /// <param name="script">The script to parse for information.</param>
        /// <returns>A config object with the values taken from the script.</returns>
        private IConfig LoadConfigValues(out string[] scriptArguments)
        {
            //Load in the arguments as command line arguments
            CommandLineConfig argConfig = new CommandLineConfig(ScriptText, true, "\n", " ");

            argConfig.AddSetting(XMRM, CONFIG_FILE, "f");
            argConfig.AddSetting(XMRM, CONFIG_FILE, "F");

            argConfig.AddSetting(XMRM, ASSEMBLY, "a");
            argConfig.AddSetting(XMRM, ASSEMBLY, "A");

            argConfig.AddSetting(XMRM, CLASS, "c");
            argConfig.AddSetting(XMRM, CLASS, "C");

            argConfig.AddSetting(XMRM, BASE_FOLDER, "b");
            argConfig.AddSetting(XMRM, BASE_FOLDER, "B");

            argConfig.AddFlag(XMRM, SHADOW_COPY, "s", false);
            argConfig.AddFlag(XMRM, SHADOW_COPY, "S", false);

            argConfig.AddFlag(XMRM, GOD, "g", false);
            argConfig.AddFlag(XMRM, GOD, "G", false);

            scriptArguments = argConfig.Argument.Length == 0 ? new string[0] : argConfig.Argument.Split(' ', '\n');

            //Merge the three guaranteed config sources
            IConfigSource config = new IniConfigSource();
            config.Merge(m_appConfig);
            config.Merge(m_config);
            config.Merge(argConfig);

            IConfig mrmConfig = config.Configs[XMRM];

            //If a config file is specified merge those values in
            if (mrmConfig.Contains(CONFIG_FILE)) {
                try {
                    IConfigSource fileSource = new DotNetConfigSource(mrmConfig.Get(CONFIG_FILE));
                    config.Merge(fileSource);
                } catch (Exception e) {
                    ErrorString = ("Unable to load config file from '" + mrmConfig.Get(CONFIG_FILE) + "'. " + e.Message);
                }
            }
            return config.Configs[XMRM];
        }
예제 #18
0
파일: Editor.cs 프로젝트: rcarz/nini
        /// <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;
            }
        }
		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"));
		}
		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);
		}
		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);
		}
		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);
		}
        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);
        }
		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);
		}
		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 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 ());
		}
예제 #27
0
파일: Editor.cs 프로젝트: rcarz/nini
        /// <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;
        }
		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);
		}
예제 #29
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;
        }
        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);