Merge pull request #549 from github-for-unity/enhancements/unzip-task

Creating a ZipHelper singleton and UnzipTask

Author: StanleyGoldman

src/GitHub.Api/GitHub.Api.csproj

@@ -117,6 +117,7 @@
     <Compile Include="Application\ApplicationManagerBase.cs" />
     <Compile Include="Helpers\Constants.cs" />
     <Compile Include="Helpers\Validation.cs" />
+    <Compile Include="Installer\UnzipTask.cs" />
     <Compile Include="OutputProcessors\GitAheadBehindStatusOutputProcessor.cs" />
     <Compile Include="OutputProcessors\LfsVersionOutputProcessor.cs" />
     <Compile Include="OutputProcessors\VersionOutputProcessor.cs" />

src/GitHub.Api/Installer/GitInstaller.cs

@@ -18,28 +18,22 @@ class GitInstaller : IGitInstaller
         private readonly CancellationToken cancellationToken;
         private readonly IEnvironment environment;
         private readonly ILogging logger;
-
-        private delegate void ExtractZipFile(string archive, string outFolder, CancellationToken cancellationToken,
-            IProgress<float> zipFileProgress = null, IProgress<long> estimatedDurationProgress = null);
-        private ExtractZipFile extractCallback;
+        private readonly IZipHelper zipHelper;
 
         public GitInstaller(IEnvironment environment, CancellationToken cancellationToken)
-            : this(environment, null, cancellationToken)
+            : this(environment, ZipHelper.Instance, cancellationToken)
         {
         }
 
-        public GitInstaller(IEnvironment environment, IZipHelper sharpZipLibHelper, CancellationToken cancellationToken)
+        public GitInstaller(IEnvironment environment, IZipHelper zipHelper, CancellationToken cancellationToken)
         {
             Guard.ArgumentNotNull(environment, nameof(environment));
 
             logger = Logging.GetLogger(GetType());
             this.cancellationToken = cancellationToken;
 
             this.environment = environment;
-            this.extractCallback = sharpZipLibHelper != null
-                 ? (ExtractZipFile)sharpZipLibHelper.Extract
-                 : ZipHelper.ExtractZipFile;
-
+            this.zipHelper = zipHelper;
 
             GitInstallationPath = environment.GetSpecialFolder(Environment.SpecialFolder.LocalApplicationData)
                 .ToNPath().Combine(ApplicationInfo.ApplicationName, PackageNameWithVersion);
@@ -184,7 +178,7 @@ public Task<bool> SetupGitIfNeeded(NPath tempPath, IProgress<float> zipFileProgr
             {
                 logger.Trace("Extracting \"{0}\" to \"{1}\"", archiveFilePath, unzipPath);
 
-                extractCallback(archiveFilePath, unzipPath, cancellationToken, zipFileProgress,
+                zipHelper.Extract(archiveFilePath, unzipPath, cancellationToken, zipFileProgress,
                     estimatedDurationProgress);
             }
             catch (Exception ex)
@@ -249,7 +243,7 @@ public Task<bool> SetupGitLfsIfNeeded(NPath tempPath, IProgress<float> zipFilePr
             {
                 logger.Trace("Extracting \"{0}\" to \"{1}\"", archiveFilePath, unzipPath);
 
-                extractCallback(archiveFilePath, unzipPath, cancellationToken, zipFileProgress,
+                zipHelper.Extract(archiveFilePath, unzipPath, cancellationToken, zipFileProgress,
                     estimatedDurationProgress);
             }
             catch (Exception ex)

src/GitHub.Api/Installer/UnzipTask.cs

@@ -0,0 +1,48 @@
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace GitHub.Unity
+{
+    class UnzipTask: TaskBase
+    {
+        private readonly string archiveFilePath;
+        private readonly string extractedPath;
+        private readonly IZipHelper zipHelper;
+        private readonly IProgress<float> zipFileProgress;
+        private readonly IProgress<long> estimatedDurationProgress;
+
+        public UnzipTask(CancellationToken token, string archiveFilePath, string extractedPath,
+            IProgress<float> zipFileProgress = null, IProgress<long> estimatedDurationProgress = null) :
+            this(token, archiveFilePath, extractedPath, ZipHelper.Instance, zipFileProgress, estimatedDurationProgress)
+        {
+            
+        }
+
+        public UnzipTask(CancellationToken token, string archiveFilePath, string extractedPath, IZipHelper zipHelper, IProgress<float> zipFileProgress = null, IProgress<long> estimatedDurationProgress = null)
+            : base(token)
+        {
+            this.archiveFilePath = archiveFilePath;
+            this.extractedPath = extractedPath;
+            this.zipHelper = zipHelper;
+            this.zipFileProgress = zipFileProgress;
+            this.estimatedDurationProgress = estimatedDurationProgress;
+        }
+
+        protected override void Run(bool success)
+        {
+            base.Run(success);
+
+            UnzipArchive();
+        }
+
+        private void UnzipArchive()
+        {
+            Logger.Trace("Unzip File: {0} to Path: {1}", archiveFilePath, extractedPath);
+
+            zipHelper.Extract(archiveFilePath, extractedPath, Token, zipFileProgress, estimatedDurationProgress);
+
+            Logger.Trace("Completed Unzip");
+        }
+    }
+}

src/GitHub.Api/Installer/ZipHelper.cs

@@ -8,6 +8,21 @@ namespace GitHub.Unity
 {
     class ZipHelper : IZipHelper
     {
+        private static IZipHelper instance;
+
+        public static IZipHelper Instance
+        {
+            get
+            {
+                if (instance == null)
+                {
+                    instance = new ZipHelper();
+                }
+
+                return instance;
+            }
+        }
+
         public static bool Copy(Stream source, Stream destination, int chunkSize, long totalSize,
             Func<long, long, bool> progress, int progressUpdateRate)
         {

src/tests/IntegrationTests/IntegrationTests.csproj

@@ -88,6 +88,7 @@
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="SetUpFixture.cs" />
     <Compile Include="ThreadSynchronizationContext.cs" />
+    <Compile Include="UnzipTaskTests.cs" />
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="$(SolutionDir)src\GitHub.Api\GitHub.Api.csproj">

src/tests/IntegrationTests/UnzipTaskTests.cs

@@ -0,0 +1,45 @@
+using System.Threading;
+using System.Threading.Tasks;
+using GitHub.Unity;
+using Microsoft.Win32.SafeHandles;
+using NSubstitute;
+using NUnit.Framework;
+using Rackspace.Threading;
+
+namespace IntegrationTests
+{
+    [TestFixture]
+    class UnzipTaskTests : BaseTaskManagerTest
+    {
+        [Test]
+        public void UnzipTest()
+        {
+            InitializeTaskManager();
+
+            var cacheContainer = Substitute.For<ICacheContainer>();
+            Environment = new IntegrationTestEnvironment(cacheContainer, TestBasePath, SolutionDirectory);
+
+            var destinationPath = TestBasePath.Combine("git_zip").CreateDirectory();
+            var archiveFilePath = AssemblyResources.ToFile(ResourceType.Platform, "git.zip", destinationPath, Environment);
+
+            Logger.Trace("ArchiveFilePath: {0}", archiveFilePath);
+            Logger.Trace("TestBasePath: {0}", TestBasePath);
+
+            var extractedPath = TestBasePath.Combine("git_zip_extracted").CreateDirectory();
+
+            var zipProgress = 0;
+            Logger.Trace("Pct Complete {0}%", zipProgress);
+            var unzipTask = new UnzipTask(CancellationToken.None, archiveFilePath, extractedPath, 
+                new Progress<float>(zipFileProgress => {
+                    var zipFileProgressInteger = (int) (zipFileProgress * 100);
+                    if (zipProgress != zipFileProgressInteger)
+                    {
+                        zipProgress = zipFileProgressInteger;
+                        Logger.Trace("Pct Complete {0}%", zipProgress);
+                    }
+                }));
+
+            unzipTask.Start().Wait();
+        }
+    }
+}