private static string GetConnectionString(string DataBaseKeyID) { string cnnString = ""; DBManager _dbManager = DBManager.GetInstance(); //evaluates if the key id exisit already in the connections string list if (!_dbManager._connectionsStringList.ContainsKey(DataBaseKeyID)) { //get acces to configuration file handler ConfigurationFileHandler configFile = default(ConfigurationFileHandler); configFile = ConfigurationFileHandlerProxyServer.GetInstance().GetFileHandler(); KeyValue configurationKey = default(KeyValue); configurationKey = (KeyValue)(configFile.GetValue("DATABASE_FRAMEWORK/CONNECTION_STRINGS/" + DataBaseKeyID)); if (configurationKey == null) { string message = ""; message = "Not connection string defined for DataBaseID : " + DataBaseKeyID + Constants.vbNewLine + "Or not configuration Exists in Route : DATABASE_FRAMEWORK/CONNECTION_STRINGS/"; throw (new Exception(message)); } //adds the new connection string cnnString = configurationKey.Value; _dbManager._connectionsStringList.Add(DataBaseKeyID, configurationKey.Value); } else { cnnString = System.Convert.ToString(_dbManager._connectionsStringList[DataBaseKeyID]); } return(cnnString); }
public void ShouldThrowOnNonExistingFile(string path) { Assert.Throws <FileNotFoundException>(() => { _ = new ConfigurationFileHandler(path); }); }
private void SaveProject() { // Store current package if in design-mode var packageOverview = this.mainWindowContent.Content as Screens.PackageOverview; if (packageOverview != null) { packageOverview.SaveDiagram(); } Type[] extraTypes = applicationInitializer.ModuleLoader.GetModuleTypeList(); // Save the connections to disk ObservableCollection <ConnectionConfigurationBase> connections = this.CurrentProject.Connections; string serializedConnections = ConfigurationSerializer.SerializeObject(connections, extraTypes); ConfigurationFileHandler.SaveStringToFile(this.CurrentProject.ProjectName + "Connections.xml", this.CurrentProject.ProjectFolder, serializedConnections); // Save the project to disk this.CurrentProject.Connections = null; string serializedProject = ConfigurationSerializer.SerializeObject(this.CurrentProject, extraTypes); ConfigurationFileHandler.SaveStringToFile(this.CurrentProject.ProjectName + ".xml", this.CurrentProject.ProjectFolder, serializedProject); this.CurrentProject.Connections = connections; }
/// <summary> /// Load all runlogs /// </summary> public void LoadRunLogs() { var loadedLogs = new List <RunLog>(); string logBasePath = this.ProjectFolder.Trim(Path.DirectorySeparatorChar) + @"\logs\"; if (Directory.Exists(logBasePath)) { foreach (string runLogFileDirectory in Directory.GetDirectories(logBasePath)) { if (File.Exists(runLogFileDirectory + @"\runLog.xml") == false) { continue; } string serializedRunLog = ConfigurationFileHandler.ReadStringFromFile(runLogFileDirectory + @"\runLog.xml"); RunLog runLog = (RunLog)ConfigurationSerializer.DeserializeObject(serializedRunLog, typeof(RunLog), new Type[] { }); loadedLogs.Add(runLog); } } this.RunLogs.Clear(); foreach (var log in loadedLogs.OrderBy(t => t.StartTime)) { RunLogs.Add(log); } }
private static void GetUserNameAndPasswordFromConfigurationFile() { ConfigurationFileHandler configfileHndlr = default(ConfigurationFileHandler); configfileHndlr = ConfigurationFileHandlerProxyServer.GetInstance.GetFileHandler; KeyValue key = default(KeyValue); key = (KeyValue)(configfileHndlr.GetValue("UTILITIES_FRAMEWORK/SQLSERVER_SCRIPT_RUNNER/USER")); if (!(key == null)) { _userName = System.Convert.ToString(key.Value); } else { throw (new Exception("No configuration found on UTILITIES_FRAMEWORK/SQLSERVER_SCRIPT_RUNNER/USER")); } key = (KeyValue)(configfileHndlr.GetValue("UTILITIES_FRAMEWORK/SQLSERVER_SCRIPT_RUNNER/PASSWORD")); if (!(key == null)) { _password = System.Convert.ToString(key.Value); } else { throw (new Exception("No configuration found on UTILITIES_FRAMEWORK/SQLSERVER_SCRIPT_RUNNER/PASSWORD")); } }
public void ShouldThrowOnEmptyPath(string path) { Assert.Throws <ArgumentException>(() => { _ = new ConfigurationFileHandler(path); }); }
public void ShouldReadFromFile(List <string> fileLines, NodeState state) { string tmpFilePAth = Path.GetTempFileName(); File.WriteAllLines(tmpFilePAth, fileLines); ConfigurationFileHandler cfh = new ConfigurationFileHandler(tmpFilePAth); NodeState resultState = cfh.ReadCurrentState(); resultState.Should().BeEquivalentTo(state); }
public void ShouldWriteToFile(List <string> inputFile, NodeState newState, List <string> expectedLines) { string tmpFilePAth = Path.GetTempFileName(); File.WriteAllLines(tmpFilePAth, inputFile); ConfigurationFileHandler cfh = new ConfigurationFileHandler(tmpFilePAth); cfh.WriteNewState(newState); List <string> resultingLines = File.ReadAllLines(tmpFilePAth).ToList(); resultingLines.Should().ContainInOrder(expectedLines); }
public static Project LoadFromFile(string projectPath, Type[] extraTypes) { string serializedProject = ConfigurationFileHandler.ReadStringFromFile(projectPath); Project project = (Project)ConfigurationSerializer.DeserializeObject(serializedProject, typeof(Project), extraTypes); project.ProjectFolder = projectPath.Replace(Path.GetFileName(projectPath), ""); string connectionsPath = project.ProjectFolder + "\\" + project.ProjectName + "Connections.xml"; if (File.Exists(connectionsPath)) { string serializedConnections = ConfigurationFileHandler.ReadStringFromFile(connectionsPath); project.Connections = (ObservableCollection <ConnectionConfigurationBase>)ConfigurationSerializer.DeserializeObject(serializedConnections, typeof(ObservableCollection <ConnectionConfigurationBase>), extraTypes); } return(project); }
/// <summary> /// Enables the ability for that project to be able to use NHibernate Repo migrations, automatic or manual. /// </summary> public void EnableMigrations(EnableMigrationsCriteria criteria) { MessageFilter.Register(); var repoInfo = TypeHandler.FindSingleRepo(criteria.ProjectPath, criteria.RepoName); //if it is null something is wrong so drop out. if (repoInfo == null) { return; } AssertRepoHasEmptyConstructor(repoInfo.RepoType); EnsureDbAndMigrationTableExists(criteria.ProjectPath, repoInfo.RepoType, criteria.ConfigFilePath); var repoBase = TypeHandler.CreateRepoBase(repoInfo.Assembly.Location, repoInfo.RepoType); //create migration log table, if it doesn't exist. var updater = CreateSchemaUpdater(criteria.ProjectPath, typeof(MigrationRepo), criteria.ConfigFilePath, repoBase.ConnectionStringOrName); updater.Execute(true, true); bool multipleFound = false; var configType = TypeHandler.FindSingleConfiguration(criteria.ProjectPath, repoInfo.RepoType, out multipleFound); //this should not happen. should only ever have one config per repo type. if (multipleFound) { return; } if (configType == null) { LoggerBase.Log("Adding migration configuration"); var filePath = new ConfigurationFileHandler().CreateConfigurationFile(criteria.ProjectPath, repoInfo.RepoType.Name, "Migrations", MigrationToUse.Manual); new ProjectDteHelper().AddFile(criteria.ProjectPath, "Migrations", filePath, showFile: true); } else { LoggerBase.Log("System is already configured for migrations, see class: " + configType.Name); } //clean up ProjectEvalutionHelper.FinishedWithProject(criteria.ProjectPath); MessageFilter.Revoke(); }
/// <summary> /// Load all runlogs /// </summary> public void LoadRunLogs() { this.RunLogs.Clear(); string logBasePath = this.ProjectFolder.Trim('\\') + @"\logs\"; if (Directory.Exists(logBasePath)) { foreach (string runLogFileDirectory in Directory.GetDirectories(logBasePath)) { if (File.Exists(runLogFileDirectory + @"\runLog.xml") == false) { continue; } string serializedRunLog = ConfigurationFileHandler.ReadStringFromFile(runLogFileDirectory + @"\runLog.xml"); RunLog runLog = (RunLog)ConfigurationSerializer.DeserializeObject(serializedRunLog, typeof(RunLog), new Type[] { }); this.RunLogs.Add(runLog); } } }
public void ShouldThrowIfFileDissapears() { string tmpFilePAth = Path.GetTempFileName(); File.WriteAllLines(tmpFilePAth, new List <string> { "#This is a config file", "IS_SIGNING=non-signing", "PARITY_VERSION=parity/parity:v2.4.0", "PARITY_CHKSUM=30b9c9852b52546e7de32832ddfaa4aba33c0c436c985ad97d3fe9c4210043d8", "ANOTHER_KEY=foobar", "KEY_2=awesomesource", "SESSION_MANAGER=local/yoga-markus:@/tmp/.ICE-unix/2876,unix/yoga-markus:/tmp/.ICE-unix/2876", "SHELL=/usr/bin/zsh", "This is a comment right in the middle", "SHLVL=2", "SSH_AGENT_PID=2940", "SSH_AUTH_SOCK=/run/user/1000/keyring/ssh", "TERM=screen", "CHAINSPEC_URL=https://example.com/chainspec-20190303.json", "CHAINSPEC_CHKSUM=7e40a9d4a3066f839882e0fc26acd9e2f08bdbd314b7319db7cae54cd4450ee9" }); // instantiate with existing file to pass first file check ConfigurationFileHandler cfh = new ConfigurationFileHandler(tmpFilePAth); // remove file File.Delete(tmpFilePAth); // make sure it was removed if (File.Exists(tmpFilePAth)) { throw new TestFailureException("Test file didn't get removed. Results would be wrong."); } // Should fail on a file write attempt Assert.Throws <FileNotFoundException>(() => { cfh.WriteNewState(new NodeState()); }); // Should fail on a file read attempt Assert.Throws <FileNotFoundException>(() => { _ = cfh.ReadCurrentState(); }); }
private static void GetUserNameAndPasswordFromConfigurationFile() { try { ConfigurationFileHandler configfileHndlr = default(ConfigurationFileHandler); configfileHndlr = ConfigurationFileHandlerProxyServer.GetInstance().GetFileHandler(); KeyValue key = default(KeyValue); key = (KeyValue)(configfileHndlr.GetValue("UTILITIES_FRAMEWORK/SQLSERVER_DB_ATTACHER/USER")); if (!(key == null)) { UserId = key.Value; } else { Console.Write("User Name : "); UserId = Console.ReadLine(); } key = (KeyValue)(configfileHndlr.GetValue("UTILITIES_FRAMEWORK/SQLSERVER_DB_ATTACHER/PASSWORD")); if (!(key == null)) { password = key.Value; } else { Console.Write("Password : "******"User Name : "); UserId = Console.ReadLine(); Console.Write("Password : "); password = Console.ReadLine(); } }
private async Task RunInternal(IProgress <ProgressReport> progress) { this.progress = progress; await Task.Run(() => { ItemWorker[] startDesignerItems = GetStartDesignerItems(); ItemWorker[] endDesignerItems = GetEndDesignerItems(); // Start starteritems foreach (ItemWorker item in startDesignerItems) { ExecuteDesignerItem(item); } while (true) { // Continously check if all items finished already List <ItemWorker> unfinishedItemWorkers = itemWorkers.Where(t => t.DesignerItem.State != ItemState.Stopped && t.DesignerItem.State != ItemState.Error && t.DesignerItem.State != ItemState.NotExecuted).ToList(); if (unfinishedItemWorkers.Count == 0) { if (RunCompleted != null) { RunCompleted(this, new EventArgs()); } break; } // Check if a new item can be started List <ItemWorker> finishedItems = itemWorkers.Where(t => t.DesignerItem.State == ItemState.Stopped || t.DesignerItem.State == ItemState.Error || t.DesignerItem.State == ItemState.NotExecuted).ToList(); foreach (ItemWorker itemWorker in unfinishedItemWorkers.Where(t => t.DesignerItem.State == ItemState.Initialized)) { // Initialize bool newItemCanBeStarted = true; // If not all incoming connections to the item are from finished items, the item may not be started IEnumerable <ConnectionBase> incomingConnections = FlowHelper.GetIncomingConnections(itemWorker.DesignerItem.ID, connectionList); foreach (ConnectionBase connection in incomingConnections) { if (finishedItems.Where(t => t.DesignerItem.ID == connection.SourceID).Count() == 0) { newItemCanBeStarted = false; } } if (newItemCanBeStarted == true) { // Check if all incoming connection allow an execution bool allowExecution_PreviousErrorTest = FlowHelper.AllowExecution_OnPreviousErrorTest(itemWorker, this.itemWorkers, this.connectionList); bool allowExecution_PreviousItemNotSuccessfulOnErrorlineTest = FlowHelper.AllowExecution_PreviousStepNotSuccessfulOnErrorlineTest(itemWorker, this.itemWorkers, this.connectionList); bool allowExecution_activeItem = itemWorker.Configuration.Status == StepExecutionStatus.Active; if (allowExecution_PreviousErrorTest && allowExecution_PreviousItemNotSuccessfulOnErrorlineTest && allowExecution_activeItem) { ExecuteDesignerItem(itemWorker); } else { DoNotExecuteDesignerItem(itemWorker); } } } System.Threading.Thread.Sleep(200); } this.runLog.EndTime = DateTime.Now; string serializedRunLog = ConfigurationSerializer.SerializeObject(runLog, new Type [] {}); ConfigurationFileHandler.SaveStringToFile("runLog.xml", this.runLog.RunLogPath, serializedRunLog); }); }
public bool Call(List <string> parameters) { if (parameters == null) { Console.WriteLine("This command needs parameters"); return(false); } bool result = false; if (ConfigurationFileHandler.FileExists()) { ConfigurationFileHandler.LoadFile(); } else { if (!ConfigurationFileHandler.CreateConfigurationFile()) { return(false); } ConfigurationFileHandler.SaveFile(); } switch (parameters[0]) { case "default-customUI": switch (parameters.Count) { case 2: if (ConfigurationFileHandler.SetCustomUIDefaultName(parameters[1])) { ConfigurationFileHandler.SaveFile(); } else { return(false); } break; default: Console.WriteLine("Not correct number of parameters"); break; } break; // Versionage as 'a.b.c.d' case "specify-version": string versionage = null; string release = null; string feature = null; string bugfix = null; string optimization = null; switch (parameters.Count) { case 2: versionage = parameters[1]; // Specifying versionage 'd' optimization = parameters[1]; break; case 3: // Specifying versionage 'c.d' bugfix = parameters[2]; optimization = parameters[1]; break; case 4: // Specifying versionage 'b.c.d' feature = parameters[3]; bugfix = parameters[2]; optimization = parameters[1]; break; case 5: // Specifying versionage 'a.b.c.d' release = parameters[4]; feature = parameters[3]; bugfix = parameters[2]; optimization = parameters[1]; break; default: Console.WriteLine("Not valid number of parameters"); break; } if (ConfigurationFileHandler.SetVersion(versionage, true)) { ConfigurationFileHandler.SaveFile(); } else { if (ConfigurationFileHandler.SetVersion(release, feature, bugfix, optimization)) { ConfigurationFileHandler.SaveFile(); } else { return(false); } } break; case "update-version": // Updating versionage 'a.b.c.d' bool a = false; bool b = false; bool c = false; bool d = false; switch (parameters.Count) { // Defuault will only update versionage of 'd' case 1: d = true; result = true; break; case 2: switch (parameters[1]) { case "release": case "rls": a = true; break; case "feature": case "ftr": b = true; break; case "bugfix": case "bfx": c = true; break; case "optimization": case "opt": d = true; break; } result = true; break; default: Console.WriteLine("Not recognized parameters"); break; } ConfigurationFileHandler.UpdateVersion(a, b, c, d); ConfigurationFileHandler.SaveFile(); break; default: Console.WriteLine($"Option '{parameters[0]}' is not valid"); break; } return(result); }