protected static void CreateMergedTestAppConfig(out string mainFile, out string userFile)
{
mainFile = "initMainSettings".TestRunUniqueName(Toml.FileExtension);
userFile = "initUserSettings".TestRunUniqueName(Toml.FileExtension);
var main = TestData.TestAppSettings.GlobalSettings;
var userSettings = TestData.TestAppSettings.User1Settings;
var user = Toml.Create();
user.Add(nameof(main.User), userSettings);
// Act
Toml.WriteFile(main, mainFile);
Toml.WriteFile(user, userFile);
}
private static void SetUpGlobalSettings()
{
// save/load settings
string settingsPath = Path.Combine(DataDir, @"settings.toml");
if (!File.Exists(settingsPath) && !new DirectoryInfo(DataDir).Attributes.HasFlag(FileAttributes.ReadOnly))
{
Toml.WriteFile <GlobalSettings>(new GlobalSettings(), settingsPath);
}
if (File.Exists(settingsPath))
{
GlobalSettings = Toml.ReadFile <GlobalSettings>(settingsPath);
}
}
public void WriteFile_WithFloat_WritesCultureInvariant()
{
// Arrange
var tt = Toml.Create();
tt.Add("TheFloat", 1.2);
// Act
Toml.WriteFile(tt, this.fn);
// Assert
var s = File.ReadAllText(this.fn);
s.Should().Be("TheFloat = 1.2\r\n");
}
public static List <AvailableResolver> GetAllResolversWithFilters()
{
var resolvers = new List <AvailableResolver>();
var dnscryptFolder = Path.Combine(Directory.GetCurrentDirectory(), Global.DnsCryptProxyFolder);
// we use a second config file
var tmpToml = Path.Combine(dnscryptFolder, "_tmp_.toml");
if (File.Exists(tmpToml))
{
File.Delete(tmpToml);
}
File.Copy(Path.Combine(dnscryptFolder, Global.DnsCryptConfigurationFile), Path.Combine(dnscryptFolder, tmpToml));
var config = Toml.ReadFile <DnscryptProxyConfiguration>(tmpToml);
//clear the array
config.server_names = null;
Toml.WriteFile(config, tmpToml);
var result = ExecuteWithArguments("-config _tmp_.toml -list -json");
if (!result.Success)
{
return(resolvers);
}
if (string.IsNullOrEmpty(result.StandardOutput))
{
return(resolvers);
}
try
{
var res = JsonConvert.DeserializeObject <List <AvailableResolver> >(result.StandardOutput);
if (res.Count > 0)
{
resolvers = res;
}
}
catch (Exception exception)
{
Log.Error(exception);
}
finally
{
if (File.Exists(tmpToml))
{
File.Delete(tmpToml);
}
}
return(resolvers);
}
public static DiscoConfig GetConfig()
{
/*
* The "current directory" is where the
* DesktopGoose executable is
*/
string discoConfig = Path.Combine(Directory.GetCurrentDirectory(), @"Assets\Mods\DiscoGoose\config.toml");
if (!File.Exists(discoConfig))
{
Toml.WriteFile(new DiscoConfig(), discoConfig);
}
return(Toml.ReadFile <DiscoConfig>(discoConfig));
}
private CurrentSettings LoadSettingsFromPath(string path)
{
var tomlFile = Toml.ReadFile(path, TomlHelper.DefaultSettings);
var version = tomlFile["Version"].Get <string>();
// Create backup before migration
if (version != CurrentSettingsVersion)
{
Toml.WriteFile(tomlFile, Path.Combine(SettingsDirectory, $"audioband.settings.{version}"), TomlHelper.DefaultSettings);
var settings = SettingsMigration.MigrateSettings <CurrentSettings>(tomlFile.Get(SettingsTypeTable[version]), version, CurrentSettingsVersion);
SerializeSettings(settings);
return(settings);
}
return(tomlFile.Get <CurrentSettings>());
}
public void WriteFile_WritesFile()
{
// Arrange
var foo = new Foo()
{
X = 1
};
// Act
Toml.WriteFile(foo, fn);
// Assert
File.Exists(this.fn).Should().Be(true);
var read = Toml.ReadFile <Foo>(this.fn);
read.X.Should().Be(1);
}
private void WriteTomlFile(string fileName)
{
var config = new Configuration()
{
EnableDebug = true,
Server = new Server()
{
Timeout = TimeSpan.FromMinutes(1)
},
Client = new Client()
{
ServerAddress = "http://127.0.0.1:8080"
},
};
Toml.WriteFile(config, fileName);
}
protected virtual void Dispose(bool disposing)
{
if (disposing)
{
if (_config != null)
{
Toml.WriteFile(_config, "config.toml", _tomlSettings);
_config = null;
}
_waveIn?.StopRecording();
_waveIn?.Dispose();
_waveIn = null;
_speechRecognizer?.Dispose();
_speechRecognizer = null;
_skFont?.Dispose();
_skFont = null;
_skStrokePaint?.Dispose();
_skStrokePaint = null;
_skFillPaint?.Dispose();
_skFillPaint = null;
_skScreenSurface?.Dispose();
_skScreenSurface = null;
_skScreenRenderTarget?.Dispose();
_skScreenRenderTarget = null;
_skContext?.Dispose();
_skContext = null;
_skInterface?.Dispose();
_skInterface = null;
_tkContext?.Dispose();
_tkContext = null;
_tkWindow?.Dispose();
_tkWindow = null;
}
}
/// <summary>
/// Saves global settings to specified file.
/// </summary>
/// <param name="path">Path to settings file.</param>
/// <exception cref="System.InvalidOperationException">Settings are not instantiated.</exception>
public static void Save(string path)
{
if (Instance == null)
{
throw new InvalidOperationException("Settings are not instantiated.");
}
Instance.Saving();
try
{
Toml.WriteFile <AppSettings>(AppSettings.Instance, path);
}
catch (Exception e)
{
MessageBox.Show($"Cannot save prefs: {e.Message}");
}
}
public void Save(string filepath = "")
{
if (!String.IsNullOrEmpty(filepath))
{
FilePath = filepath;
}
var data = new Dictionary <string, object>()
{
{ Defines.KeyConfig, InputMonitor.GetConfig() },
{ Defines.TouchConfig, TouchSettings.GetConfig() },
{ Defines.GameConfig, GameSettingsScreen.GetConfig() }
};
Toml.WriteFile(data, Defines.ConfigFile);
// Should this go here? I don't see why we would save if we didn't want to apply it immediately
UpdateGlobals();
}
public void Write_WithCustomObject_WritesCorrectFileContent()
{
// Arrange
using (var filename = TestFileName.Create("test", ".toml"))
{
// Act
var obj = new Configuration();
Toml.WriteFile(obj, filename);
// Assert
File.ReadAllText(filename).ShouldBeSemanticallyEquivalentTo(
@"
EnableDebug = false
[Server]
Timeout = 2m
[Client]
ServerAddress = ""http://localhost:8082""");
}
}
public static void SavePrivateData <T>(this Simulation simulation, T data, string group, string category, string instance)
{
var path = GetPrivatePath(
simulation,
new[] { group, category, instance },
PRIVATE_DATA_FILE_NAME
);
if (EqualityComparer <T> .Default.Equals(data, default))
{
if (File.Exists(path))
{
File.Delete(path);
}
return;
}
Toml.WriteFile(data, path);
}
private void SaveConfig()
{
TomlTable appSettings = Toml.Create();
appSettings.Add("ListenPort", ServerPort);
if (ConfigTable.ContainsKey("Application"))
{
ConfigTable.Remove("Application");
}
ConfigTable.Add("Application", appSettings);
foreach (var item in Items)
{
(item as IConfigViewModel).SaveConfig(ConfigTable);
}
Toml.WriteFile(ConfigTable, CONFIG_FILE);
}
public static bool LoadGUISettings()
{
bool fileExists = File.Exists(Path.Combine(GlobalVariables.DataDir, @"GUIsettings.toml"));
try //catches toml read errors
{
Params = Toml.ReadFile <GuiGlobalParams>(Path.Combine(GlobalVariables.DataDir, @"GUIsettings.toml"));
}
catch
{
Params = new GuiGlobalParams(); //create an instance
Toml.WriteFile(Params, Path.Combine(GlobalVariables.DataDir, @"GUIsettings.toml"), MetaMorpheusTask.tomlConfig);
}
if (GlobalVariables.MetaMorpheusVersion.Contains("Not a release version"))
{
Params.AskAboutUpdating = false;
}
return(fileExists);
}
private void PostModsLoaded()
{
try
{
// load configs
var path = Path.Combine(API.Helper.getModDirectory(this), "config.toml");
if (File.Exists(path))
{
config = Toml.ReadFile <Config>(path, tomlSettings);
}
else
{
config = new Config();
}
Toml.WriteFile(config, path, tomlSettings);
// initialize hat image
switch (config.HatMode)
{
case Config.HatType.None:
hat = new Hat(new Bitmap(1, 1), GetDefaultHatSettings(tomlSettings));
hat.Image.SetPixel(0, 0, Color.Transparent);
break;
case Config.HatType.Default:
hat = new Hat(Resources.DefaultImage, GetDefaultHatSettings(tomlSettings));
break;
case Config.HatType.Custom:
hat = ReadFromHatfile(config.CustomHatPath, config.Overrides, tomlSettings);
break;
}
}
catch (Exception e)
{
MessageBox.Show($"Error initializing {Name}: {e}",
Name, MessageBoxButtons.OK, MessageBoxIcon.Error);
hat = default;
}
}
public void UseTransaction_ExternalChangesAreLoaded()
{
using (var scenario = SingleConfigFileScenario.Setup(nameof(UseTransaction_ExternalChangesAreLoaded)))
{
// Arrange
var cfg = scenario.CreateConfig();
cfg.StartTransaction();
int originalValue = cfg.Get(c => c.X);
const int newValue = 123;
Toml.WriteFile(new SingleConfigFileScenario.ConfigContent()
{
X = newValue
}, scenario.File);
// Act
var v = cfg.Get(c => c.X);
// Assert
v.Should().Be(originalValue);
}
}
public static bool UseTopDownRecommendedSettings()
{
bool useRecommendedSettings = false;
//check with the user to update params
if (Params.AskAboutTopDownParams)
{
var results = ProteaseSpecificMsgBox.Show("Use Top-Down Recommendations?",
"We recommend using the following parameters for top-down searches:\n" +
"\t-Uncheck 'Use Provided Precursor'\n" +
"\t-Use '60' for 'Deconvolution Max Assumed Charge State'\n" +
"\t-Uncheck 'Trim MS2 Peaks'\n" +
"\t-Uncheck all variable mods (Please use a GPTMD database instead)\n" +
"\t-SEARCH TASK ONLY: Check 'No Quantification'\n" +
"\t-SEARCH TASK ONLY: Check '1, 2, or 3 Missed Monoisotopic Peaks'\n" +
"\t-GPTMD TASK ONLY: Search for only acetylation, phosphorylation, and oxidation of M\n\n" +
"Would you like to use these recommended settings?");
if (results.UseSettings)
{
useRecommendedSettings = true;
}
//else do nothing
//if they don't want to see this again, save the answer
if (!results.AskAgain)
{
Params.AskAboutTopDownParams = false;
Params.UseTopDownParams = results.UseSettings;
Toml.WriteFile(Params, Path.Combine(GlobalVariables.DataDir, @"GUIsettings.toml"), MetaMorpheusTask.tomlConfig);
}
}
else if (Params.UseTopDownParams) //user didn't want to check in, but wanted to update last time
{
useRecommendedSettings = true;
}
//else do nothing
return(useRecommendedSettings);
}
public void UseTransaction_ExternalChangesNotIncorporatedAndSavedBack()
{
using (var scenario = SingleConfigFileScenario.Setup(nameof(UseTransaction_ExternalChangesAreLoaded)))
{
// Arrange
var cfg = scenario.CreateConfig();
var trans = cfg.StartTransaction();
const int newXValue = 123;
const string newYValue = "New Y";
Toml.WriteFile(new SingleConfigFileScenario.ConfigContent()
{
X = newXValue
}, scenario.File);
// Act
cfg.Set(c => c.Y, newYValue);
Action a = () => trans.Dispose();
// Assert
a.ShouldThrow <InvalidOperationException>().WithMessage("*externally*");
}
}
private async Task LoadModulesAsync()
{
Dictionary <string, bool> enabledModules = new Dictionary <string, bool>();
if (File.Exists(Common.ModuleFile))
{
enabledModules = Toml.ReadFile <Dictionary <string, bool> >(Common.ModuleFile);
}
foreach (Type type in Assembly.GetEntryAssembly().GetExportedTypes()
.Where(x => typeof(ModuleBase).IsAssignableFrom(x) ||
x.IsSubclassOfRawGeneric(typeof(ModuleBase <>))))
{
if (enabledModules.TryAdd(type.Name, true) || enabledModules[type.Name])
{
await _commandService.AddModuleAsync(type, _serviceProvider).ConfigureAwait(false);
_logger.LogInformation("Loaded {Module}", type.Name);
}
}
Toml.WriteFile(enabledModules, Common.ModuleFile);
}
private static void LoadConfig()
{
string configPath = Path.Combine(Paths.ConfigPath, "Config.toml");
var tomlSettings = TomlSettings.Create(builder => builder
.ConfigureType <Version>(type => type
.WithConversionFor <TomlString>(convert => convert
.ToToml(tt => tt.ToString())
.FromToml(ft => Version.Parse(ft.Value)))));
var oldConfig = File.Exists(configPath) ? Toml.ReadFile <EnvironmentConfig>(configPath, tomlSettings) : null;
var version = oldConfig?.Version ?? AmoebaEnvironment.Version;
var cache = oldConfig?.Cache ?? CreateDefaultCacheConfig();
Toml.WriteFile(new EnvironmentConfig(AmoebaEnvironment.Version, cache), configPath, tomlSettings);
Config = new EnvironmentConfig(version, cache);
EnvironmentConfig.CacheConfig CreateDefaultCacheConfig()
{
return(new EnvironmentConfig.CacheConfig("../Config/Cache.blocks"));
}
}
private static void LoadConfig()
{
string configPath = Path.Combine(Paths.ConfigDirectoryPath, "Interface.toml");
var tomlSettings = TomlSettings.Create(builder => builder
.ConfigureType <Version>(type => type
.WithConversionFor <TomlString>(convert => convert
.ToToml(tt => tt.ToString())
.FromToml(ft => Version.Parse(ft.Value)))));
var oldConfig = File.Exists(configPath) ? Toml.ReadFile <InterfaceConfig>(configPath, tomlSettings) : null;
var version = oldConfig?.Version ?? AmoebaEnvironment.Version;
var communication = oldConfig?.Communication ?? CreateDefaultCommunicationConfig();
Toml.WriteFile(new InterfaceConfig(AmoebaEnvironment.Version, communication), configPath, tomlSettings);
Config = new InterfaceConfig(version, communication);
InterfaceConfig.CommunicationConfig CreateDefaultCommunicationConfig()
{
return(new InterfaceConfig.CommunicationConfig("tcp:127.0.0.1:4040"));
}
}
public static void Init()
{
if (_default == null)
{
if (File.Exists(CONFIG_FILENAME))
{
_default = Toml.ReadFile <Config>(CONFIG_FILENAME);
_default.ConfigPath = CONFIG_FILENAME;
}
else
{
var configPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), CONFIG_FILENAME);
if (File.Exists(configPath))
{
_default = Toml.ReadFile <Config>(configPath);
_default.ConfigPath = configPath;
}
else
{
_default = new Config();
Toml.WriteFile(_default, configPath);
_default.ConfigPath = configPath;
Console.WriteLine("A new config file has been created.");
Console.WriteLine("This program uses a TOML config file, any text editor should be able to edit it.");
Console.WriteLine("Open config file in default text editor? (y/n)");
if (Console.ReadLine() is "y" or "yes")
{
_default.ShellOpen();
}
Program.Exit();
}
}
}
}
/// <summary>
///
/// </summary>
/// <returns></returns>
public string Save()
{
try
{
Toml.WriteFile(this, this.GetPath());
return(string.Empty);
}
catch (FileNotFoundException fileNotFoundEx)
{
return(fileNotFoundEx.Message);
}
catch (UnauthorizedAccessException unauthAccessEx)
{
return(unauthAccessEx.Message);
}
catch (IOException ioEx)
{
return(ioEx.Message);
}
catch (Exception ex)
{
return(ex.Message);
}
}
public static bool UseElastaseRecommendedSettings()
{
bool useRecommendedSettings = false;
//check with the user to update params
if (Params.AskAboutElastaseParams)
{
var results = ProteaseSpecificMsgBox.Show("Use Elastase Recommendations?",
"We recommend using the following parameters for elastase searches:\n" +
"\t-Check 'Semi-Specific Search' (Search Task Only)\n" +
"\t-Use '50' for the 'Max Peptide Len' (Search Task Only)\n" +
"\t-Use '16' for 'Max Missed Cleavages'.\n\n" +
"Would you like to use these recommended settings?");
if (results.UseSettings)
{
useRecommendedSettings = true;
}
//else do nothing
//if they don't want to see this again, save the answer
if (!results.AskAgain)
{
Params.AskAboutElastaseParams = false;
Params.UseElastaseParams = results.UseSettings;
Toml.WriteFile(Params, Path.Combine(GlobalVariables.DataDir, @"GUIsettings.toml"), MetaMorpheusTask.tomlConfig);
}
}
else if (Params.UseElastaseParams) //user didn't want to check in, but wanted to update last time
{
useRecommendedSettings = true;
}
//else do nothing
return(useRecommendedSettings);
}
public static Configuration ReadConfig()
{
try
{
//If the file exists, just read it
if (File.Exists(FileName))
{
return(Toml.ReadFile <Configuration>(FileName));
}
//write the default config file
Logger.Log("No config file detected, making one with default settings");
Toml.WriteFile(new DefaultConfig(), FileName);
return(Toml.ReadFile <Configuration>(FileName));
}
catch (Exception e)
{
Logger.LogError(e.Message);
Logger.LogError("Error reading config file, maybe it's corrupted?");
}
return(new Configuration());
}
private void InitConfig()
{
if (_tomlSettings == null)
{
_tomlSettings = TomlSettings.Create(cfg => cfg
.ConfigureType <SKColor>(type => type
.WithConversionFor <TomlString>(conv => conv
.FromToml(s => SKColor.Parse(s.Value))
.ToToml(c => c.ToString()))));
}
try
{
_config = Toml.ReadFile <AppConfig>("config.toml", _tomlSettings);
Console.WriteLine("Configuration loaded.");
}
catch (FileNotFoundException)
{
Console.WriteLine("Configuration not found. Using default configuration.");
_config = new AppConfig();
Toml.WriteFile(_config, "config.toml", _tomlSettings);
}
}
internal void Save()
{
UpdateExecutionInterval();
_executionInterval.IfSome(ei =>
{
if (ei != default)
{
var(ms, n) = ei;
var tomlTable = Toml.Create();
tomlTable.Add(nameof(ms), ms);
tomlTable.Add(nameof(n), n);
var pathToExecutionInterval = Simulation.GetPrivatePath(new[] { nameof(SimData) }, EXECUTION_INTERVAL_FILE_NAME);
try
{
Toml.WriteFile(tomlTable, pathToExecutionInterval);
}
catch (Exception ex)
{
Log.Error(ex, $"{nameof(SimExecutionInterval)}.{nameof(Save)}");
}
}
});
}
public static void LoadMods()
{
TOML.ModList modList = new TOML.ModList();
modList.Mods.Add(new TOML.Mod("TestMod", new Version(0, 0, 0)));
Toml.WriteFile(modList, Application.persistentDataPath + "/ModList.tml");
modList = Toml.ReadFile <TOML.ModList>(Application.persistentDataPath + "/ModList.tml");
foreach (var mod in modList.Mods)
{
_modTOMLs.Add(mod);
_loadMod(mod);
}
foreach (var modInstance in _modInstances)
{
modInstance.Value.PreInit();
}
foreach (var modInstance in _modInstances)
{
modInstance.Value.Init();
}
foreach (var modInstance in _modInstances)
{
modInstance.Value.PostInit();
}
foreach (var modInstance in _modInstances)
{
modInstance.Value.LoadContent();
}
}
/// <inheritdoc />
public void SaveToFile()
{
if (_configFile == null)
{
Logger.Warning("[CFG] Cannot save the config file, because one was never loaded.");
return;
}
try
{
var tblRoot = Toml.Create();
foreach (var kvCVar in _configVars)
{
var cVar = kvCVar.Value;
var name = kvCVar.Key;
var value = cVar.Value;
if (value == null && cVar.Registered)
{
value = cVar.DefaultValue;
}
if (value == null)
{
Logger.Error($"[CFG] CVar {name} has no value or default value, was the default value registered as null?");
continue;
}
var keyIndex = name.LastIndexOf(TABLE_DELIMITER);
var tblPath = name.Substring(0, keyIndex).Split(TABLE_DELIMITER);
var keyName = name.Substring(keyIndex + 1);
// locate the Table in the config tree
var table = tblRoot;
foreach (var curTblName in tblPath)
{
if (!table.TryGetValue(curTblName, out TomlObject tblObject))
{
tblObject = table.AddTable(curTblName);
}
table = tblObject as TomlTable ?? throw new InvalidConfigurationException($"[CFG] Object {curTblName} is being used like a table, but it is a {tblObject}. Are your CVar names formed properly?");
}
//runtime unboxing, either this or generic hell... ¯\_(ツ)_/¯
switch (value)
{
case Enum val:
table.AddValue(keyName, (int)(object)val); // asserts Enum value != (ulong || long)
break;
case int val:
table.AddValue(keyName, val);
break;
case long val:
table.AddValue(keyName, val);
break;
case bool val:
table.AddValue(keyName, val);
break;
case string val:
table.AddValue(keyName, val);
break;
case float val:
table.AddValue(keyName, val);
break;
case double val:
table.AddValue(keyName, val);
break;
default:
Logger.Warning($"[CFG] Cannot serialize '{name}', unsupported type.");
break;
}
}
Toml.WriteFile(tblRoot, _configFile);
Logger.Info($"[CFG] Server config saved to '{_configFile}'.");
}
catch (Exception e)
{
Logger.Warning($"[CFG] Cannot save the config file '{_configFile}'.\n {e.Message}");
}
}
