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); } }