public GitInstallationState VerifyGitSettings(GitInstallationState state = null)
{
UpdateTask("Verifying git settings", 100);
try
{
state = state ?? new GitInstallationState(environment);
if (!state.GitExecutablePath.IsInitialized)
{
return(state);
}
state = ValidateGitVersion(state);
if (state.GitIsValid)
{
state.GitInstallationPath = state.GitExecutablePath.Parent.Parent;
}
state = ValidateGitLfsVersion(state);
if (state.GitLfsIsValid && state.GitInstallationPath != installDetails.GitInstallationPath)
{
state.GitLfsInstallationPath = state.GitLfsExecutablePath.Parent;
}
return(state);
}
finally
{
UpdateTask("Verifying git settings", 100);
}
}
private GitInstallationState GetZipsIfNeeded(GitInstallationState state)
{
if (state.GitZipExists || state.GitPackage == null)
{
return(state);
}
var asset = state.GitPackage.DugitePackage;
var downloader = new Downloader(environment.FileSystem);
downloader.QueueDownload(asset.Url, installDetails.ZipPath, asset.Name);
downloader
.Progress(progressReporter.UpdateProgress)
.Catch(e =>
{
LogHelper.Trace(e, "Failed to download");
return(true);
});
downloader.RunSynchronously();
state.GitZipExists = state.GitZipPath.IsInitialized && state.GitZipPath.FileExists();
return(state);
}
private GitInstallationState VerifyZipFiles(GitInstallationState state)
{
UpdateTask("Verifying package files", 100);
try
{
if (state.GitIsValid || state.GitPackage == null)
{
return(state);
}
var asset = state.GitPackage.DugitePackage;
state.GitZipPath = installDetails.ZipPath.Combine(asset.Name);
state.GitZipExists = state.GitZipPath.FileExists();
if (!Utils.VerifyFileIntegrity(state.GitZipPath, asset.Hash))
{
state.GitZipPath.DeleteIfExists();
}
state.GitZipExists = state.GitZipPath.FileExists();
return(state);
}
finally
{
UpdateTask("Verifying package files", 100);
}
}
private GitInstallationState ExtractGit(GitInstallationState state)
{
var tempZipExtractPath = NPath.CreateTempDirectory("ghu_extract_git");
if (state.GitZipExists && !state.GitIsValid)
{
var gitExtractPath = tempZipExtractPath.Combine("git").CreateDirectory();
var unzipTask = new UnzipTask(cancellationToken, state.GitZipPath,
gitExtractPath, sharpZipLibHelper,
environment.FileSystem)
.Progress(progressReporter.UpdateProgress)
.Catch(e =>
{
LogHelper.Trace(e, "Failed to unzip " + state.GitZipPath);
return(true);
});
unzipTask.RunSynchronously();
var target = state.GitInstallationPath;
if (unzipTask.Successful)
{
Logger.Trace("Moving Git source:{0} target:{1}", gitExtractPath.ToString(), target.ToString());
CopyHelper.Copy(gitExtractPath, target);
state.GitIsValid = true;
state.IsCustomGitPath = state.GitExecutablePath != installDetails.GitExecutablePath;
}
}
tempZipExtractPath.DeleteIfExists();
return(state);
}
public GitInstallationState GetZipsIfNeeded(GitInstallationState state)
{
if (state.GitZipExists)
{
return(state);
}
var downloader = new Downloader(environment.FileSystem);
downloader.Catch(e => {
LogHelper.Trace(e, "Failed to download");
return(true);
});
downloader.Progress(progressReporter.UpdateProgress);
var asset = state.GitReleaseManifest.DugitePackage;
if (!state.GitZipExists && !state.GitIsValid && state.GitReleaseManifest != null)
{
downloader.QueueDownload(asset.Url, installDetails.ZipPath, asset.Name);
}
downloader.RunSynchronously();
state.GitZipExists = installDetails.GitZipPath.FileExists();
return(state);
}
private GitInstallationState GetZipsIfNeeded(GitInstallationState state)
{
if (state.GitZipExists && state.GitLfsZipExists)
{
return(state);
}
var downloader = new Downloader(environment.FileSystem);
downloader.Catch(e =>
{
LogHelper.Trace(e, "Failed to download");
return(true);
});
downloader.Progress(p => Progress.UpdateProgress(20 + (long)(20 * p.Percentage), 100, downloader.Message));
if (!state.GitZipExists && !state.GitIsValid && state.GitPackage != null)
{
downloader.QueueDownload(state.GitPackage.Uri, installDetails.ZipPath);
}
if (!state.GitLfsZipExists && !state.GitLfsIsValid && state.GitLfsPackage != null)
{
downloader.QueueDownload(state.GitLfsPackage.Uri, installDetails.ZipPath);
}
downloader.RunSynchronously();
state.GitZipExists = installDetails.GitZipPath.FileExists();
state.GitLfsZipExists = installDetails.GitLfsZipPath.FileExists();
Progress.UpdateProgress(30, 100);
return(state);
}
private GitInstallationState CheckForGitUpdates(GitInstallationState state)
{
if (state.IsCustomGitPath)
{
return(state);
}
if (state.GitInstallationPath != installDetails.GitInstallationPath)
{
return(state);
}
state.GitPackage = DugiteReleaseManifest.Load(installDetails.GitManifest, GitInstallDetails.GitPackageFeed, environment);
if (state.GitPackage == null)
{
return(state);
}
state.GitIsValid = state.GitVersion >= state.GitPackage.Version;
if (!state.GitIsValid)
{
Logger.Trace($"{installDetails.GitExecutablePath} is out of date");
}
return(state);
}
public GitInstallationState VerifyGitSettings(GitInstallationState state = null)
{
state = state ?? environment.GitInstallationState;
if (!state.GitExecutablePath.IsInitialized && !state.GitLfsExecutablePath.IsInitialized)
{
return(state);
}
state = ValidateGitVersion(state);
if (state.GitIsValid)
{
state.GitInstallationPath = state.GitExecutablePath.Parent.Parent;
}
if (!state.GitLfsExecutablePath.IsInitialized)
{
// look for it in the directory where we would install it from the bundle
state.GitLfsExecutablePath = installDetails.GitLfsExecutablePath;
}
state = ValidateGitLfsVersion(state);
if (state.GitLfsIsValid)
{
state.GitLfsInstallationPath = state.GitLfsExecutablePath.Parent;
}
return(state);
}
private GitInstallationState CheckForGitUpdates(GitInstallationState state)
{
if (state.GitInstallationPath == installDetails.GitInstallationPath)
{
state.GitPackage = Package.Load(environment, installDetails.GitPackageFeed);
if (state.GitPackage != null)
{
state.GitIsValid = state.GitVersion >= state.GitPackage.Version;
if (state.GitIsValid)
{
state.IsCustomGitPath = state.GitExecutablePath != installDetails.GitExecutablePath;
}
else
{
Logger.Trace($"{installDetails.GitExecutablePath} is out of date");
}
}
}
if (state.GitLfsInstallationPath == installDetails.GitLfsInstallationPath)
{
state.GitLfsPackage = Package.Load(environment, installDetails.GitLfsPackageFeed);
if (state.GitLfsPackage != null)
{
state.GitLfsIsValid = state.GitLfsVersion >= state.GitLfsPackage.Version;
if (!state.GitLfsIsValid)
{
Logger.Trace($"{installDetails.GitLfsExecutablePath} is out of date");
}
}
}
return(state);
}
public GitInstallationState ValidateGitLfsVersion(GitInstallationState state)
{
// default installation doesn't have a standalone "git-lfs" exe
if (state.GitInstallationPath == installDetails.GitInstallationPath)
{
state.GitLfsIsValid = true;
state.GitLfsVersion = state.GitVersion;
return(state);
}
if (!state.GitLfsExecutablePath.IsInitialized || !state.GitLfsExecutablePath.FileExists())
{
state.GitLfsIsValid = false;
return(state);
}
var version = new ProcessTask <TheVersion>(Token, state.GitLfsExecutablePath, "version", new LfsVersionOutputProcessor())
.Configure(processManager)
.Progress(progressReporter.UpdateProgress)
.Catch(e => true)
.RunSynchronously();
state.GitLfsIsValid = version >= Constants.MinimumGitLfsVersion;
state.GitLfsVersion = version;
return(state);
}
private GitInstallationState SetupGitIfNeeded()
{
UpdateTask("Setting up git...", 100);
bool skipSystemProbing = currentState != null;
try
{
currentState = VerifyGitSettings(currentState);
if (currentState.GitIsValid && currentState.GitLfsIsValid)
{
Logger.Trace("Using git install path from settings: {0}", currentState.GitExecutablePath);
currentState.GitLastCheckTime = DateTimeOffset.Now;
return(currentState);
}
//if (!skipSystemProbing)
//{
// if (environment.IsMac)
// currentState = FindGit(currentState);
//}
currentState = SetDefaultPaths(currentState);
currentState = CheckForGitUpdates(currentState);
if (currentState.GitIsValid && currentState.GitLfsIsValid)
{
currentState.GitLastCheckTime = DateTimeOffset.Now;
return(currentState);
}
currentState = VerifyZipFiles(currentState);
currentState = GetZipsIfNeeded(currentState);
currentState = ExtractGit(currentState);
if (!skipSystemProbing)
{
// if installing from zip failed (internet down maybe?), try to find a usable system git
if (!currentState.GitIsValid &&
currentState.GitInstallationPath == installDetails.GitInstallationPath)
{
currentState = FindGit(currentState);
}
if (!currentState.GitLfsIsValid &&
currentState.GitLfsInstallationPath == installDetails.GitLfsInstallationPath)
{
currentState = FindGitLfs(currentState);
}
}
currentState.GitLastCheckTime = DateTimeOffset.Now;
return(currentState);
}
finally
{
UpdateTask("Setting up git...", 100);
}
}
private GitInstallationState ExtractGit(GitInstallationState state)
{
var tempZipExtractPath = NPath.CreateTempDirectory("git_zip_extract_zip_paths");
if (state.GitZipExists && !state.GitIsValid)
{
var gitExtractPath = tempZipExtractPath.Combine("git").CreateDirectory();
var unzipTask = new UnzipTask(cancellationToken, installDetails.GitZipPath,
gitExtractPath, sharpZipLibHelper,
environment.FileSystem)
.Catch(e =>
{
LogHelper.Trace(e, "Failed to unzip " + installDetails.GitZipPath);
return(true);
});
unzipTask.Progress(p => Progress.UpdateProgress(40 + (long)(20 * p.Percentage), 100, unzipTask.Message));
var source = unzipTask.RunSynchronously();
var target = state.GitInstallationPath;
if (unzipTask.Successful)
{
Logger.Trace("Moving Git source:{0} target:{1}", source.ToString(), target.ToString());
CopyHelper.Copy(source, target);
state.GitIsValid = true;
state.IsCustomGitPath = state.GitExecutablePath != installDetails.GitExecutablePath;
}
}
if (state.GitLfsZipExists && !state.GitLfsIsValid)
{
var gitLfsExtractPath = tempZipExtractPath.Combine("git-lfs").CreateDirectory();
var unzipTask = new UnzipTask(cancellationToken, installDetails.GitLfsZipPath,
gitLfsExtractPath, sharpZipLibHelper,
environment.FileSystem)
.Catch(e =>
{
LogHelper.Trace(e, "Failed to unzip " + installDetails.GitLfsZipPath);
return(true);
});
unzipTask.Progress(p => Progress.UpdateProgress(60 + (long)(20 * p.Percentage), 100, unzipTask.Message));
var source = unzipTask.RunSynchronously();
var target = state.GitLfsInstallationPath;
if (unzipTask.Successful)
{
Logger.Trace("Moving GitLFS source:{0} target:{1}", source.ToString(), target.ToString());
CopyHelper.Copy(source, target);
state.GitLfsIsValid = true;
}
}
tempZipExtractPath.DeleteIfExists();
return(state);
}
public GitInstallationState SetDefaultPaths(GitInstallationState state)
{
if (!state.GitIsValid)
{
state = installDetails.GetDefaults();
state = ValidateGitVersion(state);
}
return(state);
}
private FuncTask <NPath> ExtractPortableGit(GitInstallationState state)
{
ITask <NPath> task = null;
var tempZipExtractPath = NPath.CreateTempDirectory("git_zip_extract_zip_paths");
var gitExtractPath = tempZipExtractPath.Combine("git").CreateDirectory();
if (!state.GitIsValid)
{
ITask <NPath> unzipTask = new UnzipTask(cancellationToken, installDetails.GitZipPath, gitExtractPath, sharpZipLibHelper,
environment.FileSystem);
unzipTask.Progress(p => installationTask.UpdateProgress(40 + (long)(20 * p.Percentage), 100, unzipTask.Name));
unzipTask = unzipTask.Then((s, path) =>
{
var source = path;
var target = installDetails.GitInstallationPath;
target.DeleteIfExists();
target.EnsureParentDirectoryExists();
Logger.Trace($"Moving '{source}' to '{target}'");
source.Move(target);
state.GitExists = installDetails.GitExecutablePath.FileExists();
state.GitIsValid = s;
return(path);
});
task = unzipTask;
}
var gitLfsExtractPath = tempZipExtractPath.Combine("git-lfs").CreateDirectory();
if (!state.GitLfsIsValid)
{
ITask <NPath> unzipTask = new UnzipTask(cancellationToken, installDetails.GitLfsZipPath, gitLfsExtractPath, sharpZipLibHelper,
environment.FileSystem);
unzipTask.Progress(p => installationTask.UpdateProgress(60 + (long)(20 * p.Percentage), 100, unzipTask.Name));
unzipTask = unzipTask.Then((s, path) =>
{
var source = path.Combine(installDetails.GitLfsExecutable);
var target = installDetails.GetGitLfsExecutablePath(installDetails.GitInstallationPath);
target.DeleteIfExists();
target.EnsureParentDirectoryExists();
Logger.Trace($"Moving '{source}' to '{target}'");
source.Move(target);
state.GitExists = target.FileExists();
state.GitIsValid = s;
return(path);
});
task = task?.Then(unzipTask) ?? unzipTask;
}
return(task.Finally(new FuncTask <NPath>(cancellationToken, (success) =>
{
tempZipExtractPath.DeleteIfExists();
return installDetails.GitInstallationPath;
})));
}
private GitInstallationState GrabZipFromResourcesIfNeeded(GitInstallationState state)
{
if (!state.GitZipExists && !state.GitIsValid && state.GitInstallationPath == installDetails.GitInstallationPath)
{
AssemblyResources.ToFile(ResourceType.Platform, "git.zip", installDetails.ZipPath, environment);
}
state.GitZipExists = installDetails.GitZipPath.FileExists();
return(state);
}
public GitInstallationState SetupGitIfNeeded(GitInstallationState state = null)
{
var skipSystemProbing = state != null;
state = VerifyGitSettings(state);
if (state.GitIsValid && state.GitLfsIsValid)
{
Logger.Trace("Using git install path from settings: {0}", state.GitExecutablePath);
state.GitLastCheckTime = DateTimeOffset.Now;
return(state);
}
if (!skipSystemProbing)
{
if (environment.IsMac)
{
state = FindGit(state);
}
}
state = SetDefaultPaths(state);
state = CheckForGitUpdates(state);
if (state.GitIsValid && state.GitLfsIsValid)
{
state.GitLastCheckTime = DateTimeOffset.Now;
return(state);
}
state = VerifyZipFiles(state);
// on developer builds, prefer local zips over downloading
#if DEVELOPER_BUILD
state = GrabZipFromResourcesIfNeeded(state);
state = GetZipsIfNeeded(state);
#else
state = GetZipsIfNeeded(state);
state = GrabZipFromResourcesIfNeeded(state);
#endif
state = ExtractGit(state);
// if installing from zip failed (internet down maybe?), try to find a usable system git
if (!state.GitIsValid && state.GitInstallationPath == installDetails.GitInstallationPath)
{
state = FindGit(state);
}
if (!state.GitLfsIsValid && state.GitLfsInstallationPath == installDetails.GitLfsInstallationPath)
{
state = FindGitLfs(state);
}
state.GitLastCheckTime = DateTimeOffset.Now;
return(state);
}
public GitInstaller(IGitEnvironment environment, IProcessManager processManager,
CancellationToken token,
GitInstallationState state = null,
GitInstallDetails installDetails = null)
: base(token)
{
this.environment = environment;
this.processManager = processManager;
this.state = state;
this.sharpZipLibHelper = ZipHelper.Instance;
this.installDetails = installDetails ?? new GitInstallDetails(environment.UserCachePath, environment);
progressReporter.OnProgress += progress.UpdateProgress;
}
public GitInstaller(IPlatform platform,
GitInstallationState state = null,
GitInstallDetails installDetails = null,
CancellationToken token = default)
: base(platform.TaskManager, token)
{
this.platform = platform;
this.currentState = state;
this.sharpZipLibHelper = ZipHelper.Instance;
this.cancellationToken = token;
this.installDetails = installDetails ?? new GitInstallDetails(platform.Environment.UserCachePath, platform.Environment);
progressReporter.OnProgress += progress.UpdateProgress;
}
private ITask <NPath> CreateDownloadTask(GitInstallationState state)
{
var downloader = new Downloader();
downloader.QueueDownload(installDetails.GitZipUrl, installDetails.GitZipMd5Url, installDetails.ZipPath);
downloader.QueueDownload(installDetails.GitLfsZipUrl, installDetails.GitLfsZipMd5Url, installDetails.ZipPath);
return(downloader.Then((_, data) =>
{
state.GitZipExists = installDetails.GitZipPath.FileExists();
state.GitLfsZipExists = installDetails.GitLfsZipPath.FileExists();
installationTask.UpdateProgress(40, 100);
return installDetails.ZipPath;
}));
}
private GitInstallationState VerifyGitInstallation()
{
var state = new GitInstallationState();
state.GitExists = installDetails.GitExecutablePath.IsInitialized && installDetails.GitExecutablePath.FileExists();
state.GitLfsExists = installDetails.GitLfsExecutablePath.IsInitialized && installDetails.GitLfsExecutablePath.FileExists();
state.GitZipExists = installDetails.GitZipPath.FileExists();
state.GitLfsZipExists = installDetails.GitLfsZipPath.FileExists();
if (state.GitExists)
{
var actualmd5 = installDetails.GitExecutablePath.CalculateMD5();
var expectedmd5 = environment.IsWindows ? GitInstallDetails.WindowsGitExecutableMD5 : GitInstallDetails.MacGitExecutableMD5;
state.GitIsValid = expectedmd5.Equals(actualmd5, StringComparison.InvariantCultureIgnoreCase);
if (!state.GitIsValid)
{
Logger.Trace($"Path {installDetails.GitExecutablePath} has MD5 {actualmd5} expected {expectedmd5}");
}
}
else
{
Logger.Trace($"{installDetails.GitExecutablePath} does not exist");
}
if (state.GitLfsExists)
{
var actualmd5 = installDetails.GitLfsExecutablePath.CalculateMD5();
var expectedmd5 = environment.IsWindows ? GitInstallDetails.WindowsGitLfsExecutableMD5 : GitInstallDetails.MacGitLfsExecutableMD5;
state.GitLfsIsValid = expectedmd5.Equals(actualmd5, StringComparison.InvariantCultureIgnoreCase);
if (!state.GitLfsIsValid)
{
Logger.Trace($"Path {installDetails.GitLfsExecutablePath} has MD5 {actualmd5} expected {expectedmd5}");
}
}
else
{
Logger.Trace($"{installDetails.GitLfsExecutablePath} does not exist");
}
if (!state.GitZipExists)
{
Logger.Trace($"{installDetails.GitZipPath} does not exist");
}
if (!state.GitLfsZipExists)
{
Logger.Trace($"{installDetails.GitLfsZipPath} does not exist");
}
installationTask.UpdateProgress(10, 100);
return(state);
}
private GitInstallationState GrabZipFromResourcesIfNeeded(GitInstallationState state)
{
if (!state.GitZipExists)
{
AssemblyResources.ToFile(ResourceType.Platform, "git.zip", installDetails.ZipPath, environment);
}
state.GitZipExists = installDetails.GitZipPath.FileExists();
if (!state.GitLfsZipExists)
{
AssemblyResources.ToFile(ResourceType.Platform, "git-lfs.zip", installDetails.ZipPath, environment);
}
state.GitLfsZipExists = installDetails.GitLfsZipPath.FileExists();
installationTask.UpdateProgress(30, 100);
return(state);
}
public GitInstallationState ValidateGitVersion(GitInstallationState state)
{
if (!state.GitExecutablePath.IsInitialized || !state.GitExecutablePath.FileExists())
{
state.GitIsValid = false;
return(state);
}
var version = new GitVersionTask(cancellationToken)
.Configure(processManager, state.GitExecutablePath, dontSetupGit: true)
.Catch(e => true)
.RunWithReturn(true);
state.GitIsValid = version >= Constants.MinimumGitVersion;
state.GitVersion = version;
return(state);
}
public GitInstallationState ValidateGitLfsVersion(GitInstallationState state)
{
if (!state.GitLfsExecutablePath.IsInitialized || !state.GitLfsExecutablePath.FileExists())
{
state.GitLfsIsValid = false;
return(state);
}
var version = new ProcessTask <TheVersion>(cancellationToken, "version", new LfsVersionOutputProcessor())
.Configure(processManager, state.GitLfsExecutablePath, dontSetupGit: true)
.Catch(e => true)
.RunSynchronously();
state.GitLfsIsValid = version >= Constants.MinimumGitLfsVersion;
state.GitLfsVersion = version;
return(state);
}
private GitInstallationState FindGit(GitInstallationState state)
{
if (!state.GitIsValid)
{
var gitPath = new FindExecTask("git", cancellationToken)
.Configure(processManager, dontSetupGit: true)
.Catch(e => true)
.RunWithReturn(true);
state.GitExecutablePath = gitPath;
state = ValidateGitVersion(state);
if (state.GitIsValid)
{
state.GitInstallationPath = gitPath.Parent.Parent;
}
}
return(state);
}
public GitInstallationState ValidateGitLfsVersion(GitInstallationState state)
{
if (!state.GitLfsExecutablePath.IsInitialized || !state.GitLfsExecutablePath.FileExists())
{
state.GitLfsIsValid = false;
return(state);
}
var version = new GitLfsVersionTask(TaskManager, platform.DefaultProcessEnvironment, state.GitLfsExecutablePath)
.Configure(platform.ProcessManager)
.Progress(progressReporter.UpdateProgress)
.Catch(e => true)
.RunSynchronously();
state.GitLfsIsValid = version >= Constants.MinimumGitLfsVersion;
state.GitLfsVersion = version;
return(state);
}
private GitInstallationState FindGitLfs(GitInstallationState state)
{
if (!state.GitLfsIsValid)
{
var gitLfsPath = new FindExecTask("git-lfs", cancellationToken)
.Configure(processManager, dontSetupGit: true)
.Catch(e => true)
.RunSynchronously();
state.GitLfsExecutablePath = gitLfsPath;
state = ValidateGitLfsVersion(state);
if (state.GitLfsIsValid)
{
state.GitLfsInstallationPath = state.GitLfsExecutablePath.Parent;
}
}
return(state);
}
public GitInstallationState SetDefaultPaths(GitInstallationState state)
{
if (!state.GitIsValid && environment.IsWindows)
{
state.GitInstallationPath = installDetails.GitInstallationPath;
state.GitExecutablePath = installDetails.GitExecutablePath;
state = ValidateGitVersion(state);
}
if (!state.GitLfsIsValid)
{
state.GitLfsExecutablePath = installDetails.GitLfsExecutablePath;
state.GitLfsInstallationPath = state.GitLfsExecutablePath.Parent;
state = ValidateGitLfsVersion(state);
}
return(state);
}
private GitInstallationState FindGitLfs(GitInstallationState state)
{
if (!state.GitLfsIsValid)
{
var gitLfsPath = new FindExecTask("git-lfs", environment, Token)
.Configure(processManager)
.Progress(progressReporter.UpdateProgress)
.Catch(e => true)
.RunSynchronously();
state.GitLfsExecutablePath = gitLfsPath;
state = ValidateGitLfsVersion(state);
if (state.GitLfsIsValid)
{
state.GitLfsInstallationPath = state.GitLfsExecutablePath.Parent;
}
}
return(state);
}
private GitInstallationState VerifyZipFiles(GitInstallationState state)
{
var md5 = AssemblyResources.ToFile(ResourceType.Platform, "git.zip.md5", installDetails.ZipPath, environment);
if (!md5.FileExists() || (installDetails.GitZipPath.FileExists() && !Utils.VerifyFileIntegrity(installDetails.GitZipPath, md5)))
{
installDetails.GitZipPath.DeleteIfExists();
}
state.GitZipExists = installDetails.GitZipPath.FileExists();
md5 = AssemblyResources.ToFile(ResourceType.Platform, "git-lfs.zip.md5", installDetails.ZipPath, environment);
// check whether the git-lfs zip file exists and is valid
if (!md5.FileExists() || (installDetails.GitLfsZipPath.FileExists() && !Utils.VerifyFileIntegrity(installDetails.GitLfsZipPath, md5)))
{
installDetails.GitLfsZipPath.DeleteIfExists();
}
state.GitLfsZipExists = installDetails.GitLfsZipPath.FileExists();
installationTask.UpdateProgress(20, 100);
return(state);
}
private GitInstallationState FindGit(GitInstallationState state)
{
if (!state.GitIsValid)
{
var gitPath = new FindExecTask(TaskManager,
platform.ProcessManager.DefaultProcessEnvironment, platform.Environment,
"git", cancellationToken)
.Configure(platform.ProcessManager)
.Progress(progressReporter.UpdateProgress)
.Catch(e => true)
.RunSynchronously();
state.GitExecutablePath = gitPath;
state = ValidateGitVersion(state);
if (state.GitIsValid)
{
state.GitInstallationPath = gitPath.Parent.Parent;
}
}
return(state);
}
