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