/// <summary> /// Asynchronously transforms a file. /// </summary> /// <param name="streamTaskFactory">A stream task factory.</param> /// <param name="targetPath">A path to the file to be transformed.</param> /// <param name="projectSystem">The project where this change is taking place.</param> /// <param name="cancellationToken">A cancellation token.</param> /// <returns>A task that represents the asynchronous operation.</returns> /// <exception cref="ArgumentNullException">Thrown if <paramref name="streamTaskFactory" /> /// is <c>null</c>.</exception> /// <exception cref="ArgumentNullException">Thrown if <paramref name="projectSystem" /> /// is <c>null</c>.</exception> /// <exception cref="OperationCanceledException">Thrown if <paramref name="cancellationToken" /> /// is cancelled.</exception> public async Task TransformFileAsync( Func <Task <Stream> > streamTaskFactory, string targetPath, IMSBuildProjectSystem projectSystem, CancellationToken cancellationToken) { if (streamTaskFactory == null) { throw new ArgumentNullException(nameof(streamTaskFactory)); } if (projectSystem == null) { throw new ArgumentNullException(nameof(projectSystem)); } cancellationToken.ThrowIfCancellationRequested(); // Get the xml fragment var xmlFragment = await GetXmlAsync(streamTaskFactory, projectSystem, cancellationToken); var transformDocument = XmlUtility.GetOrCreateDocument(xmlFragment.Name, targetPath, projectSystem); // Do a merge transformDocument.Root.MergeWith(xmlFragment, _nodeActions); MSBuildNuGetProjectSystemUtility.AddFile(projectSystem, targetPath, transformDocument.Save); }
/// <summary> /// Asynchronously reverses the transform on the targetPath, using all the potential source of change. /// </summary> /// <param name="streamTaskFactory">A factory for accessing the file to be reverted from the nupkg being uninstalled.</param> /// <param name="targetPath">A path to the file to be reverted.</param> /// <param name="matchingFiles">Other files in other packages that may have changed the <paramref name="targetPath" />.</param> /// <param name="projectSystem">The project where this change is taking place.</param> /// <param name="cancellationToken">A cancellation token.</param> /// <returns>A task that represents the asynchronous operation.</returns> /// <exception cref="ArgumentNullException">Thrown if <paramref name="streamTaskFactory" /> /// is <c>null</c>.</exception> /// <exception cref="ArgumentNullException">Thrown if <paramref name="projectSystem" /> /// is <c>null</c>.</exception> /// <exception cref="OperationCanceledException">Thrown if <paramref name="cancellationToken" /> /// is cancelled.</exception> public async Task RevertFileAsync( Func <Task <Stream> > streamTaskFactory, string targetPath, IEnumerable <InternalZipFileInfo> matchingFiles, IMSBuildProjectSystem projectSystem, CancellationToken cancellationToken) { if (streamTaskFactory == null) { throw new ArgumentNullException(nameof(streamTaskFactory)); } if (projectSystem == null) { throw new ArgumentNullException(nameof(projectSystem)); } cancellationToken.ThrowIfCancellationRequested(); await MSBuildNuGetProjectSystemUtility.DeleteFileSafeAsync( targetPath, async() => StreamUtility.StreamFromString(await ProcessAsync(streamTaskFactory, projectSystem, cancellationToken)), projectSystem, cancellationToken); }
public static XDocument CreateDocument(XName rootName, string path, IMSBuildNuGetProjectSystem msBuildNuGetProjectSystem) { XDocument document = new XDocument(new XElement(rootName)); // Add it to the project system MSBuildNuGetProjectSystemUtility.AddFile(msBuildNuGetProjectSystem, path, document.Save); return(document); }
public void TransformFile(ZipArchiveEntry packageFile, string targetPath, IMSBuildNuGetProjectSystem msBuildNuGetProjectSystem) { // Get the xml fragment XElement xmlFragment = GetXml(packageFile, msBuildNuGetProjectSystem); XDocument transformDocument = XmlUtility.GetOrCreateDocument(xmlFragment.Name, targetPath, msBuildNuGetProjectSystem); // Do a merge transformDocument.Root.MergeWith(xmlFragment, _nodeActions); MSBuildNuGetProjectSystemUtility.AddFile(msBuildNuGetProjectSystem, targetPath, transformDocument.Save); }
public void TransformFile(Func <Stream> fileStreamFactory, string targetPath, IMSBuildNuGetProjectSystem msBuildNuGetProjectSystem) { // Get the xml fragment var xmlFragment = GetXml(fileStreamFactory, msBuildNuGetProjectSystem); var transformDocument = XmlUtility.GetOrCreateDocument(xmlFragment.Name, targetPath, msBuildNuGetProjectSystem); // Do a merge transformDocument.Root.MergeWith(xmlFragment, _nodeActions); MSBuildNuGetProjectSystemUtility.AddFile(msBuildNuGetProjectSystem, targetPath, transformDocument.Save); }
internal static async Task PerformXdtTransformAsync( Func <Task <Stream> > streamTaskFactory, string targetPath, IMSBuildProjectSystem msBuildNuGetProjectSystem, CancellationToken cancellationToken) { if (FileSystemUtility.FileExists(msBuildNuGetProjectSystem.ProjectFullPath, targetPath)) { var content = await Preprocessor.ProcessAsync(streamTaskFactory, msBuildNuGetProjectSystem, cancellationToken); try { using (var transformation = new XmlTransformation(content, isTransformAFile: false, logger: null)) { using (var document = new XmlTransformableDocument()) { // make sure we close the input stream immediately so that we can override // the file below when we save to it. string path = FileSystemUtility.GetFullPath(msBuildNuGetProjectSystem.ProjectFullPath, targetPath); using (FileStream fileStream = File.OpenRead(path)) { using var xmlReader = XmlReader.Create(fileStream, GetXmlReaderSettings(LoadOptions.PreserveWhitespace)); document.Load(xmlReader); } var succeeded = transformation.Apply(document); if (succeeded) { // save the result into a memoryStream first so that if there is any // exception during document.Save(), the original file won't be truncated. MSBuildNuGetProjectSystemUtility.AddFile(msBuildNuGetProjectSystem, targetPath, document.Save); } } } } catch (Exception exception) { throw new InvalidDataException( string.Format( CultureInfo.CurrentCulture, Strings.XdtError + " " + exception.Message, targetPath, msBuildNuGetProjectSystem.ProjectName), exception); } } }
private static void PerformXdtTransform(Func <Stream> fileStreamFactory, string targetPath, IMSBuildNuGetProjectSystem msBuildNuGetProjectSystem) { if (FileSystemUtility.FileExists(msBuildNuGetProjectSystem.ProjectFullPath, targetPath)) { var content = Preprocessor.Process(fileStreamFactory, msBuildNuGetProjectSystem); try { using (var transformation = new XmlTransformation(content, isTransformAFile: false, logger: null)) { using (var document = new XmlTransformableDocument()) { document.PreserveWhitespace = true; // make sure we close the input stream immediately so that we can override // the file below when we save to it. using (var inputStream = File.OpenRead(FileSystemUtility.GetFullPath(msBuildNuGetProjectSystem.ProjectFullPath, targetPath))) { document.Load(inputStream); } var succeeded = transformation.Apply(document); if (succeeded) { // save the result into a memoryStream first so that if there is any // exception during document.Save(), the original file won't be truncated. MSBuildNuGetProjectSystemUtility.AddFile(msBuildNuGetProjectSystem, targetPath, document.Save); } } } } catch (Exception exception) { throw new InvalidDataException( string.Format( CultureInfo.CurrentCulture, Strings.XdtError + " " + exception.Message, targetPath, msBuildNuGetProjectSystem.ProjectName), exception); } } }
/// <summary> /// Asynchronously transforms a file. /// </summary> /// <param name="streamTaskFactory">A stream task factory.</param> /// <param name="targetPath">A path to the file to be transformed.</param> /// <param name="projectSystem">The project where this change is taking place.</param> /// <param name="cancellationToken">A cancellation token.</param> /// <returns>A task that represents the asynchronous operation.</returns> /// <exception cref="ArgumentNullException">Thrown if <paramref name="streamTaskFactory" /> /// is <c>null</c>.</exception> /// <exception cref="ArgumentNullException">Thrown if <paramref name="projectSystem" /> /// is <c>null</c>.</exception> /// <exception cref="OperationCanceledException">Thrown if <paramref name="cancellationToken" /> /// is cancelled.</exception> public async Task TransformFileAsync( Func <Task <Stream> > streamTaskFactory, string targetPath, IMSBuildProjectSystem projectSystem, CancellationToken cancellationToken) { if (streamTaskFactory == null) { throw new ArgumentNullException(nameof(streamTaskFactory)); } if (projectSystem == null) { throw new ArgumentNullException(nameof(projectSystem)); } cancellationToken.ThrowIfCancellationRequested(); await MSBuildNuGetProjectSystemUtility.TryAddFileAsync( projectSystem, targetPath, async() => StreamUtility.StreamFromString(await ProcessAsync(streamTaskFactory, projectSystem, cancellationToken)), cancellationToken); }
public void TransformFile(Func <Stream> fileStreamFactory, string targetPath, IMSBuildNuGetProjectSystem msBuildNuGetProjectSystem) { MSBuildNuGetProjectSystemUtility.TryAddFile(msBuildNuGetProjectSystem, targetPath, () => StreamUtility.StreamFromString(Process(fileStreamFactory, msBuildNuGetProjectSystem))); }
public override async Task <bool> UninstallPackageAsync(PackageIdentity packageIdentity, INuGetProjectContext nuGetProjectContext, CancellationToken token) { if (packageIdentity == null) { throw new ArgumentNullException(nameof(packageIdentity)); } if (nuGetProjectContext == null) { throw new ArgumentNullException(nameof(nuGetProjectContext)); } // Step-1: Check if the package already exists after setting the nuGetProjectContext ProjectSystem.NuGetProjectContext = nuGetProjectContext; var packageReference = (await GetInstalledPackagesAsync(token)) .FirstOrDefault(p => p.PackageIdentity.Equals(packageIdentity)); if (packageReference == null) { nuGetProjectContext.Log(MessageLevel.Warning, Strings.PackageDoesNotExistInProject, packageIdentity, ProjectSystem.ProjectName); return(false); } var packageTargetFramework = packageReference.TargetFramework ?? ProjectSystem.TargetFramework; var packageEventArgs = new PackageEventArgs(FolderNuGetProject, packageIdentity, FolderNuGetProject.GetInstalledPath(packageIdentity)); if (PackageUninstalling != null) { PackageUninstalling(this, packageEventArgs); } PackageEventsProvider.Instance.NotifyUninstalling(packageEventArgs); using (var packageStream = File.OpenRead(FolderNuGetProject.GetInstalledPackageFilePath(packageIdentity))) { var zipArchive = new ZipArchive(packageStream); var packageReader = new PackageArchiveReader(zipArchive); // Step-2: Execute powershell script - uninstall.ps1 var toolItemGroups = packageReader.GetToolItems(); var compatibleToolItemsGroup = MSBuildNuGetProjectSystemUtility .GetMostCompatibleGroup(packageTargetFramework, toolItemGroups); compatibleToolItemsGroup = MSBuildNuGetProjectSystemUtility.Normalize(compatibleToolItemsGroup); if (MSBuildNuGetProjectSystemUtility.IsValid(compatibleToolItemsGroup)) { var uninstallPS1RelativePath = compatibleToolItemsGroup.Items.FirstOrDefault( p => p.EndsWith(Path.DirectorySeparatorChar + PowerShellScripts.Uninstall, StringComparison.OrdinalIgnoreCase)); if (!string.IsNullOrEmpty(uninstallPS1RelativePath)) { var packageInstallPath = FolderNuGetProject.GetInstalledPath( packageIdentity); await ProjectServices.ScriptService.ExecutePackageScriptAsync( packageIdentity, packageInstallPath, uninstallPS1RelativePath, nuGetProjectContext, throwOnFailure : false, token : token); } } // Step-3: Obtain the various item groups // Get the package target framework instead of using project targetframework var referenceItemGroups = packageReader.GetReferenceItems(); var contentFileGroups = packageReader.GetContentItems(); var buildFileGroups = packageReader.GetBuildItems(); // Step-4: Get the most compatible items groups for all items groups var compatibleReferenceItemsGroup = MSBuildNuGetProjectSystemUtility.GetMostCompatibleGroup(packageTargetFramework, referenceItemGroups); var compatibleContentFilesGroup = MSBuildNuGetProjectSystemUtility.GetMostCompatibleGroup(packageTargetFramework, contentFileGroups); var compatibleBuildFilesGroup = MSBuildNuGetProjectSystemUtility.GetMostCompatibleGroup(packageTargetFramework, buildFileGroups); compatibleReferenceItemsGroup = MSBuildNuGetProjectSystemUtility.Normalize(compatibleReferenceItemsGroup); compatibleContentFilesGroup = MSBuildNuGetProjectSystemUtility.Normalize(compatibleContentFilesGroup); compatibleBuildFilesGroup = MSBuildNuGetProjectSystemUtility.Normalize(compatibleBuildFilesGroup); // Step-5: Remove package reference from packages.config await PackagesConfigNuGetProject.UninstallPackageAsync(packageIdentity, nuGetProjectContext, token); // Step-6: Remove packages.config from MSBuildNuGetProject if there are no packages // OR Add it again (to ensure that Source Control works), when there are some packages if (!(await PackagesConfigNuGetProject.GetInstalledPackagesAsync(token)).Any()) { ProjectSystem.RemoveFile(Path.GetFileName(PackagesConfigNuGetProject.FullPath)); } else { ProjectSystem.AddExistingFile(Path.GetFileName(PackagesConfigNuGetProject.FullPath)); } // Step-7: Uninstall package from the msbuild project // Step-7.1: Remove references if (MSBuildNuGetProjectSystemUtility.IsValid(compatibleReferenceItemsGroup)) { foreach (var item in compatibleReferenceItemsGroup.Items) { if (IsAssemblyReference(item)) { await ProjectSystem.RemoveReferenceAsync(Path.GetFileName(item)); } } } // Step-7.2: Framework references are never removed. This is a no-op // Step-7.3: Remove content files if (MSBuildNuGetProjectSystemUtility.IsValid(compatibleContentFilesGroup)) { var packagesPaths = (await GetInstalledPackagesAsync(token)) .Select(pr => FolderNuGetProject.GetInstalledPackageFilePath(pr.PackageIdentity)); await MSBuildNuGetProjectSystemUtility.DeleteFilesAsync( ProjectSystem, zipArchive, packagesPaths, compatibleContentFilesGroup, FileTransformers, token); } // Step-7.4: Remove build imports if (MSBuildNuGetProjectSystemUtility.IsValid(compatibleBuildFilesGroup)) { foreach (var buildImportFile in compatibleBuildFilesGroup.Items) { var fullImportFilePath = Path.Combine(FolderNuGetProject.GetInstalledPath(packageIdentity), buildImportFile); ProjectSystem.RemoveImport(fullImportFilePath); } } // Step-7.5: Remove binding redirects. This is a no-op // Binding redirects will be removed when all packages have finished // uninstalling for performance reasons // Step-8: Raise PackageReferenceRemoved event if (PackageReferenceRemoved != null) { PackageReferenceRemoved(this, packageEventArgs); } PackageEventsProvider.Instance.NotifyReferenceRemoved(packageEventArgs); } // Step-9: Uninstall package from the folderNuGetProject await FolderNuGetProject.UninstallPackageAsync(packageIdentity, nuGetProjectContext, token); // Step-10: Raise PackageUninstalled event if (PackageUninstalled != null) { PackageUninstalled(this, packageEventArgs); } PackageEventsProvider.Instance.NotifyUninstalled(packageEventArgs); return(true); }
public override async Task <bool> InstallPackageAsync( PackageIdentity packageIdentity, DownloadResourceResult downloadResourceResult, INuGetProjectContext nuGetProjectContext, CancellationToken token) { if (packageIdentity == null) { throw new ArgumentNullException(nameof(packageIdentity)); } if (downloadResourceResult == null) { throw new ArgumentNullException(nameof(downloadResourceResult)); } if (nuGetProjectContext == null) { throw new ArgumentNullException(nameof(nuGetProjectContext)); } if (downloadResourceResult.Status != DownloadResourceResultStatus.AvailableWithoutStream && !downloadResourceResult.PackageStream.CanSeek) { throw new ArgumentException(Strings.PackageStreamShouldBeSeekable); } // Step-1: Check if the package already exists after setting the nuGetProjectContext ProjectSystem.NuGetProjectContext = nuGetProjectContext; var packageReference = (await GetInstalledPackagesAsync(token)) .FirstOrDefault(p => p.PackageIdentity.Equals(packageIdentity)); if (packageReference != null) { nuGetProjectContext.Log(MessageLevel.Warning, Strings.PackageAlreadyExistsInProject, packageIdentity, ProjectSystem.ProjectName); return(false); } // Step-2: Create PackageArchiveReader using the PackageStream and obtain the various item groups if (downloadResourceResult.Status != DownloadResourceResultStatus.AvailableWithoutStream) { downloadResourceResult.PackageStream.Seek(0, SeekOrigin.Begin); } // These casts enforce use of -Async(...) methods. var packageReader = downloadResourceResult.PackageReader ?? new PackageArchiveReader(downloadResourceResult.PackageStream, leaveStreamOpen: true); IAsyncPackageContentReader packageContentReader = packageReader; IAsyncPackageCoreReader packageCoreReader = packageReader; var libItemGroups = await packageContentReader.GetLibItemsAsync(token); var referenceItemGroups = await packageContentReader.GetReferenceItemsAsync(token); var frameworkReferenceGroups = await packageContentReader.GetFrameworkItemsAsync(token); var contentFileGroups = await packageContentReader.GetContentItemsAsync(token); var buildFileGroups = await packageContentReader.GetBuildItemsAsync(token); var toolItemGroups = await packageContentReader.GetToolItemsAsync(token); // Step-3: Get the most compatible items groups for all items groups var hasCompatibleProjectLevelContent = false; var compatibleLibItemsGroup = MSBuildNuGetProjectSystemUtility.GetMostCompatibleGroup(ProjectSystem.TargetFramework, libItemGroups); var compatibleReferenceItemsGroup = MSBuildNuGetProjectSystemUtility.GetMostCompatibleGroup(ProjectSystem.TargetFramework, referenceItemGroups); var compatibleFrameworkReferencesGroup = MSBuildNuGetProjectSystemUtility.GetMostCompatibleGroup(ProjectSystem.TargetFramework, frameworkReferenceGroups); var compatibleContentFilesGroup = MSBuildNuGetProjectSystemUtility.GetMostCompatibleGroup(ProjectSystem.TargetFramework, contentFileGroups); var compatibleBuildFilesGroup = MSBuildNuGetProjectSystemUtility.GetMostCompatibleGroup(ProjectSystem.TargetFramework, buildFileGroups); var compatibleToolItemsGroup = MSBuildNuGetProjectSystemUtility.GetMostCompatibleGroup(ProjectSystem.TargetFramework, toolItemGroups); compatibleLibItemsGroup = MSBuildNuGetProjectSystemUtility.Normalize(compatibleLibItemsGroup); compatibleReferenceItemsGroup = MSBuildNuGetProjectSystemUtility.Normalize(compatibleReferenceItemsGroup); compatibleFrameworkReferencesGroup = MSBuildNuGetProjectSystemUtility.Normalize(compatibleFrameworkReferencesGroup); compatibleContentFilesGroup = MSBuildNuGetProjectSystemUtility.Normalize(compatibleContentFilesGroup); compatibleBuildFilesGroup = MSBuildNuGetProjectSystemUtility.Normalize(compatibleBuildFilesGroup); compatibleToolItemsGroup = MSBuildNuGetProjectSystemUtility.Normalize(compatibleToolItemsGroup); hasCompatibleProjectLevelContent = MSBuildNuGetProjectSystemUtility.IsValid(compatibleLibItemsGroup) || MSBuildNuGetProjectSystemUtility.IsValid(compatibleFrameworkReferencesGroup) || MSBuildNuGetProjectSystemUtility.IsValid(compatibleContentFilesGroup) || MSBuildNuGetProjectSystemUtility.IsValid(compatibleBuildFilesGroup); // Check if package has any content for project var hasProjectLevelContent = libItemGroups.Any() || frameworkReferenceGroups.Any() || contentFileGroups.Any() || buildFileGroups.Any(); var onlyHasCompatibleTools = false; var onlyHasDependencies = false; if (!hasProjectLevelContent) { // Since it does not have project-level content, check if it has dependencies or compatible tools // Note that we are not checking if it has compatible project level content, but, just that it has project level content // If the package has project-level content, but nothing compatible, we still need to throw // If a package does not have any project-level content, it can be a // Legacy solution level packages which only has compatible tools group onlyHasCompatibleTools = MSBuildNuGetProjectSystemUtility.IsValid(compatibleToolItemsGroup) && compatibleToolItemsGroup.Items.Any(); if (!onlyHasCompatibleTools) { // If it does not have compatible tool items either, check if it at least has dependencies onlyHasDependencies = (await packageContentReader.GetPackageDependenciesAsync(token)).Any(); } } else { var shortFramework = ProjectSystem.TargetFramework.GetShortFolderName(); nuGetProjectContext.Log(MessageLevel.Debug, Strings.Debug_TargetFrameworkInfoPrefix, packageIdentity, GetMetadata <string>(NuGetProjectMetadataKeys.Name), shortFramework); } // Step-4: Check if there are any compatible items in the package or that this is not a package with only tools group. If not, throw if (!hasCompatibleProjectLevelContent && !onlyHasCompatibleTools && !onlyHasDependencies) { throw new InvalidOperationException( string.Format(CultureInfo.CurrentCulture, Strings.UnableToFindCompatibleItems, packageIdentity.Id + " " + packageIdentity.Version.ToNormalizedString(), ProjectSystem.TargetFramework)); } if (hasCompatibleProjectLevelContent) { var shortFramework = ProjectSystem.TargetFramework.GetShortFolderName(); nuGetProjectContext.Log(MessageLevel.Debug, Strings.Debug_TargetFrameworkInfoPrefix, packageIdentity, GetMetadata <string>(NuGetProjectMetadataKeys.Name), shortFramework); } else if (onlyHasCompatibleTools) { nuGetProjectContext.Log(MessageLevel.Info, Strings.AddingPackageWithOnlyToolsGroup, packageIdentity, GetMetadata <string>(NuGetProjectMetadataKeys.Name)); } else if (onlyHasDependencies) { nuGetProjectContext.Log(MessageLevel.Info, Strings.AddingPackageWithOnlyDependencies, packageIdentity, GetMetadata <string>(NuGetProjectMetadataKeys.Name)); } // Step-5: Raise PackageInstalling event // At this point, GetInstalledPath is pointless since the package is, likely, not already installed. It will be empty // Using PackagePathResolver.GetInstallPath would be wrong, since, package version from the nuspec is always used var packageEventArgs = new PackageEventArgs(FolderNuGetProject, packageIdentity, installPath: string.Empty); if (PackageInstalling != null) { PackageInstalling(this, packageEventArgs); } PackageEventsProvider.Instance.NotifyInstalling(packageEventArgs); // Step-6: Install package to FolderNuGetProject await FolderNuGetProject.InstallPackageAsync(packageIdentity, downloadResourceResult, nuGetProjectContext, token); // Step-7: Raise PackageInstalled event // Call GetInstalledPath to get the package installed path var packageInstallPath = FolderNuGetProject.GetInstalledPath(packageIdentity); packageEventArgs = new PackageEventArgs(FolderNuGetProject, packageIdentity, packageInstallPath); if (PackageInstalled != null) { PackageInstalled(this, packageEventArgs); } PackageEventsProvider.Instance.NotifyInstalled(packageEventArgs); // Step-8: MSBuildNuGetProjectSystem operations // Step-8.1: Add references to project if (!IsSkipAssemblyReferences(nuGetProjectContext) && MSBuildNuGetProjectSystemUtility.IsValid(compatibleReferenceItemsGroup)) { foreach (var referenceItem in compatibleReferenceItemsGroup.Items) { if (IsAssemblyReference(referenceItem)) { var referenceItemFullPath = Path.Combine(packageInstallPath, referenceItem); var referenceName = Path.GetFileName(referenceItem); if (await ProjectSystem.ReferenceExistsAsync(referenceName)) { await ProjectSystem.RemoveReferenceAsync(referenceName); } await ProjectSystem.AddReferenceAsync(referenceItemFullPath); } } } // Step-8.2: Add Frameworkreferences to project if (!IsSkipAssemblyReferences(nuGetProjectContext) && MSBuildNuGetProjectSystemUtility.IsValid(compatibleFrameworkReferencesGroup)) { foreach (var frameworkReference in compatibleFrameworkReferencesGroup.Items) { if (!await ProjectSystem.ReferenceExistsAsync(frameworkReference)) { await ProjectSystem.AddFrameworkReferenceAsync(frameworkReference, packageIdentity.Id); } } } // Step-8.3: Add Content Files if (MSBuildNuGetProjectSystemUtility.IsValid(compatibleContentFilesGroup)) { await MSBuildNuGetProjectSystemUtility.AddFilesAsync( ProjectSystem, packageCoreReader, compatibleContentFilesGroup, FileTransformers, token); } // Step-8.4: Add Build imports if (MSBuildNuGetProjectSystemUtility.IsValid(compatibleBuildFilesGroup)) { foreach (var buildImportFile in compatibleBuildFilesGroup.Items) { var fullImportFilePath = Path.Combine(packageInstallPath, buildImportFile); ProjectSystem.AddImport(fullImportFilePath, fullImportFilePath.EndsWith(".props", StringComparison.OrdinalIgnoreCase) ? ImportLocation.Top : ImportLocation.Bottom); } } // Step-9: Install package to PackagesConfigNuGetProject await PackagesConfigNuGetProject.InstallPackageAsync(packageIdentity, downloadResourceResult, nuGetProjectContext, token); // Step-10: Add packages.config to MSBuildNuGetProject ProjectSystem.AddExistingFile(Path.GetFileName(PackagesConfigNuGetProject.FullPath)); // Step 11: Raise PackageReferenceAdded event PackageReferenceAdded?.Invoke(this, packageEventArgs); PackageEventsProvider.Instance.NotifyReferenceAdded(packageEventArgs); // Step-12: Execute powershell script - install.ps1 var anyFrameworkToolsGroup = toolItemGroups.FirstOrDefault(g => g.TargetFramework.Equals(NuGetFramework.AnyFramework)); if (anyFrameworkToolsGroup != null) { var initPS1RelativePath = anyFrameworkToolsGroup.Items.Where(p => p.StartsWith(PowerShellScripts.InitPS1RelativePath, StringComparison.OrdinalIgnoreCase)).FirstOrDefault(); if (!string.IsNullOrEmpty(initPS1RelativePath)) { initPS1RelativePath = PathUtility.ReplaceAltDirSeparatorWithDirSeparator( initPS1RelativePath); await ProjectServices.ScriptService.ExecutePackageScriptAsync( packageIdentity, packageInstallPath, initPS1RelativePath, nuGetProjectContext, throwOnFailure : true, token : token); } } if (MSBuildNuGetProjectSystemUtility.IsValid(compatibleToolItemsGroup)) { var installPS1RelativePath = compatibleToolItemsGroup.Items.FirstOrDefault( p => p.EndsWith(Path.DirectorySeparatorChar + PowerShellScripts.Install, StringComparison.OrdinalIgnoreCase)); if (!string.IsNullOrEmpty(installPS1RelativePath)) { await ProjectServices.ScriptService.ExecutePackageScriptAsync( packageIdentity, packageInstallPath, installPS1RelativePath, nuGetProjectContext, throwOnFailure : true, token : token); } } return(true); }
public static XDocument GetOrCreateDocument(XName rootName, string path, IMSBuildProjectSystem msBuildNuGetProjectSystem) { return(MSBuildNuGetProjectSystemUtility.GetOrCreateDocument(rootName, path, msBuildNuGetProjectSystem)); }
public void RevertFile(Func <Stream> fileStreamFactory, string targetPath, IEnumerable <InternalZipFileInfo> matchingFiles, IMSBuildNuGetProjectSystem msBuildNuGetProjectSystem) { MSBuildNuGetProjectSystemUtility.DeleteFileSafe(targetPath, () => StreamUtility.StreamFromString(Process(fileStreamFactory, msBuildNuGetProjectSystem)), msBuildNuGetProjectSystem); }
public void RevertFile(ZipArchiveEntry packageFile, string targetPath, IEnumerable <InternalZipFileInfo> matchingFiles, IMSBuildNuGetProjectSystem msBuildNuGetProjectSystem) { MSBuildNuGetProjectSystemUtility.DeleteFileSafe(targetPath, () => StreamUtility.StreamFromString(Process(packageFile, msBuildNuGetProjectSystem)), msBuildNuGetProjectSystem); }
public void TransformFile(ZipArchiveEntry packageFile, string targetPath, IMSBuildNuGetProjectSystem msBuildNuGetProjectSystem) { MSBuildNuGetProjectSystemUtility.TryAddFile(msBuildNuGetProjectSystem, targetPath, () => StreamUtility.StreamFromString(Process(packageFile, msBuildNuGetProjectSystem))); }
public async override Task <bool> UninstallPackageAsync(PackageIdentity packageIdentity, INuGetProjectContext nuGetProjectContext, CancellationToken token) { if (packageIdentity == null) { throw new ArgumentNullException("packageIdentity"); } if (nuGetProjectContext == null) { throw new ArgumentNullException("nuGetProjectContext"); } // Step-1: Check if the package already exists after setting the nuGetProjectContext MSBuildNuGetProjectSystem.SetNuGetProjectContext(nuGetProjectContext); var packageReference = (await GetInstalledPackagesAsync(token)).Where( p => p.PackageIdentity.Equals(packageIdentity)).FirstOrDefault(); if (packageReference == null) { nuGetProjectContext.Log(MessageLevel.Warning, Strings.PackageDoesNotExistInProject, packageIdentity, MSBuildNuGetProjectSystem.ProjectName); return(false); } var packageTargetFramework = packageReference.TargetFramework ?? NuGetFramework.UnsupportedFramework; var packageEventArgs = new PackageEventArgs(FolderNuGetProject, packageIdentity, FolderNuGetProject.GetInstalledPath(packageIdentity)); using (var packageStream = File.OpenRead(FolderNuGetProject.GetInstalledPackageFilePath(packageIdentity))) { // Step-2: Create PackageReader using the PackageStream and obtain the various item groups // Get the package target framework instead of using project targetframework var zipArchive = new ZipArchive(packageStream); var packageReader = new PackageReader(zipArchive); IEnumerable <FrameworkSpecificGroup> referenceItemGroups = packageReader.GetReferenceItems(); IEnumerable <FrameworkSpecificGroup> frameworkReferenceGroups = packageReader.GetFrameworkItems(); IEnumerable <FrameworkSpecificGroup> contentFileGroups = packageReader.GetContentItems(); IEnumerable <FrameworkSpecificGroup> buildFileGroups = packageReader.GetBuildItems(); // Step-3: Get the most compatible items groups for all items groups FrameworkSpecificGroup compatibleReferenceItemsGroup = MSBuildNuGetProjectSystemUtility.GetMostCompatibleGroup(packageTargetFramework, referenceItemGroups); FrameworkSpecificGroup compatibleFrameworkReferencesGroup = MSBuildNuGetProjectSystemUtility.GetMostCompatibleGroup(packageTargetFramework, frameworkReferenceGroups); FrameworkSpecificGroup compatibleContentFilesGroup = MSBuildNuGetProjectSystemUtility.GetMostCompatibleGroup(packageTargetFramework, contentFileGroups); FrameworkSpecificGroup compatibleBuildFilesGroup = MSBuildNuGetProjectSystemUtility.GetMostCompatibleGroup(packageTargetFramework, buildFileGroups); // TODO: Need to handle References element?? // Step-4: Raise PackageUninstalling event if (PackageUninstalling != null) { PackageUninstalling(this, packageEventArgs); } PackageEventsProvider.Instance.NotifyUninstalling(packageEventArgs); // Step-5: Uninstall package from packages.config await PackagesConfigNuGetProject.UninstallPackageAsync(packageIdentity, nuGetProjectContext, token); // Step-6: Remove packages.config from MSBuildNuGetProject if there are no packages // OR Add it again (to ensure that Source Control works), when there are some packages if (!(await PackagesConfigNuGetProject.GetInstalledPackagesAsync(token)).Any()) { MSBuildNuGetProjectSystem.RemoveFile(Path.GetFileName(PackagesConfigNuGetProject.FullPath)); } else { MSBuildNuGetProjectSystem.AddExistingFile(Path.GetFileName(PackagesConfigNuGetProject.FullPath)); } // Step-7: Uninstall package from the msbuild project // Step-7.1: Remove references if (MSBuildNuGetProjectSystemUtility.IsValid(compatibleReferenceItemsGroup)) { foreach (var item in compatibleReferenceItemsGroup.Items) { if (IsAssemblyReference(item)) { MSBuildNuGetProjectSystem.RemoveReference(Path.GetFileName(item)); } } } // Step-7.2: Framework references are never removed. This is a no-op // Step-7.3: Remove content files if (MSBuildNuGetProjectSystemUtility.IsValid(compatibleContentFilesGroup)) { MSBuildNuGetProjectSystemUtility.DeleteFiles(MSBuildNuGetProjectSystem, zipArchive, (await GetInstalledPackagesAsync(token)).Select(pr => FolderNuGetProject.GetInstalledPackageFilePath(pr.PackageIdentity)), compatibleContentFilesGroup, FileTransformers); } // Step-7.4: Remove build imports if (MSBuildNuGetProjectSystemUtility.IsValid(compatibleBuildFilesGroup)) { foreach (var buildImportFile in compatibleBuildFilesGroup.Items) { string fullImportFilePath = Path.Combine(FolderNuGetProject.GetInstalledPath(packageIdentity), buildImportFile); MSBuildNuGetProjectSystem.RemoveImport(fullImportFilePath); } } // Step-7.5: Remove binding redirects. This is a no-op // Step-8: Raise PackageReferenceRemoved event if (PackageReferenceRemoved != null) { PackageReferenceRemoved(this, packageEventArgs); } PackageEventsProvider.Instance.NotifyReferenceRemoved(packageEventArgs); // Step-9: Execute powershell script - uninstall.ps1 IEnumerable <FrameworkSpecificGroup> toolItemGroups = packageReader.GetToolItems(); FrameworkSpecificGroup compatibleToolItemsGroup = MSBuildNuGetProjectSystemUtility.GetMostCompatibleGroup(MSBuildNuGetProjectSystem.TargetFramework, toolItemGroups); if (MSBuildNuGetProjectSystemUtility.IsValid(compatibleToolItemsGroup)) { string uninstallPS1RelativePath = compatibleToolItemsGroup.Items.Where(p => p.EndsWith(Path.DirectorySeparatorChar + PowerShellScripts.Uninstall)).FirstOrDefault(); if (!String.IsNullOrEmpty(uninstallPS1RelativePath)) { string packageInstallPath = FolderNuGetProject.GetInstalledPath(packageIdentity); await MSBuildNuGetProjectSystem.ExecuteScriptAsync(packageInstallPath, uninstallPS1RelativePath, zipArchive, this); } } } // Step-10: Uninstall package from the folderNuGetProject await FolderNuGetProject.UninstallPackageAsync(packageIdentity, nuGetProjectContext, token); // Step-11: Raise PackageUninstalled event if (PackageUninstalled != null) { PackageUninstalled(this, packageEventArgs); } PackageEventsProvider.Instance.NotifyUninstalled(packageEventArgs); return(true); }
public async override Task <bool> InstallPackageAsync(PackageIdentity packageIdentity, Stream packageStream, INuGetProjectContext nuGetProjectContext, CancellationToken token) { if (packageIdentity == null) { throw new ArgumentNullException("packageIdentity"); } if (packageStream == null) { throw new ArgumentNullException("packageStream"); } if (nuGetProjectContext == null) { throw new ArgumentNullException("nuGetProjectContext"); } if (!packageStream.CanSeek) { throw new ArgumentException(Strings.PackageStreamShouldBeSeekable); } // Step-1: Check if the package already exists after setting the nuGetProjectContext MSBuildNuGetProjectSystem.SetNuGetProjectContext(nuGetProjectContext); var packageReference = (await GetInstalledPackagesAsync(token)).Where( p => p.PackageIdentity.Equals(packageIdentity)).FirstOrDefault(); if (packageReference != null) { nuGetProjectContext.Log(MessageLevel.Warning, Strings.PackageAlreadyExistsInProject, packageIdentity, MSBuildNuGetProjectSystem.ProjectName); return(false); } // Step-2: Create PackageReader using the PackageStream and obtain the various item groups packageStream.Seek(0, SeekOrigin.Begin); var zipArchive = new ZipArchive(packageStream); PackageReader packageReader = new PackageReader(zipArchive); IEnumerable <FrameworkSpecificGroup> referenceItemGroups = packageReader.GetReferenceItems(); IEnumerable <FrameworkSpecificGroup> frameworkReferenceGroups = packageReader.GetFrameworkItems(); IEnumerable <FrameworkSpecificGroup> contentFileGroups = packageReader.GetContentItems(); IEnumerable <FrameworkSpecificGroup> buildFileGroups = packageReader.GetBuildItems(); IEnumerable <FrameworkSpecificGroup> toolItemGroups = packageReader.GetToolItems(); // Step-3: Get the most compatible items groups for all items groups bool hasCompatibleProjectLevelContent = false; FrameworkSpecificGroup compatibleReferenceItemsGroup = MSBuildNuGetProjectSystemUtility.GetMostCompatibleGroup(MSBuildNuGetProjectSystem.TargetFramework, referenceItemGroups); FrameworkSpecificGroup compatibleFrameworkReferencesGroup = MSBuildNuGetProjectSystemUtility.GetMostCompatibleGroup(MSBuildNuGetProjectSystem.TargetFramework, frameworkReferenceGroups); FrameworkSpecificGroup compatibleContentFilesGroup = MSBuildNuGetProjectSystemUtility.GetMostCompatibleGroup(MSBuildNuGetProjectSystem.TargetFramework, contentFileGroups); FrameworkSpecificGroup compatibleBuildFilesGroup = MSBuildNuGetProjectSystemUtility.GetMostCompatibleGroup(MSBuildNuGetProjectSystem.TargetFramework, buildFileGroups); FrameworkSpecificGroup compatibleToolItemsGroup = MSBuildNuGetProjectSystemUtility.GetMostCompatibleGroup(MSBuildNuGetProjectSystem.TargetFramework, toolItemGroups); hasCompatibleProjectLevelContent = MSBuildNuGetProjectSystemUtility.IsValid(compatibleReferenceItemsGroup) || MSBuildNuGetProjectSystemUtility.IsValid(compatibleFrameworkReferencesGroup) || MSBuildNuGetProjectSystemUtility.IsValid(compatibleContentFilesGroup) || MSBuildNuGetProjectSystemUtility.IsValid(compatibleBuildFilesGroup); // Check if package has any content for project bool hasProjectLevelContent = referenceItemGroups.Any() || frameworkReferenceGroups.Any() || contentFileGroups.Any() || buildFileGroups.Any(); bool onlyHasCompatibleTools = false; bool onlyHasDependencies = false; if (!hasProjectLevelContent) { // Since it does not have project-level content, check if it has dependencies or compatible tools // Note that we are not checking if it has compatible project level content, but, just that it has project level content // If the package has project-level content, but nothing compatible, we still need to throw // If a package does not have any project-level content, it can be a // Legacy solution level packages which only has compatible tools group onlyHasCompatibleTools = MSBuildNuGetProjectSystemUtility.IsValid(compatibleToolItemsGroup) && compatibleToolItemsGroup.Items.Any(); if (!onlyHasCompatibleTools) { // If it does not have compatible tool items either, check if it at least has dependencies onlyHasDependencies = packageReader.GetPackageDependencies().Any(); } } else { string shortFramework = MSBuildNuGetProjectSystem.TargetFramework.GetShortFolderName(); nuGetProjectContext.Log(MessageLevel.Debug, Strings.Debug_TargetFrameworkInfoPrefix, packageIdentity, this.GetMetadata <string>(NuGetProjectMetadataKeys.Name), shortFramework); } // Step-4: Check if there are any compatible items in the package or that this is not a package with only tools group. If not, throw if (!hasCompatibleProjectLevelContent && !onlyHasCompatibleTools && !onlyHasDependencies) { throw new InvalidOperationException( String.Format(CultureInfo.CurrentCulture, Strings.UnableToFindCompatibleItems, packageIdentity, MSBuildNuGetProjectSystem.TargetFramework)); } if (hasCompatibleProjectLevelContent) { string shortFramework = MSBuildNuGetProjectSystem.TargetFramework.GetShortFolderName(); nuGetProjectContext.Log(MessageLevel.Debug, Strings.Debug_TargetFrameworkInfoPrefix, packageIdentity, this.GetMetadata <string>(NuGetProjectMetadataKeys.Name), shortFramework); } else if (onlyHasCompatibleTools) { nuGetProjectContext.Log(MessageLevel.Info, Strings.AddingPackageWithOnlyToolsGroup, packageIdentity, this.GetMetadata <string>(NuGetProjectMetadataKeys.Name)); } else if (onlyHasDependencies) { nuGetProjectContext.Log(MessageLevel.Info, Strings.AddingPackageWithOnlyDependencies, packageIdentity, this.GetMetadata <string>(NuGetProjectMetadataKeys.Name)); } // Step-5: Raise PackageInstalling event // At this point, GetInstalledPath is pointless since the package is, likely, not already installed. It will be empty // Using PackagePathResolver.GetInstallPath would be wrong, since, package version from the nuspec is always used var packageEventArgs = new PackageEventArgs(FolderNuGetProject, packageIdentity, FolderNuGetProject.GetInstalledPath(packageIdentity)); if (PackageInstalling != null) { PackageInstalling(this, packageEventArgs); } PackageEventsProvider.Instance.NotifyInstalling(packageEventArgs); // Step-6: Install package to FolderNuGetProject await FolderNuGetProject.InstallPackageAsync(packageIdentity, packageStream, nuGetProjectContext, token); // Step-7: Raise PackageInstalled event // Call GetInstalledPath again, to get the package installed path packageEventArgs = new PackageEventArgs(FolderNuGetProject, packageIdentity, FolderNuGetProject.GetInstalledPath(packageIdentity)); if (PackageInstalled != null) { PackageInstalled(this, packageEventArgs); } PackageEventsProvider.Instance.NotifyInstalled(packageEventArgs); // Step-8: MSBuildNuGetProjectSystem operations // Step-8.1: Add references to project if (MSBuildNuGetProjectSystemUtility.IsValid(compatibleReferenceItemsGroup) && !IsSkipAssemblyReferences(nuGetProjectContext)) { foreach (var referenceItem in compatibleReferenceItemsGroup.Items) { if (IsAssemblyReference(referenceItem)) { var referenceItemFullPath = Path.Combine(FolderNuGetProject.GetInstalledPath(packageIdentity), referenceItem); var referenceName = Path.GetFileName(referenceItem); if (MSBuildNuGetProjectSystem.ReferenceExists(referenceName)) { MSBuildNuGetProjectSystem.RemoveReference(referenceName); } MSBuildNuGetProjectSystem.AddReference(referenceItemFullPath); } } } // Step-8.2: Add Frameworkreferences to project if (MSBuildNuGetProjectSystemUtility.IsValid(compatibleFrameworkReferencesGroup)) { foreach (var frameworkReference in compatibleFrameworkReferencesGroup.Items) { var frameworkReferenceName = Path.GetFileName(frameworkReference); if (!MSBuildNuGetProjectSystem.ReferenceExists(frameworkReference)) { MSBuildNuGetProjectSystem.AddFrameworkReference(frameworkReference); } } } // Step-8.3: Add Content Files if (MSBuildNuGetProjectSystemUtility.IsValid(compatibleContentFilesGroup)) { MSBuildNuGetProjectSystemUtility.AddFiles(MSBuildNuGetProjectSystem, zipArchive, compatibleContentFilesGroup, FileTransformers); } // Step-8.4: Add Build imports if (MSBuildNuGetProjectSystemUtility.IsValid(compatibleBuildFilesGroup)) { foreach (var buildImportFile in compatibleBuildFilesGroup.Items) { string fullImportFilePath = Path.Combine(FolderNuGetProject.GetInstalledPath(packageIdentity), buildImportFile); MSBuildNuGetProjectSystem.AddImport(fullImportFilePath, fullImportFilePath.EndsWith(".props", StringComparison.OrdinalIgnoreCase) ? ImportLocation.Top : ImportLocation.Bottom); } } // Step-9: Install package to PackagesConfigNuGetProject await PackagesConfigNuGetProject.InstallPackageAsync(packageIdentity, packageStream, nuGetProjectContext, token); // Step-10: Add packages.config to MSBuildNuGetProject MSBuildNuGetProjectSystem.AddExistingFile(Path.GetFileName(PackagesConfigNuGetProject.FullPath)); // Step 11: Raise PackageReferenceAdded event if (PackageReferenceAdded != null) { PackageReferenceAdded(this, packageEventArgs); } PackageEventsProvider.Instance.NotifyReferenceAdded(packageEventArgs); // Step-12: Execute powershell script - install.ps1 string packageInstallPath = FolderNuGetProject.GetInstalledPath(packageIdentity); FrameworkSpecificGroup anyFrameworkToolsGroup = toolItemGroups.Where(g => g.TargetFramework.Equals(NuGetFramework.AnyFramework)).FirstOrDefault(); if (anyFrameworkToolsGroup != null) { string initPS1RelativePath = anyFrameworkToolsGroup.Items.Where(p => p.StartsWith(PowerShellScripts.InitPS1RelativePath)).FirstOrDefault(); if (!String.IsNullOrEmpty(initPS1RelativePath)) { initPS1RelativePath = PathUtility.ReplaceAltDirSeparatorWithDirSeparator(initPS1RelativePath); await MSBuildNuGetProjectSystem.ExecuteScriptAsync(packageInstallPath, initPS1RelativePath, zipArchive, this); } } if (MSBuildNuGetProjectSystemUtility.IsValid(compatibleToolItemsGroup)) { string installPS1RelativePath = compatibleToolItemsGroup.Items.Where(p => p.EndsWith(Path.DirectorySeparatorChar + PowerShellScripts.Install)).FirstOrDefault(); if (!String.IsNullOrEmpty(installPS1RelativePath)) { await MSBuildNuGetProjectSystem.ExecuteScriptAsync(packageInstallPath, installPS1RelativePath, zipArchive, this); } } return(true); }