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);
*/
}
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);
}
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;
}
/// <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();
}
}
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);
}
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);
}
/// <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];
}
/// <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 ());
}
/// <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);
}
/*
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);