public bool Mount(string repoRoot)
{
if (!ProjFSFilter.IsServiceRunning(this.tracer))
{
string error;
if (!EnableAndAttachProjFSHandler.TryEnablePrjFlt(this.tracer, out error))
{
this.tracer.RelatedError($"{nameof(this.Mount)}: Unable to start the GVFS.exe process: {error}");
}
}
if (!this.CallGVFSMount(repoRoot))
{
this.tracer.RelatedError($"{nameof(this.Mount)}: Unable to start the GVFS.exe process.");
return(false);
}
string errorMessage;
if (!GVFSEnlistment.WaitUntilMounted(repoRoot, false, out errorMessage))
{
this.tracer.RelatedError(errorMessage);
return(false);
}
return(true);
}
public void Run()
{
string errorMessage;
NamedPipeMessages.CompletionState state = NamedPipeMessages.CompletionState.Success;
if (!TryEnablePrjFlt(this.tracer, out errorMessage))
{
state = NamedPipeMessages.CompletionState.Failure;
this.tracer.RelatedError("Unable to install or enable PrjFlt. Enlistment root: {0} \nError: {1} ", this.request.EnlistmentRoot, errorMessage);
}
if (!string.IsNullOrEmpty(this.request.EnlistmentRoot))
{
if (!ProjFSFilter.TryAttach(this.request.EnlistmentRoot, out errorMessage))
{
state = NamedPipeMessages.CompletionState.Failure;
this.tracer.RelatedError("Unable to attach filter to volume. Enlistment root: {0} \nError: {1} ", this.request.EnlistmentRoot, errorMessage);
}
}
NamedPipeMessages.EnableAndAttachProjFSRequest.Response response = new NamedPipeMessages.EnableAndAttachProjFSRequest.Response();
response.State = state;
response.ErrorMessage = errorMessage;
this.WriteToClient(response.ToMessage(), this.connection, this.tracer);
}
public void TryCopyNativeLibIfDriverVersionsMatch_ReturnsFalseWhenLibMissingFromPackagedLocation()
{
this.mockFileSystem.Setup(fileSystem => fileSystem.FileExists(this.system32NativeLibPath)).Returns(false);
this.mockFileSystem.Setup(fileSystem => fileSystem.FileExists(this.nonInboxNativeLibInstallPath)).Returns(false);
this.mockFileSystem.Setup(fileSystem => fileSystem.FileExists(this.packagedNativeLibPath)).Returns(false);
ProjFSFilter.TryCopyNativeLibIfDriverVersionsMatch(this.mockTracer, this.mockFileSystem.Object, out string _).ShouldBeFalse();
}
public bool MountRepository(string repoRoot, int sessionId)
{
if (!ProjFSFilter.IsServiceRunning(this.tracer))
{
string error;
if (!EnableAndAttachProjFSHandler.TryEnablePrjFlt(this.tracer, out error))
{
this.tracer.RelatedError($"{nameof(this.MountRepository)}: Could not enable PrjFlt: {error}");
return(false);
}
}
using (CurrentUser currentUser = new CurrentUser(this.tracer, sessionId))
{
if (!this.CallGVFSMount(repoRoot, currentUser))
{
this.tracer.RelatedError($"{nameof(this.MountRepository)}: Unable to start the GVFS.exe process.");
return(false);
}
string errorMessage;
if (!GVFSEnlistment.WaitUntilMounted(repoRoot, false, out errorMessage))
{
this.tracer.RelatedError(errorMessage);
return(false);
}
}
return(true);
}
public void TryCopyNativeLibIfDriverVersionsMatch_ReturnsFalseWhenFileVersionDoesNotMatch()
{
this.mockFileSystem.Setup(fileSystem => fileSystem.FileExists(this.system32NativeLibPath)).Returns(false);
this.mockFileSystem.Setup(fileSystem => fileSystem.FileExists(this.nonInboxNativeLibInstallPath)).Returns(false);
this.mockFileSystem.Setup(fileSystem => fileSystem.FileExists(this.packagedNativeLibPath)).Returns(true);
this.mockFileSystem.Setup(fileSystem => fileSystem.FileExists(this.packagedDriverPath)).Returns(true);
this.mockFileSystem.Setup(fileSystem => fileSystem.FileExists(this.system32DriverPath)).Returns(true);
this.mockFileSystem.Setup(fileSystem => fileSystem.GetVersionInfo(this.packagedDriverPath)).Returns(this.dummyVersionInfo);
this.mockFileSystem.Setup(fileSystem => fileSystem.GetVersionInfo(this.system32DriverPath)).Returns(this.dummyVersionInfo);
this.mockFileSystem.Setup(fileSystem => fileSystem.FileVersionsMatch(this.dummyVersionInfo, this.dummyVersionInfo)).Returns(false);
ProjFSFilter.TryCopyNativeLibIfDriverVersionsMatch(this.mockTracer, this.mockFileSystem.Object, out string _).ShouldBeFalse();
}
public void TryCopyNativeLibIfDriverVersionsMatch_ReturnsFalseWhenCopyingNativeLibFails()
{
this.mockFileSystem.Setup(fileSystem => fileSystem.FileExists(this.system32NativeLibPath)).Returns(false);
this.mockFileSystem.Setup(fileSystem => fileSystem.FileExists(this.nonInboxNativeLibInstallPath)).Returns(false);
this.mockFileSystem.Setup(fileSystem => fileSystem.FileExists(this.packagedNativeLibPath)).Returns(true);
this.mockFileSystem.Setup(fileSystem => fileSystem.FileExists(this.packagedDriverPath)).Returns(true);
this.mockFileSystem.Setup(fileSystem => fileSystem.FileExists(this.system32DriverPath)).Returns(true);
this.mockFileSystem.Setup(fileSystem => fileSystem.GetVersionInfo(this.packagedDriverPath)).Returns(this.dummyVersionInfo);
this.mockFileSystem.Setup(fileSystem => fileSystem.GetVersionInfo(this.system32DriverPath)).Returns(this.dummyVersionInfo);
this.mockFileSystem.Setup(fileSystem => fileSystem.FileVersionsMatch(this.dummyVersionInfo, this.dummyVersionInfo)).Returns(true);
this.mockFileSystem.Setup(fileSystem => fileSystem.ProductVersionsMatch(this.dummyVersionInfo, this.dummyVersionInfo)).Returns(true);
this.mockFileSystem.Setup(fileSystem => fileSystem.CopyFile(this.packagedNativeLibPath, this.nonInboxNativeLibInstallPath, true)).Throws(new IOException());
ProjFSFilter.TryCopyNativeLibIfDriverVersionsMatch(this.mockTracer, this.mockFileSystem.Object, out string _).ShouldBeFalse();
}
public void TryCopyNativeLibIfDriverVersionsMatch_ReturnsTrueOnSuccess()
{
this.mockFileSystem.Setup(fileSystem => fileSystem.FileExists(this.system32NativeLibPath)).Returns(false);
this.mockFileSystem.Setup(fileSystem => fileSystem.FileExists(this.nonInboxNativeLibInstallPath)).Returns(false);
this.mockFileSystem.Setup(fileSystem => fileSystem.FileExists(this.packagedNativeLibPath)).Returns(true);
this.mockFileSystem.Setup(fileSystem => fileSystem.FileExists(this.packagedDriverPath)).Returns(true);
this.mockFileSystem.Setup(fileSystem => fileSystem.FileExists(this.system32DriverPath)).Returns(true);
this.mockFileSystem.Setup(fileSystem => fileSystem.GetVersionInfo(this.packagedDriverPath)).Returns(this.dummyVersionInfo);
this.mockFileSystem.Setup(fileSystem => fileSystem.GetVersionInfo(this.system32DriverPath)).Returns(this.dummyVersionInfo);
this.mockFileSystem.Setup(fileSystem => fileSystem.FileVersionsMatch(this.dummyVersionInfo, this.dummyVersionInfo)).Returns(true);
this.mockFileSystem.Setup(fileSystem => fileSystem.ProductVersionsMatch(this.dummyVersionInfo, this.dummyVersionInfo)).Returns(true);
this.mockFileSystem.Setup(fileSystem => fileSystem.CopyFile(this.packagedNativeLibPath, this.nonInboxNativeLibInstallPath, true));
this.mockFileSystem.Setup(fileSystem => fileSystem.FlushFileBuffers(this.nonInboxNativeLibInstallPath));
ProjFSFilter.TryCopyNativeLibIfDriverVersionsMatch(this.mockTracer, this.mockFileSystem.Object, out string _).ShouldBeTrue();
}
public static bool TryEnablePrjFlt(ITracer tracer, out string error)
{
error = null;
EventMetadata prjFltHealthMetadata = new EventMetadata();
prjFltHealthMetadata.Add("Area", EtwArea);
PhysicalFileSystem fileSystem = new PhysicalFileSystem();
lock (enablePrjFltLock)
{
bool isServiceInstalled;
bool isDriverFileInstalled;
bool isNativeLibInstalled;
bool isRunning = ProjFSFilter.IsServiceRunningAndInstalled(tracer, fileSystem, out isServiceInstalled, out isDriverFileInstalled, out isNativeLibInstalled);
bool isInstalled = isServiceInstalled && isDriverFileInstalled && isNativeLibInstalled;
prjFltHealthMetadata.Add($"Initial_{nameof(isRunning)}", isRunning);
prjFltHealthMetadata.Add($"Initial_{nameof(isServiceInstalled)}", isServiceInstalled);
prjFltHealthMetadata.Add($"Initial_{nameof(isDriverFileInstalled)}", isDriverFileInstalled);
prjFltHealthMetadata.Add($"Initial_{nameof(isNativeLibInstalled)}", isNativeLibInstalled);
prjFltHealthMetadata.Add($"Initial_{nameof(isInstalled)}", isInstalled);
if (!isRunning)
{
if (!isInstalled)
{
uint windowsBuildNumber;
bool isInboxProjFSFinalAPI;
bool isProjFSFeatureAvailable;
if (ProjFSFilter.TryEnableOrInstallDriver(tracer, fileSystem, out windowsBuildNumber, out isInboxProjFSFinalAPI, out isProjFSFeatureAvailable))
{
isInstalled = true;
}
else
{
error = "Failed to install (or enable) PrjFlt";
tracer.RelatedError($"{nameof(TryEnablePrjFlt)}: {error}");
}
prjFltHealthMetadata.Add(nameof(windowsBuildNumber), windowsBuildNumber);
prjFltHealthMetadata.Add(nameof(isInboxProjFSFinalAPI), isInboxProjFSFinalAPI);
prjFltHealthMetadata.Add(nameof(isProjFSFeatureAvailable), isProjFSFeatureAvailable);
}
if (isInstalled)
{
if (ProjFSFilter.TryStartService(tracer))
{
isRunning = true;
}
else
{
error = "Failed to start prjflt service";
tracer.RelatedError($"{nameof(TryEnablePrjFlt)}: {error}");
}
}
}
isNativeLibInstalled = ProjFSFilter.IsNativeLibInstalled(tracer, new PhysicalFileSystem());
if (!isNativeLibInstalled)
{
string missingNativeLibMessage = "Native library is not installed";
error = string.IsNullOrEmpty(error) ? missingNativeLibMessage : $"{error}. {missingNativeLibMessage}";
tracer.RelatedError($"{nameof(TryEnablePrjFlt)}: {missingNativeLibMessage}");
}
bool isAutoLoggerEnabled = ProjFSFilter.IsAutoLoggerEnabled(tracer);
prjFltHealthMetadata.Add($"Initial_{nameof(isAutoLoggerEnabled)}", isAutoLoggerEnabled);
if (!isAutoLoggerEnabled)
{
if (ProjFSFilter.TryEnableAutoLogger(tracer))
{
isAutoLoggerEnabled = true;
}
else
{
tracer.RelatedError($"{nameof(TryEnablePrjFlt)}: Failed to enable prjflt AutoLogger");
}
}
prjFltHealthMetadata.Add(nameof(isInstalled), isInstalled);
prjFltHealthMetadata.Add(nameof(isRunning), isRunning);
prjFltHealthMetadata.Add(nameof(isAutoLoggerEnabled), isAutoLoggerEnabled);
prjFltHealthMetadata.Add(nameof(isNativeLibInstalled), isNativeLibInstalled);
tracer.RelatedEvent(EventLevel.Informational, $"{nameof(TryEnablePrjFlt)}_Summary", prjFltHealthMetadata, Keywords.Telemetry);
return(isInstalled && isRunning);
}
}
public static bool TryEnablePrjFlt(ITracer tracer, out string error)
{
error = null;
EventMetadata prjFltHealthMetadata = new EventMetadata();
prjFltHealthMetadata.Add("Area", EtwArea);
PhysicalFileSystem fileSystem = new PhysicalFileSystem();
lock (enablePrjFltLock)
{
bool isPrjfltServiceInstalled;
bool isPrjfltDriverInstalled;
bool isNativeProjFSLibInstalled;
bool isPrjfltServiceRunning = ProjFSFilter.IsServiceRunningAndInstalled(tracer, fileSystem, out isPrjfltServiceInstalled, out isPrjfltDriverInstalled, out isNativeProjFSLibInstalled);
prjFltHealthMetadata.Add($"Initial_{nameof(isPrjfltDriverInstalled)}", isPrjfltDriverInstalled);
prjFltHealthMetadata.Add($"Initial_{nameof(isPrjfltServiceInstalled)}", isPrjfltServiceInstalled);
prjFltHealthMetadata.Add($"Initial_{nameof(isPrjfltServiceRunning)}", isPrjfltServiceRunning);
prjFltHealthMetadata.Add($"Initial_{nameof(isNativeProjFSLibInstalled)}", isNativeProjFSLibInstalled);
if (!isPrjfltServiceRunning)
{
if (!isPrjfltServiceInstalled || !isPrjfltDriverInstalled)
{
uint windowsBuildNumber;
bool isInboxProjFSFinalAPI;
bool isProjFSFeatureAvailable;
if (ProjFSFilter.TryEnableOrInstallDriver(tracer, fileSystem, out windowsBuildNumber, out isInboxProjFSFinalAPI, out isProjFSFeatureAvailable))
{
isPrjfltServiceInstalled = true;
isPrjfltDriverInstalled = true;
}
else
{
error = "Failed to install (or enable) PrjFlt";
tracer.RelatedError($"{nameof(TryEnablePrjFlt)}: {error}");
}
prjFltHealthMetadata.Add(nameof(windowsBuildNumber), windowsBuildNumber);
prjFltHealthMetadata.Add(nameof(isInboxProjFSFinalAPI), isInboxProjFSFinalAPI);
prjFltHealthMetadata.Add(nameof(isProjFSFeatureAvailable), isProjFSFeatureAvailable);
}
if (isPrjfltServiceInstalled)
{
if (ProjFSFilter.TryStartService(tracer))
{
isPrjfltServiceRunning = true;
}
else
{
error = "Failed to start prjflt service";
tracer.RelatedError($"{nameof(TryEnablePrjFlt)}: {error}");
}
}
}
// Check again if the native library is installed. If the code above enabled the
// ProjFS optional feature then the native library will now be installed.
isNativeProjFSLibInstalled = ProjFSFilter.IsNativeLibInstalled(tracer, fileSystem);
if (!isNativeProjFSLibInstalled)
{
if (isPrjfltServiceRunning)
{
tracer.RelatedInfo($"{nameof(TryEnablePrjFlt)}: Native ProjFS library is not installed, attempting to copy version packaged with VFS for Git");
EventLevel eventLevel;
EventMetadata copyNativeLibMetadata = new EventMetadata();
copyNativeLibMetadata.Add("Area", EtwArea);
string copyNativeDllError = string.Empty;
if (ProjFSFilter.TryCopyNativeLibIfDriverVersionsMatch(tracer, new PhysicalFileSystem(), out copyNativeDllError))
{
isNativeProjFSLibInstalled = true;
eventLevel = EventLevel.Warning;
copyNativeLibMetadata.Add(TracingConstants.MessageKey.WarningMessage, $"{nameof(TryEnablePrjFlt)}: Successfully copied ProjFS native library");
}
else
{
error = $"Native ProjFS library is not installed and could not be copied: {copyNativeDllError}";
eventLevel = EventLevel.Error;
copyNativeLibMetadata.Add(nameof(copyNativeDllError), copyNativeDllError);
copyNativeLibMetadata.Add(TracingConstants.MessageKey.ErrorMessage, $"{nameof(TryEnablePrjFlt)}: Failed to copy ProjFS native library");
}
copyNativeLibMetadata.Add(nameof(isNativeProjFSLibInstalled), isNativeProjFSLibInstalled);
tracer.RelatedEvent(
eventLevel,
$"{nameof(TryEnablePrjFlt)}_{nameof(ProjFSFilter.TryCopyNativeLibIfDriverVersionsMatch)}",
copyNativeLibMetadata,
Keywords.Telemetry);
}
else
{
error = "Native ProjFS library is not installed, did not attempt to copy library because prjflt service is not running";
tracer.RelatedError($"{nameof(TryEnablePrjFlt)}: {error}");
}
}
bool isAutoLoggerEnabled = ProjFSFilter.IsAutoLoggerEnabled(tracer);
prjFltHealthMetadata.Add($"Initial_{nameof(isAutoLoggerEnabled)}", isAutoLoggerEnabled);
if (!isAutoLoggerEnabled)
{
if (ProjFSFilter.TryEnableAutoLogger(tracer))
{
isAutoLoggerEnabled = true;
}
else
{
tracer.RelatedError($"{nameof(TryEnablePrjFlt)}: Failed to enable prjflt AutoLogger");
}
}
prjFltHealthMetadata.Add(nameof(isPrjfltDriverInstalled), isPrjfltDriverInstalled);
prjFltHealthMetadata.Add(nameof(isPrjfltServiceInstalled), isPrjfltServiceInstalled);
prjFltHealthMetadata.Add(nameof(isPrjfltServiceRunning), isPrjfltServiceRunning);
prjFltHealthMetadata.Add(nameof(isNativeProjFSLibInstalled), isNativeProjFSLibInstalled);
prjFltHealthMetadata.Add(nameof(isAutoLoggerEnabled), isAutoLoggerEnabled);
tracer.RelatedEvent(EventLevel.Informational, $"{nameof(TryEnablePrjFlt)}_Summary", prjFltHealthMetadata, Keywords.Telemetry);
return(isPrjfltDriverInstalled && isPrjfltServiceInstalled && isPrjfltServiceRunning && isNativeProjFSLibInstalled);
}
}
protected override void Execute(GVFSEnlistment enlistment)
{
string errorMessage = null;
if (!HooksInstaller.InstallHooks(enlistment, out errorMessage))
{
this.ReportErrorAndExit("Error installing hooks: " + errorMessage);
}
string mountExeLocation = null;
using (JsonEtwTracer tracer = new JsonEtwTracer(GVFSConstants.GVFSEtwProviderName, "PreMount"))
{
CacheServerInfo cacheServer = this.ResolvedCacheServer ?? CacheServerResolver.GetCacheServerFromConfig(enlistment);
tracer.AddLogFileEventListener(
GVFSEnlistment.GetNewGVFSLogFileName(enlistment.GVFSLogsRoot, GVFSConstants.LogFileTypes.MountVerb),
EventLevel.Verbose,
Keywords.Any);
tracer.WriteStartEvent(
enlistment.EnlistmentRoot,
enlistment.RepoUrl,
cacheServer.Url,
new EventMetadata
{
{ "Unattended", this.Unattended },
{ "IsElevated", ProcessHelper.IsAdminElevated() },
});
// TODO 1050199: Once the service is an optional component, GVFS should only attempt to attach
// the filter via the service if the service is present\enabled
if (!ProjFSFilter.IsServiceRunning(tracer) ||
!ProjFSFilter.IsNativeLibInstalled(tracer, new PhysicalFileSystem()) ||
!ProjFSFilter.TryAttach(tracer, enlistment.EnlistmentRoot, out errorMessage))
{
tracer.RelatedInfo($"{nameof(MountVerb)}.{nameof(this.Execute)}: Enabling and attaching ProjFS through service");
if (!this.ShowStatusWhileRunning(
() => { return(this.TryEnableAndAttachGvFltThroughService(enlistment.EnlistmentRoot, out errorMessage)); },
$"Attaching {ProjFSFilter.ServiceName} to volume"))
{
this.ReportErrorAndExit(tracer, ReturnCode.FilterError, errorMessage);
}
}
RetryConfig retryConfig = null;
GVFSConfig gvfsConfig = this.DownloadedGVFSConfig;
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.");
}
if (gvfsConfig == null)
{
if (retryConfig == null)
{
retryConfig = this.GetRetryConfig(tracer, enlistment);
}
gvfsConfig = this.QueryGVFSConfig(tracer, enlistment, retryConfig);
}
this.ValidateClientVersions(tracer, enlistment, gvfsConfig, showWarnings: true);
CacheServerResolver cacheServerResolver = new CacheServerResolver(tracer, enlistment);
cacheServer = cacheServerResolver.ResolveNameFromRemote(cacheServer.Url, gvfsConfig);
this.Output.WriteLine("Configured cache server: " + cacheServer);
}
this.InitializeLocalCacheAndObjectsPaths(tracer, enlistment, retryConfig, gvfsConfig, cacheServer);
if (!this.ShowStatusWhileRunning(
() => { return(this.PerformPreMountValidation(tracer, enlistment, out mountExeLocation, out errorMessage)); },
"Validating repo"))
{
this.ReportErrorAndExit(tracer, errorMessage);
}
if (!this.SkipVersionCheck)
{
string error;
if (!RepoMetadata.TryInitialize(tracer, enlistment.DotGVFSRoot, out error))
{
this.ReportErrorAndExit(tracer, error);
}
try
{
EventMetadata metadata = new EventMetadata();
metadata.Add(nameof(RepoMetadata.Instance.EnlistmentId), RepoMetadata.Instance.EnlistmentId);
metadata.Add("Enlistment", enlistment);
tracer.RelatedEvent(EventLevel.Informational, "EnlistmentInfo", metadata, Keywords.Telemetry);
GitProcess git = new GitProcess(enlistment, new PhysicalFileSystem());
GitProcess.Result configResult = git.SetInLocalConfig(GVFSConstants.GitConfig.EnlistmentId, RepoMetadata.Instance.EnlistmentId, replaceAll: true);
if (configResult.HasErrors)
{
error = "Could not update config with enlistment id, error: " + configResult.Errors;
tracer.RelatedWarning(error);
}
}
finally
{
RepoMetadata.Shutdown();
}
}
}
if (!this.ShowStatusWhileRunning(
() => { return(this.TryMount(enlistment, mountExeLocation, out errorMessage)); },
"Mounting"))
{
this.ReportErrorAndExit(errorMessage);
}
if (!this.Unattended)
{
if (!this.ShowStatusWhileRunning(
() => { return(this.RegisterMount(enlistment, out errorMessage)); },
"Registering for automount"))
{
this.Output.WriteLine(" WARNING: " + errorMessage);
}
}
}
public static bool TryEnablePrjFlt(ITracer tracer, out string error)
{
error = null;
EventMetadata prjFltHealthMetdata = new EventMetadata();
prjFltHealthMetdata.Add("Area", EtwArea);
PhysicalFileSystem fileSystem = new PhysicalFileSystem();
lock (enablePrjFltLock)
{
bool isServiceInstalled;
bool isDriverFileInstalled;
bool isNativeLibInstalled;
bool isRunning = ProjFSFilter.IsServiceRunningAndInstalled(tracer, fileSystem, out isServiceInstalled, out isDriverFileInstalled, out isNativeLibInstalled);
bool isInstalled = isServiceInstalled && isDriverFileInstalled && isNativeLibInstalled;
prjFltHealthMetdata.Add($"Initial_{nameof(isRunning)}", isRunning);
prjFltHealthMetdata.Add($"Initial_{nameof(isServiceInstalled)}", isServiceInstalled);
prjFltHealthMetdata.Add($"Initial_{nameof(isDriverFileInstalled)}", isDriverFileInstalled);
prjFltHealthMetdata.Add($"Initial_{nameof(isNativeLibInstalled)}", isNativeLibInstalled);
prjFltHealthMetdata.Add($"Initial_{nameof(isInstalled)}", isInstalled);
if (!isRunning)
{
if (!isInstalled)
{
if (ProjFSFilter.TryEnableOrInstallDriver(tracer, fileSystem))
{
isInstalled = true;
}
else
{
error = "Failed to install (or enable) PrjFlt";
tracer.RelatedError($"{nameof(TryEnablePrjFlt)}: {error}");
}
}
if (isInstalled)
{
if (ProjFSFilter.TryStartService(tracer))
{
isRunning = true;
}
else
{
error = "Failed to start prjflt service";
tracer.RelatedError($"{nameof(TryEnablePrjFlt)}: {error}");
}
}
}
else if (!isNativeLibInstalled)
{
tracer.RelatedWarning($"{nameof(TryEnablePrjFlt)}: prjflt service is running, but native library is not installed");
if (ProjFSFilter.TryInstallNativeLib(tracer, fileSystem))
{
isInstalled = true;
}
else
{
error = "Failed to install native ProjFs library";
tracer.RelatedError($"{nameof(TryEnablePrjFlt)}: {error}");
}
}
bool isAutoLoggerEnabled = ProjFSFilter.IsAutoLoggerEnabled(tracer);
prjFltHealthMetdata.Add("InitiallyAutoLoggerEnabled", isAutoLoggerEnabled);
if (!isAutoLoggerEnabled)
{
if (ProjFSFilter.TryEnableAutoLogger(tracer))
{
isAutoLoggerEnabled = true;
}
else
{
tracer.RelatedError($"{nameof(TryEnablePrjFlt)}: Failed to enable prjflt AutoLogger");
}
}
prjFltHealthMetdata.Add(nameof(isInstalled), isInstalled);
prjFltHealthMetdata.Add(nameof(isRunning), isRunning);
prjFltHealthMetdata.Add(nameof(isAutoLoggerEnabled), isAutoLoggerEnabled);
tracer.RelatedEvent(EventLevel.Informational, $"{nameof(TryEnablePrjFlt)}_Summary", prjFltHealthMetdata, Keywords.Telemetry);
return(isInstalled && isRunning);
}
}
public void TryCopyNativeLibIfDriverVersionsMatch_ReturnsFalseWhenLibInSystem32()
{
this.mockFileSystem.Setup(fileSystem => fileSystem.FileExists(this.system32NativeLibPath)).Returns(true);
ProjFSFilter.TryCopyNativeLibIfDriverVersionsMatch(this.mockTracer, this.mockFileSystem.Object, out string _).ShouldBeFalse();
}
public void IsNativeLibInstalled_ReturnsFalseWhenNativeLibraryDoesNotExistInAnyInstallLocation()
{
this.mockFileSystem.Setup(fileSystem => fileSystem.FileExists(It.IsAny <string>())).Returns(false);
ProjFSFilter.IsNativeLibInstalled(this.mockTracer, this.mockFileSystem.Object).ShouldBeFalse();
}
public void IsNativeLibInstalled_ReturnsTrueWhenLibInNonInboxInstallLocation()
{
this.mockFileSystem.Setup(fileSystem => fileSystem.FileExists(this.system32NativeLibPath)).Returns(false);
this.mockFileSystem.Setup(fileSystem => fileSystem.FileExists(this.nonInboxNativeLibInstallPath)).Returns(true);
ProjFSFilter.IsNativeLibInstalled(this.mockTracer, this.mockFileSystem.Object).ShouldBeTrue();
}