From 6ff680e386b1543ad1a58d1b1d465ce8aa20bc7d Mon Sep 17 00:00:00 2001 From: Rob Mensching Date: Fri, 24 Jan 2020 15:27:20 -0800 Subject: Start on new patch infrastructure --- src/WixToolset.Core.Burn/Bind/BindBundleCommand.cs | 1 - .../Bundles/CreateNonUXContainers.cs | 4 +- .../Bind/AssignMediaCommand.cs | 28 +- .../Bind/AttachPatchTransformsCommand.cs | 1322 ++++++++++++++++++++ .../Bind/BindDatabaseCommand.cs | 490 ++++---- .../Bind/BindTransformCommand.cs | 197 ++- .../Bind/CabinetBuilder.cs | 6 +- .../Bind/CabinetResolver.cs | 4 +- .../Bind/CopyTransformDataCommand.cs | 222 ++-- .../Bind/CreateDeltaPatchesCommand.cs | 2 +- .../Bind/CreateIdtFileCommand.cs | 16 +- .../Bind/CreateOutputFromIRCommand.cs | 353 +++--- .../Bind/CreatePatchTransformsCommand.cs | 90 ++ .../Bind/ExtractMergeModuleFilesCommand.cs | 40 +- .../Bind/GenerateDatabaseCommand.cs | 535 ++++---- .../Bind/GenerateTransformCommand.cs | 588 +++++++++ .../Bind/GetFileFacadesCommand.cs | 2 +- .../Bind/GetFileFacadesFromTransforms.cs | 585 +++++++++ .../Bind/LoadTableDefinitionsCommand.cs | 21 +- .../Bind/MergeModulesCommand.cs | 8 +- .../Bind/PatchTransform.cs | 246 ++++ .../Bind/ProcessUncompressedFilesCommand.cs | 8 +- .../Bind/SequenceActionsCommand.cs | 13 +- .../Bind/UpdateFileFacadesCommand.cs | 102 +- .../Bind/UpdateMediaSequencesCommand.cs | 20 +- .../Data/tables.xml | 4 + src/WixToolset.Core.WindowsInstaller/Differ.cs | 4 + .../Inscribe/InscribeMsiPackageCommand.cs | 80 +- src/WixToolset.Core.WindowsInstaller/MspBackend.cs | 68 +- src/WixToolset.Core.WindowsInstaller/MstBackend.cs | 2 +- .../Ole32/Storage.cs | 2 +- src/WixToolset.Core.WindowsInstaller/Patch.cs | 7 +- .../PatchTransform.cs | 7 +- .../Unbind/UnbindMsiOrMsmCommand.cs | 2 +- .../Unbind/UnbindTranformCommand.cs | 125 +- .../WindowsInstallerBackendFactory.cs | 5 +- src/WixToolset.Core/Bind/FileFacade.cs | 128 +- src/WixToolset.Core/Bind/ResolveFieldsCommand.cs | 8 +- src/WixToolset.Core/Compiler.cs | 48 +- src/WixToolset.Core/Compiler_2.cs | 6 - src/WixToolset.Core/Compiler_Patch.cs | 3 +- src/WixToolset.Core/Compiler_UI.cs | 6 +- src/WixToolset.Core/Resolver.cs | 2 +- .../WixToolsetTest.CoreIntegration/PatchFixture.cs | 112 ++ .../PreprocessorFixture.cs | 28 - .../TestData/PatchFamilyFilter/.data/Av1.0.0.txt | 1 + .../TestData/PatchFamilyFilter/.data/Av1.0.1.txt | 1 + .../TestData/PatchFamilyFilter/.data/Bv1.0.0.txt | 1 + .../TestData/PatchFamilyFilter/.data/Bv1.0.1.txt | 1 + .../TestData/PatchFamilyFilter/Package.wxs | 31 + .../TestData/PatchFamilyFilter/Patch.wxs | 23 + .../TestData/PatchSingle/.data/Av1.0.0.txt | 1 + .../TestData/PatchSingle/.data/Av1.0.1.txt | 1 + .../TestData/PatchSingle/.data/Bv1.0.0.txt | 1 + .../TestData/PatchSingle/.data/Bv1.0.1.txt | 1 + .../TestData/PatchSingle/Package.wxs | 31 + .../TestData/PatchSingle/Patch.wxs | 16 + .../WixToolsetTest.CoreIntegration.csproj | 14 +- 58 files changed, 4481 insertions(+), 1192 deletions(-) create mode 100644 src/WixToolset.Core.WindowsInstaller/Bind/AttachPatchTransformsCommand.cs create mode 100644 src/WixToolset.Core.WindowsInstaller/Bind/CreatePatchTransformsCommand.cs create mode 100644 src/WixToolset.Core.WindowsInstaller/Bind/GenerateTransformCommand.cs create mode 100644 src/WixToolset.Core.WindowsInstaller/Bind/GetFileFacadesFromTransforms.cs create mode 100644 src/WixToolset.Core.WindowsInstaller/Bind/PatchTransform.cs create mode 100644 src/test/WixToolsetTest.CoreIntegration/PatchFixture.cs create mode 100644 src/test/WixToolsetTest.CoreIntegration/TestData/PatchFamilyFilter/.data/Av1.0.0.txt create mode 100644 src/test/WixToolsetTest.CoreIntegration/TestData/PatchFamilyFilter/.data/Av1.0.1.txt create mode 100644 src/test/WixToolsetTest.CoreIntegration/TestData/PatchFamilyFilter/.data/Bv1.0.0.txt create mode 100644 src/test/WixToolsetTest.CoreIntegration/TestData/PatchFamilyFilter/.data/Bv1.0.1.txt create mode 100644 src/test/WixToolsetTest.CoreIntegration/TestData/PatchFamilyFilter/Package.wxs create mode 100644 src/test/WixToolsetTest.CoreIntegration/TestData/PatchFamilyFilter/Patch.wxs create mode 100644 src/test/WixToolsetTest.CoreIntegration/TestData/PatchSingle/.data/Av1.0.0.txt create mode 100644 src/test/WixToolsetTest.CoreIntegration/TestData/PatchSingle/.data/Av1.0.1.txt create mode 100644 src/test/WixToolsetTest.CoreIntegration/TestData/PatchSingle/.data/Bv1.0.0.txt create mode 100644 src/test/WixToolsetTest.CoreIntegration/TestData/PatchSingle/.data/Bv1.0.1.txt create mode 100644 src/test/WixToolsetTest.CoreIntegration/TestData/PatchSingle/Package.wxs create mode 100644 src/test/WixToolsetTest.CoreIntegration/TestData/PatchSingle/Patch.wxs diff --git a/src/WixToolset.Core.Burn/Bind/BindBundleCommand.cs b/src/WixToolset.Core.Burn/Bind/BindBundleCommand.cs index c2164744..283cd115 100644 --- a/src/WixToolset.Core.Burn/Bind/BindBundleCommand.cs +++ b/src/WixToolset.Core.Burn/Bind/BindBundleCommand.cs @@ -208,7 +208,6 @@ namespace WixToolset.Core.Burn variableCache.Add(String.Concat("packageManufacturer.", facade.PackageId), msiPackage.Manufacturer); } } - } break; diff --git a/src/WixToolset.Core.Burn/Bundles/CreateNonUXContainers.cs b/src/WixToolset.Core.Burn/Bundles/CreateNonUXContainers.cs index 612e0e11..34e601a7 100644 --- a/src/WixToolset.Core.Burn/Bundles/CreateNonUXContainers.cs +++ b/src/WixToolset.Core.Burn/Bundles/CreateNonUXContainers.cs @@ -113,7 +113,7 @@ namespace WixToolset.Core.Burn.Bundles ++attachedContainerIndex; } - this.CreateContainer(container, containerPayloads, null); + this.CreateContainer(container, containerPayloads); } } @@ -122,7 +122,7 @@ namespace WixToolset.Core.Burn.Bundles this.FileTransfers = fileTransfers; } - private void CreateContainer(WixBundleContainerTuple container, IEnumerable containerPayloads, string manifestFile) + private void CreateContainer(WixBundleContainerTuple container, IEnumerable containerPayloads) { var command = new CreateContainerCommand(containerPayloads, container.WorkingPath, this.DefaultCompressionLevel); command.Execute(); diff --git a/src/WixToolset.Core.WindowsInstaller/Bind/AssignMediaCommand.cs b/src/WixToolset.Core.WindowsInstaller/Bind/AssignMediaCommand.cs index 2199bbde..2bfd587f 100644 --- a/src/WixToolset.Core.WindowsInstaller/Bind/AssignMediaCommand.cs +++ b/src/WixToolset.Core.WindowsInstaller/Bind/AssignMediaCommand.cs @@ -57,7 +57,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind var mediaRows = new Dictionary(); - List uncompressedFiles = new List(); + var uncompressedFiles = new List(); var mediaTable = this.Section.Tuples.OfType().ToList(); var mediaTemplateTable = this.Section.Tuples.OfType().ToList(); @@ -109,8 +109,8 @@ namespace WixToolset.Core.WindowsInstaller.Bind ulong currentPreCabSize = 0; ulong maxPreCabSizeInBytes; - int maxPreCabSizeInMB = 0; - int currentCabIndex = 0; + var maxPreCabSizeInMB = 0; + var currentCabIndex = 0; MediaTuple currentMediaRow = null; @@ -131,7 +131,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind this.CabinetNameTemplate = mediaTemplateRow.CabinetTemplate; } - string mumsString = Environment.GetEnvironmentVariable("WIX_MUMS"); + var mumsString = Environment.GetEnvironmentVariable("WIX_MUMS"); try { @@ -170,13 +170,13 @@ namespace WixToolset.Core.WindowsInstaller.Bind { // Associate current file with last cab (irrespective of the size) and cab index is not incremented anymore. var cabinetFiles = filesByCabinetMedia[currentMediaRow]; - facade.File.DiskId = currentCabIndex; + facade.DiskId = currentCabIndex; cabinetFiles.Add(facade); continue; } // Update current cab size. - currentPreCabSize += (ulong)facade.File.FileSize; + currentPreCabSize += (ulong)facade.FileSize; if (currentPreCabSize > maxPreCabSizeInBytes) { @@ -186,10 +186,10 @@ namespace WixToolset.Core.WindowsInstaller.Bind filesByCabinetMedia.Add(currentMediaRow, new List()); var cabinetFileRows = filesByCabinetMedia[currentMediaRow]; - facade.File.DiskId = currentCabIndex; + facade.DiskId = currentCabIndex; cabinetFileRows.Add(facade); // Now files larger than MaxUncompressedMediaSize will be the only file in its cabinet so as to respect MaxUncompressedMediaSize - currentPreCabSize = (ulong)facade.File.FileSize; + currentPreCabSize = (ulong)facade.FileSize; } else { @@ -204,7 +204,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind // Associate current file with current cab. var cabinetFiles = filesByCabinetMedia[currentMediaRow]; - facade.File.DiskId = currentCabIndex; + facade.DiskId = currentCabIndex; cabinetFiles.Add(facade); } } @@ -260,18 +260,18 @@ namespace WixToolset.Core.WindowsInstaller.Bind } } - foreach (FileFacade facade in fileFacades) + foreach (var facade in fileFacades) { if (!mediaRows.TryGetValue(facade.DiskId, out var mediaRow)) { - this.Messaging.Write(ErrorMessages.MissingMedia(facade.File.SourceLineNumbers, facade.DiskId)); + this.Messaging.Write(ErrorMessages.MissingMedia(facade.SourceLineNumber, facade.DiskId)); continue; } // When building a product, if the current file is to be uncompressed or if // the package set not to be compressed, don't cab it. - var compressed = (facade.File.Attributes & FileTupleAttributes.Compressed) == FileTupleAttributes.Compressed; - var uncompressed = (facade.File.Attributes & FileTupleAttributes.Uncompressed) == FileTupleAttributes.Uncompressed; + var compressed = facade.Compressed; + var uncompressed = facade.Uncompressed; if (SectionType.Product == this.Section.Type && (uncompressed || (!compressed && !this.FilesCompressed))) { uncompressedFiles.Add(facade); @@ -284,7 +284,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind } else { - this.Messaging.Write(ErrorMessages.ExpectedMediaCabinet(facade.File.SourceLineNumbers, facade.File.Id.Id, facade.DiskId)); + this.Messaging.Write(ErrorMessages.ExpectedMediaCabinet(facade.SourceLineNumber, facade.Id, facade.DiskId)); } } } diff --git a/src/WixToolset.Core.WindowsInstaller/Bind/AttachPatchTransformsCommand.cs b/src/WixToolset.Core.WindowsInstaller/Bind/AttachPatchTransformsCommand.cs new file mode 100644 index 00000000..aa5ca20a --- /dev/null +++ b/src/WixToolset.Core.WindowsInstaller/Bind/AttachPatchTransformsCommand.cs @@ -0,0 +1,1322 @@ +// 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.Core.WindowsInstaller.Bind +{ + using System; + using System.Collections.Generic; + using System.Globalization; + using System.Linq; + using System.Text.RegularExpressions; + using WixToolset.Core.WindowsInstaller; + using WixToolset.Core.WindowsInstaller.Msi; + using WixToolset.Data; + using WixToolset.Data.Tuples; + using WixToolset.Data.WindowsInstaller; + using WixToolset.Data.WindowsInstaller.Rows; + using WixToolset.Extensibility.Services; + + /// + /// Include transforms in a patch. + /// + internal class AttachPatchTransformsCommand + { + private static readonly string[] PatchUninstallBreakingTables = new[] + { + "AppId", + "BindImage", + "Class", + "Complus", + "CreateFolder", + "DuplicateFile", + "Environment", + "Extension", + "Font", + "IniFile", + "IsolatedComponent", + "LockPermissions", + "MIME", + "MoveFile", + "MsiLockPermissionsEx", + "MsiServiceConfig", + "MsiServiceConfigFailureActions", + "ODBCAttribute", + "ODBCDataSource", + "ODBCDriver", + "ODBCSourceAttribute", + "ODBCTranslator", + "ProgId", + "PublishComponent", + "RemoveIniFile", + "SelfReg", + "ServiceControl", + "ServiceInstall", + "TypeLib", + "Verb", + }; + + private readonly TableDefinitionCollection tableDefinitions; + + public AttachPatchTransformsCommand(IMessaging messaging, Intermediate intermediate, IEnumerable transforms) + { + this.tableDefinitions = new TableDefinitionCollection(WindowsInstallerStandardInternal.GetTableDefinitions()); + this.Messaging = messaging; + this.Intermediate = intermediate; + this.Transforms = transforms; + } + + private IMessaging Messaging { get; } + + private Intermediate Intermediate { get; } + + private IEnumerable Transforms { get; } + + public IEnumerable SubStorages { get; private set; } + + public IEnumerable Execute() + { + var subStorages = new List(); + + if (this.Transforms == null || !this.Transforms.Any()) + { + this.Messaging.Write(ErrorMessages.PatchWithoutTransforms()); + return subStorages; + } + + var summaryInfo = this.ExtractPatchSummaryInfo(); + + var section = this.Intermediate.Sections.First(); + + var tuples = this.Intermediate.Sections.SelectMany(s => s.Tuples).ToList(); + + // Get the patch id from the WixPatchId tuple. + var patchIdTuple = tuples.OfType().FirstOrDefault(); + + if (String.IsNullOrEmpty(patchIdTuple.Id?.Id)) + { + this.Messaging.Write(ErrorMessages.ExpectedPatchIdInWixMsp()); + return subStorages; + } + + if (String.IsNullOrEmpty(patchIdTuple.ClientPatchId)) + { + this.Messaging.Write(ErrorMessages.ExpectedClientPatchIdInWixMsp()); + return subStorages; + } + + // enumerate patch.Media to map diskId to Media row + var patchMediaByDiskId = tuples.OfType().ToDictionary(t => t.DiskId); + + if (patchMediaByDiskId.Count == 0) + { + this.Messaging.Write(ErrorMessages.ExpectedMediaRowsInWixMsp()); + return subStorages; + } + + // populate MSP summary information + var patchMetadata = this.PopulateSummaryInformation(summaryInfo, tuples, patchIdTuple, section.Codepage); + + // enumerate transforms + var productCodes = new SortedSet(); + var transformNames = new List(); + var validTransform = new List>(); + + var baselineTuplesById = tuples.OfType().ToDictionary(t => t.Id.Id); + + foreach (var mainTransform in this.Transforms) + { + var baselineTuple = baselineTuplesById[mainTransform.Baseline]; + + var patchRefTuples = tuples.OfType().ToList(); + if (patchRefTuples.Count > 0) + { + if (!this.ReduceTransform(mainTransform.Transform, patchRefTuples)) + { + // transform has none of the content authored into this patch + continue; + } + } + + // Validate the transform doesn't break any patch specific rules. + this.Validate(mainTransform); + + // ensure consistent File.Sequence within each Media + var mediaTuple = patchMediaByDiskId[baselineTuple.DiskId]; + + // Ensure that files are sequenced after the last file in any transform. + var transformMediaTable = mainTransform.Transform.Tables["Media"]; + if (null != transformMediaTable && 0 < transformMediaTable.Rows.Count) + { + foreach (MediaRow transformMediaRow in transformMediaTable.Rows) + { + if (mediaTuple.LastSequence < transformMediaRow.LastSequence) + { + // The Binder will pre-increment the sequence. + mediaTuple.LastSequence = transformMediaRow.LastSequence; + } + } + } + + // Use the Media/@DiskId if greater than the last sequence for backward compatibility. + if (mediaTuple.LastSequence < mediaTuple.DiskId) + { + mediaTuple.LastSequence = mediaTuple.DiskId; + } + + // Ignore media table in the transform. + mainTransform.Transform.Tables.Remove("Media"); + mainTransform.Transform.Tables.Remove("WixMedia"); + mainTransform.Transform.Tables.Remove("MsiDigitalSignature"); + + var pairedTransform = this.BuildPairedTransform(summaryInfo, patchMetadata, patchIdTuple, mainTransform.Transform, mediaTuple, baselineTuple, out var productCode); + + productCode = productCode.ToUpperInvariant(); + productCodes.Add(productCode); + validTransform.Add(Tuple.Create(productCode, mainTransform.Transform)); + + // attach these transforms to the patch object + // TODO: is this an acceptable way to auto-generate transform stream names? + var transformName = mainTransform.Baseline + "." + validTransform.Count.ToString(CultureInfo.InvariantCulture); + subStorages.Add(new SubStorage(transformName, mainTransform.Transform)); + subStorages.Add(new SubStorage("#" + transformName, pairedTransform)); + + transformNames.Add(":" + transformName); + transformNames.Add(":#" + transformName); + } + + if (validTransform.Count == 0) + { + this.Messaging.Write(ErrorMessages.PatchWithoutValidTransforms()); + return subStorages; + } + + // Validate that a patch authored as removable is actually removable + if (patchMetadata.TryGetValue("AllowRemoval", out var allowRemoval) && allowRemoval.Value == "1") + { + var uninstallable = true; + + foreach (var entry in validTransform) + { + uninstallable &= this.CheckUninstallableTransform(entry.Item1, entry.Item2); + } + + if (!uninstallable) + { + this.Messaging.Write(ErrorMessages.PatchNotRemovable()); + return subStorages; + } + } + + // Finish filling tables with transform-dependent data. + productCodes = FinalizePatchProductCodes(tuples, productCodes); + + // Semicolon delimited list of the product codes that can accept the patch. + summaryInfo.Add(SumaryInformationType.PatchProductCodes, new SummaryInformationTuple(patchIdTuple.SourceLineNumbers) + { + PropertyId = SumaryInformationType.PatchProductCodes, + Value = String.Join(";", productCodes) + }); + + // Semicolon delimited list of transform substorage names in the order they are applied. + summaryInfo.Add(SumaryInformationType.TransformNames, new SummaryInformationTuple(patchIdTuple.SourceLineNumbers) + { + PropertyId = SumaryInformationType.TransformNames, + Value = String.Join(";", transformNames) + }); + + // Put the summary information that was extracted back in now that it is updated. + foreach (var readSummaryInfo in summaryInfo.Values.OrderBy(s => s.PropertyId)) + { + section.Tuples.Add(readSummaryInfo); + } + + this.SubStorages = subStorages; + + return subStorages; + } + + private Dictionary ExtractPatchSummaryInfo() + { + var result = new Dictionary(); + + foreach (var section in this.Intermediate.Sections) + { + for (var i = section.Tuples.Count - 1; i >= 0; i--) + { + if (section.Tuples[i] is SummaryInformationTuple patchSummaryInfo) + { + // Remove all summary information from the tuples and remember those that + // are not calculated or reserved. + section.Tuples.RemoveAt(i); + + if (patchSummaryInfo.PropertyId != SumaryInformationType.PatchProductCodes && + patchSummaryInfo.PropertyId != SumaryInformationType.PatchCode && + patchSummaryInfo.PropertyId != SumaryInformationType.PatchInstallerRequirement && + patchSummaryInfo.PropertyId != SumaryInformationType.Reserved11 && + patchSummaryInfo.PropertyId != SumaryInformationType.Reserved14 && + patchSummaryInfo.PropertyId != SumaryInformationType.Reserved16) + { + result.Add(patchSummaryInfo.PropertyId, patchSummaryInfo); + } + } + } + } + + return result; + } + + private Dictionary PopulateSummaryInformation(Dictionary summaryInfo, List tuples, WixPatchIdTuple patchIdTuple, int codepage) + { + // PID_CODEPAGE + if (!summaryInfo.ContainsKey(SumaryInformationType.Codepage)) + { + // Set the code page by default to the same code page for the + // string pool in the database. + AddSummaryInformation(SumaryInformationType.Codepage, codepage.ToString(CultureInfo.InvariantCulture), patchIdTuple.SourceLineNumbers); + } + + // GUID patch code for the patch. + AddSummaryInformation(SumaryInformationType.PatchCode, patchIdTuple.Id.Id, patchIdTuple.SourceLineNumbers); + + // Indicates the minimum Windows Installer version that is required to install the patch. + AddSummaryInformation(SumaryInformationType.PatchInstallerRequirement, ((int)SummaryInformation.InstallerRequirement.Version31).ToString(CultureInfo.InvariantCulture), patchIdTuple.SourceLineNumbers); + + if (!summaryInfo.ContainsKey(SumaryInformationType.Security)) + { + AddSummaryInformation(SumaryInformationType.Security, "4", patchIdTuple.SourceLineNumbers); // Read-only enforced; + } + + // Use authored comments or default to display name. + MsiPatchMetadataTuple commentsTuple = null; + + var metadataTuples = tuples.OfType().Where(t => String.IsNullOrEmpty(t.Company)).ToDictionary(t => t.Property); + + if (!summaryInfo.ContainsKey(SumaryInformationType.Title) && + metadataTuples.TryGetValue("DisplayName", out var displayName)) + { + AddSummaryInformation(SumaryInformationType.Title, displayName.Value, displayName.SourceLineNumbers); + + // Default comments to use display name as-is. + commentsTuple = displayName; + } + + // TODO: This code below seems unnecessary given the codepage is set at the top of this method. + //if (!summaryInfo.ContainsKey(SumaryInformationType.Codepage) && + // metadataValues.TryGetValue("CodePage", out var codepage)) + //{ + // AddSummaryInformation(SumaryInformationType.Codepage, codepage); + //} + + if (!summaryInfo.ContainsKey(SumaryInformationType.PatchPackageName) && + metadataTuples.TryGetValue("Description", out var description)) + { + AddSummaryInformation(SumaryInformationType.PatchPackageName, description.Value, description.SourceLineNumbers); + } + + if (!summaryInfo.ContainsKey(SumaryInformationType.Author) && + metadataTuples.TryGetValue("ManufacturerName", out var manufacturer)) + { + AddSummaryInformation(SumaryInformationType.Author, manufacturer.Value, manufacturer.SourceLineNumbers); + } + + // Special metadata marshalled through the build. + //var wixMetadataValues = tuples.OfType().ToDictionary(t => t.Id.Id, t => t.Value); + + //if (wixMetadataValues.TryGetValue("Comments", out var wixComments)) + if (metadataTuples.TryGetValue("Comments", out var wixComments)) + { + commentsTuple = wixComments; + } + + // Write the package comments to summary info. + if (!summaryInfo.ContainsKey(SumaryInformationType.Comments) && + commentsTuple != null) + { + AddSummaryInformation(SumaryInformationType.Comments, commentsTuple.Value, commentsTuple.SourceLineNumbers); + } + + return metadataTuples; + + void AddSummaryInformation(SumaryInformationType type, string value, SourceLineNumber sourceLineNumber) + { + summaryInfo.Add(type, new SummaryInformationTuple(sourceLineNumber) + { + PropertyId = type, + Value = value + }); + } + } + + /// + /// Ensure transform is uninstallable. + /// + /// Product code in transform. + /// Transform generated by torch. + /// True if the transform is uninstallable + private bool CheckUninstallableTransform(string productCode, WindowsInstallerData transform) + { + var success = true; + + foreach (var tableName in PatchUninstallBreakingTables) + { + if (transform.TryGetTable(tableName, out var table)) + { + foreach (var row in table.Rows) + { + if (row.Operation == RowOperation.Add) + { + success = false; + + var primaryKey = row.GetPrimaryKey('/') ?? String.Empty; + + this.Messaging.Write(ErrorMessages.NewRowAddedInTable(row.SourceLineNumbers, productCode, table.Name, primaryKey)); + } + } + } + } + + return success; + } + + /// + /// Reduce the transform according to the patch references. + /// + /// transform generated by torch. + /// Table contains patch family filter. + /// true if the transform is not empty + private bool ReduceTransform(WindowsInstallerData transform, IEnumerable patchRefTuples) + { + // identify sections to keep + var oldSections = new Dictionary(); + var newSections = new Dictionary(); + var tableKeyRows = new Dictionary>(); + var sequenceList = new List(); + var componentFeatureAddsIndex = new Dictionary>(); + var customActionTable = new Dictionary(); + var directoryTableAdds = new Dictionary(); + var featureTableAdds = new Dictionary(); + var keptComponents = new Dictionary(); + var keptDirectories = new Dictionary(); + var keptFeatures = new Dictionary(); + var keptLockPermissions = new HashSet(); + var keptMsiLockPermissionExs = new HashSet(); + + var componentCreateFolderIndex = new Dictionary>(); + var directoryLockPermissionsIndex = new Dictionary>(); + var directoryMsiLockPermissionsExIndex = new Dictionary>(); + + foreach (var patchRefTuple in patchRefTuples) + { + var tableName = patchRefTuple.Table; + var key = patchRefTuple.PrimaryKeys; + + // Short circuit filtering if all changes should be included. + if ("*" == tableName && "*" == key) + { + RemoveProductCodeFromTransform(transform); + return true; + } + + if (!transform.Tables.TryGetTable(tableName, out var table)) + { + // Table not found. + continue; + } + + // Index the table. + if (!tableKeyRows.TryGetValue(tableName, out var keyRows)) + { + keyRows = new Dictionary(); + tableKeyRows.Add(tableName, keyRows); + + foreach (var newRow in table.Rows) + { + var primaryKey = newRow.GetPrimaryKey(); + keyRows.Add(primaryKey, newRow); + } + } + + if (!keyRows.TryGetValue(key, out var row)) + { + // Row not found. + continue; + } + + // Differ.sectionDelimiter + var sections = row.SectionId.Split('/'); + oldSections[sections[0]] = row; + newSections[sections[1]] = row; + } + + // throw away sections not referenced + var keptRows = 0; + Table directoryTable = null; + Table featureTable = null; + Table lockPermissionsTable = null; + Table msiLockPermissionsTable = null; + + foreach (var table in transform.Tables) + { + if ("_SummaryInformation" == table.Name) + { + continue; + } + + if (table.Name == "AdminExecuteSequence" + || table.Name == "AdminUISequence" + || table.Name == "AdvtExecuteSequence" + || table.Name == "InstallUISequence" + || table.Name == "InstallExecuteSequence") + { + sequenceList.Add(table); + continue; + } + + for (var i = 0; i < table.Rows.Count; i++) + { + var row = table.Rows[i]; + + if (table.Name == "CreateFolder") + { + var createFolderComponentId = row.FieldAsString(1); + + if (!componentCreateFolderIndex.TryGetValue(createFolderComponentId, out var directoryList)) + { + directoryList = new List(); + componentCreateFolderIndex.Add(createFolderComponentId, directoryList); + } + + directoryList.Add(row.FieldAsString(0)); + } + + if (table.Name == "CustomAction") + { + customActionTable.Add(row.FieldAsString(0), row); + } + + if (table.Name == "Directory") + { + directoryTable = table; + if (RowOperation.Add == row.Operation) + { + directoryTableAdds.Add(row.FieldAsString(0), row); + } + } + + if (table.Name == "Feature") + { + featureTable = table; + if (RowOperation.Add == row.Operation) + { + featureTableAdds.Add(row.FieldAsString(0), row); + } + } + + if (table.Name == "FeatureComponents") + { + if (RowOperation.Add == row.Operation) + { + var featureId = row.FieldAsString(0); + var componentId = row.FieldAsString(1); + + if (!componentFeatureAddsIndex.TryGetValue(componentId, out var featureList)) + { + featureList = new List(); + componentFeatureAddsIndex.Add(componentId, featureList); + } + + featureList.Add(featureId); + } + } + + if (table.Name == "LockPermissions") + { + lockPermissionsTable = table; + if ("CreateFolder" == row.FieldAsString(1)) + { + var directoryId = row.FieldAsString(0); + + if (!directoryLockPermissionsIndex.TryGetValue(directoryId, out var rowList)) + { + rowList = new List(); + directoryLockPermissionsIndex.Add(directoryId, rowList); + } + + rowList.Add(row); + } + } + + if (table.Name == "MsiLockPermissionsEx") + { + msiLockPermissionsTable = table; + if ("CreateFolder" == row.FieldAsString(1)) + { + var directoryId = row.FieldAsString(0); + + if (!directoryMsiLockPermissionsExIndex.TryGetValue(directoryId, out var rowList)) + { + rowList = new List(); + directoryMsiLockPermissionsExIndex.Add(directoryId, rowList); + } + + rowList.Add(row); + } + } + + if (null == row.SectionId) + { + table.Rows.RemoveAt(i); + i--; + } + else + { + var sections = row.SectionId.Split('/'); + // ignore the row without section id. + if (0 == sections[0].Length && 0 == sections[1].Length) + { + table.Rows.RemoveAt(i); + i--; + } + else if (IsInPatchFamily(sections[0], sections[1], oldSections, newSections)) + { + if ("Component" == table.Name) + { + keptComponents.Add(row.FieldAsString(0), row); + } + + if ("Directory" == table.Name) + { + keptDirectories.Add(row.FieldAsString(0), row); + } + + if ("Feature" == table.Name) + { + keptFeatures.Add(row.FieldAsString(0), row); + } + + keptRows++; + } + else + { + table.Rows.RemoveAt(i); + i--; + } + } + } + } + + keptRows += ReduceTransformSequenceTable(sequenceList, oldSections, newSections, customActionTable); + + if (null != directoryTable) + { + foreach (var componentRow in keptComponents.Values) + { + var componentId = componentRow.FieldAsString(0); + + if (RowOperation.Add == componentRow.Operation) + { + // Make sure each added component has its required directory and feature heirarchy. + var directoryId = componentRow.FieldAsString(2); + while (null != directoryId && directoryTableAdds.TryGetValue(directoryId, out var directoryRow)) + { + if (!keptDirectories.ContainsKey(directoryId)) + { + directoryTable.Rows.Add(directoryRow); + keptDirectories.Add(directoryId, directoryRow); + keptRows++; + } + + directoryId = directoryRow.FieldAsString(1); + } + + if (componentFeatureAddsIndex.TryGetValue(componentId, out var componentFeatureIds)) + { + foreach (var featureId in componentFeatureIds) + { + var currentFeatureId = featureId; + while (null != currentFeatureId && featureTableAdds.TryGetValue(currentFeatureId, out var featureRow)) + { + if (!keptFeatures.ContainsKey(currentFeatureId)) + { + featureTable.Rows.Add(featureRow); + keptFeatures.Add(currentFeatureId, featureRow); + keptRows++; + } + + currentFeatureId = featureRow.FieldAsString(1); + } + } + } + } + + // Hook in changes LockPermissions and MsiLockPermissions for folders for each component that has been kept. + foreach (var keptComponentId in keptComponents.Keys) + { + if (componentCreateFolderIndex.TryGetValue(keptComponentId, out var directoryList)) + { + foreach (var directoryId in directoryList) + { + if (directoryLockPermissionsIndex.TryGetValue(directoryId, out var lockPermissionsRowList)) + { + foreach (var lockPermissionsRow in lockPermissionsRowList) + { + var key = lockPermissionsRow.GetPrimaryKey('/'); + if (keptLockPermissions.Add(key)) + { + lockPermissionsTable.Rows.Add(lockPermissionsRow); + keptRows++; + } + } + } + + if (directoryMsiLockPermissionsExIndex.TryGetValue(directoryId, out var msiLockPermissionsExRowList)) + { + foreach (var msiLockPermissionsExRow in msiLockPermissionsExRowList) + { + var key = msiLockPermissionsExRow.GetPrimaryKey('/'); + if (keptMsiLockPermissionExs.Add(key)) + { + msiLockPermissionsTable.Rows.Add(msiLockPermissionsExRow); + keptRows++; + } + } + } + } + } + } + } + } + + keptRows += ReduceTransformSequenceTable(sequenceList, oldSections, newSections, customActionTable); + + // Delete tables that are empty. + var tablesToDelete = transform.Tables.Where(t => t.Rows.Count == 0).Select(t => t.Name); + + foreach (var tableName in tablesToDelete) + { + transform.Tables.Remove(tableName); + } + + return keptRows > 0; + } + + private void Validate(PatchTransform patchTransform) + { + var transformPath = patchTransform.Baseline; // TODO: this is used in error messages, how best to set it? + var transform = patchTransform.Transform; + + // Changing the ProdocutCode in a patch transform is not recommended. + if (transform.TryGetTable("Property", out var propertyTable)) + { + foreach (var row in propertyTable.Rows) + { + // Only interested in modified rows; fast check. + if (RowOperation.Modify == row.Operation && + "ProductCode".Equals(row.FieldAsString(0), StringComparison.Ordinal)) + { + this.Messaging.Write(WarningMessages.MajorUpgradePatchNotRecommended()); + } + } + } + + // If there is nothing in the component table we can return early because the remaining checks are component based. + if (!transform.TryGetTable("Component", out var componentTable)) + { + return; + } + + // Index Feature table row operations + var featureOps = new Dictionary(); + if (transform.TryGetTable("Feature", out var featureTable)) + { + foreach (var row in featureTable.Rows) + { + featureOps[row.FieldAsString(0)] = row.Operation; + } + } + + // Index Component table and check for keypath modifications + var componentKeyPath = new Dictionary(); + var deletedComponent = new Dictionary(); + foreach (var row in componentTable.Rows) + { + var id = row.FieldAsString(0); + var keypath = row.FieldAsString(5) ?? String.Empty; + + componentKeyPath.Add(id, keypath); + + if (RowOperation.Delete == row.Operation) + { + deletedComponent.Add(id, row); + } + else if (RowOperation.Modify == row.Operation) + { + if (row.Fields[1].Modified) + { + // Changing the guid of a component is equal to deleting the old one and adding a new one. + deletedComponent.Add(id, row); + } + + // If the keypath is modified its an error + if (row.Fields[5].Modified) + { + this.Messaging.Write(ErrorMessages.InvalidKeypathChange(row.SourceLineNumbers, id, transformPath)); + } + } + } + + // Verify changes in the file table + if (transform.TryGetTable("File", out var fileTable)) + { + var componentWithChangedKeyPath = new Dictionary(); + foreach (var row in fileTable.Rows) + { + if (RowOperation.None == row.Operation) + { + continue; + } + + var fileId = row.FieldAsString(0); + var componentId = row.FieldAsString(1); + + // If this file is the keypath of a component + if (componentKeyPath.TryGetValue(componentId, out var keyPath) && keyPath.Equals(fileId, StringComparison.Ordinal)) + { + if (row.Fields[2].Modified) + { + // You can't change the filename of a file that is the keypath of a component. + this.Messaging.Write(ErrorMessages.InvalidKeypathChange(row.SourceLineNumbers, componentId, transformPath)); + } + + if (!componentWithChangedKeyPath.ContainsKey(componentId)) + { + componentWithChangedKeyPath.Add(componentId, fileId); + } + } + + if (RowOperation.Delete == row.Operation) + { + // If the file is removed from a component that is not deleted. + if (!deletedComponent.ContainsKey(componentId)) + { + var foundRemoveFileEntry = false; + var filename = Common.GetName(row.FieldAsString(2), false, true); + + if (transform.TryGetTable("RemoveFile", out var removeFileTable)) + { + foreach (var removeFileRow in removeFileTable.Rows) + { + if (RowOperation.Delete == removeFileRow.Operation) + { + continue; + } + + if (componentId == removeFileRow.FieldAsString(1)) + { + // Check if there is a RemoveFile entry for this file + if (null != removeFileRow[2]) + { + var removeFileName = Common.GetName(removeFileRow.FieldAsString(2), false, true); + + // Convert the MSI format for a wildcard string to Regex format. + removeFileName = removeFileName.Replace('.', '|').Replace('?', '.').Replace("*", ".*").Replace("|", "\\."); + + var regex = new Regex(removeFileName, RegexOptions.CultureInvariant | RegexOptions.IgnoreCase); + if (regex.IsMatch(filename)) + { + foundRemoveFileEntry = true; + break; + } + } + } + } + } + + if (!foundRemoveFileEntry) + { + this.Messaging.Write(WarningMessages.InvalidRemoveFile(row.SourceLineNumbers, fileId, componentId)); + } + } + } + } + } + + var featureComponentsTable = transform.Tables["FeatureComponents"]; + + if (0 < deletedComponent.Count) + { + // Index FeatureComponents table. + var featureComponents = new Dictionary>(); + + if (null != featureComponentsTable) + { + foreach (var row in featureComponentsTable.Rows) + { + var componentId = row.FieldAsString(1); + + if (!featureComponents.TryGetValue(componentId, out var features)) + { + features = new List(); + featureComponents.Add(componentId, features); + } + + features.Add(row.FieldAsString(0)); + } + } + + // Check to make sure if a component was deleted, the feature was too. + foreach (var entry in deletedComponent) + { + if (featureComponents.TryGetValue(entry.Key, out var features)) + { + foreach (var featureId in features) + { + if (!featureOps.TryGetValue(featureId, out var op) || op != RowOperation.Delete) + { + // The feature was not deleted. + this.Messaging.Write(ErrorMessages.InvalidRemoveComponent(((Row)entry.Value).SourceLineNumbers, entry.Key.ToString(), featureId, transformPath)); + } + } + } + } + } + + // Warn if new components are added to existing features + if (null != featureComponentsTable) + { + foreach (var row in featureComponentsTable.Rows) + { + if (RowOperation.Add == row.Operation) + { + // Check if the feature is in the Feature table + var feature_ = row.FieldAsString(0); + var component_ = row.FieldAsString(1); + + // Features may not be present if not referenced + if (!featureOps.ContainsKey(feature_) || RowOperation.Add != (RowOperation)featureOps[feature_]) + { + this.Messaging.Write(WarningMessages.NewComponentAddedToExistingFeature(row.SourceLineNumbers, component_, feature_, transformPath)); + } + } + } + } + } + + /// + /// Remove the ProductCode property from the transform. + /// + /// The transform. + /// + /// Changing the ProductCode is not supported in a patch. + /// + private static void RemoveProductCodeFromTransform(WindowsInstallerData transform) + { + if (transform.Tables.TryGetTable("Property", out var propertyTable)) + { + for (var i = 0; i < propertyTable.Rows.Count; ++i) + { + var propertyRow = propertyTable.Rows[i]; + var property = (string)propertyRow[0]; + + if ("ProductCode" == property) + { + propertyTable.Rows.RemoveAt(i); + break; + } + } + } + } + + /// + /// Check if the section is in a PatchFamily. + /// + /// Section id in target wixout + /// Section id in upgrade wixout + /// Dictionary contains section id should be kept in the baseline wixout. + /// Dictionary contains section id should be kept in the upgrade wixout. + /// true if section in patch family + private static bool IsInPatchFamily(string oldSection, string newSection, Dictionary oldSections, Dictionary newSections) + { + var result = false; + + if ((String.IsNullOrEmpty(oldSection) && newSections.ContainsKey(newSection)) || (String.IsNullOrEmpty(newSection) && oldSections.ContainsKey(oldSection))) + { + result = true; + } + else if (!String.IsNullOrEmpty(oldSection) && !String.IsNullOrEmpty(newSection) && (oldSections.ContainsKey(oldSection) || newSections.ContainsKey(newSection))) + { + result = true; + } + + return result; + } + + /// + /// Reduce the transform sequence tables. + /// + /// ArrayList of tables to be reduced + /// Hashtable contains section id should be kept in the baseline wixout. + /// Hashtable contains section id should be kept in the target wixout. + /// Hashtable contains all the rows in the CustomAction table. + /// Number of rows left + private static int ReduceTransformSequenceTable(List
sequenceList, Dictionary oldSections, Dictionary newSections, Dictionary customAction) + { + var keptRows = 0; + + foreach (var currentTable in sequenceList) + { + for (var i = 0; i < currentTable.Rows.Count; i++) + { + var row = currentTable.Rows[i]; + var actionName = row.Fields[0].Data.ToString(); + var sections = row.SectionId.Split('/'); + var isSectionIdEmpty = (sections[0].Length == 0 && sections[1].Length == 0); + + if (row.Operation == RowOperation.None) + { + // ignore the rows without section id. + if (isSectionIdEmpty) + { + currentTable.Rows.RemoveAt(i); + i--; + } + else if (IsInPatchFamily(sections[0], sections[1], oldSections, newSections)) + { + keptRows++; + } + else + { + currentTable.Rows.RemoveAt(i); + i--; + } + } + else if (row.Operation == RowOperation.Modify) + { + var sequenceChanged = row.Fields[2].Modified; + var conditionChanged = row.Fields[1].Modified; + + if (sequenceChanged && !conditionChanged) + { + keptRows++; + } + else if (!sequenceChanged && conditionChanged) + { + if (isSectionIdEmpty) + { + currentTable.Rows.RemoveAt(i); + i--; + } + else if (IsInPatchFamily(sections[0], sections[1], oldSections, newSections)) + { + keptRows++; + } + else + { + currentTable.Rows.RemoveAt(i); + i--; + } + } + else if (sequenceChanged && conditionChanged) + { + if (isSectionIdEmpty) + { + row.Fields[1].Modified = false; + keptRows++; + } + else if (IsInPatchFamily(sections[0], sections[1], oldSections, newSections)) + { + keptRows++; + } + else + { + row.Fields[1].Modified = false; + keptRows++; + } + } + } + else if (row.Operation == RowOperation.Delete) + { + if (isSectionIdEmpty) + { + // it is a stardard action which is added by wix, we should keep this action. + row.Operation = RowOperation.None; + keptRows++; + } + else if (IsInPatchFamily(sections[0], sections[1], oldSections, newSections)) + { + keptRows++; + } + else + { + if (customAction.ContainsKey(actionName)) + { + currentTable.Rows.RemoveAt(i); + i--; + } + else + { + // it is a stardard action, we should keep this action. + row.Operation = RowOperation.None; + keptRows++; + } + } + } + else if (row.Operation == RowOperation.Add) + { + if (isSectionIdEmpty) + { + keptRows++; + } + else if (IsInPatchFamily(sections[0], sections[1], oldSections, newSections)) + { + keptRows++; + } + else + { + if (customAction.ContainsKey(actionName)) + { + currentTable.Rows.RemoveAt(i); + i--; + } + else + { + keptRows++; + } + } + } + } + } + + return keptRows; + } + + /// + /// Create the #transform for the given main transform. + /// + private WindowsInstallerData BuildPairedTransform(Dictionary summaryInfo, Dictionary patchMetadata, WixPatchIdTuple patchIdTuple, WindowsInstallerData mainTransform, MediaTuple mediaTuple, WixPatchBaselineTuple baselineTuple, out string productCode) + { + productCode = null; + + var pairedTransform = new WindowsInstallerData(null) + { + Type = OutputType.Transform, + Codepage = mainTransform.Codepage + }; + + // lookup productVersion property to correct summaryInformation + var newProductVersion = mainTransform.Tables["Property"]?.Rows.FirstOrDefault(r => r.FieldAsString(0) == "ProductVersion")?.FieldAsString(1); + + var mainSummaryTable = mainTransform.Tables["_SummaryInformation"]; + var mainSummaryRows = mainSummaryTable.Rows.ToDictionary(r => r.FieldAsInteger(0)); + + var baselineValidationFlags = ((int)baselineTuple.ValidationFlags).ToString(CultureInfo.InvariantCulture); + + if (!mainSummaryRows.ContainsKey((int)SumaryInformationType.TransformValidationFlags)) + { + var mainSummaryRow = mainSummaryTable.CreateRow(baselineTuple.SourceLineNumbers); + mainSummaryRow[0] = (int)SumaryInformationType.TransformValidationFlags; + mainSummaryRow[1] = baselineValidationFlags; + } + + // copy summary information from core transform + var pairedSummaryTable = pairedTransform.EnsureTable(this.tableDefinitions["_SummaryInformation"]); + + foreach (var mainSummaryRow in mainSummaryTable.Rows) + { + var type = (SumaryInformationType)mainSummaryRow.FieldAsInteger(0); + var value = mainSummaryRow.FieldAsString(1); + switch (type) + { + case SumaryInformationType.TransformProductCodes: + var propertyData = value.Split(';'); + var oldProductVersion = propertyData[0].Substring(38); + var upgradeCode = propertyData[2]; + productCode = propertyData[0].Substring(0, 38); + + if (newProductVersion == null) + { + newProductVersion = oldProductVersion; + } + + // Force mainTranform to 'old;new;upgrade' and pairedTransform to 'new;new;upgrade' + mainSummaryRow[1] = String.Concat(productCode, oldProductVersion, ';', productCode, newProductVersion, ';', upgradeCode); + value = String.Concat(productCode, newProductVersion, ';', productCode, newProductVersion, ';', upgradeCode); + break; + case SumaryInformationType.TransformValidationFlags: // use validation flags authored into the patch XML. + value = baselineValidationFlags; + mainSummaryRow[1] = value; + break; + } + + var pairedSummaryRow = pairedSummaryTable.CreateRow(mainSummaryRow.SourceLineNumbers); + pairedSummaryRow[0] = mainSummaryRow[0]; + pairedSummaryRow[1] = value; + } + + if (productCode == null) + { + this.Messaging.Write(ErrorMessages.CouldNotDetermineProductCodeFromTransformSummaryInfo()); + return null; + } + + // copy File table + if (mainTransform.Tables.TryGetTable("File", out var mainFileTable) && 0 < mainFileTable.Rows.Count) + { +#if TODO_PATCHING + // We require file source information. + var mainWixFileTable = mainTransform.Tables["WixFile"]; + if (null == mainWixFileTable) + { + this.Messaging.Write(ErrorMessages.AdminImageRequired(productCode)); + return null; + } + + var mainFileRows = new RowDictionary(mainFileTable); + + var pairedFileTable = pairedTransform.EnsureTable(mainFileTable.Definition); + { + var mainFileRow = mainFileRows[mainWixFileRow.File]; + + // set File.Sequence to non null to satisfy transform bind + mainFileRow.Sequence = 1; + + // delete's don't need rows in the paired transform + if (mainFileRow.Operation == RowOperation.Delete) + { + continue; + } + + var pairedFileRow = (FileRow)pairedFileTable.CreateRow(null); + pairedFileRow.Operation = RowOperation.Modify; + for (var i = 0; i < mainFileRow.Fields.Length; i++) + { + pairedFileRow[i] = mainFileRow[i]; + } + + // override authored media for patch bind + mainWixFileRow.DiskId = mediaTuple.DiskId; + + // suppress any change to File.Sequence to avoid bloat + mainFileRow.Fields[7].Modified = false; + + // force File row to appear in the transform + switch (mainFileRow.Operation) + { + case RowOperation.Modify: + case RowOperation.Add: + pairedFileRow.Attributes |= WindowsInstallerConstants.MsidbFileAttributesPatchAdded; + pairedFileRow.Fields[6].Modified = true; + pairedFileRow.Operation = mainFileRow.Operation; + break; + default: + pairedFileRow.Fields[6].Modified = false; + break; + } + } +#endif + } + + // Add Media row to pairedTransform + var pairedMediaTable = pairedTransform.EnsureTable(this.tableDefinitions["Media"]); + var pairedMediaRow = pairedMediaTable.CreateRow(mediaTuple.SourceLineNumbers); + pairedMediaRow.Operation = RowOperation.Add; + pairedMediaRow[0] = mediaTuple.DiskId; + pairedMediaRow[1] = mediaTuple.LastSequence ?? 0; + pairedMediaRow[2] = mediaTuple.DiskPrompt; + pairedMediaRow[3] = mediaTuple.Cabinet; + pairedMediaRow[4] = mediaTuple.VolumeLabel; + pairedMediaRow[5] = mediaTuple.Source; + + // Add PatchPackage for this Media + var pairedPackageTable = pairedTransform.EnsureTable(this.tableDefinitions["PatchPackage"]); + pairedPackageTable.Operation = TableOperation.Add; + var pairedPackageRow = pairedPackageTable.CreateRow(mediaTuple.SourceLineNumbers); + pairedPackageRow.Operation = RowOperation.Add; + pairedPackageRow[0] = patchIdTuple.Id.Id; + pairedPackageRow[1] = mediaTuple.DiskId; + + // Add the property to the patch transform's Property table. + var pairedPropertyTable = pairedTransform.EnsureTable(this.tableDefinitions["Property"]); + pairedPropertyTable.Operation = TableOperation.Add; + + // Add property to both identify client patches and whether those patches are removable or not + patchMetadata.TryGetValue("AllowRemoval", out var allowRemovalTuple); + + var pairedPropertyRow = pairedPropertyTable.CreateRow(allowRemovalTuple?.SourceLineNumbers); + pairedPropertyRow.Operation = RowOperation.Add; + pairedPropertyRow[0] = String.Concat(patchIdTuple.ClientPatchId, ".AllowRemoval"); + pairedPropertyRow[1] = allowRemovalTuple?.Value ?? "0"; + + // Add this patch code GUID to the patch transform to identify + // which patches are installed, including in multi-patch + // installations. + pairedPropertyRow = pairedPropertyTable.CreateRow(patchIdTuple.SourceLineNumbers); + pairedPropertyRow.Operation = RowOperation.Add; + pairedPropertyRow[0] = String.Concat(patchIdTuple.ClientPatchId, ".PatchCode"); + pairedPropertyRow[1] = patchIdTuple.Id.Id; + + // Add PATCHNEWPACKAGECODE to apply to admin layouts. + pairedPropertyRow = pairedPropertyTable.CreateRow(patchIdTuple.SourceLineNumbers); + pairedPropertyRow.Operation = RowOperation.Add; + pairedPropertyRow[0] = "PATCHNEWPACKAGECODE"; + pairedPropertyRow[1] = patchIdTuple.Id.Id; + + // Add PATCHNEWSUMMARYCOMMENTS and PATCHNEWSUMMARYSUBJECT to apply to admin layouts. + if (summaryInfo.TryGetValue(SumaryInformationType.Subject, out var subjectTuple)) + { + pairedPropertyRow = pairedPropertyTable.CreateRow(subjectTuple.SourceLineNumbers); + pairedPropertyRow.Operation = RowOperation.Add; + pairedPropertyRow[0] = "PATCHNEWSUMMARYSUBJECT"; + pairedPropertyRow[1] = subjectTuple.Value; + } + + if (summaryInfo.TryGetValue(SumaryInformationType.Comments, out var commentsTuple)) + { + pairedPropertyRow = pairedPropertyTable.CreateRow(commentsTuple.SourceLineNumbers); + pairedPropertyRow.Operation = RowOperation.Add; + pairedPropertyRow[0] = "PATCHNEWSUMMARYCOMMENTS"; + pairedPropertyRow[1] = commentsTuple.Value; + } + + return pairedTransform; + } + + private static SortedSet FinalizePatchProductCodes(List tuples, SortedSet productCodes) + { + var patchTargetTuples = tuples.OfType().ToList(); + + if (patchTargetTuples.Count > 0) + { + var targets = new SortedSet(); + var replace = true; + foreach (var wixPatchTargetRow in patchTargetTuples) + { + var target = wixPatchTargetRow.ProductCode.ToUpperInvariant(); + if (target == "*") + { + replace = false; + } + else + { + targets.Add(target); + } + } + + // Replace the target ProductCodes with the authored list. + if (replace) + { + productCodes = targets; + } + else + { + // Copy the authored target ProductCodes into the list. + foreach (var target in targets) + { + productCodes.Add(target); + } + } + } + + return productCodes; + } + } +} diff --git a/src/WixToolset.Core.WindowsInstaller/Bind/BindDatabaseCommand.cs b/src/WixToolset.Core.WindowsInstaller/Bind/BindDatabaseCommand.cs index 175203ce..34104ef5 100644 --- a/src/WixToolset.Core.WindowsInstaller/Bind/BindDatabaseCommand.cs +++ b/src/WixToolset.Core.WindowsInstaller/Bind/BindDatabaseCommand.cs @@ -24,7 +24,11 @@ namespace WixToolset.Core.WindowsInstaller.Bind private bool disposed; - public BindDatabaseCommand(IBindContext context, IEnumerable backendExtension, Validator validator) + public BindDatabaseCommand(IBindContext context, IEnumerable backendExtension, Validator validator):this(context, backendExtension, null, validator) + { + } + + public BindDatabaseCommand(IBindContext context, IEnumerable backendExtension, IEnumerable subStorages, Validator validator) { this.ServiceProvider = context.ServiceProvider; @@ -45,6 +49,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind this.OutputPath = context.OutputPath; this.OutputPdbPath = context.OutputPdbPath; this.IntermediateFolder = context.IntermediateFolder; + this.SubStorages = subStorages; this.Validator = validator; this.BackendExtensions = backendExtension; @@ -76,6 +81,8 @@ namespace WixToolset.Core.WindowsInstaller.Bind private IEnumerable BackendExtensions { get; } + private IEnumerable SubStorages { get; } + private Intermediate Intermediate { get; } private string OutputPath { get; } @@ -112,18 +119,10 @@ namespace WixToolset.Core.WindowsInstaller.Bind // Load standard tables, authored custom tables, and extension custom tables. TableDefinitionCollection tableDefinitions; { - var command = new LoadTableDefinitionsCommand(section); + var command = new LoadTableDefinitionsCommand(section, this.BackendExtensions); command.Execute(); tableDefinitions = command.TableDefinitions; - - foreach (var backendExtension in this.BackendExtensions) - { - foreach (var tableDefinition in backendExtension.TableDefinitions) - { - tableDefinitions.Add(tableDefinition); - } - } } // Process the summary information table before the other tables. @@ -186,8 +185,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind // Sequence all the actions. { - var command = new SequenceActionsCommand(section); - command.Messaging = this.Messaging; + var command = new SequenceActionsCommand(this.Messaging, section); command.Execute(); } @@ -196,7 +194,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind command.Execute(); } -#if TODO_FINISH_PATCH +#if TODO_PATCHING ////if (OutputType.Patch == this.Output.Type) ////{ //// foreach (SubStorage substorage in this.Output.SubStorages) @@ -223,130 +221,162 @@ namespace WixToolset.Core.WindowsInstaller.Bind return; } - this.Messaging.Write(VerboseMessages.UpdatingFileInformation()); + // Call extension + var ExtensionSaidSkip = false; - // This must occur after all variables and source paths have been resolved. - List fileFacades; + WindowsInstallerData output; + if (ExtensionSaidSkip) { - var command = new GetFileFacadesCommand(section); + // Time to create the output object, since we're bypassing everything that touches files. + var command = new CreateOutputFromIRCommand(this.Messaging, section, tableDefinitions, this.BackendExtensions); command.Execute(); - fileFacades = command.FileFacades; + output = command.Output; } - - // Extract files that come from binary .wixlibs and WixExtensions (this does not extract files from merge modules). + else { - var command = new ExtractEmbeddedFilesCommand(this.ExpectedEmbeddedFiles); - command.Execute(); - } + this.Messaging.Write(VerboseMessages.UpdatingFileInformation()); - // Gather information about files that do not come from merge modules. - { - var command = new UpdateFileFacadesCommand(this.Messaging, section); - command.FileFacades = fileFacades; - command.UpdateFileFacades = fileFacades.Where(f => !f.FromModule); - command.OverwriteHash = true; - command.TableDefinitions = tableDefinitions; - command.VariableCache = variableCache; - command.Execute(); - } + // Extract files that come from binary .wixlibs and WixExtensions (this does not extract files from merge modules). + { + var command = new ExtractEmbeddedFilesCommand(this.ExpectedEmbeddedFiles); + command.Execute(); + } - // Now that the variable cache is populated, resolve any delayed fields. - if (this.DelayedFields.Any()) - { - var command = new ResolveDelayedFieldsCommand(this.Messaging, this.DelayedFields, variableCache); - command.Execute(); - } + // This must occur after all variables and source paths have been resolved. + List fileFacades; + { + var command = new GetFileFacadesCommand(section); + command.Execute(); - // Set generated component guids. - { - var command = new CalculateComponentGuids(this.Messaging, this.BackendHelper, this.PathResolver, section); - command.Execute(); - } + fileFacades = command.FileFacades; + } - // Retrieve file information from merge modules. - if (SectionType.Product == section.Type) - { - var wixMergeTuples = section.Tuples.OfType().ToList(); + // Retrieve file information from merge modules. + if (SectionType.Product == section.Type) + { + var wixMergeTuples = section.Tuples.OfType().ToList(); + + if (wixMergeTuples.Any()) + { + containsMergeModules = true; + + var command = new ExtractMergeModuleFilesCommand(this.Messaging, section, wixMergeTuples); + command.FileFacades = fileFacades; + command.OutputInstallerVersion = installerVersion; + command.SuppressLayout = this.SuppressLayout; + command.IntermediateFolder = this.IntermediateFolder; + command.Execute(); - if (wixMergeTuples.Any()) + fileFacades.AddRange(command.MergeModulesFileFacades); + } + } + else if (SectionType.Patch == section.Type) { - containsMergeModules = true; + // Merge transform data into the output object. + //IEnumerable filesFromTransform = this.CopyFromTransformData(this.Output); + + //var command = new CopyTransformDataCommand(this.Messaging, /*output*/this.SubStorages, tableDefinitions, copyOutFileRows: true); + //command.Output = output; + //command.TableDefinitions = this.TableDefinitions; + //command.CopyOutFileRows = true; + var command = new GetFileFacadesFromTransforms(this.Messaging, this.SubStorages, tableDefinitions); + command.Execute(); + var filesFromTransforms = command.FileFacades; - var command = new ExtractMergeModuleFilesCommand(this.Messaging, section, wixMergeTuples); + fileFacades.AddRange(filesFromTransforms); + } + + // stop processing if an error previously occurred + if (this.Messaging.EncounteredError) + { + return; + } + + // Gather information about files that do not come from merge modules. + { + var command = new UpdateFileFacadesCommand(this.Messaging, section); command.FileFacades = fileFacades; - command.OutputInstallerVersion = installerVersion; - command.SuppressLayout = this.SuppressLayout; - command.IntermediateFolder = this.IntermediateFolder; + command.UpdateFileFacades = fileFacades.Where(f => !f.FromModule); + command.OverwriteHash = true; + command.TableDefinitions = tableDefinitions; + command.VariableCache = variableCache; command.Execute(); - - fileFacades.AddRange(command.MergeModulesFileFacades); } - } -#if TODO_FINISH_PATCH - else if (OutputType.Patch == this.Output.Type) - { - // Merge transform data into the output object. - IEnumerable filesFromTransform = this.CopyFromTransformData(this.Output); - fileFacades.AddRange(filesFromTransform); - } -#endif + // Assign files to media. + Dictionary assignedMediaRows; + Dictionary> filesByCabinetMedia; + IEnumerable uncompressedFiles; + { + var command = new AssignMediaCommand(section, this.Messaging); + command.FileFacades = fileFacades; + command.FilesCompressed = compressed; + command.Execute(); - // stop processing if an error previously occurred - if (this.Messaging.EncounteredError) - { - return; - } + assignedMediaRows = command.MediaRows; + filesByCabinetMedia = command.FileFacadesByCabinetMedia; + uncompressedFiles = command.UncompressedFileFacades; + } - // Assign files to media. - Dictionary assignedMediaRows; - Dictionary> filesByCabinetMedia; - IEnumerable uncompressedFiles; - { - var command = new AssignMediaCommand(section, this.Messaging); - command.FileFacades = fileFacades; - command.FilesCompressed = compressed; - command.Execute(); + // stop processing if an error previously occurred + if (this.Messaging.EncounteredError) + { + return; + } - assignedMediaRows = command.MediaRows; - filesByCabinetMedia = command.FileFacadesByCabinetMedia; - uncompressedFiles = command.UncompressedFileFacades; - } + // Now that the variable cache is populated, resolve any delayed fields. + if (this.DelayedFields.Any()) + { + var command = new ResolveDelayedFieldsCommand(this.Messaging, this.DelayedFields, variableCache); + command.Execute(); + } - // stop processing if an error previously occurred - if (this.Messaging.EncounteredError) - { - return; - } + // Set generated component guids. + { + var command = new CalculateComponentGuids(this.Messaging, this.BackendHelper, this.PathResolver, section); + command.Execute(); + } - // Time to create the output object. Try to put as much above here as possible, updating the IR is better. - WindowsInstallerData output; - { - var command = new CreateOutputFromIRCommand(this.Messaging, section, tableDefinitions, this.BackendExtensions); - command.Execute(); + // stop processing if an error previously occurred + if (this.Messaging.EncounteredError) + { + return; + } - output = command.Output; - } + // Time to create the output object. Try to put as much above here as possible, updating the IR is better. + { + var command = new CreateOutputFromIRCommand(this.Messaging, section, tableDefinitions, this.BackendExtensions); + command.Execute(); - // Update file sequence. - { - var command = new UpdateMediaSequencesCommand(output, fileFacades); - command.Execute(); - } + output = command.Output; + } - // Modularize identifiers. - if (OutputType.Module == output.Type) - { - var command = new ModularizeCommand(output, modularizationGuid, section.Tuples.OfType()); - command.Execute(); - } - else // we can create instance transforms since Component Guids are set. - { + // Update file sequence. + { + var command = new UpdateMediaSequencesCommand(output, fileFacades); + command.Execute(); + } + + // Modularize identifiers. + if (OutputType.Module == output.Type) + { + var command = new ModularizeCommand(output, modularizationGuid, section.Tuples.OfType()); + command.Execute(); + } + else if (output.Type == OutputType.Patch) + { + foreach (var storage in this.SubStorages) + { + output.SubStorages.Add(storage); + } + } + else // we can create instance transforms since Component Guids are set. + { #if TODO_FIX_INSTANCE_TRANSFORM - this.CreateInstanceTransforms(this.Output); + this.CreateInstanceTransforms(this.Output); #endif - } + } #if TODO_FINISH_UPDATE // Extended binder extensions can be called now that fields are resolved. @@ -384,116 +414,121 @@ namespace WixToolset.Core.WindowsInstaller.Bind } #endif - // Stop processing if an error previously occurred. - if (this.Messaging.EncounteredError) - { - return; - } + this.ValidateComponentGuids(output); - // Ensure the intermediate folder is created since delta patches will be - // created there. - Directory.CreateDirectory(this.IntermediateFolder); + // Stop processing if an error previously occurred. + if (this.Messaging.EncounteredError) + { + return; + } - if (SectionType.Patch == section.Type && this.DeltaBinaryPatch) - { - var command = new CreateDeltaPatchesCommand(fileFacades, this.IntermediateFolder, section.Tuples.OfType().FirstOrDefault()); - command.Execute(); - } + // Ensure the intermediate folder is created since delta patches will be + // created there. + Directory.CreateDirectory(this.IntermediateFolder); - // create cabinet files and process uncompressed files - var layoutDirectory = Path.GetDirectoryName(this.OutputPath); - if (!this.SuppressLayout || OutputType.Module == output.Type) - { - this.Messaging.Write(VerboseMessages.CreatingCabinetFiles()); - - var command = new CreateCabinetsCommand(this.ServiceProvider, this.BackendHelper); - command.CabbingThreadCount = this.CabbingThreadCount; - command.CabCachePath = this.CabCachePath; - command.DefaultCompressionLevel = this.DefaultCompressionLevel; - command.Output = output; - command.Messaging = this.Messaging; - command.BackendExtensions = this.BackendExtensions; - command.LayoutDirectory = layoutDirectory; - command.Compressed = compressed; - command.FileRowsByCabinet = filesByCabinetMedia; - command.ResolveMedia = this.ResolveMedia; - command.TableDefinitions = tableDefinitions; - command.TempFilesLocation = this.IntermediateFolder; - command.Execute(); + if (SectionType.Patch == section.Type && this.DeltaBinaryPatch) + { + var command = new CreateDeltaPatchesCommand(fileFacades, this.IntermediateFolder, section.Tuples.OfType().FirstOrDefault()); + command.Execute(); + } - fileTransfers.AddRange(command.FileTransfers); - trackedFiles.AddRange(command.TrackedFiles); - } + // create cabinet files and process uncompressed files + var layoutDirectory = Path.GetDirectoryName(this.OutputPath); + if (!this.SuppressLayout || OutputType.Module == output.Type) + { + this.Messaging.Write(VerboseMessages.CreatingCabinetFiles()); + + var command = new CreateCabinetsCommand(this.ServiceProvider, this.BackendHelper); + command.CabbingThreadCount = this.CabbingThreadCount; + command.CabCachePath = this.CabCachePath; + command.DefaultCompressionLevel = this.DefaultCompressionLevel; + command.Output = output; + command.Messaging = this.Messaging; + command.BackendExtensions = this.BackendExtensions; + command.LayoutDirectory = layoutDirectory; + command.Compressed = compressed; + command.FileRowsByCabinet = filesByCabinetMedia; + command.ResolveMedia = this.ResolveMedia; + command.TableDefinitions = tableDefinitions; + command.TempFilesLocation = this.IntermediateFolder; + command.Execute(); -#if TODO_FINISH_PATCH - if (OutputType.Patch == this.Output.Type) - { - // copy output data back into the transforms - this.CopyToTransformData(this.Output); - } -#endif + fileTransfers.AddRange(command.FileTransfers); + trackedFiles.AddRange(command.TrackedFiles); + } - this.ValidateComponentGuids(output); +#if DELETE + if (OutputType.Patch == output.Type) + { + // Copy output data back into the transforms. +#if TODO_PATCHING + var command = new CopyTransformDataCommand(this.Messaging, output, tableDefinitions, copyOutFileRows: false); + command.Execute(); - // stop processing if an error previously occurred - if (this.Messaging.EncounteredError) - { - return; - } + this.CopyToTransformData(this.Output); +#endif + } +#endif - // Generate database file. - this.Messaging.Write(VerboseMessages.GeneratingDatabase()); + // stop processing if an error previously occurred + if (this.Messaging.EncounteredError) + { + return; + } - { - var trackMsi = this.BackendHelper.TrackFile(this.OutputPath, TrackedFileType.Final); - trackedFiles.Add(trackMsi); + // Generate database file. + this.Messaging.Write(VerboseMessages.GeneratingDatabase()); - var temporaryFiles = this.GenerateDatabase(output, tableDefinitions, trackMsi.Path, false, false); - trackedFiles.AddRange(temporaryFiles); - } + { + var trackMsi = this.BackendHelper.TrackFile(this.OutputPath, TrackedFileType.Final); + trackedFiles.Add(trackMsi); - // Stop processing if an error previously occurred. - if (this.Messaging.EncounteredError) - { - return; - } + var temporaryFiles = this.GenerateDatabase(output, tableDefinitions, trackMsi.Path, false, false); + trackedFiles.AddRange(temporaryFiles); + } - // Merge modules. - if (containsMergeModules) - { - this.Messaging.Write(VerboseMessages.MergingModules()); + // Stop processing if an error previously occurred. + if (this.Messaging.EncounteredError) + { + return; + } - // Add back possibly suppressed sequence tables since all sequence tables must be present - // for the merge process to work. We'll drop the suppressed sequence tables again as - // necessary. - foreach (SequenceTable sequence in Enum.GetValues(typeof(SequenceTable))) + // Merge modules. + if (containsMergeModules) { - var sequenceTableName = sequence.ToString(); - var sequenceTable = output.Tables[sequenceTableName]; + this.Messaging.Write(VerboseMessages.MergingModules()); - if (null == sequenceTable) + // Add back possibly suppressed sequence tables since all sequence tables must be present + // for the merge process to work. We'll drop the suppressed sequence tables again as + // necessary. + foreach (SequenceTable sequence in Enum.GetValues(typeof(SequenceTable))) { - sequenceTable = output.EnsureTable(tableDefinitions[sequenceTableName]); - } + var sequenceTableName = sequence.ToString(); + var sequenceTable = output.Tables[sequenceTableName]; - if (0 == sequenceTable.Rows.Count) - { - suppressedTableNames.Add(sequenceTableName); + if (null == sequenceTable) + { + sequenceTable = output.EnsureTable(tableDefinitions[sequenceTableName]); + } + + if (0 == sequenceTable.Rows.Count) + { + suppressedTableNames.Add(sequenceTableName); + } } - } - var command = new MergeModulesCommand(); - command.FileFacades = fileFacades; - command.Output = output; - command.OutputPath = this.OutputPath; - command.SuppressedTableNames = suppressedTableNames; - command.Execute(); - } + var command = new MergeModulesCommand(); + command.FileFacades = fileFacades; + command.Output = output; + command.OutputPath = this.OutputPath; + command.SuppressedTableNames = suppressedTableNames; + command.Execute(); + } - if (this.Messaging.EncounteredError) - { - return; - } + if (this.Messaging.EncounteredError) + { + return; + } #if TODO_FINISH_VALIDATION // Validate the output if there is an MSI validator. @@ -519,27 +554,29 @@ namespace WixToolset.Core.WindowsInstaller.Bind } #endif - // Process uncompressed files. - if (!this.Messaging.EncounteredError && !this.SuppressLayout && uncompressedFiles.Any()) - { - var command = new ProcessUncompressedFilesCommand(section, this.BackendHelper, this.PathResolver); - command.Compressed = compressed; - command.FileFacades = uncompressedFiles; - command.LayoutDirectory = layoutDirectory; - command.LongNamesInImage = longNames; - command.ResolveMedia = this.ResolveMedia; - command.DatabasePath = this.OutputPath; - command.Execute(); + // Process uncompressed files. + if (!this.Messaging.EncounteredError && !this.SuppressLayout && uncompressedFiles.Any()) + { + var command = new ProcessUncompressedFilesCommand(section, this.BackendHelper, this.PathResolver); + command.Compressed = compressed; + command.FileFacades = uncompressedFiles; + command.LayoutDirectory = layoutDirectory; + command.LongNamesInImage = longNames; + command.ResolveMedia = this.ResolveMedia; + command.DatabasePath = this.OutputPath; + command.Execute(); - fileTransfers.AddRange(command.FileTransfers); - trackedFiles.AddRange(command.TrackedFiles); + fileTransfers.AddRange(command.FileTransfers); + trackedFiles.AddRange(command.TrackedFiles); + } + + // TODO: this is not sufficient to collect all Input files (for example, it misses Binary and Icon tables). + trackedFiles.AddRange(fileFacades.Select(f => this.BackendHelper.TrackFile(f.SourcePath, TrackedFileType.Input, f.SourceLineNumber))); } this.Wixout = this.CreateWixout(trackedFiles, this.Intermediate, output); this.FileTransfers = fileTransfers; - // TODO: this is not sufficient to collect all Input files (for example, it misses Binary and Icon tables). - trackedFiles.AddRange(fileFacades.Select(f => this.BackendHelper.TrackFile(f.File.Source.Path, TrackedFileType.Input, f.File.SourceLineNumbers))); this.TrackedFiles = trackedFiles; } @@ -566,7 +603,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind return wixout; } -#if TODO_FINISH_PATCH +#if TODO_PATCHING /// /// Copy file data between transform substorages and the patch output object /// @@ -936,28 +973,15 @@ namespace WixToolset.Core.WindowsInstaller.Bind /// Whether to use a subdirectory based on the file name for intermediate files. private IEnumerable GenerateDatabase(WindowsInstallerData output, TableDefinitionCollection tableDefinitions, string databaseFile, bool keepAddedColumns, bool useSubdirectory) { - var command = new GenerateDatabaseCommand(); - command.BackendHelper = this.BackendHelper; - command.Extensions = this.FileSystemExtensions; - command.Output = output; - command.OutputPath = databaseFile; - command.KeepAddedColumns = keepAddedColumns; - command.UseSubDirectory = useSubdirectory; - command.SuppressAddingValidationRows = this.SuppressAddingValidationRows; - command.TableDefinitions = tableDefinitions; - command.IntermediateFolder = this.IntermediateFolder; - command.Codepage = this.Codepage; + var command = new GenerateDatabaseCommand(this.Messaging, this.BackendHelper, this.FileSystemExtensions, output, databaseFile, tableDefinitions, this.IntermediateFolder, this.Codepage, keepAddedColumns, this.SuppressAddingValidationRows, useSubdirectory); command.Execute(); return command.GeneratedTemporaryFiles; } - #region IDisposable Support +#region IDisposable Support - public void Dispose() - { - this.Dispose(true); - } + public void Dispose() => this.Dispose(true); protected virtual void Dispose(bool disposing) { @@ -972,6 +996,6 @@ namespace WixToolset.Core.WindowsInstaller.Bind } } - #endregion +#endregion } } diff --git a/src/WixToolset.Core.WindowsInstaller/Bind/BindTransformCommand.cs b/src/WixToolset.Core.WindowsInstaller/Bind/BindTransformCommand.cs index 8757024e..ea6e4f31 100644 --- a/src/WixToolset.Core.WindowsInstaller/Bind/BindTransformCommand.cs +++ b/src/WixToolset.Core.WindowsInstaller/Bind/BindTransformCommand.cs @@ -15,24 +15,37 @@ namespace WixToolset.Core.WindowsInstaller.Bind internal class BindTransformCommand { - public IEnumerable Extensions { private get; set; } + public BindTransformCommand(IMessaging messaging, IBackendHelper backendHelper, IEnumerable extensions, string intermediateFolder, WindowsInstallerData transform, string outputPath, TableDefinitionCollection tableDefinitions) + { + this.Messaging = messaging; + this.BackendHelper = backendHelper; + this.Extensions = extensions; + this.IntermediateFolder = intermediateFolder; + this.Transform = transform; + this.OutputPath = outputPath; + this.TableDefinitions = tableDefinitions; + } + + private IMessaging Messaging { get; } - public TableDefinitionCollection TableDefinitions { private get; set; } + private IBackendHelper BackendHelper { get; } - public string TempFilesLocation { private get; set; } + private IEnumerable Extensions { get; } - public WindowsInstallerData Transform { private get; set; } + private TableDefinitionCollection TableDefinitions { get; } - public IMessaging Messaging { private get; set; } + private string IntermediateFolder { get; } - public string OutputPath { private get; set; } + private WindowsInstallerData Transform { get; } + + private string OutputPath { get; } public void Execute() { - int transformFlags = 0; + var transformFlags = 0; - WindowsInstallerData targetOutput = new WindowsInstallerData(null); - WindowsInstallerData updatedOutput = new WindowsInstallerData(null); + var targetOutput = new WindowsInstallerData(null); + var updatedOutput = new WindowsInstallerData(null); // TODO: handle added columns @@ -49,8 +62,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind string targetUpgradeCode = null; string updatedUpgradeCode = null; - Table propertyTable = this.Transform.Tables["Property"]; - if (null != propertyTable) + if (this.Transform.TryGetTable("Property", out var propertyTable)) { for (int i = propertyTable.Rows.Count - 1; i >= 0; i--) { @@ -68,18 +80,21 @@ namespace WixToolset.Core.WindowsInstaller.Bind } } - Table targetSummaryInfo = targetOutput.EnsureTable(this.TableDefinitions["_SummaryInformation"]); - Table updatedSummaryInfo = updatedOutput.EnsureTable(this.TableDefinitions["_SummaryInformation"]); - Table targetPropertyTable = targetOutput.EnsureTable(this.TableDefinitions["Property"]); - Table updatedPropertyTable = updatedOutput.EnsureTable(this.TableDefinitions["Property"]); + var targetSummaryInfo = targetOutput.EnsureTable(this.TableDefinitions["_SummaryInformation"]); + var updatedSummaryInfo = updatedOutput.EnsureTable(this.TableDefinitions["_SummaryInformation"]); + var targetPropertyTable = targetOutput.EnsureTable(this.TableDefinitions["Property"]); + var updatedPropertyTable = updatedOutput.EnsureTable(this.TableDefinitions["Property"]); // process special summary information values - foreach (Row row in this.Transform.Tables["_SummaryInformation"].Rows) + foreach (var row in this.Transform.Tables["_SummaryInformation"].Rows) { - if ((int)SummaryInformation.Transform.CodePage == (int)row[0]) + var summaryId = row.FieldAsInteger(0); + var summaryData = row.FieldAsString(1); + + if ((int)SummaryInformation.Transform.CodePage == summaryId) { // convert from a web name if provided - string codePage = (string)row.Fields[1].Data; + var codePage = summaryData; if (null == codePage) { codePage = "0"; @@ -89,7 +104,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind codePage = Common.GetValidCodePage(codePage).ToString(CultureInfo.InvariantCulture); } - string previousCodePage = (string)row.Fields[1].PreviousData; + var previousCodePage = row.Fields[1].PreviousData; if (null == previousCodePage) { previousCodePage = "0"; @@ -99,50 +114,50 @@ namespace WixToolset.Core.WindowsInstaller.Bind previousCodePage = Common.GetValidCodePage(previousCodePage).ToString(CultureInfo.InvariantCulture); } - Row targetCodePageRow = targetSummaryInfo.CreateRow(null); + var targetCodePageRow = targetSummaryInfo.CreateRow(null); targetCodePageRow[0] = 1; // PID_CODEPAGE targetCodePageRow[1] = previousCodePage; - Row updatedCodePageRow = updatedSummaryInfo.CreateRow(null); + var updatedCodePageRow = updatedSummaryInfo.CreateRow(null); updatedCodePageRow[0] = 1; // PID_CODEPAGE updatedCodePageRow[1] = codePage; } - else if ((int)SummaryInformation.Transform.TargetPlatformAndLanguage == (int)row[0] || - (int)SummaryInformation.Transform.UpdatedPlatformAndLanguage == (int)row[0]) + else if ((int)SummaryInformation.Transform.TargetPlatformAndLanguage == summaryId || + (int)SummaryInformation.Transform.UpdatedPlatformAndLanguage == summaryId) { // the target language - string[] propertyData = ((string)row[1]).Split(';'); - string lang = 2 == propertyData.Length ? propertyData[1] : "0"; + var propertyData = summaryData.Split(';'); + var lang = 2 == propertyData.Length ? propertyData[1] : "0"; - Table tempSummaryInfo = (int)SummaryInformation.Transform.TargetPlatformAndLanguage == (int)row[0] ? targetSummaryInfo : updatedSummaryInfo; - Table tempPropertyTable = (int)SummaryInformation.Transform.TargetPlatformAndLanguage == (int)row[0] ? targetPropertyTable : updatedPropertyTable; + var tempSummaryInfo = (int)SummaryInformation.Transform.TargetPlatformAndLanguage == summaryId ? targetSummaryInfo : updatedSummaryInfo; + var tempPropertyTable = (int)SummaryInformation.Transform.TargetPlatformAndLanguage == summaryId ? targetPropertyTable : updatedPropertyTable; - Row productLanguageRow = tempPropertyTable.CreateRow(null); + var productLanguageRow = tempPropertyTable.CreateRow(null); productLanguageRow[0] = "ProductLanguage"; productLanguageRow[1] = lang; // set the platform;language on the MSI to be generated - Row templateRow = tempSummaryInfo.CreateRow(null); + var templateRow = tempSummaryInfo.CreateRow(null); templateRow[0] = 7; // PID_TEMPLATE - templateRow[1] = (string)row[1]; + templateRow[1] = summaryData; } - else if ((int)SummaryInformation.Transform.ProductCodes == (int)row[0]) + else if ((int)SummaryInformation.Transform.ProductCodes == summaryId) { - string[] propertyData = ((string)row[1]).Split(';'); + var propertyData = summaryData.Split(';'); - Row targetProductCodeRow = targetPropertyTable.CreateRow(null); + var targetProductCodeRow = targetPropertyTable.CreateRow(null); targetProductCodeRow[0] = "ProductCode"; targetProductCodeRow[1] = propertyData[0].Substring(0, 38); - Row targetProductVersionRow = targetPropertyTable.CreateRow(null); + var targetProductVersionRow = targetPropertyTable.CreateRow(null); targetProductVersionRow[0] = "ProductVersion"; targetProductVersionRow[1] = propertyData[0].Substring(38); - Row updatedProductCodeRow = updatedPropertyTable.CreateRow(null); + var updatedProductCodeRow = updatedPropertyTable.CreateRow(null); updatedProductCodeRow[0] = "ProductCode"; updatedProductCodeRow[1] = propertyData[1].Substring(0, 38); - Row updatedProductVersionRow = updatedPropertyTable.CreateRow(null); + var updatedProductVersionRow = updatedPropertyTable.CreateRow(null); updatedProductVersionRow[0] = "ProductVersion"; updatedProductVersionRow[1] = propertyData[1].Substring(38); @@ -153,7 +168,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind targetUpgradeCode = propertyData[2]; if (!String.IsNullOrEmpty(targetUpgradeCode)) { - Row targetUpgradeCodeRow = targetPropertyTable.CreateRow(null); + var targetUpgradeCodeRow = targetPropertyTable.CreateRow(null); targetUpgradeCodeRow[0] = "UpgradeCode"; targetUpgradeCodeRow[1] = targetUpgradeCode; @@ -167,16 +182,16 @@ namespace WixToolset.Core.WindowsInstaller.Bind if (!String.IsNullOrEmpty(updatedUpgradeCode)) { - Row updatedUpgradeCodeRow = updatedPropertyTable.CreateRow(null); + var updatedUpgradeCodeRow = updatedPropertyTable.CreateRow(null); updatedUpgradeCodeRow[0] = "UpgradeCode"; updatedUpgradeCodeRow[1] = updatedUpgradeCode; } } - else if ((int)SummaryInformation.Transform.ValidationFlags == (int)row[0]) + else if ((int)SummaryInformation.Transform.ValidationFlags == summaryId) { - transformFlags = Convert.ToInt32(row[1], CultureInfo.InvariantCulture); + transformFlags = Convert.ToInt32(summaryData, CultureInfo.InvariantCulture); } - else if ((int)SummaryInformation.Transform.Reserved11 == (int)row[0]) + else if ((int)SummaryInformation.Transform.Reserved11 == summaryId) { // PID_LASTPRINTED should be null for transforms row.Operation = RowOperation.None; @@ -184,11 +199,11 @@ namespace WixToolset.Core.WindowsInstaller.Bind else { // add everything else as is - Row targetRow = targetSummaryInfo.CreateRow(null); + var targetRow = targetSummaryInfo.CreateRow(null); targetRow[0] = row[0]; targetRow[1] = row[1]; - Row updatedRow = updatedSummaryInfo.CreateRow(null); + var updatedRow = updatedSummaryInfo.CreateRow(null); updatedRow[0] = row[0]; updatedRow[1] = row[1]; } @@ -205,7 +220,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind string emptyFile = null; - foreach (Table table in this.Transform.Tables) + foreach (var table in this.Transform.Tables) { // Ignore unreal tables when building transforms except the _Stream table. // These tables are ignored when generating the database so there is no reason @@ -231,20 +246,21 @@ namespace WixToolset.Core.WindowsInstaller.Bind } // process row operations - foreach (Row row in table.Rows) + foreach (var row in table.Rows) { switch (row.Operation) { case RowOperation.Add: - Table updatedTable = updatedOutput.EnsureTable(table.Definition); + var updatedTable = updatedOutput.EnsureTable(table.Definition); updatedTable.Rows.Add(row); continue; + case RowOperation.Delete: - Table targetTable = targetOutput.EnsureTable(table.Definition); + var targetTable = targetOutput.EnsureTable(table.Definition); targetTable.Rows.Add(row); // fill-in non-primary key values - foreach (Field field in row.Fields) + foreach (var field in row.Fields) { if (!field.Column.PrimaryKey) { @@ -256,7 +272,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind { if (null == emptyFile) { - emptyFile = Path.Combine(this.TempFilesLocation, "empty"); + emptyFile = Path.Combine(this.IntermediateFolder, "empty"); } field.Data = emptyFile; @@ -273,7 +289,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind // Assure that the file table's sequence is populated if ("File" == table.Name) { - foreach (Row fileRow in table.Rows) + foreach (var fileRow in table.Rows) { if (null == fileRow[7]) { @@ -290,60 +306,48 @@ namespace WixToolset.Core.WindowsInstaller.Bind } // process modified and unmodified rows - bool modifiedRow = false; - Row targetRow = new Row(null, table.Definition); - Row updatedRow = row; - for (int i = 0; i < row.Fields.Length; i++) + var modifiedRow = false; + var targetRow = new Row(null, table.Definition); + var updatedRow = row; + for (var i = 0; i < row.Fields.Length; i++) { - Field updatedField = row.Fields[i]; + var updatedField = row.Fields[i]; if (updatedField.Modified) { // set a different value in the target row to ensure this value will be modified during transform generation if (ColumnType.Number == updatedField.Column.Type && !updatedField.Column.IsLocalizable) { - if (null == updatedField.Data || 1 != (int)updatedField.Data) - { - targetRow[i] = 1; - } - else - { - targetRow[i] = 2; - } + var data = updatedField.AsNullableInteger(); + targetRow[i] = (data == 1) ? 2 : 1; } else if (ColumnType.Object == updatedField.Column.Type) { if (null == emptyFile) { - emptyFile = Path.Combine(this.TempFilesLocation, "empty"); + emptyFile = Path.Combine(this.IntermediateFolder, "empty"); } targetRow[i] = emptyFile; } else { - if ("0" != (string)updatedField.Data) - { - targetRow[i] = "0"; - } - else - { - targetRow[i] = "1"; - } + var data = updatedField.AsString(); + targetRow[i] = (data == "0") ? "1" : "0"; } modifiedRow = true; } else if (ColumnType.Object == updatedField.Column.Type) { - ObjectField objectField = (ObjectField)updatedField; + var objectField = (ObjectField)updatedField; // create an empty file for comparing against if (null == objectField.PreviousData) { if (null == emptyFile) { - emptyFile = Path.Combine(this.TempFilesLocation, "empty"); + emptyFile = Path.Combine(this.IntermediateFolder, "empty"); } targetRow[i] = emptyFile; @@ -372,10 +376,10 @@ namespace WixToolset.Core.WindowsInstaller.Bind "ProductVersion" == (string)row[0] || "UpgradeCode" == (string)row[0]))) { - Table targetTable = targetOutput.EnsureTable(table.Definition); + var targetTable = targetOutput.EnsureTable(table.Definition); targetTable.Rows.Add(targetRow); - Table updatedTable = updatedOutput.EnsureTable(table.Definition); + var updatedTable = updatedOutput.EnsureTable(table.Definition); updatedTable.Rows.Add(updatedRow); } } @@ -392,38 +396,36 @@ namespace WixToolset.Core.WindowsInstaller.Bind return; } - string transformFileName = Path.GetFileNameWithoutExtension(this.OutputPath); - string targetDatabaseFile = Path.Combine(this.TempFilesLocation, String.Concat(transformFileName, "_target.msi")); - string updatedDatabaseFile = Path.Combine(this.TempFilesLocation, String.Concat(transformFileName, "_updated.msi")); + var transformFileName = Path.GetFileNameWithoutExtension(this.OutputPath); + var targetDatabaseFile = Path.Combine(this.IntermediateFolder, String.Concat(transformFileName, "_target.msi")); + var updatedDatabaseFile = Path.Combine(this.IntermediateFolder, String.Concat(transformFileName, "_updated.msi")); try { if (!String.IsNullOrEmpty(emptyFile)) { - using (FileStream fileStream = File.Create(emptyFile)) + using (var fileStream = File.Create(emptyFile)) { } } - this.GenerateDatabase(targetOutput, targetDatabaseFile, false); - this.GenerateDatabase(updatedOutput, updatedDatabaseFile, true); + this.GenerateDatabase(targetOutput, targetDatabaseFile, keepAddedColumns: false); + this.GenerateDatabase(updatedOutput, updatedDatabaseFile, keepAddedColumns: true); // make sure the directory exists Directory.CreateDirectory(Path.GetDirectoryName(this.OutputPath)); // create the transform file - using (Database targetDatabase = new Database(targetDatabaseFile, OpenDatabase.ReadOnly)) + using (var targetDatabase = new Database(targetDatabaseFile, OpenDatabase.ReadOnly)) + using (var updatedDatabase = new Database(updatedDatabaseFile, OpenDatabase.ReadOnly)) { - using (Database updatedDatabase = new Database(updatedDatabaseFile, OpenDatabase.ReadOnly)) + if (updatedDatabase.GenerateTransform(targetDatabase, this.OutputPath)) { - if (updatedDatabase.GenerateTransform(targetDatabase, this.OutputPath)) - { - updatedDatabase.CreateTransformSummaryInfo(targetDatabase, this.OutputPath, (TransformErrorConditions)(transformFlags & 0xFFFF), (TransformValidations)((transformFlags >> 16) & 0xFFFF)); - } - else - { - this.Messaging.Write(ErrorMessages.NoDifferencesInTransform(this.Transform.SourceLineNumbers)); - } + updatedDatabase.CreateTransformSummaryInfo(targetDatabase, this.OutputPath, (TransformErrorConditions)(transformFlags & 0xFFFF), (TransformValidations)((transformFlags >> 16) & 0xFFFF)); + } + else + { + this.Messaging.Write(ErrorMessages.NoDifferencesInTransform(this.Transform.SourceLineNumbers)); } } } @@ -458,16 +460,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind private void GenerateDatabase(WindowsInstallerData output, string outputPath, bool keepAddedColumns) { - var command = new GenerateDatabaseCommand(); - command.Codepage = output.Codepage; - command.Extensions = this.Extensions; - command.KeepAddedColumns = keepAddedColumns; - command.Output = output; - command.OutputPath = outputPath; - command.TableDefinitions = this.TableDefinitions; - command.IntermediateFolder = this.TempFilesLocation; - command.SuppressAddingValidationRows = true; - command.UseSubDirectory = true; + var command = new GenerateDatabaseCommand(this.Messaging, this.BackendHelper, this.Extensions, output, outputPath, this.TableDefinitions, this.IntermediateFolder, codepage: -1, keepAddedColumns, suppressAddingValidationRows: true, useSubdirectory: true ); command.Execute(); } } diff --git a/src/WixToolset.Core.WindowsInstaller/Bind/CabinetBuilder.cs b/src/WixToolset.Core.WindowsInstaller/Bind/CabinetBuilder.cs index bf1140d8..ec4e0818 100644 --- a/src/WixToolset.Core.WindowsInstaller/Bind/CabinetBuilder.cs +++ b/src/WixToolset.Core.WindowsInstaller/Bind/CabinetBuilder.cs @@ -152,7 +152,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind foreach (FileFacade facade in cabinetWorkItem.FileFacades) // No other easy way than looping to get the only row { - if ((ulong)facade.File.FileSize >= maxPreCompressedSizeInBytes) + if ((ulong)facade.FileSize >= maxPreCompressedSizeInBytes) { // If file is larger than MaximumUncompressedFileSize set Maximum Cabinet Size for Cabinet Splitting maxCabinetSize = this.MaximumCabinetSizeForLargeFileSplitting; @@ -166,8 +166,8 @@ namespace WixToolset.Core.WindowsInstaller.Bind var files = cabinetWorkItem.FileFacades .Select(facade => facade.Hash == null ? - new CabinetCompressFile(facade.File.Source.Path, facade.File.Id.Id) : - new CabinetCompressFile(facade.File.Source.Path, facade.File.Id.Id, facade.Hash.HashPart1, facade.Hash.HashPart2, facade.Hash.HashPart3, facade.Hash.HashPart4)) + new CabinetCompressFile(facade.SourcePath, facade.Id) : + new CabinetCompressFile(facade.SourcePath, facade.Id, facade.Hash.HashPart1, facade.Hash.HashPart2, facade.Hash.HashPart3, facade.Hash.HashPart4)) .ToList(); var cab = new Cabinet(cabinetPath); diff --git a/src/WixToolset.Core.WindowsInstaller/Bind/CabinetResolver.cs b/src/WixToolset.Core.WindowsInstaller/Bind/CabinetResolver.cs index 3fa3f3a0..79b1c619 100644 --- a/src/WixToolset.Core.WindowsInstaller/Bind/CabinetResolver.cs +++ b/src/WixToolset.Core.WindowsInstaller/Bind/CabinetResolver.cs @@ -112,8 +112,8 @@ namespace WixToolset.Core.WindowsInstaller.Bind private IBindFileWithPath CreateBindFileWithPath(FileFacade facade) { var result = this.ServiceProvider.GetService(); - result.Id = facade.File.Id.Id; - result.Path = facade.File.Source.Path; + result.Id = facade.Id; + result.Path = facade.SourcePath; return result; } diff --git a/src/WixToolset.Core.WindowsInstaller/Bind/CopyTransformDataCommand.cs b/src/WixToolset.Core.WindowsInstaller/Bind/CopyTransformDataCommand.cs index 107f3208..0dcce61b 100644 --- a/src/WixToolset.Core.WindowsInstaller/Bind/CopyTransformDataCommand.cs +++ b/src/WixToolset.Core.WindowsInstaller/Bind/CopyTransformDataCommand.cs @@ -1,12 +1,15 @@ // 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. +#if DELETE + namespace WixToolset.Core.WindowsInstaller.Bind { using System; using System.Collections.Generic; using System.Diagnostics; + using System.IO; + using System.Linq; using WixToolset.Core.Bind; - using WixToolset.Core.Native; using WixToolset.Data; using WixToolset.Data.Tuples; using WixToolset.Data.WindowsInstaller; @@ -16,15 +19,23 @@ namespace WixToolset.Core.WindowsInstaller.Bind internal class CopyTransformDataCommand { - public bool CopyOutFileRows { private get; set; } + public CopyTransformDataCommand(IMessaging messaging, WindowsInstallerData output, TableDefinitionCollection tableDefinitions, bool copyOutFileRows) + { + this.Messaging = messaging; + this.Output = output; + this.TableDefinitions = tableDefinitions; + this.CopyOutFileRows = copyOutFileRows; + } - public IEnumerable Extensions { private get; set; } + private bool CopyOutFileRows { get; } - public IMessaging Messaging { private get; set; } + public IEnumerable Extensions { get; } - public WindowsInstallerData Output { private get; set; } + private IMessaging Messaging { get; } - public TableDefinitionCollection TableDefinitions { private get; set; } + private WindowsInstallerData Output { get; } + + private TableDefinitionCollection TableDefinitions { get; } public IEnumerable FileFacades { get; private set; } @@ -32,18 +43,17 @@ namespace WixToolset.Core.WindowsInstaller.Bind { Debug.Assert(OutputType.Patch != this.Output.Type); - List allFileRows = this.CopyOutFileRows ? new List() : null; + var allFileRows = this.CopyOutFileRows ? new List() : null; -#if REVISIT_FOR_PATCHING // TODO: Fix this patching related code to work correctly with FileFacades. - bool copyToPatch = (allFileRows != null); - bool copyFromPatch = !copyToPatch; + var copyToPatch = (allFileRows != null); + var copyFromPatch = !copyToPatch; - RowDictionary patchMediaRows = new RowDictionary(); + var patchMediaRows = new RowDictionary(); - Dictionary> patchMediaFileRows = new Dictionary>(); + var patchMediaFileRows = new Dictionary>(); - Table patchActualFileTable = this.Output.EnsureTable(this.TableDefinitions["File"]); - Table patchFileTable = this.Output.EnsureTable(this.TableDefinitions["WixFile"]); + var patchActualFileTable = this.Output.EnsureTable(this.TableDefinitions["File"]); + var patchFileTable = this.Output.EnsureTable(this.TableDefinitions["WixFile"]); if (copyFromPatch) { @@ -51,8 +61,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind foreach (WixFileRow patchFileRow in patchFileTable.Rows) { int diskId = patchFileRow.DiskId; - RowDictionary mediaFileRows; - if (!patchMediaFileRows.TryGetValue(diskId, out mediaFileRows)) + if (!patchMediaFileRows.TryGetValue(diskId, out var mediaFileRows)) { mediaFileRows = new RowDictionary(); patchMediaFileRows.Add(diskId, mediaFileRows); @@ -61,24 +70,25 @@ namespace WixToolset.Core.WindowsInstaller.Bind mediaFileRows.Add(patchFileRow); } - Table patchMediaTable = this.Output.EnsureTable(this.TableDefinitions["Media"]); + var patchMediaTable = this.Output.EnsureTable(this.TableDefinitions["Media"]); patchMediaRows = new RowDictionary(patchMediaTable); } - // index paired transforms - Dictionary pairedTransforms = new Dictionary(); - foreach (SubStorage substorage in this.Output.SubStorages) - { - if (substorage.Name.StartsWith("#")) - { - pairedTransforms.Add(substorage.Name.Substring(1), substorage.Data); - } - } + // Index paired transforms by name without the "#" prefix. + var pairedTransforms = this.Output.SubStorages.Where(s => s.Name.StartsWith("#")).ToDictionary(s => s.Name.Substring(1), s => s.Data); + //Dictionary pairedTransforms = new Dictionary(); + //foreach (SubStorage substorage in this.Output.SubStorages) + //{ + // if (substorage.Name.StartsWith("#")) + // { + // pairedTransforms.Add(substorage.Name.Substring(1), substorage.Data); + // } + //} try { - // copy File bind data into substorages - foreach (SubStorage substorage in this.Output.SubStorages) + // Copy File bind data into substorages + foreach (var substorage in this.Output.SubStorages) { if (substorage.Name.StartsWith("#")) { @@ -86,25 +96,25 @@ namespace WixToolset.Core.WindowsInstaller.Bind continue; } - Output mainTransform = substorage.Data; - Table mainWixFileTable = mainTransform.Tables["WixFile"]; - Table mainMsiFileHashTable = mainTransform.Tables["MsiFileHash"]; + var mainTransform = substorage.Data; + var mainWixFileTable = mainTransform.Tables["WixFile"]; + var mainMsiFileHashTable = mainTransform.Tables["MsiFileHash"]; this.FileManagerCore.ActiveSubStorage = substorage; - RowDictionary mainWixFiles = new RowDictionary(mainWixFileTable); - RowDictionary mainMsiFileHashIndex = new RowDictionary(); + var mainWixFiles = new RowDictionary(mainWixFileTable); + var mainMsiFileHashIndex = new RowDictionary(); - Table mainFileTable = mainTransform.Tables["File"]; - Output pairedTransform = (Output)pairedTransforms[substorage.Name]; + var mainFileTable = mainTransform.Tables["File"]; + var pairedTransform = pairedTransforms[substorage.Name]; // copy Media.LastSequence and index the MsiFileHash table if it exists. if (copyFromPatch) { - Table pairedMediaTable = pairedTransform.Tables["Media"]; + var pairedMediaTable = pairedTransform.Tables["Media"]; foreach (MediaRow pairedMediaRow in pairedMediaTable.Rows) { - MediaRow patchMediaRow = patchMediaRows.Get(pairedMediaRow.DiskId); + var patchMediaRow = patchMediaRows.Get(pairedMediaRow.DiskId); pairedMediaRow.Fields[1] = patchMediaRow.Fields[1]; } @@ -118,8 +128,8 @@ namespace WixToolset.Core.WindowsInstaller.Bind } // Index File table of pairedTransform - Table pairedFileTable = pairedTransform.Tables["File"]; - RowDictionary pairedFileRows = new RowDictionary(pairedFileTable); + var pairedFileTable = pairedTransform.Tables["File"]; + var pairedFileRows = new RowDictionary(pairedFileTable); if (null != mainFileTable) { @@ -140,12 +150,12 @@ namespace WixToolset.Core.WindowsInstaller.Bind continue; } - WixFileRow mainWixFileRow = mainWixFiles.Get(mainFileRow.File); + var mainWixFileRow = mainWixFiles.Get(mainFileRow.File); if (copyToPatch) // when copying to the patch, we need compare the underlying files and include all file changes. { - ObjectField objectField = (ObjectField)mainWixFileRow.Fields[6]; - FileRow pairedFileRow = pairedFileRows.Get(mainFileRow.File); + var objectField = (ObjectField)mainWixFileRow.Fields[6]; + var pairedFileRow = pairedFileRows.Get(mainFileRow.File); // If the file is new, we always need to add it to the patch. if (mainFileRow.Operation != RowOperation.Add) @@ -169,8 +179,8 @@ namespace WixToolset.Core.WindowsInstaller.Bind if (null != pairedFileRow) { // Always patch-added, but never non-compressed. - pairedFileRow.Attributes |= MsiInterop.MsidbFileAttributesPatchAdded; - pairedFileRow.Attributes &= ~MsiInterop.MsidbFileAttributesNoncompressed; + pairedFileRow.Attributes |= WindowsInstallerConstants.MsidbFileAttributesPatchAdded; + pairedFileRow.Attributes &= ~WindowsInstallerConstants.MsidbFileAttributesNoncompressed; pairedFileRow.Fields[6].Modified = true; pairedFileRow.Operation = RowOperation.Modify; } @@ -179,14 +189,14 @@ namespace WixToolset.Core.WindowsInstaller.Bind { // The File is same. We need mark all the attributes as unchanged. mainFileRow.Operation = RowOperation.None; - foreach (Field field in mainFileRow.Fields) + foreach (var field in mainFileRow.Fields) { field.Modified = false; } if (null != pairedFileRow) { - pairedFileRow.Attributes &= ~MsiInterop.MsidbFileAttributesPatchAdded; + pairedFileRow.Attributes &= ~WindowsInstallerConstants.MsidbFileAttributesPatchAdded; pairedFileRow.Fields[6].Modified = false; pairedFileRow.Operation = RowOperation.None; } @@ -197,8 +207,8 @@ namespace WixToolset.Core.WindowsInstaller.Bind else if (null != pairedFileRow) // RowOperation.Add { // Always patch-added, but never non-compressed. - pairedFileRow.Attributes |= MsiInterop.MsidbFileAttributesPatchAdded; - pairedFileRow.Attributes &= ~MsiInterop.MsidbFileAttributesNoncompressed; + pairedFileRow.Attributes |= WindowsInstallerConstants.MsidbFileAttributesPatchAdded; + pairedFileRow.Attributes &= ~WindowsInstallerConstants.MsidbFileAttributesNoncompressed; pairedFileRow.Fields[6].Modified = true; pairedFileRow.Operation = RowOperation.Add; } @@ -207,20 +217,19 @@ namespace WixToolset.Core.WindowsInstaller.Bind // index patch files by diskId+fileId int diskId = mainWixFileRow.DiskId; - RowDictionary mediaFileRows; - if (!patchMediaFileRows.TryGetValue(diskId, out mediaFileRows)) + if (!patchMediaFileRows.TryGetValue(diskId, out var mediaFileRows)) { mediaFileRows = new RowDictionary(); patchMediaFileRows.Add(diskId, mediaFileRows); } - string fileId = mainFileRow.File; - WixFileRow patchFileRow = mediaFileRows.Get(fileId); + var fileId = mainFileRow.File; + var patchFileRow = mediaFileRows.Get(fileId); if (copyToPatch) { if (null == patchFileRow) { - FileRow patchActualFileRow = (FileRow)patchFileTable.CreateRow(mainFileRow.SourceLineNumbers); + var patchActualFileRow = (FileRow)patchFileTable.CreateRow(mainFileRow.SourceLineNumbers); patchActualFileRow.CopyFrom(mainFileRow); patchFileRow = (WixFileRow)patchFileTable.CreateRow(mainFileRow.SourceLineNumbers); @@ -237,7 +246,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind // make sure Source is same. Otherwise we are silently ignoring a file. if (0 != String.Compare(patchFileRow.Source, mainWixFileRow.Source, StringComparison.OrdinalIgnoreCase)) { - Messaging.Instance.OnMessage(WixErrors.SameFileIdDifferentSource(mainFileRow.SourceLineNumbers, fileId, patchFileRow.Source, mainWixFileRow.Source)); + this.Messaging.Write(ErrorMessages.SameFileIdDifferentSource(mainFileRow.SourceLineNumbers, fileId, patchFileRow.Source, mainWixFileRow.Source)); } // capture the previous file versions (and associated data) from this targeted instance of the baseline into the current filerow. @@ -249,11 +258,11 @@ namespace WixToolset.Core.WindowsInstaller.Bind // copy data from the patch back to the transform if (null != patchFileRow) { - FileRow pairedFileRow = (FileRow)pairedFileRows.Get(fileId); - for (int i = 0; i < patchFileRow.Fields.Length; i++) + var pairedFileRow = pairedFileRows.Get(fileId); + for (var i = 0; i < patchFileRow.Fields.Length; i++) { - string patchValue = patchFileRow[i] == null ? "" : patchFileRow[i].ToString(); - string mainValue = mainFileRow[i] == null ? "" : mainFileRow[i].ToString(); + var patchValue = patchFileRow[i] == null ? String.Empty : patchFileRow.FieldAsString(i); + var mainValue = mainFileRow[i] == null ? String.Empty : mainFileRow.FieldAsString(i); if (1 == i) { @@ -298,17 +307,16 @@ namespace WixToolset.Core.WindowsInstaller.Bind } // copy MsiFileHash row for this File - Row patchHashRow; - if (!mainMsiFileHashIndex.TryGetValue(patchFileRow.File, out patchHashRow)) + if (!mainMsiFileHashIndex.TryGetValue(patchFileRow.File, out var patchHashRow)) { patchHashRow = patchFileRow.Hash; } if (null != patchHashRow) { - Table mainHashTable = mainTransform.EnsureTable(this.TableDefinitions["MsiFileHash"]); - Row mainHashRow = mainHashTable.CreateRow(mainFileRow.SourceLineNumbers); - for (int i = 0; i < patchHashRow.Fields.Length; i++) + var mainHashTable = mainTransform.EnsureTable(this.TableDefinitions["MsiFileHash"]); + var mainHashRow = mainHashTable.CreateRow(mainFileRow.SourceLineNumbers); + for (var i = 0; i < patchHashRow.Fields.Length; i++) { mainHashRow[i] = patchHashRow[i]; if (i > 1) @@ -326,12 +334,12 @@ namespace WixToolset.Core.WindowsInstaller.Bind List patchAssemblyNameRows = patchFileRow.AssemblyNames; if (null != patchAssemblyNameRows) { - Table mainAssemblyNameTable = mainTransform.EnsureTable(this.TableDefinitions["MsiAssemblyName"]); - foreach (Row patchAssemblyNameRow in patchAssemblyNameRows) + var mainAssemblyNameTable = mainTransform.EnsureTable(this.TableDefinitions["MsiAssemblyName"]); + foreach (var patchAssemblyNameRow in patchAssemblyNameRows) { // Copy if there isn't an identical modified/added row already in the transform. - bool foundMatchingModifiedRow = false; - foreach (Row mainAssemblyNameRow in mainAssemblyNameTable.Rows) + var foundMatchingModifiedRow = false; + foreach (var mainAssemblyNameRow in mainAssemblyNameTable.Rows) { if (RowOperation.None != mainAssemblyNameRow.Operation && mainAssemblyNameRow.GetPrimaryKey('/').Equals(patchAssemblyNameRow.GetPrimaryKey('/'))) { @@ -342,8 +350,8 @@ namespace WixToolset.Core.WindowsInstaller.Bind if (!foundMatchingModifiedRow) { - Row mainAssemblyNameRow = mainAssemblyNameTable.CreateRow(mainFileRow.SourceLineNumbers); - for (int i = 0; i < patchAssemblyNameRow.Fields.Length; i++) + var mainAssemblyNameRow = mainAssemblyNameTable.CreateRow(mainFileRow.SourceLineNumbers); + for (var i = 0; i < patchAssemblyNameRow.Fields.Length; i++) { mainAssemblyNameRow[i] = patchAssemblyNameRow[i]; } @@ -359,34 +367,36 @@ namespace WixToolset.Core.WindowsInstaller.Bind if (null != patchFileRow.Patch) { // Add the PatchFiles action automatically to the AdminExecuteSequence and InstallExecuteSequence tables. - AddPatchFilesActionToSequenceTable(SequenceTable.AdminExecuteSequence, mainTransform, pairedTransform, mainFileRow); - AddPatchFilesActionToSequenceTable(SequenceTable.InstallExecuteSequence, mainTransform, pairedTransform, mainFileRow); + this.AddPatchFilesActionToSequenceTable(SequenceTable.AdminExecuteSequence, mainTransform, pairedTransform, mainFileRow); + this.AddPatchFilesActionToSequenceTable(SequenceTable.InstallExecuteSequence, mainTransform, pairedTransform, mainFileRow); // Add to Patch table - Table patchTable = pairedTransform.EnsureTable(this.TableDefinitions["Patch"]); + var patchTable = pairedTransform.EnsureTable(this.TableDefinitions["Patch"]); if (0 == patchTable.Rows.Count) { patchTable.Operation = TableOperation.Add; } - Row patchRow = patchTable.CreateRow(mainFileRow.SourceLineNumbers); + var patchRow = patchTable.CreateRow(mainFileRow.SourceLineNumbers); patchRow[0] = patchFileRow.File; patchRow[1] = patchFileRow.Sequence; - FileInfo patchFile = new FileInfo(patchFileRow.Source); + var patchFile = new FileInfo(patchFileRow.Source); patchRow[2] = (int)patchFile.Length; patchRow[3] = 0 == (PatchAttributeType.AllowIgnoreOnError & patchFileRow.PatchAttributes) ? 0 : 1; - string streamName = patchTable.Name + "." + patchRow[0] + "." + patchRow[1]; - if (MsiInterop.MsiMaxStreamNameLength < streamName.Length) + var streamName = patchTable.Name + "." + patchRow[0] + "." + patchRow[1]; + if (Msi.MsiInterop.MsiMaxStreamNameLength < streamName.Length) { streamName = "_" + Guid.NewGuid().ToString("D").ToUpperInvariant().Replace('-', '_'); - Table patchHeadersTable = pairedTransform.EnsureTable(this.TableDefinitions["MsiPatchHeaders"]); + + var patchHeadersTable = pairedTransform.EnsureTable(this.TableDefinitions["MsiPatchHeaders"]); if (0 == patchHeadersTable.Rows.Count) { patchHeadersTable.Operation = TableOperation.Add; } - Row patchHeadersRow = patchHeadersTable.CreateRow(mainFileRow.SourceLineNumbers); + + var patchHeadersRow = patchHeadersTable.CreateRow(mainFileRow.SourceLineNumbers); patchHeadersRow[0] = streamName; patchHeadersRow[1] = patchFileRow.Patch; patchRow[5] = streamName; @@ -420,7 +430,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind { this.FileManagerCore.ActiveSubStorage = null; } -#endif + this.FileFacades = allFileRows; } @@ -509,17 +519,19 @@ namespace WixToolset.Core.WindowsInstaller.Bind foreach (var row in sequenceTable.Rows) { var actionName = row.FieldAsString(0); - if (String.Equals("PatchFiles", actionName, StringComparison.Ordinal)) - { - hasPatchFilesAction = true; - } - else if (String.Equals("InstallFiles", actionName, StringComparison.Ordinal)) + switch (actionName) { - installFilesSequence = row.FieldAsInteger(2); - } - else if (String.Equals("DuplicateFiles", actionName, StringComparison.Ordinal)) - { - duplicateFilesSequence = row.FieldAsInteger(2); + case "PatchFiles": + hasPatchFilesAction = true; + break; + + case "InstallFiles": + installFilesSequence = row.FieldAsInteger(2); + break; + + case "DuplicateFiles": + duplicateFilesSequence = row.FieldAsInteger(2); + break; } } } @@ -531,8 +543,8 @@ namespace WixToolset.Core.WindowsInstaller.Bind /// The output to validate. private void ValidateFileRowChanges(WindowsInstallerData transform) { - Table componentTable = transform.Tables["Component"]; - Table fileTable = transform.Tables["File"]; + var componentTable = transform.Tables["Component"]; + var fileTable = transform.Tables["File"]; // There's no sense validating keypaths if the transform has no component or file table if (componentTable == null || fileTable == null) @@ -540,31 +552,31 @@ namespace WixToolset.Core.WindowsInstaller.Bind return; } - Dictionary componentKeyPath = new Dictionary(componentTable.Rows.Count); + var componentKeyPath = new Dictionary(componentTable.Rows.Count); // Index the Component table for non-directory & non-registry key paths. - foreach (Row row in componentTable.Rows) + foreach (var row in componentTable.Rows) { - if (null != row.Fields[5].Data && - 0 != ((int)row.Fields[3].Data & WindowsInstallerConstants.MsidbComponentAttributesRegistryKeyPath)) + var keyPath = row.FieldAsString(5); + if (keyPath != null && 0 != (row.FieldAsInteger(3) & WindowsInstallerConstants.MsidbComponentAttributesRegistryKeyPath)) { - componentKeyPath.Add(row.Fields[0].Data.ToString(), row.Fields[5].Data.ToString()); + componentKeyPath.Add(row.FieldAsString(0), keyPath); } } - Dictionary componentWithChangedKeyPath = new Dictionary(); - Dictionary componentWithNonKeyPathChanged = new Dictionary(); + var componentWithChangedKeyPath = new Dictionary(); + var componentWithNonKeyPathChanged = new Dictionary(); // Verify changes in the file table, now that file diffing has occurred foreach (FileRow row in fileTable.Rows) { - string fileId = row.Fields[0].Data.ToString(); - string componentId = row.Fields[1].Data.ToString(); - if (RowOperation.Modify != row.Operation) { continue; } + var fileId = row.FieldAsString(0); + var componentId = row.FieldAsString(1); + // If this file is the keypath of a component if (componentKeyPath.ContainsValue(fileId)) { @@ -582,12 +594,12 @@ namespace WixToolset.Core.WindowsInstaller.Bind } } - foreach (KeyValuePair componentFile in componentWithNonKeyPathChanged) + foreach (var componentFile in componentWithNonKeyPathChanged) { // Make sure all changes to non keypath files also had a change in the keypath. - if (!componentWithChangedKeyPath.ContainsKey(componentFile.Key) && componentKeyPath.ContainsKey(componentFile.Key)) + if (!componentWithChangedKeyPath.ContainsKey(componentFile.Key) && componentKeyPath.TryGetValue(componentFile.Key, out var keyPath)) { - this.Messaging.Write(WarningMessages.UpdateOfNonKeyPathFile((string)componentFile.Value, (string)componentFile.Key, (string)componentKeyPath[componentFile.Key])); + this.Messaging.Write(WarningMessages.UpdateOfNonKeyPathFile(componentFile.Value, componentFile.Key, keyPath)); } } } @@ -614,3 +626,5 @@ namespace WixToolset.Core.WindowsInstaller.Bind } } } + +#endif diff --git a/src/WixToolset.Core.WindowsInstaller/Bind/CreateDeltaPatchesCommand.cs b/src/WixToolset.Core.WindowsInstaller/Bind/CreateDeltaPatchesCommand.cs index 19f7b9e5..f5ac00e6 100644 --- a/src/WixToolset.Core.WindowsInstaller/Bind/CreateDeltaPatchesCommand.cs +++ b/src/WixToolset.Core.WindowsInstaller/Bind/CreateDeltaPatchesCommand.cs @@ -33,7 +33,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind var optimizePatchSizeForLargeFiles = this.WixPatchId?.OptimizePatchSizeForLargeFiles ?? false; var apiPatchingSymbolFlags = (PatchSymbolFlagsType)(this.WixPatchId?.ApiPatchingSymbolFlags ?? 0); -#if REVISIT_FOR_PATCHING +#if TODO_PATCHING foreach (FileFacade facade in this.FileFacades) { if (RowOperation.Modify == facade.File.Operation && diff --git a/src/WixToolset.Core.WindowsInstaller/Bind/CreateIdtFileCommand.cs b/src/WixToolset.Core.WindowsInstaller/Bind/CreateIdtFileCommand.cs index 6b1dead5..f09a2e47 100644 --- a/src/WixToolset.Core.WindowsInstaller/Bind/CreateIdtFileCommand.cs +++ b/src/WixToolset.Core.WindowsInstaller/Bind/CreateIdtFileCommand.cs @@ -1,4 +1,4 @@ -// 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. +// 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.Core.WindowsInstaller.Bind { @@ -122,13 +122,18 @@ namespace WixToolset.Core.WindowsInstaller.Bind tableString.Append(definition.Name); foreach (var column in definition.Columns) { - // conditionally keep columns added in a transform; otherwise, - // break because columns can only be added at the end + // Conditionally keep columns added in a transform; otherwise, + // break because columns can only be added at the end. if (column.Added && !keepAddedColumns) { break; } + if (column.Unreal) + { + continue; + } + if (!first) { columnString.Append('\t'); @@ -168,6 +173,11 @@ namespace WixToolset.Core.WindowsInstaller.Bind break; } + if (field.Column.Unreal) + { + continue; + } + if (first) { first = false; diff --git a/src/WixToolset.Core.WindowsInstaller/Bind/CreateOutputFromIRCommand.cs b/src/WixToolset.Core.WindowsInstaller/Bind/CreateOutputFromIRCommand.cs index 31d0b3a6..5707f7ce 100644 --- a/src/WixToolset.Core.WindowsInstaller/Bind/CreateOutputFromIRCommand.cs +++ b/src/WixToolset.Core.WindowsInstaller/Bind/CreateOutputFromIRCommand.cs @@ -40,193 +40,193 @@ namespace WixToolset.Core.WindowsInstaller.Bind public void Execute() { - var output = new WindowsInstallerData(this.Section.Tuples.First().SourceLineNumbers); - output.Codepage = this.Section.Codepage; - output.Type = SectionTypeToOutputType(this.Section.Type); - - this.AddSectionToOutput(this.Section, output); + this.Output = new WindowsInstallerData(this.Section.Tuples.First().SourceLineNumbers) + { + Codepage = this.Section.Codepage, + Type = SectionTypeToOutputType(this.Section.Type) + }; - this.Output = output; + this.AddSectionToOutput(); } - private void AddSectionToOutput(IntermediateSection section, WindowsInstallerData output) + private void AddSectionToOutput() { - foreach (var tuple in section.Tuples) + foreach (var tuple in this.Section.Tuples) { switch (tuple.Definition.Type) { case TupleDefinitionType.AppSearch: - this.AddTupleDefaultly(tuple, output); - output.EnsureTable(this.TableDefinitions["Signature"]); + this.AddTupleDefaultly(tuple); + this.Output.EnsureTable(this.TableDefinitions["Signature"]); break; case TupleDefinitionType.Assembly: - this.AddAssemblyTuple((AssemblyTuple)tuple, output); + this.AddAssemblyTuple((AssemblyTuple)tuple); break; case TupleDefinitionType.Binary: - this.AddTupleDefaultly(tuple, output, idIsPrimaryKey: true); + this.AddTupleDefaultly(tuple, idIsPrimaryKey: true); break; case TupleDefinitionType.BBControl: - this.AddBBControlTuple((BBControlTuple)tuple, output); + this.AddBBControlTuple((BBControlTuple)tuple); break; case TupleDefinitionType.Class: - this.AddClassTuple((ClassTuple)tuple, output); + this.AddClassTuple((ClassTuple)tuple); break; case TupleDefinitionType.Control: - this.AddControlTuple((ControlTuple)tuple, output); + this.AddControlTuple((ControlTuple)tuple); break; case TupleDefinitionType.Component: - this.AddComponentTuple((ComponentTuple)tuple, output); + this.AddComponentTuple((ComponentTuple)tuple); break; case TupleDefinitionType.CustomAction: - this.AddCustomActionTuple((CustomActionTuple)tuple, output); + this.AddCustomActionTuple((CustomActionTuple)tuple); break; case TupleDefinitionType.Dialog: - this.AddDialogTuple((DialogTuple)tuple, output); + this.AddDialogTuple((DialogTuple)tuple); break; case TupleDefinitionType.Directory: - this.AddDirectoryTuple((DirectoryTuple)tuple, output); + this.AddDirectoryTuple((DirectoryTuple)tuple); break; case TupleDefinitionType.Environment: - this.AddEnvironmentTuple((EnvironmentTuple)tuple, output); + this.AddEnvironmentTuple((EnvironmentTuple)tuple); break; case TupleDefinitionType.Error: - this.AddErrorTuple((ErrorTuple)tuple, output); + this.AddErrorTuple((ErrorTuple)tuple); break; case TupleDefinitionType.Feature: - this.AddFeatureTuple((FeatureTuple)tuple, output); + this.AddFeatureTuple((FeatureTuple)tuple); break; case TupleDefinitionType.File: - this.AddFileTuple((FileTuple)tuple, output); + this.AddFileTuple((FileTuple)tuple); break; case TupleDefinitionType.Icon: - this.AddTupleDefaultly(tuple, output, idIsPrimaryKey: true); + this.AddTupleDefaultly(tuple, idIsPrimaryKey: true); break; case TupleDefinitionType.IniFile: - this.AddIniFileTuple((IniFileTuple)tuple, output); + this.AddIniFileTuple((IniFileTuple)tuple); break; case TupleDefinitionType.Media: - this.AddMediaTuple((MediaTuple)tuple, output); + this.AddMediaTuple((MediaTuple)tuple); break; case TupleDefinitionType.ModuleConfiguration: - this.AddModuleConfigurationTuple((ModuleConfigurationTuple)tuple, output); + this.AddModuleConfigurationTuple((ModuleConfigurationTuple)tuple); break; case TupleDefinitionType.MsiEmbeddedUI: - this.AddMsiEmbeddedUITuple((MsiEmbeddedUITuple)tuple, output); + this.AddMsiEmbeddedUITuple((MsiEmbeddedUITuple)tuple); break; case TupleDefinitionType.MsiFileHash: - this.AddMsiFileHashTuple((MsiFileHashTuple)tuple, output); + this.AddMsiFileHashTuple((MsiFileHashTuple)tuple); break; case TupleDefinitionType.MsiServiceConfig: - this.AddMsiServiceConfigTuple((MsiServiceConfigTuple)tuple, output); + this.AddMsiServiceConfigTuple((MsiServiceConfigTuple)tuple); break; case TupleDefinitionType.MsiServiceConfigFailureActions: - this.AddMsiServiceConfigFailureActionsTuple((MsiServiceConfigFailureActionsTuple)tuple, output); + this.AddMsiServiceConfigFailureActionsTuple((MsiServiceConfigFailureActionsTuple)tuple); break; case TupleDefinitionType.MsiShortcutProperty: - this.AddTupleDefaultly(tuple, output, idIsPrimaryKey: true); + this.AddTupleDefaultly(tuple, idIsPrimaryKey: true); break; case TupleDefinitionType.MoveFile: - this.AddMoveFileTuple((MoveFileTuple)tuple, output); + this.AddMoveFileTuple((MoveFileTuple)tuple); break; case TupleDefinitionType.ProgId: - this.AddTupleDefaultly(tuple, output); - output.EnsureTable(this.TableDefinitions["Extension"]); + this.AddTupleDefaultly(tuple); + this.Output.EnsureTable(this.TableDefinitions["Extension"]); break; case TupleDefinitionType.Property: - this.AddPropertyTuple((PropertyTuple)tuple, output); + this.AddPropertyTuple((PropertyTuple)tuple); break; case TupleDefinitionType.RemoveFile: - this.AddRemoveFileTuple((RemoveFileTuple)tuple, output); + this.AddRemoveFileTuple((RemoveFileTuple)tuple); break; case TupleDefinitionType.Registry: - this.AddRegistryTuple((RegistryTuple)tuple, output); + this.AddRegistryTuple((RegistryTuple)tuple); break; case TupleDefinitionType.RegLocator: - this.AddRegLocatorTuple((RegLocatorTuple)tuple, output); + this.AddRegLocatorTuple((RegLocatorTuple)tuple); break; case TupleDefinitionType.RemoveRegistry: - this.AddRemoveRegistryTuple((RemoveRegistryTuple)tuple, output); + this.AddRemoveRegistryTuple((RemoveRegistryTuple)tuple); break; case TupleDefinitionType.ReserveCost: - this.AddTupleDefaultly(tuple, output, idIsPrimaryKey: true); + this.AddTupleDefaultly(tuple, idIsPrimaryKey: true); break; case TupleDefinitionType.ServiceControl: - this.AddServiceControlTuple((ServiceControlTuple)tuple, output); + this.AddServiceControlTuple((ServiceControlTuple)tuple); break; case TupleDefinitionType.ServiceInstall: - this.AddServiceInstallTuple((ServiceInstallTuple)tuple, output); + this.AddServiceInstallTuple((ServiceInstallTuple)tuple); break; case TupleDefinitionType.Shortcut: - this.AddShortcutTuple((ShortcutTuple)tuple, output); + this.AddShortcutTuple((ShortcutTuple)tuple); break; case TupleDefinitionType.Signature: - this.AddTupleDefaultly(tuple, output, idIsPrimaryKey: true); + this.AddTupleDefaultly(tuple, idIsPrimaryKey: true); break; case TupleDefinitionType.SummaryInformation: - this.AddTupleDefaultly(tuple, output, tableName: "_SummaryInformation"); + this.AddTupleDefaultly(tuple, tableName: "_SummaryInformation"); break; case TupleDefinitionType.TextStyle: - this.AddTextStyleTuple((TextStyleTuple)tuple, output); + this.AddTextStyleTuple((TextStyleTuple)tuple); break; case TupleDefinitionType.Upgrade: - this.AddUpgradeTuple((UpgradeTuple)tuple, output); + this.AddUpgradeTuple((UpgradeTuple)tuple); break; case TupleDefinitionType.WixAction: - this.AddWixActionTuple((WixActionTuple)tuple, output); + this.AddWixActionTuple((WixActionTuple)tuple); break; case TupleDefinitionType.WixMediaTemplate: - this.AddWixMediaTemplateTuple((WixMediaTemplateTuple)tuple, output); + this.AddWixMediaTemplateTuple((WixMediaTemplateTuple)tuple); break; case TupleDefinitionType.MustBeFromAnExtension: - this.AddTupleFromExtension(tuple, output); + this.AddTupleFromExtension(tuple); break; case TupleDefinitionType.WixCustomRow: - this.AddWixCustomRowTuple((WixCustomRowTuple)tuple, output); + this.AddWixCustomRowTuple((WixCustomRowTuple)tuple); break; case TupleDefinitionType.WixEnsureTable: - this.AddWixEnsureTableTuple((WixEnsureTableTuple)tuple, output); + this.AddWixEnsureTableTuple((WixEnsureTableTuple)tuple); break; // ignored. @@ -234,25 +234,25 @@ namespace WixToolset.Core.WindowsInstaller.Bind case TupleDefinitionType.WixComponentGroup: case TupleDefinitionType.WixDeltaPatchFile: case TupleDefinitionType.WixFeatureGroup: - break; + case TupleDefinitionType.WixPatchBaseline: + break; // Already processed. case TupleDefinitionType.WixCustomTable: break; default: - this.AddTupleDefaultly(tuple, output); + this.AddTupleDefaultly(tuple); break; } } } - private void AddAssemblyTuple(AssemblyTuple tuple, WindowsInstallerData output) + private void AddAssemblyTuple(AssemblyTuple tuple) { var attributes = tuple.Type == AssemblyType.Win32Assembly ? 1 : (int?)null; - var table = output.EnsureTable(this.TableDefinitions["MsiAssembly"]); - var row = table.CreateRow(tuple.SourceLineNumbers); + var row = this.CreateRow(tuple, "MsiAssembly"); row[0] = tuple.ComponentRef; row[1] = tuple.FeatureRef; row[2] = tuple.ManifestFileRef; @@ -260,7 +260,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind row[4] = attributes; } - private void AddBBControlTuple(BBControlTuple tuple, WindowsInstallerData output) + private void AddBBControlTuple(BBControlTuple tuple) { var attributes = tuple.Attributes; attributes |= tuple.Enabled ? WindowsInstallerConstants.MsidbControlAttributesEnabled : 0; @@ -272,8 +272,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind attributes |= tuple.Sunken ? WindowsInstallerConstants.MsidbControlAttributesSunken : 0; attributes |= tuple.Visible ? WindowsInstallerConstants.MsidbControlAttributesVisible : 0; - var table = output.EnsureTable(this.TableDefinitions["BBControl"]); - var row = table.CreateRow(tuple.SourceLineNumbers); + var row = this.CreateRow(tuple, "BBControl"); row[0] = tuple.BillboardRef; row[1] = tuple.BBControl; row[2] = tuple.Type; @@ -285,10 +284,9 @@ namespace WixToolset.Core.WindowsInstaller.Bind row[8] = tuple.Text; } - private void AddClassTuple(ClassTuple tuple, WindowsInstallerData output) + private void AddClassTuple(ClassTuple tuple) { - var table = output.EnsureTable(this.TableDefinitions["Class"]); - var row = table.CreateRow(tuple.SourceLineNumbers); + var row = this.CreateRow(tuple, "Class"); row[0] = tuple.CLSID; row[1] = tuple.Context; row[2] = tuple.ComponentRef; @@ -304,7 +302,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind row[12] = tuple.RelativePath ? (int?)1 : null; } - private void AddControlTuple(ControlTuple tuple, WindowsInstallerData output) + private void AddControlTuple(ControlTuple tuple) { var text = tuple.Text; var attributes = tuple.Attributes; @@ -329,8 +327,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind text = String.Concat(text, " "); } - var table = output.EnsureTable(this.TableDefinitions["Control"]); - var row = table.CreateRow(tuple.SourceLineNumbers); + var row = this.CreateRow(tuple, "Control"); row[0] = tuple.DialogRef; row[1] = tuple.Control; row[2] = tuple.Type; @@ -344,7 +341,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind row[10] = tuple.Help; } - private void AddComponentTuple(ComponentTuple tuple, WindowsInstallerData output) + private void AddComponentTuple(ComponentTuple tuple) { var attributes = ComponentLocation.Either == tuple.Location ? WindowsInstallerConstants.MsidbComponentAttributesOptional : 0; attributes |= ComponentLocation.SourceOnly == tuple.Location ? WindowsInstallerConstants.MsidbComponentAttributesSourceOnly : 0; @@ -359,8 +356,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind attributes |= tuple.UninstallWhenSuperseded ? WindowsInstallerConstants.MsidbComponentAttributesUninstallOnSupersedence : 0; attributes |= tuple.Win64 ? WindowsInstallerConstants.MsidbComponentAttributes64bit : 0; - var table = output.EnsureTable(this.TableDefinitions["Component"]); - var row = table.CreateRow(tuple.SourceLineNumbers); + var row = this.CreateRow(tuple, "Component"); row[0] = tuple.Id.Id; row[1] = tuple.ComponentId; row[2] = tuple.DirectoryRef; @@ -369,7 +365,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind row[5] = tuple.KeyPath; } - private void AddCustomActionTuple(CustomActionTuple tuple, WindowsInstallerData output) + private void AddCustomActionTuple(CustomActionTuple tuple) { var type = tuple.Win64 ? WindowsInstallerConstants.MsidbCustomActionType64BitScript : 0; type |= tuple.IgnoreResult ? WindowsInstallerConstants.MsidbCustomActionTypeContinue : 0; @@ -396,8 +392,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind type |= tuple.TSAware ? WindowsInstallerConstants.MsidbCustomActionTypeTSAware : 0; } - var table = output.EnsureTable(this.TableDefinitions["CustomAction"]); - var row = table.CreateRow(tuple.SourceLineNumbers); + var row = this.CreateRow(tuple, "CustomAction"); row[0] = tuple.Id.Id; row[1] = type; row[2] = tuple.Source; @@ -405,7 +400,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind row[4] = tuple.PatchUninstall ? (int?)WindowsInstallerConstants.MsidbCustomActionTypePatchUninstall : null; } - private void AddDialogTuple(DialogTuple tuple, WindowsInstallerData output) + private void AddDialogTuple(DialogTuple tuple) { var attributes = tuple.Visible ? WindowsInstallerConstants.MsidbDialogAttributesVisible : 0; attributes|= tuple.Modal ? WindowsInstallerConstants.MsidbDialogAttributesModal : 0; @@ -419,8 +414,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind attributes|= tuple.SystemModal ? WindowsInstallerConstants.MsidbDialogAttributesSysModal : 0; attributes|= tuple.TrackDiskSpace ? WindowsInstallerConstants.MsidbDialogAttributesTrackDiskSpace : 0; - var table = output.EnsureTable(this.TableDefinitions["Dialog"]); - var row = table.CreateRow(tuple.SourceLineNumbers); + var row = this.CreateRow(tuple, "Dialog"); row[0] = tuple.Id.Id; row[1] = tuple.HCentering; row[2] = tuple.VCentering; @@ -432,10 +426,10 @@ namespace WixToolset.Core.WindowsInstaller.Bind row[8] = tuple.DefaultControlRef; row[9] = tuple.CancelControlRef; - output.EnsureTable(this.TableDefinitions["ListBox"]); + this.Output.EnsureTable(this.TableDefinitions["ListBox"]); } - private void AddDirectoryTuple(DirectoryTuple tuple, WindowsInstallerData output) + private void AddDirectoryTuple(DirectoryTuple tuple) { var sourceName = GetMsiFilenameValue(tuple.SourceShortName, tuple.SourceName); var targetName = GetMsiFilenameValue(tuple.ShortName, tuple.Name); @@ -447,14 +441,13 @@ namespace WixToolset.Core.WindowsInstaller.Bind var defaultDir = String.IsNullOrEmpty(sourceName) ? targetName : targetName + ":" + sourceName ; - var table = output.EnsureTable(this.TableDefinitions["Directory"]); - var row = table.CreateRow(tuple.SourceLineNumbers); + var row = this.CreateRow(tuple, "Directory"); row[0] = tuple.Id.Id; row[1] = tuple.ParentDirectoryRef; row[2] = defaultDir; } - private void AddEnvironmentTuple(EnvironmentTuple tuple, WindowsInstallerData output) + private void AddEnvironmentTuple(EnvironmentTuple tuple) { var action = String.Empty; var system = tuple.System ? "*" : String.Empty; @@ -484,23 +477,21 @@ namespace WixToolset.Core.WindowsInstaller.Bind break; } - var table = output.EnsureTable(this.TableDefinitions["Environment"]); - var row = table.CreateRow(tuple.SourceLineNumbers); + var row = this.CreateRow(tuple, "Environment"); row[0] = tuple.Id.Id; row[1] = String.Concat(action, uninstall, system, tuple.Name); row[2] = value; row[3] = tuple.ComponentRef; } - private void AddErrorTuple(ErrorTuple tuple, WindowsInstallerData output) + private void AddErrorTuple(ErrorTuple tuple) { - var table = output.EnsureTable(this.TableDefinitions["Error"]); - var row = table.CreateRow(tuple.SourceLineNumbers); + var row = this.CreateRow(tuple, "Error"); row[0] = Convert.ToInt32(tuple.Id.Id); row[1] = tuple.Message; } - private void AddFeatureTuple(FeatureTuple tuple, WindowsInstallerData output) + private void AddFeatureTuple(FeatureTuple tuple) { var attributes = tuple.DisallowAbsent ? WindowsInstallerConstants.MsidbFeatureAttributesUIDisallowAbsent : 0; attributes |= tuple.DisallowAdvertise ? WindowsInstallerConstants.MsidbFeatureAttributesDisallowAdvertise : 0; @@ -508,8 +499,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind attributes |= FeatureInstallDefault.Source == tuple.InstallDefault ? WindowsInstallerConstants.MsidbFeatureAttributesFavorSource : 0; attributes |= FeatureTypicalDefault.Advertise == tuple.TypicalDefault ? WindowsInstallerConstants.MsidbFeatureAttributesFavorAdvertise : 0; - var table = output.EnsureTable(this.TableDefinitions["Feature"]); - var row = table.CreateRow(tuple.SourceLineNumbers); + var row = this.CreateRow(tuple, "Feature"); row[0] = tuple.Id.Id; row[1] = tuple.ParentFeatureRef; row[2] = tuple.Title; @@ -520,16 +510,17 @@ namespace WixToolset.Core.WindowsInstaller.Bind row[7] = attributes; } - private void AddFileTuple(FileTuple tuple, WindowsInstallerData output) + private void AddFileTuple(FileTuple tuple) { - var table = output.EnsureTable(this.TableDefinitions["File"]); - var row = (FileRow)table.CreateRow(tuple.SourceLineNumbers); + var row = (FileRow)this.CreateRow(tuple, "File"); row.File = tuple.Id.Id; row.Component = tuple.ComponentRef; row.FileName = GetMsiFilenameValue(tuple.ShortName, tuple.Name); row.FileSize = tuple.FileSize; row.Version = tuple.Version; row.Language = tuple.Language; + row.DiskId = tuple.DiskId ?? 1; // TODO: is 0 the correct thing to default here + row.Source = tuple.Source.Path; var attributes = (tuple.Attributes & FileTupleAttributes.Checksum) == FileTupleAttributes.Checksum ? WindowsInstallerConstants.MsidbFileAttributesChecksum : 0; attributes |= (tuple.Attributes & FileTupleAttributes.Compressed) == FileTupleAttributes.Compressed ? WindowsInstallerConstants.MsidbFileAttributesCompressed : 0; @@ -542,19 +533,17 @@ namespace WixToolset.Core.WindowsInstaller.Bind if (!String.IsNullOrEmpty(tuple.FontTitle)) { - var fontTable = output.EnsureTable(this.TableDefinitions["Font"]); - var fontRow = fontTable.CreateRow(tuple.SourceLineNumbers); + var fontRow = this.CreateRow(tuple, "Font"); fontRow[0] = tuple.Id.Id; fontRow[1] = tuple.FontTitle; } } - private void AddIniFileTuple(IniFileTuple tuple, WindowsInstallerData output) + private void AddIniFileTuple(IniFileTuple tuple) { var tableName = (InifFileActionType.AddLine == tuple.Action || InifFileActionType.AddTag == tuple.Action || InifFileActionType.CreateLine == tuple.Action) ? "IniFile" : "RemoveIniFile"; - var table = output.EnsureTable(this.TableDefinitions[tableName]); - var row = table.CreateRow(tuple.SourceLineNumbers); + var row = this.CreateRow(tuple, tableName); row[0] = tuple.Id.Id; row[1] = tuple.FileName; row[2] = tuple.DirProperty; @@ -565,12 +554,11 @@ namespace WixToolset.Core.WindowsInstaller.Bind row[7] = tuple.ComponentRef; } - private void AddMediaTuple(MediaTuple tuple, WindowsInstallerData output) + private void AddMediaTuple(MediaTuple tuple) { if (this.Section.Type != SectionType.Module) { - var table = output.EnsureTable(this.TableDefinitions["Media"]); - var row = (MediaRow)table.CreateRow(tuple.SourceLineNumbers); + var row = (MediaRow)this.CreateRow(tuple, "Media"); row.DiskId = tuple.DiskId; row.LastSequence = tuple.LastSequence ?? 0; row.DiskPrompt = tuple.DiskPrompt; @@ -580,10 +568,9 @@ namespace WixToolset.Core.WindowsInstaller.Bind } } - private void AddModuleConfigurationTuple(ModuleConfigurationTuple tuple, WindowsInstallerData output) + private void AddModuleConfigurationTuple(ModuleConfigurationTuple tuple) { - var table = output.EnsureTable(this.TableDefinitions["ModuleConfiguration"]); - var row = table.CreateRow(tuple.SourceLineNumbers); + var row = this.CreateRow(tuple, "ModuleConfiguration"); row[0] = tuple.Id.Id; row[1] = tuple.Format; row[2] = tuple.Type; @@ -597,13 +584,12 @@ namespace WixToolset.Core.WindowsInstaller.Bind row[9] = tuple.HelpKeyword; } - private void AddMsiEmbeddedUITuple(MsiEmbeddedUITuple tuple, WindowsInstallerData output) + private void AddMsiEmbeddedUITuple(MsiEmbeddedUITuple tuple) { var attributes = tuple.EntryPoint ? WindowsInstallerConstants.MsidbEmbeddedUI : 0; attributes |= tuple.SupportsBasicUI ? WindowsInstallerConstants.MsidbEmbeddedHandlesBasic : 0; - var table = output.EnsureTable(this.TableDefinitions["MsiEmbeddedUI"]); - var row = table.CreateRow(tuple.SourceLineNumbers); + var row = this.CreateRow(tuple, "MsiEmbeddedUI"); row[0] = tuple.Id.Id; row[1] = tuple.FileName; row[2] = attributes; @@ -611,10 +597,9 @@ namespace WixToolset.Core.WindowsInstaller.Bind row[4] = tuple.Source; } - private void AddMsiFileHashTuple(MsiFileHashTuple tuple, WindowsInstallerData output) + private void AddMsiFileHashTuple(MsiFileHashTuple tuple) { - var table = output.EnsureTable(this.TableDefinitions["MsiFileHash"]); - var row = table.CreateRow(tuple.SourceLineNumbers); + var row = this.CreateRow(tuple, "MsiFileHash"); row[0] = tuple.Id.Id; row[1] = tuple.Options; row[2] = tuple.HashPart1; @@ -623,14 +608,13 @@ namespace WixToolset.Core.WindowsInstaller.Bind row[5] = tuple.HashPart4; } - private void AddMsiServiceConfigTuple(MsiServiceConfigTuple tuple, WindowsInstallerData output) + private void AddMsiServiceConfigTuple(MsiServiceConfigTuple tuple) { var events = tuple.OnInstall ? WindowsInstallerConstants.MsidbServiceConfigEventInstall : 0; events |= tuple.OnReinstall ? WindowsInstallerConstants.MsidbServiceConfigEventReinstall : 0; events |= tuple.OnUninstall ? WindowsInstallerConstants.MsidbServiceConfigEventUninstall : 0; - var table = output.EnsureTable(this.TableDefinitions["MsiServiceConfigFailureActions"]); - var row = table.CreateRow(tuple.SourceLineNumbers); + var row = this.CreateRow(tuple, "MsiServiceConfigFailureActions"); row[0] = tuple.Id.Id; row[1] = tuple.Name; row[2] = events; @@ -639,14 +623,13 @@ namespace WixToolset.Core.WindowsInstaller.Bind row[5] = tuple.ComponentRef; } - private void AddMsiServiceConfigFailureActionsTuple(MsiServiceConfigFailureActionsTuple tuple, WindowsInstallerData output) + private void AddMsiServiceConfigFailureActionsTuple(MsiServiceConfigFailureActionsTuple tuple) { var events = tuple.OnInstall ? WindowsInstallerConstants.MsidbServiceConfigEventInstall : 0; events |= tuple.OnReinstall ? WindowsInstallerConstants.MsidbServiceConfigEventReinstall : 0; events |= tuple.OnUninstall ? WindowsInstallerConstants.MsidbServiceConfigEventUninstall : 0; - var table = output.EnsureTable(this.TableDefinitions["MsiServiceConfig"]); - var row = table.CreateRow(tuple.SourceLineNumbers); + var row = this.CreateRow(tuple, "MsiServiceConfig"); row[0] = tuple.Id.Id; row[1] = tuple.Name; row[2] = events; @@ -658,10 +641,9 @@ namespace WixToolset.Core.WindowsInstaller.Bind row[8] = tuple.ComponentRef; } - private void AddMoveFileTuple(MoveFileTuple tuple, WindowsInstallerData output) + private void AddMoveFileTuple(MoveFileTuple tuple) { - var table = output.EnsureTable(this.TableDefinitions["MoveFile"]); - var row = table.CreateRow(tuple.SourceLineNumbers); + var row = this.CreateRow(tuple, "MoveFile"); row[0] = tuple.Id.Id; row[1] = tuple.ComponentRef; row[2] = tuple.SourceName; @@ -671,26 +653,24 @@ namespace WixToolset.Core.WindowsInstaller.Bind row[6] = tuple.Delete ? WindowsInstallerConstants.MsidbMoveFileOptionsMove : 0; } - private void AddPropertyTuple(PropertyTuple tuple, WindowsInstallerData output) + private void AddPropertyTuple(PropertyTuple tuple) { if (String.IsNullOrEmpty(tuple.Value)) { return; } - var table = output.EnsureTable(this.TableDefinitions["Property"]); - var row = (PropertyRow)table.CreateRow(tuple.SourceLineNumbers); + var row = (PropertyRow)this.CreateRow(tuple, "Property"); row.Property = tuple.Id.Id; row.Value = tuple.Value; } - private void AddRemoveFileTuple(RemoveFileTuple tuple, WindowsInstallerData output) + private void AddRemoveFileTuple(RemoveFileTuple tuple) { var installMode = tuple.OnInstall == true ? WindowsInstallerConstants.MsidbRemoveFileInstallModeOnInstall : 0; installMode |= tuple.OnUninstall == true ? WindowsInstallerConstants.MsidbRemoveFileInstallModeOnRemove : 0; - var table = output.EnsureTable(this.TableDefinitions["RemoveFile"]); - var row = table.CreateRow(tuple.SourceLineNumbers); + var row = this.CreateRow(tuple, "RemoveFile"); row[0] = tuple.Id.Id; row[1] = tuple.ComponentRef; row[2] = tuple.FileName; @@ -698,7 +678,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind row[4] = installMode; } - private void AddRegistryTuple(RegistryTuple tuple, WindowsInstallerData output) + private void AddRegistryTuple(RegistryTuple tuple) { var value = tuple.Value; @@ -740,8 +720,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind break; } - var table = output.EnsureTable(this.TableDefinitions["Registry"]); - var row = table.CreateRow(tuple.SourceLineNumbers); + var row = this.CreateRow(tuple, "Registry"); row[0] = tuple.Id.Id; row[1] = tuple.Root; row[2] = tuple.Key; @@ -750,13 +729,12 @@ namespace WixToolset.Core.WindowsInstaller.Bind row[5] = tuple.ComponentRef; } - private void AddRegLocatorTuple(RegLocatorTuple tuple, WindowsInstallerData output) + private void AddRegLocatorTuple(RegLocatorTuple tuple) { var type = (int)tuple.Type; type |= tuple.Win64 ? WindowsInstallerConstants.MsidbLocatorType64bit : 0; - var table = output.EnsureTable(this.TableDefinitions["RegLocator"]); - var row = table.CreateRow(tuple.SourceLineNumbers); + var row = this.CreateRow(tuple, "RegLocator"); row[0] = tuple.Id.Id; row[1] = tuple.Root; row[2] = tuple.Key; @@ -764,12 +742,11 @@ namespace WixToolset.Core.WindowsInstaller.Bind row[4] = type; } - private void AddRemoveRegistryTuple(RemoveRegistryTuple tuple, WindowsInstallerData output) + private void AddRemoveRegistryTuple(RemoveRegistryTuple tuple) { if (tuple.Action == RemoveRegistryActionType.RemoveOnInstall) { - var table = output.EnsureTable(this.TableDefinitions["RemoveRegistry"]); - var row = table.CreateRow(tuple.SourceLineNumbers); + var row = this.CreateRow(tuple, "RemoveRegistry"); row[0] = tuple.Id.Id; row[1] = tuple.Root; row[2] = tuple.Key; @@ -778,8 +755,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind } else // Registry table is used to remove registry keys on uninstall. { - var table = output.EnsureTable(this.TableDefinitions["Registry"]); - var row = table.CreateRow(tuple.SourceLineNumbers); + var row = this.CreateRow(tuple, "Registry"); row[0] = tuple.Id.Id; row[1] = tuple.Root; row[2] = tuple.Key; @@ -788,7 +764,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind } } - private void AddServiceControlTuple(ServiceControlTuple tuple, WindowsInstallerData output) + private void AddServiceControlTuple(ServiceControlTuple tuple) { var events = tuple.InstallRemove ? WindowsInstallerConstants.MsidbServiceControlEventDelete : 0; events |= tuple.UninstallRemove ? WindowsInstallerConstants.MsidbServiceControlEventUninstallDelete : 0; @@ -797,8 +773,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind events |= tuple.InstallStop ? WindowsInstallerConstants.MsidbServiceControlEventStop : 0; events |= tuple.UninstallStop ? WindowsInstallerConstants.MsidbServiceControlEventUninstallStop : 0; - var table = output.EnsureTable(this.TableDefinitions["ServiceControl"]); - var row = table.CreateRow(tuple.SourceLineNumbers); + var row = this.CreateRow(tuple, "ServiceControl"); row[0] = tuple.Id.Id; row[1] = tuple.Name; row[2] = events; @@ -810,7 +785,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind row[5] = tuple.ComponentRef; } - private void AddServiceInstallTuple(ServiceInstallTuple tuple, WindowsInstallerData output) + private void AddServiceInstallTuple(ServiceInstallTuple tuple) { var errorControl = (int)tuple.ErrorControl; errorControl |= tuple.Vital ? WindowsInstallerConstants.MsidbServiceInstallErrorControlVital : 0; @@ -818,8 +793,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind var serviceType = (int)tuple.ServiceType; serviceType |= tuple.Interactive ? WindowsInstallerConstants.MsidbServiceInstallInteractive : 0; - var table = output.EnsureTable(this.TableDefinitions["ServiceInstall"]); - var row = table.CreateRow(tuple.SourceLineNumbers); + var row = this.CreateRow(tuple, "ServiceInstall"); row[0] = tuple.Id.Id; row[1] = tuple.Name; row[2] = tuple.DisplayName; @@ -835,10 +809,9 @@ namespace WixToolset.Core.WindowsInstaller.Bind row[12] = tuple.Description; } - private void AddShortcutTuple(ShortcutTuple tuple, WindowsInstallerData output) + private void AddShortcutTuple(ShortcutTuple tuple) { - var table = output.EnsureTable(this.TableDefinitions["Shortcut"]); - var row = table.CreateRow(tuple.SourceLineNumbers); + var row = this.CreateRow(tuple, "Shortcut"); row[0] = tuple.Id.Id; row[1] = tuple.DirectoryRef; row[2] = GetMsiFilenameValue(tuple.ShortName, tuple.Name); @@ -857,7 +830,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind row[15] = tuple.DescriptionResourceId; } - private void AddTextStyleTuple(TextStyleTuple tuple, WindowsInstallerData output) + private void AddTextStyleTuple(TextStyleTuple tuple) { var styleBits = tuple.Bold ? WindowsInstallerConstants.MsidbTextStyleStyleBitsBold : 0; styleBits |= tuple.Italic ? WindowsInstallerConstants.MsidbTextStyleStyleBitsItalic : 0; @@ -873,8 +846,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind color += (long)(tuple.Blue ?? 0) * 65536; } - var table = output.EnsureTable(this.TableDefinitions["TextStyle"]); - var row = table.CreateRow(tuple.SourceLineNumbers); + var row = this.CreateRow(tuple, "TextStyle"); row[0] = tuple.Id.Id; row[1] = tuple.FaceName; row[2] = tuple.Size; @@ -882,10 +854,9 @@ namespace WixToolset.Core.WindowsInstaller.Bind row[4] = styleBits == 0 ? null : (int?)styleBits; } - private void AddUpgradeTuple(UpgradeTuple tuple, WindowsInstallerData output) + private void AddUpgradeTuple(UpgradeTuple tuple) { - var table = output.EnsureTable(this.TableDefinitions["Upgrade"]); - var row = (UpgradeRow)table.CreateRow(tuple.SourceLineNumbers); + var row = (UpgradeRow)this.CreateRow(tuple, "Upgrade"); row.UpgradeCode = tuple.UpgradeCode; row.VersionMin = tuple.VersionMin; row.VersionMax = tuple.VersionMax; @@ -902,72 +873,71 @@ namespace WixToolset.Core.WindowsInstaller.Bind row.Attributes = attributes; } - private void AddWixActionTuple(WixActionTuple tuple, WindowsInstallerData output) + private void AddWixActionTuple(WixActionTuple tuple) { // Get the table definition for the action (and ensure the proper table exists for a module). - TableDefinition sequenceTableDefinition = null; + string sequenceTableName = null; switch (tuple.SequenceTable) { case SequenceTable.AdminExecuteSequence: - if (OutputType.Module == output.Type) + if (OutputType.Module == this.Output.Type) { - output.EnsureTable(this.TableDefinitions["AdminExecuteSequence"]); - sequenceTableDefinition = this.TableDefinitions["ModuleAdminExecuteSequence"]; + this.Output.EnsureTable(this.TableDefinitions["AdminExecuteSequence"]); + sequenceTableName = "ModuleAdminExecuteSequence"; } else { - sequenceTableDefinition = this.TableDefinitions["AdminExecuteSequence"]; + sequenceTableName = "AdminExecuteSequence"; } break; case SequenceTable.AdminUISequence: - if (OutputType.Module == output.Type) + if (OutputType.Module == this.Output.Type) { - output.EnsureTable(this.TableDefinitions["AdminUISequence"]); - sequenceTableDefinition = this.TableDefinitions["ModuleAdminUISequence"]; + this.Output.EnsureTable(this.TableDefinitions["AdminUISequence"]); + sequenceTableName = "ModuleAdminUISequence"; } else { - sequenceTableDefinition = this.TableDefinitions["AdminUISequence"]; + sequenceTableName = "AdminUISequence"; } break; case SequenceTable.AdvertiseExecuteSequence: - if (OutputType.Module == output.Type) + if (OutputType.Module == this.Output.Type) { - output.EnsureTable(this.TableDefinitions["AdvtExecuteSequence"]); - sequenceTableDefinition = this.TableDefinitions["ModuleAdvtExecuteSequence"]; + this.Output.EnsureTable(this.TableDefinitions["AdvtExecuteSequence"]); + sequenceTableName = "ModuleAdvtExecuteSequence"; } else { - sequenceTableDefinition = this.TableDefinitions["AdvtExecuteSequence"]; + sequenceTableName = "AdvtExecuteSequence"; } break; case SequenceTable.InstallExecuteSequence: - if (OutputType.Module == output.Type) + if (OutputType.Module == this.Output.Type) { - output.EnsureTable(this.TableDefinitions["InstallExecuteSequence"]); - sequenceTableDefinition = this.TableDefinitions["ModuleInstallExecuteSequence"]; + this.Output.EnsureTable(this.TableDefinitions["InstallExecuteSequence"]); + sequenceTableName = "ModuleInstallExecuteSequence"; } else { - sequenceTableDefinition = this.TableDefinitions["InstallExecuteSequence"]; + sequenceTableName = "InstallExecuteSequence"; } break; case SequenceTable.InstallUISequence: - if (OutputType.Module == output.Type) + if (OutputType.Module == this.Output.Type) { - output.EnsureTable(this.TableDefinitions["InstallUISequence"]); - sequenceTableDefinition = this.TableDefinitions["ModuleInstallUISequence"]; + this.Output.EnsureTable(this.TableDefinitions["InstallUISequence"]); + sequenceTableName = "ModuleInstallUISequence"; } else { - sequenceTableDefinition = this.TableDefinitions["InstallUISequence"]; + sequenceTableName = "InstallUISequence"; } break; } // create the action sequence row in the output - var sequenceTable = output.EnsureTable(sequenceTableDefinition); - var row = sequenceTable.CreateRow(tuple.SourceLineNumbers); + var row = this.CreateRow(tuple, sequenceTableName); if (SectionType.Module == this.Section.Type) { @@ -992,7 +962,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind } } - private void AddWixCustomRowTuple(WixCustomRowTuple tuple, WindowsInstallerData output) + private void AddWixCustomRowTuple(WixCustomRowTuple tuple) { var customTableDefinition = this.TableDefinitions[tuple.Table]; @@ -1002,8 +972,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind return; } - var customTable = output.EnsureTable(customTableDefinition); - var customRow = customTable.CreateRow(tuple.SourceLineNumbers); + var customRow = this.CreateRow(tuple, customTableDefinition); #if TODO // SectionId seems like a good thing to preserve. customRow.SectionId = tuple.SectionId; @@ -1073,16 +1042,15 @@ namespace WixToolset.Core.WindowsInstaller.Bind } } - private void AddWixEnsureTableTuple(WixEnsureTableTuple tuple, WindowsInstallerData output) + private void AddWixEnsureTableTuple(WixEnsureTableTuple tuple) { var tableDefinition = this.TableDefinitions[tuple.Table]; - output.EnsureTable(tableDefinition); + this.Output.EnsureTable(tableDefinition); } - private void AddWixMediaTemplateTuple(WixMediaTemplateTuple tuple, WindowsInstallerData output) + private void AddWixMediaTemplateTuple(WixMediaTemplateTuple tuple) { - var table = output.EnsureTable(this.TableDefinitions["WixMediaTemplate"]); - var row = (WixMediaTemplateRow)table.CreateRow(tuple.SourceLineNumbers); + var row = (WixMediaTemplateRow)this.CreateRow(tuple, "WixMediaTemplate"); row.CabinetTemplate = tuple.CabinetTemplate; row.CompressionLevel = tuple.CompressionLevel; row.DiskPrompt = tuple.DiskPrompt; @@ -1091,26 +1059,25 @@ namespace WixToolset.Core.WindowsInstaller.Bind row.MaximumCabinetSizeForLargeFileSplitting = tuple.MaximumCabinetSizeForLargeFileSplitting ?? MaxValueOfMaxCabSizeForLargeFileSplitting; } - private void AddTupleFromExtension(IntermediateTuple tuple, WindowsInstallerData output) + private void AddTupleFromExtension(IntermediateTuple tuple) { foreach (var extension in this.BackendExtensions) { - if (extension.TryAddTupleToOutput(tuple, output)) + if (extension.TryAddTupleToOutput(tuple, this.Output)) { break; } } } - private void AddTupleDefaultly(IntermediateTuple tuple, WindowsInstallerData output, bool idIsPrimaryKey = false, string tableName = null) + private void AddTupleDefaultly(IntermediateTuple tuple, bool idIsPrimaryKey = false, string tableName = null) { if (!this.TableDefinitions.TryGet(tableName ?? tuple.Definition.Name, out var tableDefinition)) { return; } - var table = output.EnsureTable(tableDefinition); - var row = table.CreateRow(tuple.SourceLineNumbers); + var row = this.CreateRow(tuple, tableDefinition); var rowOffset = 0; if (idIsPrimaryKey) @@ -1159,6 +1126,18 @@ namespace WixToolset.Core.WindowsInstaller.Bind } } + private Row CreateRow(IntermediateTuple tuple, string tableDefinitionName) => this.CreateRow(tuple, this.TableDefinitions[tableDefinitionName]); + + private Row CreateRow(IntermediateTuple tuple, TableDefinition tableDefinition) + { + var table = this.Output.EnsureTable(tableDefinition); + + var row = table.CreateRow(tuple.SourceLineNumbers); + row.SectionId = this.Section.Id; + + return row; + } + private static string GetMsiFilenameValue(string shortName, string longName) { if (String.IsNullOrEmpty(shortName) || String.Equals(shortName, longName, StringComparison.OrdinalIgnoreCase)) diff --git a/src/WixToolset.Core.WindowsInstaller/Bind/CreatePatchTransformsCommand.cs b/src/WixToolset.Core.WindowsInstaller/Bind/CreatePatchTransformsCommand.cs new file mode 100644 index 00000000..854d973e --- /dev/null +++ b/src/WixToolset.Core.WindowsInstaller/Bind/CreatePatchTransformsCommand.cs @@ -0,0 +1,90 @@ +// 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.Core.WindowsInstaller.Bind +{ + using System; + using System.Collections.Generic; + using System.IO; + using System.Linq; + using WixToolset.Core.WindowsInstaller.Msi; + using WixToolset.Core.WindowsInstaller.Unbind; + using WixToolset.Data; + using WixToolset.Data.Tuples; + using WixToolset.Data.WindowsInstaller; + using WixToolset.Extensibility.Services; + + internal class CreatePatchTransformsCommand + { + public CreatePatchTransformsCommand(IMessaging messaging, Intermediate intermediate, string intermediateFolder) + { + this.Messaging = messaging; + this.Intermediate = intermediate; + this.IntermediateFolder = intermediateFolder; + } + + private IMessaging Messaging { get; } + + private Intermediate Intermediate { get; } + + private string IntermediateFolder { get; } + + public IEnumerable PatchTransforms { get; private set; } + + public IEnumerable Execute() + { + var patchTransforms = new List(); + + var tuples = this.Intermediate.Sections.SelectMany(s => s.Tuples).OfType(); + + foreach (var tuple in tuples) + { + WindowsInstallerData transform; + + if (tuple.TransformFile is null) + { + var baselineData = this.GetData(tuple.BaselineFile.Path); + var updateData = this.GetData(tuple.UpdateFile.Path); + + var command = new GenerateTransformCommand(this.Messaging, baselineData, updateData, false); + transform = command.Execute(); + } + else + { + var exportBasePath = Path.Combine(this.IntermediateFolder, "_trans"); // TODO: come up with a better path. + + var command = new UnbindTransformCommand(this.Messaging, tuple.TransformFile.Path, exportBasePath, this.IntermediateFolder); + transform = command.Execute(); + } + + patchTransforms.Add(new PatchTransform(tuple.Id.Id, transform)); + } + + this.PatchTransforms = patchTransforms; + + return this.PatchTransforms; + } + + private WindowsInstallerData GetData(string path) + { + var ext = Path.GetExtension(path); + + if (".msi".Equals(ext, StringComparison.OrdinalIgnoreCase)) + { + using (var database = new Database(path, OpenDatabase.ReadOnly)) + { + var exportBasePath = Path.Combine(this.IntermediateFolder, "_msi"); // TODO: come up with a better path. + + var isAdminImage = false; // TODO: need a better way to set this + + var command = new UnbindDatabaseCommand(this.Messaging, database, path, OutputType.Product, exportBasePath, this.IntermediateFolder, isAdminImage, suppressDemodularization: true, skipSummaryInfo: true); + return command.Execute(); + } + } + else // assume .wixpdb (or .wixout) + { + var data = WindowsInstallerData.Load(path, true); + return data; + } + } + } +} diff --git a/src/WixToolset.Core.WindowsInstaller/Bind/ExtractMergeModuleFilesCommand.cs b/src/WixToolset.Core.WindowsInstaller/Bind/ExtractMergeModuleFilesCommand.cs index 5412c6f9..49b6a6f8 100644 --- a/src/WixToolset.Core.WindowsInstaller/Bind/ExtractMergeModuleFilesCommand.cs +++ b/src/WixToolset.Core.WindowsInstaller/Bind/ExtractMergeModuleFilesCommand.cs @@ -48,7 +48,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind { var mergeModulesFileFacades = new List(); - IMsmMerge2 merge = MsmInterop.GetMsmMerge(); + var merge = MsmInterop.GetMsmMerge(); // Index all of the file rows to be able to detect collisions with files in the Merge Modules. // It may seem a bit expensive to build up this index solely for the purpose of checking collisions @@ -57,11 +57,11 @@ namespace WixToolset.Core.WindowsInstaller.Bind // Now since Merge Modules are already slow and generally less desirable than .wixlibs we'll let // this case be slightly more expensive because the cost of maintaining an indexed file row collection // is a lot more costly for the common cases. - var indexedFileFacades = this.FileFacades.ToDictionary(f => f.File.Id.Id, StringComparer.Ordinal); + var indexedFileFacades = this.FileFacades.ToDictionary(f => f.Id, StringComparer.Ordinal); foreach (var wixMergeRow in this.WixMergeTuples) { - bool containsFiles = this.CreateFacadesForMergeModuleFiles(wixMergeRow, mergeModulesFileFacades, indexedFileFacades); + var containsFiles = this.CreateFacadesForMergeModuleFiles(wixMergeRow, mergeModulesFileFacades, indexedFileFacades); // If the module has files and creating layout if (containsFiles && !this.SuppressLayout) @@ -75,21 +75,21 @@ namespace WixToolset.Core.WindowsInstaller.Bind private bool CreateFacadesForMergeModuleFiles(WixMergeTuple wixMergeRow, List mergeModulesFileFacades, Dictionary indexedFileFacades) { - bool containsFiles = false; + var containsFiles = false; try { // read the module's File table to get its FileMediaInformation entries and gather any other information needed from the module. - using (Database db = new Database(wixMergeRow.SourceFile, OpenDatabase.ReadOnly)) + using (var db = new Database(wixMergeRow.SourceFile, OpenDatabase.ReadOnly)) { if (db.TableExists("File") && db.TableExists("Component")) { - Dictionary uniqueModuleFileIdentifiers = new Dictionary(StringComparer.OrdinalIgnoreCase); + var uniqueModuleFileIdentifiers = new Dictionary(StringComparer.OrdinalIgnoreCase); - using (View view = db.OpenExecuteView("SELECT `File`, `Directory_` FROM `File`, `Component` WHERE `Component_`=`Component`")) + using (var view = db.OpenExecuteView("SELECT `File`, `Directory_` FROM `File`, `Component` WHERE `Component_`=`Component`")) { // add each file row from the merge module into the file row collection (check for errors along the way) - foreach (Record record in view.Records) + foreach (var record in view.Records) { // NOTE: this is very tricky - the merge module file rows are not added to the // file table because they should not be created via idt import. Instead, these @@ -103,21 +103,21 @@ namespace WixToolset.Core.WindowsInstaller.Bind var mergeModuleFileFacade = new FileFacade(true, fileTuple); // If case-sensitive collision with another merge module or a user-authored file identifier. - if (indexedFileFacades.TryGetValue(mergeModuleFileFacade.File.Id.Id, out var collidingFacade)) + if (indexedFileFacades.TryGetValue(mergeModuleFileFacade.Id, out var collidingFacade)) { - this.Messaging.Write(ErrorMessages.DuplicateModuleFileIdentifier(wixMergeRow.SourceLineNumbers, wixMergeRow.Id.Id, collidingFacade.File.Id.Id)); + this.Messaging.Write(ErrorMessages.DuplicateModuleFileIdentifier(wixMergeRow.SourceLineNumbers, wixMergeRow.Id.Id, collidingFacade.Id)); } - else if (uniqueModuleFileIdentifiers.TryGetValue(mergeModuleFileFacade.File.Id.Id, out collidingFacade)) // case-insensitive collision with another file identifier in the same merge module + else if (uniqueModuleFileIdentifiers.TryGetValue(mergeModuleFileFacade.Id, out collidingFacade)) // case-insensitive collision with another file identifier in the same merge module { - this.Messaging.Write(ErrorMessages.DuplicateModuleCaseInsensitiveFileIdentifier(wixMergeRow.SourceLineNumbers, wixMergeRow.Id.Id, mergeModuleFileFacade.File.Id.Id, collidingFacade.File.Id.Id)); + this.Messaging.Write(ErrorMessages.DuplicateModuleCaseInsensitiveFileIdentifier(wixMergeRow.SourceLineNumbers, wixMergeRow.Id.Id, mergeModuleFileFacade.Id, collidingFacade.Id)); } else // no collision { mergeModulesFileFacades.Add(mergeModuleFileFacade); // Keep updating the indexes as new rows are added. - indexedFileFacades.Add(mergeModuleFileFacade.File.Id.Id, mergeModuleFileFacade); - uniqueModuleFileIdentifiers.Add(mergeModuleFileFacade.File.Id.Id, mergeModuleFileFacade); + indexedFileFacades.Add(mergeModuleFileFacade.Id, mergeModuleFileFacade); + uniqueModuleFileIdentifiers.Add(mergeModuleFileFacade.Id, mergeModuleFileFacade); } containsFiles = true; @@ -126,13 +126,13 @@ namespace WixToolset.Core.WindowsInstaller.Bind } // Get the summary information to detect the Schema - using (SummaryInformation summaryInformation = new SummaryInformation(db)) + using (var summaryInformation = new SummaryInformation(db)) { - string moduleInstallerVersionString = summaryInformation.GetProperty(14); + var moduleInstallerVersionString = summaryInformation.GetProperty(14); try { - int moduleInstallerVersion = Convert.ToInt32(moduleInstallerVersionString, CultureInfo.InvariantCulture); + var moduleInstallerVersion = Convert.ToInt32(moduleInstallerVersionString, CultureInfo.InvariantCulture); if (moduleInstallerVersion > this.OutputInstallerVersion) { this.Messaging.Write(WarningMessages.InvalidHigherInstallerVersionInModule(wixMergeRow.SourceLineNumbers, wixMergeRow.Id.Id, moduleInstallerVersion, this.OutputInstallerVersion)); @@ -159,7 +159,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind private void ExtractFilesFromMergeModule(IMsmMerge2 merge, WixMergeTuple wixMergeRow) { - bool moduleOpen = false; + var moduleOpen = false; short mergeLanguage; var mergeId = wixMergeRow.Id.Id; @@ -180,10 +180,10 @@ namespace WixToolset.Core.WindowsInstaller.Bind moduleOpen = true; // extract the module cabinet, then explode all of the files to a temp directory - string moduleCabPath = Path.Combine(this.IntermediateFolder, mergeId + ".cab"); + var moduleCabPath = Path.Combine(this.IntermediateFolder, mergeId + ".cab"); merge.ExtractCAB(moduleCabPath); - string mergeIdPath = Path.Combine(this.IntermediateFolder, mergeId); + var mergeIdPath = Path.Combine(this.IntermediateFolder, mergeId); Directory.CreateDirectory(mergeIdPath); try diff --git a/src/WixToolset.Core.WindowsInstaller/Bind/GenerateDatabaseCommand.cs b/src/WixToolset.Core.WindowsInstaller/Bind/GenerateDatabaseCommand.cs index 6b365ecd..ed3b6f01 100644 --- a/src/WixToolset.Core.WindowsInstaller/Bind/GenerateDatabaseCommand.cs +++ b/src/WixToolset.Core.WindowsInstaller/Bind/GenerateDatabaseCommand.cs @@ -5,367 +5,396 @@ namespace WixToolset.Core.WindowsInstaller.Bind using System; using System.Collections.Generic; using System.ComponentModel; - using System.Globalization; using System.IO; using System.Text; + using WixToolset.Core.WindowsInstaller.Msi; using WixToolset.Data; - using WixToolset.Extensibility; using WixToolset.Data.WindowsInstaller; - using WixToolset.Extensibility.Services; + using WixToolset.Extensibility; using WixToolset.Extensibility.Data; - using WixToolset.Core.WindowsInstaller.Msi; + using WixToolset.Extensibility.Services; - internal class GenerateDatabaseCommand + internal class GenerateDatabaseCommand { - public int Codepage { private get; set; } + public GenerateDatabaseCommand(IMessaging messaging, IBackendHelper backendHelper, IEnumerable fileSystemExtensions, WindowsInstallerData data, string outputPath, TableDefinitionCollection tableDefinitions, string intermediateFolder, int codepage, bool keepAddedColumns, bool suppressAddingValidationRows, bool useSubdirectory) + { + this.Messaging = messaging; + this.BackendHelper = backendHelper; + this.Extensions = fileSystemExtensions; + this.Data = data; + this.OutputPath = outputPath; + this.TableDefinitions = tableDefinitions; + this.IntermediateFolder = intermediateFolder; + this.Codepage = codepage; + this.KeepAddedColumns = keepAddedColumns; + this.SuppressAddingValidationRows = suppressAddingValidationRows; + this.UseSubDirectory = useSubdirectory; + } + + private int Codepage { get; } - public IBackendHelper BackendHelper { private get; set; } + private IBackendHelper BackendHelper { get; } - public IEnumerable Extensions { private get; set; } + private IEnumerable Extensions { get; } /// /// Whether to keep columns added in a transform. /// - public bool KeepAddedColumns { private get; set; } + private bool KeepAddedColumns { get; } - public IMessaging Messaging { private get; set; } + private IMessaging Messaging { get; } - public WindowsInstallerData Output { private get; set; } + private WindowsInstallerData Data { get; } - public string OutputPath { private get; set; } + private string OutputPath { get; } - public TableDefinitionCollection TableDefinitions { private get; set; } + private TableDefinitionCollection TableDefinitions { get; } - public string IntermediateFolder { private get; set; } + private string IntermediateFolder { get; } public List GeneratedTemporaryFiles { get; } = new List(); /// /// Whether to use a subdirectory based on the file name for intermediate files. /// - public bool SuppressAddingValidationRows { private get; set; } + private bool SuppressAddingValidationRows { get; } - public bool UseSubDirectory { private get; set; } + private bool UseSubDirectory { get; } public void Execute() { // Add the _Validation rows. if (!this.SuppressAddingValidationRows) { - var validationTable = this.Output.EnsureTable(this.TableDefinitions["_Validation"]); - - foreach (var table in this.Output.Tables) - { - if (!table.Definition.Unreal) - { - // Add the validation rows for this table. - foreach (ColumnDefinition columnDef in table.Definition.Columns) - { - var row = validationTable.CreateRow(null); - - row[0] = table.Name; - - row[1] = columnDef.Name; - - if (columnDef.Nullable) - { - row[2] = "Y"; - } - else - { - row[2] = "N"; - } - - if (columnDef.MinValue.HasValue) - { - row[3] = columnDef.MinValue.Value; - } - - if (columnDef.MaxValue.HasValue) - { - row[4] = columnDef.MaxValue.Value; - } - - row[5] = columnDef.KeyTable; - - if (columnDef.KeyColumn.HasValue) - { - row[6] = columnDef.KeyColumn.Value; - } - - if (ColumnCategory.Unknown != columnDef.Category) - { - row[7] = columnDef.Category.ToString(); - } - - row[8] = columnDef.Possibilities; - - row[9] = columnDef.Description; - } - } - } + this.AddValidationRows(); } - // Set the base directory. var baseDirectory = this.IntermediateFolder; if (this.UseSubDirectory) { - string filename = Path.GetFileNameWithoutExtension(this.OutputPath); + var filename = Path.GetFileNameWithoutExtension(this.OutputPath); baseDirectory = Path.Combine(baseDirectory, filename); - - // make sure the directory exists - Directory.CreateDirectory(baseDirectory); } - var idtDirectory = Path.Combine(baseDirectory, "_idts"); - Directory.CreateDirectory(idtDirectory); + var idtFolder = Path.Combine(baseDirectory, "_idts"); - try + var type = OpenDatabase.CreateDirect; + + if (OutputType.Patch == this.Data.Type) { - OpenDatabase type = OpenDatabase.CreateDirect; + type |= OpenDatabase.OpenPatchFile; + } - // set special flag for patch files - if (OutputType.Patch == this.Output.Type) - { - type |= OpenDatabase.OpenPatchFile; - } + // Localize the codepage if a value was specified directly. + if (-1 != this.Codepage) + { + this.Data.Codepage = this.Codepage; + } + try + { #if DEBUG Console.WriteLine("Opening database at: {0}", this.OutputPath); #endif - // Localize the codepage if a value was specified directly. - if (-1 != this.Codepage) - { - this.Output.Codepage = this.Codepage; - } - Directory.CreateDirectory(Path.GetDirectoryName(this.OutputPath)); - using (Database db = new Database(this.OutputPath, type)) + Directory.CreateDirectory(idtFolder); + + using (var db = new Database(this.OutputPath, type)) { - // if we're not using the default codepage, import a new one into our + // If we're not using the default codepage, import a new one into our // database before we add any tables (or the tables would be added // with the wrong codepage). - if (0 != this.Output.Codepage) + if (0 != this.Data.Codepage) { - this.SetDatabaseCodepage(db, this.Output.Codepage, idtDirectory); + this.SetDatabaseCodepage(db, this.Data.Codepage, idtFolder); } - foreach (Table table in this.Output.Tables) + this.ImportTables(db, idtFolder); + + // Insert substorages (usually transforms inside a patch or instance transforms in a package). + this.ImportSubStorages(db); + + // We're good, commit the changes to the new database. + db.Commit(); + } + } + catch (IOException e) + { + // TODO: this error message doesn't seem specific enough + throw new WixException(ErrorMessages.FileNotFound(new SourceLineNumber(this.OutputPath), this.OutputPath), e); + } + } + + private void AddValidationRows() + { + var validationTable = this.Data.EnsureTable(this.TableDefinitions["_Validation"]); + + foreach (var table in this.Data.Tables) + { + if (!table.Definition.Unreal) + { + // Add the validation rows for this table. + foreach (var columnDef in table.Definition.Columns) { - Table importTable = table; - bool hasBinaryColumn = false; + var row = validationTable.CreateRow(null); + + row[0] = table.Name; - // Skip all unreal tables other than _Streams. - if (table.Definition.Unreal && "_Streams" != table.Name) + row[1] = columnDef.Name; + + if (columnDef.Nullable) { - continue; + row[2] = "Y"; + } + else + { + row[2] = "N"; } - // Do not put the _Validation table in patches, it is not needed. - if (OutputType.Patch == this.Output.Type && "_Validation" == table.Name) + if (columnDef.MinValue.HasValue) { - continue; + row[3] = columnDef.MinValue.Value; } - // The only way to import binary data is to copy it to a local subdirectory first. - // To avoid this extra copying and perf hit, import an empty table with the same - // definition and later import the binary data from source using records. - foreach (ColumnDefinition columnDefinition in table.Definition.Columns) + if (columnDef.MaxValue.HasValue) { - if (ColumnType.Object == columnDefinition.Type) - { - importTable = new Table(table.Definition); - hasBinaryColumn = true; - break; - } + row[4] = columnDef.MaxValue.Value; } - // Create the table via IDT import. - if ("_Streams" != importTable.Name) + row[5] = columnDef.KeyTable; + + if (columnDef.KeyColumn.HasValue) { - try - { - var command = new CreateIdtFileCommand(this.Messaging, importTable, this.Output.Codepage, idtDirectory, this.KeepAddedColumns); - command.Execute(); + row[6] = columnDef.KeyColumn.Value; + } - var buildOutput = this.BackendHelper.TrackFile(command.IdtPath, TrackedFileType.Temporary); - this.GeneratedTemporaryFiles.Add(buildOutput); + if (ColumnCategory.Unknown != columnDef.Category) + { + row[7] = columnDef.Category.ToString(); + } - db.Import(command.IdtPath); - } - catch (WixInvalidIdtException) - { - // If ValidateRows finds anything it doesn't like, it throws - importTable.ValidateRows(); + row[8] = columnDef.Possibilities; - // Otherwise we rethrow the InvalidIdt - throw; - } + row[9] = columnDef.Description; + } + } + } + } + + private void ImportTables(Database db, string idtDirectory) + { + foreach (var table in this.Data.Tables) + { + var importTable = table; + var hasBinaryColumn = false; + + // Skip all unreal tables other than _Streams. + if (table.Definition.Unreal && "_Streams" != table.Name) + { + continue; + } + + // Do not put the _Validation table in patches, it is not needed. + if (OutputType.Patch == this.Data.Type && "_Validation" == table.Name) + { + continue; + } + + // The only way to import binary data is to copy it to a local subdirectory first. + // To avoid this extra copying and perf hit, import an empty table with the same + // definition and later import the binary data from source using records. + foreach (var columnDefinition in table.Definition.Columns) + { + if (ColumnType.Object == columnDefinition.Type) + { + importTable = new Table(table.Definition); + hasBinaryColumn = true; + break; + } + } + + // Create the table via IDT import. + if ("_Streams" != importTable.Name) + { + try + { + var command = new CreateIdtFileCommand(this.Messaging, importTable, this.Data.Codepage, idtDirectory, this.KeepAddedColumns); + command.Execute(); + + var buildOutput = this.BackendHelper.TrackFile(command.IdtPath, TrackedFileType.Temporary); + this.GeneratedTemporaryFiles.Add(buildOutput); + + db.Import(command.IdtPath); + } + catch (WixInvalidIdtException) + { + // If ValidateRows finds anything it doesn't like, it throws + importTable.ValidateRows(); + + // Otherwise we rethrow the InvalidIdt + throw; + } + } + + // insert the rows via SQL query if this table contains object fields + if (hasBinaryColumn) + { + var query = new StringBuilder("SELECT "); + + // Build the query for the view. + var firstColumn = true; + foreach (var columnDefinition in table.Definition.Columns) + { + if (columnDefinition.Unreal) + { + continue; } - // insert the rows via SQL query if this table contains object fields - if (hasBinaryColumn) + if (!firstColumn) { - StringBuilder query = new StringBuilder("SELECT "); + query.Append(","); + } - // Build the query for the view. - bool firstColumn = true; - foreach (ColumnDefinition columnDefinition in table.Definition.Columns) + query.AppendFormat(" `{0}`", columnDefinition.Name); + firstColumn = false; + } + query.AppendFormat(" FROM `{0}`", table.Name); + + using (var tableView = db.OpenExecuteView(query.ToString())) + { + // Import each row containing a stream + foreach (var row in table.Rows) + { + using (var record = new Record(table.Definition.Columns.Length)) { - if (!firstColumn) + // Stream names are created by concatenating the name of the table with the values + // of the primary key (delimited by periods). + var streamName = new StringBuilder(); + + // the _Streams table doesn't prepend the table name (or a period) + if ("_Streams" != table.Name) { - query.Append(","); + streamName.Append(table.Name); } - query.AppendFormat(" `{0}`", columnDefinition.Name); - firstColumn = false; - } - query.AppendFormat(" FROM `{0}`", table.Name); + var needStream = false; - using (View tableView = db.OpenExecuteView(query.ToString())) - { - // Import each row containing a stream - foreach (Row row in table.Rows) + for (var i = 0; i < table.Definition.Columns.Length; i++) { - using (Record record = new Record(table.Definition.Columns.Length)) + var columnDefinition = table.Definition.Columns[i]; + + if (columnDefinition.Unreal) { - StringBuilder streamName = new StringBuilder(); - bool needStream = false; + continue; + } + + switch (columnDefinition.Type) + { + case ColumnType.Localized: + case ColumnType.Preserved: + case ColumnType.String: + var str = row.FieldAsString(i); - // the _Streams table doesn't prepend the table name (or a period) - if ("_Streams" != table.Name) - { - streamName.Append(table.Name); - } + if (columnDefinition.PrimaryKey) + { + if (0 < streamName.Length) + { + streamName.Append("."); + } + + streamName.Append(str); + } - for (int i = 0; i < table.Definition.Columns.Length; i++) - { - ColumnDefinition columnDefinition = table.Definition.Columns[i]; + record.SetString(i + 1, str); + break; + case ColumnType.Number: + record.SetInteger(i + 1, row.FieldAsInteger(i)); + break; - switch (columnDefinition.Type) + case ColumnType.Object: + if (null != row[i]) { - case ColumnType.Localized: - case ColumnType.Preserved: - case ColumnType.String: - if (columnDefinition.PrimaryKey) + needStream = true; + try + { + record.SetStream(i + 1, row.FieldAsString(i)); + } + catch (Win32Exception e) + { + if (0xA1 == e.NativeErrorCode) // ERROR_BAD_PATHNAME { - if (0 < streamName.Length) - { - streamName.Append("."); - } - streamName.Append((string)row[i]); + throw new WixException(ErrorMessages.FileNotFound(row.SourceLineNumbers, row.FieldAsString(i))); } - - record.SetString(i + 1, (string)row[i]); - break; - case ColumnType.Number: - record.SetInteger(i + 1, Convert.ToInt32(row[i], CultureInfo.InvariantCulture)); - break; - case ColumnType.Object: - if (null != row[i]) + else { - needStream = true; - try - { - record.SetStream(i + 1, (string)row[i]); - } - catch (Win32Exception e) - { - if (0xA1 == e.NativeErrorCode) // ERROR_BAD_PATHNAME - { - throw new WixException(ErrorMessages.FileNotFound(row.SourceLineNumbers, (string)row[i])); - } - else - { - throw new WixException(ErrorMessages.Win32Exception(e.NativeErrorCode, e.Message)); - } - } + throw new WixException(ErrorMessages.Win32Exception(e.NativeErrorCode, e.Message)); } - break; + } } - } - - // stream names are created by concatenating the name of the table with the values - // of the primary key (delimited by periods) - // check for a stream name that is more than 62 characters long (the maximum allowed length) - if (needStream && MsiInterop.MsiMaxStreamNameLength < streamName.Length) - { - this.Messaging.Write(ErrorMessages.StreamNameTooLong(row.SourceLineNumbers, table.Name, streamName.ToString(), streamName.Length)); - } - else // add the row to the database - { - tableView.Modify(ModifyView.Assign, record); - } + break; } } - } - - // Remove rows from the _Streams table for wixpdbs. - if ("_Streams" == table.Name) - { - table.Rows.Clear(); - } - } - } - // Insert substorages (usually transforms inside a patch or instance transforms in a package). - if (0 < this.Output.SubStorages.Count) - { - using (View storagesView = new View(db, "SELECT `Name`, `Data` FROM `_Storages`")) - { - foreach (SubStorage subStorage in this.Output.SubStorages) - { - string transformFile = Path.Combine(this.IntermediateFolder, String.Concat(subStorage.Name, ".mst")); - - // Bind the transform. - this.BindTransform(subStorage.Data, transformFile); - - if (this.Messaging.EncounteredError) + // check for a stream name that is more than 62 characters long (the maximum allowed length) + if (needStream && MsiInterop.MsiMaxStreamNameLength < streamName.Length) { - continue; + this.Messaging.Write(ErrorMessages.StreamNameTooLong(row.SourceLineNumbers, table.Name, streamName.ToString(), streamName.Length)); } - - // add the storage - using (Record record = new Record(2)) + else // add the row to the database { - record.SetString(1, subStorage.Name); - record.SetStream(2, transformFile); - storagesView.Modify(ModifyView.Assign, record); + tableView.Modify(ModifyView.Assign, record); } } } } - // We're good, commit the changes to the new database. - db.Commit(); + // Remove rows from the _Streams table for wixpdbs. + if ("_Streams" == table.Name) + { + table.Rows.Clear(); + } } } - catch (IOException e) - { - // TODO: this error message doesn't seem specific enough - throw new WixException(ErrorMessages.FileNotFound(new SourceLineNumber(this.OutputPath), this.OutputPath), e); - } } - private void BindTransform(WindowsInstallerData transform, string outputPath) + private void ImportSubStorages(Database db) { - var command = new BindTransformCommand(); - command.Messaging = this.Messaging; - command.Extensions = this.Extensions; - command.TempFilesLocation = this.IntermediateFolder; - command.Transform = transform; - command.OutputPath = outputPath; - command.TableDefinitions = this.TableDefinitions; - command.Execute(); + if (0 < this.Data.SubStorages.Count) + { + using (var storagesView = new View(db, "SELECT `Name`, `Data` FROM `_Storages`")) + { + foreach (var subStorage in this.Data.SubStorages) + { + var transformFile = Path.Combine(this.IntermediateFolder, String.Concat(subStorage.Name, ".mst")); + + // Bind the transform. + var command = new BindTransformCommand(this.Messaging, this.BackendHelper, this.Extensions, this.IntermediateFolder, subStorage.Data, transformFile, this.TableDefinitions); + command.Execute(); + + if (this.Messaging.EncounteredError) + { + continue; + } + + // Add the storage to the database. + using (var record = new Record(2)) + { + record.SetString(1, subStorage.Name); + record.SetStream(2, transformFile); + storagesView.Modify(ModifyView.Assign, record); + } + } + } + } } - private void SetDatabaseCodepage(Database db, int codepage, string idtDirectory) + private void SetDatabaseCodepage(Database db, int codepage, string idtFolder) { - // write out the _ForceCodepage IDT file - var idtPath = Path.Combine(idtDirectory, "_ForceCodepage.idt"); + // Write out the _ForceCodepage IDT file. + var idtPath = Path.Combine(idtFolder, "_ForceCodepage.idt"); using (var idtFile = new StreamWriter(idtPath, false, Encoding.ASCII)) { idtFile.WriteLine(); // dummy column name record @@ -377,14 +406,14 @@ namespace WixToolset.Core.WindowsInstaller.Bind var trackId = this.BackendHelper.TrackFile(idtPath, TrackedFileType.Temporary); this.GeneratedTemporaryFiles.Add(trackId); - // try to import the table into the MSI + // Try to import the table into the MSI. try { db.Import(idtPath); } catch (WixInvalidIdtException) { - // the IDT should be valid, so an invalid code page was given + // The IDT should be valid, so an invalid code page was given. throw new WixException(ErrorMessages.IllegalCodepage(codepage)); } } diff --git a/src/WixToolset.Core.WindowsInstaller/Bind/GenerateTransformCommand.cs b/src/WixToolset.Core.WindowsInstaller/Bind/GenerateTransformCommand.cs new file mode 100644 index 00000000..8a7dd702 --- /dev/null +++ b/src/WixToolset.Core.WindowsInstaller/Bind/GenerateTransformCommand.cs @@ -0,0 +1,588 @@ +// 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.Core.WindowsInstaller +{ + using System; + using System.Collections.Generic; + using System.Globalization; + using WixToolset.Core.WindowsInstaller.Msi; + using WixToolset.Data; + using WixToolset.Data.Tuples; + using WixToolset.Data.WindowsInstaller; + using WixToolset.Data.WindowsInstaller.Rows; + using WixToolset.Extensibility; + using WixToolset.Extensibility.Services; + + /// + /// Creates a transform by diffing two outputs. + /// + public sealed class GenerateTransformCommand + { + private const char sectionDelimiter = '/'; + private readonly IMessaging messaging; + private SummaryInformationStreams transformSummaryInfo; + + /// + /// Instantiates a new Differ class. + /// + public GenerateTransformCommand(IMessaging messaging, WindowsInstallerData targetOutput, WindowsInstallerData updatedOutput, bool showPedanticMessages) + { + this.messaging = messaging; + this.TargetOutput = targetOutput; + this.UpdatedOutput = updatedOutput; + this.ShowPedanticMessages = showPedanticMessages; + } + + private WindowsInstallerData TargetOutput { get; } + + private WindowsInstallerData UpdatedOutput { get; } + + private TransformFlags ValidationFlags { get; } + + /// + /// Gets or sets the option to show pedantic messages. + /// + /// The option to show pedantic messages. + private bool ShowPedanticMessages { get; } + + /// + /// Gets or sets the option to suppress keeping special rows. + /// + /// The option to suppress keeping special rows. + private bool SuppressKeepingSpecialRows { get; } + + /// + /// Gets or sets the flag to determine if all rows, even unchanged ones will be persisted in the output. + /// + /// The option to keep all rows including unchanged rows. + private bool PreserveUnchangedRows { get; } + + public WindowsInstallerData Transform { get; private set; } + + /// + /// Creates a transform by diffing two outputs. + /// + /// The target output. + /// The updated output. + /// + /// The transform. + public WindowsInstallerData Execute() + { + var targetOutput = this.TargetOutput; + var updatedOutput = this.UpdatedOutput; + var validationFlags = this.ValidationFlags; + + var transform = new WindowsInstallerData(null) + { + Type = OutputType.Transform, + Codepage = updatedOutput.Codepage + }; + + this.transformSummaryInfo = new SummaryInformationStreams(); + + // compare the codepages + if (targetOutput.Codepage != updatedOutput.Codepage && 0 == (TransformFlags.ErrorChangeCodePage & validationFlags)) + { + this.messaging.Write(ErrorMessages.OutputCodepageMismatch(targetOutput.SourceLineNumbers, targetOutput.Codepage, updatedOutput.Codepage)); + if (null != updatedOutput.SourceLineNumbers) + { + this.messaging.Write(ErrorMessages.OutputCodepageMismatch2(updatedOutput.SourceLineNumbers)); + } + } + + // compare the output types + if (targetOutput.Type != updatedOutput.Type) + { + throw new WixException(ErrorMessages.OutputTypeMismatch(targetOutput.SourceLineNumbers, targetOutput.Type.ToString(), updatedOutput.Type.ToString())); + } + + // compare the contents of the tables + foreach (var targetTable in targetOutput.Tables) + { + var updatedTable = updatedOutput.Tables[targetTable.Name]; + var operation = TableOperation.None; + + var rows = this.CompareTables(targetOutput, targetTable, updatedTable, out operation); + + if (TableOperation.Drop == operation) + { + var droppedTable = transform.EnsureTable(targetTable.Definition); + droppedTable.Operation = TableOperation.Drop; + } + else if (TableOperation.None == operation) + { + var modified = transform.EnsureTable(updatedTable.Definition); + foreach (var row in rows) + { + modified.Rows.Add(row); + } + } + } + + // added tables + foreach (var updatedTable in updatedOutput.Tables) + { + if (null == targetOutput.Tables[updatedTable.Name]) + { + var addedTable = transform.EnsureTable(updatedTable.Definition); + addedTable.Operation = TableOperation.Add; + + foreach (var updatedRow in updatedTable.Rows) + { + updatedRow.Operation = RowOperation.Add; + updatedRow.SectionId = sectionDelimiter + updatedRow.SectionId; + addedTable.Rows.Add(updatedRow); + } + } + } + + // set summary information properties + if (!this.SuppressKeepingSpecialRows) + { + var summaryInfoTable = transform.Tables["_SummaryInformation"]; + this.UpdateTransformSummaryInformationTable(summaryInfoTable, validationFlags); + } + + this.Transform = transform; + return this.Transform; + } + + /// + /// Add a row to the using the primary key. + /// + /// The indexed rows. + /// The row to index. + private void AddIndexedRow(Dictionary index, Row row) + { + var primaryKey = row.GetPrimaryKey(); + + if (null != primaryKey) + { + if (index.TryGetValue(primaryKey, out var collisionRow)) + { + // Overriding WixActionRows have a primary key defined and take precedence in the index. + if (row is WixActionRow actionRow) + { + // If the current row is not overridable, see if the indexed row is. + if (!actionRow.Overridable) + { + if (collisionRow is WixActionRow indexedRow && indexedRow.Overridable) + { + // The indexed key is overridable and should be replaced. + index[primaryKey] = actionRow; + } + } + + // If we got this far, the row does not need to be indexed. + return; + } + + if (this.ShowPedanticMessages) + { + this.messaging.Write(ErrorMessages.DuplicatePrimaryKey(row.SourceLineNumbers, primaryKey, row.Table.Name)); + } + } + else + { + index.Add(primaryKey, row); + } + } + else // use the string representation of the row as its primary key (it may not be unique) + { + // this is provided for compatibility with unreal tables with no primary key + // all real tables must specify at least one column as the primary key + primaryKey = row.ToString(); + index[primaryKey] = row; + } + } + + private bool CompareRows(Table targetTable, Row targetRow, Row updatedRow, out Row comparedRow) + { + comparedRow = null; + + var keepRow = false; + + if (null == targetRow ^ null == updatedRow) + { + if (null == targetRow) + { + updatedRow.Operation = RowOperation.Add; + comparedRow = updatedRow; + } + else if (null == updatedRow) + { + targetRow.Operation = RowOperation.Delete; + targetRow.SectionId += sectionDelimiter; + + comparedRow = targetRow; + keepRow = true; + } + } + else // possibly modified + { + updatedRow.Operation = RowOperation.None; + if (!this.SuppressKeepingSpecialRows && "_SummaryInformation" == targetTable.Name) + { + // ignore rows that shouldn't be in a transform + if (Enum.IsDefined(typeof(SummaryInformation.Transform), (int)updatedRow[0])) + { + updatedRow.SectionId = targetRow.SectionId + sectionDelimiter + updatedRow.SectionId; + comparedRow = updatedRow; + keepRow = true; + } + } + else + { + if (this.PreserveUnchangedRows) + { + keepRow = true; + } + + for (var i = 0; i < updatedRow.Fields.Length; i++) + { + var columnDefinition = updatedRow.Fields[i].Column; + + if (columnDefinition.Unreal) + { + } + else if (!columnDefinition.PrimaryKey) + { + var modified = false; + + if (i >= targetRow.Fields.Length) + { + columnDefinition.Added = true; + modified = true; + } + else if (ColumnType.Number == columnDefinition.Type && !columnDefinition.IsLocalizable) + { + if (null == targetRow[i] ^ null == updatedRow[i]) + { + modified = true; + } + else if (null != targetRow[i] && null != updatedRow[i]) + { + modified = (targetRow.FieldAsInteger(i) != updatedRow.FieldAsInteger(i)); + } + } + else if (ColumnType.Preserved == columnDefinition.Type) + { + updatedRow.Fields[i].PreviousData = targetRow.FieldAsString(i); + + // keep rows containing preserved fields so the historical data is available to the binder + keepRow = !this.SuppressKeepingSpecialRows; + } + else if (ColumnType.Object == columnDefinition.Type) + { + var targetObjectField = (ObjectField)targetRow.Fields[i]; + var updatedObjectField = (ObjectField)updatedRow.Fields[i]; + + updatedObjectField.PreviousEmbeddedFileIndex = targetObjectField.EmbeddedFileIndex; + updatedObjectField.PreviousBaseUri = targetObjectField.BaseUri; + + // always keep a copy of the previous data even if they are identical + // This makes diff.wixmst clean and easier to control patch logic + updatedObjectField.PreviousData = (string)targetObjectField.Data; + + // always remember the unresolved data for target build + updatedObjectField.UnresolvedPreviousData = targetObjectField.UnresolvedData; + + // keep rows containing object fields so the files can be compared in the binder + keepRow = !this.SuppressKeepingSpecialRows; + } + else + { + modified = (targetRow.FieldAsString(i) != updatedRow.FieldAsString(i)); + } + + if (modified) + { + if (null != updatedRow.Fields[i].PreviousData) + { + updatedRow.Fields[i].PreviousData = targetRow.FieldAsString(i); + } + + updatedRow.Fields[i].Modified = true; + updatedRow.Operation = RowOperation.Modify; + keepRow = true; + } + } + } + + if (keepRow) + { + comparedRow = updatedRow; + comparedRow.SectionId = targetRow.SectionId + sectionDelimiter + updatedRow.SectionId; + } + } + } + + return keepRow; + } + + private List CompareTables(WindowsInstallerData targetOutput, Table targetTable, Table updatedTable, out TableOperation operation) + { + var rows = new List(); + operation = TableOperation.None; + + // dropped tables + if (null == updatedTable ^ null == targetTable) + { + if (null == targetTable) + { + operation = TableOperation.Add; + rows.AddRange(updatedTable.Rows); + } + else if (null == updatedTable) + { + operation = TableOperation.Drop; + } + } + else // possibly modified tables + { + var updatedPrimaryKeys = new Dictionary(); + var targetPrimaryKeys = new Dictionary(); + + // compare the table definitions + if (0 != targetTable.Definition.CompareTo(updatedTable.Definition)) + { + // continue to the next table; may be more mismatches + this.messaging.Write(ErrorMessages.DatabaseSchemaMismatch(targetOutput.SourceLineNumbers, targetTable.Name)); + } + else + { + this.IndexPrimaryKeys(targetTable, targetPrimaryKeys, updatedTable, updatedPrimaryKeys); + + // diff the target and updated rows + foreach (var targetPrimaryKeyEntry in targetPrimaryKeys) + { + var targetPrimaryKey = targetPrimaryKeyEntry.Key; + var targetRow = targetPrimaryKeyEntry.Value; + updatedPrimaryKeys.TryGetValue(targetPrimaryKey, out var updatedRow); + + var keepRow = this.CompareRows(targetTable, targetRow, updatedRow, out var compared); + + if (keepRow) + { + rows.Add(compared); + } + } + + // find the inserted rows + foreach (var updatedPrimaryKeyEntry in updatedPrimaryKeys) + { + var updatedPrimaryKey = updatedPrimaryKeyEntry.Key; + + if (!targetPrimaryKeys.ContainsKey(updatedPrimaryKey)) + { + var updatedRow = updatedPrimaryKeyEntry.Value; + + updatedRow.Operation = RowOperation.Add; + updatedRow.SectionId = sectionDelimiter + updatedRow.SectionId; + rows.Add(updatedRow); + } + } + } + } + + return rows; + } + + private void IndexPrimaryKeys(Table targetTable, Dictionary targetPrimaryKeys, Table updatedTable, Dictionary updatedPrimaryKeys) + { + // index the target rows + foreach (var row in targetTable.Rows) + { + this.AddIndexedRow(targetPrimaryKeys, row); + + if ("Property" == targetTable.Name) + { + var id = row.FieldAsString(0); + + if ("ProductCode" == id) + { + this.transformSummaryInfo.TargetProductCode = row.FieldAsString(1); + + if ("*" == this.transformSummaryInfo.TargetProductCode) + { + this.messaging.Write(ErrorMessages.ProductCodeInvalidForTransform(row.SourceLineNumbers)); + } + } + else if ("ProductVersion" == id) + { + this.transformSummaryInfo.TargetProductVersion = row.FieldAsString(1); + } + else if ("UpgradeCode" == id) + { + this.transformSummaryInfo.TargetUpgradeCode = row.FieldAsString(1); + } + } + else if ("_SummaryInformation" == targetTable.Name) + { + var id = row.FieldAsInteger(0); + + if (1 == id) // PID_CODEPAGE + { + this.transformSummaryInfo.TargetSummaryInfoCodepage = row.FieldAsString(1); + } + else if (7 == id) // PID_TEMPLATE + { + this.transformSummaryInfo.TargetPlatformAndLanguage = row.FieldAsString(1); + } + else if (14 == id) // PID_PAGECOUNT + { + this.transformSummaryInfo.TargetMinimumVersion = row.FieldAsString(1); + } + } + } + + // index the updated rows + foreach (var row in updatedTable.Rows) + { + this.AddIndexedRow(updatedPrimaryKeys, row); + + if ("Property" == updatedTable.Name) + { + var id = row.FieldAsString(0); + + if ("ProductCode" == id) + { + this.transformSummaryInfo.UpdatedProductCode = row.FieldAsString(1); + + if ("*" == this.transformSummaryInfo.UpdatedProductCode) + { + this.messaging.Write(ErrorMessages.ProductCodeInvalidForTransform(row.SourceLineNumbers)); + } + } + else if ("ProductVersion" == id) + { + this.transformSummaryInfo.UpdatedProductVersion = row.FieldAsString(1); + } + } + else if ("_SummaryInformation" == updatedTable.Name) + { + var id = row.FieldAsInteger(0); + + if (1 == id) // PID_CODEPAGE + { + this.transformSummaryInfo.UpdatedSummaryInfoCodepage = row.FieldAsString(1); + } + else if (7 == id) // PID_TEMPLATE + { + this.transformSummaryInfo.UpdatedPlatformAndLanguage = row.FieldAsString(1); + } + else if (14 == id) // PID_PAGECOUNT + { + this.transformSummaryInfo.UpdatedMinimumVersion = row.FieldAsString(1); + } + } + } + } + + private void UpdateTransformSummaryInformationTable(Table summaryInfoTable, TransformFlags validationFlags) + { + // calculate the minimum version of MSI required to process the transform + var minimumVersion = 100; + + if (Int32.TryParse(this.transformSummaryInfo.TargetMinimumVersion, out var targetMin) && Int32.TryParse(this.transformSummaryInfo.UpdatedMinimumVersion, out var updatedMin)) + { + minimumVersion = Math.Max(targetMin, updatedMin); + } + + var summaryRows = new Dictionary(summaryInfoTable.Rows.Count); + + foreach (var row in summaryInfoTable.Rows) + { + var id = row.FieldAsInteger(0); + + summaryRows[id] = row; + + if ((int)SummaryInformation.Transform.CodePage == id) + { + row.Fields[1].Data = this.transformSummaryInfo.UpdatedSummaryInfoCodepage; + row.Fields[1].PreviousData = this.transformSummaryInfo.TargetSummaryInfoCodepage; + } + else if ((int)SummaryInformation.Transform.TargetPlatformAndLanguage == id) + { + row[1] = this.transformSummaryInfo.TargetPlatformAndLanguage; + } + else if ((int)SummaryInformation.Transform.UpdatedPlatformAndLanguage == id) + { + row[1] = this.transformSummaryInfo.UpdatedPlatformAndLanguage; + } + else if ((int)SummaryInformation.Transform.ProductCodes == id) + { + row[1] = String.Concat(this.transformSummaryInfo.TargetProductCode, this.transformSummaryInfo.TargetProductVersion, ';', this.transformSummaryInfo.UpdatedProductCode, this.transformSummaryInfo.UpdatedProductVersion, ';', this.transformSummaryInfo.TargetUpgradeCode); + } + else if ((int)SummaryInformation.Transform.InstallerRequirement == id) + { + row[1] = minimumVersion.ToString(CultureInfo.InvariantCulture); + } + else if ((int)SummaryInformation.Transform.Security == id) + { + row[1] = "4"; + } + } + + if (!summaryRows.ContainsKey((int)SummaryInformation.Transform.TargetPlatformAndLanguage)) + { + var summaryRow = summaryInfoTable.CreateRow(null); + summaryRow[0] = (int)SummaryInformation.Transform.TargetPlatformAndLanguage; + summaryRow[1] = this.transformSummaryInfo.TargetPlatformAndLanguage; + } + + if (!summaryRows.ContainsKey((int)SummaryInformation.Transform.UpdatedPlatformAndLanguage)) + { + var summaryRow = summaryInfoTable.CreateRow(null); + summaryRow[0] = (int)SummaryInformation.Transform.UpdatedPlatformAndLanguage; + summaryRow[1] = this.transformSummaryInfo.UpdatedPlatformAndLanguage; + } + + if (!summaryRows.ContainsKey((int)SummaryInformation.Transform.ValidationFlags)) + { + var summaryRow = summaryInfoTable.CreateRow(null); + summaryRow[0] = (int)SummaryInformation.Transform.ValidationFlags; + summaryRow[1] = ((int)validationFlags).ToString(CultureInfo.InvariantCulture); + } + + if (!summaryRows.ContainsKey((int)SummaryInformation.Transform.InstallerRequirement)) + { + var summaryRow = summaryInfoTable.CreateRow(null); + summaryRow[0] = (int)SummaryInformation.Transform.InstallerRequirement; + summaryRow[1] = minimumVersion.ToString(CultureInfo.InvariantCulture); + } + + if (!summaryRows.ContainsKey((int)SummaryInformation.Transform.Security)) + { + var summaryRow = summaryInfoTable.CreateRow(null); + summaryRow[0] = (int)SummaryInformation.Transform.Security; + summaryRow[1] = "4"; + } + } + + private class SummaryInformationStreams + { + public string TargetSummaryInfoCodepage { get; set; } + + public string TargetPlatformAndLanguage { get; set; } + + public string TargetProductCode { get; set; } + + public string TargetProductVersion { get; set; } + + public string TargetUpgradeCode { get; set; } + + public string TargetMinimumVersion { get; set; } + + public string UpdatedSummaryInfoCodepage { get; set; } + + public string UpdatedPlatformAndLanguage { get; set; } + + public string UpdatedProductCode { get; set; } + + public string UpdatedProductVersion { get; set; } + + public string UpdatedMinimumVersion { get; set; } + } + } +} diff --git a/src/WixToolset.Core.WindowsInstaller/Bind/GetFileFacadesCommand.cs b/src/WixToolset.Core.WindowsInstaller/Bind/GetFileFacadesCommand.cs index 0da6a6b0..2844f797 100644 --- a/src/WixToolset.Core.WindowsInstaller/Bind/GetFileFacadesCommand.cs +++ b/src/WixToolset.Core.WindowsInstaller/Bind/GetFileFacadesCommand.cs @@ -132,7 +132,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind file.SymbolPaths = String.Concat(file.SymbolPaths, ";", row.SymbolPaths); } -#if REVISIT_FOR_PATCHING +#if TODO_PATCHING Field field = row.Fields[2]; if (null != field.PreviousData) { diff --git a/src/WixToolset.Core.WindowsInstaller/Bind/GetFileFacadesFromTransforms.cs b/src/WixToolset.Core.WindowsInstaller/Bind/GetFileFacadesFromTransforms.cs new file mode 100644 index 00000000..9818f01a --- /dev/null +++ b/src/WixToolset.Core.WindowsInstaller/Bind/GetFileFacadesFromTransforms.cs @@ -0,0 +1,585 @@ +// 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.Core.WindowsInstaller.Bind +{ + using System; + using System.Collections.Generic; + using System.Diagnostics; + using System.IO; + using System.Linq; + using WixToolset.Core.Bind; + using WixToolset.Data; + using WixToolset.Data.Tuples; + using WixToolset.Data.WindowsInstaller; + using WixToolset.Data.WindowsInstaller.Rows; + using WixToolset.Extensibility; + using WixToolset.Extensibility.Services; + + internal class GetFileFacadesFromTransforms + { + public GetFileFacadesFromTransforms(IMessaging messaging, IEnumerable subStorages, TableDefinitionCollection tableDefinitions) + { + this.Messaging = messaging; + this.SubStorages = subStorages; + this.TableDefinitions = tableDefinitions; + } + + public IEnumerable Extensions { get; } + + private IMessaging Messaging { get; } + + public IEnumerable SubStorages { get; } + + private TableDefinitionCollection TableDefinitions { get; } + + public IEnumerable FileFacades { get; private set; } + + public void Execute() + { + var allFileRows = new List(); + var copyToPatch = (allFileRows != null); +#if TODO_PATCHING + var patchMediaRows = new RowDictionary(); + + var patchMediaFileRows = new Dictionary>(); + + var patchActualFileTable = this.Output.EnsureTable(this.TableDefinitions["File"]); + var patchFileTable = this.Output.EnsureTable(this.TableDefinitions["WixFile"]); + + if (copyFromPatch) + { + // index patch files by diskId+fileId + foreach (WixFileRow patchFileRow in patchFileTable.Rows) + { + int diskId = patchFileRow.DiskId; + if (!patchMediaFileRows.TryGetValue(diskId, out var mediaFileRows)) + { + mediaFileRows = new RowDictionary(); + patchMediaFileRows.Add(diskId, mediaFileRows); + } + + mediaFileRows.Add(patchFileRow); + } + + var patchMediaTable = this.Output.EnsureTable(this.TableDefinitions["Media"]); + patchMediaRows = new RowDictionary(patchMediaTable); + } + + // Index paired transforms by name without their "#" prefix. + var pairedTransforms = this.SubStorages.Where(s => s.Name.StartsWith("#")).ToDictionary(s => s.Name.Substring(1), s => s.Data); + + foreach (var substorage in this.SubStorages) + { + if (substorage.Name.StartsWith("#")) + { + // Skip paired transforms. + continue; + } + + var mainTransform = substorage.Data; + var mainWixFiles = new RowDictionary(mainTransform.Tables["WixFile"]); + var mainMsiFileHashIndex = new RowDictionary(mainTransform.Tables["MsiFileHash"]); + + var mainFileTable = mainTransform.Tables["File"]; + var pairedTransform = pairedTransforms[substorage.Name]; + + // copy Media.LastSequence and index the MsiFileHash table if it exists. + if (copyFromPatch) + { + var pairedMediaTable = pairedTransform.Tables["Media"]; + foreach (MediaRow pairedMediaRow in pairedMediaTable.Rows) + { + var patchMediaRow = patchMediaRows.Get(pairedMediaRow.DiskId); + pairedMediaRow.Fields[1] = patchMediaRow.Fields[1]; + } + + if (null != mainMsiFileHashTable) + { + mainMsiFileHashIndex = new RowDictionary(mainMsiFileHashTable); + } + + // Validate file row changes for keypath-related issues + this.ValidateFileRowChanges(mainTransform); + } + + if (null == mainFileTable) + { + continue; + } + + // Index File table of pairedTransform + var pairedFileRows = new RowDictionary(pairedTransform.Tables["File"]); + + foreach (FileRow mainFileRow in mainFileTable.Rows) + { + if (RowOperation.Delete == mainFileRow.Operation) + { + continue; + } + else if (RowOperation.None == mainFileRow.Operation) + { + continue; + } + + var mainWixFileRow = mainWixFiles.Get(mainFileRow.File); + + if (copyToPatch) // when copying to the patch, we need compare the underlying files and include all file changes. + { + var objectField = (ObjectField)mainWixFileRow.Fields[6]; + var pairedFileRow = pairedFileRows.Get(mainFileRow.File); + + // If the file is new, we always need to add it to the patch. + if (mainFileRow.Operation != RowOperation.Add) + { + // If PreviousData doesn't exist, target and upgrade layout point to the same location. No need to compare. + if (null == objectField.PreviousData) + { + if (mainFileRow.Operation == RowOperation.None) + { + continue; + } + } + else + { + // TODO: should this entire condition be placed in the binder file manager? + if ((0 == (PatchAttributeType.Ignore & mainWixFileRow.PatchAttributes)) && + !this.CompareFiles(objectField.PreviousData.ToString(), objectField.Data.ToString())) + { + // If the file is different, we need to mark the mainFileRow and pairedFileRow as modified. + mainFileRow.Operation = RowOperation.Modify; + if (null != pairedFileRow) + { + // Always patch-added, but never non-compressed. + pairedFileRow.Attributes |= WindowsInstallerConstants.MsidbFileAttributesPatchAdded; + pairedFileRow.Attributes &= ~WindowsInstallerConstants.MsidbFileAttributesNoncompressed; + pairedFileRow.Fields[6].Modified = true; + pairedFileRow.Operation = RowOperation.Modify; + } + } + else + { + // The File is same. We need mark all the attributes as unchanged. + mainFileRow.Operation = RowOperation.None; + foreach (var field in mainFileRow.Fields) + { + field.Modified = false; + } + + if (null != pairedFileRow) + { + pairedFileRow.Attributes &= ~WindowsInstallerConstants.MsidbFileAttributesPatchAdded; + pairedFileRow.Fields[6].Modified = false; + pairedFileRow.Operation = RowOperation.None; + } + continue; + } + } + } + else if (null != pairedFileRow) // RowOperation.Add + { + // Always patch-added, but never non-compressed. + pairedFileRow.Attributes |= WindowsInstallerConstants.MsidbFileAttributesPatchAdded; + pairedFileRow.Attributes &= ~WindowsInstallerConstants.MsidbFileAttributesNoncompressed; + pairedFileRow.Fields[6].Modified = true; + pairedFileRow.Operation = RowOperation.Add; + } + } + + // index patch files by diskId+fileId + int diskId = mainWixFileRow.DiskId; + + if (!patchMediaFileRows.TryGetValue(diskId, out var mediaFileRows)) + { + mediaFileRows = new RowDictionary(); + patchMediaFileRows.Add(diskId, mediaFileRows); + } + + var fileId = mainFileRow.File; + var patchFileRow = mediaFileRows.Get(fileId); + if (copyToPatch) + { + if (null == patchFileRow) + { + var patchActualFileRow = (FileRow)patchFileTable.CreateRow(mainFileRow.SourceLineNumbers); + patchActualFileRow.CopyFrom(mainFileRow); + + patchFileRow = (WixFileRow)patchFileTable.CreateRow(mainFileRow.SourceLineNumbers); + patchFileRow.CopyFrom(mainWixFileRow); + + mediaFileRows.Add(patchFileRow); + + allFileRows.Add(new FileFacade(patchActualFileRow, patchFileRow, null)); // TODO: should we be passing along delta information? Probably, right? + } + else + { + // TODO: confirm the rest of data is identical? + + // make sure Source is same. Otherwise we are silently ignoring a file. + if (0 != String.Compare(patchFileRow.Source, mainWixFileRow.Source, StringComparison.OrdinalIgnoreCase)) + { + this.Messaging.Write(ErrorMessages.SameFileIdDifferentSource(mainFileRow.SourceLineNumbers, fileId, patchFileRow.Source, mainWixFileRow.Source)); + } + + // capture the previous file versions (and associated data) from this targeted instance of the baseline into the current filerow. + patchFileRow.AppendPreviousDataFrom(mainWixFileRow); + } + } + //else + //{ + // // copy data from the patch back to the transform + // if (null != patchFileRow) + // { + // var pairedFileRow = pairedFileRows.Get(fileId); + // for (var i = 0; i < patchFileRow.Fields.Length; i++) + // { + // var patchValue = patchFileRow[i] == null ? String.Empty : patchFileRow.FieldAsString(i); + // var mainValue = mainFileRow[i] == null ? String.Empty : mainFileRow.FieldAsString(i); + + // if (1 == i) + // { + // // File.Component_ changes should not come from the shared file rows + // // that contain the file information as each individual transform might + // // have different changes (or no changes at all). + // } + // // File.Attributes should not changed for binary deltas + // else if (6 == i) + // { + // if (null != patchFileRow.Patch) + // { + // // File.Attribute should not change for binary deltas + // pairedFileRow.Attributes = mainFileRow.Attributes; + // mainFileRow.Fields[i].Modified = false; + // } + // } + // // File.Sequence is updated in pairedTransform, not mainTransform + // else if (7 == i) + // { + // // file sequence is updated in Patch table instead of File table for delta patches + // if (null != patchFileRow.Patch) + // { + // pairedFileRow.Fields[i].Modified = false; + // } + // else + // { + // pairedFileRow[i] = patchFileRow[i]; + // pairedFileRow.Fields[i].Modified = true; + // } + // mainFileRow.Fields[i].Modified = false; + // } + // else if (patchValue != mainValue) + // { + // mainFileRow[i] = patchFileRow[i]; + // mainFileRow.Fields[i].Modified = true; + // if (mainFileRow.Operation == RowOperation.None) + // { + // mainFileRow.Operation = RowOperation.Modify; + // } + // } + // } + + // // copy MsiFileHash row for this File + // if (!mainMsiFileHashIndex.TryGetValue(patchFileRow.File, out var patchHashRow)) + // { + // patchHashRow = patchFileRow.Hash; + // } + + // if (null != patchHashRow) + // { + // var mainHashTable = mainTransform.EnsureTable(this.TableDefinitions["MsiFileHash"]); + // var mainHashRow = mainHashTable.CreateRow(mainFileRow.SourceLineNumbers); + // for (var i = 0; i < patchHashRow.Fields.Length; i++) + // { + // mainHashRow[i] = patchHashRow[i]; + // if (i > 1) + // { + // // assume all hash fields have been modified + // mainHashRow.Fields[i].Modified = true; + // } + // } + + // // assume the MsiFileHash operation follows the File one + // mainHashRow.Operation = mainFileRow.Operation; + // } + + // // copy MsiAssemblyName rows for this File + // List patchAssemblyNameRows = patchFileRow.AssemblyNames; + // if (null != patchAssemblyNameRows) + // { + // var mainAssemblyNameTable = mainTransform.EnsureTable(this.TableDefinitions["MsiAssemblyName"]); + // foreach (var patchAssemblyNameRow in patchAssemblyNameRows) + // { + // // Copy if there isn't an identical modified/added row already in the transform. + // var foundMatchingModifiedRow = false; + // foreach (var mainAssemblyNameRow in mainAssemblyNameTable.Rows) + // { + // if (RowOperation.None != mainAssemblyNameRow.Operation && mainAssemblyNameRow.GetPrimaryKey('/').Equals(patchAssemblyNameRow.GetPrimaryKey('/'))) + // { + // foundMatchingModifiedRow = true; + // break; + // } + // } + + // if (!foundMatchingModifiedRow) + // { + // var mainAssemblyNameRow = mainAssemblyNameTable.CreateRow(mainFileRow.SourceLineNumbers); + // for (var i = 0; i < patchAssemblyNameRow.Fields.Length; i++) + // { + // mainAssemblyNameRow[i] = patchAssemblyNameRow[i]; + // } + + // // assume value field has been modified + // mainAssemblyNameRow.Fields[2].Modified = true; + // mainAssemblyNameRow.Operation = mainFileRow.Operation; + // } + // } + // } + + // // Add patch header for this file + // if (null != patchFileRow.Patch) + // { + // // Add the PatchFiles action automatically to the AdminExecuteSequence and InstallExecuteSequence tables. + // this.AddPatchFilesActionToSequenceTable(SequenceTable.AdminExecuteSequence, mainTransform, pairedTransform, mainFileRow); + // this.AddPatchFilesActionToSequenceTable(SequenceTable.InstallExecuteSequence, mainTransform, pairedTransform, mainFileRow); + + // // Add to Patch table + // var patchTable = pairedTransform.EnsureTable(this.TableDefinitions["Patch"]); + // if (0 == patchTable.Rows.Count) + // { + // patchTable.Operation = TableOperation.Add; + // } + + // var patchRow = patchTable.CreateRow(mainFileRow.SourceLineNumbers); + // patchRow[0] = patchFileRow.File; + // patchRow[1] = patchFileRow.Sequence; + + // var patchFile = new FileInfo(patchFileRow.Source); + // patchRow[2] = (int)patchFile.Length; + // patchRow[3] = 0 == (PatchAttributeType.AllowIgnoreOnError & patchFileRow.PatchAttributes) ? 0 : 1; + + // var streamName = patchTable.Name + "." + patchRow[0] + "." + patchRow[1]; + // if (Msi.MsiInterop.MsiMaxStreamNameLength < streamName.Length) + // { + // streamName = "_" + Guid.NewGuid().ToString("D").ToUpperInvariant().Replace('-', '_'); + + // var patchHeadersTable = pairedTransform.EnsureTable(this.TableDefinitions["MsiPatchHeaders"]); + // if (0 == patchHeadersTable.Rows.Count) + // { + // patchHeadersTable.Operation = TableOperation.Add; + // } + + // var patchHeadersRow = patchHeadersTable.CreateRow(mainFileRow.SourceLineNumbers); + // patchHeadersRow[0] = streamName; + // patchHeadersRow[1] = patchFileRow.Patch; + // patchRow[5] = streamName; + // patchHeadersRow.Operation = RowOperation.Add; + // } + // else + // { + // patchRow[4] = patchFileRow.Patch; + // } + // patchRow.Operation = RowOperation.Add; + // } + // } + // else + // { + // // TODO: throw because all transform rows should have made it into the patch + // } + //} + } + } +#endif + this.FileFacades = allFileRows; + } + + /// + /// Adds the PatchFiles action to the sequence table if it does not already exist. + /// + /// The sequence table to check or modify. + /// The primary authoring transform. + /// The secondary patch transform. + /// The file row that contains information about the patched file. + private void AddPatchFilesActionToSequenceTable(SequenceTable table, WindowsInstallerData mainTransform, WindowsInstallerData pairedTransform, Row mainFileRow) + { + var tableName = table.ToString(); + + // Find/add PatchFiles action (also determine sequence for it). + // Search mainTransform first, then pairedTransform (pairedTransform overrides). + var hasPatchFilesAction = false; + var installFilesSequence = 0; + var duplicateFilesSequence = 0; + + TestSequenceTableForPatchFilesAction( + mainTransform.Tables[tableName], + ref hasPatchFilesAction, + ref installFilesSequence, + ref duplicateFilesSequence); + TestSequenceTableForPatchFilesAction( + pairedTransform.Tables[tableName], + ref hasPatchFilesAction, + ref installFilesSequence, + ref duplicateFilesSequence); + if (!hasPatchFilesAction) + { + WindowsInstallerStandard.TryGetStandardAction(tableName, "PatchFiles", out var patchFilesActionTuple); + + var sequence = patchFilesActionTuple.Sequence; + + // Test for default sequence value's appropriateness + if (installFilesSequence >= sequence || (0 != duplicateFilesSequence && duplicateFilesSequence <= sequence)) + { + if (0 != duplicateFilesSequence) + { + if (duplicateFilesSequence < installFilesSequence) + { + throw new WixException(ErrorMessages.InsertInvalidSequenceActionOrder(mainFileRow.SourceLineNumbers, tableName, "InstallFiles", "DuplicateFiles", patchFilesActionTuple.Action)); + } + else + { + sequence = (duplicateFilesSequence + installFilesSequence) / 2; + if (installFilesSequence == sequence || duplicateFilesSequence == sequence) + { + throw new WixException(ErrorMessages.InsertSequenceNoSpace(mainFileRow.SourceLineNumbers, tableName, "InstallFiles", "DuplicateFiles", patchFilesActionTuple.Action)); + } + } + } + else + { + sequence = installFilesSequence + 1; + } + } + + var sequenceTable = pairedTransform.EnsureTable(this.TableDefinitions[tableName]); + if (0 == sequenceTable.Rows.Count) + { + sequenceTable.Operation = TableOperation.Add; + } + + var patchAction = sequenceTable.CreateRow(null); + patchAction[0] = patchFilesActionTuple.Action; + patchAction[1] = patchFilesActionTuple.Condition; + patchAction[2] = sequence; + patchAction.Operation = RowOperation.Add; + } + } + + /// + /// Tests sequence table for PatchFiles and associated actions + /// + /// The table to test. + /// Set to true if PatchFiles action is found. Left unchanged otherwise. + /// Set to sequence value of InstallFiles action if found. Left unchanged otherwise. + /// Set to sequence value of DuplicateFiles action if found. Left unchanged otherwise. + private static void TestSequenceTableForPatchFilesAction(Table sequenceTable, ref bool hasPatchFilesAction, ref int installFilesSequence, ref int duplicateFilesSequence) + { + if (null != sequenceTable) + { + foreach (var row in sequenceTable.Rows) + { + var actionName = row.FieldAsString(0); + switch (actionName) + { + case "PatchFiles": + hasPatchFilesAction = true; + break; + + case "InstallFiles": + installFilesSequence = row.FieldAsInteger(2); + break; + + case "DuplicateFiles": + duplicateFilesSequence = row.FieldAsInteger(2); + break; + } + } + } + } + + /// + /// Signal a warning if a non-keypath file was changed in a patch without also changing the keypath file of the component. + /// + /// The output to validate. + private void ValidateFileRowChanges(WindowsInstallerData transform) + { + var componentTable = transform.Tables["Component"]; + var fileTable = transform.Tables["File"]; + + // There's no sense validating keypaths if the transform has no component or file table + if (componentTable == null || fileTable == null) + { + return; + } + + var componentKeyPath = new Dictionary(componentTable.Rows.Count); + + // Index the Component table for non-directory & non-registry key paths. + foreach (var row in componentTable.Rows) + { + var keyPath = row.FieldAsString(5); + if (keyPath != null && 0 != (row.FieldAsInteger(3) & WindowsInstallerConstants.MsidbComponentAttributesRegistryKeyPath)) + { + componentKeyPath.Add(row.FieldAsString(0), keyPath); + } + } + + var componentWithChangedKeyPath = new Dictionary(); + var componentWithNonKeyPathChanged = new Dictionary(); + // Verify changes in the file table, now that file diffing has occurred + foreach (FileRow row in fileTable.Rows) + { + if (RowOperation.Modify != row.Operation) + { + continue; + } + + var fileId = row.FieldAsString(0); + var componentId = row.FieldAsString(1); + + // If this file is the keypath of a component + if (componentKeyPath.ContainsValue(fileId)) + { + if (!componentWithChangedKeyPath.ContainsKey(componentId)) + { + componentWithChangedKeyPath.Add(componentId, fileId); + } + } + else + { + if (!componentWithNonKeyPathChanged.ContainsKey(componentId)) + { + componentWithNonKeyPathChanged.Add(componentId, fileId); + } + } + } + + foreach (var componentFile in componentWithNonKeyPathChanged) + { + // Make sure all changes to non keypath files also had a change in the keypath. + if (!componentWithChangedKeyPath.ContainsKey(componentFile.Key) && componentKeyPath.TryGetValue(componentFile.Key, out var keyPath)) + { + this.Messaging.Write(WarningMessages.UpdateOfNonKeyPathFile(componentFile.Value, componentFile.Key, keyPath)); + } + } + } + + private bool CompareFiles(string targetFile, string updatedFile) + { + bool? compared = null; + foreach (var extension in this.Extensions) + { + compared = extension.CompareFiles(targetFile, updatedFile); + + if (compared.HasValue) + { + break; + } + } + + if (!compared.HasValue) + { + throw new InvalidOperationException(); // TODO: something needs to be said here that none of the binder file managers returned a result. + } + + return compared.Value; + } + } +} diff --git a/src/WixToolset.Core.WindowsInstaller/Bind/LoadTableDefinitionsCommand.cs b/src/WixToolset.Core.WindowsInstaller/Bind/LoadTableDefinitionsCommand.cs index 92ddad6f..1aa4065e 100644 --- a/src/WixToolset.Core.WindowsInstaller/Bind/LoadTableDefinitionsCommand.cs +++ b/src/WixToolset.Core.WindowsInstaller/Bind/LoadTableDefinitionsCommand.cs @@ -9,15 +9,22 @@ namespace WixToolset.Core.WindowsInstaller.Bind using WixToolset.Data; using WixToolset.Data.Tuples; using WixToolset.Data.WindowsInstaller; + using WixToolset.Extensibility; internal class LoadTableDefinitionsCommand { - public LoadTableDefinitionsCommand(IntermediateSection section) => this.Section = section; - - public TableDefinitionCollection TableDefinitions { get; private set; } + public LoadTableDefinitionsCommand(IntermediateSection section, IEnumerable backendExtensions) + { + this.Section = section; + this.BackendExtensions = backendExtensions; + } private IntermediateSection Section { get; } + private IEnumerable BackendExtensions { get; } + + public TableDefinitionCollection TableDefinitions { get; private set; } + public TableDefinitionCollection Execute() { var tableDefinitions = new TableDefinitionCollection(WindowsInstallerStandardInternal.GetTableDefinitions()); @@ -28,6 +35,14 @@ namespace WixToolset.Core.WindowsInstaller.Bind tableDefinitions.Add(customTableDefinition); } + foreach (var backendExtension in this.BackendExtensions) + { + foreach (var tableDefinition in backendExtension.TableDefinitions) + { + tableDefinitions.Add(tableDefinition); + } + } + this.TableDefinitions = tableDefinitions; return this.TableDefinitions; } diff --git a/src/WixToolset.Core.WindowsInstaller/Bind/MergeModulesCommand.cs b/src/WixToolset.Core.WindowsInstaller/Bind/MergeModulesCommand.cs index 8c11555e..b90aecd1 100644 --- a/src/WixToolset.Core.WindowsInstaller/Bind/MergeModulesCommand.cs +++ b/src/WixToolset.Core.WindowsInstaller/Bind/MergeModulesCommand.cs @@ -277,7 +277,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind using (Record record = new Record(1)) { - record.SetString(1, file.File.Id.Id); + record.SetString(1, file.Id); view.Execute(record); } @@ -288,7 +288,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind throw new InvalidOperationException("Failed to fetch a File row from the database that was merged in from a module."); } - recordUpdate.SetInteger(1, file.File.Sequence); + recordUpdate.SetInteger(1, file.Sequence); // Update the file attributes to match the compression specified // on the Merge element or on the Package element. @@ -300,12 +300,12 @@ namespace WixToolset.Core.WindowsInstaller.Bind attributes = recordUpdate.GetInteger(2); } - if ((file.File.Attributes & FileTupleAttributes.Compressed) == FileTupleAttributes.Compressed) + if (file.Compressed) { attributes |= WindowsInstallerConstants.MsidbFileAttributesCompressed; attributes &= ~WindowsInstallerConstants.MsidbFileAttributesNoncompressed; } - else if ((file.File.Attributes & FileTupleAttributes.Uncompressed) == FileTupleAttributes.Uncompressed) + else if (file.Uncompressed) { attributes |= WindowsInstallerConstants.MsidbFileAttributesNoncompressed; attributes &= ~WindowsInstallerConstants.MsidbFileAttributesCompressed; diff --git a/src/WixToolset.Core.WindowsInstaller/Bind/PatchTransform.cs b/src/WixToolset.Core.WindowsInstaller/Bind/PatchTransform.cs new file mode 100644 index 00000000..5ada29de --- /dev/null +++ b/src/WixToolset.Core.WindowsInstaller/Bind/PatchTransform.cs @@ -0,0 +1,246 @@ +// 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.Core.WindowsInstaller.Bind +{ + using System; + using System.Collections; + using System.Globalization; + using System.Text; + using System.Text.RegularExpressions; + using WixToolset.Data; + using WixToolset.Data.WindowsInstaller; + using WixToolset.Extensibility; + + internal class PatchTransform + { + public PatchTransform(string baseline, WindowsInstallerData transform) + { + this.Baseline = baseline; + this.Transform = transform; + } + + public string Baseline { get; } + + public WindowsInstallerData Transform { get; } + + /// + /// Validates that the differences in the transform are valid for patch transforms. + /// + public void Validate() + { +#if TODO_PATCHING + // Changing the ProdocutCode in a patch transform is not recommended. + Table propertyTable = this.Transform.Tables["Property"]; + if (null != propertyTable) + { + foreach (Row row in propertyTable.Rows) + { + // Only interested in modified rows; fast check. + if (RowOperation.Modify == row.Operation) + { + if (0 == String.CompareOrdinal("ProductCode", (string)row[0])) + { + this.OnMessage(WixWarnings.MajorUpgradePatchNotRecommended()); + } + } + } + } + + // If there is nothing in the component table we can return early because the remaining checks are component based. + Table componentTable = this.Transform.Tables["Component"]; + if (null == componentTable) + { + return; + } + + // Index Feature table row operations + Table featureTable = this.Transform.Tables["Feature"]; + Table featureComponentsTable = this.Transform.Tables["FeatureComponents"]; + Hashtable featureOps = null; + if (null != featureTable) + { + int capacity = featureTable.Rows.Count; + featureOps = new Hashtable(capacity); + + foreach (Row row in featureTable.Rows) + { + featureOps[(string)row[0]] = row.Operation; + } + } + else + { + featureOps = new Hashtable(); + } + + // Index Component table and check for keypath modifications + Hashtable deletedComponent = new Hashtable(); + Hashtable componentKeyPath = new Hashtable(); + foreach (Row row in componentTable.Rows) + { + string id = row.Fields[0].Data.ToString(); + string keypath = (null == row.Fields[5].Data) ? String.Empty : row.Fields[5].Data.ToString(); + + componentKeyPath.Add(id, keypath); + if (RowOperation.Delete == row.Operation) + { + deletedComponent.Add(id, row); + } + else if (RowOperation.Modify == row.Operation) + { + if (row.Fields[1].Modified) + { + // Changing the guid of a component is equal to deleting the old one and adding a new one. + deletedComponent.Add(id, row); + } + + // If the keypath is modified its an error + if (row.Fields[5].Modified) + { + this.OnMessage(WixErrors.InvalidKeypathChange(row.SourceLineNumbers, id, this.transformPath)); + } + } + } + + // Verify changes in the file table + Table fileTable = this.Transform.Tables["File"]; + if (null != fileTable) + { + Hashtable componentWithChangedKeyPath = new Hashtable(); + foreach (Row row in fileTable.Rows) + { + if (RowOperation.None != row.Operation) + { + string fileId = row.Fields[0].Data.ToString(); + string componentId = row.Fields[1].Data.ToString(); + + // If this file is the keypath of a component + if (String.Equals((string)componentKeyPath[componentId], fileId, StringComparison.Ordinal)) + { + if (row.Fields[2].Modified) + { + // You cant change the filename of a file that is the keypath of a component. + this.OnMessage(WixErrors.InvalidKeypathChange(row.SourceLineNumbers, componentId, this.transformPath)); + } + + if (!componentWithChangedKeyPath.ContainsKey(componentId)) + { + componentWithChangedKeyPath.Add(componentId, fileId); + } + } + + if (RowOperation.Delete == row.Operation) + { + // If the file is removed from a component that is not deleted. + if (!deletedComponent.ContainsKey(componentId)) + { + bool foundRemoveFileEntry = false; + string filename = Common.GetName((string)row[2], false, true); + + Table removeFileTable = this.Transform.Tables["RemoveFile"]; + if (null != removeFileTable) + { + foreach (Row removeFileRow in removeFileTable.Rows) + { + if (RowOperation.Delete == removeFileRow.Operation) + { + continue; + } + + if (componentId == (string)removeFileRow[1]) + { + // Check if there is a RemoveFile entry for this file + if (null != removeFileRow[2]) + { + string removeFileName = Common.GetName((string)removeFileRow[2], false, true); + + // Convert the MSI format for a wildcard string to Regex format. + removeFileName = removeFileName.Replace('.', '|').Replace('?', '.').Replace("*", ".*").Replace("|", "\\."); + + Regex regex = new Regex(removeFileName, RegexOptions.CultureInvariant | RegexOptions.IgnoreCase); + if (regex.IsMatch(filename)) + { + foundRemoveFileEntry = true; + break; + } + } + } + } + } + + if (!foundRemoveFileEntry) + { + this.OnMessage(WixWarnings.InvalidRemoveFile(row.SourceLineNumbers, fileId, componentId)); + } + } + } + } + } + } + + if (0 < deletedComponent.Count) + { + // Index FeatureComponents table. + Hashtable featureComponents = new Hashtable(); + + if (null != featureComponentsTable) + { + foreach (Row row in featureComponentsTable.Rows) + { + ArrayList features; + string componentId = row.Fields[1].Data.ToString(); + + if (featureComponents.Contains(componentId)) + { + features = (ArrayList)featureComponents[componentId]; + } + else + { + features = new ArrayList(); + featureComponents.Add(componentId, features); + } + features.Add(row.Fields[0].Data.ToString()); + } + } + + // Check to make sure if a component was deleted, the feature was too. + foreach (DictionaryEntry entry in deletedComponent) + { + if (featureComponents.Contains(entry.Key.ToString())) + { + ArrayList features = (ArrayList)featureComponents[entry.Key.ToString()]; + foreach (string featureId in features) + { + if (!featureOps.ContainsKey(featureId) || RowOperation.Delete != (RowOperation)featureOps[featureId]) + { + // The feature was not deleted. + this.OnMessage(WixErrors.InvalidRemoveComponent(((Row)entry.Value).SourceLineNumbers, entry.Key.ToString(), featureId, this.transformPath)); + } + } + } + } + } + + // Warn if new components are added to existing features + if (null != featureComponentsTable) + { + foreach (Row row in featureComponentsTable.Rows) + { + if (RowOperation.Add == row.Operation) + { + // Check if the feature is in the Feature table + string feature_ = (string)row[0]; + string component_ = (string)row[1]; + + // Features may not be present if not referenced + if (!featureOps.ContainsKey(feature_) || RowOperation.Add != (RowOperation)featureOps[feature_]) + { + this.OnMessage(WixWarnings.NewComponentAddedToExistingFeature(row.SourceLineNumbers, component_, feature_, this.transformPath)); + } + } + } + } +#endif + throw new NotImplementedException(); + } + } +} diff --git a/src/WixToolset.Core.WindowsInstaller/Bind/ProcessUncompressedFilesCommand.cs b/src/WixToolset.Core.WindowsInstaller/Bind/ProcessUncompressedFilesCommand.cs index 373ada38..13d47215 100644 --- a/src/WixToolset.Core.WindowsInstaller/Bind/ProcessUncompressedFilesCommand.cs +++ b/src/WixToolset.Core.WindowsInstaller/Bind/ProcessUncompressedFilesCommand.cs @@ -86,14 +86,14 @@ namespace WixToolset.Core.WindowsInstaller.Bind // setup up the query record and find the appropriate file in the // previously executed file view - fileQueryRecord[1] = facade.File.Id.Id; + fileQueryRecord[1] = facade.Id; fileView.Execute(fileQueryRecord); using (Record fileRecord = fileView.Fetch()) { if (null == fileRecord) { - throw new WixException(ErrorMessages.FileIdentifierNotFound(facade.File.SourceLineNumbers, facade.File.Id.Id)); + throw new WixException(ErrorMessages.FileIdentifierNotFound(facade.SourceLineNumber, facade.Id)); } relativeFileLayoutPath = this.PathResolver.GetFileSourcePath(directories, fileRecord[1], fileRecord[2], this.Compressed, this.LongNamesInImage); @@ -102,7 +102,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind // finally put together the base media layout path and the relative file layout path var fileLayoutPath = Path.Combine(mediaLayoutDirectory, relativeFileLayoutPath); - var transfer = this.BackendHelper.CreateFileTransfer(facade.File.Source.Path, fileLayoutPath, false, facade.File.SourceLineNumbers); + var transfer = this.BackendHelper.CreateFileTransfer(facade.SourcePath, fileLayoutPath, false, facade.SourceLineNumber); fileTransfers.Add(transfer); // Track the location where the cabinet will be placed. If the transfer is @@ -110,7 +110,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind // because if the source and destination of the transfer is the same, we // don't want to clean the file because we'd be deleting the original // (and that would be bad). - var tracked = this.BackendHelper.TrackFile(transfer.Destination, TrackedFileType.Final, facade.File.SourceLineNumbers); + var tracked = this.BackendHelper.TrackFile(transfer.Destination, TrackedFileType.Final, facade.SourceLineNumber); tracked.Clean = !transfer.Redundant; trackedFiles.Add(tracked); diff --git a/src/WixToolset.Core.WindowsInstaller/Bind/SequenceActionsCommand.cs b/src/WixToolset.Core.WindowsInstaller/Bind/SequenceActionsCommand.cs index e9b0d612..749f9ac0 100644 --- a/src/WixToolset.Core.WindowsInstaller/Bind/SequenceActionsCommand.cs +++ b/src/WixToolset.Core.WindowsInstaller/Bind/SequenceActionsCommand.cs @@ -11,24 +11,25 @@ namespace WixToolset.Core.WindowsInstaller.Bind using WixToolset.Data.WindowsInstaller; using WixToolset.Extensibility.Services; + /// + /// Set sequence numbers for all the actions and create tuples in the output object. + /// internal class SequenceActionsCommand { - public SequenceActionsCommand(IntermediateSection section) + public SequenceActionsCommand(IMessaging messaging, IntermediateSection section) { + this.Messaging = messaging; this.Section = section; this.RelativeActionsForActions = new Dictionary(); } + private IMessaging Messaging { get; } + private IntermediateSection Section { get; } private Dictionary RelativeActionsForActions { get; } - public IMessaging Messaging { private get; set; } - - /// - /// Set sequence numbers for all the actions and create tuples in the output object. - /// public void Execute() { var requiredActionTuples = new Dictionary(); diff --git a/src/WixToolset.Core.WindowsInstaller/Bind/UpdateFileFacadesCommand.cs b/src/WixToolset.Core.WindowsInstaller/Bind/UpdateFileFacadesCommand.cs index 1f2a22d9..81d46b41 100644 --- a/src/WixToolset.Core.WindowsInstaller/Bind/UpdateFileFacadesCommand.cs +++ b/src/WixToolset.Core.WindowsInstaller/Bind/UpdateFileFacadesCommand.cs @@ -59,27 +59,27 @@ namespace WixToolset.Core.WindowsInstaller.Bind FileInfo fileInfo = null; try { - fileInfo = new FileInfo(facade.File.Source.Path); + fileInfo = new FileInfo(facade.SourcePath); } catch (ArgumentException) { - this.Messaging.Write(ErrorMessages.InvalidFileName(facade.File.SourceLineNumbers, facade.File.Source.Path)); + this.Messaging.Write(ErrorMessages.InvalidFileName(facade.SourceLineNumber, facade.SourcePath)); return; } catch (PathTooLongException) { - this.Messaging.Write(ErrorMessages.InvalidFileName(facade.File.SourceLineNumbers, facade.File.Source.Path)); + this.Messaging.Write(ErrorMessages.InvalidFileName(facade.SourceLineNumber, facade.SourcePath)); return; } catch (NotSupportedException) { - this.Messaging.Write(ErrorMessages.InvalidFileName(facade.File.SourceLineNumbers, facade.File.Source.Path)); + this.Messaging.Write(ErrorMessages.InvalidFileName(facade.SourceLineNumber, facade.SourcePath)); return; } if (!fileInfo.Exists) { - this.Messaging.Write(ErrorMessages.CannotFindFile(facade.File.SourceLineNumbers, facade.File.Id.Id, facade.File.Name, facade.File.Source.Path)); + this.Messaging.Write(ErrorMessages.CannotFindFile(facade.SourceLineNumber, facade.Id, facade.FileName, facade.SourcePath)); return; } @@ -87,10 +87,10 @@ namespace WixToolset.Core.WindowsInstaller.Bind { if (Int32.MaxValue < fileStream.Length) { - throw new WixException(ErrorMessages.FileTooLarge(facade.File.SourceLineNumbers, facade.File.Source.Path)); + throw new WixException(ErrorMessages.FileTooLarge(facade.SourceLineNumber, facade.SourcePath)); } - facade.File.FileSize = Convert.ToInt32(fileStream.Length, CultureInfo.InvariantCulture); + facade.FileSize = Convert.ToInt32(fileStream.Length, CultureInfo.InvariantCulture); } string version = null; @@ -103,7 +103,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind { if (0x2 == e.NativeErrorCode) // ERROR_FILE_NOT_FOUND { - throw new WixException(ErrorMessages.FileNotFound(facade.File.SourceLineNumbers, fileInfo.FullName)); + throw new WixException(ErrorMessages.FileNotFound(facade.SourceLineNumber, fileInfo.FullName)); } else { @@ -118,7 +118,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind { // not overwriting hash, so don't do the rest of these options. } - else if (null != facade.File.Version) + else if (null != facade.Version) { // Search all of the file rows available to see if the specified version is actually a companion file. Yes, this looks // very expensive and you're probably thinking it would be better to create an index of some sort to do an O(1) look up. @@ -127,16 +127,16 @@ namespace WixToolset.Core.WindowsInstaller.Bind // // Also, if we do not find a matching file identifier then the user provided a default version and is providing a version // for unversioned file. That's allowed but generally a dangerous thing to do so let's point that out to the user. - if (!this.FileFacades.Any(r => facade.File.Version.Equals(r.File.Id.Id, StringComparison.Ordinal))) + if (!this.FileFacades.Any(r => facade.Version.Equals(r.Id, StringComparison.Ordinal))) { - this.Messaging.Write(WarningMessages.DefaultVersionUsedForUnversionedFile(facade.File.SourceLineNumbers, facade.File.Version, facade.File.Id.Id)); + this.Messaging.Write(WarningMessages.DefaultVersionUsedForUnversionedFile(facade.SourceLineNumber, facade.Version, facade.Id)); } } else { - if (null != facade.File.Language) + if (null != facade.Language) { - this.Messaging.Write(WarningMessages.DefaultLanguageUsedForUnversionedFile(facade.File.SourceLineNumbers, facade.File.Language, facade.File.Id.Id)); + this.Messaging.Write(WarningMessages.DefaultLanguageUsedForUnversionedFile(facade.SourceLineNumber, facade.Language, facade.Id)); } int[] hash; @@ -148,7 +148,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind { if (0x2 == e.NativeErrorCode) // ERROR_FILE_NOT_FOUND { - throw new WixException(ErrorMessages.FileNotFound(facade.File.SourceLineNumbers, fileInfo.FullName)); + throw new WixException(ErrorMessages.FileNotFound(facade.SourceLineNumber, fileInfo.FullName)); } else { @@ -158,7 +158,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind if (null == facade.Hash) { - facade.Hash = new MsiFileHashTuple(facade.File.SourceLineNumbers, facade.File.Id); + facade.Hash = new MsiFileHashTuple(facade.SourceLineNumber, facade.Identifier); this.Section.Tuples.Add(facade.Hash); } @@ -173,11 +173,11 @@ namespace WixToolset.Core.WindowsInstaller.Bind { // If no version was provided by the user, use the version from the file itself. // This is the most common case. - if (String.IsNullOrEmpty(facade.File.Version)) + if (String.IsNullOrEmpty(facade.Version)) { - facade.File.Version = version; + facade.Version = version; } - else if (!this.FileFacades.Any(r => facade.File.Version.Equals(r.File.Id.Id, StringComparison.Ordinal))) // this looks expensive, but see explanation below. + else if (!this.FileFacades.Any(r => facade.Version.Equals(r.Id, StringComparison.Ordinal))) // this looks expensive, but see explanation below. { // The user provided a default version for the file row so we looked for a companion file (a file row with Id matching // the version value). We didn't find it so, we will override the default version they provided with the actual @@ -188,41 +188,41 @@ namespace WixToolset.Core.WindowsInstaller.Bind // // Also note this case can occur when the file is being updated using the WixBindUpdatedFiles extension mechanism. // That's typically even more rare than companion files so again, no index, just search. - facade.File.Version = version; + facade.Version = version; } - if (!String.IsNullOrEmpty(facade.File.Language) && String.IsNullOrEmpty(language)) + if (!String.IsNullOrEmpty(facade.Language) && String.IsNullOrEmpty(language)) { - this.Messaging.Write(WarningMessages.DefaultLanguageUsedForVersionedFile(facade.File.SourceLineNumbers, facade.File.Language, facade.File.Id.Id)); + this.Messaging.Write(WarningMessages.DefaultLanguageUsedForVersionedFile(facade.SourceLineNumber, facade.Language, facade.Id)); } else // override the default provided by the user (usually nothing) with the actual language from the file itself. { - facade.File.Language = language; + facade.Language = language; } // Populate the binder variables for this file information if requested. if (null != this.VariableCache) { - if (!String.IsNullOrEmpty(facade.File.Version)) + if (!String.IsNullOrEmpty(facade.Version)) { - var key = String.Format(CultureInfo.InvariantCulture, "fileversion.{0}", facade.File.Id.Id); - this.VariableCache[key] = facade.File.Version; + var key = String.Format(CultureInfo.InvariantCulture, "fileversion.{0}", facade.Id); + this.VariableCache[key] = facade.Version; } - if (!String.IsNullOrEmpty(facade.File.Language)) + if (!String.IsNullOrEmpty(facade.Language)) { - var key = String.Format(CultureInfo.InvariantCulture, "filelanguage.{0}", facade.File.Id.Id); - this.VariableCache[key] = facade.File.Language; + var key = String.Format(CultureInfo.InvariantCulture, "filelanguage.{0}", facade.Id); + this.VariableCache[key] = facade.Language; } } } // If this is a CLR assembly, load the assembly and get the assembly name information - if (AssemblyType.DotNetAssembly == facade.Assembly?.Type) + if (AssemblyType.DotNetAssembly == facade.AssemblyType) { try { - var assemblyName = AssemblyNameReader.ReadAssembly(facade.File.SourceLineNumbers, fileInfo.FullName, version); + var assemblyName = AssemblyNameReader.ReadAssembly(facade.SourceLineNumber, fileInfo.FullName, version); this.SetMsiAssemblyName(assemblyNameTuples, facade, "name", assemblyName.Name); this.SetMsiAssemblyName(assemblyNameTuples, facade, "culture", assemblyName.Culture); @@ -242,9 +242,9 @@ namespace WixToolset.Core.WindowsInstaller.Bind { this.SetMsiAssemblyName(assemblyNameTuples, facade, "publicKeyToken", assemblyName.PublicKeyToken); } - else if (facade.Assembly.ApplicationFileRef == null) + else if (facade.AssemblyApplicationFileRef == null) { - throw new WixException(ErrorMessages.GacAssemblyNoStrongName(facade.File.SourceLineNumbers, fileInfo.FullName, facade.File.ComponentRef)); + throw new WixException(ErrorMessages.GacAssemblyNoStrongName(facade.SourceLineNumber, fileInfo.FullName, facade.ComponentRef)); } if (!String.IsNullOrEmpty(assemblyName.FileVersion)) @@ -255,7 +255,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind // add the assembly name to the information cache if (null != this.VariableCache) { - this.VariableCache[$"assemblyfullname.{facade.File.Id.Id}"] = assemblyName.GetFullName(); + this.VariableCache[$"assemblyfullname.{facade.Id}"] = assemblyName.GetFullName(); } } catch (WixException e) @@ -263,20 +263,20 @@ namespace WixToolset.Core.WindowsInstaller.Bind this.Messaging.Write(e.Error); } } - else if (AssemblyType.Win32Assembly == facade.Assembly?.Type) + else if (AssemblyType.Win32Assembly == facade.AssemblyType) { // TODO: Consider passing in the this.FileFacades as an indexed collection instead of searching through // all files like this. Even though this is a rare case it looks like we might be able to index the // file earlier. - var fileManifest = this.FileFacades.FirstOrDefault(r => r.File.Id.Id.Equals(facade.Assembly.ManifestFileRef, StringComparison.Ordinal)); + var fileManifest = this.FileFacades.FirstOrDefault(r => r.Id.Equals(facade.AssemblyManifestFileRef, StringComparison.Ordinal)); if (null == fileManifest) { - this.Messaging.Write(ErrorMessages.MissingManifestForWin32Assembly(facade.File.SourceLineNumbers, facade.File.Id.Id, facade.Assembly.ManifestFileRef)); + this.Messaging.Write(ErrorMessages.MissingManifestForWin32Assembly(facade.SourceLineNumber, facade.Id, facade.AssemblyManifestFileRef)); } try { - var assemblyName = AssemblyNameReader.ReadAssemblyManifest(facade.File.SourceLineNumbers, fileManifest.File.Source.Path); + var assemblyName = AssemblyNameReader.ReadAssemblyManifest(facade.SourceLineNumber, fileManifest.SourcePath); if (!String.IsNullOrEmpty(assemblyName.Name)) { @@ -315,41 +315,41 @@ namespace WixToolset.Core.WindowsInstaller.Bind /// create a new row. /// /// MsiAssemblyName table. - /// FileFacade containing the assembly read for the MsiAssemblyName row. + /// FileFacade containing the assembly read for the MsiAssemblyName row. /// MsiAssemblyName name. /// MsiAssemblyName value. - private void SetMsiAssemblyName(Dictionary assemblyNameTuples, FileFacade file, string name, string value) + private void SetMsiAssemblyName(Dictionary assemblyNameTuples, FileFacade facade, string name, string value) { // check for null value (this can occur when grabbing the file version from an assembly without one) if (String.IsNullOrEmpty(value)) { - this.Messaging.Write(WarningMessages.NullMsiAssemblyNameValue(file.File.SourceLineNumbers, file.File.ComponentRef, name)); + this.Messaging.Write(WarningMessages.NullMsiAssemblyNameValue(facade.SourceLineNumber, facade.ComponentRef, name)); } else { // if the assembly will be GAC'd and the name in the file table doesn't match the name in the MsiAssemblyName table, error because the install will fail. - if ("name" == name && AssemblyType.DotNetAssembly == file.Assembly.Type && - String.IsNullOrEmpty(file.Assembly.ApplicationFileRef) && - !String.Equals(Path.GetFileNameWithoutExtension(file.File.Name), value, StringComparison.OrdinalIgnoreCase)) + if ("name" == name && AssemblyType.DotNetAssembly == facade.AssemblyType && + String.IsNullOrEmpty(facade.AssemblyApplicationFileRef) && + !String.Equals(Path.GetFileNameWithoutExtension(facade.FileName), value, StringComparison.OrdinalIgnoreCase)) { - this.Messaging.Write(ErrorMessages.GACAssemblyIdentityWarning(file.File.SourceLineNumbers, Path.GetFileNameWithoutExtension(file.File.Name), value)); + this.Messaging.Write(ErrorMessages.GACAssemblyIdentityWarning(facade.SourceLineNumber, Path.GetFileNameWithoutExtension(facade.FileName), value)); } // override directly authored value - var lookup = String.Concat(file.File.ComponentRef, "/", name); + var lookup = String.Concat(facade.ComponentRef, "/", name); if (!assemblyNameTuples.TryGetValue(lookup, out var assemblyNameRow)) { - assemblyNameRow = new MsiAssemblyNameTuple(file.File.SourceLineNumbers); - assemblyNameRow.ComponentRef = file.File.ComponentRef; + assemblyNameRow = new MsiAssemblyNameTuple(facade.SourceLineNumber); + assemblyNameRow.ComponentRef = facade.ComponentRef; assemblyNameRow.Name = name; assemblyNameRow.Value = value; - if (null == file.AssemblyNames) + if (null == facade.AssemblyNames) { - file.AssemblyNames = new List(); + facade.AssemblyNames = new List(); } - file.AssemblyNames.Add(assemblyNameRow); + facade.AssemblyNames.Add(assemblyNameRow); this.Section.Tuples.Add(assemblyNameRow); } @@ -357,7 +357,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind if (this.VariableCache != null) { - var key = String.Format(CultureInfo.InvariantCulture, "assembly{0}.{1}", name, file.File.Id.Id).ToLowerInvariant(); + var key = String.Format(CultureInfo.InvariantCulture, "assembly{0}.{1}", name, facade.Id).ToLowerInvariant(); this.VariableCache[key] = value; } } diff --git a/src/WixToolset.Core.WindowsInstaller/Bind/UpdateMediaSequencesCommand.cs b/src/WixToolset.Core.WindowsInstaller/Bind/UpdateMediaSequencesCommand.cs index f9e3bd5a..ae872f45 100644 --- a/src/WixToolset.Core.WindowsInstaller/Bind/UpdateMediaSequencesCommand.cs +++ b/src/WixToolset.Core.WindowsInstaller/Bind/UpdateMediaSequencesCommand.cs @@ -33,7 +33,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind // Order by Component to group the files by directory. var optimized = this.OptimizedFileFacades(); - foreach (var fileId in optimized.Select(f => f.File.Id.Id)) + foreach (var fileId in optimized.Select(f => f.Id)) { var fileRow = fileRows.Get(fileId); fileRow.Sequence = ++lastSequence; @@ -41,13 +41,13 @@ namespace WixToolset.Core.WindowsInstaller.Bind } else { - int lastSequence = 0; + var lastSequence = 0; MediaRow mediaRow = null; - Dictionary> patchGroups = new Dictionary>(); + var patchGroups = new Dictionary>(); // sequence the non-patch-added files var optimized = this.OptimizedFileFacades(); - foreach (FileFacade facade in optimized) + foreach (var facade in optimized) { if (null == mediaRow) { @@ -64,19 +64,19 @@ namespace WixToolset.Core.WindowsInstaller.Bind mediaRow = mediaRows.Get(facade.DiskId); } - if (facade.File.PatchGroup.HasValue) + if (facade.PatchGroup.HasValue) { - if (patchGroups.TryGetValue(facade.File.PatchGroup.Value, out var patchGroup)) + if (patchGroups.TryGetValue(facade.PatchGroup.Value, out var patchGroup)) { patchGroup = new List(); - patchGroups.Add(facade.File.PatchGroup.Value, patchGroup); + patchGroups.Add(facade.PatchGroup.Value, patchGroup); } patchGroup.Add(facade); } else { - var fileRow = fileRows.Get(facade.File.Id.Id); + var fileRow = fileRows.Get(facade.Id); fileRow.Sequence = ++lastSequence; } } @@ -102,7 +102,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind mediaRow = mediaRows.Get(facade.DiskId); } - var fileRow = fileRows.Get(facade.File.Id.Id); + var fileRow = fileRows.Get(facade.Id); fileRow.Sequence = ++lastSequence; } } @@ -119,7 +119,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind // TODO: Sort these facades even smarter by directory path and component id // and maybe file size or file extension and other creative ideas to // get optimal install speed out of MSI. - return this.FileFacades.OrderBy(f => f.File.ComponentRef); + return this.FileFacades.OrderBy(f => f.ComponentRef); } } } diff --git a/src/WixToolset.Core.WindowsInstaller/Data/tables.xml b/src/WixToolset.Core.WindowsInstaller/Data/tables.xml index e4b5e954..7cd1767b 100644 --- a/src/WixToolset.Core.WindowsInstaller/Data/tables.xml +++ b/src/WixToolset.Core.WindowsInstaller/Data/tables.xml @@ -156,6 +156,10 @@ minValue="0" maxValue="32767" description="Integer containing bit flags representing file attributes (with the decimal value of each bit position in parentheses)"/> + + certificates = new Dictionary(); + var certificates = new Dictionary(); // Reset the in-memory tables for this new database - Table digitalSignatureTable = new Table(this.TableDefinitions["MsiDigitalSignature"]); - Table digitalCertificateTable = new Table(this.TableDefinitions["MsiDigitalCertificate"]); + var digitalSignatureTable = new Table(this.TableDefinitions["MsiDigitalSignature"]); + var digitalCertificateTable = new Table(this.TableDefinitions["MsiDigitalCertificate"]); // If any digital signature records exist that are not of the media type, preserve them if (database.TableExists("MsiDigitalSignature")) { - using (View digitalSignatureView = database.OpenExecuteView("SELECT `Table`, `SignObject`, `DigitalCertificate_`, `Hash` FROM `MsiDigitalSignature` WHERE `Table` <> 'Media'")) + using (var digitalSignatureView = database.OpenExecuteView("SELECT `Table`, `SignObject`, `DigitalCertificate_`, `Hash` FROM `MsiDigitalSignature` WHERE `Table` <> 'Media'")) { - foreach (Record digitalSignatureRecord in digitalSignatureView.Records) + foreach (var digitalSignatureRecord in digitalSignatureView.Records) { Row digitalSignatureRow = null; digitalSignatureRow = digitalSignatureTable.CreateRow(null); - string table = digitalSignatureRecord.GetString(0); - string signObject = digitalSignatureRecord.GetString(1); + var table = digitalSignatureRecord.GetString(0); + var signObject = digitalSignatureRecord.GetString(1); digitalSignatureRow[0] = table; digitalSignatureRow[1] = signObject; @@ -75,16 +75,16 @@ namespace WixToolset.Core.WindowsInstaller.Inscribe if (false == digitalSignatureRecord.IsNull(3)) { // Export to a file, because the MSI API's require us to provide a file path on disk - string hashPath = Path.Combine(this.Context.IntermediateFolder, "MsiDigitalSignature"); - string hashFileName = string.Concat(table, ".", signObject, ".bin"); + var hashPath = Path.Combine(this.Context.IntermediateFolder, "MsiDigitalSignature"); + var hashFileName = String.Concat(table, ".", signObject, ".bin"); Directory.CreateDirectory(hashPath); hashPath = Path.Combine(hashPath, hashFileName); - using (FileStream fs = File.Create(hashPath)) + using (var fs = File.Create(hashPath)) { int bytesRead; - byte[] buffer = new byte[1024 * 4]; + var buffer = new byte[1024 * 4]; while (0 != (bytesRead = digitalSignatureRecord.GetStream(3, buffer, buffer.Length))) { @@ -101,21 +101,21 @@ namespace WixToolset.Core.WindowsInstaller.Inscribe // If any digital certificates exist, extract and preserve them if (database.TableExists("MsiDigitalCertificate")) { - using (View digitalCertificateView = database.OpenExecuteView("SELECT * FROM `MsiDigitalCertificate`")) + using (var digitalCertificateView = database.OpenExecuteView("SELECT * FROM `MsiDigitalCertificate`")) { - foreach (Record digitalCertificateRecord in digitalCertificateView.Records) + foreach (var digitalCertificateRecord in digitalCertificateView.Records) { - string certificateId = digitalCertificateRecord.GetString(1); // get the identifier of the certificate + var certificateId = digitalCertificateRecord.GetString(1); // get the identifier of the certificate // Export to a file, because the MSI API's require us to provide a file path on disk - string certPath = Path.Combine(this.Context.IntermediateFolder, "MsiDigitalCertificate"); + var certPath = Path.Combine(this.Context.IntermediateFolder, "MsiDigitalCertificate"); Directory.CreateDirectory(certPath); - certPath = Path.Combine(certPath, string.Concat(certificateId, ".cer")); + certPath = Path.Combine(certPath, String.Concat(certificateId, ".cer")); - using (FileStream fs = File.Create(certPath)) + using (var fs = File.Create(certPath)) { int bytesRead; - byte[] buffer = new byte[1024 * 4]; + var buffer = new byte[1024 * 4]; while (0 != (bytesRead = digitalCertificateRecord.GetStream(2, buffer, buffer.Length))) { @@ -124,37 +124,37 @@ namespace WixToolset.Core.WindowsInstaller.Inscribe } // Add it to our "add to MsiDigitalCertificate" table dictionary - Row digitalCertificateRow = digitalCertificateTable.CreateRow(null); + var digitalCertificateRow = digitalCertificateTable.CreateRow(null); digitalCertificateRow[0] = certificateId; // Now set the file path on disk where this binary stream will be picked up at import time - digitalCertificateRow[1] = string.Concat(certificateId, ".cer"); + digitalCertificateRow[1] = String.Concat(certificateId, ".cer"); // Load the cert to get it's thumbprint - X509Certificate cert = X509Certificate.CreateFromCertFile(certPath); - X509Certificate2 cert2 = new X509Certificate2(cert); + var cert = X509Certificate.CreateFromCertFile(certPath); + var cert2 = new X509Certificate2(cert); certificates.Add(cert2.Thumbprint, certificateId); } } } - using (View mediaView = database.OpenExecuteView("SELECT * FROM `Media`")) + using (var mediaView = database.OpenExecuteView("SELECT * FROM `Media`")) { - foreach (Record mediaRecord in mediaView.Records) + foreach (var mediaRecord in mediaView.Records) { X509Certificate2 cert2 = null; Row digitalSignatureRow = null; - string cabName = mediaRecord.GetString(4); // get the name of the cab + var cabName = mediaRecord.GetString(4); // get the name of the cab // If there is no cabinet or it's an internal cab, skip it. if (String.IsNullOrEmpty(cabName) || cabName.StartsWith("#", StringComparison.Ordinal)) { continue; } - string cabId = mediaRecord.GetString(1); // get the ID of the cab - string cabPath = Path.Combine(Path.GetDirectoryName(this.Context.InputFilePath), cabName); + var cabId = mediaRecord.GetString(1); // get the ID of the cab + var cabPath = Path.Combine(Path.GetDirectoryName(this.Context.InputFilePath), cabName); // If the cabs aren't there, throw an error but continue to catch the other errors if (!File.Exists(cabPath)) @@ -166,12 +166,12 @@ namespace WixToolset.Core.WindowsInstaller.Inscribe try { // Get the certificate from the cab - X509Certificate signedFileCert = X509Certificate.CreateFromSignedFile(cabPath); + var signedFileCert = X509Certificate.CreateFromSignedFile(cabPath); cert2 = new X509Certificate2(signedFileCert); } catch (System.Security.Cryptography.CryptographicException e) { - uint HResult = unchecked((uint)Marshal.GetHRForException(e)); + var HResult = unchecked((uint)Marshal.GetHRForException(e)); // If the file has no cert, continue, but flag that we found at least one so we can later give a warning if (0x80092009 == HResult) // CRYPT_E_NO_MATCH @@ -197,26 +197,26 @@ namespace WixToolset.Core.WindowsInstaller.Inscribe if (!certificates.ContainsKey(cert2.Thumbprint)) { // generate a stable identifier - string certificateGeneratedId = Common.GenerateIdentifier("cer", cert2.Thumbprint); + var certificateGeneratedId = Common.GenerateIdentifier("cer", cert2.Thumbprint); // Add it to our "add to MsiDigitalCertificate" table dictionary - Row digitalCertificateRow = digitalCertificateTable.CreateRow(null); + var digitalCertificateRow = digitalCertificateTable.CreateRow(null); digitalCertificateRow[0] = certificateGeneratedId; // Export to a file, because the MSI API's require us to provide a file path on disk - string certPath = Path.Combine(this.Context.IntermediateFolder, "MsiDigitalCertificate"); + var certPath = Path.Combine(this.Context.IntermediateFolder, "MsiDigitalCertificate"); Directory.CreateDirectory(certPath); - certPath = Path.Combine(certPath, string.Concat(cert2.Thumbprint, ".cer")); + certPath = Path.Combine(certPath, String.Concat(cert2.Thumbprint, ".cer")); File.Delete(certPath); - using (BinaryWriter writer = new BinaryWriter(File.Open(certPath, FileMode.Create))) + using (var writer = new BinaryWriter(File.Open(certPath, FileMode.Create))) { writer.Write(cert2.RawData); writer.Close(); } // Now set the file path on disk where this binary stream will be picked up at import time - digitalCertificateRow[1] = string.Concat(cert2.Thumbprint, ".cer"); + digitalCertificateRow[1] = String.Concat(cert2.Thumbprint, ".cer"); certificates.Add(cert2.Thumbprint, certificateGeneratedId); } diff --git a/src/WixToolset.Core.WindowsInstaller/MspBackend.cs b/src/WixToolset.Core.WindowsInstaller/MspBackend.cs index b6e72e11..8aa450bf 100644 --- a/src/WixToolset.Core.WindowsInstaller/MspBackend.cs +++ b/src/WixToolset.Core.WindowsInstaller/MspBackend.cs @@ -3,36 +3,74 @@ namespace WixToolset.Core.WindowsInstaller { using System; - using System.ComponentModel; + using System.Collections.Generic; using System.IO; - using WixToolset.Core.Native; + using System.Linq; + using WixToolset.Core.WindowsInstaller.Bind; + using WixToolset.Core.WindowsInstaller.Msi; using WixToolset.Core.WindowsInstaller.Unbind; using WixToolset.Data; - using WixToolset.Data.Bind; + using WixToolset.Data.Tuples; + using WixToolset.Data.WindowsInstaller; using WixToolset.Extensibility; using WixToolset.Extensibility.Data; - using WixToolset.Ole32; + using WixToolset.Extensibility.Services; internal class MspBackend : IBackend { public IBindResult Bind(IBindContext context) { - throw new NotImplementedException(); - } + var messaging = context.ServiceProvider.GetService(); - public IDecompileResult Decompile(IDecompileContext context) - { - throw new NotImplementedException(); - } + var extensionManager = context.ServiceProvider.GetService(); - public bool Inscribe(IInscribeContext context) - { - throw new NotImplementedException(); + var backendExtensions = extensionManager.GetServices(); + + foreach (var extension in backendExtensions) + { + extension.PreBackendBind(context); + } + + // Create transforms named in patch transforms. + IEnumerable patchTransforms; + { + var command = new CreatePatchTransformsCommand(messaging, context.IntermediateRepresentation, context.IntermediateFolder); + patchTransforms = command.Execute(); + } + + // Enhance the intermediate by attaching the created patch transforms. + IEnumerable subStorages; + { + var command = new AttachPatchTransformsCommand(messaging, context.IntermediateRepresentation, patchTransforms); + subStorages = command.Execute(); + } + + // Create WindowsInstallerData with patch metdata and transforms as sub-storages + // Create MSP from WindowsInstallerData + using (var command = new BindDatabaseCommand(context, backendExtensions, subStorages, null)) + { + command.Execute(); + + var result = context.ServiceProvider.GetService(); + result.FileTransfers = command.FileTransfers; + result.TrackedFiles = command.TrackedFiles; + + foreach (var extension in backendExtensions) + { + extension.PostBackendBind(result, command.Wixout); + } + + return result; + } } + public IDecompileResult Decompile(IDecompileContext context) => throw new NotImplementedException(); + + public bool Inscribe(IInscribeContext context) => throw new NotImplementedException(); + public Intermediate Unbind(IUnbindContext context) { -#if REVISIT_FOR_PATCHING +#if TODO_PATCHING Output patch; // patch files are essentially database files (use a special flag to let the API know its a patch file) @@ -116,4 +154,4 @@ namespace WixToolset.Core.WindowsInstaller throw new NotImplementedException(); } } -} \ No newline at end of file +} diff --git a/src/WixToolset.Core.WindowsInstaller/MstBackend.cs b/src/WixToolset.Core.WindowsInstaller/MstBackend.cs index b64f417a..a6d86c10 100644 --- a/src/WixToolset.Core.WindowsInstaller/MstBackend.cs +++ b/src/WixToolset.Core.WindowsInstaller/MstBackend.cs @@ -12,7 +12,7 @@ namespace WixToolset.Core.WindowsInstaller { public IBindResult Bind(IBindContext context) { -#if REVISIT_FOR_PATCHING +#if TODO_PATCHING var command = new BindTransformCommand(); command.Extensions = context.Extensions; command.TempFilesLocation = context.IntermediateFolder; diff --git a/src/WixToolset.Core.WindowsInstaller/Ole32/Storage.cs b/src/WixToolset.Core.WindowsInstaller/Ole32/Storage.cs index c6a43bc4..541d899a 100644 --- a/src/WixToolset.Core.WindowsInstaller/Ole32/Storage.cs +++ b/src/WixToolset.Core.WindowsInstaller/Ole32/Storage.cs @@ -63,8 +63,8 @@ namespace WixToolset.Ole32 /// internal sealed class Storage : IDisposable { + private readonly IStorage storage; private bool disposed; - private IStorage storage; /// /// Instantiate a new Storage. diff --git a/src/WixToolset.Core.WindowsInstaller/Patch.cs b/src/WixToolset.Core.WindowsInstaller/Patch.cs index 6549e830..42cd7152 100644 --- a/src/WixToolset.Core.WindowsInstaller/Patch.cs +++ b/src/WixToolset.Core.WindowsInstaller/Patch.cs @@ -1,5 +1,7 @@ // 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. +#if DELETE + namespace WixToolset.Data { using System; @@ -50,7 +52,6 @@ namespace WixToolset.Data [SuppressMessage("Microsoft.Globalization", "CA1303:DoNotPassLiteralsAsLocalizedParameters", MessageId = "System.InvalidOperationException.#ctor(System.String)")] public void AttachTransforms(List transforms) { -#if REVISIT_FOR_PATCHING // Track if at least one transform gets attached. bool attachedTransform = false; @@ -1229,8 +1230,10 @@ namespace WixToolset.Data } return pairedTransform; -#endif + throw new NotImplementedException(); } } } + +#endif diff --git a/src/WixToolset.Core.WindowsInstaller/PatchTransform.cs b/src/WixToolset.Core.WindowsInstaller/PatchTransform.cs index 0dc1e874..f58ca53f 100644 --- a/src/WixToolset.Core.WindowsInstaller/PatchTransform.cs +++ b/src/WixToolset.Core.WindowsInstaller/PatchTransform.cs @@ -1,5 +1,7 @@ // 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. +#if DELETE + namespace WixToolset { using System; @@ -50,7 +52,6 @@ namespace WixToolset /// public void Validate() { -#if REVISIT_FOR_PATCHING // Changing the ProdocutCode in a patch transform is not recommended. Table propertyTable = this.Transform.Tables["Property"]; if (null != propertyTable) @@ -261,8 +262,10 @@ namespace WixToolset } } } -#endif + throw new NotImplementedException(); } } } + +#endif \ No newline at end of file diff --git a/src/WixToolset.Core.WindowsInstaller/Unbind/UnbindMsiOrMsmCommand.cs b/src/WixToolset.Core.WindowsInstaller/Unbind/UnbindMsiOrMsmCommand.cs index eca51caf..eea0fe23 100644 --- a/src/WixToolset.Core.WindowsInstaller/Unbind/UnbindMsiOrMsmCommand.cs +++ b/src/WixToolset.Core.WindowsInstaller/Unbind/UnbindMsiOrMsmCommand.cs @@ -19,7 +19,7 @@ namespace WixToolset.Core.WindowsInstaller.Unbind public Intermediate Execute() { -#if REVISIT_FOR_PATCHING +#if TODO_PATCHING Output output; try diff --git a/src/WixToolset.Core.WindowsInstaller/Unbind/UnbindTranformCommand.cs b/src/WixToolset.Core.WindowsInstaller/Unbind/UnbindTranformCommand.cs index bdf8d542..9261fda0 100644 --- a/src/WixToolset.Core.WindowsInstaller/Unbind/UnbindTranformCommand.cs +++ b/src/WixToolset.Core.WindowsInstaller/Unbind/UnbindTranformCommand.cs @@ -4,6 +4,7 @@ namespace WixToolset.Core.WindowsInstaller.Unbind { using System; using System.Collections; + using System.Collections.Generic; using System.ComponentModel; using System.Globalization; using System.IO; @@ -12,7 +13,6 @@ namespace WixToolset.Core.WindowsInstaller.Unbind using WixToolset.Core.WindowsInstaller.Msi; using WixToolset.Data; using WixToolset.Data.WindowsInstaller; - using WixToolset.Extensibility; using WixToolset.Extensibility.Services; internal class UnbindTransformCommand @@ -41,21 +41,21 @@ namespace WixToolset.Core.WindowsInstaller.Unbind public WindowsInstallerData Execute() { - WindowsInstallerData transform = new WindowsInstallerData(new SourceLineNumber(this.TransformFile)); + var transform = new WindowsInstallerData(new SourceLineNumber(this.TransformFile)); transform.Type = OutputType.Transform; // get the summary information table - using (SummaryInformation summaryInformation = new SummaryInformation(this.TransformFile)) + using (var summaryInformation = new SummaryInformation(this.TransformFile)) { - Table table = transform.EnsureTable(this.TableDefinitions["_SummaryInformation"]); + var table = transform.EnsureTable(this.TableDefinitions["_SummaryInformation"]); - for (int i = 1; 19 >= i; i++) + for (var i = 1; 19 >= i; i++) { - string value = summaryInformation.GetProperty(i); + var value = summaryInformation.GetProperty(i); if (0 < value.Length) { - Row row = table.CreateRow(transform.SourceLineNumbers); + var row = table.CreateRow(transform.SourceLineNumbers); row[0] = i; row[1] = value; } @@ -63,9 +63,9 @@ namespace WixToolset.Core.WindowsInstaller.Unbind } // create a schema msi which hopefully matches the table schemas in the transform - WindowsInstallerData schemaOutput = new WindowsInstallerData(null); - string msiDatabaseFile = Path.Combine(this.IntermediateFolder, "schema.msi"); - foreach (TableDefinition tableDefinition in this.TableDefinitions) + var schemaOutput = new WindowsInstallerData(null); + var msiDatabaseFile = Path.Combine(this.IntermediateFolder, "schema.msi"); + foreach (var tableDefinition in this.TableDefinitions) { // skip unreal tables and the Patch table if (!tableDefinition.Unreal && "Patch" != tableDefinition.Name) @@ -74,40 +74,40 @@ namespace WixToolset.Core.WindowsInstaller.Unbind } } - Hashtable addedRows = new Hashtable(); + var addedRows = new Dictionary(); Table transformViewTable; // Bind the schema msi. this.GenerateDatabase(schemaOutput, msiDatabaseFile); // apply the transform to the database and retrieve the modifications - using (Database msiDatabase = new Database(msiDatabaseFile, OpenDatabase.Transact)) + using (var msiDatabase = new Database(msiDatabaseFile, OpenDatabase.Transact)) { // apply the transform with the ViewTransform option to collect all the modifications msiDatabase.ApplyTransform(this.TransformFile, TransformErrorConditions.All | TransformErrorConditions.ViewTransform); // unbind the database var unbindCommand = new UnbindDatabaseCommand(this.Messaging, msiDatabase, msiDatabaseFile, OutputType.Product, this.ExportBasePath, this.IntermediateFolder, false, false, skipSummaryInfo: true); - WindowsInstallerData transformViewOutput = unbindCommand.Execute(); + var transformViewOutput = unbindCommand.Execute(); // index the added and possibly modified rows (added rows may also appears as modified rows) transformViewTable = transformViewOutput.Tables["_TransformView"]; - Hashtable modifiedRows = new Hashtable(); - foreach (Row row in transformViewTable.Rows) + var modifiedRows = new Hashtable(); + foreach (var row in transformViewTable.Rows) { - string tableName = (string)row[0]; - string columnName = (string)row[1]; - string primaryKeys = (string)row[2]; + var tableName = (string)row[0]; + var columnName = (string)row[1]; + var primaryKeys = (string)row[2]; if ("INSERT" == columnName) { - string index = String.Concat(tableName, ':', primaryKeys); + var index = String.Concat(tableName, ':', primaryKeys); addedRows.Add(index, null); } else if ("CREATE" != columnName && "DELETE" != columnName && "DROP" != columnName && null != primaryKeys) // modified row { - string index = String.Concat(tableName, ':', primaryKeys); + var index = String.Concat(tableName, ':', primaryKeys); modifiedRows[index] = row; } @@ -116,16 +116,16 @@ namespace WixToolset.Core.WindowsInstaller.Unbind // create placeholder rows for modified rows to make the transform insert the updated values when its applied foreach (Row row in modifiedRows.Values) { - string tableName = (string)row[0]; - string columnName = (string)row[1]; - string primaryKeys = (string)row[2]; + var tableName = (string)row[0]; + var columnName = (string)row[1]; + var primaryKeys = (string)row[2]; - string index = String.Concat(tableName, ':', primaryKeys); + var index = String.Concat(tableName, ':', primaryKeys); // ignore information for added rows - if (!addedRows.Contains(index)) + if (!addedRows.ContainsKey(index)) { - Table table = schemaOutput.Tables[tableName]; + var table = schemaOutput.Tables[tableName]; this.CreateRow(table, primaryKeys, true); } } @@ -135,7 +135,7 @@ namespace WixToolset.Core.WindowsInstaller.Unbind this.GenerateDatabase(schemaOutput, msiDatabaseFile); // apply the transform to the database and retrieve the modifications - using (Database msiDatabase = new Database(msiDatabaseFile, OpenDatabase.Transact)) + using (var msiDatabase = new Database(msiDatabaseFile, OpenDatabase.Transact)) { try { @@ -158,26 +158,26 @@ namespace WixToolset.Core.WindowsInstaller.Unbind // unbind the database var unbindCommand = new UnbindDatabaseCommand(this.Messaging, msiDatabase, msiDatabaseFile, OutputType.Product, this.ExportBasePath, this.IntermediateFolder, false, false, skipSummaryInfo: true); - WindowsInstallerData output = unbindCommand.Execute(); + var output = unbindCommand.Execute(); // index all the rows to easily find modified rows - Hashtable rows = new Hashtable(); - foreach (Table table in output.Tables) + var rows = new Dictionary(); + foreach (var table in output.Tables) { - foreach (Row row in table.Rows) + foreach (var row in table.Rows) { rows.Add(String.Concat(table.Name, ':', row.GetPrimaryKey('\t', " ")), row); } } // process the _TransformView rows into transform rows - foreach (Row row in transformViewTable.Rows) + foreach (var row in transformViewTable.Rows) { - string tableName = (string)row[0]; - string columnName = (string)row[1]; - string primaryKeys = (string)row[2]; + var tableName = (string)row[0]; + var columnName = (string)row[1]; + var primaryKeys = (string)row[2]; - Table table = transform.EnsureTable(this.TableDefinitions[tableName]); + var table = transform.EnsureTable(this.TableDefinitions[tableName]); if ("CREATE" == columnName) // added table { @@ -185,7 +185,7 @@ namespace WixToolset.Core.WindowsInstaller.Unbind } else if ("DELETE" == columnName) // deleted row { - Row deletedRow = this.CreateRow(table, primaryKeys, false); + var deletedRow = this.CreateRow(table, primaryKeys, false); deletedRow.Operation = RowOperation.Delete; } else if ("DROP" == columnName) // dropped table @@ -194,24 +194,24 @@ namespace WixToolset.Core.WindowsInstaller.Unbind } else if ("INSERT" == columnName) // added row { - string index = String.Concat(tableName, ':', primaryKeys); - Row addedRow = (Row)rows[index]; + var index = String.Concat(tableName, ':', primaryKeys); + var addedRow = rows[index]; addedRow.Operation = RowOperation.Add; table.Rows.Add(addedRow); } else if (null != primaryKeys) // modified row { - string index = String.Concat(tableName, ':', primaryKeys); + var index = String.Concat(tableName, ':', primaryKeys); // the _TransformView table includes information for added rows // that looks like modified rows so it sometimes needs to be ignored - if (!addedRows.Contains(index)) + if (!addedRows.ContainsKey(index)) { - Row modifiedRow = (Row)rows[index]; + var modifiedRow = rows[index]; // mark the field as modified - int indexOfModifiedValue = -1; - for (int i = 0; i < modifiedRow.TableDefinition.Columns.Length; ++i) + var indexOfModifiedValue = -1; + for (var i = 0; i < modifiedRow.TableDefinition.Columns.Length; ++i) { if (columnName.Equals(modifiedRow.TableDefinition.Columns[i].Name, StringComparison.Ordinal)) { @@ -231,7 +231,7 @@ namespace WixToolset.Core.WindowsInstaller.Unbind } else // added column { - ColumnDefinition column = table.Definition.Columns.Single(c => c.Name.Equals(columnName, StringComparison.Ordinal)); + var column = table.Definition.Columns.Single(c => c.Name.Equals(columnName, StringComparison.Ordinal)); column.Added = true; } } @@ -240,21 +240,6 @@ namespace WixToolset.Core.WindowsInstaller.Unbind return transform; } - private void GenerateDatabase(WindowsInstallerData output, string databaseFile) - { - var command = new GenerateDatabaseCommand(); - command.Extensions = Array.Empty(); - command.Output = output; - command.OutputPath = databaseFile; - command.KeepAddedColumns = true; - command.UseSubDirectory = false; - command.SuppressAddingValidationRows = true; - command.TableDefinitions = this.TableDefinitions; - command.IntermediateFolder = this.IntermediateFolder; - command.Codepage = -1; - command.Execute(); - } - /// /// Create a deleted or modified row. /// @@ -264,14 +249,14 @@ namespace WixToolset.Core.WindowsInstaller.Unbind /// The new row. private Row CreateRow(Table table, string primaryKeys, bool setRequiredFields) { - Row row = table.CreateRow(null); + var row = table.CreateRow(null); - string[] primaryKeyParts = primaryKeys.Split('\t'); - int primaryKeyPartIndex = 0; + var primaryKeyParts = primaryKeys.Split('\t'); + var primaryKeyPartIndex = 0; - for (int i = 0; i < table.Definition.Columns.Length; i++) + for (var i = 0; i < table.Definition.Columns.Length; i++) { - ColumnDefinition columnDefinition = table.Definition.Columns[i]; + var columnDefinition = table.Definition.Columns[i]; if (columnDefinition.PrimaryKey) { @@ -294,8 +279,8 @@ namespace WixToolset.Core.WindowsInstaller.Unbind { if (null == this.EmptyFile) { - this.EmptyFile = Path.GetTempFileName() + ".empty"; - using (FileStream fileStream = File.Create(this.EmptyFile)) + this.EmptyFile = Path.Combine(this.IntermediateFolder, ".empty"); + using (var fileStream = File.Create(this.EmptyFile)) { } } @@ -311,5 +296,11 @@ namespace WixToolset.Core.WindowsInstaller.Unbind return row; } + + private void GenerateDatabase(WindowsInstallerData output, string databaseFile) + { + var command = new GenerateDatabaseCommand(this.Messaging, null, null, output, databaseFile, this.TableDefinitions, this.IntermediateFolder, codepage: -1, keepAddedColumns: true, suppressAddingValidationRows: true, useSubdirectory: false); + command.Execute(); + } } } diff --git a/src/WixToolset.Core.WindowsInstaller/WindowsInstallerBackendFactory.cs b/src/WixToolset.Core.WindowsInstaller/WindowsInstallerBackendFactory.cs index 173404d7..f9cf4492 100644 --- a/src/WixToolset.Core.WindowsInstaller/WindowsInstallerBackendFactory.cs +++ b/src/WixToolset.Core.WindowsInstaller/WindowsInstallerBackendFactory.cs @@ -1,11 +1,10 @@ -// 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. +// 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.Core.WindowsInstaller { using System; using System.IO; using WixToolset.Extensibility; - using WixToolset.Extensibility.Data; internal class WindowsInstallerBackendFactory : IBackendFactory { @@ -16,7 +15,7 @@ namespace WixToolset.Core.WindowsInstaller outputType = Path.GetExtension(outputFile); } - switch (outputType.ToLowerInvariant()) + switch (outputType?.ToLowerInvariant()) { case "module": case ".msm": diff --git a/src/WixToolset.Core/Bind/FileFacade.cs b/src/WixToolset.Core/Bind/FileFacade.cs index d631a3b5..7bfdb9bb 100644 --- a/src/WixToolset.Core/Bind/FileFacade.cs +++ b/src/WixToolset.Core/Bind/FileFacade.cs @@ -2,32 +2,146 @@ namespace WixToolset.Core.Bind { + using System; using System.Collections.Generic; + using WixToolset.Data; using WixToolset.Data.Tuples; + using WixToolset.Data.WindowsInstaller; + using WixToolset.Data.WindowsInstaller.Rows; public class FileFacade { public FileFacade(FileTuple file, AssemblyTuple assembly) { - this.File = file; - this.Assembly = assembly; + this.FileTuple = file; + this.AssemblyTuple = assembly; } public FileFacade(bool fromModule, FileTuple file) { this.FromModule = fromModule; - this.File = file; + this.FileTuple = file; + } + + internal FileFacade(FileRow row) + { + this.FromTransform = true; + this.FileRow = row; } public bool FromModule { get; } - public FileTuple File { get; } + public bool FromTransform { get; } + + private FileRow FileRow { get; } + + private FileTuple FileTuple { get; } + + private AssemblyTuple AssemblyTuple { get; } + + public string Id => this.FileRow == null ? this.FileTuple.Id.Id : this.FileRow.File; + + public Identifier Identifier => this.FileRow == null ? this.FileTuple.Id : throw new NotImplementedException(); + + public string ComponentRef => this.FileRow == null ? this.FileTuple.ComponentRef : this.FileRow.Component; + + public int DiskId + { + get => this.FileRow == null ? this.FileTuple.DiskId ?? 0 : this.FileRow.DiskId; + set + { + if (this.FileRow == null) + { + this.FileTuple.DiskId = value; + } + else + { + this.FileRow.DiskId = value; + } + } + } + + public string FileName => this.FileRow == null ? this.FileTuple.Name : this.FileRow.FileName; + + public int FileSize + { + get => this.FileRow == null ? this.FileTuple.FileSize : this.FileRow.FileSize; + set + { + if (this.FileRow == null) + { + this.FileTuple.FileSize = value; + } + else + { + this.FileRow.FileSize = value; + } + } + } + + public string Language + { + get => this.FileRow == null ? this.FileTuple.Language : this.FileRow.Language; + set + { + if (this.FileRow == null) + { + this.FileTuple.Language = value; + } + else + { + this.FileRow.Language = value; + } + } + } + + public int? PatchGroup => this.FileRow == null ? this.FileTuple.PatchGroup : null; + + public int Sequence + { + get => this.FileRow == null ? this.FileTuple.Sequence : this.FileRow.Sequence; + set + { + if (this.FileRow == null) + { + this.FileTuple.Sequence = value; + } + else + { + this.FileRow.Sequence = value; + } + } + } + + public SourceLineNumber SourceLineNumber => this.FileRow == null ? this.FileTuple.SourceLineNumbers : this.FileRow.SourceLineNumbers; + + public string SourcePath => this.FileRow == null ? this.FileTuple.Source.Path : this.FileRow.Source; + + public bool Compressed => this.FileRow == null ? (this.FileTuple.Attributes & FileTupleAttributes.Compressed) == FileTupleAttributes.Compressed : (this.FileRow.Attributes & WindowsInstallerConstants.MsidbFileAttributesCompressed) == WindowsInstallerConstants.MsidbFileAttributesCompressed; + + public bool Uncompressed => this.FileRow == null ? (this.FileTuple.Attributes & FileTupleAttributes.Uncompressed) == FileTupleAttributes.Uncompressed : (this.FileRow.Attributes & WindowsInstallerConstants.MsidbFileAttributesNoncompressed) == WindowsInstallerConstants.MsidbFileAttributesNoncompressed; + + public string Version + { + get => this.FileRow == null ? this.FileTuple.Version : this.FileRow.Version; + set + { + if (this.FileRow == null) + { + this.FileTuple.Version = value; + } + else + { + this.FileRow.Version = value; + } + } + } - public AssemblyTuple Assembly { get; } + public AssemblyType? AssemblyType => this.FileRow == null ? this.AssemblyTuple?.Type : throw new NotImplementedException(); - public int DiskId => this.File.DiskId ?? 0; + public string AssemblyApplicationFileRef => this.FileRow == null ? this.AssemblyTuple?.ApplicationFileRef : throw new NotImplementedException(); - public bool Uncompressed => (this.File.Attributes & FileTupleAttributes.Uncompressed) == FileTupleAttributes.Uncompressed; + public string AssemblyManifestFileRef => this.FileRow == null ? this.AssemblyTuple?.ManifestFileRef : throw new NotImplementedException(); /// /// Gets the set of MsiAssemblyName rows created for this file. diff --git a/src/WixToolset.Core/Bind/ResolveFieldsCommand.cs b/src/WixToolset.Core/Bind/ResolveFieldsCommand.cs index 19a26915..5cb2524d 100644 --- a/src/WixToolset.Core/Bind/ResolveFieldsCommand.cs +++ b/src/WixToolset.Core/Bind/ResolveFieldsCommand.cs @@ -89,7 +89,7 @@ namespace WixToolset.Core.Bind { var objectField = field.AsPath(); -#if REVISIT_FOR_PATCHING +#if TODO_PATCHING // Skip file resolution if the file is to be deleted. if (RowOperation.Delete == tuple.Operation) { @@ -111,7 +111,7 @@ namespace WixToolset.Core.Bind { if (!this.BuildingPatch) // Normal binding for non-Patch scenario such as link (light.exe) { -#if REVISIT_FOR_PATCHING +#if TODO_PATCHING // keep a copy of the un-resolved data for future replay. This will be saved into wixpdb file if (null == objectField.UnresolvedData) { @@ -129,7 +129,7 @@ namespace WixToolset.Core.Bind var value = fileResolver.ResolveFile(objectField.Path, tuple.Definition, tuple.SourceLineNumbers, BindStage.Normal); field.Set(value); } -#if REVISIT_FOR_PATCHING +#if TODO_PATCHING else // Re-base binding path scenario caused by pyro.exe -bt -bu { // by default, use the resolved Data for file lookup @@ -158,7 +158,7 @@ namespace WixToolset.Core.Bind } } -#if REVISIT_FOR_PATCHING +#if TODO_PATCHING if (null != objectField.PreviousData) { objectField.PreviousData = this.BindVariableResolver.ResolveVariables(tuple.SourceLineNumbers, objectField.PreviousData, false, out isDefault); diff --git a/src/WixToolset.Core/Compiler.cs b/src/WixToolset.Core/Compiler.cs index 0c3d4c9c..cee64911 100644 --- a/src/WixToolset.Core/Compiler.cs +++ b/src/WixToolset.Core/Compiler.cs @@ -7878,7 +7878,7 @@ namespace WixToolset.Core if (patch) { // /Patch/PatchProperty goes directly into MsiPatchMetadata table - this.Core.AddTuple(new MsiPatchMetadataTuple(sourceLineNumbers) + this.Core.AddTuple(new MsiPatchMetadataTuple(sourceLineNumbers, new Identifier(AccessModifier.Public, company, name)) { Company = company, Property = name, @@ -8130,12 +8130,15 @@ namespace WixToolset.Core /// /// The element to parse. /// Media index from parent element. - private void ParsePatchBaselineElement(XElement node, int diskId) + private void ParsePatchBaselineElement(XElement node, int? diskId) { var sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node); Identifier id = null; var parsedValidate = false; var validationFlags = TransformFlags.PatchTransformDefault; + string baselineFile = null; + string updateFile = null; + string transformFile = null; foreach (var attrib in node.Attributes()) { @@ -8146,6 +8149,18 @@ namespace WixToolset.Core case "Id": id = this.Core.GetAttributeIdentifier(sourceLineNumbers, attrib); break; + case "DiskId": + diskId = this.Core.GetAttributeIntegerValue(sourceLineNumbers, attrib, 1, Int16.MaxValue); + break; + case "BaselineFile": + baselineFile = this.Core.GetAttributeValue(sourceLineNumbers, attrib); + break; + case "UpdateFile": + updateFile = this.Core.GetAttributeValue(sourceLineNumbers, attrib); + break; + case "TransformFile": + transformFile = this.Core.GetAttributeValue(sourceLineNumbers, attrib); + break; default: this.Core.UnexpectedAttribute(node, attrib); break; @@ -8167,6 +8182,28 @@ namespace WixToolset.Core this.Core.Write(ErrorMessages.IdentifierTooLongError(sourceLineNumbers, node.Name.LocalName, "Id", id.Id, 27)); } + if (!String.IsNullOrEmpty(baselineFile) || !String.IsNullOrEmpty(updateFile)) + { + if (String.IsNullOrEmpty(baselineFile)) + { + this.Core.Write(ErrorMessages.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "BaselineFile", "UpdateFile")); + } + + if (String.IsNullOrEmpty(updateFile)) + { + this.Core.Write(ErrorMessages.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "UpdateFile", "BaselineFile")); + } + + if (!String.IsNullOrEmpty(transformFile)) + { + this.Core.Write(ErrorMessages.IllegalAttributeWithOtherAttribute(sourceLineNumbers, node.Name.LocalName, "TransformFile", !String.IsNullOrEmpty(baselineFile) ? "BaselineFile" : "UpdateFile")); + } + } + else if (String.IsNullOrEmpty(transformFile)) + { + this.Core.Write(ErrorMessages.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "BaselineFile", "TransformFile", true)); + } + foreach (var child in node.Elements()) { if (CompilerCore.WixNamespace == child.Name.Namespace) @@ -8200,8 +8237,11 @@ namespace WixToolset.Core { var tuple = new WixPatchBaselineTuple(sourceLineNumbers, id) { - DiskId = diskId, - ValidationFlags = validationFlags + DiskId = diskId ?? 1, + ValidationFlags = validationFlags, + BaselineFile = new IntermediateFieldPathValue { Path = baselineFile }, + UpdateFile = new IntermediateFieldPathValue { Path = updateFile }, + TransformFile = new IntermediateFieldPathValue { Path = transformFile } }; this.Core.AddTuple(tuple); diff --git a/src/WixToolset.Core/Compiler_2.cs b/src/WixToolset.Core/Compiler_2.cs index 4b6839f1..89d4b6da 100644 --- a/src/WixToolset.Core/Compiler_2.cs +++ b/src/WixToolset.Core/Compiler_2.cs @@ -1028,12 +1028,6 @@ namespace WixToolset.Core Value = "0" }); - this.Core.AddTuple(new SummaryInformationTuple(sourceLineNumbers) - { - PropertyId = SumaryInformationType.WindowsInstallerVersion, - Value = msiVersion.ToString(CultureInfo.InvariantCulture) - }); - this.Core.AddTuple(new SummaryInformationTuple(sourceLineNumbers) { PropertyId = SumaryInformationType.Security, diff --git a/src/WixToolset.Core/Compiler_Patch.cs b/src/WixToolset.Core/Compiler_Patch.cs index 42951543..f8d05132 100644 --- a/src/WixToolset.Core/Compiler_Patch.cs +++ b/src/WixToolset.Core/Compiler_Patch.cs @@ -197,9 +197,8 @@ namespace WixToolset.Core if (!this.Core.EncounteredError) { - var tuple = new WixPatchIdTuple(sourceLineNumbers) + var tuple = new WixPatchIdTuple(sourceLineNumbers, new Identifier(AccessModifier.Public, patchId)) { - ProductCode = patchId, ClientPatchId = clientPatchId, OptimizePatchSizeForLargeFiles = optimizePatchSizeForLargeFiles, ApiPatchingSymbolFlags = apiPatchingSymbolFlags diff --git a/src/WixToolset.Core/Compiler_UI.cs b/src/WixToolset.Core/Compiler_UI.cs index 30bb7ab6..8a425fd4 100644 --- a/src/WixToolset.Core/Compiler_UI.cs +++ b/src/WixToolset.Core/Compiler_UI.cs @@ -470,7 +470,7 @@ namespace WixToolset.Core string defaultControl = null; string cancelControl = null; - this.ParseControlElement(child, id.Id, TupleDefinitionType.BBControl, ref lastTabRow, ref firstControl, ref defaultControl, ref cancelControl, false); + this.ParseControlElement(child, id.Id, TupleDefinitionType.BBControl, ref lastTabRow, ref firstControl, ref defaultControl, ref cancelControl); break; default: this.Core.UnexpectedElement(node, child); @@ -966,7 +966,7 @@ namespace WixToolset.Core switch (child.Name.LocalName) { case "Control": - this.ParseControlElement(child, id.Id, TupleDefinitionType.Control, ref lastTabRow, ref firstControl, ref defaultControl, ref cancelControl, trackDiskSpace); + this.ParseControlElement(child, id.Id, TupleDefinitionType.Control, ref lastTabRow, ref firstControl, ref defaultControl, ref cancelControl); break; default: this.Core.UnexpectedElement(node, child); @@ -1032,7 +1032,7 @@ namespace WixToolset.Core /// Name of the default control. /// Name of the candle control. /// True if the containing dialog tracks disk space. - private void ParseControlElement(XElement node, string dialog, TupleDefinitionType tupleType, ref IntermediateTuple lastTabTuple, ref string firstControl, ref string defaultControl, ref string cancelControl, bool trackDiskSpace) + private void ParseControlElement(XElement node, string dialog, TupleDefinitionType tupleType, ref IntermediateTuple lastTabTuple, ref string firstControl, ref string defaultControl, ref string cancelControl) { var sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node); Identifier controlId = null; diff --git a/src/WixToolset.Core/Resolver.cs b/src/WixToolset.Core/Resolver.cs index cbae3742..54bde848 100644 --- a/src/WixToolset.Core/Resolver.cs +++ b/src/WixToolset.Core/Resolver.cs @@ -92,7 +92,7 @@ namespace WixToolset.Core delayedFields = command.DelayedFields; } -#if REVISIT_FOR_PATCHING +#if TODO_PATCHING if (context.IntermediateRepresentation.SubStorages != null) { foreach (SubStorage transform in context.IntermediateRepresentation.SubStorages) diff --git a/src/test/WixToolsetTest.CoreIntegration/PatchFixture.cs b/src/test/WixToolsetTest.CoreIntegration/PatchFixture.cs new file mode 100644 index 00000000..584f86fe --- /dev/null +++ b/src/test/WixToolsetTest.CoreIntegration/PatchFixture.cs @@ -0,0 +1,112 @@ +// 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 WixToolsetTest.CoreIntegration +{ + using System.ComponentModel; + using System.IO; + using System.Linq; + using System.Runtime.InteropServices; + using System.Text; + using System.Xml.Linq; + using WixBuildTools.TestSupport; + using WixToolset.Core.TestPackage; + using Xunit; + + public class PatchFixture + { + private static readonly XNamespace PatchNamespace = "http://www.microsoft.com/msi/patch_applicability.xsd"; + + [Fact(Skip = "Skip until patches have files in them")] + public void CanBuildSimplePatch() + { + var folder = TestData.Get(@"TestData\PatchSingle"); + + using (var fs = new DisposableFileSystem()) + { + var tempFolder = fs.GetFolder(); + + var baselinePdb = BuildMsi("Baseline.msi", folder, tempFolder, "1.0.0", "1.0.0", "1.0.0"); + var update1Pdb = BuildMsi("Update.msi", folder, tempFolder, "1.0.1", "1.0.1", "1.0.1"); + var patchPdb = BuildMsp("Patch1.msp", folder, tempFolder, "1.0.1"); + var baselinePath = Path.ChangeExtension(baselinePdb, ".msp"); + var patchPath = Path.ChangeExtension(patchPdb, ".msp"); + + Assert.True(File.Exists(baselinePdb)); + Assert.True(File.Exists(update1Pdb)); + + var doc = GetExtractPatchXml(patchPath); + Assert.Equal("{7D326855-E790-4A94-8611-5351F8321FCA}", doc.Root.Element(PatchNamespace + "TargetProductCode").Value); + + var names = Query.GetSubStorageNames(patchPath); + Assert.Equal(new[] { "#RTM.1", "RTM.1" }, names); + + var cab = Path.Combine(tempFolder, "foo.cab"); + Query.ExtractStream(patchPath, "foo.cab", cab); + Assert.True(File.Exists(cab)); + + var files = Query.GetCabinetFiles(cab); + Assert.Equal(new[] { "a", "b" }, files.Select(f => f.ArchiveName).ToArray()); // This test may not be quite correct, yet. + } + } + + private static string BuildMsi(string outputName, string sourceFolder, string baseFolder, string defineV, string defineA, string defineB) + { + var outputPath = Path.Combine(baseFolder, Path.Combine("bin", outputName)); + + var result = WixRunner.Execute(new[] + { + "build", + Path.Combine(sourceFolder, @"Package.wxs"), + "-d", "V=" + defineV, + "-d", "A=" + defineA, + "-d", "B=" + defineB, + "-bindpath", Path.Combine(sourceFolder, ".data"), + "-intermediateFolder", Path.Combine(baseFolder, "obj"), + "-o", outputPath + }); + + result.AssertSuccess(); + + return Path.ChangeExtension(outputPath, ".wixpdb"); + } + + private static string BuildMsp(string outputName, string sourceFolder, string baseFolder, string defineV) + { + var outputPath = Path.Combine(baseFolder, Path.Combine("bin", outputName)); + + var result = WixRunner.Execute(new[] + { + "build", + Path.Combine(sourceFolder, @"Patch.wxs"), + "-d", "V=" + defineV, + "-bindpath", Path.Combine(baseFolder, "bin"), + "-intermediateFolder", Path.Combine(baseFolder, "obj"), + "-o", outputPath + }); + + result.AssertSuccess(); + + return Path.ChangeExtension(outputPath, ".wixpdb"); + } + + private static XDocument GetExtractPatchXml(string path) + { + var buffer = new StringBuilder(65535); + var size = buffer.Capacity; + + var er = MsiExtractPatchXMLData(path, 0, buffer, ref size); + if (er != 0) + { + throw new Win32Exception(er); + } + + return XDocument.Parse(buffer.ToString()); + } + + [DllImport("msi.dll", EntryPoint = "MsiExtractPatchXMLDataW", CharSet = CharSet.Unicode, ExactSpelling = true)] + private static extern int MsiExtractPatchXMLData(string szPatchPath, int dwReserved, StringBuilder szXMLData, ref int pcchXMLData); + + [DllImport("msi.dll", EntryPoint = "MsiApplyPatchW", CharSet = CharSet.Unicode, ExactSpelling = true)] + private static extern int MsiApplyPatch(string szPatchPackage, string szInstallPackage, int eInstallType, string szCommandLine); + } +} diff --git a/src/test/WixToolsetTest.CoreIntegration/PreprocessorFixture.cs b/src/test/WixToolsetTest.CoreIntegration/PreprocessorFixture.cs index 4e48cbe1..b1a4c607 100644 --- a/src/test/WixToolsetTest.CoreIntegration/PreprocessorFixture.cs +++ b/src/test/WixToolsetTest.CoreIntegration/PreprocessorFixture.cs @@ -67,34 +67,6 @@ namespace WixToolsetTest.CoreIntegration } } - [Fact] - public void WixVersionVariablesWork() - { - var folder = TestData.Get(@"TestData\Variables"); - - using (var fs = new DisposableFileSystem()) - { - var baseFolder = fs.GetFolder(); - var intermediateFolder = Path.Combine(baseFolder, "obj"); - - var result = WixRunner.Execute(new[] - { - "build", - Path.Combine(folder, "Package.wxs"), - Path.Combine(folder, "PackageComponents.wxs"), - "-loc", Path.Combine(folder, "Package.en-us.wxl"), - "-bindpath", Path.Combine(folder, "data"), - "-intermediateFolder", intermediateFolder, - "-o", Path.Combine(baseFolder, @"bin\test.msi") - }); - - result.AssertSuccess(); - - var warning = result.Messages.Where(message => message.Id == (int)WarningMessages.Ids.PreprocessorWarning); - Assert.Single(warning); - } - } - [Fact] public void ForEachLoopsWork() { diff --git a/src/test/WixToolsetTest.CoreIntegration/TestData/PatchFamilyFilter/.data/Av1.0.0.txt b/src/test/WixToolsetTest.CoreIntegration/TestData/PatchFamilyFilter/.data/Av1.0.0.txt new file mode 100644 index 00000000..6fd385bd --- /dev/null +++ b/src/test/WixToolsetTest.CoreIntegration/TestData/PatchFamilyFilter/.data/Av1.0.0.txt @@ -0,0 +1 @@ +This is A v1.0.0 diff --git a/src/test/WixToolsetTest.CoreIntegration/TestData/PatchFamilyFilter/.data/Av1.0.1.txt b/src/test/WixToolsetTest.CoreIntegration/TestData/PatchFamilyFilter/.data/Av1.0.1.txt new file mode 100644 index 00000000..b1f0bc01 --- /dev/null +++ b/src/test/WixToolsetTest.CoreIntegration/TestData/PatchFamilyFilter/.data/Av1.0.1.txt @@ -0,0 +1 @@ +This ia A v1.0.1 diff --git a/src/test/WixToolsetTest.CoreIntegration/TestData/PatchFamilyFilter/.data/Bv1.0.0.txt b/src/test/WixToolsetTest.CoreIntegration/TestData/PatchFamilyFilter/.data/Bv1.0.0.txt new file mode 100644 index 00000000..ece55fec --- /dev/null +++ b/src/test/WixToolsetTest.CoreIntegration/TestData/PatchFamilyFilter/.data/Bv1.0.0.txt @@ -0,0 +1 @@ +This is B v1.0.0 diff --git a/src/test/WixToolsetTest.CoreIntegration/TestData/PatchFamilyFilter/.data/Bv1.0.1.txt b/src/test/WixToolsetTest.CoreIntegration/TestData/PatchFamilyFilter/.data/Bv1.0.1.txt new file mode 100644 index 00000000..cf3372fd --- /dev/null +++ b/src/test/WixToolsetTest.CoreIntegration/TestData/PatchFamilyFilter/.data/Bv1.0.1.txt @@ -0,0 +1 @@ +This ia B v1.0.1 diff --git a/src/test/WixToolsetTest.CoreIntegration/TestData/PatchFamilyFilter/Package.wxs b/src/test/WixToolsetTest.CoreIntegration/TestData/PatchFamilyFilter/Package.wxs new file mode 100644 index 00000000..2657797f --- /dev/null +++ b/src/test/WixToolsetTest.CoreIntegration/TestData/PatchFamilyFilter/Package.wxs @@ -0,0 +1,31 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/src/test/WixToolsetTest.CoreIntegration/TestData/PatchFamilyFilter/Patch.wxs b/src/test/WixToolsetTest.CoreIntegration/TestData/PatchFamilyFilter/Patch.wxs new file mode 100644 index 00000000..7c3cff7e --- /dev/null +++ b/src/test/WixToolsetTest.CoreIntegration/TestData/PatchFamilyFilter/Patch.wxs @@ -0,0 +1,23 @@ + + + + + + + + + + + + + + + + diff --git a/src/test/WixToolsetTest.CoreIntegration/TestData/PatchSingle/.data/Av1.0.0.txt b/src/test/WixToolsetTest.CoreIntegration/TestData/PatchSingle/.data/Av1.0.0.txt new file mode 100644 index 00000000..6fd385bd --- /dev/null +++ b/src/test/WixToolsetTest.CoreIntegration/TestData/PatchSingle/.data/Av1.0.0.txt @@ -0,0 +1 @@ +This is A v1.0.0 diff --git a/src/test/WixToolsetTest.CoreIntegration/TestData/PatchSingle/.data/Av1.0.1.txt b/src/test/WixToolsetTest.CoreIntegration/TestData/PatchSingle/.data/Av1.0.1.txt new file mode 100644 index 00000000..b1f0bc01 --- /dev/null +++ b/src/test/WixToolsetTest.CoreIntegration/TestData/PatchSingle/.data/Av1.0.1.txt @@ -0,0 +1 @@ +This ia A v1.0.1 diff --git a/src/test/WixToolsetTest.CoreIntegration/TestData/PatchSingle/.data/Bv1.0.0.txt b/src/test/WixToolsetTest.CoreIntegration/TestData/PatchSingle/.data/Bv1.0.0.txt new file mode 100644 index 00000000..ece55fec --- /dev/null +++ b/src/test/WixToolsetTest.CoreIntegration/TestData/PatchSingle/.data/Bv1.0.0.txt @@ -0,0 +1 @@ +This is B v1.0.0 diff --git a/src/test/WixToolsetTest.CoreIntegration/TestData/PatchSingle/.data/Bv1.0.1.txt b/src/test/WixToolsetTest.CoreIntegration/TestData/PatchSingle/.data/Bv1.0.1.txt new file mode 100644 index 00000000..cf3372fd --- /dev/null +++ b/src/test/WixToolsetTest.CoreIntegration/TestData/PatchSingle/.data/Bv1.0.1.txt @@ -0,0 +1 @@ +This ia B v1.0.1 diff --git a/src/test/WixToolsetTest.CoreIntegration/TestData/PatchSingle/Package.wxs b/src/test/WixToolsetTest.CoreIntegration/TestData/PatchSingle/Package.wxs new file mode 100644 index 00000000..ee133ba3 --- /dev/null +++ b/src/test/WixToolsetTest.CoreIntegration/TestData/PatchSingle/Package.wxs @@ -0,0 +1,31 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/src/test/WixToolsetTest.CoreIntegration/TestData/PatchSingle/Patch.wxs b/src/test/WixToolsetTest.CoreIntegration/TestData/PatchSingle/Patch.wxs new file mode 100644 index 00000000..52e87f64 --- /dev/null +++ b/src/test/WixToolsetTest.CoreIntegration/TestData/PatchSingle/Patch.wxs @@ -0,0 +1,16 @@ + + + + + + + + + + diff --git a/src/test/WixToolsetTest.CoreIntegration/WixToolsetTest.CoreIntegration.csproj b/src/test/WixToolsetTest.CoreIntegration/WixToolsetTest.CoreIntegration.csproj index 0330adf6..b17a27ff 100644 --- a/src/test/WixToolsetTest.CoreIntegration/WixToolsetTest.CoreIntegration.csproj +++ b/src/test/WixToolsetTest.CoreIntegration/WixToolsetTest.CoreIntegration.csproj @@ -1,4 +1,4 @@ - + @@ -41,6 +41,18 @@ + + + + + + + + + + + + -- cgit v1.2.3-55-g6feb