public void Execute()
{
GVFSEnlistment enlistment = this.CreateEnlistment(this.EnlistmentRootPathParameter);
EventLevel verbosity;
Keywords keywords;
this.ParseEnumArgs(out verbosity, out keywords);
JsonTracer tracer = this.CreateTracer(enlistment, verbosity, keywords);
CacheServerInfo cacheServer = CacheServerResolver.GetCacheServerFromConfig(enlistment);
tracer.WriteStartEvent(
enlistment.EnlistmentRoot,
enlistment.RepoUrl,
cacheServer.Url,
new EventMetadata
{
{ "IsElevated", GVFSPlatform.Instance.IsElevated() },
{ nameof(this.EnlistmentRootPathParameter), this.EnlistmentRootPathParameter },
{ nameof(this.StartedByService), this.StartedByService },
});
AppDomain.CurrentDomain.UnhandledException += (object sender, UnhandledExceptionEventArgs e) =>
{
this.UnhandledGVFSExceptionHandler(tracer, sender, e);
};
string error;
RetryConfig retryConfig;
if (!RetryConfig.TryLoadFromGitConfig(tracer, enlistment, out retryConfig, out error))
{
this.ReportErrorAndExit(tracer, "Failed to determine GVFS timeout and max retries: " + error);
}
GitStatusCacheConfig gitStatusCacheConfig;
if (!GitStatusCacheConfig.TryLoadFromGitConfig(tracer, enlistment, out gitStatusCacheConfig, out error))
{
tracer.RelatedWarning("Failed to determine GVFS status cache backoff time: " + error);
gitStatusCacheConfig = GitStatusCacheConfig.DefaultConfig;
}
InProcessMount mountHelper = new InProcessMount(tracer, enlistment, cacheServer, retryConfig, gitStatusCacheConfig, this.ShowDebugWindow);
try
{
mountHelper.Mount(verbosity, keywords);
}
catch (Exception ex)
{
this.ReportErrorAndExit(tracer, "Failed to mount: {0}", ex.Message);
}
}
public void TryLoadConfigEnforcesMinimumValuesOnTimeout()
{
MockTracer tracer = new MockTracer();
MockGitProcess gitProcess = new MockGitProcess();
gitProcess.SetExpectedCommandResult("config gvfs.max-retries", () => new GitProcess.Result("3", string.Empty, GitProcess.Result.SuccessCode));
gitProcess.SetExpectedCommandResult("config gvfs.timeout-seconds", () => new GitProcess.Result("-1", string.Empty, GitProcess.Result.SuccessCode));
RetryConfig config;
string error;
RetryConfig.TryLoadFromGitConfig(tracer, gitProcess, out config, out error).ShouldEqual(false);
error.ShouldContain("Invalid value -1 for setting gvfs.timeout-seconds, value must be greater than or equal to 0");
}
public void TryLoadConfigFailsWhenGitFailsToReadConfig()
{
MockTracer tracer = new MockTracer();
MockGitProcess gitProcess = new MockGitProcess();
gitProcess.SetExpectedCommandResult("config gvfs.max-retries", () => new GitProcess.Result(string.Empty, ReadConfigFailureMessage, GitProcess.Result.GenericFailureCode));
gitProcess.SetExpectedCommandResult("config gvfs.timeout-seconds", () => new GitProcess.Result(string.Empty, ReadConfigFailureMessage, GitProcess.Result.GenericFailureCode));
RetryConfig config;
string error;
RetryConfig.TryLoadFromGitConfig(tracer, gitProcess, out config, out error).ShouldEqual(false);
error.ShouldContain(ReadConfigFailureMessage);
}
private bool TryDownloadGitObjects(ITracer tracer, GVFSEnlistment enlistment)
{
string errorMessage = null;
if (!this.ShowStatusWhileRunning(
() =>
{
RetryConfig retryConfig;
if (!RetryConfig.TryLoadFromGitConfig(tracer, enlistment, out retryConfig, out errorMessage))
{
errorMessage = "Failed to determine GVFS timeout and max retries: " + errorMessage;
return(false);
}
CacheServerInfo cacheServer = new CacheServerInfo(enlistment.RepoUrl, null);
using (GitObjectsHttpRequestor objectRequestor = new GitObjectsHttpRequestor(tracer, enlistment, cacheServer, retryConfig))
{
PhysicalFileSystem fileSystem = new PhysicalFileSystem();
GitRepo gitRepo = new GitRepo(tracer, enlistment, fileSystem);
GVFSGitObjects gitObjects = new GVFSGitObjects(new GVFSContext(tracer, fileSystem, gitRepo, enlistment), objectRequestor);
GitProcess.Result revParseResult = enlistment.CreateGitProcess().RevParse("HEAD");
if (revParseResult.HasErrors)
{
errorMessage = "Unable to determine HEAD commit id: " + revParseResult.Errors;
return(false);
}
string headCommit = revParseResult.Output.TrimEnd('\n');
if (!this.TryDownloadCommit(headCommit, enlistment, objectRequestor, gitObjects, gitRepo, out errorMessage) ||
!this.TryDownloadRootGitAttributes(enlistment, gitObjects, gitRepo, out errorMessage))
{
return(false);
}
}
return(true);
},
"Downloading git objects",
suppressGvfsLogMessage: true))
{
this.WriteMessage(tracer, errorMessage);
return(false);
}
return(true);
}
public void Execute()
{
GVFSEnlistment enlistment = this.CreateEnlistment(this.EnlistmentRootPath);
EventLevel verbosity;
Keywords keywords;
this.ParseEnumArgs(out verbosity, out keywords);
JsonEtwTracer tracer = this.CreateTracer(enlistment, verbosity, keywords);
CacheServerInfo cacheServer = CacheServerResolver.GetCacheServerFromConfig(enlistment);
tracer.WriteStartEvent(
enlistment.EnlistmentRoot,
enlistment.RepoUrl,
cacheServer.Url,
enlistment.GitObjectsRoot,
new EventMetadata
{
{ "IsElevated", ProcessHelper.IsAdminElevated() },
});
AppDomain.CurrentDomain.UnhandledException += (object sender, UnhandledExceptionEventArgs e) =>
{
this.UnhandledGVFSExceptionHandler(tracer, sender, e);
};
RetryConfig retryConfig;
string error;
if (!RetryConfig.TryLoadFromGitConfig(tracer, enlistment, out retryConfig, out error))
{
this.ReportErrorAndExit("Failed to determine GVFS timeout and max retries: " + error);
}
InProcessMount mountHelper = new InProcessMount(tracer, enlistment, cacheServer, retryConfig, this.ShowDebugWindow);
try
{
mountHelper.Mount(verbosity, keywords);
}
catch (Exception ex)
{
tracer.RelatedError("Failed to mount: {0}", ex.ToString());
this.ReportErrorAndExit("Failed to mount: {0}", ex.Message);
}
}
protected RetryConfig GetRetryConfig(ITracer tracer, GVFSEnlistment enlistment, TimeSpan?timeoutOverride = null)
{
RetryConfig retryConfig;
string error;
if (!RetryConfig.TryLoadFromGitConfig(tracer, enlistment, out retryConfig, out error))
{
this.ReportErrorAndExit(tracer, "Failed to determine GVFS timeout and max retries: " + error);
}
if (timeoutOverride.HasValue)
{
retryConfig.Timeout = timeoutOverride.Value;
}
return(retryConfig);
}
public void TryLoadConfigUsesDefaultValuesWhenEntriesAreBlank()
{
MockTracer tracer = new MockTracer();
MockGitProcess gitProcess = new MockGitProcess();
gitProcess.SetExpectedCommandResult("config gvfs.max-retries", () => new GitProcess.Result(string.Empty, string.Empty, GitProcess.Result.SuccessCode));
gitProcess.SetExpectedCommandResult("config gvfs.timeout-seconds", () => new GitProcess.Result(string.Empty, string.Empty, GitProcess.Result.SuccessCode));
RetryConfig config;
string error;
RetryConfig.TryLoadFromGitConfig(tracer, gitProcess, out config, out error).ShouldEqual(true);
error.ShouldEqual(string.Empty);
config.MaxRetries.ShouldEqual(RetryConfig.DefaultMaxRetries);
config.MaxAttempts.ShouldEqual(config.MaxRetries + 1);
config.Timeout.ShouldEqual(TimeSpan.FromSeconds(RetryConfig.DefaultTimeoutSeconds));
}
public void Execute()
{
GVFSEnlistment enlistment = this.CreateEnlistment(this.EnlistmentRootPath);
EventLevel verbosity;
Keywords keywords;
this.ParseEnumArgs(out verbosity, out keywords);
JsonEtwTracer tracer = this.CreateTracer(enlistment, verbosity, keywords);
RetryConfig retryConfig;
string error;
if (!RetryConfig.TryLoadFromGitConfig(tracer, enlistment, out retryConfig, out error))
{
this.ReportErrorAndExit("Failed to determine GVFS timeout and max retries: " + error);
}
CacheServerInfo cacheServer;
if (!CacheServerInfo.TryDetermineCacheServer(null, tracer, enlistment, retryConfig, out cacheServer, out error))
{
this.ReportErrorAndExit(error);
}
tracer.WriteStartEvent(
enlistment.EnlistmentRoot,
enlistment.RepoUrl,
cacheServer.Url);
InProcessMount mountHelper = new InProcessMount(tracer, enlistment, cacheServer, retryConfig, this.ShowDebugWindow);
try
{
mountHelper.Mount(verbosity, keywords);
}
catch (Exception ex)
{
tracer.RelatedError("Failed to mount: {0}", ex.ToString());
this.ReportErrorAndExit("Failed to mount: {0}", ex.Message);
}
}
public void TryLoadConfigUsesConfiguredValues()
{
int maxRetries = RetryConfig.DefaultMaxRetries + 1;
int timeoutSeconds = RetryConfig.DefaultTimeoutSeconds + 1;
MockTracer tracer = new MockTracer();
MockGitProcess gitProcess = new MockGitProcess();
gitProcess.SetExpectedCommandResult("config scalar.max-retries", () => new GitProcess.Result(maxRetries.ToString(), string.Empty, GitProcess.Result.SuccessCode));
gitProcess.SetExpectedCommandResult("config scalar.timeout-seconds", () => new GitProcess.Result(timeoutSeconds.ToString(), string.Empty, GitProcess.Result.SuccessCode));
RetryConfig config;
string error;
RetryConfig.TryLoadFromGitConfig(tracer, gitProcess, out config, out error).ShouldEqual(true);
error.ShouldEqual(string.Empty);
config.MaxRetries.ShouldEqual(maxRetries);
config.MaxAttempts.ShouldEqual(config.MaxRetries + 1);
config.Timeout.ShouldEqual(TimeSpan.FromSeconds(timeoutSeconds));
}
protected override void Execute(GVFSEnlistment enlistment)
{
using (JsonEtwTracer tracer = new JsonEtwTracer(GVFSConstants.GVFSEtwProviderName, "Prefetch"))
{
if (this.Verbose)
{
tracer.AddDiagnosticConsoleEventListener(EventLevel.Informational, Keywords.Any);
}
else
{
tracer.AddPrettyConsoleEventListener(EventLevel.Error, Keywords.Any);
}
tracer.AddLogFileEventListener(
GVFSEnlistment.GetNewGVFSLogFileName(enlistment.GVFSLogsRoot, GVFSConstants.LogFileTypes.Prefetch),
EventLevel.Informational,
Keywords.Any);
RetryConfig retryConfig;
string error;
if (!RetryConfig.TryLoadFromGitConfig(tracer, enlistment, out retryConfig, out error))
{
tracer.RelatedError("Failed to determine GVFS timeout and max retries: " + error);
Environment.Exit((int)ReturnCode.GenericError);
}
retryConfig.Timeout = TimeSpan.FromMinutes(RetryConfig.FetchAndCloneTimeoutMinutes);
CacheServerInfo cache;
if (!CacheServerInfo.TryDetermineCacheServer(null, tracer, enlistment, retryConfig, out cache, out error))
{
tracer.RelatedError(error);
Environment.ExitCode = (int)ReturnCode.GenericError;
return;
}
tracer.WriteStartEvent(
enlistment.EnlistmentRoot,
enlistment.RepoUrl,
cache.Url);
try
{
EventMetadata metadata = new EventMetadata();
metadata.Add("Commits", this.Commits);
metadata.Add("PathWhitelist", this.PathWhitelist);
metadata.Add("PathWhitelistFile", this.PathWhitelistFile);
tracer.RelatedEvent(EventLevel.Informational, "PerformPrefetch", metadata);
GitObjectsHttpRequestor objectRequestor = new GitObjectsHttpRequestor(tracer, enlistment, cache, retryConfig);
if (this.Commits)
{
this.PrefetchCommits(tracer, enlistment, objectRequestor);
}
else
{
this.PrefetchBlobs(tracer, enlistment, objectRequestor);
}
}
catch (VerbAbortedException)
{
throw;
}
catch (AggregateException aggregateException)
{
this.Output.WriteLine(
"Cannot prefetch {0}. " + ConsoleHelper.GetGVFSLogMessage(enlistment.EnlistmentRoot),
enlistment.EnlistmentRoot);
foreach (Exception innerException in aggregateException.Flatten().InnerExceptions)
{
tracer.RelatedError(
new EventMetadata
{
{ "Verb", typeof(PrefetchVerb).Name },
{ "ErrorMessage", $"Unhandled {innerException.GetType().Name}: {innerException.Message}" },
{ "Exception", innerException.ToString() }
});
}
Environment.ExitCode = (int)ReturnCode.GenericError;
}
catch (Exception e)
{
this.Output.WriteLine(
"Cannot prefetch {0}. " + ConsoleHelper.GetGVFSLogMessage(enlistment.EnlistmentRoot),
enlistment.EnlistmentRoot);
tracer.RelatedError(
new EventMetadata
{
{ "Verb", typeof(PrefetchVerb).Name },
{ "ErrorMessage", $"Unhandled {e.GetType().Name}: {e.Message}" },
{ "Exception", e.ToString() }
});
}
}
}
protected override void Execute(GVFSEnlistment enlistment)
{
using (JsonTracer tracer = new JsonTracer(GVFSConstants.GVFSEtwProviderName, "Dehydrate"))
{
tracer.AddLogFileEventListener(
GVFSEnlistment.GetNewGVFSLogFileName(enlistment.GVFSLogsRoot, GVFSConstants.LogFileTypes.Dehydrate),
EventLevel.Informational,
Keywords.Any);
tracer.WriteStartEvent(
enlistment.EnlistmentRoot,
enlistment.RepoUrl,
CacheServerResolver.GetUrlFromConfig(enlistment),
new EventMetadata
{
{ "Confirmed", this.Confirmed },
{ "NoStatus", this.NoStatus },
{ "NamedPipeName", enlistment.NamedPipeName },
{ "Folders", this.Folders },
{ nameof(this.EnlistmentRootPathParameter), this.EnlistmentRootPathParameter },
});
// This is only intended to be run by functional tests
if (this.MaintenanceJob != null)
{
this.InitializeLocalCacheAndObjectsPaths(tracer, enlistment, retryConfig: null, serverGVFSConfig: null, cacheServer: null);
PhysicalFileSystem fileSystem = new PhysicalFileSystem();
using (GitRepo gitRepo = new GitRepo(tracer, enlistment, fileSystem))
using (GVFSContext context = new GVFSContext(tracer, fileSystem, gitRepo, enlistment))
{
switch (this.MaintenanceJob)
{
case "LooseObjects":
(new LooseObjectsStep(context, forceRun: true)).Execute();
return;
case "PackfileMaintenance":
(new PackfileMaintenanceStep(
context,
forceRun: true,
batchSize: this.PackfileMaintenanceBatchSize ?? PackfileMaintenanceStep.DefaultBatchSize)).Execute();
return;
case "PostFetch":
(new PostFetchStep(context, new System.Collections.Generic.List <string>(), requireObjectCacheLock: false)).Execute();
return;
default:
this.ReportErrorAndExit($"Unknown maintenance job requested: {this.MaintenanceJob}");
break;
}
}
}
bool fullDehydrate = string.IsNullOrEmpty(this.Folders);
if (!this.Confirmed && fullDehydrate)
{
this.Output.WriteLine(
@"WARNING: THIS IS AN EXPERIMENTAL FEATURE
Dehydrate will back up your src folder, and then create a new, empty src folder
with a fresh virtualization of the repo. All of your downloaded objects, branches,
and siblings of the src folder will be preserved. Your modified working directory
files will be moved to the backup, and your new working directory will not have
any of your uncommitted changes.
Before you dehydrate, make sure you have committed any working directory changes
you want to keep. If you choose not to, you can still find your uncommitted changes
in the backup folder, but it will be harder to find them because 'git status'
will not work in the backup.
To actually execute the dehydrate, run 'gvfs dehydrate --confirm' from the parent
of your enlistment's src folder.
");
return;
}
else if (!this.Confirmed)
{
this.Output.WriteLine(
@"WARNING: THIS IS AN EXPERIMENTAL FEATURE
All of your downloaded objects, branches, and siblings of the src folder
will be preserved. This will remove the folders specified and any working directory
files and folders even if ignored by git similar to 'git clean -xdf <path>'.
Before you dehydrate, you will have to commit any working directory changes
you want to keep and have a clean 'git status'.
To actually execute the dehydrate, run 'gvfs dehydrate --confirm --folders <folder list>'
from a parent of the folders list.
");
return;
}
if (this.NoStatus && !fullDehydrate)
{
this.ReportErrorAndExit(tracer, "Dehydrate --no-status not valid with --folders");
return;
}
bool cleanStatus = this.CheckGitStatus(tracer, enlistment, fullDehydrate);
string backupRoot = Path.GetFullPath(Path.Combine(enlistment.EnlistmentRoot, "dehydrate_backup", DateTime.Now.ToString("yyyyMMdd_HHmmss")));
this.Output.WriteLine();
if (fullDehydrate)
{
this.WriteMessage(tracer, $"Starting {this.RunningVerbName}. All of your existing files will be backed up in " + backupRoot);
}
this.WriteMessage(tracer, $"WARNING: If you abort the {this.RunningVerbName} after this point, the repo may become corrupt");
this.Output.WriteLine();
this.Unmount(tracer);
string error;
if (!DiskLayoutUpgrade.TryCheckDiskLayoutVersion(tracer, enlistment.EnlistmentRoot, out error))
{
this.ReportErrorAndExit(tracer, error);
}
if (fullDehydrate)
{
RetryConfig retryConfig;
if (!RetryConfig.TryLoadFromGitConfig(tracer, enlistment, out retryConfig, out error))
{
this.ReportErrorAndExit(tracer, "Failed to determine GVFS timeout and max retries: " + error);
}
string errorMessage;
if (!this.TryAuthenticate(tracer, enlistment, out errorMessage))
{
this.ReportErrorAndExit(tracer, errorMessage);
}
// Local cache and objects paths are required for TryDownloadGitObjects
this.InitializeLocalCacheAndObjectsPaths(tracer, enlistment, retryConfig, serverGVFSConfig: null, cacheServer: null);
this.RunFullDehydrate(tracer, enlistment, backupRoot, retryConfig);
}
else
{
string[] folders = this.Folders.Split(new[] { FolderListSeparator }, StringSplitOptions.RemoveEmptyEntries);
if (folders.Length > 0)
{
if (cleanStatus)
{
this.DehydrateFolders(tracer, enlistment, folders);
}
else
{
this.ReportErrorAndExit($"Cannot {this.ActionName}: must have a clean git status.");
}
}
else
{
this.ReportErrorAndExit($"No folders to {this.ActionName}.");
}
}
}
}
protected override void Execute(GVFSEnlistment enlistment)
{
string errorMessage = null;
if (!HooksInstaller.InstallHooks(enlistment, out errorMessage))
{
this.ReportErrorAndExit("Error installing hooks: " + errorMessage);
}
if (!enlistment.TryConfigureAlternate(out errorMessage))
{
this.ReportErrorAndExit("Error configuring alternate: " + errorMessage);
}
using (JsonEtwTracer tracer = new JsonEtwTracer(GVFSConstants.GVFSEtwProviderName, "PreMount"))
{
tracer.AddLogFileEventListener(
GVFSEnlistment.GetNewGVFSLogFileName(enlistment.GVFSLogsRoot, GVFSConstants.LogFileTypes.Mount),
EventLevel.Verbose,
Keywords.Any);
if (!this.SkipVersionCheck)
{
string authErrorMessage = null;
if (!this.ShowStatusWhileRunning(
() => enlistment.Authentication.TryRefreshCredentials(tracer, out authErrorMessage),
"Authenticating"))
{
this.Output.WriteLine(" WARNING: " + authErrorMessage);
this.Output.WriteLine(" Mount will proceed, but new files cannot be accessed until GVFS can authenticate.");
}
}
RetryConfig retryConfig = null;
string error;
if (!RetryConfig.TryLoadFromGitConfig(tracer, enlistment, out retryConfig, out error))
{
this.ReportErrorAndExit("Failed to determine GVFS timeout and max retries: " + error);
}
GVFSConfig gvfsConfig;
CacheServerInfo cacheServer;
using (ConfigHttpRequestor configRequestor = new ConfigHttpRequestor(tracer, enlistment, retryConfig))
{
gvfsConfig = configRequestor.QueryGVFSConfig();
}
if (!CacheServerInfo.TryDetermineCacheServer(null, enlistment, gvfsConfig.CacheServers, out cacheServer, out error))
{
this.ReportErrorAndExit(error);
}
tracer.WriteStartEvent(
enlistment.EnlistmentRoot,
enlistment.RepoUrl,
cacheServer.Url);
if (!GvFltFilter.TryAttach(tracer, enlistment.EnlistmentRoot, out errorMessage))
{
if (!this.ShowStatusWhileRunning(
() => { return(this.AttachGvFltThroughService(enlistment, out errorMessage)); },
"Attaching GvFlt to volume"))
{
this.ReportErrorAndExit(errorMessage);
}
}
this.ValidateClientVersions(tracer, enlistment, gvfsConfig);
}
if (!this.ShowStatusWhileRunning(
() => { return(this.TryMount(enlistment, out errorMessage)); },
"Mounting"))
{
this.ReportErrorAndExit(errorMessage);
}
if (!this.ShowStatusWhileRunning(
() => { return(this.RegisterMount(enlistment, out errorMessage)); },
"Registering for automount"))
{
this.Output.WriteLine(" WARNING: " + errorMessage);
}
}
protected override void Execute(GVFSEnlistment enlistment)
{
using (ITracer tracer = new JsonEtwTracer(GVFSConstants.GVFSEtwProviderName, "CacheVerb"))
{
RetryConfig retryConfig;
string error;
if (!RetryConfig.TryLoadFromGitConfig(tracer, enlistment, out retryConfig, out error))
{
this.ReportErrorAndExit("Failed to determine GVFS timeout and max retries: " + error);
}
GVFSConfig config;
using (ConfigHttpRequestor configRequestor = new ConfigHttpRequestor(tracer, enlistment, retryConfig))
{
config = configRequestor.QueryGVFSConfig();
if (config == null)
{
this.ReportErrorAndExit("Could not query for available cache servers.");
}
}
CacheServerInfo cache;
if (!string.IsNullOrWhiteSpace(this.CacheToSet))
{
if (CacheServerInfo.TryParse(this.CacheToSet, enlistment, config.CacheServers, out cache))
{
if (!CacheServerInfo.TrySaveToConfig(new GitProcess(enlistment), cache, out error))
{
this.ReportErrorAndExit("Failed to save cache to config: " + error);
}
}
else
{
this.ReportErrorAndExit("Unrecognized or invalid cache name or url: " + this.CacheToSet);
}
this.OutputCacheInfo(cache);
this.Output.WriteLine("You must remount GVFS for this to take effect.");
}
else if (this.ListCacheServers)
{
if (config.CacheServers.Any())
{
this.Output.WriteLine("Available cache servers for: " + enlistment.RepoUrl);
foreach (CacheServerInfo cacheServer in config.CacheServers)
{
this.Output.WriteLine("{0, -25} ({1})", cacheServer.Name, cacheServer.Url);
}
}
else
{
this.Output.WriteLine("There are no available cache servers for: " + enlistment.RepoUrl);
}
}
else
{
if (!CacheServerInfo.TryDetermineCacheServer(null, enlistment, config.CacheServers, out cache, out error))
{
this.ReportErrorAndExit(error);
}
this.OutputCacheInfo(cache);
}
}
}
private void EnsureLocalCacheIsHealthy(
ITracer tracer,
GVFSEnlistment enlistment,
RetryConfig retryConfig,
GVFSConfig gvfsConfig,
CacheServerInfo cacheServer)
{
if (!Directory.Exists(enlistment.LocalCacheRoot))
{
try
{
tracer.RelatedInfo($"{nameof(this.EnsureLocalCacheIsHealthy)}: Local cache root: {enlistment.LocalCacheRoot} missing, recreating it");
Directory.CreateDirectory(enlistment.LocalCacheRoot);
}
catch (Exception e)
{
EventMetadata metadata = new EventMetadata();
metadata.Add("Exception", e.ToString());
metadata.Add("enlistment.LocalCacheRoot", enlistment.LocalCacheRoot);
tracer.RelatedError(metadata, $"{nameof(this.EnsureLocalCacheIsHealthy)}: Exception while trying to create local cache root");
this.ReportErrorAndExit(tracer, "Failed to create local cache: " + enlistment.LocalCacheRoot);
}
}
PhysicalFileSystem fileSystem = new PhysicalFileSystem();
if (Directory.Exists(enlistment.GitObjectsRoot))
{
bool gitObjectsRootInAlternates = false;
string alternatesFilePath = this.GetAlternatesPath(enlistment);
if (File.Exists(alternatesFilePath))
{
try
{
using (Stream stream = fileSystem.OpenFileStream(
alternatesFilePath,
FileMode.Open,
FileAccess.Read,
FileShare.ReadWrite,
callFlushFileBuffers: false))
{
using (StreamReader reader = new StreamReader(stream))
{
while (!reader.EndOfStream)
{
string alternatesLine = reader.ReadLine();
if (string.Equals(alternatesLine, enlistment.GitObjectsRoot, StringComparison.OrdinalIgnoreCase))
{
gitObjectsRootInAlternates = true;
}
}
}
}
}
catch (Exception e)
{
EventMetadata exceptionMetadata = new EventMetadata();
exceptionMetadata.Add("Exception", e.ToString());
tracer.RelatedError(exceptionMetadata, $"{nameof(this.EnsureLocalCacheIsHealthy)}: Exception while trying to validate alternates file");
this.ReportErrorAndExit(tracer, $"Failed to validate that alternates file includes git objects root: {e.Message}");
}
}
else
{
tracer.RelatedInfo($"{nameof(this.EnsureLocalCacheIsHealthy)}: Alternates file not found");
}
if (!gitObjectsRootInAlternates)
{
tracer.RelatedInfo($"{nameof(this.EnsureLocalCacheIsHealthy)}: GitObjectsRoot ({enlistment.GitObjectsRoot}) missing from alternates files, recreating alternates");
string error;
if (!this.TryCreateAlternatesFile(fileSystem, enlistment, out error))
{
this.ReportErrorAndExit(tracer, $"Failed to update alternates file to include git objects root: {error}");
}
}
}
else
{
tracer.RelatedInfo($"{nameof(this.EnsureLocalCacheIsHealthy)}: GitObjectsRoot ({enlistment.GitObjectsRoot}) missing, determining new root");
if (cacheServer == null)
{
cacheServer = CacheServerResolver.GetCacheServerFromConfig(enlistment);
}
string error;
if (gvfsConfig == null)
{
if (retryConfig == null)
{
if (!RetryConfig.TryLoadFromGitConfig(tracer, enlistment, out retryConfig, out error))
{
this.ReportErrorAndExit(tracer, "Failed to determine GVFS timeout and max retries: " + error);
}
}
gvfsConfig = this.QueryGVFSConfig(tracer, enlistment, retryConfig);
}
string localCacheKey;
LocalCacheResolver localCacheResolver = new LocalCacheResolver(enlistment);
if (!localCacheResolver.TryGetLocalCacheKeyFromLocalConfigOrRemoteCacheServers(
tracer,
gvfsConfig,
cacheServer,
enlistment.LocalCacheRoot,
localCacheKey: out localCacheKey,
errorMessage: out error))
{
this.ReportErrorAndExit(tracer, $"Previous git objects root ({enlistment.GitObjectsRoot}) not found, and failed to determine new local cache key: {error}");
}
EventMetadata metadata = new EventMetadata();
metadata.Add("localCacheRoot", enlistment.LocalCacheRoot);
metadata.Add("localCacheKey", localCacheKey);
metadata.Add(TracingConstants.MessageKey.InfoMessage, "Initializing and persisting updated paths");
tracer.RelatedEvent(EventLevel.Informational, "GVFSVerb_InitializeLocalCacheAndObjectsPaths", metadata);
enlistment.InitializeLocalCacheAndObjectsPathsFromKey(enlistment.LocalCacheRoot, localCacheKey);
tracer.RelatedInfo($"{nameof(this.EnsureLocalCacheIsHealthy)}: Creating GitObjectsRoot ({enlistment.GitObjectsRoot}) and GitPackRoot ({enlistment.GitPackRoot})");
try
{
Directory.CreateDirectory(enlistment.GitObjectsRoot);
Directory.CreateDirectory(enlistment.GitPackRoot);
}
catch (Exception e)
{
EventMetadata exceptionMetadata = new EventMetadata();
exceptionMetadata.Add("Exception", e.ToString());
exceptionMetadata.Add("enlistment.LocalCacheRoot", enlistment.LocalCacheRoot);
exceptionMetadata.Add("enlistment.GitObjectsRoot", enlistment.GitObjectsRoot);
exceptionMetadata.Add("enlistment.GitPackRoot", enlistment.GitPackRoot);
tracer.RelatedError(exceptionMetadata, $"{nameof(this.InitializeLocalCacheAndObjectsPaths)}: Exception while trying to create objects and pack folders");
this.ReportErrorAndExit(tracer, "Failed to create objects and pack folders");
}
tracer.RelatedInfo($"{nameof(this.EnsureLocalCacheIsHealthy)}: Creating new alternates file");
if (!this.TryCreateAlternatesFile(fileSystem, enlistment, out error))
{
this.ReportErrorAndExit(tracer, $"Failed to update alterates file with new objects path: {error}");
}
tracer.RelatedInfo($"{nameof(this.EnsureLocalCacheIsHealthy)}: Saving git objects root ({enlistment.GitObjectsRoot}) in repo metadata");
RepoMetadata.Instance.SetGitObjectsRoot(enlistment.GitObjectsRoot);
}
}
private void EnsureLocalCacheIsHealthy(
ITracer tracer,
GVFSEnlistment enlistment,
RetryConfig retryConfig,
ServerGVFSConfig serverGVFSConfig,
CacheServerInfo cacheServer)
{
if (!Directory.Exists(enlistment.LocalCacheRoot))
{
try
{
tracer.RelatedInfo($"{nameof(this.EnsureLocalCacheIsHealthy)}: Local cache root: {enlistment.LocalCacheRoot} missing, recreating it");
Directory.CreateDirectory(enlistment.LocalCacheRoot);
}
catch (Exception e)
{
EventMetadata metadata = new EventMetadata();
metadata.Add("Exception", e.ToString());
metadata.Add("enlistment.LocalCacheRoot", enlistment.LocalCacheRoot);
tracer.RelatedError(metadata, $"{nameof(this.EnsureLocalCacheIsHealthy)}: Exception while trying to create local cache root");
this.ReportErrorAndExit(tracer, "Failed to create local cache: " + enlistment.LocalCacheRoot);
}
}
// Validate that the GitObjectsRoot directory is on disk, and that the GVFS repo is configured to use it.
// If the directory is missing (and cannot be found in the mapping file) a new key for the repo will be added
// to the mapping file and used for BOTH the GitObjectsRoot and BlobSizesRoot
PhysicalFileSystem fileSystem = new PhysicalFileSystem();
if (Directory.Exists(enlistment.GitObjectsRoot))
{
bool gitObjectsRootInAlternates = false;
string alternatesFilePath = this.GetAlternatesPath(enlistment);
if (File.Exists(alternatesFilePath))
{
try
{
using (Stream stream = fileSystem.OpenFileStream(
alternatesFilePath,
FileMode.Open,
FileAccess.Read,
FileShare.ReadWrite,
callFlushFileBuffers: false))
{
using (StreamReader reader = new StreamReader(stream))
{
while (!reader.EndOfStream)
{
string alternatesLine = reader.ReadLine();
if (string.Equals(alternatesLine, enlistment.GitObjectsRoot, StringComparison.OrdinalIgnoreCase))
{
gitObjectsRootInAlternates = true;
}
}
}
}
}
catch (Exception e)
{
EventMetadata exceptionMetadata = new EventMetadata();
exceptionMetadata.Add("Exception", e.ToString());
tracer.RelatedError(exceptionMetadata, $"{nameof(this.EnsureLocalCacheIsHealthy)}: Exception while trying to validate alternates file");
this.ReportErrorAndExit(tracer, $"Failed to validate that alternates file includes git objects root: {e.Message}");
}
}
else
{
tracer.RelatedInfo($"{nameof(this.EnsureLocalCacheIsHealthy)}: Alternates file not found");
}
if (!gitObjectsRootInAlternates)
{
tracer.RelatedInfo($"{nameof(this.EnsureLocalCacheIsHealthy)}: GitObjectsRoot ({enlistment.GitObjectsRoot}) missing from alternates files, recreating alternates");
string error;
if (!this.TryCreateAlternatesFile(fileSystem, enlistment, out error))
{
this.ReportErrorAndExit(tracer, $"Failed to update alternates file to include git objects root: {error}");
}
}
}
else
{
tracer.RelatedInfo($"{nameof(this.EnsureLocalCacheIsHealthy)}: GitObjectsRoot ({enlistment.GitObjectsRoot}) missing, determining new root");
if (cacheServer == null)
{
cacheServer = CacheServerResolver.GetCacheServerFromConfig(enlistment);
}
string error;
if (serverGVFSConfig == null)
{
if (retryConfig == null)
{
if (!RetryConfig.TryLoadFromGitConfig(tracer, enlistment, out retryConfig, out error))
{
this.ReportErrorAndExit(tracer, "Failed to determine GVFS timeout and max retries: " + error);
}
}
serverGVFSConfig = this.QueryGVFSConfig(tracer, enlistment, retryConfig);
}
string localCacheKey;
LocalCacheResolver localCacheResolver = new LocalCacheResolver(enlistment);
if (!localCacheResolver.TryGetLocalCacheKeyFromLocalConfigOrRemoteCacheServers(
tracer,
serverGVFSConfig,
cacheServer,
enlistment.LocalCacheRoot,
localCacheKey: out localCacheKey,
errorMessage: out error))
{
this.ReportErrorAndExit(tracer, $"Previous git objects root ({enlistment.GitObjectsRoot}) not found, and failed to determine new local cache key: {error}");
}
EventMetadata metadata = new EventMetadata();
metadata.Add("localCacheRoot", enlistment.LocalCacheRoot);
metadata.Add("localCacheKey", localCacheKey);
metadata.Add(TracingConstants.MessageKey.InfoMessage, "Initializing and persisting updated paths");
tracer.RelatedEvent(EventLevel.Informational, "GVFSVerb_EnsureLocalCacheIsHealthy_InitializePathsFromKey", metadata);
enlistment.InitializeCachePathsFromKey(enlistment.LocalCacheRoot, localCacheKey);
tracer.RelatedInfo($"{nameof(this.EnsureLocalCacheIsHealthy)}: Creating GitObjectsRoot ({enlistment.GitObjectsRoot}), GitPackRoot ({enlistment.GitPackRoot}), and BlobSizesRoot ({enlistment.BlobSizesRoot})");
try
{
Directory.CreateDirectory(enlistment.GitObjectsRoot);
Directory.CreateDirectory(enlistment.GitPackRoot);
}
catch (Exception e)
{
EventMetadata exceptionMetadata = new EventMetadata();
exceptionMetadata.Add("Exception", e.ToString());
exceptionMetadata.Add("enlistment.LocalCacheRoot", enlistment.LocalCacheRoot);
exceptionMetadata.Add("enlistment.GitObjectsRoot", enlistment.GitObjectsRoot);
exceptionMetadata.Add("enlistment.GitPackRoot", enlistment.GitPackRoot);
exceptionMetadata.Add("enlistment.BlobSizesRoot", enlistment.BlobSizesRoot);
tracer.RelatedError(exceptionMetadata, $"{nameof(this.InitializeLocalCacheAndObjectsPaths)}: Exception while trying to create objects, pack, and sizes folders");
this.ReportErrorAndExit(tracer, "Failed to create objects, pack, and sizes folders");
}
tracer.RelatedInfo($"{nameof(this.EnsureLocalCacheIsHealthy)}: Creating new alternates file");
if (!this.TryCreateAlternatesFile(fileSystem, enlistment, out error))
{
this.ReportErrorAndExit(tracer, $"Failed to update alterates file with new objects path: {error}");
}
tracer.RelatedInfo($"{nameof(this.EnsureLocalCacheIsHealthy)}: Saving git objects root ({enlistment.GitObjectsRoot}) in repo metadata");
RepoMetadata.Instance.SetGitObjectsRoot(enlistment.GitObjectsRoot);
tracer.RelatedInfo($"{nameof(this.EnsureLocalCacheIsHealthy)}: Saving blob sizes root ({enlistment.BlobSizesRoot}) in repo metadata");
RepoMetadata.Instance.SetBlobSizesRoot(enlistment.BlobSizesRoot);
}
// Validate that the BlobSizesRoot folder is on disk.
// Note that if a user performed an action that resulted in the entire .gvfscache being deleted, the code above
// for validating GitObjectsRoot will have already taken care of generating a new key and setting a new enlistment.BlobSizesRoot path
if (!Directory.Exists(enlistment.BlobSizesRoot))
{
tracer.RelatedInfo($"{nameof(this.EnsureLocalCacheIsHealthy)}: BlobSizesRoot ({enlistment.BlobSizesRoot}) not found, re-creating");
try
{
Directory.CreateDirectory(enlistment.BlobSizesRoot);
}
catch (Exception e)
{
EventMetadata exceptionMetadata = new EventMetadata();
exceptionMetadata.Add("Exception", e.ToString());
exceptionMetadata.Add("enlistment.BlobSizesRoot", enlistment.BlobSizesRoot);
tracer.RelatedError(exceptionMetadata, $"{nameof(this.InitializeLocalCacheAndObjectsPaths)}: Exception while trying to create blob sizes folder");
this.ReportErrorAndExit(tracer, "Failed to create blob sizes folder");
}
}
}
public override void Execute()
{
int exitCode = 0;
this.EnlistmentRootPath = this.GetCloneRoot();
this.CheckGVFltHealthy();
this.CheckNotInsideExistingRepo();
try
{
GVFSEnlistment enlistment;
Result cloneResult = new Result(false);
using (JsonEtwTracer tracer = new JsonEtwTracer(GVFSConstants.GVFSEtwProviderName, "GVFSClone"))
{
cloneResult = this.TryCreateEnlistment(out enlistment);
if (cloneResult.Success)
{
tracer.AddLogFileEventListener(
GVFSEnlistment.GetNewGVFSLogFileName(enlistment.GVFSLogsRoot, GVFSConstants.LogFileTypes.Clone),
EventLevel.Informational,
Keywords.Any);
string authErrorMessage = null;
if (!this.ShowStatusWhileRunning(
() => enlistment.Authentication.TryRefreshCredentials(tracer, out authErrorMessage),
"Authenticating"))
{
this.ReportErrorAndExit("Unable to clone because authentication failed");
}
RetryConfig retryConfig;
string error;
if (!RetryConfig.TryLoadFromGitConfig(tracer, enlistment, out retryConfig, out error))
{
this.ReportErrorAndExit("Failed to determine GVFS timeout and max retries: " + error);
}
retryConfig.Timeout = TimeSpan.FromMinutes(RetryConfig.FetchAndCloneTimeoutMinutes);
GVFSConfig gvfsConfig;
CacheServerInfo cacheServer;
using (ConfigHttpRequestor configRequestor = new ConfigHttpRequestor(tracer, enlistment, retryConfig))
{
gvfsConfig = configRequestor.QueryGVFSConfig();
}
if (!CacheServerInfo.TryDetermineCacheServer(this.CacheServerUrl, enlistment, gvfsConfig.CacheServers, out cacheServer, out error))
{
this.ReportErrorAndExit(error);
}
tracer.WriteStartEvent(
enlistment.EnlistmentRoot,
enlistment.RepoUrl,
cacheServer.Url,
new EventMetadata
{
{ "Branch", this.Branch },
{ "SingleBranch", this.SingleBranch },
{ "NoMount", this.NoMount },
{ "NoPrefetch", this.NoPrefetch }
});
this.Output.WriteLine("Clone parameters:");
this.Output.WriteLine(" Repo URL: " + enlistment.RepoUrl);
this.Output.WriteLine(" Cache Server: " + cacheServer);
this.Output.WriteLine(" Destination: " + enlistment.EnlistmentRoot);
this.ValidateClientVersions(tracer, enlistment, gvfsConfig);
this.ShowStatusWhileRunning(
() =>
{
cloneResult = this.TryClone(tracer, enlistment, cacheServer, retryConfig);
return(cloneResult.Success);
},
"Cloning");
}
if (!cloneResult.Success)
{
tracer.RelatedError(cloneResult.ErrorMessage);
}
}
if (cloneResult.Success)
{
if (!this.NoPrefetch)
{
PrefetchVerb prefetch = new PrefetchVerb();
prefetch.EnlistmentRootPath = this.EnlistmentRootPath;
prefetch.Commits = true;
prefetch.Execute();
}
if (this.NoMount)
{
this.Output.WriteLine("\r\nIn order to mount, first cd to within your enlistment, then call: ");
this.Output.WriteLine("gvfs mount");
}
else
{
MountVerb mount = new MountVerb();
mount.EnlistmentRootPath = this.EnlistmentRootPath;
mount.SkipMountedCheck = true;
mount.SkipVersionCheck = true;
mount.ServiceName = this.ServiceName;
mount.Execute();
}
}
else
{
this.Output.WriteLine("\r\nCannot clone @ {0}", this.EnlistmentRootPath);
this.Output.WriteLine("Error: {0}", cloneResult.ErrorMessage);
exitCode = (int)ReturnCode.GenericError;
}
}
catch (AggregateException e)
{
this.Output.WriteLine("Cannot clone @ {0}:", this.EnlistmentRootPath);
foreach (Exception ex in e.Flatten().InnerExceptions)
{
this.Output.WriteLine("Exception: {0}", ex.ToString());
}
exitCode = (int)ReturnCode.GenericError;
}
catch (VerbAbortedException)
{
throw;
}
catch (Exception e)
{
this.ReportErrorAndExit("Cannot clone @ {0}: {1}", this.EnlistmentRootPath, e.ToString());
}
Environment.Exit(exitCode);
}
protected override void Execute(GVFSEnlistment enlistment)
{
using (JsonTracer tracer = new JsonTracer(GVFSConstants.GVFSEtwProviderName, "Dehydrate"))
{
tracer.AddLogFileEventListener(
GVFSEnlistment.GetNewGVFSLogFileName(enlistment.GVFSLogsRoot, GVFSConstants.LogFileTypes.Dehydrate),
EventLevel.Informational,
Keywords.Any);
tracer.WriteStartEvent(
enlistment.EnlistmentRoot,
enlistment.RepoUrl,
CacheServerResolver.GetUrlFromConfig(enlistment),
new EventMetadata
{
{ "Confirmed", this.Confirmed },
{ "NoStatus", this.NoStatus },
{ "NamedPipeName", enlistment.NamedPipeName },
{ nameof(this.EnlistmentRootPathParameter), this.EnlistmentRootPathParameter },
});
if (!this.Confirmed)
{
this.Output.WriteLine(
@"WARNING: THIS IS AN EXPERIMENTAL FEATURE
Dehydrate will back up your src folder, and then create a new, empty src folder
with a fresh virtualization of the repo. All of your downloaded objects, branches,
and siblings of the src folder will be preserved. Your modified working directory
files will be moved to the backup, and your new working directory will not have
any of your uncommitted changes.
Before you dehydrate, make sure you have committed any working directory changes
you want to keep. If you choose not to, you can still find your uncommitted changes
in the backup folder, but it will be harder to find them because 'git status'
will not work in the backup.
To actually execute the dehydrate, run 'gvfs dehydrate --confirm' from the parent
of your enlistment's src folder.
");
return;
}
this.CheckGitStatus(tracer, enlistment);
string backupRoot = Path.GetFullPath(Path.Combine(enlistment.EnlistmentRoot, "dehydrate_backup", DateTime.Now.ToString("yyyyMMdd_HHmmss")));
this.Output.WriteLine();
this.WriteMessage(tracer, "Starting dehydration. All of your existing files will be backed up in " + backupRoot);
this.WriteMessage(tracer, "WARNING: If you abort the dehydrate after this point, the repo may become corrupt");
this.Output.WriteLine();
this.Unmount(tracer);
string error;
if (!DiskLayoutUpgrade.TryCheckDiskLayoutVersion(tracer, enlistment.EnlistmentRoot, out error))
{
this.ReportErrorAndExit(tracer, error);
}
RetryConfig retryConfig;
if (!RetryConfig.TryLoadFromGitConfig(tracer, enlistment, out retryConfig, out error))
{
this.ReportErrorAndExit(tracer, "Failed to determine GVFS timeout and max retries: " + error);
}
// Local cache and objects paths are required for TryDownloadGitObjects
this.InitializeLocalCacheAndObjectsPaths(tracer, enlistment, retryConfig, serverGVFSConfig: null, cacheServer: null);
if (this.TryBackupFiles(tracer, enlistment, backupRoot))
{
if (this.TryDownloadGitObjects(tracer, enlistment, retryConfig) &&
this.TryRecreateIndex(tracer, enlistment))
{
// Converting the src folder to partial must be the final step before mount
this.PrepareSrcFolder(tracer, enlistment);
this.Mount(tracer);
this.Output.WriteLine();
this.WriteMessage(tracer, "The repo was successfully dehydrated and remounted");
}
}
else
{
this.Output.WriteLine();
this.WriteMessage(tracer, "ERROR: Backup failed. We will attempt to mount, but you may need to reclone if that fails");
this.Mount(tracer);
this.WriteMessage(tracer, "Dehydrate failed, but remounting succeeded");
}
}
}
public void Execute()
{
if (this.StartedByVerb)
{
// If this process was started by a verb it means that StartBackgroundVFS4GProcess was used
// and we should be running in the background. PrepareProcessToRunInBackground will perform
// any platform specific preparation required to run as a background process.
GSDPlatform.Instance.PrepareProcessToRunInBackground();
}
GSDEnlistment enlistment = this.CreateEnlistment(this.EnlistmentRootPathParameter);
EventLevel verbosity;
Keywords keywords;
this.ParseEnumArgs(out verbosity, out keywords);
JsonTracer tracer = this.CreateTracer(enlistment, verbosity, keywords);
CacheServerInfo cacheServer = CacheServerResolver.GetCacheServerFromConfig(enlistment);
tracer.WriteStartEvent(
enlistment.EnlistmentRoot,
enlistment.RepoUrl,
cacheServer.Url,
new EventMetadata
{
{ "IsElevated", GSDPlatform.Instance.IsElevated() },
{ nameof(this.EnlistmentRootPathParameter), this.EnlistmentRootPathParameter },
{ nameof(this.StartedByService), this.StartedByService },
{ nameof(this.StartedByVerb), this.StartedByVerb },
});
AppDomain.CurrentDomain.UnhandledException += (object sender, UnhandledExceptionEventArgs e) =>
{
this.UnhandledGSDExceptionHandler(tracer, sender, e);
};
string error;
RetryConfig retryConfig;
if (!RetryConfig.TryLoadFromGitConfig(tracer, enlistment, out retryConfig, out error))
{
this.ReportErrorAndExit(tracer, "Failed to determine GSD timeout and max retries: " + error);
}
GitStatusCacheConfig gitStatusCacheConfig;
if (!GitStatusCacheConfig.TryLoadFromGitConfig(tracer, enlistment, out gitStatusCacheConfig, out error))
{
tracer.RelatedWarning("Failed to determine GSD status cache backoff time: " + error);
gitStatusCacheConfig = GitStatusCacheConfig.DefaultConfig;
}
InProcessMount mountHelper = new InProcessMount(tracer, enlistment, cacheServer, retryConfig, gitStatusCacheConfig, this.ShowDebugWindow);
try
{
mountHelper.Mount(verbosity, keywords);
}
catch (Exception ex)
{
this.ReportErrorAndExit(tracer, "Failed to mount: {0}", ex.Message);
}
}