private void NugetEvents_PackageInstalled(IVsPackageMetadata metadata) { //有可能出现这种情况:解决方案已经加载完成了,还没加载此包, //导致在解决方案加载完整事件时,不能更新所有项目的引用包 //所以在这里更新包一次 PackageHelper.UpdateAllPackagesOfAllProjects(); }
// The parameter 'latestKnownAssemblyVersion' can be null and if yes will be // infered from 'assemblyReferenceName' parameter. // I added that as a parameter to make unit testing easier. internal static void GetPackageFileNameForPackage(CodeGenerationContext context, IEnumerable <IVsPackageMetadata> installedPackages, string packageId, string assemblyReferenceName, Version minSupportedAssemblyReferenceVersion, ref string packageFileName) { if (ProjectReferences.IsAssemblyReferenced(context.ActiveProject, assemblyReferenceName)) { // If the project has reference to MVC version 5.0 or // above the corresponding package versions file is loaded from the file system. IVsPackageMetadata installedPackage = installedPackages .Where(package => String.Equals(packageId, package.Id, StringComparison.OrdinalIgnoreCase)) .FirstOrDefault(); Version versionForPackageFile; // First try to get the package version and if not fallback to assembly reference version. if (installedPackage == null || !SemanticVersionParser.TryParse(installedPackage.VersionString, out versionForPackageFile)) { // Note: In this scenario where user does not have a package // reference but only has assembly reference, we will end up // using 5.1.0 instead of 5.1.1 version of package file (even // if the assembly reference is the same as the one shipped in 5.1.1) // because the assembly version did not change for 5.1.1 versionForPackageFile = ProjectReferences.GetAssemblyVersion(context.ActiveProject, assemblyReferenceName); } // Version should have been either available from package or atleast the assembly reference. Contract.Assert(versionForPackageFile != null); // For example : If 5.1 is the latest tooling version and if we release just the NuGet packages for a higher version of runtime (may be 5.2), // we will still continue to scaffold the latest tooling version (in this case 5.1). if (versionForPackageFile >= minSupportedAssemblyReferenceVersion && versionForPackageFile <= _latestKnownPackageVersion) { packageFileName = GetPackageVersionsFileName(versionForPackageFile); } } }
private void PackageInstallerEvents_PackageInstalled(IVsPackageMetadata metadata) { if (BatchEnd != null) { BatchEnd(); } }
protected internal virtual void OnPackageInstalled(IVsPackageMetadata metadata) { var handler = PackageInstalled; if (handler == null) return; handler(metadata); }
private bool AuditPackageInternal(IVsPackageMetadata package) { var packageId = new PackageId(package.Id, package.VersionString); WriteLine(Resources.AuditingPackage, packageId); return(AuditPackagesInternal(new[] { packageId })); }
private void nugetEvents_PackageReferenceAdded(IVsPackageMetadata metadata) { //Debug Debug.WriteLine(string.Format("Umbraco New Project - PackageReferencedAdded() event {0} {1}", metadata.Title, metadata.VersionString)); //Update IDE status bar bottom left _dte.StatusBar.Text = string.Format("Umbraco New Project - Adding Nuget Package Reference {0} {1}", metadata.Title, metadata.VersionString); }
public string GetNugetVersion(Project prj, string pkgName) { IVsPackageMetadata m_data = this.GetNugetMetadata(prj, pkgName); if (m_data != null) { return(m_data.VersionString); } return(string.Empty); }
private void PackageInstallerEvents_PackageInstalled(IVsPackageMetadata metadata) { ThreadHelper.JoinableTaskFactory.Run(async() => { await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync(); if (BatchEnd != null) { BatchEnd(); } }); }
protected internal virtual void OnPackageReferenceAdded(IVsPackageMetadata metadata) { var handler = PackageReferenceAdded; if (handler == null) { return; } handler(metadata); }
protected internal virtual void OnPackageInstalling(IVsPackageMetadata metadata) { var handler = PackageInstalling; if (handler == null) { return; } handler(metadata); }
private void BindPackage(IVsPackageMetadata package) { try { if (Binder.Execute(package.InstallPath)) PrintToOutputWindow(string.Format("{0}{1} locaolized Complete.\r\n", package.Id, package.VersionString)); } catch (Exception ex) { PrintToOutputWindow(string.Format("{0}{1} locaolized fail: {2}\r\n", package.Id, package.VersionString, ex.Message)); } }
private void InstallerEvents_PackageInstalled(IVsPackageMetadata metadata) { _backgroundQueue.QueueTask(async() => { var asyncTask = TTasks.Task.Factory.StartNew(() => { return(AuditPackageInternal(metadata)); }, CancellationToken.None, TTasks.TaskCreationOptions.None, _uiTaskScheduler); while (!await asyncTask) { TTasks.Task.Delay(TimeSpan.FromSeconds(5)).Wait(); } }); }
private void OnPackageInstalled(IVsPackageMetadata metadata) { // Fire and forget. When new package is installed, we are not just adding this package to the index, // but instead we attempt full sync. Full sync in this case would only sync new packages that don't // exist in the index which should be fast. The reason for full sync is that when there are several // instances of VS and each tries to update index at the same tiime, only one would succeed, other // would notive that index is locked and skip this operation. Thus if all VS instances attempt full // sync at least one of them would do it and add all new packages to the index. var indexFactory = new PackageIndexFactory(); var builder = indexFactory.GetLocalIndexBuilder(); builder.BuildAsync(newOnly: true); }
public void GetInstalledPackages_OneInstalledPackages_ReturnsOnePackage() { CreatePackageInstallerServices(); string installPath = @"d:\projects\MyProject\packages\TestPackage"; IPackage installedPackage = AddPackage("Id", "1.1", installPath); List <IVsPackageMetadata> packages = installerServices.GetInstalledPackages().ToList(); IVsPackageMetadata package = packages[0]; Assert.AreEqual(1, packages.Count); Assert.AreEqual("Id", package.Id); Assert.AreEqual("1.1", package.Version.ToString()); Assert.AreEqual(@"d:\projects\MyProject\packages\TestPackage", package.InstallPath); }
private bool IsSlowCheetahUpdated(Project project) { // Checks for older SC versions that require more complex update procedure. IVsPackageInstallerServices installerServices = GetInstallerServices(this.package); IVsPackageMetadata scPackage = installerServices.GetInstalledPackages().FirstOrDefault(pkg => string.Equals(pkg.Id, PackageName, StringComparison.OrdinalIgnoreCase)); if (scPackage != null) { if (Version.TryParse(scPackage.VersionString, out Version ver)) { return(ver > LastUnsupportedVersion); } } return(false); }
private void OnPackageReferenceAdded(IVsPackageMetadata metadata) { if (IsCurrentSolutionEnabledForRestore) { var packageMetadata = (VsPackageMetadata)metadata; var fileSystem = packageMetadata.FileSystem as IVsProjectSystem; if (fileSystem != null) { var project = _solutionManager.GetProject(fileSystem.UniqueName); if (project != null) { // in this case, we know that this project has at least one nuget package, // so enable package restore straight away EnablePackageRestore(project); } } } }
/// <summary> /// Gets the generator for the given project /// </summary> /// <param name="proj">The project</param> /// <returns>the associated import generator</returns> public static ImportedGenerator GetForProj(Project proj) { #if DEBUG return(s_imports.GetOrAdd("Debug", (dontcare) => { return new ImportedGenerator(CacheBasePath, "Debug", ""); })); #else IVsPackageMetadata pkg = GetInstalledPackageMetadata(proj); if (pkg == null) { return(null); } return(s_imports.GetOrAdd(pkg.VersionString, (dontcare) => { return new ImportedGenerator(CacheBasePath, pkg.VersionString, pkg.InstallPath); })); #endif }
internal static void GetPackageFileNameForPackage(CodeGenerationContext context, IEnumerable <IVsPackageMetadata> installedPackages, string packageId, string assemblyReferenceName, Version minSupportedAssemblyReferenceVersion, ref string packageFileName) { Version assemblyVersion; if (ProjectReferences.IsAssemblyReferenced(context.ActiveProject, assemblyReferenceName)) { IVsPackageMetadata variable = ( from package in installedPackages where string.Equals(packageId, package.Id, StringComparison.OrdinalIgnoreCase) select package).FirstOrDefault <IVsPackageMetadata>(); if (variable == null || !SemanticVersionParser.TryParse(variable.VersionString, out assemblyVersion)) { assemblyVersion = ProjectReferences.GetAssemblyVersion(context.ActiveProject, assemblyReferenceName); } if (assemblyVersion >= minSupportedAssemblyReferenceVersion && assemblyVersion <= PackageVersions._latestKnownPackageVersion) { packageFileName = PackageVersions.GetPackageVersionsFileName(assemblyVersion); } } }
private static Version GetNuGetPackageVersion(IVsPackageMetadata package) { Version version; string versionString = package.VersionString; int dashIndex = versionString.IndexOf('-'); if (dashIndex != -1) { // Trim off any pre-release versions. Because the handler should never install pre-release // versions they can be ignored when comparing versions. versionString = versionString.Substring(0, dashIndex); } if (!Version.TryParse(versionString, out version)) { Debug.Fail("Unable to parse the NuGet package version " + versionString); } return(version); }
private void addExtension(IVsPackageMetadata package) { //td: determine if the package is installed in this project var toolPath = Path.Combine(package.InstallPath, "tools"); if (!Directory.Exists(toolPath)) { return; //td: ask to restore packages } var dlls = Directory.EnumerateFiles(toolPath) .Where(file => Path.GetExtension(file) == ".dll"); foreach (var dll in dlls) { var fileName = Path.GetFileName(dll); if (!fileName.StartsWith("Excess.")) { continue; //convention over configuration? } var assembly = Assembly.LoadFrom(dll); if (assembly == null) { continue; } //var extension = loadReference(dll, name); var name = string.Empty; var extension = Loader <RoslynCompiler> .CreateFrom(assembly, out name); if (extension != null) { _extensions[name] = extension; } } }
/// <summary> /// Uninstall the packages that exist in the project. /// </summary> public static async Task UninstallPackagesAsync( Project targetProject, ISet <string> packages, Func <string, Task> uninstallPackage, ConnectedServiceLogger logger, IVsPackageInstallerServices packageInstallerServices) { IEnumerable <IVsPackageMetadata> installedPackages = packageInstallerServices.GetInstalledPackages(targetProject); foreach (string packageId in packages) { IVsPackageMetadata installedPackage = installedPackages.FirstOrDefault(p => p.Id == packageId); if (installedPackage != null) { await logger.WriteMessageAsync( LoggerMessageCategory.Information, Resource.LogMessage_RemovingNuGetPackage, packageId, installedPackage.VersionString); await uninstallPackage(packageId); } } }
private async Task AddNuGetPackagesAsync(ConnectedServiceHandlerContext context, Project project) { IEnumerable <IVsPackageMetadata> installedPackages = this.PackageInstallerServices.GetInstalledPackages(project); Dictionary <string, string> packagesToInstall = new Dictionary <string, string>(); foreach (Tuple <string, Version> requiredPackage in SalesforceConnectedServiceHandler.requiredPackages) { IVsPackageMetadata installedPackage = installedPackages.FirstOrDefault(p => p.Id == requiredPackage.Item1); if (installedPackage == null) { // The package does not exist - notify and install the package. await context.Logger.WriteMessageAsync( LoggerMessageCategory.Information, Resources.LogMessage_AddingNuGetPackage, requiredPackage.Item1, requiredPackage.Item2.ToString()); } else { Version installedVersion = SalesforceConnectedServiceHandler.GetNuGetPackageVersion(installedPackage); if (installedVersion == null) { // Unable to parse the version - continue. continue; } else if (installedVersion.Major < requiredPackage.Item2.Major) { // An older potentially non-compatible version of the package already exists - warn and upgrade the package. await context.Logger.WriteMessageAsync( LoggerMessageCategory.Warning, Resources.LogMessage_OlderMajorVersionNuGetPackageExists, requiredPackage.Item1, installedPackage.VersionString, requiredPackage.Item2.ToString()); } else if (installedVersion.Major > requiredPackage.Item2.Major) { // A newer potentially non-compatible version of the package already exists - warn and continue. await context.Logger.WriteMessageAsync( LoggerMessageCategory.Warning, Resources.LogMessage_NewerMajorVersionNuGetPackageExists, requiredPackage.Item1, requiredPackage.Item2.ToString(), installedPackage.VersionString); continue; } else if (installedVersion >= requiredPackage.Item2) { // A newer semantically compatible version of the package already exists - continue. continue; } else { // An older semantically compatible version of the package exists - notify and upgrade the package. await context.Logger.WriteMessageAsync( LoggerMessageCategory.Information, Resources.LogMessage_UpgradingNuGetPackage, requiredPackage.Item1, installedPackage.VersionString, requiredPackage.Item2.ToString()); } } packagesToInstall.Add(requiredPackage.Item1, requiredPackage.Item2.ToString()); } if (packagesToInstall.Any()) { this.PackageInstaller.InstallPackagesFromVSExtensionRepository( "Salesforce.VisualStudio.Services.B161EEC7-17E0-4C35-AF8D-F241325BDD1C", false, false, project, packagesToInstall); } }
public NugetPackageToolImporter(Project proj, string cacheBasePath) : base(cacheBasePath) { _pkg = GetInstalledPackageMetadata(proj); }
private void OnEventsOnPackageInstalling(IVsPackageMetadata m) { m_outputWindowPane.OutputStringThreadSafe($"Installing package {m.Id}, version {m.VersionString}."); }
private GraphNode GetOrCreatePackageNode(IGraphContext context, GraphNode parent, IVsPackageMetadata package) { var parentId = parent.GetValue <GraphNodeId>("Id"); var nodeId = GraphNodeId.GetNested( parentId, GraphNodeId.GetPartial(CodeGraphNodeIdName.Member, package.Id), GraphNodeId.GetPartial(CodeGraphNodeIdName.Parameter, package.VersionString)); var node = context.Graph.Nodes.Get(nodeId); if (node == null) { using (var scope = new GraphTransactionScope()) { node = context.Graph.Nodes.GetOrCreate(nodeId, package.Id, ReferencesGraphSchema.PackageCategory); node.SetValue <string>(DgmlNodeProperties.Icon, GraphIcons.Package); node.SetValue <IVsPackageMetadata>(ReferencesGraphSchema.PackageProperty, package); // Establish the relationship with the parent node. context.Graph.Links.GetOrCreate(parent, node, null, GraphCommonSchema.Contains); context.OutputNodes.Add(node); scope.Complete(); } } return(node); }
void packageEvents_PackageReferenceAdded(IVsPackageMetadata metadata) { BindPackage(metadata); }
private void ResetAnalyzersCache(IVsPackageMetadata metadata) { this.groupingEvent.FireIncoming(); }
internal void ReportPackageReferenceAddedProgress(uint prog, IVsPackageMetadata metadata) { var msg = string.Format(PrigResources.GetString("ReferenceAdded_0_MessageFormat"), metadata.Id); Statusbar.ReportProgress(msg, prog); }
internal void ReportPackageInstallingProgress(uint prog, IVsPackageMetadata metadata) { var msg = string.Format(PrigResources.GetString("Installing_0_MessageFormat"), metadata.Id); Statusbar.ReportProgress(msg, prog); }
private void RecalcInstalledPackages(IVsPackageMetadata metadata) { if (!IsNuGetAvailable || solution.IsTemporary) { lock (syncObject) { installedPackages = emptyLookup; } return; } try { lock (syncObject) { installedPackages = ToLookup(vsPackageInstallerServices.GetInstalledPackages()); } } catch (Exception ex) { installedPackages = emptyLookup; Logger.LogException("RecalcInstalledPackages", ex); } }
/// <summary> /// Ensures the appropriate version of the specified packages are installed. If an existing version of the package /// already exists the following will happen: /// If a semantically compatible version already exists, no change is made to the package. /// If an older major version exists, a warning is logged and the package is upgraded. /// If an older minor/build version exists, an information message is logged and the package is upgraded. /// If a newer major version exists, a warning is logged and no change is made to the package. /// </summary> public static async Task InstallPackagesAsync( Project targetProject, Dictionary <string, string> packages, Func <string, string, Task> installPackage, ConnectedServiceLogger logger, IVsPackageInstallerServices packageInstallerServices) { IEnumerable <IVsPackageMetadata> installedPackages; try { installedPackages = packageInstallerServices.GetInstalledPackages(targetProject); } catch (ArgumentException) { // This happens for C++ projects installedPackages = new List <IVsPackageMetadata>(); } foreach (KeyValuePair <string, string> requiredPackage in packages) { IVsPackageMetadata installedPackage = installedPackages.FirstOrDefault(p => p.Id == requiredPackage.Key); if (installedPackage == null) { // The package does not exist - notify and install the package. await logger.WriteMessageAsync( LoggerMessageCategory.Information, Resource.LogMessage_AddingNuGetPackage, requiredPackage.Key, requiredPackage.Value); } else { Version installedVersion = NuGetUtilities.GetVersion(installedPackage.VersionString); Version requiredVersion = NuGetUtilities.GetVersion(requiredPackage.Value); if (installedVersion == null || requiredVersion == null) { // Unable to parse the version - continue. continue; } else if (installedVersion.Major < requiredVersion.Major) { // An older potentially non-compatible version of the package already exists - warn and upgrade the package. await logger.WriteMessageAsync( LoggerMessageCategory.Warning, Resource.LogMessage_OlderMajorVersionNuGetPackageExists, requiredPackage.Key, installedPackage.VersionString, requiredPackage.Value); } else if (installedVersion.Major > requiredVersion.Major) { // A newer potentially non-compatible version of the package already exists - warn and continue. await logger.WriteMessageAsync( LoggerMessageCategory.Warning, Resource.LogMessage_NewerMajorVersionNuGetPackageExists, requiredPackage.Key, requiredPackage.Value, installedPackage.VersionString); continue; } else if (installedVersion >= requiredVersion) { // A semantically compatible version of the package already exists - continue. continue; } else { // An older semantically compatible version of the package exists - notify and upgrade the package. await logger.WriteMessageAsync( LoggerMessageCategory.Information, Resource.LogMessage_UpgradingNuGetPackage, requiredPackage.Key, installedPackage.VersionString, requiredPackage.Value); } } await installPackage(requiredPackage.Key, requiredPackage.Value); } }
private bool AuditPackageInternal(IVsPackageMetadata package) { var packageId = new PackageId(package.Id, package.VersionString); WriteLine(Resources.AuditingPackage, packageId); return AuditPackagesInternal(new[] { packageId }); }
private void InstallerEvents_PackageReferenceAdded(IVsPackageMetadata metadata) { _backgroundQueue.QueueTask(async () => { var asyncTask = TTasks.Task.Factory.StartNew(() => { return AuditPackageInternal(metadata); }, CancellationToken.None, TTasks.TaskCreationOptions.None, _uiTaskScheduler); while (!await asyncTask) { TTasks.Task.Delay(TimeSpan.FromSeconds(5)).Wait(); } }); }
private void InstallerEvents_PackageReferenceRemoved(IVsPackageMetadata metadata) { _backgroundQueue.QueueTask(() => { RefreshTasks(); }, _uiTaskScheduler); }
public static void FixPackagePathsAndSaveProject(EnvDTE.Project project, IVsPackageMetadata package, string solutionDir) { FixPackagePathsAndSaveProject(project, new[] { package }, solutionDir); }
private void InstallerEvents_PackageReferenceRemoved(IVsPackageMetadata metadata) { _refreshTimer.Change(_refreshTimeout, Timeout.Infinite); }
public static void RevertPackagePaths(EnvDTE.Project project, IVsPackageMetadata package, string solutionDir) { RevertPackagePaths(project, new[] { package }, solutionDir); }
private static Version GetNuGetPackageVersion(IVsPackageMetadata package) { Version version; string versionString = package.VersionString; int dashIndex = versionString.IndexOf('-'); if (dashIndex != -1) { // Trim off any pre-release versions. Because the handler should never install pre-release // versions they can be ignored when comparing versions. versionString = versionString.Substring(0, dashIndex); } if (!Version.TryParse(versionString, out version)) { Debug.Fail("Unable to parse the NuGet package version " + versionString); } return version; }