public bool Install(string extensionPath, bool?allUsers = default)
{
var installableExtension = extensionManager.CreateInstallableExtension(extensionPath);
if (extensionManager.TryGetInstalledExtension(installableExtension.Header.Identifier, out var installedExtension))
{
if (IsUpToDate(installableExtension, installedExtension))
{
Console.WriteLine($"Extension {NameVer(installedExtension)} is up to date.");
if (installedExtension.State != EnabledState.Enabled)
{
extensionManager.Enable(installedExtension);
}
return(false);
}
Uninstall(installableExtension.Header.Identifier, skipGlobal: GetIsExperimentalProperty(installableExtension.Header) != null);
}
if (extensionManager.TryGetInstalledExtension(installableExtension.Header.Identifier, out var globalExtension) && globalExtension.InstalledPerMachine)
{
if (installableExtension.Header.Version <= globalExtension.Header.Version)
{
throw new Exception($"Extension '{NameVer(installableExtension)}' version must be higher than the globally installed extension '{NameVer(globalExtension)}'.");
}
SetIsExperimental(installableExtension.Header, true);
}
if (allUsers.HasValue)
{
SetAllUsers(installableExtension.Header, allUsers.Value);
}
Console.WriteLine($"Installing {NameVer(installableExtension)}");
extensionManager.Install(installableExtension, installableExtension.Header.AllUsers);
ExtensionManagerUtil.EnableLoadingExtensionsFromLocalAppData(externalSettingsManager);
ExtensionManagerUtil.RemovePendingExtensionDeletion(externalSettingsManager, installableExtension.Header);
ExtensionManagerService.UpdateLastExtensionsChange();
var newlyInstalledExtension = extensionManager.GetInstalledExtension(installableExtension.Header.Identifier);
extensionManager.Enable(newlyInstalledExtension);
File.SetLastWriteTime(GetManifestPath(newlyInstalledExtension), DateTime.Now);
if (!IsUpToDate(installableExtension, newlyInstalledExtension))
{
throw new Exception($"Failed installing extension '{NameVer(installableExtension)}'.");
}
return(true);
}
public bool InstallExtension(string extensionPath)
{
var installableExtension = extensionManager.CreateInstallableExtension(extensionPath);
var packageWriteDateTime = File.GetLastWriteTime(installableExtension.PackagePath);
var installedExtension = default(IInstalledExtension);
if (extensionManager.IsInstalled(installableExtension))
{
installedExtension = extensionManager.GetInstalledExtension(installableExtension.Header.Identifier);
var installedOn = File.GetLastWriteTime(GetManifestPath(installedExtension)); // installedExtension.InstalledOn throws
if (installableExtension.Header.Version == installedExtension.Header.Version && packageWriteDateTime < installedOn)
{
Console.WriteLine($"Extension {NameVer(installedExtension)} is up to date.");
extensionManager.Enable(installedExtension);
return(false);
}
Console.WriteLine($"Uninstalling {NameVer(installedExtension)}");
extensionManager.Uninstall(installedExtension);
}
if (installableExtension.Header.AllUsers)
{
var header = installableExtension.Header;
header.GetType().GetProperty(nameof(header.AllUsers)).SetValue(header, false);
}
Console.WriteLine($"Installing {NameVer(installableExtension)}");
extensionManager.Install(installableExtension, false);
var newlyInstalledExtension = extensionManager.GetInstalledExtension(installableExtension.Header.Identifier);
extensionManager.Enable(newlyInstalledExtension);
File.SetLastWriteTime(GetManifestPath(newlyInstalledExtension), DateTime.Now);
if (installedExtension != null && !PathUtil.ArePathEqual(installedExtension.InstallPath, newlyInstalledExtension.InstallPath))
{
Console.WriteLine($"Removing {installedExtension.InstallPath}");
if (!DirectoryUtil.TryDeleteHard(installedExtension.InstallPath, recursive: true))
{
Console.WriteLine($"The directory {installedExtension.InstallPath} could not be deleted completely. If you do not delete it manually, it will waste disk space.");
}
}
return(true);
}
private void RunInstall(string extensionPath)
{
try
{
Console.Write("{0} Install ... ", _version);
var installableExtension = _extensionManager.CreateInstallableExtension(extensionPath);
var identifier = installableExtension.Header.Identifier;
UninstallSilent(identifier);
var perMachine = false;
var header = installableExtension.Header;
if (header.AllUsers != perMachine)
{
if (SetAllUsers(header, perMachine))
{
Console.Write(string.Format("NOTE: Changing `AllUsers` to {0} ... ", perMachine));
}
else
{
Console.Write(string.Format("WARNING: Couldn't change `AllUsers` to {0} ... ", perMachine));
}
}
_extensionManager.Install(installableExtension, perMachine);
var installedExtension = _extensionManager.GetInstalledExtension(identifier);
_extensionManager.Enable(installedExtension);
Console.WriteLine("Succeeded");
}
catch (Exception ex)
{
Console.WriteLine("ERROR: {0}", ex.Message);
}
}
public static RestartReason CheckForUpdates(string identifier, string updateUrl)
{
// Don't check for updates on non-DEPLOY builds; the URLs don't work and it seems
// undesirable anyway.
#if DEPLOY
IVsExtensionManager extensionManager = Package.GetGlobalService(typeof(SVsExtensionManager)) as IVsExtensionManager;
IInstalledExtension installedExtension = extensionManager.GetInstalledExtension(identifier);
if (installedExtension == null)
{
throw new Exception(String.Format("Unable to find extension: {0}", identifier));
}
RepositoryEntry entry = new RepositoryEntry();
entry.DownloadUrl = updateUrl;
IVsExtensionRepository repository = Package.GetGlobalService(typeof(SVsExtensionRepository)) as IVsExtensionRepository;
IInstallableExtension latestExtension = repository.Download(entry);
if (latestExtension.Header.Version > installedExtension.Header.Version)
{
RestartReason reason = RestartReason.None;
reason |= extensionManager.Disable(installedExtension);
extensionManager.Uninstall(installedExtension);
try {
reason |= extensionManager.Install(latestExtension, /*perMachine*/ false);
// Enable the new one.
IInstalledExtension latestInstalledExtension = extensionManager.GetInstalledExtension(latestExtension.Header.Identifier);
reason |= extensionManager.Enable(latestInstalledExtension);
return(reason);
} catch {
// Revert the uninstallation.
extensionManager.RevertUninstall(installedExtension);
extensionManager.Enable(installedExtension);
throw;
}
}
#endif
return(RestartReason.None);
}
public void Install(IVsExtensionManager manager, IInstalledExtension currentExtention, IInstallableExtension updatedExtension)
{
manager.Disable(currentExtention);
manager.Uninstall(currentExtention);
manager.Install(updatedExtension, false);
var newlyInstalledVersion = manager.GetInstalledExtension(updatedExtension.Header.Identifier);
if (newlyInstalledVersion.IsNotNull())
{
manager.Enable(newlyInstalledVersion);
}
}
private RestartReason Install(IInstalledExtension currentExtension, IInstallableExtension updatedExtension)
{
//Uninstall old extension
_extensionManager.Disable(currentExtension);
_extensionManager.Uninstall(currentExtension);
//Install new version
var restartReason = _extensionManager.Install(updatedExtension, false);
//Enable the newly installed version of the extension
var newlyInstalledVersion = _extensionManager.GetInstalledExtension(updatedExtension.Header.Identifier);
if (newlyInstalledVersion != null)
{
_extensionManager.Enable(newlyInstalledVersion);
}
return(restartReason);
}
private void RunInstall(string extensionPath)
{
try
{
Console.Write("{0} Install ... ", _version);
var installableExtension = _extensionManager.CreateInstallableExtension(extensionPath);
var identifier = installableExtension.Header.Identifier;
UninstallSilent(identifier);
_extensionManager.Install(installableExtension, perMachine: false);
var installedExtension = _extensionManager.GetInstalledExtension(identifier);
_extensionManager.Enable(installedExtension);
Console.WriteLine("Succeeded");
}
catch (Exception ex)
{
Console.WriteLine("ERROR: {0}", ex.Message);
}
}
private void CheckExtension(IVsExtensionManager manager, string target)
{
if (IsInDisableCycle && !string.IsNullOrWhiteSpace(target))
{
var extension = manager.GetInstalledExtension(target);
if (extension != null)
{
if (extension.State == EnabledState.Disabled)
{
manager.Enable(extension);
IsInDisableCycle = false;
}
else
{
throw new Exception("The extension is not disabled");
}
}
}
}
