Massive refactoring to introduce the concept of IBackend

1 files changed, 122 insertions, 0 deletions

diff --git a/src/WixToolset.Core.WindowsInstaller/Bind/CabinetResolver.cs b/src/WixToolset.Core.WindowsInstaller/Bind/CabinetResolver.cs
new file mode 100644
index 00000000..df1ccecf
--- /dev/null
+++ b/src/WixToolset.Core.WindowsInstaller/Bind/CabinetResolver.cs
@@ -0,0 +1,122 @@
+// 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.Cab;
+    using WixToolset.Core.Bind;
+    using WixToolset.Data;
+    using WixToolset.Extensibility;
+
+    public class CabinetResolver
+    {
+        public CabinetResolver(string cabCachePath, IEnumerable<IWindowsInstallerBackendExtension> backendExtensions)
+        {
+            this.CabCachePath = cabCachePath;
+
+            this.BackendExtensions = backendExtensions;
+        }
+
+        private string CabCachePath { get; }
+
+        private IEnumerable<IWindowsInstallerBackendExtension> BackendExtensions { get; }
+
+        public ResolvedCabinet ResolveCabinet(string cabinetPath, IEnumerable<FileFacade> fileFacades)
+        {
+            var filesWithPath = fileFacades.Select(f => new BindFileWithPath() { Id = f.File.File, Path = f.WixFile.Source }).ToList();
+
+            ResolvedCabinet resolved = null;
+
+            foreach (var extension in this.BackendExtensions)
+            {
+                resolved = extension.ResolveCabinet(cabinetPath, filesWithPath);
+
+                if (null != resolved)
+                {
+                    return resolved;
+                }
+            }
+
+            // By default cabinet should be built and moved to the suggested location.
+            resolved = new ResolvedCabinet() { BuildOption = CabinetBuildOption.BuildAndMove, Path = cabinetPath };
+
+            // If a cabinet cache path was provided, change the location for the cabinet
+            // to be built to and check if there is a cabinet that can be reused.
+            if (!String.IsNullOrEmpty(this.CabCachePath))
+            {
+                string cabinetName = Path.GetFileName(cabinetPath);
+                resolved.Path = Path.Combine(this.CabCachePath, cabinetName);
+
+                if (CheckFileExists(resolved.Path))
+                {
+                    // Assume that none of the following are true:
+                    // 1. any files are added or removed
+                    // 2. order of files changed or names changed
+                    // 3. modified time changed
+                    bool cabinetValid = true;
+
+                    // Need to force garbage collection of WixEnumerateCab to ensure the handle
+                    // associated with it is closed before it is reused.
+                    using (var wixEnumerateCab = new WixEnumerateCab())
+                    {
+                        List<CabinetFileInfo> fileList = wixEnumerateCab.Enumerate(resolved.Path);
+
+                        if (filesWithPath.Count() != fileList.Count)
+                        {
+                            cabinetValid = false;
+                        }
+                        else
+                        {
+                            int i = 0;
+                            foreach (BindFileWithPath file in filesWithPath)
+                            {
+                                // First check that the file identifiers match because that is quick and easy.
+                                CabinetFileInfo cabFileInfo = fileList[i];
+                                cabinetValid = (cabFileInfo.FileId == file.Id);
+                                if (cabinetValid)
+                                {
+                                    // Still valid so ensure the file sizes are the same.
+                                    FileInfo fileInfo = new FileInfo(file.Path);
+                                    cabinetValid = (cabFileInfo.Size == fileInfo.Length);
+                                    if (cabinetValid)
+                                    {
+                                        // Still valid so ensure the source time stamp hasn't changed. Thus we need
+                                        // to convert the source file time stamp into a cabinet compatible data/time.
+                                        Native.CabInterop.DateTimeToCabDateAndTime(fileInfo.LastWriteTime, out var sourceCabDate, out var sourceCabTime);
+                                        cabinetValid = (cabFileInfo.Date == sourceCabDate && cabFileInfo.Time == sourceCabTime);
+                                    }
+                                }
+
+                                if (!cabinetValid)
+                                {
+                                    break;
+                                }
+
+                                i++;
+                            }
+                        }
+                    }
+
+                    resolved.BuildOption = cabinetValid ? CabinetBuildOption.Copy : CabinetBuildOption.BuildAndCopy;
+                }
+            }
+
+            return resolved;
+        }
+
+        private static bool CheckFileExists(string path)
+        {
+            try
+            {
+                return File.Exists(path);
+            }
+            catch (ArgumentException)
+            {
+                throw new WixException(WixErrors.IllegalCharactersInPath(path));
+            }
+        }
+    }
+}