From a12b13c36d1da707cf541595cf5f38338f37cc68 Mon Sep 17 00:00:00 2001 From: Sean Hall Date: Sat, 19 Jan 2019 19:19:15 -0600 Subject: Import code from old v4 repo --- src/wixext/MsmqCompiler.cs | 536 +++++++++++++++++++++++++++++++++++++ src/wixext/MsmqDecompiler.cs | 303 +++++++++++++++++++++ src/wixext/MsmqExtensionData.cs | 64 +++++ src/wixext/WixMsmqExtension.csproj | 49 ++++ src/wixext/messages.xml | 77 ++++++ src/wixext/msmq.xsd | 121 +++++++++ src/wixext/tables.xml | 54 ++++ 7 files changed, 1204 insertions(+) create mode 100644 src/wixext/MsmqCompiler.cs create mode 100644 src/wixext/MsmqDecompiler.cs create mode 100644 src/wixext/MsmqExtensionData.cs create mode 100644 src/wixext/WixMsmqExtension.csproj create mode 100644 src/wixext/messages.xml create mode 100644 src/wixext/msmq.xsd create mode 100644 src/wixext/tables.xml (limited to 'src/wixext') diff --git a/src/wixext/MsmqCompiler.cs b/src/wixext/MsmqCompiler.cs new file mode 100644 index 00000000..b40e2dc1 --- /dev/null +++ b/src/wixext/MsmqCompiler.cs @@ -0,0 +1,536 @@ +// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information. + +namespace WixToolset.Extensions +{ + using System; + using System.Collections; + using System.Collections.Generic; + using System.Globalization; + using System.Reflection; + using System.Xml; + using System.Xml.Linq; + using System.Xml.Schema; + using WixToolset.Data; + using WixToolset.Extensibility; + + /// + /// The compiler for the WiX Toolset Internet Information Services Extension. + /// + public sealed class MsmqCompiler : CompilerExtension + { + /// + /// Instantiate a new MsmqCompiler. + /// + public MsmqCompiler() + { + this.Namespace = "http://wixtoolset.org/schemas/v4/wxs/msmq"; + } + + /// + /// + /// + public enum MqiMessageQueueAttributes + { + Authenticate = (1 << 0), + Journal = (1 << 1), + Transactional = (1 << 2) + } + + /// + /// + /// + public enum MqiMessageQueuePrivacyLevel + { + None = 0, + Optional = 1, + Body = 2 + } + + /// + /// + /// + public enum MqiMessageQueuePermission + { + DeleteMessage = (1 << 0), + PeekMessage = (1 << 1), + WriteMessage = (1 << 2), + DeleteJournalMessage = (1 << 3), + SetQueueProperties = (1 << 4), + GetQueueProperties = (1 << 5), + DeleteQueue = (1 << 6), + GetQueuePermissions = (1 << 7), + ChangeQueuePermissions = (1 << 8), + TakeQueueOwnership = (1 << 9), + ReceiveMessage = (1 << 10), + ReceiveJournalMessage = (1 << 11), + QueueGenericRead = (1 << 12), + QueueGenericWrite = (1 << 13), + QueueGenericExecute = (1 << 14), + QueueGenericAll = (1 << 15) + } + + /// + /// Processes an element for the Compiler. + /// + /// Parent element of element to process. + /// Element to process. + /// Extra information about the context in which this element is being parsed. + public override void ParseElement(XElement parentElement, XElement element, IDictionary context) + { + switch (parentElement.Name.LocalName) + { + case "Component": + string componentId = context["ComponentId"]; + string directoryId = context["DirectoryId"]; + + switch (element.Name.LocalName) + { + case "MessageQueue": + this.ParseMessageQueueElement(element, componentId); + break; + case "MessageQueuePermission": + this.ParseMessageQueuePermissionElement(element, componentId, null); + break; + default: + this.Core.UnexpectedElement(parentElement, element); + break; + } + break; + default: + this.Core.UnexpectedElement(parentElement, element); + break; + } + } + + /// + /// Parses an MSMQ message queue element. + /// + /// Element to parse. + /// Identifier of parent component. + private void ParseMessageQueueElement(XElement node, string componentId) + { + SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node); + + string id = null; + int basePriority = CompilerConstants.IntegerNotSet; + int journalQuota = CompilerConstants.IntegerNotSet; + string label = null; + string multicastAddress = null; + string pathName = null; + int privLevel = CompilerConstants.IntegerNotSet; + int quota = CompilerConstants.IntegerNotSet; + string serviceTypeGuid = null; + int attributes = 0; + + foreach (XAttribute attrib in node.Attributes()) + { + if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || this.Namespace == attrib.Name.Namespace) + { + switch (attrib.Name.LocalName) + { + case "Id": + id = this.Core.GetAttributeIdentifierValue(sourceLineNumbers, attrib); + break; + case "Authenticate": + if (YesNoType.Yes == this.Core.GetAttributeYesNoValue(sourceLineNumbers, attrib)) + { + attributes |= (int)MqiMessageQueueAttributes.Authenticate; + } + else + { + attributes &= ~(int)MqiMessageQueueAttributes.Authenticate; + } + break; + case "BasePriority": + basePriority = this.Core.GetAttributeIntegerValue(sourceLineNumbers, attrib, 0, short.MaxValue); + break; + case "Journal": + if (YesNoType.Yes == this.Core.GetAttributeYesNoValue(sourceLineNumbers, attrib)) + { + attributes |= (int)MqiMessageQueueAttributes.Journal; + } + else + { + attributes &= ~(int)MqiMessageQueueAttributes.Journal; + } + break; + case "JournalQuota": + journalQuota = this.Core.GetAttributeIntegerValue(sourceLineNumbers, attrib, 0, int.MaxValue); + break; + case "Label": + label = this.Core.GetAttributeValue(sourceLineNumbers, attrib); + break; + case "MulticastAddress": + multicastAddress = this.Core.GetAttributeValue(sourceLineNumbers, attrib); + break; + case "PathName": + pathName = this.Core.GetAttributeValue(sourceLineNumbers, attrib); + break; + case "PrivLevel": + string privLevelAttr = this.Core.GetAttributeValue(sourceLineNumbers, attrib); + switch (privLevelAttr) + { + case "none": + privLevel = (int)MqiMessageQueuePrivacyLevel.None; + break; + case "optional": + privLevel = (int)MqiMessageQueuePrivacyLevel.Optional; + break; + case "body": + privLevel = (int)MqiMessageQueuePrivacyLevel.Body; + break; + default: + this.Core.OnMessage(WixErrors.IllegalAttributeValue(sourceLineNumbers, "MessageQueue", "PrivLevel", privLevelAttr, "none", "body", "optional")); + break; + } + break; + case "Quota": + quota = this.Core.GetAttributeIntegerValue(sourceLineNumbers, attrib, 0, int.MaxValue); + break; + case "Transactional": + if (YesNoType.Yes == this.Core.GetAttributeYesNoValue(sourceLineNumbers, attrib)) + { + attributes |= (int)MqiMessageQueueAttributes.Transactional; + } + else + { + attributes &= ~(int)MqiMessageQueueAttributes.Transactional; + } + break; + case "ServiceTypeGuid": + serviceTypeGuid = TryFormatGuidValue(this.Core.GetAttributeValue(sourceLineNumbers, attrib)); + break; + default: + this.Core.UnexpectedAttribute(node, attrib); + break; + } + } + else + { + this.Core.ParseExtensionAttribute(node, attrib); + } + } + + foreach (XElement child in node.Elements()) + { + if (this.Namespace == child.Name.Namespace) + { + switch (child.Name.LocalName) + { + case "MessageQueuePermission": + this.ParseMessageQueuePermissionElement(child, componentId, id); + break; + default: + this.Core.UnexpectedElement(node, child); + break; + } + } + else + { + this.Core.ParseExtensionElement(node, child); + } + } + + Row row = this.Core.CreateRow(sourceLineNumbers, "MessageQueue"); + row[0] = id; + row[1] = componentId; + if (CompilerConstants.IntegerNotSet != basePriority) + { + row[2] = basePriority; + } + if (CompilerConstants.IntegerNotSet != journalQuota) + { + row[3] = journalQuota; + } + row[4] = label; + row[5] = multicastAddress; + row[6] = pathName; + if (CompilerConstants.IntegerNotSet != privLevel) + { + row[7] = privLevel; + } + if (CompilerConstants.IntegerNotSet != quota) + { + row[8] = quota; + } + row[9] = serviceTypeGuid; + row[10] = attributes; + + this.Core.CreateSimpleReference(sourceLineNumbers, "CustomAction", "MessageQueuingInstall"); + this.Core.CreateSimpleReference(sourceLineNumbers, "CustomAction", "MessageQueuingUninstall"); + } + + /// + /// Parses an MSMQ message queue permission element. + /// + /// Element to parse. + /// Identifier of parent component. + /// Optional identifier of parent message queue. + private void ParseMessageQueuePermissionElement(XElement node, string componentId, string messageQueueId) + { + SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node); + + string id = null; + string user = null; + string group = null; + int permissions = 0; + + foreach (XAttribute attrib in node.Attributes()) + { + if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || this.Namespace == attrib.Name.Namespace) + { + switch (attrib.Name.LocalName) + { + case "Id": + id = this.Core.GetAttributeIdentifierValue(sourceLineNumbers, attrib); + break; + case "MessageQueue": + if (null != messageQueueId) + { + this.Core.OnMessage(WixErrors.IllegalAttributeWhenNested(sourceLineNumbers, node.Name.LocalName, attrib.Name.LocalName, node.Parent.Name.LocalName)); + } + messageQueueId = this.Core.GetAttributeValue(sourceLineNumbers, attrib); + this.Core.CreateSimpleReference(sourceLineNumbers, "MessageQueue", messageQueueId); + break; + case "User": + if (null != group) + { + this.Core.OnMessage(WixErrors.IllegalAttributeWithOtherAttribute(sourceLineNumbers, node.Name.LocalName, "User", "Group")); + } + user = this.Core.GetAttributeValue(sourceLineNumbers, attrib); + this.Core.CreateSimpleReference(sourceLineNumbers, "User", user); + break; + case "Group": + if (null != user) + { + this.Core.OnMessage(WixErrors.IllegalAttributeWithOtherAttribute(sourceLineNumbers, node.Name.LocalName, "Group", "User")); + } + group = this.Core.GetAttributeValue(sourceLineNumbers, attrib); + this.Core.CreateSimpleReference(sourceLineNumbers, "Group", group); + break; + case "DeleteMessage": + if (YesNoType.Yes == this.Core.GetAttributeYesNoValue(sourceLineNumbers, attrib)) + { + permissions |= (int)MqiMessageQueuePermission.DeleteMessage; + } + else + { + permissions &= ~(int)MqiMessageQueuePermission.DeleteMessage; + } + break; + case "PeekMessage": + if (YesNoType.Yes == this.Core.GetAttributeYesNoValue(sourceLineNumbers, attrib)) + { + permissions |= (int)MqiMessageQueuePermission.PeekMessage; + } + else + { + permissions &= ~(int)MqiMessageQueuePermission.PeekMessage; + } + break; + case "WriteMessage": + if (YesNoType.Yes == this.Core.GetAttributeYesNoValue(sourceLineNumbers, attrib)) + { + permissions |= (int)MqiMessageQueuePermission.WriteMessage; + } + else + { + permissions &= ~(int)MqiMessageQueuePermission.WriteMessage; + } + break; + case "DeleteJournalMessage": + if (YesNoType.Yes == this.Core.GetAttributeYesNoValue(sourceLineNumbers, attrib)) + { + permissions |= (int)MqiMessageQueuePermission.DeleteJournalMessage; + } + else + { + permissions &= ~(int)MqiMessageQueuePermission.DeleteJournalMessage; + } + break; + case "SetQueueProperties": + if (YesNoType.Yes == this.Core.GetAttributeYesNoValue(sourceLineNumbers, attrib)) + { + permissions |= (int)MqiMessageQueuePermission.SetQueueProperties; + } + else + { + permissions &= ~(int)MqiMessageQueuePermission.SetQueueProperties; + } + break; + case "GetQueueProperties": + if (YesNoType.Yes == this.Core.GetAttributeYesNoValue(sourceLineNumbers, attrib)) + { + permissions |= (int)MqiMessageQueuePermission.GetQueueProperties; + } + else + { + permissions &= ~(int)MqiMessageQueuePermission.GetQueueProperties; + } + break; + case "DeleteQueue": + if (YesNoType.Yes == this.Core.GetAttributeYesNoValue(sourceLineNumbers, attrib)) + { + permissions |= (int)MqiMessageQueuePermission.DeleteQueue; + } + else + { + permissions &= ~(int)MqiMessageQueuePermission.DeleteQueue; + } + break; + case "GetQueuePermissions": + if (YesNoType.Yes == this.Core.GetAttributeYesNoValue(sourceLineNumbers, attrib)) + { + permissions |= (int)MqiMessageQueuePermission.GetQueuePermissions; + } + else + { + permissions &= ~(int)MqiMessageQueuePermission.GetQueuePermissions; + } + break; + case "ChangeQueuePermissions": + if (YesNoType.Yes == this.Core.GetAttributeYesNoValue(sourceLineNumbers, attrib)) + { + permissions |= (int)MqiMessageQueuePermission.ChangeQueuePermissions; + } + else + { + permissions &= ~(int)MqiMessageQueuePermission.ChangeQueuePermissions; + } + break; + case "TakeQueueOwnership": + if (YesNoType.Yes == this.Core.GetAttributeYesNoValue(sourceLineNumbers, attrib)) + { + permissions |= (int)MqiMessageQueuePermission.TakeQueueOwnership; + } + else + { + permissions &= ~(int)MqiMessageQueuePermission.TakeQueueOwnership; + } + break; + case "ReceiveMessage": + if (YesNoType.Yes == this.Core.GetAttributeYesNoValue(sourceLineNumbers, attrib)) + { + permissions |= (int)MqiMessageQueuePermission.ReceiveMessage; + } + else + { + permissions &= ~(int)MqiMessageQueuePermission.ReceiveMessage; + } + break; + case "ReceiveJournalMessage": + if (YesNoType.Yes == this.Core.GetAttributeYesNoValue(sourceLineNumbers, attrib)) + { + permissions |= (int)MqiMessageQueuePermission.ReceiveJournalMessage; + } + else + { + permissions &= ~(int)MqiMessageQueuePermission.ReceiveJournalMessage; + } + break; + case "QueueGenericRead": + if (YesNoType.Yes == this.Core.GetAttributeYesNoValue(sourceLineNumbers, attrib)) + { + permissions |= (int)MqiMessageQueuePermission.QueueGenericRead; + } + else + { + permissions &= ~(int)MqiMessageQueuePermission.QueueGenericRead; + } + break; + case "QueueGenericWrite": + if (YesNoType.Yes == this.Core.GetAttributeYesNoValue(sourceLineNumbers, attrib)) + { + permissions |= (int)MqiMessageQueuePermission.QueueGenericWrite; + } + else + { + permissions &= ~(int)MqiMessageQueuePermission.QueueGenericWrite; + } + break; + case "QueueGenericExecute": + if (YesNoType.Yes == this.Core.GetAttributeYesNoValue(sourceLineNumbers, attrib)) + { + permissions |= (int)MqiMessageQueuePermission.QueueGenericExecute; + } + else + { + permissions &= ~(int)MqiMessageQueuePermission.QueueGenericExecute; + } + break; + case "QueueGenericAll": + if (YesNoType.Yes == this.Core.GetAttributeYesNoValue(sourceLineNumbers, attrib)) + { + permissions |= (int)MqiMessageQueuePermission.QueueGenericAll; + } + else + { + permissions &= ~(int)MqiMessageQueuePermission.QueueGenericAll; + } + break; + default: + this.Core.UnexpectedAttribute(node, attrib); + break; + } + } + else + { + this.Core.ParseExtensionAttribute(node, attrib); + } + } + + if (null == messageQueueId) + { + this.Core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "MessageQueue")); + } + if (null == user && null == group) + { + this.Core.OnMessage(WixErrors.ExpectedAttributes(sourceLineNumbers, node.Name.LocalName, "User", "Group")); + } + + this.Core.ParseForExtensionElements(node); + + if (null != user) + { + Row row = this.Core.CreateRow(sourceLineNumbers, "MessageQueueUserPermission"); + row[0] = id; + row[1] = componentId; + row[2] = messageQueueId; + row[3] = user; + row[4] = permissions; + } + if (null != group) + { + Row row = this.Core.CreateRow(sourceLineNumbers, "MessageQueueGroupPermission"); + row[0] = id; + row[1] = componentId; + row[2] = messageQueueId; + row[3] = group; + row[4] = permissions; + } + } + + /// + /// Attempts to parse the input value as a GUID, and in case the value is a valid + /// GUID returnes it in the format "{XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX}". + /// + /// + /// + string TryFormatGuidValue(string val) + { + try + { + Guid guid = new Guid(val); + return guid.ToString("B").ToUpper(); + } + catch (FormatException) + { + return val; + } + catch (OverflowException) + { + return val; + } + } + } +} diff --git a/src/wixext/MsmqDecompiler.cs b/src/wixext/MsmqDecompiler.cs new file mode 100644 index 00000000..396fc49a --- /dev/null +++ b/src/wixext/MsmqDecompiler.cs @@ -0,0 +1,303 @@ +// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information. + +namespace WixToolset.Extensions +{ + using System; + using System.Collections; + using System.Globalization; + using WixToolset.Data; + using WixToolset.Extensibility; + using Msmq = WixToolset.Extensions.Serialize.Msmq; + using Wix = WixToolset.Data.Serialize; + + /// + /// The decompiler for the WiX Toolset MSMQ Extension. + /// + public sealed class MsmqDecompiler : DecompilerExtension + { + /// + /// Creates a decompiler for MSMQ Extension. + /// + public MsmqDecompiler() + { + this.TableDefinitions = MsmqExtensionData.GetExtensionTableDefinitions(); + } + + /// + /// Get the extensions library to be removed. + /// + /// Table definitions for library. + /// Library to remove from decompiled output. + public override Library GetLibraryToRemove(TableDefinitionCollection tableDefinitions) + { + return MsmqExtensionData.GetExtensionLibrary(tableDefinitions); + } + + /// + /// Decompiles an extension table. + /// + /// The table to decompile. + public override void DecompileTable(Table table) + { + switch (table.Name) + { + case "MessageQueue": + this.DecompileMessageQueueTable(table); + break; + case "MessageQueueUserPermission": + this.DecompileMessageQueueUserPermissionTable(table); + break; + case "MessageQueueGroupPermission": + this.DecompileMessageQueueGroupPermissionTable(table); + break; + default: + base.DecompileTable(table); + break; + } + } + + /// + /// Decompile the MessageQueue table. + /// + /// The table to decompile. + private void DecompileMessageQueueTable(Table table) + { + foreach (Row row in table.Rows) + { + Msmq.MessageQueue queue = new Msmq.MessageQueue(); + + queue.Id = (string)row[0]; + + if (null != row[2]) + { + queue.BasePriority = (int)row[2]; + } + + if (null != row[3]) + { + queue.JournalQuota = (int)row[3]; + } + + queue.Label = (string)row[4]; + + if (null != row[5]) + { + queue.MulticastAddress = (string)row[5]; + } + + queue.PathName = (string)row[6]; + + if (null != row[7]) + { + switch ((MsmqCompiler.MqiMessageQueuePrivacyLevel)row[7]) + { + case MsmqCompiler.MqiMessageQueuePrivacyLevel.None: + queue.PrivLevel = Msmq.MessageQueue.PrivLevelType.none; + break; + case MsmqCompiler.MqiMessageQueuePrivacyLevel.Optional: + queue.PrivLevel = Msmq.MessageQueue.PrivLevelType.optional; + break; + case MsmqCompiler.MqiMessageQueuePrivacyLevel.Body: + queue.PrivLevel = Msmq.MessageQueue.PrivLevelType.body; + break; + default: + break; + } + } + + if (null != row[8]) + { + queue.Quota = (int)row[8]; + } + + if (null != row[9]) + { + queue.ServiceTypeGuid = (string)row[9]; + } + + int attributes = (int)row[10]; + + if (0 != (attributes & (int)MsmqCompiler.MqiMessageQueueAttributes.Authenticate)) + { + queue.Authenticate = Msmq.YesNoType.yes; + } + + if (0 != (attributes & (int)MsmqCompiler.MqiMessageQueueAttributes.Journal)) + { + queue.Journal = Msmq.YesNoType.yes; + } + + if (0 != (attributes & (int)MsmqCompiler.MqiMessageQueueAttributes.Transactional)) + { + queue.Transactional = Msmq.YesNoType.yes; + } + + Wix.Component component = (Wix.Component)this.Core.GetIndexedElement("Component", (string)row[1]); + if (null != component) + { + component.AddChild(queue); + } + else + { + this.Core.OnMessage(WixWarnings.ExpectedForeignRow(row.SourceLineNumbers, table.Name, row.GetPrimaryKey(DecompilerConstants.PrimaryKeyDelimiter), "Component_", (string)row[1], "Component")); + } + } + } + + /// + /// Decompile the MessageQueueUserPermission table. + /// + /// The table to decompile. + private void DecompileMessageQueueUserPermissionTable(Table table) + { + foreach (Row row in table.Rows) + { + Msmq.MessageQueuePermission queuePermission = new Msmq.MessageQueuePermission(); + + queuePermission.Id = (string)row[0]; + + if (null != row[2]) + { + queuePermission.MessageQueue = (string)row[2]; + } + + queuePermission.User = (string)row[3]; + + DecompileMessageQueuePermissionAttributes(row, queuePermission); + + Wix.Component component = (Wix.Component)this.Core.GetIndexedElement("Component", (string)row[1]); + if (null != component) + { + component.AddChild(queuePermission); + } + else + { + this.Core.OnMessage(WixWarnings.ExpectedForeignRow(row.SourceLineNumbers, table.Name, row.GetPrimaryKey(DecompilerConstants.PrimaryKeyDelimiter), "Component_", (string)row[1], "Component")); + } + } + } + + /// + /// Decompile the MessageQueueGroupPermission table. + /// + /// The table to decompile. + private void DecompileMessageQueueGroupPermissionTable(Table table) + { + foreach (Row row in table.Rows) + { + Msmq.MessageQueuePermission queuePermission = new Msmq.MessageQueuePermission(); + + queuePermission.Id = (string)row[0]; + + if (null != row[2]) + { + queuePermission.MessageQueue = (string)row[2]; + } + + queuePermission.Group = (string)row[3]; + + DecompileMessageQueuePermissionAttributes(row, queuePermission); + + Wix.Component component = (Wix.Component)this.Core.GetIndexedElement("Component", (string)row[1]); + if (null != component) + { + component.AddChild(queuePermission); + } + else + { + this.Core.OnMessage(WixWarnings.ExpectedForeignRow(row.SourceLineNumbers, table.Name, row.GetPrimaryKey(DecompilerConstants.PrimaryKeyDelimiter), "Component_", (string)row[1], "Component")); + } + } + } + + /// + /// Decompile row attributes for the MessageQueueUserPermission and MessageQueueGroupPermission tables. + /// + /// The row to decompile. + /// Target element. + private void DecompileMessageQueuePermissionAttributes(Row row, Msmq.MessageQueuePermission queuePermission) + { + int attributes = (int)row[4]; + + if (0 != (attributes & (int)MsmqCompiler.MqiMessageQueuePermission.DeleteMessage)) + { + queuePermission.DeleteMessage = Msmq.YesNoType.yes; + } + + if (0 != (attributes & (int)MsmqCompiler.MqiMessageQueuePermission.PeekMessage)) + { + queuePermission.PeekMessage = Msmq.YesNoType.yes; + } + + if (0 != (attributes & (int)MsmqCompiler.MqiMessageQueuePermission.WriteMessage)) + { + queuePermission.WriteMessage = Msmq.YesNoType.yes; + } + + if (0 != (attributes & (int)MsmqCompiler.MqiMessageQueuePermission.DeleteJournalMessage)) + { + queuePermission.DeleteJournalMessage = Msmq.YesNoType.yes; + } + + if (0 != (attributes & (int)MsmqCompiler.MqiMessageQueuePermission.SetQueueProperties)) + { + queuePermission.SetQueueProperties = Msmq.YesNoType.yes; + } + + if (0 != (attributes & (int)MsmqCompiler.MqiMessageQueuePermission.GetQueueProperties)) + { + queuePermission.GetQueueProperties = Msmq.YesNoType.yes; + } + + if (0 != (attributes & (int)MsmqCompiler.MqiMessageQueuePermission.DeleteQueue)) + { + queuePermission.DeleteQueue = Msmq.YesNoType.yes; + } + + if (0 != (attributes & (int)MsmqCompiler.MqiMessageQueuePermission.GetQueuePermissions)) + { + queuePermission.GetQueuePermissions = Msmq.YesNoType.yes; + } + + if (0 != (attributes & (int)MsmqCompiler.MqiMessageQueuePermission.ChangeQueuePermissions)) + { + queuePermission.ChangeQueuePermissions = Msmq.YesNoType.yes; + } + + if (0 != (attributes & (int)MsmqCompiler.MqiMessageQueuePermission.TakeQueueOwnership)) + { + queuePermission.TakeQueueOwnership = Msmq.YesNoType.yes; + } + + if (0 != (attributes & (int)MsmqCompiler.MqiMessageQueuePermission.ReceiveMessage)) + { + queuePermission.ReceiveMessage = Msmq.YesNoType.yes; + } + + if (0 != (attributes & (int)MsmqCompiler.MqiMessageQueuePermission.ReceiveJournalMessage)) + { + queuePermission.ReceiveJournalMessage = Msmq.YesNoType.yes; + } + + if (0 != (attributes & (int)MsmqCompiler.MqiMessageQueuePermission.QueueGenericRead)) + { + queuePermission.QueueGenericRead = Msmq.YesNoType.yes; + } + + if (0 != (attributes & (int)MsmqCompiler.MqiMessageQueuePermission.QueueGenericWrite)) + { + queuePermission.QueueGenericWrite = Msmq.YesNoType.yes; + } + + if (0 != (attributes & (int)MsmqCompiler.MqiMessageQueuePermission.QueueGenericExecute)) + { + queuePermission.QueueGenericExecute = Msmq.YesNoType.yes; + } + + if (0 != (attributes & (int)MsmqCompiler.MqiMessageQueuePermission.QueueGenericAll)) + { + queuePermission.QueueGenericAll = Msmq.YesNoType.yes; + } + } + } +} diff --git a/src/wixext/MsmqExtensionData.cs b/src/wixext/MsmqExtensionData.cs new file mode 100644 index 00000000..81d53ce7 --- /dev/null +++ b/src/wixext/MsmqExtensionData.cs @@ -0,0 +1,64 @@ +// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information. + +namespace WixToolset.Extensions +{ + using System; + using System.Reflection; + using WixToolset.Data; + using WixToolset.Extensibility; + + /// + /// The WiX Toolset MSMQ Extension. + /// + public sealed class MsmqExtensionData : ExtensionData + { + /// + /// Gets the default culture. + /// + /// The default culture. + public override string DefaultCulture + { + get { return "en-us"; } + } + + /// + /// Gets the optional table definitions for this extension. + /// + /// The optional table definitions for this extension. + public override TableDefinitionCollection TableDefinitions + { + get + { + return MsmqExtensionData.GetExtensionTableDefinitions(); + } + } + + /// + /// Gets the library associated with this extension. + /// + /// The table definitions to use while loading the library. + /// The loaded library. + public override Library GetLibrary(TableDefinitionCollection tableDefinitions) + { + return MsmqExtensionData.GetExtensionLibrary(tableDefinitions); + } + + /// + /// Internal mechanism to access the extension's table definitions. + /// + /// Extension's table definitions. + internal static TableDefinitionCollection GetExtensionTableDefinitions() + { + return ExtensionData.LoadTableDefinitionHelper(Assembly.GetExecutingAssembly(), "WixToolset.Extensions.Data.tables.xml"); + } + + /// + /// Internal mechanism to access the extension's library. + /// + /// Extension's library. + internal static Library GetExtensionLibrary(TableDefinitionCollection tableDefinitions) + { + return ExtensionData.LoadLibraryHelper(Assembly.GetExecutingAssembly(), "WixToolset.Extensions.Data.msmq.wixlib", tableDefinitions); + } + } +} diff --git a/src/wixext/WixMsmqExtension.csproj b/src/wixext/WixMsmqExtension.csproj new file mode 100644 index 00000000..e37d62a3 --- /dev/null +++ b/src/wixext/WixMsmqExtension.csproj @@ -0,0 +1,49 @@ + + + + + + + {B990D81B-9F60-4EEE-B31D-B5D1EAA799EE} + WixMsmqExtension + Library + WixToolset.Extensions + + + + + + + + $(RootNamespace).Data.tables.xml + + + $(RootNamespace).Xsd.msmq.xsd + + + WixToolset.Data.Serialize + WixToolset.Extensions.Serialize.Msmq + + + msmq.xsd + PreserveNewest + + + Data\msmq.wixlib + + + + + + + + + + + + false + + + + + diff --git a/src/wixext/messages.xml b/src/wixext/messages.xml new file mode 100644 index 00000000..5ab6417f --- /dev/null +++ b/src/wixext/messages.xml @@ -0,0 +1,77 @@ + + + + + + + + + The {0}/@{1} attribute cannot be specified unless the element has a component as an ancestor. A {0} that does not have a component ancestor is not installed. + + + + + + + The {0} element cannot be specified unless the element has a component as an ancestor. A {0} that does not have a component ancestor is not installed. + + + + + + The {0}/@{1} attribute cannot coexist with the {2} attribute's value of '{3}'. + + + + + + + The {0}/@{1} attribute's value, '{2}', cannot coexist with the {3} attribute's value of '{4}'. + + + + + + + + + + The {0}/@{1} cannot be provided unless the {2} attribute is provided with a value of '{3}'. + + + + + + + + + The {0}/@{1} attribute must be provided when {0} element is nested under a component. + + + + + + + A {0} element must have either a {1} attribute or a {2} attribute, or both set. + + + + + + + + A {0} element not nested under a component must have either a {1} attribute or a {2} attribute, or both set. + + + + + + + + + The MsmqAssembly element has a Type attribute with a value of 'native', but the element does not contain any MsmqComponent elements. All components contained in a native assembly must be listed, or they will not be correctly removed during uninstall. + + + + + diff --git a/src/wixext/msmq.xsd b/src/wixext/msmq.xsd new file mode 100644 index 00000000..26348330 --- /dev/null +++ b/src/wixext/msmq.xsd @@ -0,0 +1,121 @@ + + + + + + + + The source code schema for the WiX Toolset MSMQ Extension. + + + + + + + + + + + + + + + + + + + + + + + Default: No. + + + + + + Default: No. + + + + + + + + + + + + + + + + + + + Default: No. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Values of this type will either be "yes" or "no". + + + + + + + + diff --git a/src/wixext/tables.xml b/src/wixext/tables.xml new file mode 100644 index 00000000..5fdd1fad --- /dev/null +++ b/src/wixext/tables.xml @@ -0,0 +1,54 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + -- cgit v1.2.3-55-g6feb