private async Task InstallAsync(IEnumerable <ExtensionEntry> extensions, IVsExtensionRepository repository, IVsExtensionManager manager, CancellationToken token)
{
if (!extensions.Any() || token.IsCancellationRequested)
{
return;
}
await Task.Run(() =>
{
try
{
foreach (ExtensionEntry extension in extensions)
{
if (token.IsCancellationRequested)
{
return;
}
InstallExtension(extension, repository, manager);
}
}
catch (Exception ex)
{
System.Diagnostics.Debug.Write(ex);
}
finally
{
Store.Save();
}
}).ConfigureAwait(false);
}
public async Task RunAsync(Version vsVersion, IVsExtensionRepository repository, IVsExtensionManager manager, CancellationToken cancellationToken)
{
_log.Debug("RunAsync started");
IEnumerable <ExtensionEntry> toUninstall = GetExtensionsMarkedForDeletion(vsVersion);
IEnumerable <ExtensionEntry> toInstall = GetMissingExtensions(manager).Except(toUninstall);
int actions = toUninstall.Count() + toInstall.Count();
if (actions > 0)
{
_progress = new Progress(actions);
await UninstallAsync(toUninstall, repository, manager, cancellationToken).ConfigureAwait(false);
var installationResult = await InstallAsync(toInstall, repository, manager, cancellationToken).ConfigureAwait(false);
_log.Debug("Installation Completed ");
_logger.Log(Environment.NewLine + _settings.ResourceProvider.InstallationComplete + Environment.NewLine);
Done?.Invoke(this, installationResult);
}
else
{
_log.Debug("No actions to do");
}
_log.Debug("RunAsync ended");
}
private void InstallExtension(IVsExtensionRepository repository, IVsExtensionManager manager, KeyValuePair <string, string> product)
{
#if DEBUG
System.Threading.Thread.Sleep(1000);
return;
#endif
try
{
GalleryEntry entry = repository.CreateQuery <GalleryEntry>(includeTypeInQuery: false, includeSkuInQuery: true, searchSource: "ExtensionManagerUpdate")
.Where(e => e.VsixID == product.Key)
.AsEnumerable()
.FirstOrDefault();
if (entry != null)
{
IInstallableExtension installable = repository.Download(entry);
manager.Install(installable, false);
Telemetry.TrackEvent(installable.Header.Name);
}
}
catch (Exception ex)
{
Logger.Log(ex);
}
}
private ExtensionInstalledChecker(IVsExtensionRepository repository, IVsExtensionManager manager)
{
_repository = repository;
_manager = manager;
SolutionHandler.ExtensionFileFound += ExtensionFileFound;
}
private void InstallExtension(IVsExtensionRepository repository, IVsExtensionManager manager, KeyValuePair<string, string> product, DataStore store)
{
#if DEBUG
System.Threading.Thread.Sleep(1000);
return;
#endif
try
{
GalleryEntry entry = repository.CreateQuery<GalleryEntry>(includeTypeInQuery: false, includeSkuInQuery: true, searchSource: "ExtensionManagerUpdate")
.Where(e => e.VsixID == product.Key)
.AsEnumerable()
.FirstOrDefault();
if (entry != null)
{
IInstallableExtension installable = repository.Download(entry);
manager.Install(installable, false);
store.PreviouslyInstalledExtensions.Add(entry.VsixID);
}
}
catch (Exception ex)
{
Logger.Log(ex);
}
}
private ExtensionInstalledChecker(IVsExtensionRepository repository, IVsExtensionManager manager)
{
_repository = repository;
_manager = manager;
SolutionHandler.ExtensionFileFound += ExtensionFileFound;
}
private void InstallExtension(IVsExtensionRepository repository, IVsExtensionManager manager, KeyValuePair <string, string> product, DataStore store)
{
#if DEBUG
System.Threading.Thread.Sleep(1000);
return;
#endif
GalleryEntry entry = null;
try
{
entry = repository.CreateQuery <GalleryEntry>(includeTypeInQuery: false, includeSkuInQuery: true, searchSource: "ExtensionManagerUpdate")
.Where(e => e.VsixID == product.Key)
.AsEnumerable()
.FirstOrDefault();
if (entry != null)
{
var installable = repository.Download(entry);
manager.Install(installable, false);
}
}
catch (Exception ex)
{
Logger.Log(ex);
}
finally
{
if (entry != null)
{
store.PreviouslyInstalledExtensions.Add(entry.VsixID);
}
}
}
public Commands(IVsExtensionRepository repo, IVsExtensionManager manager, OleMenuCommandService mcs, IVsOutputWindowPane outputPane)
{
_repository = repo;
_manager = manager;
_mcs = mcs;
_outputPane = outputPane;
}
public static async Task RunAsync()
{
bool hasUpdates = await Installer.CheckForUpdatesAsync();
if (!hasUpdates)
{
return;
}
_hasShownProgress = false;
// Waits for MEF to initialize before the extension manager is ready to use
await _package.GetServiceAsync(typeof(SComponentModel));
IVsExtensionRepository repository = await _package.GetServiceAsync(typeof(SVsExtensionRepository)) as IVsExtensionRepository;
IVsExtensionManager manager = await _package.GetServiceAsync(typeof(SVsExtensionManager)) as IVsExtensionManager;
Version vsVersion = VsHelpers.GetVisualStudioVersion();
_handler = await SetupTaskStatusCenter();
Task task = Installer.RunAsync(vsVersion, repository, manager, _handler.UserCancellation);
_handler.RegisterTask(task);
}
public Commands(IVsExtensionRepository repo, IVsExtensionManager manager, OleMenuCommandService mcs, IVsOutputWindowPane outputPane)
{
_repository = repo;
_manager = manager;
_mcs = mcs;
_outputPane = outputPane;
}
private ExtensionInstalledChecker(IServiceProvider serviceProvider, IVsExtensionRepository repository, IVsExtensionManager manager)
{
_serviceProvider = serviceProvider;
_repository = repository;
_manager = manager;
SolutionHandler.ExtensionFileFound += ExtensionFileFound;
}
private ExtensionInstalledChecker(IServiceProvider serviceProvider, IVsExtensionRepository repository, IVsExtensionManager manager)
{
_serviceProvider = serviceProvider;
_repository = repository;
_manager = manager;
SolutionHandler.ExtensionFileFound += ExtensionFileFound;
}
//I have been calling this from the VSPackage's Initilize, passing in the component model
public bool CheckForUpdates(IComponentModel componentModel)
{
_extensionRepository = (IVsExtensionRepository)Microsoft.VisualStudio.Shell.Package.GetGlobalService(typeof(SVsExtensionRepository));
_extensionManager = (IVsExtensionManager)Microsoft.VisualStudio.Shell.Package.GetGlobalService(typeof(SVsExtensionManager));
//Find the extension you're after.
var extension = _extensionManager.GetInstalledExtensions().Where(n => n.Header.Name == "Code Connect Alpha").SingleOrDefault();
return(CheckAndInstallNewVersion(extension));
}
public void CheckForUpdates(IVsExtensionManager extensionManager, IVsExtensionRepository repoManager)
{
var plugin = collectionPluginToPluginMapper.MapFrom(GetCollection().plugin);
var updatedExtension = extensionManager.GetInstalledExtensions().FirstOrDefault(x => GlobalConstants.PackageName == x.Header.Name && x.Header.Version < plugin.Version);
if (updatedExtension.IsNotNull())
{
var dialogParameters = dialogMessageEventFactory.GetInstance(packageUpdateManager, updatedExtension, extensionManager, repoManager);
dialogMessagesEvents.OnDialogMessageRequested(this, dialogParameters);
}
}
private ShowSuggestionsCommand(Package package, IVsExtensionRepository repository, IVsExtensionManager manager)
{
_package = package;
_repository = repository;
_manager = manager;
OleMenuCommandService commandService = this.ServiceProvider.GetService(typeof(IMenuCommandService)) as OleMenuCommandService;
if (commandService != null)
{
var menuCommandID = new CommandID(PackageGuids.guidExtensionCmdSet, PackageIds.cmdShowSuggestions);
var button = new OleMenuCommand(async (s, e) => await ShowSuggestions(s, e), menuCommandID);
commandService.AddCommand(button);
}
}
private void InstallExtension(ExtensionEntry extension, IVsExtensionRepository repository, IVsExtensionManager manager)
{
GalleryEntry entry = null;
OnUpdate(string.Format(Resources.Text.InstallingExtension, extension.Name));
try
{
Logger.Log($"{Environment.NewLine}{extension.Name}");
Logger.Log(" " + Resources.Text.Verifying, false);
entry = repository.GetVSGalleryExtensions <GalleryEntry>(new List <string> {
extension.Id
}, 1033, false)?.FirstOrDefault();
if (entry != null)
{
Logger.Log(Resources.Text.Ok); // Marketplace ok
Logger.Log(" " + Resources.Text.Downloading, false);
#if !DEBUG
IInstallableExtension installable = repository.Download(entry);
#endif
Logger.Log(Resources.Text.Ok); // Download ok
Logger.Log(" " + Resources.Text.Installing, false);
#if !DEBUG
manager.Install(installable, false);
#else
Thread.Sleep(2000);
#endif
Logger.Log(Resources.Text.Ok); // Install ok
Telemetry.Install(extension.Id, true);
}
else
{
Logger.Log(Resources.Text.Failed); // Markedplace failed
}
}
catch (Exception)
{
Logger.Log(Resources.Text.Failed);
Telemetry.Install(extension.Id, false);
}
finally
{
if (entry != null)
{
Store.MarkInstalled(extension);
}
}
}
private async Task UninstallAsync(IEnumerable <ExtensionEntry> extensions, IVsExtensionRepository repository, IVsExtensionManager manager, CancellationToken token)
{
if (!extensions.Any() || token.IsCancellationRequested)
{
return;
}
await Task.Run(() =>
{
try
{
foreach (ExtensionEntry extension in extensions)
{
if (token.IsCancellationRequested)
{
return;
}
string msg = string.Format(Resources.Text.UninstallingExtension, extension.Name);
OnUpdate(msg);
Logger.Log(msg, false);
try
{
if (manager.TryGetInstalledExtension(extension.Id, out IInstalledExtension installedExtension))
{
#if !DEBUG
manager.Uninstall(installedExtension);
Telemetry.Uninstall(extension.Id, true);
#endif
Store.MarkUninstalled(extension);
Logger.Log(Resources.Text.Ok);
}
}
catch (Exception)
{
Logger.Log(Resources.Text.Failed);
Telemetry.Uninstall(extension.Id, false);
}
}
}
finally
{
Store.Save();
}
});
}
public VS2010UpdateWorker(IVsExtensionRepository extensionRepository, IVsExtensionManager extensionManager)
{
if (extensionManager == null)
{
throw new ArgumentNullException("extensionManager");
}
if (extensionRepository == null)
{
throw new ArgumentNullException("extensionRepository");
}
_extensionManager = extensionManager;
_extensionRepository = extensionRepository;
}
public ProductUpdateService(
IVsExtensionRepository extensionRepository,
IVsExtensionManager extensionManager,
IVsUIShell vsUIShell,
IProductUpdateSettings productUpdateSettings)
{
if (productUpdateSettings == null) {
throw new ArgumentNullException("productUpdateSettings");
}
_vsUIShell = vsUIShell;
_extensionRepository = extensionRepository;
_extensionManager = extensionManager;
_productUpdateSettings = productUpdateSettings;
}
public VS2010UpdateWorker(IVsExtensionRepository extensionRepository, IVsExtensionManager extensionManager)
{
if (extensionManager == null)
{
throw new ArgumentNullException("extensionManager");
}
if (extensionRepository == null)
{
throw new ArgumentNullException("extensionRepository");
}
_extensionManager = extensionManager;
_extensionRepository = extensionRepository;
}
private ShowSuggestionsCommand(Package package, IVsExtensionRepository repository, IVsExtensionManager manager)
{
_package = package;
_repository = repository;
_manager = manager;
OleMenuCommandService commandService = this.ServiceProvider.GetService(typeof(IMenuCommandService)) as OleMenuCommandService;
if (commandService != null)
{
var menuCommandID = new CommandID(PackageGuids.guidExtensionCmdSet, PackageIds.cmdShowSuggestions);
var button = new OleMenuCommand(async(s, e) => await ShowSuggestions(s, e), menuCommandID);
commandService.AddCommand(button);
}
}
public ProductUpdateService(
IVsExtensionRepository extensionRepository,
IVsExtensionManager extensionManager,
IVsUIShell vsUIShell,
IProductUpdateSettings productUpdateSettings)
{
if (productUpdateSettings == null)
{
throw new ArgumentNullException("productUpdateSettings");
}
_vsUIShell = vsUIShell;
_extensionRepository = extensionRepository;
_extensionManager = extensionManager;
_productUpdateSettings = productUpdateSettings;
}
//Checks the version of the extension
private bool NewerVersionExists(IInstalledExtension extension, IVsExtensionRepository repository, GalleryEntry entry)
{
var version = extension.Header.Version;
var strNewVersion = repository.GetCurrentExtensionVersions("ExtensionManagerQuery", new List <string>()
{
extension.Header.Identifier
}, 1033).Single();
var newVersion = Version.Parse(strNewVersion);
if (newVersion > version)
{
return(true);
}
return(false);
}
public async Task RunAsync(Version vsVersion, IVsExtensionRepository repository, IVsExtensionManager manager, CancellationToken cancellationToken)
{
IEnumerable <ExtensionEntry> toUninstall = GetExtensionsMarkedForDeletion(vsVersion);
IEnumerable <ExtensionEntry> toInstall = GetMissingExtensions(manager).Except(toUninstall);
int actions = toUninstall.Count() + toInstall.Count();
if (actions > 0)
{
_progress = new Progress(actions);
await UninstallAsync(toUninstall, repository, manager, cancellationToken).ConfigureAwait(false);
await InstallAsync(toInstall, repository, manager, cancellationToken).ConfigureAwait(false);
Logger.Log(Environment.NewLine + Resources.Text.InstallationComplete + Environment.NewLine);
Done?.Invoke(this, actions);
}
}
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 InstallExtension(ExtensionEntry extension, IVsExtensionRepository repository, IVsExtensionManager manager)
{
GalleryEntry entry = null;
OnUpdate(string.Format("Installing Extension: ", extension.Name));
try
{
Logger.Log($"{Environment.NewLine}{extension.Name}");
Logger.Log(" " + "Verifying ", false);
entry = repository.GetVSGalleryExtensions <GalleryEntry>(new List <string> {
extension.Id
}, 1033, false)?.FirstOrDefault();
if (entry != null)
{
Logger.Log("Marketplace OK"); // Marketplace ok
Logger.Log(" " + "Downloading", false);
IInstallableExtension installable = repository.Download(entry);
Logger.Log("Downloading OK"); // Download ok
Logger.Log(" " + "Installing", false);
manager.Install(installable, false);
Logger.Log("Install OK"); // Install ok
Telemetry.Install(extension.Id, true);
}
else
{
Logger.Log("Marketplace failed"); // Markedplace failed
}
}
catch (Exception)
{
Logger.Log("Install failed exception");
Telemetry.Install(extension.Id, false);
}
finally
{
}
}
public static void Initialize(IServiceProvider serviceProvider, IVsExtensionRepository repository, IVsExtensionManager manager)
{
Instance = new InfoBarService(serviceProvider, repository, manager);
}
private InfoBarService(IServiceProvider serviceProvider, IVsExtensionRepository repository, IVsExtensionManager manager)
{
_serviceProvider = serviceProvider;
_repository = repository;
_manager = manager;
}
public static void Initialize(Package package, IVsExtensionRepository repository, IVsExtensionManager manager)
{
Instance = new ShowSuggestionsCommand(package, repository, manager);
}
public static void Initialize(IServiceProvider serviceProvider, IVsExtensionRepository repository, IVsExtensionManager manager)
{
Instance = new InfoBarService(serviceProvider, repository, manager);
}
private InfoBarService(IServiceProvider serviceProvider, IVsExtensionRepository repository, IVsExtensionManager manager)
{
_serviceProvider = serviceProvider;
_repository = repository;
_manager = manager;
}
public Commands(IVsExtensionRepository repo, IVsExtensionManager manager, OleMenuCommandService mcs)
{
_repository = repo;
_manager = manager;
_mcs = mcs;
}
public static void Initialize(IVsExtensionRepository repository, IVsExtensionManager manager)
{
Instance = new ExtensionInstalledChecker(repository, manager);
}
public ExtensionManagerFacade(IVsExtensionManager visualStudioExtensionManager,
IVsExtensionRepository visualStudioExtensionRepository)
{
ExtensionManager = visualStudioExtensionManager;
ExtensionRepository = visualStudioExtensionRepository;
}
public static void Initialize(IServiceProvider serviceProvider, IVsExtensionRepository repository, IVsExtensionManager manager)
{
Instance = new ExtensionInstalledChecker(serviceProvider, repository, manager);
}
private void InstallExtension(IVsExtensionRepository repository, IVsExtensionManager manager, KeyValuePair<string, string> product)
{
try
{
GalleryEntry entry = repository.CreateQuery<GalleryEntry>(includeTypeInQuery: false, includeSkuInQuery: true, searchSource: "ExtensionManagerUpdate")
.Where(e => e.VsixID == product.Key)
.AsEnumerable()
.FirstOrDefault();
if (entry != null)
{
IInstallableExtension installable = repository.Download(entry);
manager.Install(installable, false);
Telemetry.TrackEvent(installable.Header.Name);
}
}
catch (Exception ex)
{
Logger.Log(ex);
}
}
private async System.Threading.Tasks.Task ExtMgrInstallExtensionAsync()
{
GalleryEntry entry = null;
try
{
// Waits for MEF to initialize before the extension manager is ready to use
var scComponentModel = VSPackageInstaller.VSPackage.GetGlobalService(typeof(SComponentModel));
IVsExtensionRepository repository = VSPackageInstaller.VSPackage.GetGlobalService(typeof(SVsExtensionRepository)) as IVsExtensionRepository;
IVsExtensionManager manager = VSPackageInstaller.VSPackage.GetGlobalService(typeof(SVsExtensionManager)) as IVsExtensionManager;
Logger.Log($"{Environment.NewLine}{this.Extension.Title}");
Logger.Log(" " + "Verifying ", false);
entry = repository.GetVSGalleryExtensions <GalleryEntry>(new System.Collections.Generic.List <string> {
this.Extension.VsixId.ToString()
}, 1033, false)?.FirstOrDefault();
if (entry != null)
{
// ensure that we update the URL if it is empty
if (entry.DownloadUrl == null)
{
entry.DownloadUrl = this.Extension.Installer;
throw new Exception("This is not a VsiX");
}
Logger.Log("Marketplace OK"); // Marketplace ok
Logger.Log(" " + "Downloading");
IInstallableExtension installable = repository.Download(entry);
if (installable == null)
{
throw new Exception("This is not a VsiX");
}
Logger.Log("Downloading OK"); // Download ok
Logger.Log(" " + "Installing");
manager.Install(installable, false);
Logger.Log("Installation queued OK"); // Install ok
Logger.Log("This extension package will now be automatically installed when you exist all instances of Visual Studio");
}
else
{
Logger.Log("Marketplace failed"); // Markedplace failed
// This is not a VsiX
throw new Exception("This is not a VsiX");
Logger.Log("Done");
}
}
catch (Exception ex)
{
Logger.Log("Extension Manager installtion failed exception: " + ex);
Logger.Log("Trying manual downloand and install");
await this.ManualInstallExtensionAsync();
}
finally
{
await System.Threading.Tasks.Task.Yield();
}
}
public static void Initialize(IServiceProvider serviceProvider, IVsExtensionRepository repository, IVsExtensionManager manager)
{
Instance = new ExtensionInstalledChecker(serviceProvider, repository, manager);
}
public ExtensionInstaller(IVsExtensionRepository repository, IVsExtensionManager manager)
{
_repository = repository;
_manager = manager;
}
public ExtensionManagerFacade(IVsExtensionManager visualStudioExtensionManager,
IVsExtensionRepository visualStudioExtensionRepository)
{
ExtensionManager = visualStudioExtensionManager;
ExtensionRepository = visualStudioExtensionRepository;
}
public ExtensionInstaller(IVsExtensionRepository repository, IVsExtensionManager manager)
{
_repository = repository;
_manager = manager;
}
public Updater(IVsExtensionRepository extensionRepository, IVsExtensionManager extensionManager)
{
_manager = extensionManager;
_repository = extensionRepository;
_checker = new UpdateChecker(extensionRepository, extensionManager);
}
private RestartReason InstallExtension(ExtensionEntry extension, IVsExtensionRepository repository, IVsExtensionManager manager)
{
GalleryEntry entry = null;
OnUpdate(string.Format("{0} ({1})", _settings.ResourceProvider.InstallingExtension, extension.Name));
var ret = RestartReason.None;
try
{
_logger.Log($"{Environment.NewLine}{extension.Name}");
_logger.Log(" " + _settings.ResourceProvider.Verifying, false);
entry = repository.GetVSGalleryExtensions <GalleryEntry>(new List <string> {
extension.Id
}, 1033, false)?.FirstOrDefault();
if (entry != null)
{
_logger.Log(_settings.ResourceProvider.Ok); // Marketplace ok
#if DEBUG || true
var extensionsByAuthor = manager.GetInstalledExtensions().GroupBy(x => x.Header.Author).Select(y => new { y.Key, items = y }).ToArray();
#endif
var installed = manager.GetInstalledExtensions().SingleOrDefault(n => n.Header.Identifier == extension.Id);
_logger.Log(" " + _settings.ResourceProvider.Verifying, false);
IInstallableExtension installable = null;
if (installed != null)
{
if (NewerVersionExists(installed, repository, entry))
{
installed = null;
}
}
_logger.Log(" " + _settings.ResourceProvider.Ok);
if (installed == null)
{
_logger.Log(" " + _settings.ResourceProvider.Downloading, false);
installable = repository.Download(entry);
_logger.Log(_settings.ResourceProvider.Ok); // Download ok
}
if (installable == null)
{
_logger.Log(" nothing to do");
}
else
{
_logger.Log(" " + _settings.ResourceProvider.Installing, false);
ret = manager.Install(installable, false);
_logger.Log(_settings.ResourceProvider.Ok); // Install ok
}
Telemetry.Install(extension.Id, true);
}
else
{
_logger.Log(_settings.ResourceProvider.Failed); // Markedplace failed
}
}
catch (Exception e)
{
_logger.Log(_settings.ResourceProvider.Failed);
_logger.Log("Failed to install package: " + e.Message);
_log.Error(e);
Telemetry.Install(extension.Id, false);
}
finally
{
if (entry != null)
{
Store.MarkInstalled(extension);
}
}
return(ret);
}
public ExtensionInstaller(IServiceProvider serviceProvider, IVsExtensionRepository repository, IVsExtensionManager manager)
{
_serviceProvider = serviceProvider;
_repository = repository;
_manager = manager;
}
public Updater(IVsExtensionRepository extensionRepository, IVsExtensionManager extensionManager)
{
_manager = extensionManager;
_repository = extensionRepository;
_checker = new UpdateChecker(extensionRepository, extensionManager);
}
private async Task <InstallResult> InstallAsync(IEnumerable <ExtensionEntry> extensions, IVsExtensionRepository repository, IVsExtensionManager manager, CancellationToken token)
{
_log.Debug("InstallAsync started");
if (!extensions.Any() || token.IsCancellationRequested)
{
return(InstallResult.NothingToDo);
}
return(await Task.Factory.StartNew <InstallResult>(() =>
{
var ret = new InstallResult();
try
{
foreach (ExtensionEntry extension in extensions)
{
if (token.IsCancellationRequested)
{
return ret;
}
var result = InstallExtension(extension, repository, manager);
ret.AddResult(extension, result);
}
}
catch (Exception ex)
{
_logger.Log("Error installing " + ex.Message);
}
finally
{
Store.Save();
}
return ret;
}, token).ConfigureAwait(false));
}
public ExtensionInstaller(IServiceProvider serviceProvider, IVsExtensionRepository repository, IVsExtensionManager manager)
{
_serviceProvider = serviceProvider;
_repository = repository;
_manager = manager;
}
public static void Initialize(IVsExtensionRepository repository, IVsExtensionManager manager)
{
Instance = new ExtensionInstalledChecker(repository, manager);
}
public static void Initialize(Package package, IVsExtensionRepository repository, IVsExtensionManager manager)
{
Instance = new ShowSuggestionsCommand(package, repository, manager);
}
