From 823fdecce96c38de2ff464853d649a798a3ea5ea Mon Sep 17 00:00:00 2001 From: Schwirg László Date: Mon, 22 Nov 2021 12:21:13 +0100 Subject: [PATCH] - MSMQ kezelés beépítése - elevated modra való automatikus átváltás - SYSTEM user-ként való indítási lehetőség beépítése --- Vrh.Log4Pro.MaintenanceConsole/ConsoleFunction - ColorConsole.cs | 11 ++++++----- Vrh.Log4Pro.MaintenanceConsole/ConsoleFunction - CommandLineParser.cs | 18 ++++++++++++++++++ Vrh.Log4Pro.MaintenanceConsole/ConsoleFunction - Menu.cs | 2 +- Vrh.Log4Pro.MaintenanceConsole/ConsoleFunction - Tools.cs | 48 ++++++++++++++++++++++++++++++++++++++++++++++++ Vrh.Log4Pro.MaintenanceConsole/Manager - MSMQManager.cs | 1044 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++------------------------------------------------------------ Vrh.Log4Pro.MaintenanceConsole/Manager - MaintenanceToolManager.cs | 6 ++++++ Vrh.Log4Pro.MaintenanceConsole/Program.cs | 5 +++++ Vrh.Log4Pro.MaintenanceConsole/Properties/AssemblyInfo.cs | 4 ++-- Vrh.Log4Pro.MaintenanceConsole/Vrh.Log4Pro.MaintenanceConsole.csproj | 3 +++ 9 files changed, 1073 insertions(+), 68 deletions(-) diff --git a/Vrh.Log4Pro.MaintenanceConsole/ConsoleFunction - ColorConsole.cs b/Vrh.Log4Pro.MaintenanceConsole/ConsoleFunction - ColorConsole.cs index 2aa80cf..bb0a745 100644 --- a/Vrh.Log4Pro.MaintenanceConsole/ConsoleFunction - ColorConsole.cs +++ b/Vrh.Log4Pro.MaintenanceConsole/ConsoleFunction - ColorConsole.cs @@ -139,7 +139,7 @@ namespace Vrh.Log4Pro.MaintenanceConsole.ColorConsoleNS string input; while (true) { - string prompt = text; + string prompt = ""; if (SilentMode) { if (readlineList == null || readlineList.Length == 0) { return null; } @@ -154,13 +154,14 @@ namespace Vrh.Log4Pro.MaintenanceConsole.ColorConsoleNS { if (validitylist != null && validitylist.Any()) { prompt += $" Valid values are {'\''+string.Join("','", validitylist)+'\''}."; } if (defaultvalue != null) { prompt += $" Default value is '{defaultvalue}'."; } - if (exitvalue != null) { prompt += $" Enter EX to exit."; } + if (exitvalue != null) { prompt += $" Enter '{exitvalue}' to exit."; } - Write(prompt, f, b, bracket, prefix, suffix); - input = Console.ReadLine(); + WriteLine(text, f, b, bracket, prefix, suffix); + if (prompt != null) { WriteLine(prompt); } + Write("-->"); input = Console.ReadLine(); if (defaultvalue!=null && (input == null || input == "")) { input = defaultvalue; } if (required && string.IsNullOrWhiteSpace(input)) { WriteLine($"Erroneous value!", ConsoleColor.Red); continue; } - if (exitvalue != null && input != null && input.ToLower() == exitvalue) { break; } + if (exitvalue != null && input != null && input.ToLower() == exitvalue.ToLower()) { break; } if (validitylist == null || !validitylist.Any() || string.IsNullOrWhiteSpace(input) || validitylist.Contains(input)) { break; } WriteLine($"Erroneous value!", ConsoleColor.Red); } diff --git a/Vrh.Log4Pro.MaintenanceConsole/ConsoleFunction - CommandLineParser.cs b/Vrh.Log4Pro.MaintenanceConsole/ConsoleFunction - CommandLineParser.cs index b921a80..1813de7 100644 --- a/Vrh.Log4Pro.MaintenanceConsole/ConsoleFunction - CommandLineParser.cs +++ b/Vrh.Log4Pro.MaintenanceConsole/ConsoleFunction - CommandLineParser.cs @@ -257,6 +257,23 @@ namespace Vrh.Log4Pro.MaintenanceConsole.CommandLineParserNS public static class ChangePriority { public const string KEY = "CHP"; } } } + public static class MSMQManager + { + public const string KEY = "MSQ"; + public static class Function + { + public const string CMD_TASKS = "-TASKS"; + public static class Create{ public const string KEY = "CRE"; } + public static class Remove { public const string KEY = "UIN"; } + public static class SetPermissions { public const string KEY = "PRM"; } + public static class SetDefaultPermissions { public const string KEY = "DPR"; } + public static class GetInfo { public const string KEY = "INF"; } + public static class Send { public const string KEY = "SND"; } + public static class Peek { public const string KEY = "PEK"; } + public static class Read{ public const string KEY = "RED"; } + public static class Purge { public const string KEY = "PRG"; } + } + } public static class BackupPackageManager { public const string KEY = "BAK"; @@ -301,6 +318,7 @@ namespace Vrh.Log4Pro.MaintenanceConsole.CommandLineParserNS public const string KEY = "TOL"; public static class Functions { + public static class StartAsSystem { public const string KEY = "SAS"; } public static class RegexTester { public const string KEY = "RGX"; } public static class TCPIPTester { public const string KEY = "TCP"; } public static class Tool { public const string KEY = "TOL"; } diff --git a/Vrh.Log4Pro.MaintenanceConsole/ConsoleFunction - Menu.cs b/Vrh.Log4Pro.MaintenanceConsole/ConsoleFunction - Menu.cs index 801a7ca..1cb1ddd 100644 --- a/Vrh.Log4Pro.MaintenanceConsole/ConsoleFunction - Menu.cs +++ b/Vrh.Log4Pro.MaintenanceConsole/ConsoleFunction - Menu.cs @@ -263,7 +263,7 @@ namespace Vrh.Log4Pro.MaintenanceConsole.MenuNS if (li > 0) { ColorConsole.Write(new string(' ', MenuItemIndentWidth)); } var str = (string)MenuItemDisplayer.Invoke(menuitem.Parameters, li); if (string.IsNullOrEmpty(str)) { ColorConsole.SetCursorPosition(0, ColorConsole.CursorTop); } - if (str == null) { break; } + if (str == null) { break; }//nincs több kiírandó sor } } } diff --git a/Vrh.Log4Pro.MaintenanceConsole/ConsoleFunction - Tools.cs b/Vrh.Log4Pro.MaintenanceConsole/ConsoleFunction - Tools.cs index 28ad7e0..5270d55 100644 --- a/Vrh.Log4Pro.MaintenanceConsole/ConsoleFunction - Tools.cs +++ b/Vrh.Log4Pro.MaintenanceConsole/ConsoleFunction - Tools.cs @@ -18,9 +18,57 @@ using System.Xml.Linq; using Vrh.Log4Pro.MaintenanceConsole.ColorConsoleNS; using VRH.Common; using Microsoft.Win32; +using System.Reflection; namespace Vrh.Log4Pro.MaintenanceConsole.ToolsNS { + public static class OtherTools + { + public static bool IsRunAsAdmin() + { + WindowsIdentity id = WindowsIdentity.GetCurrent(); + WindowsPrincipal pr = new WindowsPrincipal(id); + return pr.IsInRole(WindowsBuiltInRole.Administrator); + } + public static void StartAsAdmin() + { + if (!OtherTools.IsRunAsAdmin()) + { + ProcessStartInfo proc = new ProcessStartInfo(); + + proc.UseShellExecute = true; + proc.WorkingDirectory = Environment.CurrentDirectory; + proc.FileName = Assembly.GetEntryAssembly().CodeBase; + proc.Verb = "runas"; + try + { + Process.Start(proc); + System.Environment.Exit(1); + } + catch (Exception ex) + { + Console.WriteLine("This program must be run as an administrator! \n\n" + ex.ToString()); + } + } + } + + public static void StartAsSystem(bool silent) + { + if (!silent) + { + var ans = ColorConsole.ReadLine("NT AUTHORITY/SYSTEM", prefix: "Start as ",f:ConsoleColor.Yellow, suffix: "?", bracket: "[]",validitylist:new List { "yes","no"},exitvalue:"EX",defaultvalue:"NO"); + if (ans.ToLower() != "yes") { return; } + } + Process p = new System.Diagnostics.Process(); + p.StartInfo.FileName = @"C:\Log4ProIS\MAINTENANCECONSOLE\PsTools\psexec.exe"; + p.StartInfo.Arguments = @"-sid C:\Log4ProIS\MAINTENANCECONSOLE\Vrh.Log4Pro.MaintenanceConsole.exe"; + // The UseShellExecute flag must be turned off in order to supply a password: + p.StartInfo.UseShellExecute = false; + + p.Start(); + System.Environment.Exit(1); + } + } public static class ZipTools { public static void Extract1stFileFromZIP(string targetfilefullpath, string ZIPfilefullpath) diff --git a/Vrh.Log4Pro.MaintenanceConsole/Manager - MSMQManager.cs b/Vrh.Log4Pro.MaintenanceConsole/Manager - MSMQManager.cs index a0aa1ab..a542f5e 100644 --- a/Vrh.Log4Pro.MaintenanceConsole/Manager - MSMQManager.cs +++ b/Vrh.Log4Pro.MaintenanceConsole/Manager - MSMQManager.cs @@ -5,79 +5,1003 @@ using System.Messaging; using System.Text; using System.Threading.Tasks; -namespace Vrh.Log4Pro.MaintenanceConsole +using Vrh.Log4Pro.MaintenanceConsole.MenuNS; +using Vrh.Log4Pro.MaintenanceConsole.ColorConsoleNS; +using Vrh.Log4Pro.MaintenanceConsole.ToolsNS; +using Vrh.Log4Pro.MaintenanceConsole.CommandLineParserNS; + +using Vrh.XmlProcessing; +using VRH.Common; +using System.Xml.Linq; +using System.Text.RegularExpressions; + + +namespace Vrh.Log4Pro.MaintenanceConsole.MSMQManagerNS { - class Manager___MSMQManager + #region MSMQManager class + public static class MSMQManager { - void CreateQueue() + private const string XMLCONNECTIONSTRING = "config=MAINTENANCECONSOLE_MSMQMANAGER;"; + private const string XMLCONNECTIONSTRING_DEFAULT = "file=Config.Xml;element=MSMQManager;"; + + #region Execute + public static object Execute(object o1 = null, object o2 = null) + { + var args = (o1 as Menu.ExecutorParameter).Args; + var functionkey = CommandLine.GetCommandLineArgument(args, CLP.CMD_FUNCTION); + + var config = new MSMQManagerXmlProcessor(XMLCONNECTIONSTRING, "", "hu-HU"); + var ep = new Menu.ExecutorParameter(config, args); + var menufunctions = new Menu("Manage MS Message Queues", "Select the management function!") + .AddMenuItem(new Menu.Item(CLP.Module.MSMQManager.Function.Create.KEY, "Create MSMQ", Create, ep)) + .AddMenuItem(new Menu.Item(CLP.Module.MSMQManager.Function.Remove.KEY, "Remove MSMQ", Remove, ep)) + .AddMenuItem(new Menu.Item(CLP.Module.MSMQManager.Function.SetPermissions.KEY, "Set MSMQ permisssions", SetPermissions, ep)) + .AddMenuItem(new Menu.Item(CLP.Module.MSMQManager.Function.SetDefaultPermissions.KEY, "Set default MSMQ permisssions", SetDefaultPermissions, ep)) + .AddMenuItem(new Menu.Item(CLP.Module.MSMQManager.Function.GetInfo.KEY, "Get MSMQ information", GetInfo, ep)) + .AddMenuItem(new Menu.Item(CLP.Module.MSMQManager.Function.Peek.KEY, "Peek MSMQ message", Peek, ep)) + .AddMenuItem(new Menu.Item(CLP.Module.MSMQManager.Function.Read.KEY, "Read MSMQ message", Read, ep)) + .AddMenuItem(new Menu.Item(CLP.Module.MSMQManager.Function.Send.KEY, "Send MSMQ message", Send, ep)) + .AddMenuItem(new Menu.Item(CLP.Module.MSMQManager.Function.Purge.KEY, "Purge MSMQ", Purge, ep)) + .SetSelectionMode(Menu.SelectionMode.Single) + .SetMenuHeaderDisplayer(MSMQListDisplayer); + menufunctions.ExecuteMenu(functionkey); + return o2; + } + #endregion Execute + + #region First level Executors with UI + private static object Create(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 = DisplayMSMQMenu(config, $"Select the MSMQ(s) to manage with function '{nameof(Create)}'!", 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) + { + MSMQ st = p.Parameters as MSMQ; + try + { + var fullpath = MSMQManagerCore.CreateFullQueuePath(st.Xml_AddressPrefix, st.Xml_Server, st.Xml_Private, st.Xml_Name); + MSMQManagerCore.CreateQueue(fullpath, st.Xml_Label); + ColorConsole.WriteLine($"MSMQ:{st.Xml_Name} created.", ConsoleColor.Green); + foreach (var a in st.Xml_AccessRights) + { + MSMQManagerCore.SetPermissions(fullpath, a.un, a.ar, a.ac); + string ctrlstring = + a.ac == AccessControlEntryType.Allow ? "allowed" + : a.ac == AccessControlEntryType.Deny ? "denied" + : a.ac == AccessControlEntryType.Revoke ? "revoked" + : a.ac == AccessControlEntryType.Set ? "set" + : "???"; + ColorConsole.WriteLine($"Access right {a.ar} {ctrlstring} for user:{a.un}.", ConsoleColor.Green); + } + } + catch (Exception ex) { ColorConsole.WriteLine(ex.Message, ConsoleColor.Red); } + } + return o; + } + private static object Remove(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 = DisplayMSMQMenu(config, $"Select the MSMQ(s) to manage with function '{nameof(Remove)}'!", 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) + { + MSMQ st = p.Parameters as MSMQ; + try + { + var fullpath = MSMQManagerCore.CreateFullQueuePath(st.Xml_AddressPrefix, st.Xml_Server, st.Xml_Private, st.Xml_Name); + MSMQManagerCore.DeleteQueue(fullpath); + ColorConsole.WriteLine($"MSMQ:{st.Xml_Name} removed.", ConsoleColor.Green); + } + catch (Exception ex) { ColorConsole.WriteLine(ex.Message, ConsoleColor.Red); } + } + return o; + } + private static object SetDefaultPermissions(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 = DisplayMSMQMenu(config, $"Select the MSMQ(s) to manage with function '{nameof(SetDefaultPermissions)}'!", silent: true) + .SetSelectionMode(Menu.SelectionMode.Multi); + + 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) + { + MSMQ st = p.Parameters as MSMQ; + try + { + foreach (var a in st.Xml_AccessRights) + { + var fullpath = MSMQManagerCore.CreateFullQueuePath(st.Xml_AddressPrefix, st.Xml_Server, st.Xml_Private, st.Xml_Name); + MSMQManagerCore.SetPermissions(fullpath, a.un, a.ar, a.ac); + string ctrlstring = + a.ac == AccessControlEntryType.Allow ? "allowed" + : a.ac == AccessControlEntryType.Deny ? "denied" + : a.ac == AccessControlEntryType.Revoke ? "revoked" + : a.ac == AccessControlEntryType.Set ? "set" + : "???"; + ColorConsole.WriteLine($"Access right {a.ar} {ctrlstring} for user:{a.un}.", ConsoleColor.Green); + } + } + catch (Exception ex) { ColorConsole.WriteLine(ex.Message, ConsoleColor.Red); } + } + return o; + } + private static object SetPermissions(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 = DisplayMSMQMenu(config, $"Select the MSMQ(s) to manage with function '{nameof(SetPermissions)}'!", silent: true) + .SetSelectionMode(Menu.SelectionMode.Multi); + + 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 defaultusername = "Everyone"; + string defaultaccessrightsstring = nameof(MessageQueueAccessRights.FullControl); + string defaultcontroltypestring = nameof(AccessControlEntryType.Allow); + + while (true) + { + string username = ColorConsole.ReadLine("Enter username:", ConsoleColor.Yellow,defaultvalue:defaultusername); + if (username.ToUpper() == "EX") { break; } + + string accessrightsstring = ColorConsole.ReadLine("Enter access right:", ConsoleColor.Yellow, validitylist: Enum.GetNames(typeof(MessageQueueAccessRights)).Select(e=>e.ToString()).ToList(), defaultvalue: defaultaccessrightsstring); + if (accessrightsstring.ToUpper() == "EX") { break; } + var accessrights = (MessageQueueAccessRights)Enum.Parse(typeof(MessageQueueAccessRights),accessrightsstring); + + string controltypestring = ColorConsole.ReadLine("Enter access right:", ConsoleColor.Yellow, validitylist: Enum.GetNames(typeof(AccessControlEntryType)).Select(e => e.ToString()).ToList(), defaultvalue: defaultcontroltypestring); + if (controltypestring.ToUpper() == "EX") { break; } + var controltype = (AccessControlEntryType)Enum.Parse(typeof(AccessControlEntryType), controltypestring); + + foreach (var p in sr.SelectedParameterList) + { + MSMQ st = p.Parameters as MSMQ; + try + { + var fullpath = MSMQManagerCore.CreateFullQueuePath(st.Xml_AddressPrefix, st.Xml_Server, st.Xml_Private, st.Xml_Name); + 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); } + } + + defaultusername = username; + defaultaccessrightsstring = accessrightsstring; + defaultcontroltypestring = controltypestring; + } + return o; + } + private static object GetInfo(object parameter, object o) { - string ccs = @"localhost\private$\ljskskin"; - string msmqservername = ""; - bool msmqprivate = true; - string msmqname = ""; - string msmqFullname = msmqservername + "\\" + (msmqprivate ? "private$\\" : msmqname); - if (!MessageQueue.Exists(ccs)) { MessageQueue.Create(msmqFullname); } + 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 = DisplayMSMQMenu(config, $"Select the MSMQ(s) to manage with function '{nameof(GetInfo)}'!", silent: true) + .SetSelectionMode(Menu.SelectionMode.Multi); + + 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) + { + MSMQ st = p.Parameters as MSMQ; + ColorConsole.Write($">>> MSMQ detailed info collected for ", ConsoleColor.Yellow); + ColorConsole.Write($"{st.QueueName}", ConsoleColor.Yellow,suffix:", ",prefix: " QueueName : "); + ColorConsole.Write($"{st.MachineName}", ConsoleColor.Yellow,prefix: "MachineName: "); + ColorConsole.WriteLine(); + var qqn = MSMQManagerCore.CreateQualifiedQueueName(st.Xml_AddressPrefix, st.Xml_Server,st.Xml_Private, st.Xml_Name); + var qexists = MSMQManagerCore.CheckIfQueueExists(st.Xml_Server, qqn); + if (!qexists) + { + ColorConsole.WriteLine($" Queue does not exist!", ConsoleColor.Red); + } + else + { + try + { + st = MSMQManagerCore.CollectMSMQInfo(st); + ColorConsole.WriteLine($"{st.Status}", ConsoleColor.Green,prefix: $" Status: "); + ColorConsole.WriteLine($"{st.StatusDescription}", ConsoleColor.Green,prefix:" StatusDescription: "); + ColorConsole.WriteLine($"{st.Id}", ConsoleColor.Green,prefix: " Id: "); + ColorConsole.WriteLine($"{st.Label}", ConsoleColor.Green,prefix: " Label: "); + ColorConsole.WriteLine($"{st.Path}", ConsoleColor.Green,prefix: " Path: "); + ColorConsole.WriteLine($"{st.FormatName}", ConsoleColor.Green,prefix: " FormatName: "); + ColorConsole.Write($"{st.Transactional}", ConsoleColor.Green, prefix: " Transactional: ",suffix: ", "); + ColorConsole.Write($"{st.UseJournalQueue}", ConsoleColor.Green, suffix: ", ",prefix: "UseJournalQueue: "); + ColorConsole.Write($"{st.AccessMode}", ConsoleColor.Green,suffix:", ",prefix: "AccessMode: "); + ColorConsole.Write($"{st.CanRead}", ConsoleColor.Green, suffix: ", ",prefix: "CanRead: "); + ColorConsole.Write($"{st.CanWrite}", ConsoleColor.Green, suffix: ", ",prefix: "CanWrite: "); + ColorConsole.WriteLine(); + ColorConsole.Write($"{st.Authenticate}", ConsoleColor.Green, suffix: ", ",prefix: " Authenticate: "); + ColorConsole.Write($"{st.BasePriority}", ConsoleColor.Green, suffix: ", ",prefix: "BasePriority: "); + ColorConsole.Write($"{st.EncryptionRequired}", ConsoleColor.Green, suffix: ", ",prefix: "EncryptionRequired: "); + ColorConsole.WriteLine(); + ColorConsole.Write($"{st.Formatter}", ConsoleColor.Green, suffix: ", ",prefix: " Formatter: "); + ColorConsole.Write($"{st.LastModifyTime}", ConsoleColor.Green, suffix: ", ",prefix: "LastModifyTime: "); + ColorConsole.WriteLine(); + ColorConsole.Write($"{st.NumOfMessages}", ConsoleColor.Green, suffix: ", ",prefix: " NumOfMessages: "); + ColorConsole.Write($"{st.MaximumJournalSize}", ConsoleColor.Green, suffix: ", ",prefix: "MaximumJournalSize: "); + ColorConsole.Write($"{st.MaximumQueueSize}", ConsoleColor.Green, suffix: ", ",prefix: "MaximumQueueSize: "); + ColorConsole.WriteLine(); + } + catch (Exception ex) { ColorConsole.WriteLine(" "+ex.Message, ConsoleColor.Red); } + } + } + return o; } - void DeleteQueue() + private static object Peek(object parameter, object o) { - string ccs = @"localhost\private$\ljskskin"; - if (MessageQueue.Exists(ccs)) { MessageQueue.Delete(ccs); } + 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 = DisplayMSMQMenu(config, $"Select the MSMQ(s) to manage with function '{nameof(Peek)}'!", silent: true) + .SetSelectionMode(Menu.SelectionMode.Single); + + 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) + { + MSMQ st = p.Parameters as MSMQ; + try + { + var fullpath = MSMQManagerCore.CreateFullQueuePath(st.Xml_AddressPrefix, st.Xml_Server, st.Xml_Private, st.Xml_Name); + MSMQManagerCore.Peek(fullpath, out string msgbody, out string msglabel); + ColorConsole.WriteLine($"Message peeked from MSMQ:{st.Xml_Name}", ConsoleColor.Green); + ColorConsole.WriteLine($" Body: {msgbody}", ConsoleColor.Yellow); + ColorConsole.WriteLine($" Label: {msglabel}", ConsoleColor.Yellow); + } + catch (Exception ex) + { + ColorConsole.WriteLine(ex.Message, ConsoleColor.Red); + } + } + return o; } - void Purge() + private static object Read(object parameter, object o) { - string ccs = @"localhost\private$\ljskskin"; - var msmq = new MessageQueue(ccs); - msmq.Purge(); + 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 = DisplayMSMQMenu(config, $"Select the MSMQ(s) to manage with function '{nameof(Read)}'!", silent: true) + .SetSelectionMode(Menu.SelectionMode.Single); + + 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) + { + MSMQ st = p.Parameters as MSMQ; + try + { + var messageformatter = new ActiveXMessageFormatter(); + var encoding = Encoding.UTF8; + var fullpath = MSMQManagerCore.CreateFullQueuePath(st.Xml_AddressPrefix, st.Xml_Server, st.Xml_Private, st.Xml_Name); + MSMQManagerCore.Read(fullpath, messageformatter, encoding, out string msgbody, out string msglabel); + ColorConsole.WriteLine($"Message read from MSMQ:{st.Xml_Name}", ConsoleColor.Green); + ColorConsole.WriteLine($" Body: {msgbody}", ConsoleColor.Yellow); + ColorConsole.WriteLine($" Label: {msglabel}", ConsoleColor.Yellow); + } + catch (Exception ex) + { + ColorConsole.WriteLine(ex.Message, ConsoleColor.Red); + } + } + return o; } - void Peek() + private static object Send(object parameter, object o) { - string ccs = @"localhost\private$\ljskskin"; - var msmq = new MessageQueue(ccs); + 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 = DisplayMSMQMenu(config, $"Select the MSMQ(s) to manage with function '{nameof(Send)}'!", silent: true) + .SetSelectionMode(Menu.SelectionMode.Single); - Message m = msmq.Peek(new TimeSpan(0)); - m.BodyStream.Position = 0; - var sr = new System.IO.StreamReader(m.BodyStream); - var label = m.Label; - var body = sr.ReadToEnd().Replace(((char)0).ToString(), ""); - } - void Read() - { - string ccs = @"localhost\private$\ljskskin"; - var msmq = new MessageQueue(ccs); - var frmA = new System.Messaging.ActiveXMessageFormatter(); - var frmB = new System.Messaging.BinaryMessageFormatter(); - var frmX = new System.Messaging.XmlMessageFormatter(); - msmq.Formatter = frmA; + 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) + { + MSMQ st = p.Parameters as MSMQ; + while (true) + { + try + { + var now = DateTime.Now.ToString(); + string messagebody = ColorConsole.ReadLine("Enter message body:", ConsoleColor.Yellow, defaultvalue: "TEST MESSAGE " + now); + if (messagebody.ToUpper() == "EX") { break; } + + string messagelabel = ColorConsole.ReadLine("Enter message label:", ConsoleColor.Yellow, defaultvalue: "TESTLABEL" + now); + if (messagelabel.ToUpper() == "EX") { break; } + + string messageformatterstring = ColorConsole.ReadLine("Enter encoding:", ConsoleColor.Yellow, validitylist: MSMQManagerCore.GetFormatterNames(), defaultvalue: st.Xml_Formatter); + if (messageformatterstring.ToUpper() == "EX") { break; } + var messageformatter = MSMQManagerCore.SetFormatter(messageformatterstring); + if (messageformatter == null) { var exmsg = $"Message formatter value is incorrect! Value:{st.Xml_Formatter}."; throw new ApplicationException(exmsg); } + + string encodingstring = ColorConsole.ReadLine("Enter encoding:", ConsoleColor.Yellow, validitylist: MSMQManagerCore.GetEncodingNames(), defaultvalue: st.Xml_Encoding); + if (encodingstring.ToUpper() == "EX") { break; } + var encoding = MSMQManagerCore.SetEncoding(encodingstring); + if (encoding == null) { var exmsg = $"Message encoder value is incorrect! Value:{st.Xml_Encoding}."; throw new ApplicationException(exmsg); } + + var fullpath = MSMQManagerCore.CreateFullQueuePath(st.Xml_AddressPrefix, st.Xml_Server, st.Xml_Private, st.Xml_Name); + MSMQManagerCore.Send(fullpath, messagebody, messagelabel, messageformatter, encoding); + 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); } + } + } + return o; + } + private static object Purge(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 = DisplayMSMQMenu(config, $"Select the MSMQ(s) to manage with function '{nameof(Purge)}'!", 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) + { + MSMQ st = p.Parameters as MSMQ; + try + { + var fullpath = MSMQManagerCore.CreateFullQueuePath(st.Xml_AddressPrefix, st.Xml_Server, st.Xml_Private, st.Xml_Name); + MSMQManagerCore.Purge(fullpath); + ColorConsole.WriteLine($"MSMQ messages purged. Name:{st.Xml_Name}", ConsoleColor.Green); + } + catch (Exception ex) { ColorConsole.WriteLine(ex.Message, ConsoleColor.Red); } + } + return o; + } + #endregion First level Executors with UI + + #region private methods + #region private DisplayTasks + private static void MSMQListDisplayer() { DisplayMSMQMenu(); } + private static Menu DisplayMSMQMenu(MSMQManagerXmlProcessor config = null, string prompt = null, bool silent = false) + { + if (config == null) { config = new MSMQManagerXmlProcessor(XMLCONNECTIONSTRING, "", "hu-HU"); } + List msmqdefList = config.GetDefinitionList(); + var menufct = new Menu("Scheduled tasks", prompt) + .SetMenuItemDisplayer(DisplayMSMQInfo) + .SetSelectionMode(Menu.SelectionMode.Multi); + menufct.ClearMenuItemList(); + foreach (var msmqdef in msmqdefList) + { + var st = MSMQManagerCore.CollectMSMQInfo(msmqdef); + menufct.AddMenuItem(new Menu.Item(msmqdef.Xml_Key, null, null, new Menu.ExecutorParameter(pars: st))); + } + if (!silent) { menufct.DisplayItems(1); } + return menufct; + } + #endregion private DisplayTasks + #region private method: DisplayTaskInfo + private static object DisplayMSMQInfo(object obj, int lineix) + { + MSMQ st = (obj as Menu.ExecutorParameter).Parameters as MSMQ; + if (lineix == 0) + { + ColorConsole.Write($"{st.Xml_Name}", ConsoleColor.Black, ConsoleColor.White,prefix: "Queue '",suffix: $"' queue label: '{st.Xml_Label}'."); + ConsoleColor statuscolor; + if (st.Status == "Uninstalled") { statuscolor = ConsoleColor.Red; } + else if (st.Status == "Error") { statuscolor = ConsoleColor.Red; } + else if (st.Status == "Installed") { statuscolor = ConsoleColor.Yellow; } + else if (st.Status == "Ready") { statuscolor = ConsoleColor.Green; } + else { statuscolor = ConsoleColor.Red; } + ColorConsole.Write(st.Status, statuscolor, bracket: "[]", prefix: " ", suffix: ". "); + ColorConsole.WriteLine(); + return " "; + } + else if (lineix == 1) + { + var privatepublictext = st.Xml_Private ? "private" : "public"; + ColorConsole.Write($"{st.Xml_AddressPrefix}{st.Xml_Server}", ConsoleColor.Black, ConsoleColor.White, prefix: "Server:", suffix: $"Queue is { privatepublictext }."); + ColorConsole.WriteLine(); + return " "; + } + else if (lineix == 2) + { + ColorConsole.Write($"{st.Path}", ConsoleColor.Yellow, prefix: "Path ", suffix: ", "); + ColorConsole.WriteLine(); + return " "; + } + else if (lineix == 3) + { + if (st.StatusDescription != null) + { + ConsoleColor color = ConsoleColor.Yellow; + if (st.Status == "Ready") { color = ConsoleColor.Green; } + else if (st.Status == "Error") { color = ConsoleColor.Red; } + ColorConsole.Write($"{st.StatusDescription}", color, prefix: "Status description "); + ColorConsole.WriteLine(); + return " "; + } + return "";//empty=van még szöveg, de most nem történt kiírás + } + else if (lineix == 4) + { + if (st.Status == "Ready") + { + ColorConsole.Write($"{st.FormatName}", ConsoleColor.Yellow, prefix: "FormatName "); + ColorConsole.WriteLine(); + return " "; + } + return ""; + } + else if (lineix == 5) + { + if (st.Status == "Ready") + { + ColorConsole.Write(st.NumOfMessages.ToString(), ConsoleColor.Yellow, prefix: "Num.of msgs in queue ", suffix: ". "); + ColorConsole.Write($"{st.LastModifyTime}", ConsoleColor.Yellow, prefix: "LastModified ", suffix: ", "); + ColorConsole.WriteLine(); + return " "; + } + return ""; + } + else if (lineix == 6) + { + if (st.Status == "Ready") + { + ColorConsole.Write($"{st.AccessMode}", ConsoleColor.Yellow, prefix: "AccessMode ", suffix: ", "); + ColorConsole.Write($"{st.CanRead}", ConsoleColor.Yellow, prefix: "CanRead ", suffix: ", "); + ColorConsole.Write($"{st.CanWrite}", ConsoleColor.Yellow, prefix: "CanWrite ", suffix: ", "); + ColorConsole.WriteLine(); + return " "; + } + return ""; + } + return null; + } + #endregion private method: DisplayTaskInfo + #endregion private methods + } + #endregion MSMQManager class + + #region MSMQManagerCore class + internal static class MSMQManagerCore + { + public static string CreateFullQueuePath(string addressprefix, string msmqservername, bool msmqprivate, string msmqname) + { + CreateQueueNames(addressprefix, msmqservername, msmqprivate, msmqname, out string qqn, out string qfn); + return qfn; + } + public static string CreateQualifiedQueueName(string addressprefix, string msmqservername, bool msmqprivate, string msmqname) + { + CreateQueueNames(addressprefix, msmqservername, msmqprivate, msmqname, out string qqn, out string qfn); + return qqn; + } + private static void CreateQueueNames(string addressprefix, string msmqservername, bool msmqprivate, string msmqname,out string queuequalifiedname, out string msmqFullname) + { + var msmqprivatenamepart = msmqprivate ? "private$\\" : ""; + if (msmqservername == "." || msmqservername.ToLower() == "localhost") { msmqservername = System.Environment.MachineName; } + var msmqservernamepart = string.IsNullOrWhiteSpace(msmqservername) ? "" : $"{msmqservername}\\"; + addressprefix = string.IsNullOrWhiteSpace(addressprefix) ? "" : addressprefix; + msmqFullname = $"{addressprefix}{msmqservernamepart}{msmqprivatenamepart}{msmqname}"; + queuequalifiedname = $"{msmqprivatenamepart}{msmqname}"; + } + public static bool CheckIfQueueExists(string servername,string queuefullname) + { + if (string.IsNullOrWhiteSpace(servername) || servername == "." || servername.ToLower() == "localhost") { servername = System.Environment.MachineName; } + var queuearray = System.Messaging.MessageQueue.GetPrivateQueuesByMachine(servername); + foreach (var q in queuearray) + { + if (q.Path.ToLower().Contains(queuefullname.ToLower()) && q.FormatName.ToLower().Contains(queuefullname.ToLower()) && queuefullname.ToLower().Contains(q.QueueName.ToLower())) { return true; } + } + return false; + //var queuenamelist = queuearray.Select(q => q.Path == queuefullname || q.FormatName== queuefullname || q.QueueName== queuefullname).ToList(); + //return queuenamelist.Any(); + } + public static MSMQ CollectMSMQInfo(MSMQ msmgqef) + { + string msmqaddressprefix = msmgqef.Xml_AddressPrefix; + string msmqservername = msmgqef.Xml_Server; + bool msmqprivate = msmgqef.Xml_Private; + string msmqname = msmgqef.Xml_Name; + var msmqprivatenamepart = msmqprivate ? "private$\\" : ""; + string msmqFullname = $"{msmqaddressprefix}{msmqservername}\\{msmqprivatenamepart}{msmqname}"; + msmgqef.QueueName = msmqname ; + msmgqef.MachineName = msmqservername; + msmgqef.Path = msmqFullname; + try + { + msmgqef.Status = MessageQueue.Exists(msmqFullname) ? "Installed" : "Uninstalled"; + if (msmgqef.Status == "Installed") + { + using (var msmq = new MessageQueue(msmqFullname)) + { + msmgqef.QueueName = msmq.QueueName; + msmgqef.MachineName = msmq.MachineName; + + msmgqef.Id = msmq.Id; + msmgqef.NumOfMessages = MSMQManagerCore.Count(msmq); + msmgqef.Label = msmq.Label; + msmgqef.Formatter = msmq.Formatter; + msmgqef.FormatName = msmq.FormatName; + msmgqef.Path = msmq.Path; + msmgqef.LastModifyTime = msmq.LastModifyTime; + msmgqef.AccessMode = msmq.AccessMode; + msmgqef.CanRead = msmq.CanRead; + msmgqef.CanWrite = msmq.CanWrite; + msmgqef.MaximumQueueSize = msmq.MaximumQueueSize; + msmgqef.UseJournalQueue = msmq.UseJournalQueue; + msmgqef.MaximumJournalSize = msmq.MaximumJournalSize; + + msmgqef.Transactional = msmq.Transactional; + msmgqef.Authenticate = msmq.Authenticate; + msmgqef.BasePriority = msmq.BasePriority; + msmgqef.EncryptionRequired = msmq.EncryptionRequired; + + msmgqef.Status = "Ready"; + } + } + } + catch (Exception ex) { msmgqef.Status = "Error"; msmgqef.StatusDescription = ex.Message + (ex.InnerException!=null? ("\n" + ex.InnerException.Message):""); } + return msmgqef; + } + public static void CreateQueue(string msmqFullname, string label=null) + { + if (!MessageQueue.Exists(msmqFullname)) { MessageQueue.Create(msmqFullname); } + using (var msmq = new MessageQueue(msmqFullname)) + { + if (!string.IsNullOrWhiteSpace(label)) { msmq.Label = label; } + } + } + public static void SetPermissions(string msmqFullname,string username, MessageQueueAccessRights accessrights, AccessControlEntryType controltype) + { + using (var msmq = new MessageQueue(msmqFullname)) + { + //controltype=AccessControlEntryType.Allow; + //accessrights = MessageQueueAccessRights.FullControl; + //accessrights = MessageQueueAccessRights.SetQueueProperties + // | MessageQueueAccessRights.GenericRead + // | MessageQueueAccessRights.ChangeQueuePermissions + // | MessageQueueAccessRights.GetQueuePermissions + // | MessageQueueAccessRights.TakeQueueOwnership + // | MessageQueueAccessRights.GenericWrite + // | MessageQueueAccessRights.DeleteJournalMessage + // | MessageQueueAccessRights.WriteMessage + // | MessageQueueAccessRights.DeleteMessage + // | MessageQueueAccessRights.GetQueueProperties + // | MessageQueueAccessRights.PeekMessage + // | MessageQueueAccessRights.ReceiveJournalMessage + // | MessageQueueAccessRights.ReceiveMessage + // | MessageQueueAccessRights.SetQueueProperties + // | MessageQueueAccessRights.DeleteQueue; + msmq.SetPermissions("EveryOne", accessrights, controltype); + } + } + + public static void DeleteQueue(string msmqFullname) + { + if (MessageQueue.Exists(msmqFullname)) { MessageQueue.Delete(msmqFullname); } + } + public static void Purge(string msmqFullname) + { + using (var msmq = new MessageQueue(msmqFullname)) + { + msmq.Purge(); + } + } + public static void Peek(string msmqFullname, out string body, out string label) + { + using (var msmq = new MessageQueue(msmqFullname)) + { + Message m = msmq.Peek(new TimeSpan(0)); + m.BodyStream.Position = 0; + var sr = new System.IO.StreamReader(m.BodyStream); + label = m.Label; + body = sr.ReadToEnd().Replace(((char)0).ToString(), ""); + } + } + public static void Read(string msmqFullname, IMessageFormatter messageformatter, Encoding encoding, out string body, out string label) + { + using (var msmq = new MessageQueue(msmqFullname)) + { + //frmA = new System.Messaging.ActiveXMessageFormatter(); + //frmA = new System.Messaging.BinaryMessageFormatter(); + //frmA = new System.Messaging.XmlMessageFormatter(); + msmq.Formatter = messageformatter; + + Message m = msmq.Receive(new TimeSpan(0)); + m.BodyStream.Position = 0; + + // encoding = System.Text.Encoding.UTF8; + // encoding = System.Text.Encoding.UTF7; + // encoding = System.Text.Encoding.UTF32; + // encoding = System.Text.Encoding.Unicode; + // encoding = System.Text.Encoding.BigEndianUnicode; + // encoding = System.Text.Encoding.ASCII; + // encoding = System.Text.Encoding.Default; + var sr = new System.IO.StreamReader(m.BodyStream, encoding); + label = m.Label; + body = sr.ReadToEnd().Replace(((char)0).ToString(), ""); + } + } + public static void Send(string msmqFullname, string messagetosend, string messagelabel, IMessageFormatter messageformatter, Encoding encoding) + { + using (var msmq = new MessageQueue(msmqFullname)) + { + ///frmA = new System.Messaging.ActiveXMessageFormatter(); + //enc = System.Text.Encoding.UTF8; + msmq.Formatter = messageformatter; + byte[] encodedmessage = encoding.GetBytes(messagetosend); + + msmq.Send(encodedmessage, messagelabel); + } + } + public static long Count(MessageQueue messageQueue) + { + var enumerator = messageQueue.GetMessageEnumerator2(); + long counter = 0; + while (enumerator.MoveNext()) + { + counter++; + } + return counter; + } + public static IMessageFormatter SetFormatter(string formattername) + { + switch (formattername) + { + case nameof(MSMQ.XmlStructure.MSMQManager.MessageQueues.MessageQueue.Attributes.Formatter.Values.ActiveXMessageFormatter): return new ActiveXMessageFormatter(); + case nameof(MSMQ.XmlStructure.MSMQManager.MessageQueues.MessageQueue.Attributes.Formatter.Values.BinaryMessageFormatter): return new BinaryMessageFormatter(); + case nameof(MSMQ.XmlStructure.MSMQManager.MessageQueues.MessageQueue.Attributes.Formatter.Values.XmlMessageFormatter): return new XmlMessageFormatter(); + default: return null; + } + } + public static List GetFormatterNames() + { + var r = new List(); + r.Add(nameof(MSMQ.XmlStructure.MSMQManager.MessageQueues.MessageQueue.Attributes.Formatter.Values.ActiveXMessageFormatter)); + r.Add(nameof(MSMQ.XmlStructure.MSMQManager.MessageQueues.MessageQueue.Attributes.Formatter.Values.BinaryMessageFormatter)); + r.Add(nameof(MSMQ.XmlStructure.MSMQManager.MessageQueues.MessageQueue.Attributes.Formatter.Values.XmlMessageFormatter)); + return r; + } + public static Encoding SetEncoding(string formattername) + { + switch (formattername) + { + case nameof(Encoding.UTF8): return Encoding.UTF8; + case nameof(Encoding.UTF7): return Encoding.UTF7; + case nameof(Encoding.BigEndianUnicode): return Encoding.BigEndianUnicode; + case nameof(Encoding.Unicode): return Encoding.Unicode; + case nameof(Encoding.ASCII): return Encoding.ASCII; + case nameof(Encoding.UTF32): return Encoding.UTF32; + case nameof(Encoding.Default): return Encoding.Default; + default: return null; + } + } + public static List GetEncodingNames() + { + var r = new List(); + r.Add(nameof(Encoding.UTF8)); + r.Add(nameof(Encoding.UTF7)); + r.Add(nameof(Encoding.UTF32)); + r.Add(nameof(Encoding.BigEndianUnicode)); + r.Add(nameof(Encoding.Unicode)); + r.Add(nameof(Encoding.ASCII)); + r.Add(nameof(Encoding.Default)); + return r; + } + } + #endregion MSMQManagerCore class + + #region MSMQManagerXmlProcessor class + public class MSMQManagerXmlProcessor : XmlParser + { + private List _msmqlist; + #region constructor + public MSMQManagerXmlProcessor(string xmlcs, string basefolder, string lcid) : base(xmlcs, basefolder, lcid, null) + { + _msmqlist = new List(); + var msmqxmllist = GetAllXElements(nameof(MSMQ.XmlStructure.MSMQManager.MessageQueues), nameof(MSMQ.XmlStructure.MSMQManager.MessageQueues.MessageQueue)); + if (msmqxmllist != null && msmqxmllist.Any()) + { + foreach (var msmqxml in msmqxmllist) { var st = new MSMQ(msmqxml, new MSMQDefaults(RootElement)); if (st.Valid) { _msmqlist.Add(st); } } + } + } + #endregion constructor + #region GetDefinitionList + public List GetDefinitionList() { return _msmqlist; } + #endregion GetDefinitionList + } + #endregion MSMQManagerXmlProcessor class + + #region Defaults class + public class AccessRights : XmlLinqBase + { + public static AccessRights Factory(XElement arxml) + { + try + { + var r = new AccessRights(); + r.un = r.GetValue(nameof(MSMQ.XmlStructure.MSMQManager.General.AccessRights.AccessRight.Attributes.Username), arxml, MSMQ.XmlStructure.MSMQManager.General.AccessRights.AccessRight.Attributes.Username.Values.DEFAULT); + r.ar = (MessageQueueAccessRights)Enum.Parse(typeof(MessageQueueAccessRights), r.GetValue(nameof(MSMQ.XmlStructure.MSMQManager.General.AccessRights.AccessRight.Attributes.Right), arxml, MSMQ.XmlStructure.MSMQManager.General.AccessRights.AccessRight.Attributes.Right.Values.DEFAULT)); + r.ac = (AccessControlEntryType)Enum.Parse(typeof(AccessControlEntryType), r.GetValue(nameof(MSMQ.XmlStructure.MSMQManager.General.AccessRights.AccessRight.Attributes.Control), arxml, MSMQ.XmlStructure.MSMQManager.General.AccessRights.AccessRight.Attributes.Control.Values.DEFAULT)); + return r; + } + catch { return null; } + } + public string un; + public MessageQueueAccessRights ar; + public AccessControlEntryType ac; + } + public class MSMQDefaults : XmlLinqBase + { + public string Xml_MessageFilesDirectory; + public string Xml_MessageFilesReadToMask; + public string Xml_MessageFilesSendToMask; + public string Xml_DefaultFormatter; + public string Xml_DefaultEncoding; + public List Xml_AccessRights = new List(); + public MSMQDefaults(XElement rootxml) + { + var generalxml = GetXElement(rootxml,nameof(MSMQ.XmlStructure.MSMQManager.General)); + var messagefiles = GetXElement(generalxml, nameof(MSMQ.XmlStructure.MSMQManager.General.MessageFiles)); + + Xml_MessageFilesDirectory = GetValue(nameof(MSMQ.XmlStructure.MSMQManager.General.MessageFiles.Attributes.Directory), messagefiles, MSMQ.XmlStructure.MSMQManager.General.MessageFiles.Attributes.Directory.Values.DEFAULT); + Xml_MessageFilesReadToMask = GetValue(nameof(MSMQ.XmlStructure.MSMQManager.General.MessageFiles.Attributes.ReadToMask), messagefiles, MSMQ.XmlStructure.MSMQManager.General.MessageFiles.Attributes.ReadToMask.Values.DEFAULT); + Xml_MessageFilesSendToMask = GetValue(nameof(MSMQ.XmlStructure.MSMQManager.General.MessageFiles.Attributes.SendToMask), messagefiles, MSMQ.XmlStructure.MSMQManager.General.MessageFiles.Attributes.SendToMask.Values.DEFAULT); + Xml_DefaultFormatter = GetValue(nameof(MSMQ.XmlStructure.MSMQManager.General.DefaultFormatter), generalxml, MSMQ.XmlStructure.MSMQManager.General.DefaultFormatter.Values.DEFAULT); + Xml_DefaultEncoding = GetValue(nameof(MSMQ.XmlStructure.MSMQManager.General.DefaultEncoding), generalxml, MSMQ.XmlStructure.MSMQManager.General.DefaultEncoding.Values.DEFAULT); + + try + { + var arxmllist = GetAllXElements(generalxml, nameof(MSMQ.XmlStructure.MSMQManager.General.AccessRights), nameof(MSMQ.XmlStructure.MSMQManager.General.AccessRights.AccessRight)); + foreach (var arxml in arxmllist) { var newa = AccessRights.Factory(arxml); if (newa != null) { Xml_AccessRights.Add(newa); } } + } + catch { } + } + } + #endregion Defaults class + + #region MSMQ class + public class MSMQ : XmlLinqBase + { + #region fields + public bool Valid = true; + public string Xml_Key; + public string Xml_Name; + public string Xml_AddressPrefix = XmlStructure.MSMQManager.MessageQueues.MessageQueue.Attributes.AddressPrefix.Values.DEFAULT; + public string Xml_Server = XmlStructure.MSMQManager.MessageQueues.MessageQueue.Attributes.Server.Values.DEFAULT; + public bool Xml_Private = XmlStructure.MSMQManager.MessageQueues.MessageQueue.Attributes.Private.Values.DEFAULT; + public string Xml_Mode = XmlStructure.MSMQManager.MessageQueues.MessageQueue.Attributes.Mode.Values.DEFAULT; + public string Xml_Label; + public string Xml_Formatter = XmlStructure.MSMQManager.General.DefaultFormatter.Values.DEFAULT; + public string Xml_Encoding = XmlStructure.MSMQManager.General.DefaultEncoding.Values.DEFAULT; + public List Xml_AccessRights = new List(); + + public string Status; + public string StatusDescription=null; + public Guid Id; + public string QueueName; + public long NumOfMessages; + public string Label; + public string MachineName; + public IMessageFormatter Formatter; + public string FormatName; + public string Path; + public DateTime LastModifyTime; + public QueueAccessMode AccessMode; + public bool CanRead; + public bool CanWrite; + public long MaximumQueueSize; + public bool UseJournalQueue; + public long MaximumJournalSize; + + public bool Transactional; + public bool Authenticate; + public int BasePriority; + public EncryptionRequired EncryptionRequired; + #endregion fields + + #region basic constructor + public MSMQ() { } + #endregion basic constructor + #region xml constructor + public string PriorityText(int pri) + { + return + (pri == 0 ? "Realtime" + : pri == 1 ? "High" + : pri == 2 ? "High" + : pri == 3 ? "Normal" + : pri == 4 ? "Normal" + : pri == 5 ? "Normal" + : pri == 6 ? "Normal" + : pri == 7 ? "Low" + : pri == 8 ? "Low" + : pri == 9 ? "Idle" + : pri == 10 ? "Idle" + : "Idle") + $"({pri})"; + } + public MSMQ(XElement msmqxml,MSMQDefaults msmqdefaults) + { + Valid = true; + string ATTRIBUTEMANDATORY = nameof(XmlStructure.MSMQManager.MessageQueues.MessageQueue) + " attribute is mandatory! Name: {0}"; + Xml_Key = GetValue(nameof(XmlStructure.MSMQManager.MessageQueues.MessageQueue.Attributes.Key), msmqxml, XmlStructure.MSMQManager.MessageQueues.MessageQueue.Attributes.Key.Values.DEFAULT); + Xml_Name = msmqxml.Attribute(XName.Get(nameof(XmlStructure.MSMQManager.MessageQueues.MessageQueue.Attributes.Name)))?.Value; + if (string.IsNullOrWhiteSpace(Xml_Name)) { throw new ApplicationException(string.Format(ATTRIBUTEMANDATORY, nameof(XmlStructure.MSMQManager.MessageQueues.MessageQueue.Attributes.Name))); } + Xml_AddressPrefix = GetValue(nameof(XmlStructure.MSMQManager.MessageQueues.MessageQueue.Attributes.AddressPrefix), msmqxml, XmlStructure.MSMQManager.MessageQueues.MessageQueue.Attributes.AddressPrefix.Values.DEFAULT); + Xml_Server = GetValue(nameof(XmlStructure.MSMQManager.MessageQueues.MessageQueue.Attributes.Server), msmqxml, XmlStructure.MSMQManager.MessageQueues.MessageQueue.Attributes.Server.Values.DEFAULT); + if (Xml_Server == "." || Xml_Server.ToLower() == "localhost") { Xml_Server = System.Environment.MachineName; } + + Xml_Private = GetValue(nameof(XmlStructure.MSMQManager.MessageQueues.MessageQueue.Attributes.Private), msmqxml, XmlStructure.MSMQManager.MessageQueues.MessageQueue.Attributes.Private.Values.DEFAULT); + Xml_Mode = GetValue(nameof(XmlStructure.MSMQManager.MessageQueues.MessageQueue.Attributes.Mode), msmqxml, XmlStructure.MSMQManager.MessageQueues.MessageQueue.Attributes.Mode.Values.DEFAULT); + Xml_Label = GetValue(nameof(XmlStructure.MSMQManager.MessageQueues.MessageQueue.Attributes.Label), msmqxml, Xml_Name); + Xml_Formatter = GetValue(nameof(XmlStructure.MSMQManager.MessageQueues.MessageQueue.Attributes.Formatter), msmqxml, msmqdefaults.Xml_DefaultFormatter); + Xml_Encoding = GetValue(nameof(XmlStructure.MSMQManager.MessageQueues.MessageQueue.Attributes.Encoding), msmqxml, msmqdefaults.Xml_DefaultEncoding); + + foreach (var ar in msmqdefaults.Xml_AccessRights) { Xml_AccessRights.Add(ar); } + try + { + var arxmllist = GetAllXElements(msmqxml, nameof(MSMQ.XmlStructure.MSMQManager.MessageQueues.MessageQueue.AccessRight)); + foreach (var arxml in arxmllist) { var newa = AccessRights.Factory(arxml); if (newa != null) { Xml_AccessRights.Add(newa); } } + } + catch{ } - Message m = msmq.Receive(new TimeSpan(0)); - m.BodyStream.Position = 0; - - Encoding enc = System.Text.Encoding.UTF8; - enc = System.Text.Encoding.UTF7; - enc = System.Text.Encoding.UTF32; - enc = System.Text.Encoding.Unicode; - enc = System.Text.Encoding.BigEndianUnicode; - enc = System.Text.Encoding.ASCII; - enc = System.Text.Encoding.Default; - var sr = new System.IO.StreamReader(m.BodyStream, enc); - var label = m.Label; - var body = sr.ReadToEnd().Replace(((char)0).ToString(), ""); - } - void Send() - { - string ccs = @"localhost\private$\ljskskin"; - - var frmA = new System.Messaging.ActiveXMessageFormatter(); - var msmq = new MessageQueue(ccs); - msmq.Formatter = frmA; - string messagetosend = ""; - string messagelabel = ""; - - Encoding enc = System.Text.Encoding.UTF8; - byte[] encodedmessage = enc.GetBytes(messagetosend); + } + #endregion xml constructor + #region cloner constructor + public MSMQ(MSMQ msmq) + { + Valid = msmq.Valid; + Xml_Key = msmq.Xml_Key; + Xml_Name = msmq.Xml_Name; + Xml_Server = msmq.Xml_Server; + Xml_Private = msmq.Xml_Private; + Xml_Mode = msmq.Xml_Mode; + Xml_Label = msmq.Xml_Label; + Xml_Formatter= msmq.Xml_Formatter; + Xml_Encoding = msmq.Xml_Encoding; + } + #endregion cloner constructor + #region XmlStructure + public static class XmlStructure + { + public static class MSMQManager + { + public static class General + { + public static class AccessRights + { + public static class AccessRight + { + public static class Attributes + { + public static class Username { public static class Values { public const string DEFAULT = "Everyone"; } } + public static class Right {public static class Values { public const string DEFAULT = nameof(MessageQueueAccessRights.FullControl); } } + public static class Control { public static class Values { public const string DEFAULT = nameof(AccessControlEntryType.Allow); } } + } + } + } + public static class MessageFiles + { + public static class Attributes + { + public static class Directory { public static class Values { public const string DEFAULT = ""; } } + public static class SendToMask { public static class Values { public const string DEFAULT = "*.*"; } } + public static class ReadToMask { public static class Values { public const string DEFAULT = "*.*"; } } + } + } + public static class DefaultFormatter { public static class Values { public const string DEFAULT = nameof(ActiveXMessageFormatter); } } + public static class DefaultEncoding { public static class Values { public const string DEFAULT = nameof(System.Text.Encoding.UTF8); } } + } - msmq.Send(encodedmessage, messagelabel); + public static class MessageQueues + { + public static class MessageQueue + { + public static class Attributes + { + public static class Key { public static class Values { public const string DEFAULT = ""; } } + public static class AddressPrefix{ public static class Values { public const string DEFAULT = ""; } } + public static class Server { public static class Values { public const string DEFAULT = "."; } } + public static class Name { } + public static class Label { } + public static class Private { public static class Values { public const bool DEFAULT = true; } } + public static class Mode + { + public static class Values + { + public const string DEFAULT = "In"; + public static class In { } + public static class Out { } + } + } + public static class Formatter + { + public static class Values + { + public static class ActiveXMessageFormatter { } + public static class BinaryMessageFormatter { } + public static class XmlMessageFormatter { } + } + } + public static class Encoding { } + } + public static class AccessRight + { + public static class Attributes + { + public static class Username { public static class Values { public const string DEFAULT = "Everyone"; } } + public static class Right { public static class Values { public const string DEFAULT = nameof(MessageQueueAccessRights.FullControl); } } + public static class Control { public static class Values { public const string DEFAULT = nameof(AccessControlEntryType.Allow); } } + } + } + } + } + } } + #endregion XmlStructure } + #endregion MSMQ class } diff --git a/Vrh.Log4Pro.MaintenanceConsole/Manager - MaintenanceToolManager.cs b/Vrh.Log4Pro.MaintenanceConsole/Manager - MaintenanceToolManager.cs index aa25036..63ae0ce 100644 --- a/Vrh.Log4Pro.MaintenanceConsole/Manager - MaintenanceToolManager.cs +++ b/Vrh.Log4Pro.MaintenanceConsole/Manager - MaintenanceToolManager.cs @@ -39,6 +39,7 @@ namespace Vrh.Log4Pro.MaintenanceConsole.MaintenanceToolManagerNS var config = new MaintenanceToolsXmlProcessor(xmlcs, "", "hu-HU"); var menufunctions = new Menu("Maintenance Tools", "Select function!") + .AddMenuItem(new Menu.Item(CLP.Module.MaintenanceToolManager.Functions.StartAsSystem.KEY, "Start As NT AUTHORITY/SYSTEM", StartAsSystem, new Menu.ExecutorParameter(cfg: config))) .AddMenuItem(new Menu.Item(CLP.Module.MaintenanceToolManager.Functions.RegexTester.KEY, "Regex tester", RegexTester,new Menu.ExecutorParameter(cfg:config))) .AddMenuItem(new Menu.Item(CLP.Module.MaintenanceToolManager.Functions.TCPIPTester.KEY, "TcpIp Tester", TcpIpTester, new Menu.ExecutorParameter(cfg: config, null))) .AddMenuItem(new Menu.Item(CLP.Module.MaintenanceToolManager.Functions.Tool.KEY, "Tool sample", Tool2, new Menu.ExecutorParameter(cfg: config, null))) @@ -68,6 +69,11 @@ namespace Vrh.Log4Pro.MaintenanceConsole.MaintenanceToolManagerNS return o; } #region RegexTester + public static object StartAsSystem(object parameter, object o) + { + OtherTools.StartAsSystem(false); + return o; + } private static object RegexTester(object parameter, object o) { var config = (parameter as Menu.ExecutorParameter).GetConfig(); diff --git a/Vrh.Log4Pro.MaintenanceConsole/Program.cs b/Vrh.Log4Pro.MaintenanceConsole/Program.cs index 2f2ecb7..bdd92e4 100644 --- a/Vrh.Log4Pro.MaintenanceConsole/Program.cs +++ b/Vrh.Log4Pro.MaintenanceConsole/Program.cs @@ -18,6 +18,7 @@ using Vrh.Log4Pro.MaintenanceConsole.WindowsServiceManagerNS; using Vrh.Log4Pro.MaintenanceConsole.BackupPackageManagerNS; using Vrh.Log4Pro.MaintenanceConsole.SQLDataBaseManagerNS; using Vrh.Log4Pro.MaintenanceConsole.ScheduledTaskManagerNS; +using Vrh.Log4Pro.MaintenanceConsole.MSMQManagerNS; using Vrh.Log4Pro.MaintenanceConsole.FileCleanerManagerNS; using Vrh.Log4Pro.MaintenanceConsole.MaintenanceToolManagerNS; using Vrh.Log4Pro.MaintenanceConsole.UserManagerNS; @@ -28,6 +29,7 @@ using Vrh.Log4Pro.MaintenanceConsole.CommandLineParserNS; using Vrh.XmlProcessing; using VRH.Common; using System.Xml.Linq; +using System.Reflection; namespace Vrh.Log4Pro.MaintenanceConsole { @@ -35,6 +37,8 @@ namespace Vrh.Log4Pro.MaintenanceConsole { static void Main(string[] args) { + OtherTools.StartAsAdmin(); + OtherTools.StartAsSystem(silent:false); //while (true) //{ // Console.Clear(); @@ -95,6 +99,7 @@ namespace Vrh.Log4Pro.MaintenanceConsole .AddMenuItem(new Menu.Item(CLP.Module.WindowsServiceManager.KEY, "Windows Service Manager", WindowsServiceManager.Execute, new Menu.ExecutorParameter(args: args))) .AddMenuItem(new Menu.Item(CLP.Module.FileCleanerManager.KEY, "File Cleaner Manager", FileCleanerManager.Execute, new Menu.ExecutorParameter(args: args))) .AddMenuItem(new Menu.Item(CLP.Module.ScheduledTaskManager.KEY, "Scheduled Task Manager", ScheduledTaskManager.Execute, new Menu.ExecutorParameter(args: args))) + .AddMenuItem(new Menu.Item(CLP.Module.MSMQManager.KEY, "MS MessageQueue (MSMQ) Manager", MSMQManager.Execute, new Menu.ExecutorParameter(args: args))) .AddMenuItem(new Menu.Item(CLP.Module.BackupPackageManager.KEY, "Backup Package Manager", BackupPackageManager.Execute, new Menu.ExecutorParameter(args: args))) .AddMenuItem(new Menu.Item(CLP.Module.SQLDataBaseManager.KEY, "SQL Database Manager", SQLDataBaseManager.Execute, new Menu.ExecutorParameter(args: args))) .AddMenuItem(new Menu.Item(CLP.Module.Log4ProUserManager.KEY, "Log4Pro User Manager", UserManager.Execute, new Menu.ExecutorParameter(args: args))) diff --git a/Vrh.Log4Pro.MaintenanceConsole/Properties/AssemblyInfo.cs b/Vrh.Log4Pro.MaintenanceConsole/Properties/AssemblyInfo.cs index 09f7ab4..110d7c2 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.8.5.0")] -[assembly: AssemblyFileVersion("1.8.5.0")] +[assembly: AssemblyVersion("1.9.0.0")] +[assembly: AssemblyFileVersion("1.9.0.0")] diff --git a/Vrh.Log4Pro.MaintenanceConsole/Vrh.Log4Pro.MaintenanceConsole.csproj b/Vrh.Log4Pro.MaintenanceConsole/Vrh.Log4Pro.MaintenanceConsole.csproj index d0f5d2d..e0cd6ec 100644 --- a/Vrh.Log4Pro.MaintenanceConsole/Vrh.Log4Pro.MaintenanceConsole.csproj +++ b/Vrh.Log4Pro.MaintenanceConsole/Vrh.Log4Pro.MaintenanceConsole.csproj @@ -172,6 +172,7 @@ ..\packages\Newtonsoft.Json.11.0.1\lib\net45\Newtonsoft.Json.dll + ..\packages\System.AppContext.4.1.0\lib\net463\System.AppContext.dll @@ -331,6 +332,7 @@ ..\packages\Microsoft.AspNet.Providers.Core.2.0.0\lib\net40\System.Web.Providers.dll + @@ -346,6 +348,7 @@ ..\packages\Vrh.XmlProcessing.1.27.1\lib\net45\Vrh.XmlProcessing.dll + -- libgit2 0.21.2