private void TimerCallback(object unusedState)
{
string errorMessage = null;
InstallerPreRunChecker prerunChecker = new InstallerPreRunChecker(this.tracer, string.Empty);
IProductUpgrader productUpgrader;
bool deleteExistingDownloads = true;
if (ProductUpgraderFactory.TryCreateUpgrader(out productUpgrader, this.tracer, out errorMessage))
{
if (prerunChecker.TryRunPreUpgradeChecks(out string _) && this.TryDownloadUpgrade(productUpgrader, out errorMessage))
{
deleteExistingDownloads = false;
}
}
if (errorMessage != null)
{
this.tracer.RelatedError(errorMessage);
}
if (deleteExistingDownloads)
{
ProductUpgraderInfo.DeleteAllInstallerDownloads();
}
}
private bool TryInitializeUpgrader()
{
if (GVFSPlatform.Instance.UnderConstruction.SupportsGVFSUpgrade)
{
if (this.upgrader == null)
{
JsonTracer jsonTracer = new JsonTracer(GVFSConstants.GVFSEtwProviderName, "UpgradeVerb");
string logFilePath = GVFSEnlistment.GetNewGVFSLogFileName(
ProductUpgrader.GetLogDirectoryPath(),
GVFSConstants.LogFileTypes.UpgradeVerb);
jsonTracer.AddLogFileEventListener(logFilePath, EventLevel.Informational, Keywords.Any);
this.tracer = jsonTracer;
this.prerunChecker = new InstallerPreRunChecker(this.tracer, this.Confirmed ? GVFSConstants.UpgradeVerbMessages.GVFSUpgradeConfirm : GVFSConstants.UpgradeVerbMessages.GVFSUpgrade);
this.upgrader = new ProductUpgrader(ProcessHelper.GetCurrentProcessVersion(), this.tracer);
}
return(true);
}
else
{
this.ReportInfoToConsole($"ERROR: {GVFSConstants.UpgradeVerbMessages.GVFSUpgrade} is not supported on this operating system.");
return(false);
}
}
private bool TryInitializeUpgrader(out string error)
{
if (GVFSPlatform.Instance.UnderConstruction.SupportsGVFSUpgrade)
{
error = null;
if (this.upgrader == null)
{
JsonTracer jsonTracer = new JsonTracer(GVFSConstants.GVFSEtwProviderName, "UpgradeVerb");
string logFilePath = GVFSEnlistment.GetNewGVFSLogFileName(
ProductUpgraderInfo.GetLogDirectoryPath(),
GVFSConstants.LogFileTypes.UpgradeVerb);
jsonTracer.AddLogFileEventListener(logFilePath, EventLevel.Informational, Keywords.Any);
this.tracer = jsonTracer;
this.prerunChecker = new InstallerPreRunChecker(this.tracer, this.Confirmed ? GVFSConstants.UpgradeVerbMessages.GVFSUpgradeConfirm : GVFSConstants.UpgradeVerbMessages.GVFSUpgrade);
IProductUpgrader upgrader;
if (ProductUpgraderFactory.TryCreateUpgrader(out upgrader, this.tracer, out error))
{
this.upgrader = upgrader;
}
else
{
error = $"ERROR: {error}";
}
}
return(this.upgrader != null);
}
else
{
error = $"ERROR: {GVFSConstants.UpgradeVerbMessages.GVFSUpgrade} is not supported on this operating system.";
return(false);
}
}
private bool TryInitializeUpgrader()
{
OperatingSystem os_info = Environment.OSVersion;
if (os_info.Platform == PlatformID.Win32NT)
{
if (this.upgrader == null)
{
JsonTracer jsonTracer = new JsonTracer(GVFSConstants.GVFSEtwProviderName, "UpgradeVerb");
string logFilePath = GVFSEnlistment.GetNewGVFSLogFileName(
ProductUpgrader.GetLogDirectoryPath(),
GVFSConstants.LogFileTypes.UpgradeVerb);
jsonTracer.AddLogFileEventListener(logFilePath, EventLevel.Informational, Keywords.Any);
this.tracer = jsonTracer;
this.prerunChecker = new InstallerPreRunChecker(this.tracer, this.Confirmed ? GVFSConstants.UpgradeVerbMessages.GVFSUpgradeConfirm : GVFSConstants.UpgradeVerbMessages.GVFSUpgrade);
this.upgrader = new ProductUpgrader(ProcessHelper.GetCurrentProcessVersion(), this.tracer);
}
return(true);
}
else
{
this.ReportInfoToConsole($"ERROR: {GVFSConstants.UpgradeVerbMessages.GVFSUpgrade} in only supported on Microsoft Windows Operating System.");
return(false);
}
}
private bool TryInitializeUpgrader(out string error)
{
if (this.DryRun && this.Confirmed)
{
error = $"{DryRunOption} and {ConfirmOption} arguments are not compatible.";
return(false);
}
if (GVFSPlatform.Instance.UnderConstruction.SupportsGVFSUpgrade)
{
error = null;
if (this.upgrader == null)
{
this.productUpgraderPlatformStrategy = GVFSPlatform.Instance.CreateProductUpgraderPlatformInteractions(this.fileSystem, tracer: null);
if (!this.productUpgraderPlatformStrategy.TryPrepareLogDirectory(out error))
{
return(false);
}
JsonTracer jsonTracer = new JsonTracer(GVFSConstants.GVFSEtwProviderName, "UpgradeVerb");
string logFilePath = GVFSEnlistment.GetNewGVFSLogFileName(
ProductUpgraderInfo.GetLogDirectoryPath(),
GVFSConstants.LogFileTypes.UpgradeVerb);
jsonTracer.AddLogFileEventListener(logFilePath, EventLevel.Informational, Keywords.Any);
this.tracer = jsonTracer;
this.prerunChecker = new InstallerPreRunChecker(this.tracer, this.Confirmed ? GVFSPlatform.Instance.Constants.UpgradeConfirmCommandMessage : GVFSConstants.UpgradeVerbMessages.GVFSUpgrade);
string gitBinPath = GVFSPlatform.Instance.GitInstallation.GetInstalledGitBinPath();
if (string.IsNullOrEmpty(gitBinPath))
{
error = $"nameof(this.TryInitializeUpgrader): Unable to locate git installation. Ensure git is installed and try again.";
return(false);
}
ICredentialStore credentialStore = new GitProcess(gitBinPath, workingDirectoryRoot: null);
ProductUpgrader upgrader;
if (ProductUpgrader.TryCreateUpgrader(this.tracer, this.fileSystem, new LocalGVFSConfig(), credentialStore, this.DryRun, this.NoVerify, out upgrader, out error))
{
this.upgrader = upgrader;
}
else
{
error = $"ERROR: {error}";
}
}
return(this.upgrader != null);
}
else
{
error = $"ERROR: {GVFSConstants.UpgradeVerbMessages.GVFSUpgrade} is not supported on this operating system.";
return(false);
}
}
private void TimerCallback(object unusedState)
{
string errorMessage = null;
InstallerPreRunChecker prerunChecker = new InstallerPreRunChecker(this.tracer, string.Empty);
if (prerunChecker.TryRunPreUpgradeChecks(out string _) && !this.TryDownloadUpgrade(out errorMessage))
{
this.tracer.RelatedError(errorMessage);
}
}
private bool TryInitializeUpgrader(out string error)
{
if (this.DryRun && this.Confirmed)
{
error = $"{DryRunOption} and {ConfirmOption} arguments are not compatible.";
return(false);
}
if (GVFSPlatform.Instance.UnderConstruction.SupportsGVFSUpgrade)
{
error = null;
if (this.upgrader == null)
{
// Under normal circumstances ProductUpgraderInfo.GetLogDirectoryPath will have already been created by GVFS.Service. If for some reason it
// does not (e.g. the service failed to start), we need to create ProductUpgraderInfo.GetLogDirectoryPath() explicity to ensure that
// it has the correct ACLs (so that both admin and non-admin users can create log files).
// If the logs directory does not already exist, this call could fail when running as a non-elevated user.
string createDirectoryError;
if (!this.fileSystem.TryCreateDirectoryWithAdminAndUserModifyPermissions(ProductUpgraderInfo.GetLogDirectoryPath(), out createDirectoryError))
{
error = $"ERROR: Unable to create directory `{ProductUpgraderInfo.GetLogDirectoryPath()}`";
error += $"\n{createDirectoryError}";
error += $"\n\nTry running {GVFSConstants.UpgradeVerbMessages.GVFSUpgrade} from an elevated command prompt.";
return(false);
}
JsonTracer jsonTracer = new JsonTracer(GVFSConstants.GVFSEtwProviderName, "UpgradeVerb");
string logFilePath = GVFSEnlistment.GetNewGVFSLogFileName(
ProductUpgraderInfo.GetLogDirectoryPath(),
GVFSConstants.LogFileTypes.UpgradeVerb);
jsonTracer.AddLogFileEventListener(logFilePath, EventLevel.Informational, Keywords.Any);
this.tracer = jsonTracer;
this.prerunChecker = new InstallerPreRunChecker(this.tracer, this.Confirmed ? GVFSConstants.UpgradeVerbMessages.GVFSUpgradeConfirm : GVFSConstants.UpgradeVerbMessages.GVFSUpgrade);
ProductUpgrader upgrader;
if (ProductUpgrader.TryCreateUpgrader(this.tracer, this.fileSystem, this.DryRun, this.NoVerify, out upgrader, out error))
{
this.upgrader = upgrader;
}
else
{
error = $"ERROR: {error}";
}
}
return(this.upgrader != null);
}
else
{
error = $"ERROR: {GVFSConstants.UpgradeVerbMessages.GVFSUpgrade} is not supported on this operating system.";
return(false);
}
}
public UpgradeVerb(
IProductUpgrader upgrader,
ITracer tracer,
InstallerPreRunChecker prerunChecker,
ProcessLauncher processWrapper,
TextWriter output)
{
this.upgrader = upgrader;
this.tracer = tracer;
this.prerunChecker = prerunChecker;
this.processLauncher = processWrapper;
this.Output = output;
}
public UpgradeVerb(
ProductUpgrader upgrader,
ITracer tracer,
PhysicalFileSystem fileSystem,
InstallerPreRunChecker prerunChecker,
ProcessLauncher processWrapper,
TextWriter output)
{
this.upgrader = upgrader;
this.tracer = tracer;
this.fileSystem = fileSystem;
this.prerunChecker = prerunChecker;
this.processLauncher = processWrapper;
this.Output = output;
}
public UpgradeVerb(
ProductUpgrader upgrader,
ITracer tracer,
PhysicalFileSystem fileSystem,
InstallerPreRunChecker prerunChecker,
ProcessLauncher processWrapper,
TextWriter output)
{
this.upgrader = upgrader;
this.tracer = tracer;
this.fileSystem = fileSystem;
this.prerunChecker = prerunChecker;
this.processLauncher = processWrapper;
this.Output = output;
this.productUpgraderPlatformStrategy = GVFSPlatform.Instance.CreateProductUpgraderPlatformInteractions(fileSystem, tracer);
}
private void TimerCallback(object unusedState)
{
string errorMessage = null;
InstallerPreRunChecker prerunChecker = new InstallerPreRunChecker(this.tracer, string.Empty);
ProductUpgrader productUpgrader = new ProductUpgrader(ProcessHelper.GetCurrentProcessVersion(), this.tracer);
if (prerunChecker.TryRunPreUpgradeChecks(out string _) && this.TryDownloadUpgrade(productUpgrader, out errorMessage))
{
return;
}
productUpgrader.CleanupDownloadDirectory();
if (errorMessage != null)
{
this.tracer.RelatedError(errorMessage);
}
}
private void TimerCallback(object unusedState)
{
string errorMessage = null;
using (ITracer activity = this.tracer.StartActivity("Checking for product upgrades.", EventLevel.Informational))
{
try
{
ProductUpgraderInfo info = new ProductUpgraderInfo(
this.tracer,
this.fileSystem);
ProductUpgrader.TryCreateUpgrader(
this.tracer,
this.fileSystem,
new LocalScalarConfig(),
credentialStore: null,
dryRun: false,
noVerify: false,
newUpgrader: out ProductUpgrader productUpgrader,
error: out errorMessage);
if (productUpgrader == null)
{
string message = string.Format(
"{0}.{1}: failed to create upgrader: {2}",
nameof(ProductUpgradeTimer),
nameof(this.TimerCallback),
errorMessage);
activity.RelatedWarning(
metadata: new EventMetadata(),
message: message,
keywords: Keywords.Telemetry);
info.RecordHighestAvailableVersion(highestAvailableVersion: null);
return;
}
if (!productUpgrader.SupportsAnonymousVersionQuery)
{
// If this is a NuGetUpgrader that does not support anonymous version query,
// fall back to using the GitHubUpgrader, to preserve existing behavior.
// Once we have completely transitioned to using the anonymous endpoint,
// we can remove this code.
if (productUpgrader is NuGetUpgrader)
{
productUpgrader = GitHubUpgrader.Create(
this.tracer,
this.fileSystem,
new LocalScalarConfig(),
dryRun: false,
noVerify: false,
error: out errorMessage);
if (productUpgrader == null)
{
string gitHubUpgraderFailedMessage = string.Format(
"{0}.{1}: GitHubUpgrader.Create failed to create upgrader: {2}",
nameof(ProductUpgradeTimer),
nameof(this.TimerCallback),
errorMessage);
activity.RelatedWarning(
metadata: new EventMetadata(),
message: gitHubUpgraderFailedMessage,
keywords: Keywords.Telemetry);
info.RecordHighestAvailableVersion(highestAvailableVersion: null);
return;
}
}
else
{
errorMessage = string.Format(
"{0}.{1}: Configured Product Upgrader does not support anonymous version queries.",
nameof(ProductUpgradeTimer),
nameof(this.TimerCallback),
errorMessage);
activity.RelatedWarning(
metadata: new EventMetadata(),
message: errorMessage,
keywords: Keywords.Telemetry);
info.RecordHighestAvailableVersion(highestAvailableVersion: null);
return;
}
}
InstallerPreRunChecker prerunChecker = new InstallerPreRunChecker(this.tracer, string.Empty);
if (!prerunChecker.TryRunPreUpgradeChecks(out errorMessage))
{
string message = string.Format(
"{0}.{1}: PreUpgradeChecks failed with: {2}",
nameof(ProductUpgradeTimer),
nameof(this.TimerCallback),
errorMessage);
activity.RelatedWarning(
metadata: new EventMetadata(),
message: message,
keywords: Keywords.Telemetry);
info.RecordHighestAvailableVersion(highestAvailableVersion: null);
return;
}
if (!productUpgrader.UpgradeAllowed(out errorMessage))
{
errorMessage = errorMessage ??
$"{nameof(ProductUpgradeTimer)}.{nameof(this.TimerCallback)}: Upgrade is not allowed, but no reason provided.";
activity.RelatedWarning(
metadata: new EventMetadata(),
message: errorMessage,
keywords: Keywords.Telemetry);
info.RecordHighestAvailableVersion(highestAvailableVersion: null);
return;
}
if (!this.TryQueryForNewerVersion(
activity,
productUpgrader,
out Version newerVersion,
out errorMessage))
{
string message = string.Format(
"{0}.{1}: TryQueryForNewerVersion failed with: {2}",
nameof(ProductUpgradeTimer),
nameof(this.TimerCallback),
errorMessage);
activity.RelatedWarning(
metadata: new EventMetadata(),
message: message,
keywords: Keywords.Telemetry);
info.RecordHighestAvailableVersion(highestAvailableVersion: null);
return;
}
info.RecordHighestAvailableVersion(highestAvailableVersion: newerVersion);
this.DisplayUpgradeAvailableToast(newerVersion.ToString());
}
catch (Exception ex) when(
ex is IOException ||
ex is UnauthorizedAccessException ||
ex is NotSupportedException)
{
this.tracer.RelatedWarning(
CreateEventMetadata(ex),
"Exception encountered recording highest available version");
}
catch (Exception ex)
{
this.tracer.RelatedError(
CreateEventMetadata(ex),
"Unhanlded exception encountered recording highest available version");
Environment.Exit((int)ReturnCode.GenericError);
}
}
}
private void TimerCallback(object unusedState)
{
string errorMessage = null;
using (ITracer activity = this.tracer.StartActivity("Checking for product upgrades.", EventLevel.Informational))
{
try
{
ProductUpgraderInfo info = new ProductUpgraderInfo(
this.tracer,
this.fileSystem);
// The upgrade check always goes against GitHub
GitHubUpgrader productUpgrader = GitHubUpgrader.Create(
this.tracer,
this.fileSystem,
dryRun: false,
noVerify: false,
error: out errorMessage);
if (productUpgrader == null)
{
string message = string.Format(
"{0}.{1}: GitHubUpgrader.Create failed to create upgrader: {2}",
nameof(ProductUpgradeTimer),
nameof(this.TimerCallback),
errorMessage);
activity.RelatedWarning(
metadata: new EventMetadata(),
message: message,
keywords: Keywords.Telemetry);
info.RecordHighestAvailableVersion(highestAvailableVersion: null);
return;
}
InstallerPreRunChecker prerunChecker = new InstallerPreRunChecker(this.tracer, string.Empty);
if (!prerunChecker.TryRunPreUpgradeChecks(out errorMessage))
{
string message = string.Format(
"{0}.{1}: PreUpgradeChecks failed with: {2}",
nameof(ProductUpgradeTimer),
nameof(this.TimerCallback),
errorMessage);
activity.RelatedWarning(
metadata: new EventMetadata(),
message: message,
keywords: Keywords.Telemetry);
info.RecordHighestAvailableVersion(highestAvailableVersion: null);
return;
}
if (!productUpgrader.UpgradeAllowed(out errorMessage))
{
errorMessage = errorMessage ??
$"{nameof(ProductUpgradeTimer)}.{nameof(this.TimerCallback)}: Upgrade is not allowed, but no reason provided.";
activity.RelatedWarning(
metadata: new EventMetadata(),
message: errorMessage,
keywords: Keywords.Telemetry);
info.RecordHighestAvailableVersion(highestAvailableVersion: null);
return;
}
if (!this.TryQueryForNewerVersion(
activity,
productUpgrader,
out Version newerVersion,
out errorMessage))
{
string message = string.Format(
"{0}.{1}: TryQueryForNewerVersion failed with: {2}",
nameof(ProductUpgradeTimer),
nameof(this.TimerCallback),
errorMessage);
activity.RelatedWarning(
metadata: new EventMetadata(),
message: message,
keywords: Keywords.Telemetry);
info.RecordHighestAvailableVersion(highestAvailableVersion: null);
return;
}
info.RecordHighestAvailableVersion(highestAvailableVersion: newerVersion);
}
catch (Exception ex) when(
ex is IOException ||
ex is UnauthorizedAccessException ||
ex is NotSupportedException)
{
this.tracer.RelatedWarning(
CreateEventMetadata(ex),
"Exception encountered recording highest available version");
}
catch (Exception ex)
{
this.tracer.RelatedError(
CreateEventMetadata(ex),
"Unhanlded exception encountered recording highest available version");
Environment.Exit((int)ReturnCode.GenericError);
}
}
}
private void TimerCallback(object unusedState)
{
string errorMessage = null;
using (ITracer activity = this.tracer.StartActivity("Checking for product upgrades.", EventLevel.Informational))
{
try
{
ProductUpgraderInfo info = new ProductUpgraderInfo(
this.tracer,
this.fileSystem);
ProductUpgrader.TryCreateUpgrader(
this.tracer,
this.fileSystem,
new LocalScalarConfig(),
credentialStore: null,
dryRun: false,
noVerify: false,
newUpgrader: out ProductUpgrader productUpgrader,
error: out errorMessage);
if (productUpgrader == null)
{
string message = string.Format(
"{0}.{1}: failed to create upgrader: {2}",
nameof(ProductUpgradeTimer),
nameof(this.TimerCallback),
errorMessage);
activity.RelatedWarning(
metadata: new EventMetadata(),
message: message,
keywords: Keywords.Telemetry);
info.RecordHighestAvailableVersion(highestAvailableVersion: null);
return;
}
InstallerPreRunChecker prerunChecker = new InstallerPreRunChecker(this.tracer, string.Empty);
if (!prerunChecker.TryRunPreUpgradeChecks(out errorMessage))
{
string message = string.Format(
"{0}.{1}: PreUpgradeChecks failed with: {2}",
nameof(ProductUpgradeTimer),
nameof(this.TimerCallback),
errorMessage);
activity.RelatedWarning(
metadata: new EventMetadata(),
message: message,
keywords: Keywords.Telemetry);
info.RecordHighestAvailableVersion(highestAvailableVersion: null);
return;
}
if (!productUpgrader.UpgradeAllowed(out errorMessage))
{
errorMessage = errorMessage ??
$"{nameof(ProductUpgradeTimer)}.{nameof(this.TimerCallback)}: Upgrade is not allowed, but no reason provided.";
activity.RelatedWarning(
metadata: new EventMetadata(),
message: errorMessage,
keywords: Keywords.Telemetry);
info.RecordHighestAvailableVersion(highestAvailableVersion: null);
return;
}
if (!this.TryQueryForNewerVersion(
activity,
productUpgrader,
out Version newerVersion,
out errorMessage))
{
string message = string.Format(
"{0}.{1}: TryQueryForNewerVersion failed with: {2}",
nameof(ProductUpgradeTimer),
nameof(this.TimerCallback),
errorMessage);
activity.RelatedWarning(
metadata: new EventMetadata(),
message: message,
keywords: Keywords.Telemetry);
info.RecordHighestAvailableVersion(highestAvailableVersion: null);
return;
}
info.RecordHighestAvailableVersion(highestAvailableVersion: newerVersion);
this.DisplayUpgradeAvailableToast(newerVersion.ToString());
}
catch (Exception ex)
{
this.tracer.RelatedWarning(
CreateEventMetadata(ex),
"Exception encountered recording highest available version");
}
}
}
