From fc8a064bd0ba4c7cb27b77d712cc17e61dd82695 Mon Sep 17 00:00:00 2001 From: Schwirg László Date: Thu, 22 Aug 2024 18:41:44 +0200 Subject: [PATCH] v1.27.0 - MoveDbToRemoteServer megvalósítása --- Vrh.Log4Pro.MaintenanceConsole/ConsoleFunction - CommandLineParser.cs | 5 +++-- Vrh.Log4Pro.MaintenanceConsole/ConsoleFunction - Menu.cs | 4 ++-- Vrh.Log4Pro.MaintenanceConsole/Manager - FileCleanerManager.cs | 2 +- Vrh.Log4Pro.MaintenanceConsole/Manager - MSMQManager.cs | 32 +++++++++++++------------------- Vrh.Log4Pro.MaintenanceConsole/Manager - MaintenanceToolManager.cs | 2 +- Vrh.Log4Pro.MaintenanceConsole/Manager - SQLDataBaseManager.cs | 1368 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Vrh.Log4Pro.MaintenanceConsole/Manager - ScheduledTaskManager.cs | 14 +++++++------- Vrh.Log4Pro.MaintenanceConsole/Manager - UserManager.cs | 14 +++++++------- Vrh.Log4Pro.MaintenanceConsole/Manager - WindowsServiceManager.cs | 20 ++++++++------------ Vrh.Log4Pro.MaintenanceConsole/Program.cs | 1 + Vrh.Log4Pro.MaintenanceConsole/Properties/AssemblyInfo.cs | 4 ++-- Vrh.Log4Pro.MaintenanceConsole/Tools - Http.cs | 2 +- Vrh.Log4Pro.MaintenanceConsole/Tools - Membership.cs | 6 +++--- Vrh.Log4Pro.MaintenanceConsole/Tools.cs | 23 +++++++++++++++-------- 14 files changed, 954 insertions(+), 543 deletions(-) diff --git a/Vrh.Log4Pro.MaintenanceConsole/ConsoleFunction - CommandLineParser.cs b/Vrh.Log4Pro.MaintenanceConsole/ConsoleFunction - CommandLineParser.cs index d54479d..8ee2c7a 100644 --- a/Vrh.Log4Pro.MaintenanceConsole/ConsoleFunction - CommandLineParser.cs +++ b/Vrh.Log4Pro.MaintenanceConsole/ConsoleFunction - CommandLineParser.cs @@ -301,10 +301,11 @@ namespace Vrh.Log4Pro.MaintenanceConsole.CommandLineParserNS public static class BackupDataBase { public const string KEY = "BAK"; } public static class CreateCodeScripts { public const string KEY = "CCS"; } public static class CreateDataScripts { public const string KEY = "CDS"; } - public static class RestoreDataBase { public const string KEY = "RES"; public const string CMD_RESTOREFIRST = "-RESTOREFIRST"; - } + public static class RestoreDataBase { public const string KEY = "RES"; public const string KEY2 = "RE2"; public const string CMD_RESTOREFIRST = "-RESTOREFIRST";} + public static class MoveDbToRemoteServer { public const string KEY = "MOV"; } public static class RelocatePhysicalFiles { public const string KEY = "COP"; } public static class ShrinkDB { public const string KEY = "SHR"; } + public static class DropDB { public const string KEY = "DRP";} public static class ExecuteScript{ public const string KEY = "EXE"; } public static class CreateLoginAndUser{ public const string KEY = "CRU"; } public static class AddUserForLogin{ public const string KEY = "CRA"; } diff --git a/Vrh.Log4Pro.MaintenanceConsole/ConsoleFunction - Menu.cs b/Vrh.Log4Pro.MaintenanceConsole/ConsoleFunction - Menu.cs index 3917800..ef30d4f 100644 --- a/Vrh.Log4Pro.MaintenanceConsole/ConsoleFunction - Menu.cs +++ b/Vrh.Log4Pro.MaintenanceConsole/ConsoleFunction - Menu.cs @@ -16,6 +16,7 @@ using Vrh.XmlProcessing; using VRH.Common; using System.Xml.Linq; using System.Reflection; +using Vrh.Log4Pro.MaintenanceConsole.ToolsNS; namespace Vrh.Log4Pro.MaintenanceConsole.MenuNS { @@ -168,8 +169,7 @@ namespace Vrh.Log4Pro.MaintenanceConsole.MenuNS } catch (Exception ex) { - ColorConsole.WriteLine(ex.Message, ConsoleColor.Red); - if (ex.InnerException != null) { ColorConsole.WriteLine(ex.InnerException.Message, ConsoleColor.Red); } + ColorConsole.WriteLine(ex.MessageNested(), ConsoleColor.Red); Menu.PressAnykeyToContinue(); } } diff --git a/Vrh.Log4Pro.MaintenanceConsole/Manager - FileCleanerManager.cs b/Vrh.Log4Pro.MaintenanceConsole/Manager - FileCleanerManager.cs index 58aabe8..f0dcfb9 100644 --- a/Vrh.Log4Pro.MaintenanceConsole/Manager - FileCleanerManager.cs +++ b/Vrh.Log4Pro.MaintenanceConsole/Manager - FileCleanerManager.cs @@ -75,7 +75,7 @@ namespace Vrh.Log4Pro.MaintenanceConsole.FileCleanerManagerNS var success = FileCleanerManagerCore.CleanFolderFiles(di, ftc, delete: true); ColorConsole.WriteLine($"Folder cleaned. Name:{ftc.Xml_DirectoryPath}", ConsoleColor.Green); } - catch (Exception ex) { ColorConsole.WriteLine(ex.Message, ConsoleColor.Red); } + catch (Exception ex) { ColorConsole.WriteLine(ex.MessageNested(), ConsoleColor.Red); } } #endregion First level Executors with UI diff --git a/Vrh.Log4Pro.MaintenanceConsole/Manager - MSMQManager.cs b/Vrh.Log4Pro.MaintenanceConsole/Manager - MSMQManager.cs index c1829c4..75f5bcb 100644 --- a/Vrh.Log4Pro.MaintenanceConsole/Manager - MSMQManager.cs +++ b/Vrh.Log4Pro.MaintenanceConsole/Manager - MSMQManager.cs @@ -83,7 +83,7 @@ namespace Vrh.Log4Pro.MaintenanceConsole.MSMQManagerNS ColorConsole.WriteLine($"Access right {accessright.ar} {ctrlstring} for user:{accessright.un}.", ConsoleColor.Green); } } - catch (Exception ex) { ColorConsole.WriteLine(ex.Message, ConsoleColor.Red); } + catch (Exception ex) { ColorConsole.WriteLine(ex.MessageNested(), ConsoleColor.Red); } } return o; } @@ -111,7 +111,7 @@ namespace Vrh.Log4Pro.MaintenanceConsole.MSMQManagerNS MSMQManagerCore.DeleteQueue(fullpath); ColorConsole.WriteLine($"MSMQ:{st.Xml_Name} removed.", ConsoleColor.Green); } - catch (Exception ex) { ColorConsole.WriteLine(ex.Message, ConsoleColor.Red); } + catch (Exception ex) { ColorConsole.WriteLine(ex.MessageNested(), ConsoleColor.Red); } } return o; } @@ -145,7 +145,7 @@ namespace Vrh.Log4Pro.MaintenanceConsole.MSMQManagerNS ColorConsole.WriteLine($"Access right {accessright.ar} {ctrlstring} for user:{accessright.un}.", ConsoleColor.Green); } } - catch (Exception ex) { ColorConsole.WriteLine(ex.Message, ConsoleColor.Red); } + catch (Exception ex) { ColorConsole.WriteLine(ex.MessageNested(), ConsoleColor.Red); } } return o; } @@ -192,7 +192,7 @@ namespace Vrh.Log4Pro.MaintenanceConsole.MSMQManagerNS MSMQManagerCore.SetPermissions(fullpath, username, accessrights, controltype); ColorConsole.WriteLine($"Permissions set for MSMQ:{st.Xml_Name}. Username:{username}, access right: {accessrights}, control type: {controltype}", ConsoleColor.Green); } - catch (Exception ex) { ColorConsole.WriteLine(ex.Message, ConsoleColor.Red); } + catch (Exception ex) { ColorConsole.WriteLine(ex.MessageNested(), ConsoleColor.Red); } } defaultusername = username; @@ -320,10 +320,7 @@ namespace Vrh.Log4Pro.MaintenanceConsole.MSMQManagerNS ColorConsole.WriteLine($" Body: {msgbody}", ConsoleColor.Yellow); ColorConsole.WriteLine($" Label: {msglabel}", ConsoleColor.Yellow); } - catch (Exception ex) - { - ColorConsole.WriteLine(ex.Message, ConsoleColor.Red); - } + catch (Exception ex) { ColorConsole.WriteLine(ex.MessageNested(), ConsoleColor.Red); } } return o; } @@ -356,10 +353,7 @@ namespace Vrh.Log4Pro.MaintenanceConsole.MSMQManagerNS ColorConsole.WriteLine($" Body: {msgbody}", ConsoleColor.Yellow); ColorConsole.WriteLine($" Label: {msglabel}", ConsoleColor.Yellow); } - catch (Exception ex) - { - ColorConsole.WriteLine(ex.Message, ConsoleColor.Red); - } + catch (Exception ex) { ColorConsole.WriteLine(ex.MessageNested(), ConsoleColor.Red); } } return o; } @@ -395,8 +389,8 @@ namespace Vrh.Log4Pro.MaintenanceConsole.MSMQManagerNS ColorConsole.WriteLine($"Message sent to MSMQ:{st.Xml_Name}.", ConsoleColor.Green); } } - catch (ApplicationException ex) { ColorConsole.WriteLine(ex.Message, ConsoleColor.Red); } - catch (Exception ex) { ColorConsole.WriteLine(ex.Message, ConsoleColor.Red); } + catch (ApplicationException ex) { ColorConsole.WriteLine(ex.MessageNested(), ConsoleColor.Red); } + catch (Exception ex) { ColorConsole.WriteLine(ex.MessageNested(), ConsoleColor.Red); } } } return o; @@ -514,7 +508,7 @@ namespace Vrh.Log4Pro.MaintenanceConsole.MSMQManagerNS MSMQManagerCore.Purge(fullpath); ColorConsole.WriteLine($"MSMQ messages purged. Name:{st.Xml_Name}", ConsoleColor.Green); } - catch (Exception ex) { ColorConsole.WriteLine(ex.Message, ConsoleColor.Red); } + catch (Exception ex) { ColorConsole.WriteLine(ex.MessageNested(), ConsoleColor.Red); } } return o; } @@ -1118,7 +1112,7 @@ namespace Vrh.Log4Pro.MaintenanceConsole.MSMQManagerNS } catch (MessageQueueException ex) { - returnmessage= ex.ErrorCode + ":" + ex.Message + (ex.InnerException != null ? ("\n" + ex.InnerException.Message) : ""); + returnmessage= ex.ErrorCode + ":" + ex.MessageNested(); return ex.Message.StartsWith("Timeout"); } } @@ -1167,11 +1161,11 @@ namespace Vrh.Log4Pro.MaintenanceConsole.MSMQManagerNS } catch (MessageQueueException ex) { - msmqdef.Status = "Error"; msmqdef.StatusDescription = ex.ErrorCode +":"+ ex.Message + (ex.InnerException != null ? ("\n" + ex.InnerException.Message) : ""); + msmqdef.Status = "Error"; msmqdef.StatusDescription = ex.ErrorCode +":"+ ex.MessageNested(); } catch (Exception ex) { - msmqdef.Status = "Error"; msmqdef.StatusDescription = ex.Message + (ex.InnerException != null ? ("\n" + ex.InnerException.Message) : ""); + msmqdef.Status = "Error"; msmqdef.StatusDescription = ex.MessageNested(); } return msmqdef; } @@ -1350,7 +1344,7 @@ namespace Vrh.Log4Pro.MaintenanceConsole.MSMQManagerNS ColorConsole.WriteLine(); } } - catch (Exception ex) { ColorConsole.WriteLine(" " + ex.Message, ConsoleColor.Red); } + catch (Exception ex) { ColorConsole.WriteLine(" " + ex.MessageNested(), ConsoleColor.Red); } } } #endregion DisplayInfo diff --git a/Vrh.Log4Pro.MaintenanceConsole/Manager - MaintenanceToolManager.cs b/Vrh.Log4Pro.MaintenanceConsole/Manager - MaintenanceToolManager.cs index 68e1b7d..3889178 100644 --- a/Vrh.Log4Pro.MaintenanceConsole/Manager - MaintenanceToolManager.cs +++ b/Vrh.Log4Pro.MaintenanceConsole/Manager - MaintenanceToolManager.cs @@ -532,7 +532,7 @@ namespace Vrh.Log4Pro.MaintenanceConsole.MaintenanceToolManagerNS } catch (Exception ex) { - ColorConsole.WriteLine(ex.Message, f: ConsoleColor.Red); + ColorConsole.WriteLine(ex.MessageNested(), f: ConsoleColor.Red); return false; } } diff --git a/Vrh.Log4Pro.MaintenanceConsole/Manager - SQLDataBaseManager.cs b/Vrh.Log4Pro.MaintenanceConsole/Manager - SQLDataBaseManager.cs index ecac672..1565842 100644 --- a/Vrh.Log4Pro.MaintenanceConsole/Manager - SQLDataBaseManager.cs +++ b/Vrh.Log4Pro.MaintenanceConsole/Manager - SQLDataBaseManager.cs @@ -25,7 +25,7 @@ using System.Text.RegularExpressions; using Microsoft.SqlServer.Management.Common; using Microsoft.SqlServer.Management.Smo; -using System.Data.SqlClient; +using Microsoft.Data.SqlClient; namespace Vrh.Log4Pro.MaintenanceConsole.SQLDataBaseManagerNS { @@ -48,12 +48,15 @@ namespace Vrh.Log4Pro.MaintenanceConsole.SQLDataBaseManagerNS .AddMenuItem(new Menu.Item(CLP.Module.SQLDataBaseManager.Function.CreateCodeScripts.KEY, "Create code scripts", CreateCodeScripts, ep)) .AddMenuItem(new Menu.Item(CLP.Module.SQLDataBaseManager.Function.CreateDataScripts.KEY, "Create data scripts", CreateDataScripts, ep)) .AddMenuItem(new Menu.Item(CLP.Module.SQLDataBaseManager.Function.RestoreDataBase.KEY, "Restore database backup", RestoreDataBase, ep)) + .AddMenuItem(new Menu.Item(CLP.Module.SQLDataBaseManager.Function.RestoreDataBase.KEY2, "Restore database backup (any to anywhere)", RestoreDataBaseAnyToAnywhere, ep)) .AddMenuItem(new Menu.Item(CLP.Module.SQLDataBaseManager.Function.RelocatePhysicalFiles.KEY, "Copy database and or relocate its physical files", RelocatePhysicalFiles, ep)) .AddMenuItem(new Menu.Item(CLP.Module.SQLDataBaseManager.Function.ShrinkDB.KEY, "Shrink database", ShrinkDB, ep)) + .AddMenuItem(new Menu.Item(CLP.Module.SQLDataBaseManager.Function.DropDB.KEY, "Drop database", DropDB, ep)) .AddMenuItem(new Menu.Item(CLP.Module.SQLDataBaseManager.Function.ExecuteScript.KEY, "Execute script", ExecuteScript, ep)) - .AddMenuItem(new Menu.Item(CLP.Module.SQLDataBaseManager.Function.CreateLoginAndUser.KEY, "Create Server login and database user", CreteLoginAndAddToDB, ep)) - .AddMenuItem(new Menu.Item(CLP.Module.SQLDataBaseManager.Function.AddUserForLogin.KEY, "Add database user to an existing Login", AddExistingLoginToDB, ep)) + .AddMenuItem(new Menu.Item(CLP.Module.SQLDataBaseManager.Function.CreateLoginAndUser.KEY, "Create Server login", CreateServerLogin, ep)) + .AddMenuItem(new Menu.Item(CLP.Module.SQLDataBaseManager.Function.AddUserForLogin.KEY, "Create DB user", CreateDBUser, ep)) .AddMenuItem(new Menu.Item(CLP.Module.SQLDataBaseManager.Function.CreateLastUpdatedTrigger.KEY, "Add/remove LastUpdated trigger to a datatable column", ManageLastUpdatedTrigger, ep)) + .AddMenuItem(new Menu.Item(CLP.Module.SQLDataBaseManager.Function.MoveDbToRemoteServer.KEY, "Move DB from local to remote server", MoveDbToRemoteServer, ep)) .SetSelectionMode(Menu.SelectionMode.Single) .SetMenuHeaderDisplayer(DataBaseListDisplayer); menufunctions.ExecuteMenu(functionkey); @@ -105,10 +108,7 @@ namespace Vrh.Log4Pro.MaintenanceConsole.SQLDataBaseManagerNS SQLDataBaseManagerCore.BackupSqlData(sqld,TS); ColorConsole.WriteLine($"SQLDB data scripts created. Name:{sqld.Xml_Description}", ConsoleColor.Green); } - catch (Exception ex) - { - ColorConsole.WriteLine(ex.Message, ConsoleColor.Red); - } + catch (Exception ex){ColorConsole.WriteLine(ex.MessageNested(), ConsoleColor.Red);} } return o; } @@ -138,7 +138,7 @@ namespace Vrh.Log4Pro.MaintenanceConsole.SQLDataBaseManagerNS SQLDataBaseManagerCore.BackupSqlScripts(sqld,TS); ColorConsole.WriteLine($"SQLDB code scripts created. Name:{sqld.Xml_Description}", ConsoleColor.Green); } - catch (Exception ex) { ColorConsole.WriteLine(ex.Message, ConsoleColor.Red); } + catch (Exception ex) { ColorConsole.WriteLine(ex.MessageNested(), ConsoleColor.Red); } } return o; } @@ -167,7 +167,7 @@ namespace Vrh.Log4Pro.MaintenanceConsole.SQLDataBaseManagerNS SQLDataBaseManagerCore.CreateBackup(ssqldb,null,TS); ColorConsole.WriteLine($"Database backup created. Name:{ssqldb.DBName}", ConsoleColor.Green); } - catch (Exception ex) { ColorConsole.WriteLine(ex.Message, ConsoleColor.Red); } + catch (Exception ex) { ColorConsole.WriteLine(ex.MessageNested(), ConsoleColor.Red); } } return o; } @@ -179,53 +179,335 @@ namespace Vrh.Log4Pro.MaintenanceConsole.SQLDataBaseManagerNS var selectedsqldbindexes = CommandLine.GetCommandLineArgument(args, CLP.Module.SQLDataBaseManager.Function.CMD_DATABASES); bool restorefirst = CommandLine.GetCommandLineArgument(args, CLP.Module.SQLDataBaseManager.Function.RestoreDataBase.CMD_RESTOREFIRST,switchtype:true)!=null; - var menufolders = DisplaySQLDataBaseMenu(config, $"Select the SQL database(s) to manage with function '{nameof(RestoreDataBase)}'!", silent: true); + startselection: + var menufolders = DisplaySQLDataBaseMenu(config, $"Select the SQL database(s) to manage with function '{nameof(RestoreDataBase)}'!", silent: true,selectionmode:Menu.SelectionMode.Single); Menu.Selection sr = menufolders.Select(selectedsqldbindexes); if (sr.Result == Menu.SelectionResult.Exit) { return o; } else if (sr.Result == Menu.SelectionResult.None) { return o; } else if (sr.Result == Menu.SelectionResult.Error) { return o; } + else if (sr.Result == Menu.SelectionResult.Ok && sr.SelectedParameterList.FirstOrDefault() == null) { return o; } else if (sr.Result == Menu.SelectionResult.Ok) { } else { } - foreach (var p in sr.SelectedParameterList) + var p = sr.SelectedParameterList.First(); + SQLDataBase st = p.Parameters as SQLDataBase; + try { - SQLDataBase st = p.Parameters as SQLDataBase; - try + var targetdirectorypath = st.Xml_PhysicalFilesDirectoryPath; + var targetdbname = st.DBName; + bool restorefromzip = st.Xml_CreateZip; + var backupfilelist = SQLDataBaseManagerCore.GetBackupFilePathList(st); + Dictionary selectionlist = new Dictionary(); + + string selectedbackupfilepath=null; + if (backupfilelist == null || !backupfilelist.Any()) { } + else if (restorefirst) { selectedbackupfilepath = backupfilelist.First().FullName; } + else { - var targetdirectorypath = st.Xml_PhysicalFilesDirectoryPath; - var targetdbname= st.DBName; - bool restorefromzip = st.Xml_CreateZip; - var backupfilelist = SQLDataBaseManagerCore.GetBackupFilePathList(st); - if (backupfilelist != null && backupfilelist.Any()) - { - string selectedbackupfilepath; - if (restorefirst) - { - selectedbackupfilepath = backupfilelist.First().FullName; - } - else - { - var selectionlist = backupfilelist - .Select(x => new KeyValuePair($"{x.Name}({x.Length}bytes,created:{x.CreationTime})", x.FullName)) - .ToDictionary(x=>x.Key,x=>x.Value); - var ms = Menu.SelectFromItemList($"Backup files of {st.DBName}", "Select the backup file to restore! First is the newest!", selectionlist,Menu.SelectionMode.Single,getconfirmation:true); - if (ms == null) { continue; } - selectedbackupfilepath = ms.SelectedParameterList.First().Parameters.ToString(); - } - SQLDataBaseManagerCore.RestoreBackup(st, selectedbackupfilepath, targetdirectorypath, restorefromzip, targetdbname); - ColorConsole.WriteLine($"Database '{st.DBName}' restored to '{targetdbname}' into directory '{targetdirectorypath}'.", ConsoleColor.Green); - } - else - { - ColorConsole.WriteLine($"Database '{st.DBName}' restore FAILED, as no backup to restore!", ConsoleColor.Red); - } + selectionlist = (backupfilelist??new List()) + .Select(x => new KeyValuePair($"{x.Name}({x.Length}bytes,created:{x.CreationTime})", x.FullName)) + .ToDictionary(x => x.Key, x => x.Value); + selectionlist.Add("*", "other..."); + var ms = Menu.SelectFromItemList($"Backup files of {st.DBName}", "Select the backup file to restore! First is the newest!", selectionlist, Menu.SelectionMode.Single, getconfirmation: true); + if (ms == null) { goto startselection; } + else if (ms.SelectedKeyList.First() == "*") { } + else { selectedbackupfilepath = ms.SelectedParameterList.First().Parameters.ToString(); } + } + if (selectedbackupfilepath == null) + { + enterpathtobackupfileloop: + selectedbackupfilepath = ColorConsole.ReadLine("Enter the full path to the backup file, EX: to exit", ConsoleColor.Yellow); + if (selectedbackupfilepath.ToUpper() == "EX") return o; + else if (string.IsNullOrWhiteSpace(selectedbackupfilepath)) goto enterpathtobackupfileloop; } - catch (Exception ex) { ColorConsole.WriteLine(ex.Message, ConsoleColor.Red); } + + SQLDataBaseManagerCore.RestoreBackup(st, selectedbackupfilepath, targetdirectorypath, restorefromzip, targetdbname); + ColorConsole.WriteLine($"Database '{st.DBName}' restored to '{targetdbname}' into directory '{targetdirectorypath}'.", ConsoleColor.Green); + } + catch (Exception ex) { ColorConsole.WriteLine(ex.MessageNested(), ConsoleColor.Red); } + return o; + } + private static object RestoreDataBaseAnyToAnywhere(object parameter, object o) + { + var config = (parameter as Menu.ExecutorParameter).GetConfig(); + var args = (parameter as Menu.ExecutorParameter).Args; + + var selectedsqldbindexes = CommandLine.GetCommandLineArgument(args, CLP.Module.SQLDataBaseManager.Function.CMD_DATABASES); + bool restorefirst = CommandLine.GetCommandLineArgument(args, CLP.Module.SQLDataBaseManager.Function.RestoreDataBase.CMD_RESTOREFIRST, switchtype: true) != null; + + startselection: + var menufolders = DisplaySQLDataBaseMenu(config, $"Select the SQL database(s) to manage with function '{nameof(RestoreDataBaseAnyToAnywhere)}'!", silent: true, selectionmode: Menu.SelectionMode.Single); + + Menu.Selection sr = menufolders.Select(selectedsqldbindexes); + if (sr.Result == Menu.SelectionResult.Exit) { return o; } + else if (sr.Result == Menu.SelectionResult.None) { return o; } + else if (sr.Result == Menu.SelectionResult.Error) { return o; } + else if (sr.Result == Menu.SelectionResult.Ok && sr.SelectedParameterList.FirstOrDefault() == null) { return o; } + else if (sr.Result == Menu.SelectionResult.Ok) { } + else { } + var p = sr.SelectedParameterList.First(); + SQLDataBase st = p.Parameters as SQLDataBase; + try + { + var selectedbackupfilepath = ColorConsole.ReadLine("Enter the full path to the backup file (or its zip), EX: to exit", ConsoleColor.Yellow); + if (selectedbackupfilepath.ToUpper() == "EX") { return o; } + if (string.IsNullOrWhiteSpace(selectedbackupfilepath)) { goto startselection; } + var targetdirectorypath = ColorConsole.ReadLine("Enter the full path to the folder where the DB physical files will be located, EX: to exit", ConsoleColor.Yellow); + if (targetdirectorypath.ToUpper() == "EX") { return o; } + if (string.IsNullOrWhiteSpace(selectedbackupfilepath)) { goto startselection; } + var targetdbname = ColorConsole.ReadLine($"Enter the name of the target DB (empty={st.DBName}), EX: to exit", ConsoleColor.Yellow); + if (targetdirectorypath.ToUpper() == "EX") { return o; } + if (string.IsNullOrWhiteSpace(selectedbackupfilepath)) { targetdbname = st.DBName; } + bool restorefromzip =Path.GetExtension(selectedbackupfilepath).ToLower() == ".zip"; ; + SQLDataBaseManagerCore.RestoreBackup(st, selectedbackupfilepath, targetdirectorypath, restorefromzip, targetdbname); + ColorConsole.WriteLine($"Database '{targetdbname}' restored into directory '{targetdirectorypath}'.", ConsoleColor.Green); + goto startselection; } + catch (Exception ex) { ColorConsole.WriteLine(ex.MessageNested(), ConsoleColor.Red); } + return o; + } + private static object CreateServerLogin(object parameter, object o) + { + var config = (parameter as Menu.ExecutorParameter).GetConfig(); + var args = (parameter as Menu.ExecutorParameter).Args; + var selectedtaskindexes = CommandLine.GetCommandLineArgument(args, CLP.Module.ScheduledTaskManager.Function.CMD_TASKS); + var menuofdbs = DisplaySQLDataBaseMenu(config, $"Select the SQL database(s) to manage with function '{nameof(CreateServerLogin)}'!", silent: true, selectionmode: Menu.SelectionMode.Single); + Menu.Selection sr = menuofdbs.Select(selectedtaskindexes); + if (sr.Result == Menu.SelectionResult.Exit) { return o; } + else if (sr.Result == Menu.SelectionResult.None) { return o; } + else if (sr.Result == Menu.SelectionResult.Error) { return o; } + else if (sr.SelectedParameterList?.FirstOrDefault() == null) { return o; } + else if (sr.Result == Menu.SelectionResult.Ok) { } + else { } + string dbusername; + string password; + LoginType logintype; + + var p = sr.SelectedParameterList.FirstOrDefault(); + SQLDataBase sqld = p.Parameters as SQLDataBase; + + parameterinputloop: + try + { + ColorConsole.WriteLine(prefix: $"Enter the parameters for creating server login: {sqld.DBName}. Format:", bracket: "()", text: "LOGINNAME[,PASSWORD][GRANTORUSER[,GRANTORUSERPASSWORD]]", f: ConsoleColor.Yellow); + ColorConsole.WriteLine(prefix: " ", text: "LOGINNAME", bracket: "", suffix: $": server login name"); + ColorConsole.WriteLine(prefix: " ", text: "PASSWORD", bracket: "", suffix: $": password for login; empty=windows login is created, non empty=sql login is created"); + ColorConsole.WriteLine(prefix: " ", text: "GRANTORUSER", bracket: "", suffix: $": name of the user in behalf the login is created (that logs in the sql server); default:current user with windows authentication"); + ColorConsole.WriteLine(prefix: " ", text: "GRANTORUSERPASSWORD", bracket: "", suffix: $": password for GRANTORUSER;default:empy (windows authentication is used with GRANTORUSER)"); + + var createuseroptions = ColorConsole.ReadLine($"EX=exit.", ConsoleColor.Yellow, suffix: " --> "); + if (createuseroptions.ToUpper() == "EX") { return o; } + + dbusername = null; + password = null; + logintype = LoginType.WindowsUser; + + var optionList = createuseroptions.Split(new char[] { ',' }, StringSplitOptions.None); + if (optionList.Length < 1) { ColorConsole.WriteLine("ERROR! LOGINNAME is required, PASSWORD is optional", ConsoleColor.Red); goto parameterinputloop; } + + dbusername = optionList[0]; + if (optionList.Length == 2) + { + password = optionList[1]; + if (string.IsNullOrWhiteSpace(password)) { ColorConsole.WriteLine("ERROR! PASSWORD, if set, may not be empty!", ConsoleColor.Red); goto parameterinputloop; } + logintype = LoginType.SqlLogin; + } + string grantoruser = null; + string grantoruserpsw = null; + if (optionList.Length > 2) + { + grantoruser = optionList[2]; + if (string.IsNullOrWhiteSpace(grantoruser)) { ColorConsole.WriteLine("ERROR! GRANTORUSER, if set, may not be empty!", ConsoleColor.Red); goto parameterinputloop; } + } + if (optionList.Length > 3) + { + grantoruserpsw = optionList[3]; + if (string.IsNullOrWhiteSpace(grantoruser)) { ColorConsole.WriteLine("ERROR! GRANTORUSERPASSWORD, if set, may not be empty!", ConsoleColor.Red); goto parameterinputloop; } + } + + SQLDataBaseManagerCore.CreateLogin(sqld.SQLCS, dbusername, password, "master", logintype, null,grantoruser,grantoruserpsw); + string passwordtext = logintype == LoginType.WindowsUser ? "" : $", password:{password}"; + ColorConsole.WriteLine($"Server login created. Server login name:{dbusername}, login type: {logintype}{passwordtext}.", ConsoleColor.Green); + } + catch (Exception ex) + { + ColorConsole.WriteLine(ex.MessageNested(), ConsoleColor.Red); + goto parameterinputloop; + } + goto parameterinputloop; + + } + private static string[] selectablerolelist = new string[] { "FULLACCESS", "DATAREADER", "db_accessadmin", "db_backupoperator", "db_datareader", "db_datawriter", "db_ddladmin", "db_denydatareader", "db_denydatawriter", "db_owner", "db_securityadmin", }; + private static string[] fullaccessrolelist = new string[] { "db_accessadmin", "db_backupoperator", "db_datareader", "db_datawriter", "db_ddladmin", "db_owner", "db_securityadmin", }; + private static string[] datareaderrolelist = new string[] { "db_datareader", "db_denydatareader", }; + private static object CreateDBUser(object parameter, object o) + { + const string COMMA = ","; + var config = (parameter as Menu.ExecutorParameter).GetConfig(); + var args = (parameter as Menu.ExecutorParameter).Args; + var selectedtaskindexes = CommandLine.GetCommandLineArgument(args, CLP.Module.ScheduledTaskManager.Function.CMD_TASKS); + var menuofdbs = DisplaySQLDataBaseMenu(config, $"Select the SQL database(s) to manage with function '{nameof(CreateDBUser)}'!", silent: true, selectionmode: Menu.SelectionMode.Single); + Menu.Selection sr = menuofdbs.Select(selectedtaskindexes); + if (sr.Result == Menu.SelectionResult.Exit) { return o; } + else if (sr.Result == Menu.SelectionResult.None) { return o; } + else if (sr.Result == Menu.SelectionResult.Error) { return o; } + else if (sr.SelectedParameterList?.FirstOrDefault() == null) { return o; } + else if (sr.Result == Menu.SelectionResult.Ok) { } + else { } + string dbusername = null; + string loginname = null; + string rolenamecommalist = null; + + var p = sr.SelectedParameterList.FirstOrDefault(); + SQLDataBase sqld = p.Parameters as SQLDataBase; + + parameterinputloop: + try + { + ColorConsole.WriteLine(prefix: $"Enter the parameters for creating DB user for: {sqld.DBName}. Format:", bracket: "()", text: "DBUSERNAME,SERVERLOGINNAME,ROLENAME,ROLENAME,ROLENAME...", f: ConsoleColor.Yellow); + ColorConsole.WriteLine(prefix: " ", text: "DBUSERNAME", bracket: "", suffix: $": dbusername."); + ColorConsole.WriteLine(prefix: " ", text: "SERVERLOGINNAME", bracket: "", suffix: $": serverlogin name; empty=SQL user w/o login,w=WIndows user, other=SQL user for this server login name(* means server login name equals to dbusername)."); + ColorConsole.WriteLine(prefix: " ", text: "ROLENAME", bracket: "", suffix: $": One of these->" + string.Join(COMMA, selectablerolelist)); + + var createuseroptions = ColorConsole.ReadLine($"EX=exit.", ConsoleColor.Yellow, suffix: " --> "); + if (createuseroptions.ToUpper() == "EX") { return o; } + + dbusername = null; + loginname = null; + rolenamecommalist = null; + var optionList = createuseroptions.Split(new char[] { ',' }, StringSplitOptions.None); + if (optionList.Length < 3) { ColorConsole.WriteLine("ERROR! DBUSERNAME,SERVERLOGINNAME and at least one ROLENAME are required", ConsoleColor.Red); goto parameterinputloop; } + //012345678 + //uuu,ppp,r1,r2,r3 + dbusername = optionList[0]; + loginname = optionList[1]; + var selectedrolelist = optionList.Skip(2).ToArray(); + List badrolenames = new List(); + bool enablefullaccess = false; + bool enabledatareader = false; + int selectedrolelistnum = 0; + foreach (var rolename in selectedrolelist) + { + selectedrolelistnum++; + enablefullaccess = enablefullaccess || rolename.ToUpper() == "FULLACCESS"; + enabledatareader = enabledatareader || rolename.ToUpper() == "DATAREADER"; + if (!selectablerolelist.Contains(rolename)) { badrolenames.Add(rolename); } + } + bool specialselectionactive = enablefullaccess || enabledatareader; + if (selectedrolelistnum > 1 && specialselectionactive) { ColorConsole.WriteLine($"ERROR! FULLACCESS or DATAREADER has to be selected alone!", ConsoleColor.Red); goto parameterinputloop; } + if (badrolenames.Count > 0) { ColorConsole.WriteLine($"ERROR! {string.Join(COMMA, badrolenames)} are not available!", ConsoleColor.Red); goto parameterinputloop; } + + var effectiverolelist = + enablefullaccess ? fullaccessrolelist + : enabledatareader ? datareaderrolelist + : selectedrolelist; + rolenamecommalist = string.Join(",", effectiverolelist); + + SQLDataBaseManagerCore.CreateUser(sqld.SQLCS, dbusername, rolenamecommalist, loginname); + ColorConsole.WriteLine($"DB user created. DB name:{sqld.DBName}, DB username:{dbusername}, rolelist={rolenamecommalist}.", ConsoleColor.Green); + } + catch (Exception ex) + { + ColorConsole.WriteLine(ex.MessageNested(), ConsoleColor.Red); + goto parameterinputloop; + } + goto parameterinputloop; + } + private static object MoveDbToRemoteServer(object parameter, object o) + { + var config = (parameter as Menu.ExecutorParameter).GetConfig(); + var args = (parameter as Menu.ExecutorParameter).Args; + + var selectedsqldbindexes = CommandLine.GetCommandLineArgument(args, CLP.Module.SQLDataBaseManager.Function.CMD_DATABASES); + + selectionloop: + var menufolders = DisplaySQLDataBaseMenu(config, $"Select the SQL database(s) to manage with function. '{nameof(MoveDbToRemoteServer)}'! Format:FROMLOCALDB,TOREMOTEDB", silent: true, selectionmode: Menu.SelectionMode.Multi); + + Menu.Selection sr = menufolders.Select(selectedsqldbindexes); + if (sr.Result == Menu.SelectionResult.Exit) { return o; } + else if (sr.Result == Menu.SelectionResult.None) { goto selectionloop; } + else if (sr.Result == Menu.SelectionResult.Error) { goto selectionloop; } + else if (sr.Result == Menu.SelectionResult.Ok && sr.SelectedParameterList.FirstOrDefault() == null) { goto selectionloop; } + else if (sr.Result == Menu.SelectionResult.Ok && sr.SelectedParameterList.Count() != 2) + { + ColorConsole.WriteLine($"Select exactly 2 DB. Format:FROMLOCALDB,TOREMOTEDB", ConsoleColor.Red); + goto selectionloop; + } + else if (sr.Result == Menu.SelectionResult.Ok) { } + else { } + var spfrom = sr.SelectedParameterList.First(); + var spto = sr.SelectedParameterList.ElementAt(1); + SQLDataBase dbfrom = spfrom.Parameters as SQLDataBase; + SQLDataBase dbto = spto.Parameters as SQLDataBase; + if (!dbto.Xml_IsRemoteDB) + { + ColorConsole.WriteLine($"TOREMOTEDB '{dbto.SQLCS}' has to be remote!", ConsoleColor.Red); + goto selectionloop; + } + if (dbfrom.Xml_IsRemoteDB) + { + ColorConsole.WriteLine($"FROMLOCALDB '{dbfrom.SQLCS}' has to be local!", ConsoleColor.Red); + goto selectionloop; + } + bool emulation = false; + + var selecteddbname = ColorConsole.ReadLine($"Enter the name of the restored DB. EMPTY={dbto.DBName}, EX=exit."); + if (selecteddbname.ToUpper() == "EX") return o; + else if (string.IsNullOrWhiteSpace(selecteddbname)) selecteddbname=dbto.DBName; + + confirmloop:; + var selection = ColorConsole.ReadLine("Enter CONFIRM to start, EMU to emulate, EX to exit."); + if (selection.ToUpper() == "EX") return o; + else if (selection.ToUpper() == "EMU") emulation = true; + else if (selection.ToUpper() == "CONFIRM") { } + else goto confirmloop; + + var DateTimeNow = DateTime.Now; + var usernameList = new string[] { "corplear\\lschwirg", "corplear\\gen_vrhalmadmin", $"corplear\\{Program.ThisComputer.ComputerName}$" }; + foreach (var username in usernameList) + { + ColorConsole.WriteLine(username, ConsoleColor.Yellow, prefix: nameof(SQLDataBaseManagerCore.CreateUser) + ":"); + try { if (!emulation) SQLDataBaseManagerCore.CreateLogin(dbfrom.SQLCS, username, null, "master", LoginType.WindowsUser, null); } + catch (Exception ex) { ColorConsole.WriteLine(nameof(SQLDataBaseManagerCore.CreateLogin)+">>>: "+ex.MessageNested(), ConsoleColor.Red); } + try { if (!emulation) SQLDataBaseManagerCore.CreateUser(dbfrom.SQLCS, username, string.Join(",", fullaccessrolelist), "w"); } + catch (Exception ex) { ColorConsole.WriteLine(nameof(SQLDataBaseManagerCore.CreateUser) + "\n" + ex.MessageNested(), ConsoleColor.Red); } + } + + //backup dbfrom + var backupfileFullname = SQLDataBaseManagerCore.CreateBackup(dbfrom, false, DateTimeNow,emulation); + //move dbfrom to tranit area + + if (!emulation && !File.Exists(backupfileFullname)) { goto selectionloop; } + + string backupfileFilename = null; + string tranzitfileFullname = null; + try + { + backupfileFilename = Path.GetFileName(backupfileFullname); + tranzitfileFullname = Path.Combine(dbto.Xml_TranzitDirectoryPath, backupfileFilename); + ColorConsole.WriteLine($"Moving backup file {backupfileFullname} to tranzit location: {dbto.Xml_TranzitDirectoryPath}", ConsoleColor.Yellow); + if (!emulation) + { + if (File.Exists(tranzitfileFullname)) { File.Delete(tranzitfileFullname); } + File.Move(backupfileFullname, tranzitfileFullname); + ColorConsole.WriteLine($"...completed...", ConsoleColor.Yellow); + } + } + catch (Exception ex) + { + ColorConsole.WriteLine($"Moving file FAILED!", ConsoleColor.Red); + ColorConsole.WriteLine(ex.MessageNested(), ConsoleColor.Red); + goto selectionloop; + } + if (!emulation && !File.Exists(tranzitfileFullname)) { goto selectionloop; } + + //restore backup to dbto + tranzitfileFullname = Path.Combine(dbto.Xml_TranzitDirectoryPath, backupfileFilename); + SQLDataBaseManagerCore.RestoreBackup(dbto, tranzitfileFullname, dbto.Xml_PhysicalFilesDirectoryPath, false, selecteddbname, emulation); + + ColorConsole.WriteLine($"Moving DB to remote server completed. Required time: {(int)(DateTime.Now.Subtract(DateTimeNow).TotalSeconds)} seconds.",ConsoleColor.Green); return o; } - private static object CreteLoginAndAddToDB(object parameter, object o) { return _CreteLoginAndUser(parameter, o, true); } - private static object AddExistingLoginToDB(object parameter, object o) { return _CreteLoginAndUser(parameter, o, false); } private static object ManageLastUpdatedTrigger(object parameter, object o) { return _ManageLastUpdatedTrigger(parameter, o, null); } #region script texts for _RemoveAndCreateLastUpdatedTrigger @@ -351,10 +633,10 @@ GO if (!Tools.ResolveArguments(parameters, RemoveLastUpdatedTrigger_Script, out ssScriptText)) { throw new ApplicationException(); } try {SQLDataBaseManagerCore.ExecuteSQLScript(sqld.SQLCS, ssScriptText, 5000, null); } - catch (Exception e) {ColorConsole.WriteLine(e.Message, ConsoleColor.Yellow);} + catch (Exception e) {ColorConsole.WriteLine(e.MessageNested(), ConsoleColor.Yellow);} if (!Tools.ResolveArguments(parameters, RemoveLastUpdatedColumn_Script, out ssScriptText)) { throw new ApplicationException(); } try {SQLDataBaseManagerCore.ExecuteSQLScript(sqld.SQLCS, ssScriptText, 5000, null);} - catch (Exception e) { ColorConsole.WriteLine(e.Message, ConsoleColor.Yellow); } + catch (Exception e) { ColorConsole.WriteLine(e.MessageNested(), ConsoleColor.Yellow); } if (!effectiveremoveaction) { @@ -377,102 +659,10 @@ GO } catch (Exception e) { - ColorConsole.WriteLine("FATAL ERROR! "+e.Message, ConsoleColor.Red); + ColorConsole.WriteLine("FATAL ERROR! "+e.MessageNested(), ConsoleColor.Red); goto getparameters; } } - private static object _CreteLoginAndUser(object parameter, object o,bool createlogin) - { - const string COMMA = ","; - var config = (parameter as Menu.ExecutorParameter).GetConfig(); - var args = (parameter as Menu.ExecutorParameter).Args; - var selectedtaskindexes = CommandLine.GetCommandLineArgument(args, CLP.Module.ScheduledTaskManager.Function.CMD_TASKS); - var functionname = createlogin ? nameof(CreteLoginAndAddToDB) : nameof(AddExistingLoginToDB); - var menufolders = DisplaySQLDataBaseMenu(config, $"Select the SQL database(s) to manage with function '{functionname}'!", silent: true); - Menu.Selection sr = menufolders.Select(selectedtaskindexes); - if (sr.Result == Menu.SelectionResult.Exit) { return o; } - else if (sr.Result == Menu.SelectionResult.None) { return o; } - else if (sr.Result == Menu.SelectionResult.Error) { return o; } - else if (sr.Result == Menu.SelectionResult.Ok) { } - else { } - string dbusername = null; - string password = null; - string rolenamecommalist = null; - int loopindex = 0; - bool effectivecreatelogin = createlogin; - foreach (var p in sr.SelectedParameterList) - { - effectivecreatelogin = createlogin && loopindex == 0; - SQLDataBase sqld = p.Parameters as SQLDataBase; - try - { - var enabledrolelist = new string[] { "db_datareader", "db_datawriter", "db_accessadmin", "db_securityadmin", "db_backupoperator" }; - if (effectivecreatelogin) - { - ColorConsole.WriteLine(prefix: $"Enter the parameters for creating user for database: {sqld.DBName}. Format:", bracket: "()", text: "DBUSERNAME,PASSWORD,ROLENAME,ROLENAME,ROLENAME...", f: ConsoleColor.Yellow); - } - else - { - ColorConsole.WriteLine(prefix: $"Enter the parameters for creating user for database: {sqld.DBName}. Format:", bracket: "()", text: "DBUSERNAME,ROLENAME,ROLENAME,ROLENAME...", f: ConsoleColor.Yellow); - if (createlogin) - { - ColorConsole.WriteLine(prefix: $"Press [Enter] to use parameters set in the previous loop.", bracket: "()", text: $"{dbusername},{rolenamecommalist}", f: ConsoleColor.Yellow); - } - } - ColorConsole.WriteLine(prefix: " ", text: "DBUSERNAME", bracket: "", suffix: $": dbusername (server login name; must exist when adding login to DB)"); - if (effectivecreatelogin) - { - ColorConsole.WriteLine(prefix: " ", text: "PASSWORD", bracket: "", suffix: $": password for login"); - } - ColorConsole.WriteLine(prefix: " ", text: "ROLENAME", bracket: "", suffix: $": One of these->" + string.Join(COMMA, enabledrolelist)); - - var createuseroptions = ColorConsole.ReadLine($"EX=exit.", ConsoleColor.Yellow, suffix: " --> "); - if (createuseroptions.ToUpper() == "EX") { continue; } - if (loopindex>0 && string.IsNullOrWhiteSpace(createuseroptions)) { createuseroptions = $"{dbusername},{rolenamecommalist}"; } - - dbusername = null; - password = null; - rolenamecommalist = null; - var optionList = createuseroptions.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries); - if (effectivecreatelogin) - { - if (optionList.Length < 3) { ColorConsole.WriteLine("ERROR! USERNAME,PASSWORD and at least one ROLENAME are required", ConsoleColor.Red); continue; } - } - else - { - if (optionList.Length < 2) { ColorConsole.WriteLine("ERROR! USERNAME and at least one ROLENAME are required", ConsoleColor.Red); continue; } - } - //012345678 - //uuu,ppp,r1,r2,r3 - dbusername = optionList[0]; - password = effectivecreatelogin ? optionList[1]:null; - //rolenamecommalist = cretauseroptions.Substring(username.Length + password.Length + 2); - var rolenameList = optionList.Skip(effectivecreatelogin ? 2:1).ToArray(); - List badrolenames = new List(); - foreach (var rolename in rolenameList) - { - if (!enabledrolelist.Contains(rolename)) { badrolenames.Add(rolename); } - } - if (badrolenames.Count > 0) { ColorConsole.WriteLine($"ERROR! {string.Join(COMMA, badrolenames)} are not available!", ConsoleColor.Red); continue; } - rolenamecommalist = string.Join(",", rolenameList); - - if (effectivecreatelogin) - { - SQLDataBaseManagerCore.CreateLogin(sqld.SQLCS, dbusername, password, "master", null); - SQLDataBaseManagerCore.CreateUser(sqld.SQLCS, dbusername, rolenamecommalist); - ColorConsole.WriteLine($"Login and DB users created. DB name:{sqld.DBName}, login and DB username:{dbusername}, password:{password},rolelist={rolenamecommalist}.", ConsoleColor.Green); - } - else - { - SQLDataBaseManagerCore.CreateUser(sqld.SQLCS, dbusername, rolenamecommalist); - ColorConsole.WriteLine($"DB user created. DB name:{sqld.DBName}, DB username:{dbusername}, rolelist={rolenamecommalist}.", ConsoleColor.Green); - } - } - catch (Exception ex) { ColorConsole.WriteLine(ex.Message, ConsoleColor.Red);continue; } - loopindex++; - } - return o; - } private static object ExecuteScript(object parameter, object o) { @@ -532,11 +722,66 @@ GO } } } - catch (Exception ex) { ColorConsole.WriteLine(ex.Message, ConsoleColor.Red); } + catch (Exception ex) { ColorConsole.WriteLine(ex.MessageNested(), ConsoleColor.Red); } } return o; } + private static object DropDB(object parameter, object o) + { + var config = (parameter as Menu.ExecutorParameter).GetConfig(); + var args = (parameter as Menu.ExecutorParameter).Args; + + var selectedtaskindexes = CommandLine.GetCommandLineArgument(args, CLP.Module.ScheduledTaskManager.Function.CMD_TASKS); + + var menufolders = DisplaySQLDataBaseMenu(config, $"Select the SQL database(s) that is located on the server, where the DB to manage with function '{nameof(DropDB)}'!", silent: true); + + Menu.Selection sr = menufolders.Select(selectedtaskindexes); + if (sr.Result == Menu.SelectionResult.Exit) { return o; } + else if (sr.Result == Menu.SelectionResult.None) { return o; } + else if (sr.Result == Menu.SelectionResult.Error) { return o; } + else if (sr.Result == Menu.SelectionResult.Ok) { } + else { } + foreach (var p in sr.SelectedParameterList) + { + SQLDataBase sqld = p.Parameters as SQLDataBase; + try + { + ColorConsole.WriteLine(prefix: $"Enter the dbname, the userid/password (for the user in favour you want to drop the DB). Format:", bracket: "()", text: "[DBNAME][,USERNAME[,PASSWORD]]:", f: ConsoleColor.Yellow); + ColorConsole.WriteLine(prefix: " ", text: "[DBNAME]", bracket: "[]", suffix: $":name of the DB to delete, default:{sqld.DBName}", f: ConsoleColor.Yellow); + ColorConsole.WriteLine(prefix: " ", text: "[USERNAME,PASSWORD empty]", bracket: "[]", suffix: $":use windows authentication with current user", f: ConsoleColor.Yellow); + ColorConsole.WriteLine(prefix: " ", text: "USERNAME", bracket: "[]", suffix: $":use windows authentication with this user", f: ConsoleColor.Yellow); + ColorConsole.WriteLine(prefix: " ", text: "USERNAME,PASSWORD", bracket: "[]", suffix: $":use sql server authentication with this user and password.", f: ConsoleColor.Yellow); + var parameters = ColorConsole.ReadLine($"EX=exit.", ConsoleColor.Yellow, suffix: " --> "); + if (parameters.ToUpper() == "EX") { continue; } + + string userid = null; + string password = null; + string dbname = null; + if (!string.IsNullOrWhiteSpace(parameters)) + { + dbname = parameters.Split(new char[] { ',' })[0]; + if (parameters.IndexOf(',') >= 1) { userid = parameters.Split(new char[] { ',' })[1]; } + if (parameters.IndexOf(',') >= 0) { password = parameters.Split(new char[] { ',' })[2]; } + } + if (string.IsNullOrWhiteSpace(dbname)) { dbname = sqld.DBName; } + ColorConsole.WriteLine($"Dropping DB..."); + ColorConsole.WriteLine(prefix: " connection string to server:", text: sqld.SQLCS, bracket: "[]", f: ConsoleColor.Yellow); + ColorConsole.WriteLine(prefix: " DB name to drop:", text: dbname, bracket: "[]", f: ConsoleColor.Yellow); + ColorConsole.WriteLine(prefix: " userid:", text: userid ?? "-", bracket: "[]", f: ConsoleColor.Yellow); + ColorConsole.WriteLine(prefix: " user psw:", text: password ?? "-", bracket: "[]", f: ConsoleColor.Yellow); + var confirmation = ColorConsole.ReadLine($"Enter CONFIRM to execute. EX=exit.", ConsoleColor.Yellow, suffix: " --> "); + if (confirmation.ToUpper() == "EX") { continue; } + else if (confirmation.ToUpper() != "CONFIRM") { continue; } + + var success = SQLDataBaseManagerCore.DropDatabase(sqld.SQLCS, dbname, userid, password); + if (success) { ColorConsole.WriteLine($"SUCCESS! Database dropped. Name:{dbname}", ConsoleColor.Green); } + else { ColorConsole.WriteLine($"FAILURE! Database is NOT dropped. Name:{dbname}", ConsoleColor.Red); } + } + catch (Exception ex) { ColorConsole.WriteLine(ex.MessageNested(), ConsoleColor.Red); } + } + return o; + } private static object ShrinkDB(object parameter, object o) { var config = (parameter as Menu.ExecutorParameter).GetConfig(); @@ -576,7 +821,7 @@ GO SQLDataBaseManagerCore.ShrinkDB(sqld.SQLCS, shrinkmethod, fspint); ColorConsole.WriteLine($"Database shrinked. Name:{sqld.DBName}", ConsoleColor.Green); } - catch (Exception ex) { ColorConsole.WriteLine(ex.Message, ConsoleColor.Red); } + catch (Exception ex) { ColorConsole.WriteLine(ex.MessageNested(), ConsoleColor.Red); } } return o; } @@ -605,7 +850,7 @@ GO else if (string.IsNullOrWhiteSpace(restoredbname)) { restoredbname = sqld.DBName; } ColorConsole.WriteLine("Enter the path for the DB physical files.", ConsoleColor.Yellow); ColorConsole.WriteLine(sqld.PhysicalFilesDirectoryPath, ConsoleColor.Yellow, prefix: $" Empty=current location of source DB: ", bracket: "[]"); - ColorConsole.WriteLine(SQLDataBaseManagerCore.GetServerDefaultPhysicalDATFileLocation(sqld.SQLCS), ConsoleColor.Yellow,prefix: $" DEFAULT= sql server default location.",bracket:"[]"); + ColorConsole.WriteLine(SQLDataBaseManagerCore.GetServerDefaultPhysicalDATFileLocation(sqld.SQLCS)??"???", ConsoleColor.Yellow,prefix: $" DEFAULT= sql server default location.",bracket:"[]"); var targetdirectory = ColorConsole.ReadLine($"Enter the target path.EX=exit.", ConsoleColor.Yellow, suffix: " --> "); if (targetdirectory.ToUpper() == "EX") { continue; } else if (targetdirectory == "DEFAULT") { targetdirectory = null; ; } @@ -616,7 +861,7 @@ GO SQLDataBaseManagerCore.RelocatePhysicalFiles(sqld, targetdirectory, restoredbname); ColorConsole.WriteLine($"Database physical files relocated. Name:{sqld.DBName}", ConsoleColor.Green); } - catch (Exception ex) { ColorConsole.WriteLine(ex.Message, ConsoleColor.Red); } + catch (Exception ex) { ColorConsole.WriteLine(ex.MessageNested(), ConsoleColor.Red); } } return o; } @@ -655,6 +900,7 @@ GO { ColorConsole.Write(st.DBName, statuscolor, bracket: "[]", prefix: "Database ", suffix: ". "); ColorConsole.Write(st.DataSource, statuscolor, bracket: "[]", prefix: "from server ", suffix: ". "); + if (st.Xml_IsRemoteDB) { ColorConsole.Write("REMOTE", ConsoleColor.Cyan, bracket: "[]", prefix: "", suffix: ""); } } ColorConsole.WriteLine(); return " "; @@ -709,8 +955,8 @@ GO { try { - sqld.Status = GetStatus(sqld.SQLCS); - sqld.PhysicalFilesDirectoryPath = (GetPhysicalFilesLocation(sqld.SQLCS))??""; + sqld.PhysicalFilesDirectoryPath = (GetPhysicalFilesLocation(sqld.SQLCS)) ?? ""; + sqld.Status = string.IsNullOrWhiteSpace(sqld.PhysicalFilesDirectoryPath)? SQLDBStatus.NoAccess: SQLDBStatus.OK; sqld.DBName = GetDBName(sqld.SQLCS); sqld.DataSource = GetDataSource(sqld.SQLCS); sqld.SizeString = GetSize(sqld.SQLCS); @@ -734,61 +980,91 @@ GO RestoreBackup(sqld, dbbackupfilepath, targetdirectory, false, restoredbname); if (File.Exists(dbbackupfilepath)) { File.Delete(dbbackupfilepath); } } - public static void RestoreBackup(SQLDataBase sqldb, string sourcesqlbackupfilepath, string targetdbphysicalfilesdirectorypath, bool restorefromZIP = false, string restoretodbname = null) + /// + /// Restores database backup (zipped or normal) + /// + /// + /// source backup file + /// + /// true=sourcesqlbackupfilepath is a zip file + /// + /// + public static void RestoreBackup(SQLDataBase sqldb, string sourcesqlbackupfilepath, string targetdbphysicalfilesdirectorypath, bool restorefromZIP = false, string restoretodbname = null,bool emulate=false) { - if (sqldb.Xml_IsRemoteDB) - { - ColorConsole.WriteLine(text: $" {nameof(RestoreBackup)}: data restore is not available for remote SQL Servers! DBname:'{sqldb.DBName}'.", prefix: $"WARNING!", f: ConsoleColor.Yellow); - return; - } + string sqlcs = sqldb.SQLCS; //sqlcs = sqlcs.Replace("LearALM2", "master"); + string zippedbackupfilepath = restorefromZIP? sourcesqlbackupfilepath:Path.Combine(Path.GetDirectoryName(sourcesqlbackupfilepath), Path.GetFileNameWithoutExtension(sourcesqlbackupfilepath) + ".zip"); + string normalbackupfilepath = !restorefromZIP? sourcesqlbackupfilepath : Path.Combine(Path.GetDirectoryName(sourcesqlbackupfilepath), Path.GetFileNameWithoutExtension(sourcesqlbackupfilepath) + ".bak"); + + ColorConsole.WriteLine(nameof(RestoreBackup), ConsoleColor.Yellow, prefix: "running...."); + ColorConsole.WriteLine(restoretodbname, ConsoleColor.Yellow, prefix: " restoretodbname:"); + ColorConsole.WriteLine(sqldb.SQLCS, ConsoleColor.Yellow, prefix: " sqldb.SQLCS:"); + ColorConsole.WriteLine(sourcesqlbackupfilepath, ConsoleColor.Yellow, prefix: " sourcesqlbackupfilepath:"); + ColorConsole.WriteLine(normalbackupfilepath, ConsoleColor.Yellow, prefix: " backupfilepath:"); + ColorConsole.WriteLine(restorefromZIP.ToString(), ConsoleColor.Yellow, prefix: " restorefromZIP:"); + ColorConsole.WriteLine(zippedbackupfilepath, ConsoleColor.Yellow, prefix: " zippedbackupfilepath:"); + ColorConsole.WriteLine(targetdbphysicalfilesdirectorypath, ConsoleColor.Yellow, prefix: " targetdbphysicalfilesdirectorypath:"); + if (emulate) { return; } - string sqlcs = sqldb.SQLCS; - string backupfilepath; if (restorefromZIP) { - backupfilepath = Path.Combine(Path.GetDirectoryName(sourcesqlbackupfilepath), Path.GetFileNameWithoutExtension(sourcesqlbackupfilepath) + ".bak"); - ZipTools.Extract1stFileFromZIP(backupfilepath, sourcesqlbackupfilepath); + if (!File.Exists(zippedbackupfilepath)) + { + ColorConsole.WriteLine($"ERROR! Restore source zipped backup file '{zippedbackupfilepath}' does not exist!", ConsoleColor.Red, prefix: ""); + return; + } + ZipTools.Extract1stFileFromZIP(normalbackupfilepath, zippedbackupfilepath); var starttime = DateTime.Now; - while (DateTime.Now.Subtract(starttime).TotalSeconds > 5) { if (File.Exists(backupfilepath)) { break; } Thread.Sleep(500); } - } - else { backupfilepath = sourcesqlbackupfilepath; } - var sqlserver = SQLServerConnect(sqlcs); - - var smoRestore = new Restore(); - smoRestore.NoRecovery = false; - smoRestore.ReplaceDatabase = true; - smoRestore.Action = RestoreActionType.Database; - smoRestore.PercentCompleteNotification = 5; - var backupdevice = new BackupDeviceItem(backupfilepath, DeviceType.File); - smoRestore.Devices.Add(backupdevice); - smoRestore.Database = string.IsNullOrWhiteSpace(restoretodbname) - ? smoRestore.ReadBackupHeader(sqlserver).Rows[0]["DatabaseName"].ToString() - : restoretodbname; - - var dbfilelist = smoRestore.ReadFileList(sqlserver); - var smorestoreDATfile = new RelocateFile(); - string targetdbphysicalfilesdirectorypathDAT = targetdbphysicalfilesdirectorypath; - if (string.IsNullOrEmpty(targetdbphysicalfilesdirectorypathDAT)) { targetdbphysicalfilesdirectorypathDAT = sqlserver.DefaultFile; } - if (string.IsNullOrEmpty(targetdbphysicalfilesdirectorypathDAT)) { targetdbphysicalfilesdirectorypathDAT = sqlserver.MasterDBPath; } - smorestoreDATfile.PhysicalFileName = Path.Combine(targetdbphysicalfilesdirectorypathDAT, smoRestore.Database + "_Data.mdf"); - smorestoreDATfile.LogicalFileName = dbfilelist.Select("Type='D'")[0]["LogicalName"].ToString(); - smoRestore.RelocateFiles.Add(smorestoreDATfile); - - var smorestoreLOGfile = new RelocateFile(); - string targetdbphysicalfilesdirectorypathLOG = targetdbphysicalfilesdirectorypath; - if (string.IsNullOrEmpty(targetdbphysicalfilesdirectorypathLOG)) { targetdbphysicalfilesdirectorypathLOG = sqlserver.DefaultLog; } - if (string.IsNullOrEmpty(targetdbphysicalfilesdirectorypathLOG)) { targetdbphysicalfilesdirectorypathLOG = sqlserver.MasterDBLogPath; } - smorestoreLOGfile.PhysicalFileName = Path.Combine(targetdbphysicalfilesdirectorypathLOG, smoRestore.Database + "_Log.ldf"); - smorestoreLOGfile.LogicalFileName = dbfilelist.Select("Type='L'")[0]["LogicalName"].ToString(); - smoRestore.RelocateFiles.Add(smorestoreLOGfile); - - sqlserver.KillAllProcesses(smoRestore.Database); - - smoRestore.SqlRestore(sqlserver); - if (restorefromZIP) + while (DateTime.Now.Subtract(starttime).TotalSeconds > 5) { if (File.Exists(normalbackupfilepath)) { break; } Thread.Sleep(500); } + } + + if (!File.Exists(normalbackupfilepath)) + { + ColorConsole.WriteLine($"ERROR! Restore source backup file '{normalbackupfilepath}' does not exist!", ConsoleColor.Red, prefix: ""); + return; + } + Server sqlserver = null; + try { - if (File.Exists(backupfilepath)) { File.Delete(backupfilepath); } + var sc = GetSqlConnection(sqlcs, "master"); + sqlserver = SQLServerConnect(sc);if (sqlserver == null) { return; } + + var smoRestore = new Restore(); + smoRestore.NoRecovery = false; + smoRestore.ReplaceDatabase = true; + smoRestore.Action = RestoreActionType.Database; + smoRestore.PercentComplete += SmoBackupRestore_PercentComplete; + smoRestore.PercentCompleteNotification = 1; + var backupdevice = new BackupDeviceItem(normalbackupfilepath, DeviceType.File); + smoRestore.Devices.Add(backupdevice); + smoRestore.Database = string.IsNullOrWhiteSpace(restoretodbname) + ? smoRestore.ReadBackupHeader(sqlserver).Rows[0]["DatabaseName"].ToString() + : restoretodbname; + + + var dbfilelist = smoRestore.ReadFileList(sqlserver); + var smorestoreDATfile = new RelocateFile(); + string targetdbphysicalfilesdirectorypathDAT = targetdbphysicalfilesdirectorypath; + if (string.IsNullOrEmpty(targetdbphysicalfilesdirectorypathDAT)) { targetdbphysicalfilesdirectorypathDAT = sqlserver.DefaultFile; } + if (string.IsNullOrEmpty(targetdbphysicalfilesdirectorypathDAT)) { targetdbphysicalfilesdirectorypathDAT = sqlserver.MasterDBPath; } + smorestoreDATfile.PhysicalFileName = Path.Combine(targetdbphysicalfilesdirectorypathDAT, smoRestore.Database + "_Data.mdf"); + smorestoreDATfile.LogicalFileName = dbfilelist.Select("Type='D'")[0]["LogicalName"].ToString(); + smoRestore.RelocateFiles.Add(smorestoreDATfile); + + var smorestoreLOGfile = new RelocateFile(); + string targetdbphysicalfilesdirectorypathLOG = targetdbphysicalfilesdirectorypath; + if (string.IsNullOrEmpty(targetdbphysicalfilesdirectorypathLOG)) { targetdbphysicalfilesdirectorypathLOG = sqlserver.DefaultLog; } + if (string.IsNullOrEmpty(targetdbphysicalfilesdirectorypathLOG)) { targetdbphysicalfilesdirectorypathLOG = sqlserver.MasterDBLogPath; } + smorestoreLOGfile.PhysicalFileName = Path.Combine(targetdbphysicalfilesdirectorypathLOG, smoRestore.Database + "_Log.ldf"); + smorestoreLOGfile.LogicalFileName = dbfilelist.Select("Type='L'")[0]["LogicalName"].ToString(); + smoRestore.RelocateFiles.Add(smorestoreLOGfile); + + GetExclusiveUse(smoRestore.Database, sqlserver, sc); + smoRestore.SqlRestore(sqlserver); + ColorConsole.WriteLine(); + ColorConsole.WriteLine("Restore completed", ConsoleColor.Green); + if (restorefromZIP && File.Exists(normalbackupfilepath)) { File.Delete(normalbackupfilepath); } } + finally { sqlserver?.ConnectionContext.SqlConnectionObject.Dispose(); } } /// @@ -798,34 +1074,27 @@ GO /// /// /// - public static string CreateBackup(SQLDataBase sqld,bool? forcecreatezip, DateTime? timestamp) + public static string CreateBackup(SQLDataBase sqld,bool? forcecreatezip, DateTime? timestamp,bool emulate=false) { string backupdirectorypath = sqld.Xml_BackupTargetDirectoryPath; - string tranzitdirectorypathlocal = sqld.Xml_TranzitDirectoryPathLocal; - string tranzitdirectorypathnetwork = sqld.Xml_TranzitDirectoryPathNetwork; + string tranzitdirectorypath = sqld.Xml_TranzitDirectoryPath; bool usetranzit = sqld.Xml_IsRemoteDB; - string sqlconnectionstring = sqld.SQLCS; string backupfilenamemask = sqld.Xml_BackupFileNameMask; bool createzip = forcecreatezip ?? sqld.Xml_CreateZip; //tranzitdirectorypathlocal = @"F:\ALM"; //tranzitdirectorypathnetwork = @"\\matng-sql01\ALM"; - var sqlserver = SQLServerConnect(sqlconnectionstring); - if (sqlserver == null) - { - ColorConsole.WriteLine($"ERROR! Database connection string error. '{sqlconnectionstring}'", ConsoleColor.Red); - return null; - } - + string returnfilename = null; - var dbname = GetDBName(sqlconnectionstring); + var dbname = GetDBName(sqld.SQLCS); + var datasource = GetDataSource(sqld.SQLCS); var backupts = (timestamp.HasValue ? timestamp.Value : DateTime.Now).ToString("yyyyMMddHHmmss"); string backupfileNameOnly = Path.GetFileNameWithoutExtension(backupfilenamemask); var vars = new Dictionary(); - vars.Add(nameof(DBSubstitutionName.DATABASE), GetDBName(sqlconnectionstring)); + vars.Add(nameof(DBSubstitutionName.DATABASE), dbname); vars.Add(nameof(DBSubstitutionName.DBKEY), sqld.Xml_Key); - vars.Add(nameof(DBSubstitutionName.DATASOURCE), GetDataSource(sqlconnectionstring)); + vars.Add(nameof(DBSubstitutionName.DATASOURCE), datasource); vars.Add(nameof(DBSubstitutionName.DBOTYPE), "DBBACKUP"); vars.Add(nameof(DBSubstitutionName.DBONAME), ""); vars.Add(nameof(DBSubstitutionName.DBDATAGROUP), ""); @@ -835,70 +1104,90 @@ GO string backupfilename = backupfileNameOnly + ".bak"; string backupFullName = Path.Combine(backupdirectorypath, backupfilename); - string tranzitFullNameLocal= usetranzit ? Path.Combine(tranzitdirectorypathlocal, backupfilename) : null; - string tranzitFullNameNetwork= usetranzit ? Path.Combine(tranzitdirectorypathnetwork, backupfilename) : null; - if (File.Exists(backupFullName)) { File.Delete(backupFullName); } - - - var smoBackup = new Backup(); - smoBackup.Action = BackupActionType.Database; - smoBackup.BackupSetName = sqlserver.ConnectionContext.DatabaseName + " Backup"; - smoBackup.BackupSetDescription = $"Full Backup of {sqlserver.ConnectionContext.DatabaseName}"; - smoBackup.MediaDescription = "Disk"; + string tranzitFullName = usetranzit ? Path.Combine(tranzitdirectorypath, backupfilename) : null; + + string ZIPbackupfilename = backupfileNameOnly + ".zip"; + string ZIPbackupFullName = Path.Combine(backupdirectorypath, ZIPbackupfilename); + returnfilename = createzip? ZIPbackupFullName : backupFullName; + + ColorConsole.WriteLine(nameof(CreateBackup), ConsoleColor.Yellow, prefix: "running...."); + ColorConsole.WriteLine(dbname, ConsoleColor.Yellow, prefix: " dbname:"); + ColorConsole.WriteLine(sqld.SQLCS, ConsoleColor.Yellow, prefix: " sqld.SQLCS:"); + ColorConsole.WriteLine(backupdirectorypath, ConsoleColor.Yellow, prefix: " backupdirectorypath:"); + ColorConsole.WriteLine(backupfilename, ConsoleColor.Yellow, prefix: " backupfilename:"); + ColorConsole.WriteLine(backupFullName, ConsoleColor.Yellow, prefix: " backupFullName:"); + ColorConsole.WriteLine(createzip.ToString(), ConsoleColor.Yellow, prefix: " createzip:"); + ColorConsole.WriteLine(ZIPbackupfilename, ConsoleColor.Yellow, prefix: " ZIPbackupfilename:"); + ColorConsole.WriteLine(ZIPbackupFullName, ConsoleColor.Yellow, prefix: " ZIPbackupFullName:"); + ColorConsole.WriteLine(usetranzit.ToString(), ConsoleColor.Yellow, prefix: " usetranzit:"); + ColorConsole.WriteLine(tranzitFullName, ConsoleColor.Yellow, prefix: " tranzitFullName:"); + ColorConsole.WriteLine(returnfilename, ConsoleColor.Yellow, prefix: " returnfilename:"); + + if (!emulate) + { + ColorConsole.WriteLine($"Database backup started...", ConsoleColor.DarkGreen); + if (File.Exists(backupFullName)) { File.Delete(backupFullName); } + var smoBackup = new Backup(); + smoBackup.Database = dbname; + smoBackup.Action = BackupActionType.Database; + smoBackup.BackupSetName = smoBackup.Database + " Backup"; + smoBackup.BackupSetDescription = $"Full Backup of {smoBackup.Database}"; + smoBackup.MediaDescription = "Disk"; Console.WriteLine($"Backup set: {smoBackup.BackupSetName} ({smoBackup.BackupSetDescription}) to media: {smoBackup.MediaDescription}"); - smoBackup.Database = sqlserver.ConnectionContext.DatabaseName; string dummystring = usetranzit ? " REMOTE SQL SERVER!" : ""; Console.WriteLine($"Database name: {smoBackup.Database}{dummystring}"); Console.WriteLine($"Connection string: {sqld.SQLCS}"); - smoBackup.Devices.AddDevice(usetranzit ? tranzitFullNameLocal : backupFullName, DeviceType.File); + smoBackup.Devices.AddDevice(usetranzit ? tranzitFullName : backupFullName, DeviceType.File); Console.WriteLine($"Backup full name:{backupFullName}"); - if (usetranzit) + if (usetranzit) { - Console.WriteLine($" ...will be created through tranzit: {tranzitFullNameNetwork}"); + Console.WriteLine($" ...will be created through tranzit: {tranzitFullName}"); + } + smoBackup.PercentComplete += SmoBackupRestore_PercentComplete; + smoBackup.PercentCompleteNotification = 1; + + Server sqlserver = null; + try + { + sqlserver = SQLServerConnect(sqld.SQLCS, "master"); if (sqlserver == null) { return null; } + smoBackup.SqlBackupAsync(sqlserver); + var startbackup = DateTime.Now; + smoBackup.Wait(); + Console.WriteLine($""); + Console.WriteLine($"Backup completed. Backup time: {(int)(DateTime.Now.Subtract(startbackup).TotalSeconds)}sec."); + } + finally { sqlserver?.ConnectionContext.SqlConnectionObject.Dispose(); } + if (usetranzit && File.Exists(tranzitFullName)) + { + File.Move(tranzitFullName, backupFullName); + Console.WriteLine($"Moving backup file..."); + Console.WriteLine($" ...from tranzit location: {tranzitFullName}"); + Console.WriteLine($" ...to backup location: {backupFullName}"); + } + if (!File.Exists(backupFullName)) + { + ColorConsole.WriteLine($"ERROR! Database backup failed. DB name:'{smoBackup.Database}'. BAK/ZIP file name:'{Path.GetFileName(returnfilename)}'", ConsoleColor.Red); + return null; } - smoBackup.PercentComplete += SmoBackup_PercentComplete; - smoBackup.PercentCompleteNotification = 1; - smoBackup.SqlBackupAsync(sqlserver); - var startbackup = DateTime.Now; - smoBackup.Wait(); - Console.WriteLine($""); - Console.WriteLine($"Backup completed. Backup time: {(int)(DateTime.Now.Subtract(startbackup).TotalSeconds)}sec."); - if (usetranzit && File.Exists(tranzitFullNameNetwork)) - { - File.Move(tranzitFullNameNetwork, backupFullName); - Console.WriteLine($"Moving backup file..."); - Console.WriteLine($" ...from tranzit location: {tranzitFullNameNetwork}"); - Console.WriteLine($" ...to backup location: {backupFullName}"); - } - returnfilename = backupFullName; - if (File.Exists(backupFullName)) - { if (createzip) { var startcompressing = DateTime.Now; - string ZIPbackupfilename = backupfileNameOnly + ".zip"; - string ZIPbackupFullName = Path.Combine(backupdirectorypath, ZIPbackupfilename); if (File.Exists(ZIPbackupFullName)) { File.Delete(ZIPbackupFullName); } ZipTools.CreateEntriesFromDirectoryContent(backupdirectorypath, ZIPbackupFullName, backupfilename, "", "", removearchivedfiles: false, storepathinzip: false); File.Delete(backupFullName); Console.WriteLine($"Zipping completed. Compressing time: {(int)(DateTime.Now.Subtract(startcompressing).TotalSeconds)}sec."); - returnfilename = ZIPbackupFullName; } - ColorConsole.WriteLine($"SUCCESS! Database backup created. DB name:'{dbname}'. BAK/ZIP file name:'{Path.GetFileName(returnfilename)}'", ConsoleColor.DarkGreen); - } - else - { - ColorConsole.WriteLine($"ERROR! Database backup failed. DB name:'{dbname}'. BAK/ZIP file name:'{Path.GetFileName(returnfilename)}'", ConsoleColor.Red); + ColorConsole.WriteLine($"SUCCESS! Database backup created. DB name:'{smoBackup.Database}'. BAK/ZIP file name:'{Path.GetFileName(returnfilename)}'", ConsoleColor.DarkGreen); } return returnfilename; } - private static void SmoBackup_PercentComplete(object sender, PercentCompleteEventArgs e) + private static void SmoBackupRestore_PercentComplete(object sender, PercentCompleteEventArgs e) { - Console.SetCursorPosition(0, Console.CursorTop); - Console.Write($"Database backup completed: {e.Percent}%. {e.Message}"); - } + ColorConsole.SetCursorPosition(0, Console.CursorTop); + ColorConsole.Write($"Completed: {e.Percent}%. {e.Message}"); + } #region private methods public static List GetBackupFilePathList(SQLDataBase sqld) @@ -926,16 +1215,21 @@ GO /// public static string ConfigureSaUser(string cs,string password, string newsapassword) { - var sqlserver = SQLServerConnect(cs); - sqlserver.Settings.LoginMode= ServerLoginMode.Mixed; - sqlserver.Logins["sa"].Enable(); - sqlserver.Logins.ItemById(10).Enable(); - sqlserver.Logins["sa"].ChangePassword(newsapassword); - sqlserver.Alter(); - sqlserver.Logins["a"].Refresh(); - return SQLServerConnect(cs).ConnectionContext.ConnectionString; + Server sqlserver = null; + try + { + sqlserver = SQLServerConnect(cs); if (sqlserver == null) return null; + sqlserver.Settings.LoginMode = ServerLoginMode.Mixed; + sqlserver.Logins["sa"].Enable(); + sqlserver.Logins.ItemById(10).Enable(); + sqlserver.Logins["sa"].ChangePassword(newsapassword); + sqlserver.Alter(); + sqlserver.Logins["a"].Refresh(); + return sqlserver.ConnectionContext.ConnectionString; + } + finally { sqlserver?.ConnectionContext.SqlConnectionObject.Dispose(); } } - public static void CreateUser(string sqldbconnectionString, string dbusername, string dbrolenamecommalist) + public static void CreateUser(string sqldbconnectionString, string dbusername, string dbrolenamecommalist,string loginname) { using (SqlConnection connection = new SqlConnection(sqldbconnectionString)) { @@ -944,7 +1238,37 @@ GO //USE [LearALM2] //DROP USER[datareader] - string createUserQuery = "CREATE USER [" + dbusername + "] FOR LOGIN [" + dbusername + "];"; + //empty=DB user w/o login, *=DB user with login,w=WIndows user, other=server login name DB user is created for + bool? forlogin; + if (string.IsNullOrWhiteSpace(loginname)) { forlogin = false; loginname = null; } + else if (loginname.ToLower() == "w") { forlogin = null; loginname = null; } + else { forlogin = true; loginname = loginname == "*"?dbusername: loginname; } + + //Creating a database user based on a SQL Server login + // CREATE LOGIN AbolrousHazem WITH PASSWORD = '340$Uuxwp7Mcxo7Khy'; + // GO + // USE AdventureWorks2022 + // GO + // CREATE USER AbolrousHazem FOR LOGIN AbolrousHazem; + // GO + //Creating and using a user without a login + // USE AdventureWorks2022; + // CREATE USER CustomApp WITHOUT LOGIN; + // GRANT IMPERSONATE ON USER::CustomApp TO[adventure - works\tengiz0]; + // GO + // To use the CustomApp credentials, the user adventure-works\tengiz0 executes the following statement. + // EXECUTE AS USER = 'CustomApp' ; + //Creating a contained database user for a domain login for a login named Fritz in a domain named Contoso. + // USE AdventureWorks2022; + // GO + // CREATE USER [Contoso\Fritz]; + // GO + + string createUserQuery = "CREATE USER [" + dbusername + "]"; + if (forlogin.HasValue && forlogin.Value) {createUserQuery += " FOR LOGIN [" + loginname + "];"; } + else if (forlogin.HasValue && !forlogin.Value) { createUserQuery = " WITHOUT LOGIN;"; } + createUserQuery += ";"; + using (SqlCommand createUserCommand = new SqlCommand(createUserQuery, connection)) { createUserCommand.ExecuteNonQuery(); } //--ALTER AUTHORIZATION ON SCHEMA::[aspnet_Membership_BasicAccess] TO[dbo] //--ALTER AUTHORIZATION ON SCHEMA::[aspnet_Membership_FullAccess] TO[dbo] @@ -955,113 +1279,198 @@ GO string grantPermissionsQuery = "EXEC sp_addrolemember N'"+ rolename + "', N'"+ dbusername + "'"; using (SqlCommand grantPermissionsCommand = new SqlCommand(grantPermissionsQuery, connection)) { grantPermissionsCommand.ExecuteNonQuery(); } } - } - } - public static void CreateLogin(string sqldbconnectionString, string name, string password, string defaultDatabase, string[] roles) - { - var _server = SQLServerConnect(sqldbconnectionString); - Login login = new Login(_server, name); - login.LoginType = LoginType.SqlLogin; - login.DefaultDatabase = defaultDatabase; - - login.PasswordExpirationEnabled = false; - login.PasswordPolicyEnforced = false; - login.Create(password, LoginCreateOptions.None); - for (int i = 0; i < (roles==null?-1:roles.Length); i++) { login.AddToRole(roles[i]); } + //USE[LearALM2] + //ALTER AUTHORIZATION ON SCHEMA::[ALM] TO[dbo] + //ALTER AUTHORIZATION ON SCHEMA::[Andon] TO[dbo] + //ALTER AUTHORIZATION ON SCHEMA::[aspnet_Membership_BasicAccess] TO[dbo] + //ALTER AUTHORIZATION ON SCHEMA::[aspnet_Membership_FullAccess] TO[dbo] + //ALTER AUTHORIZATION ON SCHEMA::[aspnet_Membership_ReportingAccess] TO[dbo] + //ALTER AUTHORIZATION ON SCHEMA::[aspnet_Personalization_BasicAccess] TO[dbo] + //ALTER AUTHORIZATION ON SCHEMA::[aspnet_Personalization_FullAccess] TO[dbo] + //ALTER AUTHORIZATION ON SCHEMA::[aspnet_Personalization_ReportingAccess] TO[dbo] + //ALTER AUTHORIZATION ON SCHEMA::[aspnet_Profile_BasicAccess] TO[dbo] + //ALTER AUTHORIZATION ON SCHEMA::[aspnet_Profile_FullAccess] TO[dbo] + //ALTER AUTHORIZATION ON SCHEMA::[aspnet_Profile_ReportingAccess] TO[dbo] + //ALTER AUTHORIZATION ON SCHEMA::[aspnet_Roles_BasicAccess] TO[dbo] + //ALTER AUTHORIZATION ON SCHEMA::[aspnet_Roles_FullAccess] TO[dbo] + //ALTER AUTHORIZATION ON SCHEMA::[aspnet_Roles_ReportingAccess] TO[dbo] + //ALTER AUTHORIZATION ON SCHEMA::[aspnet_WebEvent_FullAccess] TO[dbo] + //ALTER AUTHORIZATION ON SCHEMA::[CP] TO[dbo] + //ALTER AUTHORIZATION ON SCHEMA::[db_accessadmin] TO[dbo] + //ALTER AUTHORIZATION ON SCHEMA::[db_backupoperator] TO[dbo] + //ALTER AUTHORIZATION ON SCHEMA::[db_datareader] TO[dbo] + //ALTER AUTHORIZATION ON SCHEMA::[db_datawriter] TO[dbo] + //ALTER AUTHORIZATION ON SCHEMA::[db_ddladmin] TO[dbo] + //ALTER AUTHORIZATION ON SCHEMA::[db_denydatareader] TO[dbo] + //ALTER AUTHORIZATION ON SCHEMA::[db_denydatawriter] TO[dbo] + //ALTER AUTHORIZATION ON SCHEMA::[db_owner] TO[dbo] + //ALTER AUTHORIZATION ON SCHEMA::[db_securityadmin] TO[dbo] + //ALTER AUTHORIZATION ON SCHEMA::[guest] TO[dbo] + //ALTER AUTHORIZATION ON SCHEMA::[i18n] TO[dbo] + //ALTER AUTHORIZATION ON SCHEMA::[IdTranslator] TO[dbo] + //ALTER AUTHORIZATION ON SCHEMA::[ImportLog] TO[dbo] + //ALTER AUTHORIZATION ON SCHEMA::[iScheduler] TO[dbo] + //ALTER AUTHORIZATION ON SCHEMA::[iSchedulerReports] TO[dbo] - login.Alter(); - login.Enable(); - login.Alter(); + } + } + public static void CreateLogin(string sqldbconnectionString, string name, string password, string defaultDatabase, LoginType logintype, string[] roles,string grantoruser=null,string grantoruserpsw=null) + { + Server sqlserver = null; + try + { + var sc = GetSqlConnection(sqldbconnectionString,null, grantoruser, grantoruserpsw); + sqlserver = SQLServerConnect(sc); if (sqlserver == null) return; + Login login = new Login(sqlserver, name); + login.LoginType = logintype; + login.DefaultDatabase = defaultDatabase; + + login.PasswordExpirationEnabled = false; + login.PasswordPolicyEnforced = false; + if (password == null) { login.Create(); } + else { login.Create(password, LoginCreateOptions.None); } + + for (int i = 0; i < (roles == null ? -1 : roles.Length); i++) { login.AddToRole(roles[i]); } + + login.Alter(); + login.Enable(); + login.Alter(); + } + finally { sqlserver?.ConnectionContext.SqlConnectionObject.Dispose(); } } public static void ConfigureWindowsUser(string cs, string sapassword, string databasename, string windowsfullusername,string windowsuserpassword,List rolenamelist) { - var sqlserver = SQLServerConnect(cs); - if (!sqlserver.Logins.Contains(windowsfullusername)) + Server sqlserver = null; + try { - var wul = new Microsoft.SqlServer.Management.Smo.Login(sqlserver, windowsfullusername); - wul.LoginType = LoginType.WindowsUser; - wul.Create(windowsuserpassword,LoginCreateOptions.None); - if (!string.IsNullOrWhiteSpace(databasename)) + sqlserver = SQLServerConnect(cs); if (sqlserver == null) return; + if (!sqlserver.Logins.Contains(windowsfullusername)) { - var dbobject = sqlserver.Databases[databasename]; - if (dbobject==null) { throw new Exception($"Specified databas '{databasename}' does not exist!"); } - if (dbobject.Users.Contains(windowsfullusername)) { dbobject.Users[windowsfullusername].Drop(); } - var dbuser = new Microsoft.SqlServer.Management.Smo.User(dbobject, windowsfullusername); - dbuser.Login = windowsfullusername; - dbuser.Create(windowsuserpassword); - foreach (var rn in rolenamelist) - { - var dbrole = dbobject.Roles[rn]; - dbrole.AddMember(windowsfullusername); - dbrole.Alter(); + var wul = new Microsoft.SqlServer.Management.Smo.Login(sqlserver, windowsfullusername); + wul.LoginType = LoginType.WindowsUser; + wul.Create(windowsuserpassword, LoginCreateOptions.None); + if (!string.IsNullOrWhiteSpace(databasename)) + { + var dbobject = sqlserver.Databases[databasename]; + if (dbobject == null) { throw new Exception($"Specified databas '{databasename}' does not exist!"); } + if (dbobject.Users.Contains(windowsfullusername)) { dbobject.Users[windowsfullusername].Drop(); } + var dbuser = new Microsoft.SqlServer.Management.Smo.User(dbobject, windowsfullusername); + dbuser.Login = windowsfullusername; + dbuser.Create(windowsuserpassword); + foreach (var rn in rolenamelist) + { + var dbrole = dbobject.Roles[rn]; + dbrole.AddMember(windowsfullusername); + dbrole.Alter(); + } } } } + finally { sqlserver?.ConnectionContext.SqlConnectionObject.Dispose(); } } - public static void DropDatabase(string cs,string databasename,string sapassword) + public static bool DropDatabase(string cs,string databasename,string userid, string password) { - var sqlserver = SQLServerConnect(cs); - if (sqlserver.Databases.Contains(databasename)) + Server sqlserver = null; + try { - sqlserver.KillAllProcesses(databasename); - sqlserver.Databases[databasename].Drop(); + var sc = GetSqlConnection(cs, dbname:databasename, userid: userid, userpassword: password); + sqlserver = SQLServerConnect(sc); if (sqlserver == null) return false; + if (sqlserver.Databases.Contains(databasename)) + { + GetExclusiveUse(databasename, sqlserver, sc); + sqlserver.Databases[databasename].Drop(); + return true; + } + else { throw new ApplicationException($"Specified DB '{databasename}' does not exist!"); } } - else { throw new Exception($"Specified databas '{databasename}' does not exist!"); } + catch (Exception ex) { ColorConsole.WriteLine(ex.MessageNested(), ConsoleColor.Red); return false; } + finally { sqlserver?.ConnectionContext.SqlConnectionObject.Dispose(); } + } + public static void GetExclusiveUse(string databasename,Server sqlserver,SqlConnection sc) + { + try { sqlserver.KillAllProcesses(databasename); } + catch (Exception ex) { ColorConsole.WriteLine($"{nameof(GetExclusiveUse)}/{nameof(Server.KillAllProcesses)}>>>:" + ex.MessageNested(), ConsoleColor.Red); } + + SqlCommand sqlcommand = null; + try { sqlcommand = new SqlCommand($"ALTER DATABASE {databasename} SET Single_User WITH Rollback IMMEDIATE", sc); sqlcommand.ExecuteNonQuery(); } + catch (Exception ex) { ColorConsole.WriteLine($"{nameof(GetExclusiveUse)}/{nameof(SqlCommand.ExecuteNonQuery)}>>>: " + ex.MessageNested(), ConsoleColor.Red); } + finally { sqlcommand?.Dispose(); } } + public static string GetServerDefaultPhysicalDATFileLocation(string cs) { - var sqlserver = SQLDataBaseManagerCore.SQLServerConnect(cs); - return string.IsNullOrEmpty(sqlserver.DefaultFile) ? sqlserver.MasterDBPath : sqlserver.DefaultFile; + Server sqlserver = null; + try + { + sqlserver = SQLServerConnect(cs); if (sqlserver == null) return null; + return string.IsNullOrEmpty(sqlserver.DefaultFile) ? sqlserver.MasterDBPath : sqlserver.DefaultFile; + } + finally { sqlserver?.ConnectionContext.SqlConnectionObject.Dispose(); } } public static string GetServerDefaultPhysicalLOGFileLocation(string cs) { - var sqlserver = SQLDataBaseManagerCore.SQLServerConnect(cs); - return string.IsNullOrEmpty(sqlserver.DefaultLog) ? sqlserver.MasterDBLogPath : sqlserver.DefaultLog; + Server sqlserver = null; + try + { + sqlserver = SQLServerConnect(cs);if (sqlserver == null) return null; + return string.IsNullOrEmpty(sqlserver.DefaultLog) ? sqlserver.MasterDBLogPath : sqlserver.DefaultLog; + } + finally { sqlserver?.ConnectionContext.SqlConnectionObject.Dispose(); } } public static string GetDBName(string cs) { - var sqlc = new Microsoft.Data.SqlClient.SqlConnection(cs); - return sqlc.Database; + var sqlcb = new SqlConnectionStringBuilder(cs); + return sqlcb.InitialCatalog; } public static string GetDataSource(string cs) { - var sqlc = new Microsoft.Data.SqlClient.SqlConnection(cs); - return sqlc.DataSource; + var sqlcb = new SqlConnectionStringBuilder(cs); + return sqlcb.DataSource; } public enum SQLDBStatus { NoAccess, OK, } - public static SQLDBStatus GetStatus(string cs) + public static SqlConnection GetSqlConnection(string sqlconnectionstring, string dbname = null, string userid = null, string userpassword = null) { - try - { - var s = GetPhysicalFilesLocation(cs); - if (s == null) { throw new Exception(); }; - return SQLDBStatus.OK; - } - catch { return SQLDBStatus.NoAccess; } + var scb = new SqlConnectionStringBuilder(sqlconnectionstring); + if (!string.IsNullOrWhiteSpace(dbname)) { scb.InitialCatalog = dbname; } + if (!string.IsNullOrWhiteSpace(userid) && !string.IsNullOrWhiteSpace(userpassword)) { scb.UserID = userid; scb.Password = userpassword; } + else if (!string.IsNullOrWhiteSpace(userid) && string.IsNullOrWhiteSpace(userpassword)) { scb.UserID= userid; scb.IntegratedSecurity= true; } + return new SqlConnection(scb.ToString()); } - public static Server SQLServerConnect(string sqlconnectionstring) + public static Server SQLServerConnect(string sqlconnectionstring,string dbname=null) { + return SQLServerConnect(GetSqlConnection(sqlconnectionstring, dbname)); + } + public static Server SQLServerConnect(SqlConnection sqlconnection) + { + if (sqlconnection == null) return null; try { - var sqlconnection = new Microsoft.Data.SqlClient.SqlConnection(sqlconnectionstring); + ColorConsole.WriteLine($"{nameof(SQLServerConnect)}. Connecting to: '{sqlconnection.ConnectionString}'", ConsoleColor.Yellow); var serverconnection = new ServerConnection(sqlconnection); var sqlserver = new Server(serverconnection); - if (string.IsNullOrEmpty(sqlserver.Information.Version.ToString())) { throw new Exception("Connection not established!"); } + ColorConsole.WriteLine($"{nameof(SQLServerConnect)}. Connected. Server version:v{sqlserver.Information.Version}", ConsoleColor.Yellow); return sqlserver; } - catch (Exception ex) { throw ex; } + catch (Exception ex) + { + ColorConsole.WriteLine($"{nameof(SQLServerConnect)}. ERROR! Connecting to: '{sqlconnection.ConnectionString}'", ConsoleColor.Red); + ColorConsole.WriteLine(ex.MessageNested()); + throw ex; + } } public static void ShrinkDB(string sqlconnectionstring, ShrinkMethod shrinkmethod,int freespacepercent) { - var sqlc = new Microsoft.Data.SqlClient.SqlConnection(sqlconnectionstring); - var sc = new ServerConnection(sqlc); - var srvr = new Server(sc); - var db = new Database(srvr, GetDBName(sqlconnectionstring)); - db.Shrink(freespacepercent, shrinkmethod); + using (var sqlc = new SqlConnection(sqlconnectionstring)) + { + var sc = new ServerConnection(sqlc); + var srvr = new Server(sc); + var db = new Database(srvr, GetDBName(sqlconnectionstring)); + db.Shrink(freespacepercent, shrinkmethod); + } } #region GetSize @@ -1074,25 +1483,26 @@ GO { try { - var sqlc = new Microsoft.Data.SqlClient.SqlConnection(sqlconnectionstring); - var dbname = GetDBName(sqlconnectionstring); + using (var sqlc = new Microsoft.Data.SqlClient.SqlConnection(sqlconnectionstring)) + { + var dbname = GetDBName(sqlconnectionstring); - var getsizecmd = new Microsoft.Data.SqlClient.SqlCommand("sp_spaceused", sqlc); - getsizecmd.CommandType = System.Data.CommandType.StoredProcedure; - sqlc.Open(); - var reader = getsizecmd.ExecuteReader(); + var getsizecmd = new Microsoft.Data.SqlClient.SqlCommand("sp_spaceused", sqlc); + getsizecmd.CommandType = System.Data.CommandType.StoredProcedure; + sqlc.Open(); + var reader = getsizecmd.ExecuteReader(); - if (reader.HasRows) - { - while (reader.Read()) + if (reader.HasRows) { - var dbn = reader["database_name"]; - var dbs = reader["database_size"]; - if (Convert.ToString(dbn) == dbname) { return Convert.ToString(dbs); }; + while (reader.Read()) + { + var dbn = reader["database_name"]; + var dbs = reader["database_size"]; + if (Convert.ToString(dbn) == dbname) { return Convert.ToString(dbs); }; + } } + sqlc.Close(); } - sqlc.Close(); - sqlc.Dispose(); return "N/A"; } catch { return "ERR"; } @@ -1152,46 +1562,47 @@ GO /// public static ReturnInfoJSON ExecuteSQLScript(string sqlconnectionstring, string sqltxt, int commandtimeout, Dictionary vars) { - var sqlc = new Microsoft.Data.SqlClient.SqlConnection(sqlconnectionstring); - - sqltxt = VRH.Common.StringConstructor.ResolveConstructorR(vars, sqltxt, "{}@@"); - - sqlc.Open(); - string SQLBatchTxt = ""; // ebben lesznek az sql script-en belüli batch-ek összerakva - int SQLBatchIndex = 0; // az aktuális batch indexe - int scriptlineindex = 0; // az aktuális script sor indexe - System.Data.DataSet DataSet = null; // ebben lesz az eredmény (az utolsó batch eredménye) - sqltxt += "\r\nGO";// ha esetleg nem lenne, odatesszük a végére az utolsó batch-et lezáró GO-t - foreach (var scriptline in sqltxt.Split(new char[] { '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries)) + using (var sqlc = new Microsoft.Data.SqlClient.SqlConnection(sqlconnectionstring)) { - scriptlineindex += 1; - if (Regex.Match(scriptline, @"^GO$").Success)// a batch utolső sora + sqltxt = VRH.Common.StringConstructor.ResolveConstructorR(vars, sqltxt, "{}@@"); + + sqlc.Open(); + string SQLBatchTxt = ""; // ebben lesznek az sql script-en belüli batch-ek összerakva + int SQLBatchIndex = 0; // az aktuális batch indexe + int scriptlineindex = 0; // az aktuális script sor indexe + System.Data.DataSet DataSet = null; // ebben lesz az eredmény (az utolsó batch eredménye) + sqltxt += "\r\nGO";// ha esetleg nem lenne, odatesszük a végére az utolsó batch-et lezáró GO-t + foreach (var scriptline in sqltxt.Split(new char[] { '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries)) { - if (!string.IsNullOrWhiteSpace(SQLBatchTxt)) + scriptlineindex += 1; + if (Regex.Match(scriptline, @"^GO$").Success)// a batch utolső sora { - SQLBatchIndex += 1; - DataSet = ExecuteSQLScriptBatch(sqlc, SQLBatchTxt, commandtimeout); - SQLBatchTxt = ""; + if (!string.IsNullOrWhiteSpace(SQLBatchTxt)) + { + SQLBatchIndex += 1; + DataSet = ExecuteSQLScriptBatch(sqlc, SQLBatchTxt, commandtimeout); + SQLBatchTxt = ""; + } + } + else if (!string.IsNullOrWhiteSpace(scriptline)) + { + SQLBatchTxt += scriptline + "\r\n"; } } - else if (!string.IsNullOrWhiteSpace(scriptline)) + + sqlc.Close(); + try { - SQLBatchTxt += scriptline + "\r\n"; + var firstreturnedtable = DataSet.Tables[0]; + var firstreturnedrow = firstreturnedtable.Rows[0]; + var firstreturnedvalue = firstreturnedrow[0]; + var secondreturnedvalue = firstreturnedrow[1]; + var rv = Convert.ToInt32(firstreturnedvalue); + var rm = Convert.ToString(secondreturnedvalue); + return new ReturnInfoJSON() { ReturnValue = rv, ReturnMessage = rm, }; } + catch { } } - - sqlc.Close(); - try - { - var firstreturnedtable = DataSet.Tables[0]; - var firstreturnedrow = firstreturnedtable.Rows[0]; - var firstreturnedvalue = firstreturnedrow[0]; - var secondreturnedvalue = firstreturnedrow[1]; - var rv = Convert.ToInt32(firstreturnedvalue); - var rm = Convert.ToString(secondreturnedvalue); - return new ReturnInfoJSON() { ReturnValue = rv, ReturnMessage = rm, }; - } - catch { } return new ReturnInfoJSON() { ReturnValue = 0, ReturnMessage = null, }; } @@ -1252,38 +1663,40 @@ GO public static List ExecuteSQLStoredProcedure(string sqlconnectionstring, string storedprocedurename, int commandtimeout, List SPparameters) { - var sqlc = new Microsoft.Data.SqlClient.SqlConnection(sqlconnectionstring); - var sqlcommand = sqlc.CreateCommand(); - sqlcommand.Connection = sqlc; - sqlcommand.CommandText = storedprocedurename; - sqlcommand.CommandTimeout = commandtimeout; - sqlcommand.CommandType= System.Data.CommandType.StoredProcedure; - //var DataAdapter = new Microsoft.Data.SqlClient.SqlDataAdapter(sqlcommand); - sqlc.Open(); - foreach (var p in SPparameters) - { - var sqlparameter = new Microsoft.Data.SqlClient.SqlParameter() - { - ParameterName = p.Name, - SqlDbType = p.Type, - Size = p.Typepar, - Direction = p.Direction, - Value = p.Value, - }; - sqlcommand.Parameters.Add(sqlparameter); - } - sqlcommand.ExecuteNonQuery(); + using (var sqlc = new Microsoft.Data.SqlClient.SqlConnection(sqlconnectionstring)) + { + var sqlcommand = sqlc.CreateCommand(); + sqlcommand.Connection = sqlc; + sqlcommand.CommandText = storedprocedurename; + sqlcommand.CommandTimeout = commandtimeout; + sqlcommand.CommandType = System.Data.CommandType.StoredProcedure; + //var DataAdapter = new Microsoft.Data.SqlClient.SqlDataAdapter(sqlcommand); + sqlc.Open(); + foreach (var p in SPparameters) + { + var sqlparameter = new Microsoft.Data.SqlClient.SqlParameter() + { + ParameterName = p.Name, + SqlDbType = p.Type, + Size = p.Typepar, + Direction = p.Direction, + Value = p.Value, + }; + sqlcommand.Parameters.Add(sqlparameter); + } + sqlcommand.ExecuteNonQuery(); - var sqlresult = new List(); - foreach (var p in SPparameters) - { - if (p.Direction == System.Data.ParameterDirection.Output) + var sqlresult = new List(); + foreach (var p in SPparameters) { - sqlresult.Add(new SPparameter(sqlcommand.Parameters[p.Name])); + if (p.Direction == System.Data.ParameterDirection.Output) + { + sqlresult.Add(new SPparameter(sqlcommand.Parameters[p.Name])); + } } + sqlc.Close(); + return sqlresult; } - sqlc.Close(); - return sqlresult; } #endregion ExecuteSQLStoredProcedure #region BackupSqlScripts @@ -1298,35 +1711,38 @@ GO string backupfilenamemask = sqld.Xml_BackupFileNameMask; string sqlcs = sqld.SQLCS; bool createZip = sqld.Xml_CreateZip; - var sqlserver = SQLServerConnect(sqlcs); + var dbname = GetDBName(sqlcs); - if (sqlserver!=null) + string backupts = (timestamp.HasValue ? timestamp.Value : DateTime.Now).ToString("yyyyMMddHHmmss"); + var vars = new Dictionary(); + vars.Add(nameof(DBSubstitutionName.DATABASE), GetDBName(sqlcs)); + vars.Add(nameof(DBSubstitutionName.DATASOURCE), GetDataSource(sqlcs)); + vars.Add(nameof(DBSubstitutionName.BACKUPTS), backupts); + vars.Add(nameof(DBSubstitutionName.DBOTYPE), "Scripts"); + + string zipfilefullpath = null; + string tempbackupdirectorypath; + if (createZip) { - string backupts = (timestamp.HasValue? timestamp.Value:DateTime.Now).ToString("yyyyMMddHHmmss"); - var vars = new Dictionary(); - vars.Add(nameof(DBSubstitutionName.DATABASE), GetDBName(sqlcs)); - vars.Add(nameof(DBSubstitutionName.DATASOURCE), GetDataSource(sqlcs)); - vars.Add(nameof(DBSubstitutionName.BACKUPTS), backupts); - vars.Add(nameof(DBSubstitutionName.DBOTYPE), "Scripts"); - - string zipfilefullpath = null; - string tempbackupdirectorypath; - if (createZip) - { - vars[nameof(DBSubstitutionName.DBONAME)] = ""; - vars[nameof(DBSubstitutionName.DBDATAGROUP)] = ""; - string zipfilename = VRH.Common.StringConstructor.ResolveConstructorR(vars, backupfilenamemask, "{}@@") + ".zip"; - zipfilefullpath = Path.Combine(backupdirectorypath, zipfilename); - tempbackupdirectorypath = Path.Combine(backupdirectorypath, Path.GetRandomFileName()); - if (Directory.Exists(tempbackupdirectorypath)) { Directory.Delete(tempbackupdirectorypath, recursive: true); } - if (!Directory.Exists(tempbackupdirectorypath)) { Directory.CreateDirectory(tempbackupdirectorypath); } - } - else { tempbackupdirectorypath = backupdirectorypath; } + vars[nameof(DBSubstitutionName.DBONAME)] = ""; + vars[nameof(DBSubstitutionName.DBDATAGROUP)] = ""; + string zipfilename = VRH.Common.StringConstructor.ResolveConstructorR(vars, backupfilenamemask, "{}@@") + ".zip"; + zipfilefullpath = Path.Combine(backupdirectorypath, zipfilename); + tempbackupdirectorypath = Path.Combine(backupdirectorypath, Path.GetRandomFileName()); + if (Directory.Exists(tempbackupdirectorypath)) { Directory.Delete(tempbackupdirectorypath, recursive: true); } + if (!Directory.Exists(tempbackupdirectorypath)) { Directory.CreateDirectory(tempbackupdirectorypath); } + } + else { tempbackupdirectorypath = backupdirectorypath; } + + if (!Directory.Exists(backupdirectorypath)) { Directory.CreateDirectory(backupdirectorypath); } + var directorynameonly = new DirectoryInfo(backupdirectorypath).Name; + var backupfilenameext = Path.GetExtension(backupfilenamemask); if (string.IsNullOrWhiteSpace(backupfilenameext)) { backupfilenameext = ".sql"; } + backupfilenamemask = Path.GetFileNameWithoutExtension(backupfilenamemask); - if (!Directory.Exists(backupdirectorypath)) { Directory.CreateDirectory(backupdirectorypath); } - var directorynameonly = new DirectoryInfo(backupdirectorypath).Name; - var backupfilenameext = Path.GetExtension(backupfilenamemask); if (string.IsNullOrWhiteSpace(backupfilenameext)) { backupfilenameext = ".sql"; } - backupfilenamemask = Path.GetFileNameWithoutExtension(backupfilenamemask); + Server sqlserver = null; + try + { + sqlserver = SQLServerConnect(sqlcs);if (sqlserver == null) { return; } var sqldatabase = sqlserver.Databases[sqlserver.ConnectionContext.DatabaseName]; ScriptOneObject(sqlserver, tempbackupdirectorypath, backupfilenamemask + backupfilenameext, new List { sqldatabase }, vars); @@ -1335,11 +1751,11 @@ GO ScriptOneObject(sqlserver, tempbackupdirectorypath, backupfilenamemask + backupfilenameext, sqldatabase.Views.Cast().ToList(), vars); ScriptOneObject(sqlserver, tempbackupdirectorypath, backupfilenamemask + backupfilenameext, sqldatabase.Tables.Cast().ToList(), vars); ScriptOneObject(sqlserver, tempbackupdirectorypath, backupfilenamemask + backupfilenameext, sqldatabase.Triggers.Cast().ToList(), vars); - if (createZip) { ZipTools.CreateEntriesFromDirectoryContent(tempbackupdirectorypath, zipfilefullpath, "*.sql","", backupts,removearchivedfiles:true, storepathinzip: false); } + if (createZip) { ZipTools.CreateEntriesFromDirectoryContent(tempbackupdirectorypath, zipfilefullpath, "*.sql", "", backupts, removearchivedfiles: true, storepathinzip: false); } var resultfilename = zipfilefullpath == null ? "-" : Path.GetFileName(zipfilefullpath); ColorConsole.WriteLine($"SQL scripts created. DB name:'{dbname}'. BAK/ZIP file name:'{resultfilename}'", ConsoleColor.DarkGreen); } - else { ColorConsole.WriteLine($"SQL scripts create: error in db connection string. '{sqlcs}'", ConsoleColor.DarkGreen); } + finally { sqlserver?.ConnectionContext.SqlConnectionObject.Dispose(); } } private static void ScriptOneObject(Server sqlserver,string backupdirectory,string backupfilenamemask,List sqldbobjects,Dictionary vars) { @@ -1414,60 +1830,62 @@ GO return; } string sqlcs = sqld.SQLCS; - var sqlserver = SQLServerConnect(sqlcs); var dbname = GetDBName(sqlcs); - if (sqlserver != null) - { - string backupts = (timestamp.HasValue ? timestamp.Value : DateTime.Now).ToString("yyyyMMddHHmmss"); - bool createZip = sqld.Xml_CreateZip; - string backupdirectorypath = sqld.Xml_BackupTargetDirectoryPath; - string backupfilenamemask = sqld.Xml_BackupFileNameMask; - var backupfilenameext = Path.GetExtension(backupfilenamemask); if (string.IsNullOrWhiteSpace(backupfilenameext)) { backupfilenameext = ".sql"; } - backupfilenamemask = Path.GetFileNameWithoutExtension(backupfilenamemask); + string backupts = (timestamp.HasValue ? timestamp.Value : DateTime.Now).ToString("yyyyMMddHHmmss"); + bool createZip = sqld.Xml_CreateZip; + string backupdirectorypath = sqld.Xml_BackupTargetDirectoryPath; + string backupfilenamemask = sqld.Xml_BackupFileNameMask; - var vars = new Dictionary(); - vars.Add(nameof(DBSubstitutionName.DATABASE), GetDBName(sqlcs)); - vars.Add(nameof(DBSubstitutionName.DATASOURCE), GetDataSource(sqlcs)); - vars.Add(nameof(DBSubstitutionName.BACKUPTS), backupts); - vars.Add(nameof(DBSubstitutionName.DBOTYPE), "TableData"); - - string zipfilefullpath=null; - string tempbackupdirectorypath; - if (createZip) - { - vars[nameof(DBSubstitutionName.DBONAME)] = ""; - vars[nameof(DBSubstitutionName.DBDATAGROUP)] = ""; - string zipfilename = VRH.Common.StringConstructor.ResolveConstructorR(vars, backupfilenamemask, "{}@@") + ".zip"; - tempbackupdirectorypath = Path.Combine(backupdirectorypath, Path.GetRandomFileName()); - zipfilefullpath = Path.Combine(backupdirectorypath, zipfilename); - if (Directory.Exists(tempbackupdirectorypath)) { Directory.Delete(tempbackupdirectorypath, recursive: true); } - if (!Directory.Exists(tempbackupdirectorypath)) { Directory.CreateDirectory(tempbackupdirectorypath); } - } - else { tempbackupdirectorypath = backupdirectorypath; } + var backupfilenameext = Path.GetExtension(backupfilenamemask); if (string.IsNullOrWhiteSpace(backupfilenameext)) { backupfilenameext = ".sql"; } + backupfilenamemask = Path.GetFileNameWithoutExtension(backupfilenamemask); + + var vars = new Dictionary(); + vars.Add(nameof(DBSubstitutionName.DATABASE), GetDBName(sqlcs)); + vars.Add(nameof(DBSubstitutionName.DATASOURCE), GetDataSource(sqlcs)); + vars.Add(nameof(DBSubstitutionName.BACKUPTS), backupts); + vars.Add(nameof(DBSubstitutionName.DBOTYPE), "TableData"); + + string zipfilefullpath=null; + string tempbackupdirectorypath; + if (createZip) + { + vars[nameof(DBSubstitutionName.DBONAME)] = ""; + vars[nameof(DBSubstitutionName.DBDATAGROUP)] = ""; + string zipfilename = VRH.Common.StringConstructor.ResolveConstructorR(vars, backupfilenamemask, "{}@@") + ".zip"; + tempbackupdirectorypath = Path.Combine(backupdirectorypath, Path.GetRandomFileName()); + zipfilefullpath = Path.Combine(backupdirectorypath, zipfilename); + if (Directory.Exists(tempbackupdirectorypath)) { Directory.Delete(tempbackupdirectorypath, recursive: true); } + if (!Directory.Exists(tempbackupdirectorypath)) { Directory.CreateDirectory(tempbackupdirectorypath); } + } + else { tempbackupdirectorypath = backupdirectorypath; } - if (!Directory.Exists(backupdirectorypath)) { Directory.CreateDirectory(backupdirectorypath); } + if (!Directory.Exists(backupdirectorypath)) { Directory.CreateDirectory(backupdirectorypath); } - List backupfilepathlist = new List(); + List backupfilepathlist = new List(); + Server sqlserver = null; + try + { + sqlserver = SQLServerConnect(sqlcs);if (sqlserver == null) { return; } foreach (var sqldata in sqld.Xml_SQLDataList) { vars[nameof(DBSubstitutionName.DBDATAGROUP)] = sqldata.Group; - var sqlfilescreated = ScriptOneDataGroup(sqlserver, tempbackupdirectorypath, backupfilenamemask + backupfilenameext, sqldata.TableNameList, vars,out List errormessageList); + var sqlfilescreated = ScriptOneDataGroup(sqlserver, tempbackupdirectorypath, backupfilenamemask + backupfilenameext, sqldata.TableNameList, vars, out List errormessageList); backupfilepathlist.AddRange(sqlfilescreated); - if (errormessageList != null && errormessageList.Any()) { foreach (var emsg in errormessageList) { ColorConsole.WriteLine("\n"+emsg, ConsoleColor.Red); } } + if (errormessageList != null && errormessageList.Any()) { foreach (var emsg in errormessageList) { ColorConsole.WriteLine("\n" + emsg, ConsoleColor.Red); } } } + } + finally { sqlserver?.ConnectionContext.SqlConnectionObject.Dispose(); } - if (createZip) - { - string fullpathregex = Regex.Escape(string.Join(";",backupfilepathlist)).Replace(';','|'); - ZipTools.CreateEntriesFromDirectoryContent(tempbackupdirectorypath, zipfilefullpath, "*.sql","", fullpathregex, removearchivedfiles: true, storepathinzip: false); - } - var resultfilename = zipfilefullpath == null ? "-" : Path.GetFileName(zipfilefullpath); - ColorConsole.WriteLine($"SQL data scripts created. DB name:'{dbname}'. BAK/ZIP file name:'{resultfilename}'", ConsoleColor.DarkGreen); + if (createZip) + { + string fullpathregex = Regex.Escape(string.Join(";",backupfilepathlist)).Replace(';','|'); + ZipTools.CreateEntriesFromDirectoryContent(tempbackupdirectorypath, zipfilefullpath, "*.sql","", fullpathregex, removearchivedfiles: true, storepathinzip: false); } - else { ColorConsole.WriteLine($"SQL data scripts create: error in db connection string. '{sqlcs}'", ConsoleColor.DarkGreen); } + var resultfilename = zipfilefullpath == null ? "-" : Path.GetFileName(zipfilefullpath); + ColorConsole.WriteLine($"SQL data scripts created. DB name:'{dbname}'. BAK/ZIP file name:'{resultfilename}'", ConsoleColor.DarkGreen); } private static List ScriptOneDataGroup(Server sqlserver, string backupdirectorypath, string backupfilenamemask, List tablenamelist, Dictionary vars,out List errormessageList) { @@ -1562,8 +1980,7 @@ GO Xml_BackupFileNameMask = GetValue(nameof(SQLDataBase.XmlStructure.Attributes.BackupFileNameMask), this.RootElement, SQLDataBase.XmlStructure.Attributes.BackupFileNameMask.Values.DEFAULT), Xml_RestoreFileNameMask = GetValue(nameof(SQLDataBase.XmlStructure.Attributes.RestoreFileNameMask), this.RootElement, SQLDataBase.XmlStructure.Attributes.RestoreFileNameMask.Values.DEFAULT), Xml_BackupTargetDirectoryPath = GetValue(nameof(SQLDataBase.XmlStructure.Attributes.BackupTargetDirectoryPath), this.RootElement, SQLDataBase.XmlStructure.Attributes.BackupTargetDirectoryPath.Values.DEFAULT), - Xml_TranzitDirectoryPathLocal = GetValue(nameof(SQLDataBase.XmlStructure.Attributes.TranzitDirectoryPathLocal), this.RootElement, SQLDataBase.XmlStructure.Attributes.TranzitDirectoryPathLocal.Values.DEFAULT), - Xml_TranzitDirectoryPathNetwork = GetValue(nameof(SQLDataBase.XmlStructure.Attributes.TranzitDirectoryPathNetwork), this.RootElement, SQLDataBase.XmlStructure.Attributes.TranzitDirectoryPathNetwork.Values.DEFAULT), + Xml_TranzitDirectoryPath = GetValue(nameof(SQLDataBase.XmlStructure.Attributes.TranzitDirectoryPath), this.RootElement, SQLDataBase.XmlStructure.Attributes.TranzitDirectoryPath.Values.DEFAULT), Xml_PhysicalFilesDirectoryPath = GetValue(nameof(SQLDataBase.XmlStructure.Attributes.PhysicalFilesDirectoryPath), this.RootElement, SQLDataBase.XmlStructure.Attributes.PhysicalFilesDirectoryPath.Values.DEFAULT), Xml_ScriptCommandTimeout = GetValue(nameof(SQLDataBase.XmlStructure.Attributes.ScriptCommandTimeout), this.RootElement, SQLDataBase.XmlStructure.Attributes.ScriptCommandTimeout.Values.DEFAULT), }; @@ -1591,9 +2008,8 @@ GO public string Xml_BackupFileNameMask; public string Xml_RestoreFileNameMask; public string Xml_BackupTargetDirectoryPath; - public string Xml_TranzitDirectoryPathLocal; - public bool Xml_IsRemoteDB { get { return !string.IsNullOrWhiteSpace(Xml_TranzitDirectoryPathLocal); } } - public string Xml_TranzitDirectoryPathNetwork; + public bool Xml_IsRemoteDB { get { return !string.IsNullOrWhiteSpace(Xml_TranzitDirectoryPath); } } + public string Xml_TranzitDirectoryPath; public string Xml_SQLConnectionString; public string Xml_PhysicalFilesDirectoryPath; public int Xml_ScriptCommandTimeout; @@ -1625,8 +2041,7 @@ GO Xml_BackupFileNameMask = GetValue(nameof(XmlStructure.SQLDataBase.Attributes.BackupFileNameMask), sqldatabasexml, common.Xml_BackupFileNameMask); Xml_RestoreFileNameMask = GetValue(nameof(XmlStructure.SQLDataBase.Attributes.RestoreFileNameMask), sqldatabasexml, common.Xml_RestoreFileNameMask); Xml_BackupTargetDirectoryPath = GetValue(nameof(XmlStructure.SQLDataBase.Attributes.BackupTargetDirectoryPath), sqldatabasexml, common.Xml_BackupTargetDirectoryPath); - Xml_TranzitDirectoryPathLocal = GetValue(nameof(XmlStructure.SQLDataBase.Attributes.TranzitDirectoryPathLocal), sqldatabasexml, common.Xml_TranzitDirectoryPathLocal); - Xml_TranzitDirectoryPathNetwork = GetValue(nameof(XmlStructure.SQLDataBase.Attributes.TranzitDirectoryPathNetwork), sqldatabasexml, common.Xml_TranzitDirectoryPathNetwork); + Xml_TranzitDirectoryPath = GetValue(nameof(XmlStructure.SQLDataBase.Attributes.TranzitDirectoryPath), sqldatabasexml, common.Xml_TranzitDirectoryPath); Xml_SQLConnectionString = GetValue(nameof(XmlStructure.SQLDataBase.Attributes.SQLConnectionString), sqldatabasexml, XmlStructure.SQLDataBase.Attributes.SQLConnectionString.Values.DEFAULT); Xml_CreateZip = GetValue(nameof(XmlStructure.SQLDataBase.Attributes.CreateZip), sqldatabasexml, common.Xml_CreateZip); @@ -1654,8 +2069,7 @@ GO Xml_BackupFileNameMask = sqld.Xml_BackupFileNameMask; Xml_RestoreFileNameMask = sqld.Xml_RestoreFileNameMask; Xml_BackupTargetDirectoryPath = sqld.Xml_BackupTargetDirectoryPath; - Xml_TranzitDirectoryPathLocal = sqld.Xml_TranzitDirectoryPathLocal; - Xml_TranzitDirectoryPathNetwork = sqld.Xml_TranzitDirectoryPathNetwork; + Xml_TranzitDirectoryPath = sqld.Xml_TranzitDirectoryPath; Xml_SQLConnectionString = sqld.Xml_SQLConnectionString; Xml_PhysicalFilesDirectoryPath = sqld.Xml_PhysicalFilesDirectoryPath; Xml_SQLDataList = sqld.Xml_SQLDataList.Select(x => new SQLData(x)).ToList(); @@ -1670,8 +2084,7 @@ GO public static class BackupFileNameMask { public static class Values { public const string DEFAULT = ""; } } public static class RestoreFileNameMask { public static class Values { public const string DEFAULT = ""; } } public static class BackupTargetDirectoryPath { public static class Values { public const string DEFAULT = ""; } } - public static class TranzitDirectoryPathLocal { public static class Values { public const string DEFAULT = ""; } } - public static class TranzitDirectoryPathNetwork { public static class Values { public const string DEFAULT = ""; } } + public static class TranzitDirectoryPath { public static class Values { public const string DEFAULT = ""; } } public static class PhysicalFilesDirectoryPath { public static class Values { public const string DEFAULT = ""; } } public static class ScriptCommandTimeout { public static class Values { public const int DEFAULT = 10000; } } @@ -1688,8 +2101,7 @@ GO public static class BackupFileNameMask { } public static class RestoreFileNameMask { } public static class BackupTargetDirectoryPath { } - public static class TranzitDirectoryPathLocal { } - public static class TranzitDirectoryPathNetwork { } + public static class TranzitDirectoryPath { } public static class CreateZip { } public static class PhysicalFilesDirectoryPath { } public static class ScriptCommandTimeout { public static class Values { public const int DEFAULT = 10000; } } diff --git a/Vrh.Log4Pro.MaintenanceConsole/Manager - ScheduledTaskManager.cs b/Vrh.Log4Pro.MaintenanceConsole/Manager - ScheduledTaskManager.cs index 49f6c9d..663526b 100644 --- a/Vrh.Log4Pro.MaintenanceConsole/Manager - ScheduledTaskManager.cs +++ b/Vrh.Log4Pro.MaintenanceConsole/Manager - ScheduledTaskManager.cs @@ -77,7 +77,7 @@ namespace Vrh.Log4Pro.MaintenanceConsole.ScheduledTaskManagerNS ScheduledTaskManagerCore.SetPriority(st.Xml_Name,st.Xml_Priority); ColorConsole.WriteLine($"Priority changed for scheduled task. Name:{st.Xml_Name}", ConsoleColor.Green); } - catch (Exception ex) { ColorConsole.WriteLine(ex.Message, ConsoleColor.Red); } + catch (Exception ex) { ColorConsole.WriteLine(ex.MessageNested(), ConsoleColor.Red); } } return o; } @@ -104,7 +104,7 @@ namespace Vrh.Log4Pro.MaintenanceConsole.ScheduledTaskManagerNS ScheduledTaskManagerCore.DisableTask(st.Xml_Name); ColorConsole.WriteLine($"Scheduled task disabled. Name:{st.Xml_Name}", ConsoleColor.Green); } - catch (Exception ex) { ColorConsole.WriteLine(ex.Message, ConsoleColor.Red); } + catch (Exception ex) { ColorConsole.WriteLine(ex.MessageNested(), ConsoleColor.Red); } } return o; } @@ -131,7 +131,7 @@ namespace Vrh.Log4Pro.MaintenanceConsole.ScheduledTaskManagerNS ScheduledTaskManagerCore.EnableTask(st.Xml_Name); ColorConsole.WriteLine($"Scheduled task enabled. Name:{st.Xml_Name}", ConsoleColor.Green); } - catch (Exception ex){ ColorConsole.WriteLine(ex.Message, ConsoleColor.Red); } + catch (Exception ex){ ColorConsole.WriteLine(ex.MessageNested(), ConsoleColor.Red); } } return o; } @@ -158,7 +158,7 @@ namespace Vrh.Log4Pro.MaintenanceConsole.ScheduledTaskManagerNS ScheduledTaskManagerCore.EndTask(st.Xml_Name); ColorConsole.WriteLine($"Scheduled task stopped. Name:{st.Xml_Name}", ConsoleColor.Green); } - catch (Exception ex) { ColorConsole.WriteLine(ex.Message, ConsoleColor.Red); } + catch (Exception ex) { ColorConsole.WriteLine(ex.MessageNested(), ConsoleColor.Red); } } return o; } @@ -187,7 +187,7 @@ namespace Vrh.Log4Pro.MaintenanceConsole.ScheduledTaskManagerNS } catch (Exception ex) { - ColorConsole.WriteLine(ex.Message, ConsoleColor.Red); + ColorConsole.WriteLine(ex.MessageNested(), ConsoleColor.Red); } } return o; @@ -216,7 +216,7 @@ namespace Vrh.Log4Pro.MaintenanceConsole.ScheduledTaskManagerNS ScheduledTaskManagerCore.DeleteTask(st.Xml_Name); ColorConsole.WriteLine($"Scheduled task uninstalled. Name:{st.Xml_Name}", ConsoleColor.Green); } - catch (Exception ex) { ColorConsole.WriteLine(ex.Message, ConsoleColor.Red); } + catch (Exception ex) { ColorConsole.WriteLine(ex.MessageNested(), ConsoleColor.Red); } } return o; } @@ -245,7 +245,7 @@ namespace Vrh.Log4Pro.MaintenanceConsole.ScheduledTaskManagerNS ScheduledTaskManagerCore.CreateTask(st); ColorConsole.WriteLine($"Scheduled task installed. Name:{st.Xml_Name}", ConsoleColor.Green); } - catch (Exception ex) { ColorConsole.WriteLine(ex.Message, ConsoleColor.Red); } + catch (Exception ex) { ColorConsole.WriteLine(ex.MessageNested(), ConsoleColor.Red); } } return o; } diff --git a/Vrh.Log4Pro.MaintenanceConsole/Manager - UserManager.cs b/Vrh.Log4Pro.MaintenanceConsole/Manager - UserManager.cs index 8d5cb28..b746c23 100644 --- a/Vrh.Log4Pro.MaintenanceConsole/Manager - UserManager.cs +++ b/Vrh.Log4Pro.MaintenanceConsole/Manager - UserManager.cs @@ -94,7 +94,7 @@ namespace Vrh.Log4Pro.MaintenanceConsole.UserManagerNS ColorConsole.WriteLine($"Action:{cr.Type}, role names: {cr.Roles}.", ConsoleColor.Yellow); var sel = ColorConsole.ReadLine($"Press enter to continue.", ConsoleColor.Gray); if (sel.ToUpper() == "EX") return o; } - foreach (var rn in cr.RoleArray) { try { MembershipTools.Roles.Create(rn); } catch (Exception ex) { ColorConsole.WriteLine(ex.Message, ConsoleColor.Red); }; } + foreach (var rn in cr.RoleArray) { try { MembershipTools.Roles.Create(rn); } catch (Exception ex) { ColorConsole.WriteLine(ex.MessageNested(), ConsoleColor.Red); }; } } foreach (var cr in iab.GetCreateRoleGroupActions()) { @@ -107,7 +107,7 @@ namespace Vrh.Log4Pro.MaintenanceConsole.UserManagerNS { MembershipTools.RoleGroups.Create(cr.Name); MembershipTools.Assign.RolesToRoleGroups(cr.Roles, cr.Name); - } catch (Exception ex) { ColorConsole.WriteLine(ex.Message, ConsoleColor.Red); }; + } catch (Exception ex) { ColorConsole.WriteLine(ex.MessageNested(), ConsoleColor.Red); }; } foreach (var cr in iab.GetCreateUserActions()) @@ -122,11 +122,11 @@ namespace Vrh.Log4Pro.MaintenanceConsole.UserManagerNS { MembershipTools.Users.Create(cr.Name, cr.Password, administrator: false, superuser: cr.Superuser, rolenames: cr.RoleArray, rolegroupnames: cr.RoleGroupArray); } - catch (Exception ex) { ColorConsole.WriteLine(ex.Message, ConsoleColor.Red); }; + catch (Exception ex) { ColorConsole.WriteLine(ex.MessageNested(), ConsoleColor.Red); }; } ColorConsole.WriteLine($"Executing init action block '{iabname}' was successful!", ConsoleColor.Green); } - catch (Exception ex) { ColorConsole.WriteLine(ex.Message, ConsoleColor.Red); } + catch (Exception ex) { ColorConsole.WriteLine(ex.MessageNested(), ConsoleColor.Red); } return o; } #endregion ExecuteInitActionBlock @@ -144,7 +144,7 @@ namespace Vrh.Log4Pro.MaintenanceConsole.UserManagerNS MembershipTools.Users.Create(suname, supsw, superuser: true); ColorConsole.WriteLine($"Creating superuser '{suname}' was successful!", ConsoleColor.Green); } - catch (Exception ex) { ColorConsole.WriteLine(ex.Message, ConsoleColor.Red); } + catch (Exception ex) { ColorConsole.WriteLine(ex.MessageNested(), ConsoleColor.Red); } return o; } #endregion CreateSuperuser @@ -164,7 +164,7 @@ namespace Vrh.Log4Pro.MaintenanceConsole.UserManagerNS MembershipTools.Users.CreateAdminRolesRoleGroupsUsers(adminun,adminpsw); ColorConsole.WriteLine($"Creating admin users was successful!", ConsoleColor.Green); } - catch (Exception ex) { ColorConsole.WriteLine(ex.Message, ConsoleColor.Red); } + catch (Exception ex) { ColorConsole.WriteLine(ex.MessageNested(), ConsoleColor.Red); } return o; } #endregion CreateAdminusers @@ -184,7 +184,7 @@ namespace Vrh.Log4Pro.MaintenanceConsole.UserManagerNS } else { throw new Exception($"User '{uname}' is protected, can not be deleted!"); } } - catch (Exception ex) { ColorConsole.WriteLine(ex.Message, ConsoleColor.Red); } + catch (Exception ex) { ColorConsole.WriteLine(ex.MessageNested(), ConsoleColor.Red); } return o; } #endregion DeleteUsers diff --git a/Vrh.Log4Pro.MaintenanceConsole/Manager - WindowsServiceManager.cs b/Vrh.Log4Pro.MaintenanceConsole/Manager - WindowsServiceManager.cs index 8b0bf33..d0582c6 100644 --- a/Vrh.Log4Pro.MaintenanceConsole/Manager - WindowsServiceManager.cs +++ b/Vrh.Log4Pro.MaintenanceConsole/Manager - WindowsServiceManager.cs @@ -113,7 +113,7 @@ namespace Vrh.Log4Pro.MaintenanceConsole.WindowsServiceManagerNS var success = WindowsServiceManagerCore.Register(ws, selectedServices.Select(x => x.Name).ToList()); ColorConsole.WriteLine($"Service registered. Name:{ws.Name}", ConsoleColor.Green); } - catch (Exception ex) { ColorConsole.WriteLine(ex.Message, ConsoleColor.Red); } + catch (Exception ex) { ColorConsole.WriteLine(ex.MessageNested(), ConsoleColor.Red); } } break; case CLP.Module.WindowsServiceManager.Function.Unregister.KEY: @@ -124,7 +124,7 @@ namespace Vrh.Log4Pro.MaintenanceConsole.WindowsServiceManagerNS var success = WindowsServiceManagerCore.Unregister(ws); ColorConsole.WriteLine($"Service unregistered. Name:{ws.Name}", ConsoleColor.Green); } - catch (Exception ex) { ColorConsole.WriteLine(ex.Message, ConsoleColor.Red); } + catch (Exception ex) { ColorConsole.WriteLine(ex.MessageNested(), ConsoleColor.Red); } } break; case CLP.Module.WindowsServiceManager.Function.Start.KEY: @@ -135,7 +135,7 @@ namespace Vrh.Log4Pro.MaintenanceConsole.WindowsServiceManagerNS var success = WindowsServiceManagerCore.Start(ws.Name, ws.Xml_StartTimeout); ColorConsole.WriteLine($"Service started. Name:{ws.Name}", ConsoleColor.Green); } - catch (Exception ex) { ColorConsole.WriteLine(ex.Message, ConsoleColor.Red); } + catch (Exception ex) { ColorConsole.WriteLine(ex.MessageNested(), ConsoleColor.Red); } } break; case CLP.Module.WindowsServiceManager.Function.Stop.KEY: @@ -146,7 +146,7 @@ namespace Vrh.Log4Pro.MaintenanceConsole.WindowsServiceManagerNS var success = WindowsServiceManagerCore.Stop(ws.Name, ws.Xml_StopTimeout); ColorConsole.WriteLine($"Service stopped. Name:{ws.Name}", ConsoleColor.Green); } - catch (Exception ex) { ColorConsole.WriteLine(ex.Message, ConsoleColor.Red); } + catch (Exception ex) { ColorConsole.WriteLine(ex.MessageNested(), ConsoleColor.Red); } } break; case CLP.Module.WindowsServiceManager.Function.Dump.KEY: @@ -157,7 +157,7 @@ namespace Vrh.Log4Pro.MaintenanceConsole.WindowsServiceManagerNS var success = WindowsServiceManagerCore.Dump(ws.Name); ColorConsole.WriteLine($"Service dump completed. Name:{ws.Name}", ConsoleColor.Green); } - catch (Exception ex) { ColorConsole.WriteLine(ex.Message, ConsoleColor.Red); } + catch (Exception ex) { ColorConsole.WriteLine(ex.MessageNested(), ConsoleColor.Red); } } break; case CLP.Module.WindowsServiceManager.Function.Kill.KEY: @@ -168,7 +168,7 @@ namespace Vrh.Log4Pro.MaintenanceConsole.WindowsServiceManagerNS var success = WindowsServiceManagerCore.Kill(ws.Name); ColorConsole.WriteLine($"Service killed. Name:{ws.Name}", ConsoleColor.Green); } - catch (Exception ex) { ColorConsole.WriteLine(ex.Message, ConsoleColor.Red); } + catch (Exception ex) { ColorConsole.WriteLine(ex.MessageNested(), ConsoleColor.Red); } } break; case CLP.Module.WindowsServiceManager.Function.SetUserAccount.KEY: SetUserAccount(config, string.Join(",",selectedkeylist),forcecommandmode:true); break; @@ -265,7 +265,7 @@ namespace Vrh.Log4Pro.MaintenanceConsole.WindowsServiceManagerNS else { ColorConsole.WriteLine($"Service user account change FAILED! Name:{ws.Name}", ConsoleColor.Red); } } } - catch (Exception ex) { ColorConsole.WriteLine(ex.Message, ConsoleColor.Red); } + catch (Exception ex) { ColorConsole.WriteLine(ex.MessageNested(), ConsoleColor.Red); } } return; } @@ -567,11 +567,7 @@ namespace Vrh.Log4Pro.MaintenanceConsole.WindowsServiceManagerNS ColorConsole.WriteLine(startInfo.FileName + " " + startInfo.Arguments); using (Process exeProcess = Process.Start(startInfo)) { exeProcess.WaitForExit(); } } - catch (Exception ex) - { - ColorConsole.WriteLine(ex.Message); - if(ex.InnerException!=null) ColorConsole.WriteLine(ex.InnerException.Message); - } + catch (Exception ex) { ColorConsole.WriteLine(ex.MessageNested()); } return true; } private static string BuildArgumentListSetDescription(WindowsService ws, List dependencygroupservicenamelist) diff --git a/Vrh.Log4Pro.MaintenanceConsole/Program.cs b/Vrh.Log4Pro.MaintenanceConsole/Program.cs index e1bc149..df20ddf 100644 --- a/Vrh.Log4Pro.MaintenanceConsole/Program.cs +++ b/Vrh.Log4Pro.MaintenanceConsole/Program.cs @@ -92,6 +92,7 @@ namespace Vrh.Log4Pro.MaintenanceConsole ColorConsole.PressAnykeyToContinue(); } + public static ComputerInfo ThisComputer=null; } public static class TESTS { diff --git a/Vrh.Log4Pro.MaintenanceConsole/Properties/AssemblyInfo.cs b/Vrh.Log4Pro.MaintenanceConsole/Properties/AssemblyInfo.cs index c531fe8..3c45105 100644 --- a/Vrh.Log4Pro.MaintenanceConsole/Properties/AssemblyInfo.cs +++ b/Vrh.Log4Pro.MaintenanceConsole/Properties/AssemblyInfo.cs @@ -32,5 +32,5 @@ using System.Runtime.InteropServices; // You can specify all the values or you can default the Build and Revision Numbers // by using the '*' as shown below: // [assembly: AssemblyVersion("1.0.*")] -[assembly: AssemblyVersion("1.26.0.0")] -[assembly: AssemblyFileVersion("1.26.0.0")] +[assembly: AssemblyVersion("1.27.0.0")] +[assembly: AssemblyFileVersion("1.27.0.0")] diff --git a/Vrh.Log4Pro.MaintenanceConsole/Tools - Http.cs b/Vrh.Log4Pro.MaintenanceConsole/Tools - Http.cs index ab90753..90c0566 100644 --- a/Vrh.Log4Pro.MaintenanceConsole/Tools - Http.cs +++ b/Vrh.Log4Pro.MaintenanceConsole/Tools - Http.cs @@ -38,7 +38,7 @@ namespace Vrh.Log4Pro.MaintenanceConsole.ToolsNS { return mode == RequestType.GET? _GetReturninfoJSON(url, timeoutinseconds,out returninfojsonstring) : _PostReturninfoJSON(url, timeoutinseconds, out returninfojsonstring, dictparameterlist); } - catch (Exception ex) { return new ReturnInfoJSON() { ReturnValue = -1, ReturnMessage = ex.Message + "\n" + returninfojsonstring, }; } + catch (Exception ex) { return new ReturnInfoJSON() { ReturnValue = -1, ReturnMessage = ex.MessageNested() + "\n" + returninfojsonstring, }; } } private static ReturnInfoJSON _GetReturninfoJSON(string url, int timeoutinseconds, out string returninfojsonstring) diff --git a/Vrh.Log4Pro.MaintenanceConsole/Tools - Membership.cs b/Vrh.Log4Pro.MaintenanceConsole/Tools - Membership.cs index 0f76830..0f66cef 100644 --- a/Vrh.Log4Pro.MaintenanceConsole/Tools - Membership.cs +++ b/Vrh.Log4Pro.MaintenanceConsole/Tools - Membership.cs @@ -552,7 +552,7 @@ namespace Vrh.Log4Pro.MaintenanceConsole.ToolsNS catch (Exception ex) { result.ReturnValue = -1; - result.ReturnMessage = ex.Message; + result.ReturnMessage = ex.MessageNested(); } return result; } @@ -590,7 +590,7 @@ namespace Vrh.Log4Pro.MaintenanceConsole.ToolsNS catch (Exception ex) { result.ReturnValue = -1; - result.ReturnMessage = ex.Message; + result.ReturnMessage = ex.MessageNested(); } return result; } @@ -632,7 +632,7 @@ namespace Vrh.Log4Pro.MaintenanceConsole.ToolsNS catch (Exception ex) { result.ReturnValue = -1; - result.ReturnMessage = ex.Message; + result.ReturnMessage = ex.MessageNested(); } return result; } diff --git a/Vrh.Log4Pro.MaintenanceConsole/Tools.cs b/Vrh.Log4Pro.MaintenanceConsole/Tools.cs index a574108..0f76b1a 100644 --- a/Vrh.Log4Pro.MaintenanceConsole/Tools.cs +++ b/Vrh.Log4Pro.MaintenanceConsole/Tools.cs @@ -93,7 +93,8 @@ namespace Vrh.Log4Pro.MaintenanceConsole.ToolsNS { foreach (var zipentry in archive.Entries) { - zipentry.ExtractToFile(targetfilefullpath); + ColorConsole.WriteLine($"{nameof(Extract1stFileFromZIP)} extracting to file: {targetfilefullpath}", ConsoleColor.Yellow, prefix: ""); + zipentry.ExtractToFile(targetfilefullpath,true); return; } } @@ -103,9 +104,13 @@ namespace Vrh.Log4Pro.MaintenanceConsole.ToolsNS if (!Directory.Exists(targetdirectorypath)) { Directory.CreateDirectory(targetdirectorypath); } using (ZipArchive archive = ZipFile.Open(ZIPfilefullpath, ZipArchiveMode.Read)) { + ColorConsole.WriteLine(); foreach (var zipentry in archive.Entries) { - zipentry.ExtractToFile(Path.Combine(targetdirectorypath, zipentry.FullName)); + ColorConsole.SetCursorPosition(0, Console.CursorTop); + string targetfilefullpath = Path.Combine(targetdirectorypath, zipentry.FullName); + ColorConsole.WriteLine($"{nameof(Extract1stFileFromZIP)} extracting to file: {targetfilefullpath}", ConsoleColor.Yellow, prefix: ""); + zipentry.ExtractToFile(targetfilefullpath,true); } } } @@ -151,7 +156,7 @@ namespace Vrh.Log4Pro.MaintenanceConsole.ToolsNS catch (Exception ex) { ColorConsole.WriteLine($"Error when accessing/zipping file '{fi.FullName}'!", ConsoleColor.Red); - ColorConsole.WriteLine(ex.Message, ConsoleColor.Red,prefix: "Exception message: ", bracket:"[]"); + ColorConsole.WriteLine(ex.MessageNested(), ConsoleColor.Red,prefix: "Exception message: ", bracket:"[]"); } } cpt = ColorConsole.CursorTop; @@ -384,7 +389,7 @@ namespace Vrh.Log4Pro.MaintenanceConsole.ToolsNS public string OSServicePack; public string OSVersionString; public List OSFriendlyNames; - public static void DisplayThis() { new ComputerInfo().Display(); } + public static void DisplayThis() { Program.ThisComputer = Program.ThisComputer??new ComputerInfo(); Program.ThisComputer.Display(); } public ComputerInfo() { var ci = this; @@ -504,12 +509,14 @@ namespace Vrh.Log4Pro.MaintenanceConsole.ToolsNS string indent = ""; const string indentof1level = " "; Exception excl = ex; - while (true) + while (excl != null) { - rexmsg += indent + excl.Message; + if (!string.IsNullOrWhiteSpace(ex.Message)) + { + rexmsg += indent + excl.Message; + indent += (indent == "" ? "\n" : "") + indentof1level; + } excl = excl.InnerException; - indent += (indent==""?"\n":"")+indentof1level; - if (excl == null) { break; } } return rexmsg.Replace("\n\n","\n"); } -- libgit2 0.21.2