private async Task CleanLibrariesAsync(ProjectItem configProjectItem, CancellationToken cancellationToken)
{
Logger.LogEventsHeader(OperationType.Clean, string.Empty);
try
{
Stopwatch sw = new Stopwatch();
sw.Start();
string configFileName = configProjectItem.FileNames[1];
var dependencies = Dependencies.FromConfigFile(configFileName);
Project project = VsHelpers.GetDTEProjectFromConfig(configFileName);
Manifest manifest = await Manifest.FromFileAsync(configFileName, dependencies, CancellationToken.None).ConfigureAwait(false);
IEnumerable <ILibraryOperationResult> results = new List <ILibraryOperationResult>();
if (manifest != null)
{
IHostInteraction hostInteraction = dependencies.GetHostInteractions();
results = await manifest.CleanAsync(async (filesPaths) => await hostInteraction.DeleteFilesAsync(filesPaths, cancellationToken), cancellationToken);
}
sw.Stop();
AddErrorsToErrorList(project?.Name, configFileName, results);
Logger.LogEventsSummary(results, OperationType.Clean, sw.Elapsed);
Telemetry.LogEventsSummary(results, OperationType.Clean, sw.Elapsed);
}
catch (OperationCanceledException ex)
{
Logger.LogEvent(LibraryManager.Resources.Text.Clean_OperationCancelled, LogLevel.Task);
Telemetry.TrackException($@"{OperationType.Clean}Cancelled", ex);
}
}
private async Task RunTaskAsync(Func <CancellationToken, Task> getTaskToRun, string taskTitle, string errorMessage)
{
if (IsOperationInProgress)
{
return;
}
try
{
ITaskHandler handler = await TaskStatusCenterServiceInstance.CreateTaskHandlerAsync(taskTitle);
CancellationToken internalToken = RegisterCancellationToken(handler.UserCancellation);
lock (_lockObject)
{
_currentOperationTask = getTaskToRun(internalToken);
handler.RegisterTask(_currentOperationTask);
}
await _currentOperationTask.ConfigureAwait(false);
}
catch (Exception ex)
{
Logger.LogEvent(errorMessage + Environment.NewLine + ex.Message, LogLevel.Operation);
Telemetry.TrackException(nameof(RunTaskAsync), ex);
}
}
public static async Task AddFileToProjectAsync(this Project project, string file, string itemType = null)
{
await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
if (IsCapabilityMatch(project, Constants.DotNetCoreWebCapability))
{
return;
}
try
{
if (DTE.Solution.FindProjectItem(file) == null)
{
ProjectItem item = project.ProjectItems.AddFromFile(file);
if (string.IsNullOrEmpty(itemType) || project.IsKind(Constants.WebsiteProject))
{
return;
}
item.Properties.Item("ItemType").Value = "None";
}
}
catch (Exception ex)
{
Logger.LogEvent(ex.ToString(), LogLevel.Error);
Telemetry.TrackException(nameof(AddFilesToProjectAsync), ex);
System.Diagnostics.Debug.Write(ex);
}
}
public override async void Invoke(CancellationToken cancellationToken)
{
try
{
Telemetry.TrackUserTask("Invoke-UninstallFromSuggestedAction");
await _libraryCommandService.UninstallAsync(_provider.ConfigFilePath, _provider.InstallationState.LibraryId, cancellationToken).ConfigureAwait(false);
await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
using (ITextEdit edit = TextBuffer.CreateEdit())
{
var arrayElement = _provider.LibraryObject.Parent as JSONArrayElement;
var prev = GetPreviousSibling(arrayElement) as JSONArrayElement;
var next = GetNextSibling(arrayElement) as JSONArrayElement;
int start = TextBuffer.CurrentSnapshot.GetLineFromPosition(arrayElement.Start).Start;
int end = TextBuffer.CurrentSnapshot.GetLineFromPosition(arrayElement.AfterEnd).EndIncludingLineBreak;
if (next == null && prev?.Comma != null)
{
start = prev.Comma.Start;
end = TextBuffer.CurrentSnapshot.GetLineFromPosition(arrayElement.AfterEnd).End;
}
edit.Delete(Span.FromBounds(start, end));
edit.Apply();
}
}
catch (Exception ex)
{
Logger.LogEvent(ex.ToString(), LibraryManager.Contracts.LogLevel.Error);
Telemetry.TrackException("UninstallFromSuggestedActionFailed", ex);
}
}
public static void LogEvent(string message, LogLevel level)
{
try
{
switch (level)
{
case LogLevel.Operation:
LogToOutputWindow(message);
break;
case LogLevel.Error:
LogToActivityLog(message, __ACTIVITYLOG_ENTRYTYPE.ALE_ERROR);
break;
case LogLevel.Task:
LogToStatusBar(message);
LogToOutputWindow(message);
break;
case LogLevel.Status:
LogToStatusBar(message);
break;
}
}
catch (Exception ex)
{
Telemetry.TrackException(nameof(LogEvent), ex);
System.Diagnostics.Debug.Write(ex);
}
}
private async Task <Dictionary <string, Manifest> > GetManifestFromConfigAsync(IEnumerable <string> configFiles, CancellationToken cancellationToken)
{
Dictionary <string, Manifest> manifests = new Dictionary <string, Manifest>();
try
{
foreach (string configFilePath in configFiles)
{
Dependencies dependencies = Dependencies.FromConfigFile(configFilePath);
Manifest manifest = await Manifest.FromFileAsync(configFilePath, dependencies, cancellationToken).ConfigureAwait(false);
if (manifest != null)
{
manifests.Add(configFilePath, manifest);
}
}
}
catch (Exception ex)
{
Logger.LogEvent(LibraryManager.Resources.Text.Restore_OperationFailed + Environment.NewLine + ex.Message, LogLevel.Operation);
Telemetry.TrackException(nameof(GetManifestFromConfigAsync), ex);
return(null);
}
return(manifests);
}
public void DeleteFiles(params string[] relativeFilePaths)
{
foreach (string relativeFilePath in relativeFilePaths)
{
string absoluteFile = new FileInfo(Path.Combine(WorkingDirectory, relativeFilePath)).FullName;
try
{
ProjectItem item = VsHelpers.DTE.Solution.FindProjectItem(absoluteFile);
Project project = item?.ContainingProject;
if (project != null)
{
item.Delete();
}
else
{
VsHelpers.CheckFileOutOfSourceControl(absoluteFile);
File.Delete(absoluteFile);
}
Logger.Log(string.Format(LibraryManager.Resources.Text.FileDeleted, relativeFilePath.Replace(Path.DirectorySeparatorChar, '/')), LogLevel.Operation);
}
catch (Exception ex)
{
Logger.Log(string.Format(LibraryManager.Resources.Text.FileDeleteFail, relativeFilePath.Replace(Path.DirectorySeparatorChar, '/')), LogLevel.Operation);
Telemetry.TrackException("deletefilefailed", ex);
}
}
}
public override async Task <IEnumerable <SuggestedActionSet> > GetActionSetsAsync(CancellationToken cancellationToken)
{
try
{
return(await GetActionSetAsync().ConfigureAwait(false));
}
catch (Exception ex)
{
Telemetry.TrackException(nameof(GetActionSetsAsync), ex);
return(null);
}
}
private void Execute(object sender, EventArgs e)
{
ProjectItem item = VsHelpers.DTE.SelectedItems.Item(1).ProjectItem;
try
{
var dependencies = Dependencies.FromConfigFile(item.FileNames[1]);
IEnumerable <string> packageIds = dependencies.Providers.Select(p => p.NuGetPackageId).Distinct();
if (!_isPackageInstalled)
{
if (!UserWantsToInstall())
{
return;
}
System.Threading.Tasks.Task.Run(() =>
{
Logger.LogEvent("Installing NuGet package containing MSBuild target...", LogLevel.Status);
foreach (string packageId in packageIds)
{
IVsPackageInstaller2 installer = _componentModel.GetService <IVsPackageInstaller2>();
installer.InstallLatestPackage(null, item.ContainingProject, packageId, true, false);
}
Telemetry.TrackUserTask("InstallNugetPackage");
Logger.LogEvent("NuGet package installed", LogLevel.Status);
});
}
else
{
System.Threading.Tasks.Task.Run(() =>
{
Logger.LogEvent("Uninstalling NuGet package...", LogLevel.Status);
foreach (string packageId in packageIds)
{
IVsPackageUninstaller uninstaller = _componentModel.GetService <IVsPackageUninstaller>();
uninstaller.UninstallPackage(item.ContainingProject, packageId, false);
}
Telemetry.TrackUserTask("UninstallNugetPackage");
Logger.LogEvent("NuGet package uninstalled", LogLevel.Status);
});
}
}
catch (Exception ex)
{
Telemetry.TrackException(nameof(RestoreOnBuildCommand), ex);
Logger.LogEvent("Error installing NuGet package", LogLevel.Status);
}
}
private async Task UninstallLibraryAsync(string configFilePath, string libraryName, string version, string providerId, CancellationToken cancellationToken)
{
string libraryId = LibraryIdToNameAndVersionConverter.Instance.GetLibraryId(libraryName, version, providerId);
Logger.LogEventsHeader(OperationType.Uninstall, libraryId);
try
{
Stopwatch sw = new Stopwatch();
sw.Start();
var dependencies = _dependenciesFactory.FromConfigFile(configFilePath);
Manifest manifest = await Manifest.FromFileAsync(configFilePath, dependencies, cancellationToken).ConfigureAwait(false);
ILibraryOperationResult result = null;
if (manifest == null)
{
result = LibraryOperationResult.FromError(PredefinedErrors.ManifestMalformed());
}
else
{
IHostInteraction hostInteraction = dependencies.GetHostInteractions();
result = await manifest.UninstallAsync(libraryName, version, async (filesPaths) => await hostInteraction.DeleteFilesAsync(filesPaths, cancellationToken), cancellationToken).ConfigureAwait(false);
}
sw.Stop();
if (result.Errors.Any())
{
Logger.LogErrorsSummary(new List <ILibraryOperationResult> {
result
}, OperationType.Uninstall);
}
else
{
Logger.LogEventsSummary(new List <ILibraryOperationResult> {
result
}, OperationType.Uninstall, sw.Elapsed);
}
Telemetry.LogEventsSummary(new List <ILibraryOperationResult> {
result
}, OperationType.Uninstall, sw.Elapsed);
}
catch (OperationCanceledException ex)
{
Logger.LogEvent(string.Format(LibraryManager.Resources.Text.Uninstall_LibraryCancelled, libraryId), LogLevel.Task);
Telemetry.TrackException($@"{OperationType.Uninstall}Cancelled", ex);
}
}
private async Task RestoreInternalAsync(IDictionary <string, Manifest> manifests, CancellationToken cancellationToken)
{
Logger.LogEventsHeader(OperationType.Restore, string.Empty);
try
{
Stopwatch swTotal = new Stopwatch();
swTotal.Start();
foreach (KeyValuePair <string, Manifest> manifest in manifests)
{
cancellationToken.ThrowIfCancellationRequested();
Stopwatch swLocal = new Stopwatch();
swLocal.Start();
IDependencies dependencies = Dependencies.FromConfigFile(manifest.Key);
Project project = VsHelpers.GetDTEProjectFromConfig(manifest.Key);
Logger.LogEvent(string.Format(LibraryManager.Resources.Text.Restore_LibrariesForProject, project?.Name), LogLevel.Operation);
IEnumerable <ILibraryOperationResult> validationResults = await LibrariesValidator.GetManifestErrorsAsync(manifest.Value, dependencies, cancellationToken).ConfigureAwait(false);
if (!validationResults.All(r => r.Success))
{
swLocal.Stop();
AddErrorsToErrorList(project?.Name, manifest.Key, validationResults);
Logger.LogErrorsSummary(validationResults, OperationType.Restore, false);
Telemetry.LogErrors($"FailValidation_{OperationType.Restore}", validationResults);
}
else
{
IEnumerable <ILibraryOperationResult> results = await RestoreLibrariesAsync(manifest.Value, cancellationToken).ConfigureAwait(false);
await AddFilesToProjectAsync(manifest.Key, project, results.Where(r => r.Success && !r.UpToDate), cancellationToken).ConfigureAwait(false);
swLocal.Stop();
AddErrorsToErrorList(project?.Name, manifest.Key, results);
Logger.LogEventsSummary(results, OperationType.Restore, swLocal.Elapsed, false);
Telemetry.LogEventsSummary(results, OperationType.Restore, swLocal.Elapsed);
}
}
swTotal.Stop();
Logger.LogEventsFooter(OperationType.Restore, swTotal.Elapsed);
}
catch (OperationCanceledException ex)
{
Logger.LogEvent(LibraryManager.Resources.Text.Restore_OperationCancelled, LogLevel.Task);
Telemetry.TrackException($@"{OperationType.Restore}Cancelled", ex);
}
}
private static async Task <bool> DeleteProjectItemsInBatchAsync(IVsHierarchy hierarchy, IEnumerable <string> filePaths, Action <string, LogLevel> logAction, CancellationToken cancellationToken)
{
await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
IVsProjectBuildSystem bldSystem = hierarchy as IVsProjectBuildSystem;
HashSet <ProjectItem> folders = new HashSet <ProjectItem>();
try
{
if (bldSystem != null)
{
bldSystem.StartBatchEdit();
}
foreach (string filePath in filePaths)
{
cancellationToken.ThrowIfCancellationRequested();
ProjectItem item = DTE.Solution.FindProjectItem(filePath);
if (item != null)
{
ProjectItem parentFolder = item.Collection.Parent as ProjectItem;
folders.Add(parentFolder);
item.Delete();
logAction.Invoke(string.Format(Resources.Text.LibraryDeletedFromProject, filePath.Replace('\\', '/')), LogLevel.Operation);
}
}
DeleteEmptyFolders(folders);
}
catch (Exception ex)
{
Telemetry.TrackException(nameof(DeleteProjectItemsInBatchAsync), ex);
return(false);
}
finally
{
if (bldSystem != null)
{
bldSystem.EndBatchEdit();
}
}
return(true);
}
private static async Task <bool> AddProjectItemsInBatchAsync(IVsHierarchy vsHierarchy, List <string> filePaths, Action <string, LogLevel> logAction, CancellationToken cancellationToken)
{
await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
IVsProjectBuildSystem bldSystem = vsHierarchy as IVsProjectBuildSystem;
try
{
if (bldSystem != null)
{
bldSystem.StartBatchEdit();
}
cancellationToken.ThrowIfCancellationRequested();
var vsProject = (IVsProject)vsHierarchy;
VSADDRESULT[] result = new VSADDRESULT[filePaths.Count()];
vsProject.AddItem(VSConstants.VSITEMID_ROOT,
VSADDITEMOPERATION.VSADDITEMOP_LINKTOFILE,
string.Empty,
(uint)filePaths.Count(),
filePaths.ToArray(),
IntPtr.Zero,
result);
foreach (string filePath in filePaths)
{
logAction.Invoke(string.Format(Resources.Text.LibraryAddedToProject, filePath.Replace('\\', '/')), LogLevel.Operation);
}
}
catch (Exception ex)
{
Telemetry.TrackException(nameof(AddProjectItemsInBatchAsync), ex);
return(false);
}
finally
{
if (bldSystem != null)
{
bldSystem.EndBatchEdit();
}
}
return(true);
}
public static Project GetDTEProjectFromConfig(string file)
{
try
{
ProjectItem projectItem = DTE.Solution.FindProjectItem(file);
if (projectItem != null)
{
return(projectItem.ContainingProject);
}
}
catch (Exception ex)
{
Logger.LogEvent(ex.ToString(), LogLevel.Error);
Telemetry.TrackException(nameof(GetDTEProjectFromConfig), ex);
System.Diagnostics.Debug.Write(ex);
}
return(null);
}
private async Task RestoreInternalAsync(IDictionary <string, Manifest> manifests, CancellationToken cancellationToken)
{
Logger.LogEventsHeader(OperationType.Restore, string.Empty);
List <ILibraryOperationResult> totalResults = new List <ILibraryOperationResult>();
try
{
Stopwatch sw = new Stopwatch();
sw.Start();
foreach (KeyValuePair <string, Manifest> manifest in manifests)
{
cancellationToken.ThrowIfCancellationRequested();
Project project = VsHelpers.GetDTEProjectFromConfig(manifest.Key);
Logger.LogEvent(string.Format(LibraryManager.Resources.Text.Restore_LibrariesForProject, project?.Name), LogLevel.Operation);
IEnumerable <ILibraryOperationResult> results = await RestoreLibrariesAsync(manifest.Value, cancellationToken).ConfigureAwait(false);
await AddFilesToProjectAsync(manifest.Key, project, results.Where(r => r.Success && !r.UpToDate), cancellationToken).ConfigureAwait(false);
AddErrorsToErrorList(project?.Name, manifest.Key, results);
totalResults.AddRange(results);
}
sw.Stop();
Logger.LogEventsSummary(totalResults, OperationType.Restore, sw.Elapsed);
Telemetry.LogEventsSummary(totalResults, OperationType.Restore, sw.Elapsed);
}
catch (OperationCanceledException ex)
{
Logger.LogEvent(LibraryManager.Resources.Text.Restore_OperationCancelled, LogLevel.Task);
Telemetry.TrackException($@"{OperationType.Restore}Cancelled", ex);
}
}
public override void Invoke(CancellationToken cancellationToken)
{
Telemetry.TrackUserTask("Invoke-UpdateSuggestedAction");
if (_disabled)
{
return;
}
try
{
IDependencies dependencies = _provider.DependenciesFactory.FromConfigFile(_provider.ConfigFilePath);
IProvider provider = dependencies.GetProvider(_provider.InstallationState.ProviderId);
ILibraryCatalog catalog = provider?.GetCatalog();
if (catalog == null)
{
return;
}
SortedNodeList <Node> children = JsonHelpers.GetChildren(_provider.LibraryObject);
MemberNode member = children.OfType <MemberNode>().FirstOrDefault(m => m.UnquotedNameText == ManifestConstants.Library);
if (member != null)
{
using (ITextEdit edit = TextBuffer.CreateEdit())
{
edit.Replace(new Span(member.Value.Start, member.Value.Width), "\"" + _updatedLibraryId + "\"");
edit.Apply();
}
}
}
catch (Exception ex)
{
Logger.LogEvent(ex.ToString(), LogLevel.Error);
Telemetry.TrackException("UpdateSuggestedActionFailed", ex);
}
}
public static async Task <bool> DeleteFilesFromProjectAsync(Project project, IEnumerable <string> filePaths, Action <string, LogLevel> logAction, CancellationToken cancellationToken)
{
await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
int batchSize = 10;
try
{
IVsHierarchy hierarchy = GetHierarchy(project);
IVsProjectBuildSystem bldSystem = hierarchy as IVsProjectBuildSystem;
List <string> filesToRemove = filePaths.ToList();
while (filesToRemove.Any())
{
List <string> nextBatch = filesToRemove.Take(batchSize).ToList();
bool success = await DeleteProjectItemsInBatchAsync(hierarchy, nextBatch, logAction, cancellationToken);
if (!success)
{
return(false);
}
await System.Threading.Tasks.Task.Yield();
int countToDelete = Math.Min(filesToRemove.Count(), batchSize);
filesToRemove.RemoveRange(0, countToDelete);
}
return(true);
}
catch (Exception ex)
{
Telemetry.TrackException(nameof(DeleteFilesFromProjectAsync), ex);
return(false);
}
}
private async Task ExecuteAsync(object sender, EventArgs e)
{
ProjectItem projectItem = await VsHelpers.GetSelectedItemAsync();
Project project = await VsHelpers.GetProjectOfSelectedItemAsync();
try
{
var dependencies = _dependenciesFactory.FromConfigFile(projectItem.FileNames[1]);
IEnumerable <string> packageIds = dependencies.Providers
.Where(p => p.NuGetPackageId != null)
.Select(p => p.NuGetPackageId)
.Distinct();
if (!_isPackageInstalled)
{
if (!UserWantsToInstall())
{
return;
}
await Task.Run(() =>
{
Logger.LogEvent(Resources.Text.Nuget_InstallingPackage, LogLevel.Status);
try
{
foreach (string packageId in packageIds)
{
IVsPackageInstaller2 installer = _componentModel.GetService <IVsPackageInstaller2>();
installer.InstallLatestPackage(null, project, packageId, true, false);
}
Telemetry.TrackUserTask("Install-NugetPackage");
Logger.LogEvent(Resources.Text.Nuget_PackageInstalled, LogLevel.Status);
}
catch (Exception ex)
{
Telemetry.TrackException(nameof(RestoreOnBuildCommand), ex);
Logger.LogEvent(Resources.Text.Nuget_PackageFailedToInstall, LogLevel.Status);
}
});
}
else
{
await Task.Run(() =>
{
Logger.LogEvent(Resources.Text.Nuget_UninstallingPackage, LogLevel.Status);
try
{
foreach (string packageId in packageIds)
{
IVsPackageUninstaller uninstaller = _componentModel.GetService <IVsPackageUninstaller>();
uninstaller.UninstallPackage(project, packageId, false);
}
Telemetry.TrackUserTask("Uninstall-NugetPackage");
Logger.LogEvent(Resources.Text.Nuget_PackageUninstalled, LogLevel.Status);
}
catch (Exception ex)
{
Telemetry.TrackException(nameof(RestoreOnBuildCommand), ex);
Logger.LogEvent(Resources.Text.Nuget_PackageFailedToUninstall, LogLevel.Status);
}
});
}
}
catch (Exception ex)
{
Telemetry.TrackException(nameof(RestoreOnBuildCommand), ex);
Logger.LogEvent(Resources.Text.Nuget_PackageFailedToInstall, LogLevel.Status);
}
}
