Merge pull request #634 from github-for-unity/releases/0.30

0.30 beta 1 release

Author: shana

common/SolutionInfo.cs

@@ -31,6 +31,6 @@
 namespace System
 {
     internal static class AssemblyVersionInformation {
-        internal const string Version = "0.30.0";
+        internal const string Version = "0.30.3";
     }
 }

common/properties.props

@@ -3,6 +3,7 @@
   <!-- Build flags -->
   <PropertyGroup>
     <BuildType Condition="Exists('$(SolutionDir)script\src\MetricsService.cs')">Internal</BuildType>
+    <BuildDefs Condition="Exists('$(SolutionDir)script\src\MetricsService.cs')">ENABLE_METRICS</BuildDefs>
 
     <UnityDir Condition="$(UnityDir) == '' and Exists('$(SolutionDir)\script\lib\UnityEditor.dll')">$(SolutionDir)\script\lib\</UnityDir>
     <UnityDir Condition="$(UnityDir) == '' and Exists('$(SolutionDir)\lib\UnityEditor.dll')">$(SolutionDir)\lib\</UnityDir>

src/GitHub.Api/Application/ApplicationInfo.cs

@@ -4,7 +4,7 @@ namespace GitHub.Unity
     static partial class ApplicationInfo
     {
 #if DEBUG
-        public const string ApplicationName = "GitHubUnityDebug";
+        public const string ApplicationName = "GitHub for Unity Debug";
         public const string ApplicationProvider = "GitHub";
 #else
         public const string ApplicationName = "GitHubUnity";

src/GitHub.Api/Application/ApplicationManagerBase.cs

@@ -54,48 +54,52 @@ public void Run(bool firstRun)
         {
             Logger.Trace("Run - CurrentDirectory {0}", NPath.CurrentDirectory);
 
-            isBusy = true;
+            var initEnvironmentTask = new ActionTask<NPath>(CancellationToken,
+                    (_, path) => InitializeEnvironment(path))
+                { Affinity = TaskAffinity.UI };
 
-            var gitExecutablePath = SystemSettings.Get(Constants.GitInstallPathKey)?.ToNPath();
-            if (gitExecutablePath.HasValue && gitExecutablePath.Value.FileExists()) // we have a git path
-            {
-                Logger.Trace("Using git install path from settings: {0}", gitExecutablePath);
-                InitializeEnvironment(gitExecutablePath.Value);
-            }
-            else // we need to go find git
-            {
-                Logger.Trace("No git path found in settings");
+            isBusy = true;
 
-                var initEnvironmentTask = new ActionTask<NPath>(CancellationToken,
-                    (b, path) => InitializeEnvironment(path)) { Affinity = TaskAffinity.UI };
-                var findExecTask = new FindExecTask("git", CancellationToken)
-                    .FinallyInUI((b, ex, path) =>
+            var octorunInstaller = new OctorunInstaller(Environment, TaskManager);
+            var setupTask = octorunInstaller
+                .SetupOctorunIfNeeded()
+                .Then((s, octorunPath) =>
                     {
-                        if (b && path.IsInitialized)
-                        {
-                            //Logger.Trace("FindExecTask Success: {0}", path);
-                            InitializeEnvironment(path);
-                        }
-                        else
-                        {
-                            //Logger.Warning("FindExecTask Failure");
-                            Logger.Error("Git not found");
-                        }
+                        Environment.OctorunScriptPath = octorunPath;
                     });
 
-                var gitInstaller = new GitInstaller(Environment, CancellationToken);
+            var initializeGitTask = new FuncTask<NPath>(CancellationToken, () =>
+                {
+                    var gitExecutablePath = SystemSettings.Get(Constants.GitInstallPathKey)?.ToNPath();
+                    if (gitExecutablePath.HasValue && gitExecutablePath.Value.FileExists()) // we have a git path
+                    {
+                        Logger.Trace("Using git install path from settings: {0}", gitExecutablePath);
+                        return gitExecutablePath.Value;
+                    }
+                    return NPath.Default;
+                });
 
-                // if successful, continue with environment initialization, otherwise try to find an existing git installation
-                var setupTask = gitInstaller.SetupGitIfNeeded();
-                setupTask.Progress(progressReporter.UpdateProgress);
-                setupTask.OnEnd += (thisTask, result, success, exception) =>
+            initializeGitTask.OnEnd += (t, path, _, __) =>
                 {
-                    if (success && result.IsInitialized)
-                        thisTask.Then(initEnvironmentTask);
-                    else
-                        thisTask.Then(findExecTask);
+                    if (path.IsInitialized)
+                        return;
+
+                    Logger.Trace("Using portable git");
+
+                    var gitInstaller = new GitInstaller(Environment, ProcessManager, TaskManager);
+
+                    var task = gitInstaller.SetupGitIfNeeded();
+                    task.Progress(progressReporter.UpdateProgress);
+                    task.OnEnd += (thisTask, result, success, exception) =>
+                    {
+                        thisTask.GetEndOfChain().Then(initEnvironmentTask, taskIsTopOfChain: true);
+                    };
+
+                    // append installer task to top chain
+                    t.Then(task, taskIsTopOfChain: true);
                 };
-            }
+
+            setupTask.Then(initializeGitTask).Start();
         }
 
         public ITask InitializeRepository()
@@ -170,6 +174,7 @@ protected void SetupMetrics(string unityVersion, bool firstRun)
                 UserSettings.Set(Constants.GuidKey, id);
             }
 
+#if ENABLE_METRICS
             var metricsService = new MetricsService(ProcessManager,
                 TaskManager,
                 Environment.FileSystem,
@@ -182,6 +187,7 @@ protected void SetupMetrics(string unityVersion, bool firstRun)
             {
                 UsageTracker.IncrementLaunchCount();
             }
+#endif
         }
 
         protected abstract void SetupMetrics();
@@ -195,13 +201,20 @@ protected void SetupMetrics(string unityVersion, bool firstRun)
         /// <param name="octorunScriptPath"></param>
         private void InitializeEnvironment(NPath gitExecutablePath)
         {
+            SetupMetrics();
+
+            if (!gitExecutablePath.IsInitialized)
+            {
+                isBusy = false;
+                return;
+            }
+
             Environment.GitExecutablePath = gitExecutablePath;
             Environment.User.Initialize(GitClient);
 
             var afterGitSetup = new ActionTask(CancellationToken, RestartRepository)
                 .ThenInUI(InitializeUI);
 
-            SetupMetrics();
             ITask task = afterGitSetup;
             if (Environment.IsWindows)
             {

src/GitHub.Api/GitHub.Api.csproj

@@ -22,7 +22,7 @@
     <DebugSymbols>true</DebugSymbols>
     <DebugType>full</DebugType>
     <Optimize>false</Optimize>
-    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <DefineConstants>DEBUG;TRACE;$(BuildDefs)</DefineConstants>
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>4</WarningLevel>
     <RunCodeAnalysis>true</RunCodeAnalysis>
@@ -32,7 +32,7 @@
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
     <DebugType>pdbonly</DebugType>
     <Optimize>true</Optimize>
-    <DefineConstants>TRACE</DefineConstants>
+    <DefineConstants>TRACE;$(BuildDefs)</DefineConstants>
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>4</WarningLevel>
     <BuildConfid>Release</BuildConfid>
@@ -44,7 +44,7 @@
     <DebugSymbols>true</DebugSymbols>
     <DebugType>full</DebugType>
     <Optimize>false</Optimize>
-    <DefineConstants>TRACE;DEBUG;DEVELOPER_BUILD</DefineConstants>
+    <DefineConstants>TRACE;DEBUG;DEVELOPER_BUILD;$(BuildDefs)</DefineConstants>
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>4</WarningLevel>
     <RunCodeAnalysis>false</RunCodeAnalysis>

src/GitHub.Api/Helpers/AssemblyResources.cs

@@ -33,7 +33,7 @@ public static NPath ToFile(ResourceType resourceType, string resource, NPath des
             if (stream != null)
                 return destinationPath.Combine(resource).WriteAllBytes(stream.ToByteArray());
 
-            return environment.ExtensionInstallPath.Combine(type, os, resource);
+            return environment.ExtensionInstallPath.Combine(type, os, resource).Copy(destinationPath.Combine(resource));
         }
     }
 }

src/GitHub.Api/Installer/GitInstaller.cs

@@ -1,6 +1,5 @@
 using System;
 using System.Threading;
-using System.Threading.Tasks;
 using GitHub.Logging;
 
 namespace GitHub.Unity
@@ -11,59 +10,75 @@ class GitInstaller
         private readonly CancellationToken cancellationToken;
 
         private readonly IEnvironment environment;
+        private readonly IProcessManager processManager;
         private readonly GitInstallDetails installDetails;
         private readonly IZipHelper sharpZipLibHelper;
 
+        GitInstallationState installationState;
         ITask<NPath> installationTask;
 
-        public GitInstaller(IEnvironment environment, CancellationToken cancellationToken,
+        public GitInstaller(IEnvironment environment, IProcessManager processManager,
+            ITaskManager taskManager,
             GitInstallDetails installDetails = null)
         {
             this.environment = environment;
+            this.processManager = processManager;
             this.sharpZipLibHelper = ZipHelper.Instance;
-            this.cancellationToken = cancellationToken;
+            this.cancellationToken = taskManager.Token;
             this.installDetails = installDetails ?? new GitInstallDetails(environment.UserCachePath, environment.IsWindows);
         }
 
         public ITask<NPath> SetupGitIfNeeded()
         {
             //Logger.Trace("SetupGitIfNeeded");
 
-            installationTask = new FuncTask<GitInstallationState, NPath>(cancellationToken, (_, r) => installDetails.GitExecutablePath)
+            installationTask = new FuncTask<NPath, NPath>(cancellationToken, (success, path) =>
+                    {
+                        return path;
+                    })
                 { Name = "Git Installation - Complete" };
             installationTask.OnStart += thisTask => thisTask.UpdateProgress(0, 100);
             installationTask.OnEnd += (thisTask, result, success, exception) => thisTask.UpdateProgress(100, 100);
 
+            ITask<NPath> startTask = null;
             if (!environment.IsWindows)
-                return installationTask;
-
-            var startTask = new FuncTask<GitInstallationState>(cancellationToken, () =>
+            {
+                startTask = new FindExecTask("git", cancellationToken)
+                    .Configure(processManager);
+                // we should doublecheck that system git is usable here
+                installationState = new GitInstallationState
                 {
-                    var state = VerifyGitInstallation();
-                    if (!state.GitIsValid && !state.GitLfsIsValid)
-                        state = GrabZipFromResources(state);
-                    else
-                        Logger.Trace("SetupGitIfNeeded: Skipped");
-                    return state;
-                })
+                    GitIsValid = true,
+                    GitLfsIsValid = true
+                };
+            }
+            else
+            {
+                startTask = new FuncTask<NPath>(cancellationToken, () =>
+                    {
+                        installationState = VerifyGitInstallation();
+                        if (!installationState.GitIsValid && !installationState.GitLfsIsValid)
+                            installationState = GrabZipFromResources(installationState);
+                        else
+                            Logger.Trace("SetupGitIfNeeded: Skipped");
+                        return installDetails.GitExecutablePath;
+                    })
                 { Name = "Git Installation - Extract" };
 
+            }
 
-            startTask.OnEnd += (thisTask, state, success, exception) =>
+            startTask.OnEnd += (thisTask, path, success, exception) =>
             {
-                if (!state.GitIsValid && !state.GitLfsIsValid)
+                if (!installationState.GitIsValid && !installationState.GitLfsIsValid)
                 {
-                    if (!state.GitZipExists || !state.GitLfsZipExists)
-                        thisTask = thisTask.Then(CreateDownloadTask(state));
-                    thisTask = thisTask.Then(ExtractPortableGit(state));
+                    if (!installationState.GitZipExists || !installationState.GitLfsZipExists)
+                        thisTask = thisTask.Then(CreateDownloadTask(installationState));
+                    thisTask = thisTask.Then(ExtractPortableGit(installationState));
                 }
                 thisTask.Then(installationTask);
             };
 
-            // we want to start the startTask and not the installationTask because the latter only gets
-            // appended to the task chain when startTask ends, so calling Start() on it wouldn't work
-            startTask.Start();
-            return installationTask;
+            return startTask;
         }
 
         private GitInstallationState VerifyGitInstallation()
@@ -123,7 +138,7 @@ private GitInstallationState GrabZipFromResources(GitInstallationState state)
             return state;
         }
 
-        private ITask<GitInstallationState> CreateDownloadTask(GitInstallationState state)
+        private ITask<NPath> CreateDownloadTask(GitInstallationState state)
         {
             var downloader = new Downloader();
             downloader.QueueDownload(installDetails.GitZipUrl, installDetails.GitZipMd5Url, installDetails.ZipPath);
@@ -133,11 +148,11 @@ private ITask<GitInstallationState> CreateDownloadTask(GitInstallationState stat
                 state.GitZipExists = installDetails.GitZipPath.FileExists();
                 state.GitLfsZipExists = installDetails.GitLfsZipPath.FileExists();
                 installationTask.UpdateProgress(40, 100);
-                return state;
+                return installDetails.ZipPath;
             });
         }
 
-        private FuncTask<GitInstallationState> ExtractPortableGit(GitInstallationState state)
+        private FuncTask<NPath> ExtractPortableGit(GitInstallationState state)
         {
             ITask<NPath> task = null;
             var tempZipExtractPath = NPath.CreateTempDirectory("git_zip_extract_zip_paths");
@@ -146,7 +161,7 @@ private FuncTask<GitInstallationState> ExtractPortableGit(GitInstallationState s
             if (!state.GitIsValid)
             {
                 ITask<NPath> unzipTask = new UnzipTask(cancellationToken, installDetails.GitZipPath, gitExtractPath, sharpZipLibHelper,
-                    environment.FileSystem, GitInstallDetails.GitExtractedMD5);
+                    environment.FileSystem);
                 unzipTask.Progress(p => installationTask.UpdateProgress(40 + (long)(20 * p.Percentage), 100, unzipTask.Name));
 
                 unzipTask = unzipTask.Then((s, path) =>
@@ -169,7 +184,7 @@ private FuncTask<GitInstallationState> ExtractPortableGit(GitInstallationState s
             if (!state.GitLfsIsValid)
             {
                 ITask<NPath> unzipTask = new UnzipTask(cancellationToken, installDetails.GitLfsZipPath, gitLfsExtractPath, sharpZipLibHelper,
-                    environment.FileSystem, GitInstallDetails.GitLfsExtractedMD5);
+                    environment.FileSystem);
                 unzipTask.Progress(p => installationTask.UpdateProgress(60 + (long)(20 * p.Percentage), 100, unzipTask.Name));
 
                 unzipTask = unzipTask.Then((s, path) =>
@@ -187,10 +202,10 @@ private FuncTask<GitInstallationState> ExtractPortableGit(GitInstallationState s
                 task = task?.Then(unzipTask) ?? unzipTask;
             }
 
-            return task.Finally(new FuncTask<GitInstallationState>(cancellationToken, (success) =>
+            return task.Finally(new FuncTask<NPath>(cancellationToken, (success) =>
             {
                 tempZipExtractPath.DeleteIfExists();
-                return state;
+                return installDetails.GitInstallationPath;
             }));
         }
 

src/GitHub.Api/Installer/IZipHelper.cs

@@ -6,6 +6,6 @@ namespace GitHub.Unity
     interface IZipHelper
     {
         bool Extract(string archive, string outFolder, CancellationToken cancellationToken,
-            Func<long, long, bool> onProgress = null);
+            Func<long, long, bool> onProgress);
     }
 }