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 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);
}
public void CheckForAvailableUpdateAsync()
{
if (_updateDeclined || _updateAccepted || !_productUpdateSettings.ShouldCheckForUpdate)
{
return;
}
Task.Factory.StartNew(() => {
try {
// Find the vsix on the vs gallery
VSGalleryEntry nugetVsix = _extensionRepository.CreateQuery <VSGalleryEntry>()
.Where(e => e.VsixID == NuGetVSIXId)
.AsEnumerable()
.FirstOrDefault();
// Get the current NuGet VSIX version
IInstalledExtension installedNuGet = _extensionManager.GetInstalledExtension(NuGetVSIXId);
Version installedVersion = installedNuGet.Header.Version;
// If we're running an older version then update
if (nugetVsix != null && nugetVsix.NonNullVsixVersion > installedVersion)
{
RaiseUpdateEvent(new ProductUpdateAvailableEventArgs(installedVersion, nugetVsix.NonNullVsixVersion));
}
}
catch {
// Swallow all exceptions. We don't want to take down vs, if the VS extension
// gallery happens to be down.
}
});
}
public bool CheckForUpdate(out Version installedVersion, out Version newVersion)
{
// Find the vsix on the vs gallery
// IMPORTANT: The .AsEnumerble() call is REQUIRED. Don't remove it or the update service won't work.
GalleryEntry nugetVsix = _extensionRepository.CreateQuery <GalleryEntry>(includeTypeInQuery: false, includeSkuInQuery: true)
.Where(e => e.VsixID == NuGetVSIXId)
.AsEnumerable()
.FirstOrDefault();
// Get the current NuGet VSIX version
IInstalledExtension installedNuGet = _extensionManager.GetInstalledExtension(NuGetVSIXId);
installedVersion = installedNuGet.Header.Version;
// If we're running an older version then update
if (nugetVsix != null && nugetVsix.NonNullVsixVersion > installedVersion)
{
newVersion = nugetVsix.NonNullVsixVersion;
return(true);
}
else
{
newVersion = installedVersion;
return(false);
}
}
public VSIXPackageInformation GetCurrentVSIXPackageInformation()
{
VSIXPackageInformation outInfo = null;
try
{
outInfo = new VSIXPackageInformation();
// get ExtensionManager
IVsExtensionManager manager = GetService(typeof(SVsExtensionManager)) as IVsExtensionManager;
// get your extension by Product Id
IInstalledExtension myExtension = manager.GetInstalledExtension("FASTBuildMonitorVSIX.44bf85a5-7635-4a2e-86d7-7b7f3bf757a8");
// get current version
outInfo._version = myExtension.Header.Version;
outInfo._authors = myExtension.Header.Author;
outInfo._packageName = myExtension.Header.Name;
outInfo._moreInfoURL = myExtension.Header.MoreInfoUrl.OriginalString;
}
catch (System.Exception ex)
{
Console.WriteLine("Exception: " + ex.ToString());
}
return(outInfo);
}
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);
}
}
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);
}
}
public Version GetCurrentVersion()
{
try
{
// get ExtensionManager
IVsExtensionManager manager = GetService(typeof(SVsExtensionManager)) as IVsExtensionManager;
// get your extension by Product Id
IInstalledExtension myExtension = manager.GetInstalledExtension("Disasmo.39513ef5-c3ee-4547-b7be-f29c752b591d");
// get current version
Version currentVersion = myExtension.Header.Version;
return(currentVersion);
}
catch { return(new Version(0, 0)); }
}
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);
}
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 static string GetVSIXInstalledLocation()
{
//return "";
// get ExtensionManager
IVsExtensionManager manager = ServiceProvider.GlobalProvider.GetService(typeof(SVsExtensionManager)) as IVsExtensionManager;
//foreach (IInstalledExtension extension in manager.GetInstalledExtensions())
// if(extension.Header.Name == "MyExtensionName")
// return extension.InstallPath;
// get your extension by Product Id
IInstalledExtension myExtension = manager.GetInstalledExtension(GuidList.guidQCStudioPluginPkgString);
// get current version
return(myExtension.InstallPath);
}
private static string SetDefaultPath()
{
IVsExtensionManager manager = ServiceProvider.GetService(typeof(SVsExtensionManager)) as IVsExtensionManager;
if (manager == null)
{
// This will be used for testing
packagePath = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
return(packagePath);
}
IInstalledExtension extension = manager.GetInstalledExtension(ServiceFactoryPackageExtensionId);
Debug.Assert(extension != null, "We could not find " + ServiceFactoryPackageExtensionId + " or package not installed.");
packagePath = extension.InstallPath;
return(packagePath);
}
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");
}
}
}
}
public string GetExtensionInstallDir(string extensionId, IVsExtensionManager extManager)
{
if (string.IsNullOrWhiteSpace(extensionId))
{
throw new ApplicationException("ExtensionId is empty");
}
if (extManager == null)
{
throw new ArgumentNullException(nameof(extManager));
}
var extension = extManager.GetInstalledExtension(extensionId);
if (extension != null)
{
return(extension.InstallPath);
}
throw new ApplicationException($"Extension with ID {extensionId} not found");
}
protected override void Initialize()
{
// determine whether we're running the experimental instance.
_isExperimental = false;
string[] args = Environment.GetCommandLineArgs();
if (args.Length >= 3 && args[2].Equals("exp", StringComparison.OrdinalIgnoreCase))
{
_isExperimental = true;
}
// get the product version
IVsExtensionManager manager = GetService(typeof(SVsExtensionManager)) as IVsExtensionManager;
IInstalledExtension myExtension = manager.GetInstalledExtension(PackageId);
if (myExtension != null)
{
ProductVersion = myExtension.Header.Version;
}
// Initialize NLog
if (LogManager.Configuration == null)
{
string path = Path.Combine(SettingsDirectory, string.Format("{0}_NLog.config", PackageName));
if (!File.Exists(path))
{
// Get the template from resources and write it to the directory.
if (!Directory.Exists(SettingsDirectory))
{
Directory.CreateDirectory(SettingsDirectory);
}
File.WriteAllText(path, GetDefaultNLogConfigFileContents());
}
if (File.Exists(path))
{
LogManager.Configuration = new XmlLoggingConfiguration(path);
// Register for changes to the config file
LogManager.ConfigurationChanged += LogManager_ConfigurationChanged;
}
}
// Get the current logger now, since we have the configuration
_logger = LogManager.GetCurrentClassLogger();
_logger.Trace("VS arguments: [{0}]", string.Join(",", args));
var componentManager = _compMgr = (IOleComponentManager)GetService(typeof(SOleComponentManager));
OLECRINFO[] crinfo = new OLECRINFO[1];
crinfo[0].cbSize = (uint)Marshal.SizeOf(typeof(OLECRINFO));
crinfo[0].grfcrf = (uint)_OLECRF.olecrfNeedIdleTime;
crinfo[0].grfcadvf = (uint)_OLECADVF.olecadvfModal | (uint)_OLECADVF.olecadvfRedrawOff | (uint)_OLECADVF.olecadvfWarningsOff;
crinfo[0].uIdleTimeInterval = 0;
ErrorHandler.ThrowOnFailure(componentManager.FRegisterComponent(this, crinfo, out _componentID));
_activityLog = GetService(typeof(SVsActivityLog)) as IVsActivityLog;
base.Initialize();
Instance = this;
_packageDTEEvents = ApplicationObject.Events.DTEEvents;
_packageDTEEvents.OnBeginShutdown += OnBeginShutdown;
}
public string GetExtensionInstallDir(string extensionId,IVsExtensionManager extManager) {
if (string.IsNullOrWhiteSpace(extensionId)) {
throw new ApplicationException("ExtensionId is empty");
}
if (extManager == null) { throw new ArgumentNullException(nameof(extManager)); }
var extension = extManager.GetInstalledExtension(extensionId);
if(extension != null) {
return extension.InstallPath;
}
throw new ApplicationException($"Extension with ID {extensionId} not found");
}
