// We have to access all members that we want to mock in advance, because Embed Interop Types is set to true against NuGet.VisualStudio.
// See also the following issues:
// * [A COM type can't make its mock by same procedure as usual. · Issue #215 · Moq-moq4](https://github.com/Moq/moq4/issues/215)
// * [A COM type can't make its proxy by same procedure as usual. · Issue #117 · castleproject-Core](https://github.com/castleproject/Core/issues/117)
static void Realize(IVsPackageInstallerServices installerServices)
{
installerServices.GetInstalledPackages();
installerServices.GetInstalledPackages(default(Project));
installerServices.IsPackageInstalled(default(Project), default(string));
installerServices.IsPackageInstalledEx(default(Project), default(string), default(string));
}
public void InstallApertureLibrariesInProject(Project project)
{
if (project == null)
{
throw new ArgumentNullException(nameof(project));
}
var installedPackages = packageInstallerService
.GetInstalledPackages(project);
// Check if package is already installed.
foreach (var package in installedPackages)
{
if (package.Title.Equals("ApertureLabs.Selenium", StringComparison.Ordinal))
{
return;
}
}
packageInstaller.InstallPackage(
source: null,
project: project,
packageId: "ApertureLabs.Selenium",
version: default(Version),
ignoreDependencies: false);
}
private void MenuItem_BeforeQueryStatus(object sender, EventArgs e)
{
OleMenuCommand commandInfo = sender as OleMenuCommand;
if (commandInfo != null)
{
DTE dte = (DTE)GetService(typeof(DTE));
var componentModel = (IComponentModel)GetService(typeof(SComponentModel));
IVsPackageInstallerServices installerServices = componentModel.GetService <IVsPackageInstallerServices>();
dte.Windows.Item(EnvDTE.Constants.vsWindowKindSolutionExplorer).Activate();
if (installerServices.GetInstalledPackages().Where(o => o.Id == PackageId).FirstOrDefault() == null)
{
commandInfo.Visible = false;
}
else
{
commandInfo.Visible = true;
commandInfo.Text = "Publish to Cloud Foundry";
}
}
}
public IEnumerable <PackageModel> GetInstalledNugetPackages(Project project)
{
return(_PkgService.GetInstalledPackages(project).Select(x => new PackageModel()
{
Id = x.Id, Version = x.VersionString
}));
}
private NuGetPackageReference[] GetPackageReferences()
{
if (_vsPackageInstallerServices == null)
{
return(new NuGetPackageReference[0]);
}
try
{
return(_vsPackageInstallerServices.GetInstalledPackages(_project)
.Select(pmd => new NuGetPackageReference(pmd.Id, new NuGetVersion(pmd.VersionString), pmd.InstallPath))
.ToArray());
}
catch (Exception e)
{
if (IdeScope.IsSolutionLoaded)
{
Logger.LogVerboseException(MonitoringService, e);
}
else
{
Logger.LogVerbose("Loading package references failed, solution is not loaded fully yet.");
}
return(null);
}
}
private IVsPackageMetadata GetPackageFromAssemblyLocations(IEnumerable <FileSystemPath> assemblyLocations)
{
return((from p in vsPackageInstallerServices.GetInstalledPackages()
from l in assemblyLocations
where l.FullPath.StartsWith(Path.GetFullPath(p.InstallPath), StringComparison.InvariantCultureIgnoreCase)
select p).FirstOrDefault());
}
public static string GetTargetFile()
{
string targetFile = string.Empty;
try
{
var componentModel = (IComponentModel)CloudFoundryVisualStudioPackage.GetGlobalService(typeof(SComponentModel));
if (componentModel == null)
{
return(string.Empty);
}
IVsPackageInstallerServices installerServices = componentModel.GetService <IVsPackageInstallerServices>();
var packageDir = installerServices.GetInstalledPackages().Where(o => o.Id == CloudFoundryVisualStudioPackage.PackageId).FirstOrDefault().InstallPath;
targetFile = System.IO.Path.Combine(packageDir, "cf-msbuild-tasks.targets");
}
catch (Exception ex)
{
Logger.Error("Error retrieving nuget package service", ex);
}
return(targetFile);
}
private void GetInstalledPackagesTest(object sender, EventArgs e)
{
EnvDTE.DTE dte = ServiceLocator.GetInstance <EnvDTE.DTE>();
IVsPackageInstallerServices services = ServiceLocator.GetInstance <IVsPackageInstallerServices>();
var allPackages = services.GetInstalledPackages();
DisplayMessage("Packages in solution", String.Join(", ", allPackages.Select(p => String.Format("[{0} {1}]", p.Id, p.InstallPath))));
foreach (EnvDTE.Project project in dte.Solution.Projects)
{
var projPackages = services.GetInstalledPackages(project);
DisplayMessage("Project Packages", String.Join(", ", allPackages.Select(p => String.Format("[{0} {1}]", p.Id, p.InstallPath))));
}
}
/// <summary>
/// Gets the package metatdata installed for the given project
/// </summary>
/// <param name="proj"></param>
/// <returns></returns>
private static IVsPackageMetadata GetInstalledPackageMetadata(Project proj)
{
IComponentModel componentModel = (IComponentModel)Package.GetGlobalService(typeof(SComponentModel));
IVsPackageInstallerServices installerServices = componentModel.GetService <IVsPackageInstallerServices>();
IEnumerable <IVsPackageMetadata> packages = installerServices.GetInstalledPackages(proj);
return(packages.Where(pkg => pkg.Id == TypeRightPackage.NugetID).FirstOrDefault());
}
private IEnumerable <IVsPackageMetadata> GetInstalledPackages(string packagesConfig)
{
var projectPackages = new HashSet <Tuple <string, string> >(
from package in XDocument.Load(packagesConfig).Root.Elements()
select Tuple.Create(package.Attribute("id").Value, package.Attribute("version").Value));
var allPackages = packageInstaller.GetInstalledPackages().Where(x => projectPackages.Contains(Tuple.Create(x.Id, x.VersionString)));
return(allPackages);
}
public ProjectCache(VisualStudioWorkspace workspace, ProjectId projectId, IVsPackageInstallerServices nuget, IVsPackageInstallerEvents nugetEvents)
{
var project = workspace.CurrentSolution.GetProject(projectId);
_workspace = workspace;
_path = Path.GetDirectoryName(project.FilePath);
registerPackages(nuget.GetInstalledPackages());
nugetEvents.PackageInstalled += nugetEventsPackageInstalled;
}
public void Execute()
{
var installedPackages = _installerServices.GetInstalledPackages();
var pkgsToConsolidate = installedPackages.GroupBy(pkg => pkg.Id, pkg => pkg.VersionString, StringComparer.OrdinalIgnoreCase)
.Where(g => g.Count() > 1)
.Select(p => Tuple.Create(p.Key, p.Max()));
if (pkgsToConsolidate.Any())
{
OnNeedsConsolidating();
}
}
private static void InstallLatestNugetPackage(IProject project, IVsPackageInstallerServices vsPackageInstallerServices, IVsPackageInstaller vsPackageInstaller, string packageName)
{
vsPackageInstaller.InstallPackage("All",
project.As <EnvDTE.Project>(),
packageName,
(Version)null,
false);
// Call the installed packages to get the version that was just installed and cache the version.
var installedPackages = vsPackageInstallerServices.GetInstalledPackages();
NugetPackageVersionManager.UpdateCache(packageName, installedPackages);
}
/// <summary>
/// Get package references of the project.
/// </summary>
/// <param name="project"></param>
/// <param name="vsPackageInstallerServices"></param>
/// <returns></returns>
public static Dictionary <string, string> GetPackageReferences(this Project project, IVsPackageInstallerServices vsPackageInstallerServices)
{
var packages = new Dictionary <string, string>();
var nugetpackages = vsPackageInstallerServices.GetInstalledPackages().ToList();
foreach (var item in nugetpackages)
{
if (vsPackageInstallerServices.IsPackageInstalledEx(project, item.Id, item.VersionString))
{
packages.Add(item.Id, item.VersionString);
}
}
return(packages);
}
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);
}
public IVsPackageMetadata GetNugetMetadata(Project prj, string pkgName)
{
var componentModel = (IComponentModel)serviceProvider.GetService(typeof(SComponentModel));
IVsPackageInstallerServices installerServices = componentModel.GetService <IVsPackageInstallerServices>();
var installedPackages = installerServices.GetInstalledPackages(prj);
foreach (IVsPackageMetadata meta in installedPackages)
{
if (meta.Id == pkgName)
{
return(meta);
}
}
return(null);
}
private static void InstallLatestNugetPackage(IProject project, IVsPackageInstallerServices vsPackageInstallerServices, IVsPackageInstaller vsPackageInstaller, string packageId, int?majorVersion)
{
// lookup latest version for the given major (or null), and install that
var latestVersion = GetLatestVersionForMajor(packageId, majorVersion);
vsPackageInstaller.InstallPackage(
ServiceMatrixOverrides.GetNugetFeedServiceBaseAddress() ?? "All",
project.As <EnvDTE.Project>(),
packageId,
latestVersion,
false);
// Call the installed packages to get the version that was just installed and cache the version.
// Packages are needed in case latestVersion is null,
var installedPackages = vsPackageInstallerServices.GetInstalledPackages();
NugetPackageVersionManager.UpdateCache(packageId, majorVersion, installedPackages);
}
public bool RemovePackage(string packageId)
{
if (!m_packageServices.IsPackageInstalled(m_project, packageId))
{
return(false);
}
var meta = m_packageServices.GetInstalledPackages(m_project).FirstOrDefault(p => p.Id == packageId);
if (string.IsNullOrEmpty(meta?.InstallPath))
{
//
// UinstallPackage() fails, with the following exception when the respective package is still
// referenced by the project, but no longer present in the "packages"-folder.
//
// So in this case a rebuild of the project _and_ a restore of the (existing/old) NuGet
// packages is required.
//
// System.ArgumentException: Empty path name is not legal.
// at System.IO.FileStream.Init(String path, FileMode mode, FileAccess access, Int32 rights, Boolean useRights, FileShare share, Int32 bufferSize, FileOptions options, SECURITY_ATTRIBUTES secAttrs, String msgPath, Boolean bFromProxy, Boolean useLongPath, Boolean checkHost)
// at System.IO.FileStream..ctor(String path, FileMode mode, FileAccess access, FileShare share)
// at NuGet.ProjectManagement.MSBuildNuGetProject.<UninstallPackageAsync>d__36.MoveNext()
// ...
// at NuGet.VisualStudio.VsPackageUninstaller.UninstallPackage(Project project, String packageId, Boolean removeDependencies)
// at NUnitToMSTestPackage.Utilities.PackageHandler.RemovePackage(String packageId) in C:\Sources\Stuff\mine\NUnitToMSTest\NUnitToMSTestPackage\Utilities\PackageHandler.cs:line 87
// at NUnitToMSTestPackage.Commands.TransformProjectFilesCommand.RemoveNUnitPackages(Project selectedProject, StatusbarContext statusbar, Int32& complete, Int32 total) in C:\Sources\Stuff\mine\NUnitToMSTest\NUnitToMSTestPackage\Commands\TransformProjectFilesCommand.cs:line 186
// at NUnitToMSTestPackage.Commands.TransformProjectFilesCommand.<InvokeRefactoring>d__16.MoveNext() in C:\Sources\Stuff\mine\NUnitToMSTest\NUnitToMSTestPackage\Commands\TransformProjectFilesCommand.cs:line 147
//
string str = $"Could not remove package {packageId}, because it's InstallPath is not set. " +
"Possibly the package is no longer present in your \"packages\" folder. Packages can " +
"only be removed, if they are present there. You could revert what has changed, restore " +
"all existing/old packages and retry the conversion. Or you can manually remove the package " +
$"{packageId} from the project {m_project.Name}.";
m_outputWindowPane?.OutputStringThreadSafe("Warning: " + str);
ReportWarning?.Invoke(str);
return(false);
}
m_uninstaller.UninstallPackage(m_project, packageId, true);
return(true);
}
private IDictionary <string, IEnumerable <PackageConfigEntry> > RemoveAndCachePackages(
IEnumerable <Project> projects, ConverterUpdateViewModel model, CancellationToken token)
{
var installedPackages =
new Dictionary <string, IEnumerable <PackageConfigEntry> >(StringComparer.OrdinalIgnoreCase);
var projectList = projects.ToList();
int total = projectList.Count;
foreach (var project in projectList)
{
token.ThrowIfCancellationRequested();
model.Status =
$"{model.Count}/{total} Retrieving and removing old package format for '{project.Name}'";
_logger.WriteLine(model.Status);
var packages = _services.GetInstalledPackages(project)
.Select(p => new PackageConfigEntry(p.Id, p.VersionString))
.ToArray();
var fullname = project.GetFullName();
if (fullname != null)
{
installedPackages.Add(fullname, packages);
_logger.WriteLine($"{project.Name} added {packages.Length} packages");
RemovePackages(project, packages.Select(p => p.Id), token, model);
}
else
{
model.Log = $"{project.Name} not modified, missing fullname";
_logger.WriteLine(model.Log);
}
model.Count++;
}
return(installedPackages);
}
/// <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);
}
}
}
/// <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);
}
}
}
internal static IEnumerable <IVsPackageMetadata> GetInstalledPackages(CodeGenerationContext context)
{
IVsPackageInstallerServices service = context.ServiceProvider.GetService <IComponentModel, SComponentModel>().GetService <IVsPackageInstallerServices>();
return(service.GetInstalledPackages(context.ActiveProject));
}
/// <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);
}
}
public IEnumerable <Lib.PackageInfo> GetNugetPackages(IVsPackageInstallerServices installerServices, Solution envSolution, bool includePackageDependencies)
{
var allprojects = new List <Project>();
if (envSolution != null)
{
foreach (Project project in envSolution.Projects)
{
Debug.WriteLine("PojectName: " + project.Name);
if (EnvDTE.Constants.vsProjectKindSolutionItems == project.Kind)
{
foreach (ProjectItem item in project.ProjectItems)
{
Debug.WriteLine("PojectItemName: " + item.Name);
if (item.Object != null)
{
var childProject = item.Object as Project;
Debug.WriteLine("PojectItemName: " + item.Name + " ProjectItemGuid: " +
childProject.Kind);
if (ProjectSettings.DotnetCoreProjectGuid == childProject.Kind)
{
allprojects.Add(childProject);
}
}
}
}
else
{
Debug.WriteLine("PojectName: " + project.Name + " PojectNameGuid: " + project.Kind);
allprojects.Add(project);
}
}
}
if (!allprojects.Any())
{
Debug.WriteLine("No projects found.");
return(null);
}
var packageList = new List <PackageInfo>();
var installedPackages = installerServices?.GetInstalledPackages().ToList();
if (installedPackages != null && installedPackages.Any())
{
foreach (var installedPackage in installedPackages)
{
var projects = new List <ProjectInfo>();
projects.AddRange(
from Project envProject in allprojects
where !string.IsNullOrEmpty(envProject.FullName) &&
installerServices.IsPackageInstalled(envProject, installedPackage.Id)
select new ProjectInfo
{
Name = envProject.Name,
FrameworkName = envProject.Properties.Item("TargetFrameworkMoniker")?.Value.ToString()
}
);
var version = NuGet.Versioning.NuGetVersion.Parse(installedPackage.VersionString);
if (string.IsNullOrEmpty(installedPackage.InstallPath))
{
Debug.WriteLine("Package: " + installedPackage.Id + " has no install path.");
}
else
{
var type = LocalFolderUtility.GetLocalFeedType(installedPackage.InstallPath, _logger);
var package = BuildPackageInfo(type, installedPackage.InstallPath, installedPackage.Id, version, projects);
if (package != null)
{
packageList.Add(package);
if (includePackageDependencies)
{
var dependenciesPackageList = new List <PackageInfo>();
var frameworks = projects.Select(p => p.FrameworkName).ToList();
foreach (var dependencyGroup in package.LocalPackageInfo.Nuspec.GetDependencyGroups())
{
if (frameworks.Contains(dependencyGroup.TargetFramework.DotNetFrameworkName))
{
foreach (var packageDependency in dependencyGroup.Packages)
{
var depVersion = NuGet.Versioning.NuGetVersion.Parse(packageDependency.VersionRange.OriginalString);
var basePath = Path.GetFullPath(Path.Combine(installedPackage.InstallPath, @"..\..\"));
var newPath = Path.Combine(basePath, packageDependency.Id, depVersion.ToString());
var dependencyPackage = BuildPackageInfo(type, newPath, packageDependency.Id, depVersion, projects);
if (dependencyPackage != null)
{
dependenciesPackageList.Add(dependencyPackage);
}
else
{
Debug.WriteLine($"Could not locate dependency package {packageDependency.Id} version {depVersion}...");
_logger.Log(LogLevel.Warning, $"Could not locate dependency package {packageDependency.Id} version {depVersion}...");
}
}
}
}
if (dependenciesPackageList.Any())
{
packageList.AddRange(dependenciesPackageList);
}
}
}
else
{
Debug.WriteLine($"Could not locate package {installedPackage.Id} version {version}...");
_logger.Log(LogLevel.Warning, $"Could not locate package {installedPackage.Id} version {version}...");
}
}
}
}
return(packageList);
}
private IEnumerable <DependencyDescription> GetPackageDependencies(string targetFramework)
{
return(vsPackageInstaller.GetInstalledPackages(project)
.Select(p => new DependencyDescription(p.Id, p.VersionString, p.InstallPath, targetFramework, DependencyType.Package, true))
.ToList());
}
private static void InstallLatestNugetPackage(IProject project, IVsPackageInstallerServices vsPackageInstallerServices, IVsPackageInstaller vsPackageInstaller, string packageId, int? majorVersion)
{
// lookup latest version for the given major (or null), and install that
var latestVersion = GetLatestVersionForMajor(packageId, majorVersion);
vsPackageInstaller.InstallPackage(
ServiceMatrixOverrides.GetNugetFeedServiceBaseAddress() ?? "All",
project.As<EnvDTE.Project>(),
packageId,
latestVersion,
false);
// Call the installed packages to get the version that was just installed and cache the version.
// Packages are needed in case latestVersion is null,
var installedPackages = vsPackageInstallerServices.GetInstalledPackages();
NugetPackageVersionManager.UpdateCache(packageId, majorVersion, installedPackages);
}
/// <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 async Task OnOpened()
{
Debug.WriteLine(string.Format(CultureInfo.CurrentCulture, "OnOpened: {0}", this.ToString()));
do
{
try
{
var componentModel = (IComponentModel) await GetServiceAsync(typeof(SComponentModel));
IVsPackageInstallerServices installerServices = componentModel.GetService <IVsPackageInstallerServices>();
var installedPackages = installerServices.GetInstalledPackages();
var remoteControlPackages = new[] {
"Uno.UI.RemoteControl",
"Uno.WinUI.RemoteControl",
};
var unoNuGetPackage = installedPackages
.Where(p => remoteControlPackages.Any(rcp => p.Id.Equals(rcp, StringComparison.OrdinalIgnoreCase)))
.OrderByDescending(p => p.VersionString)
.LastOrDefault();
if (unoNuGetPackage != null)
{
if (string.IsNullOrWhiteSpace(unoNuGetPackage.InstallPath.Trim()))
{
_infoAction("The Uno.WinUI.RemoteControl or Uno.UI.RemoteControl package has not been restored yet, retrying...");
}
else
{
var toolsPath = System.IO.Path.Combine(unoNuGetPackage.InstallPath, "tools", "rc");
var asmPath = System.IO.Path.Combine(toolsPath, "Uno.UI.RemoteControl.VS.dll");
var asm = System.Reflection.Assembly.LoadFrom(asmPath);
var entryPointType = asm.GetType("Uno.UI.RemoteControl.VS.EntryPoint");
if (entryPointType.GetConstructor(
new[] {
typeof(DTE2),
typeof(string),
typeof(AsyncPackage),
typeof(Action <Func <Task <Dictionary <string, string> > > >)
}) != null)
{
_remoteControl = Activator.CreateInstance(
entryPointType,
_dte,
toolsPath,
this,
(Action <Func <Task <Dictionary <string, string> > > >)SetGlobalVariablesProvider) as IDisposable;
_infoAction($"Loaded the {unoNuGetPackage.Id} Remote Control service ({unoNuGetPackage.VersionString}).");
}
else
{
_infoAction("The loaded solution contains an Uno.UI Remote Control service.");
}
}
}
if (_dte.Solution.IsOpen)
{
return;
}
}
catch (Exception e)
{
_errorAction(e);
}
await System.Threading.Tasks.Task.Delay(5000);
}while (true);
}
public static string GetPackageLocation(this IVsPackageInstallerServices packageInstallerServices, string packageName)
{
return(packageInstallerServices.GetInstalledPackages().Where(p => p.Id == packageName).OrderByDescending(p => p.VersionString).First().InstallPath);
}
private async Task OnOpenedAsync(CancellationToken ct)
{
Debug.WriteLine(string.Format(CultureInfo.CurrentCulture, "OnOpened: {0}", this.ToString()));
_currentCts?.Cancel();
_currentCts = CancellationTokenSource.CreateLinkedTokenSource(ct);
var sw = Stopwatch.StartNew();
do
{
try
{
var componentModel = (IComponentModel) await GetServiceAsync(typeof(SComponentModel));
IVsPackageInstallerServices installerServices = componentModel.GetService <IVsPackageInstallerServices>();
var installedPackages = installerServices.GetInstalledPackages();
var remoteControlPackages = new[] {
"Uno.UI.RemoteControl",
"Uno.WinUI.RemoteControl",
};
var unoNuGetPackage = installedPackages
.Where(p => remoteControlPackages.Any(rcp => p.Id.Equals(rcp, StringComparison.OrdinalIgnoreCase)))
.OrderByDescending(p => p.VersionString)
.LastOrDefault();
if (unoNuGetPackage != null)
{
if (string.IsNullOrWhiteSpace(unoNuGetPackage.InstallPath.Trim()))
{
_infoAction("The Uno.WinUI.RemoteControl or Uno.UI.RemoteControl package has not been restored yet, retrying...");
}
else
{
var toolsPath = System.IO.Path.Combine(unoNuGetPackage.InstallPath, "tools", "rc");
var asmPath = System.IO.Path.Combine(toolsPath, "Uno.UI.RemoteControl.VS.dll");
var asm = System.Reflection.Assembly.LoadFrom(asmPath);
var entryPointType = asm.GetType("Uno.UI.RemoteControl.VS.EntryPoint");
if (entryPointType.GetConstructor(
new[] {
typeof(DTE2),
typeof(string),
typeof(AsyncPackage),
typeof(Action <Func <Task <Dictionary <string, string> > > >)
}) != null)
{
_remoteControl = Activator.CreateInstance(
entryPointType,
_dte,
toolsPath,
this,
(Action <Func <Task <Dictionary <string, string> > > >)SetGlobalVariablesProvider) as IDisposable;
_infoAction($"Loaded the {unoNuGetPackage.Id} Remote Control service ({unoNuGetPackage.VersionString}).");
}
else
{
_infoAction("The loaded solution contains an Uno.UI Remote Control service.");
}
}
}
if (_dte.Solution.IsOpen)
{
return;
}
if (sw.Elapsed > TimeSpan.FromMinutes(5))
{
// If we spent more than 5 minutes trying to enumerate loaded packages and could not
// bail out. In some cases, the Nuget package manager may never return the full list
// of packages if there's a faulty project in the solution.
_errorAction(new InvalidOperationException(
"Failed to retreive the solution's loaded nuget packages. " +
"Make sure a full nuget restore has completed properly and reload the solution."));
}
}
catch (Exception e)
{
_errorAction(e);
}
await System.Threading.Tasks.Task.Delay(5000, _currentCts.Token);
}while (!_currentCts.IsCancellationRequested);
}
private static void InstallLatestNugetPackage(IProject project,IVsPackageInstallerServices vsPackageInstallerServices, IVsPackageInstaller vsPackageInstaller, string packageName)
{
vsPackageInstaller.InstallPackage("All",
project.As<EnvDTE.Project>(),
packageName,
(Version)null,
false);
// Call the installed packages to get the version that was just installed and cache the version.
var installedPackages = vsPackageInstallerServices.GetInstalledPackages();
NugetPackageVersionManager.UpdateCache(packageName, installedPackages);
}
public IEnumerable <PackageMetadata> GetInstalledPackages(EnvDTE.Project project)
{
return(_packageInstallerServices.GetInstalledPackages(project)
.Select(m => new PackageMetadata(m.Id, m.VersionString))
.ToList());
}
// We have to access all members that we want to mock in advance, because Embed Interop Types is set to true against NuGet.VisualStudio.
// See also the following issues:
// * [A COM type can't make its mock by same procedure as usual. · Issue #215 · Moq-moq4](https://github.com/Moq/moq4/issues/215)
// * [A COM type can't make its proxy by same procedure as usual. · Issue #117 · castleproject-Core](https://github.com/castleproject/Core/issues/117)
static void Realize(IVsPackageInstallerServices installerServices)
{
installerServices.GetInstalledPackages();
installerServices.GetInstalledPackages(default(Project));
installerServices.IsPackageInstalled(default(Project), default(string));
installerServices.IsPackageInstalledEx(default(Project), default(string), default(string));
}
private async Task <bool> GetPackagesAndRiskInformation(IEnumerable <Project> projects)
{
var status = false;
await Task.Run(() =>
{
var hubSettings = new HubSettings()
{
ServerUrl = _package.HubServerUrl,
Username = _package.HubUsername,
Password = _package.HubPassword,
Timeout = _package.HubTimeout,
ProxyHost = _package.ProxyHost,
ProxyPort = _package.ProxyPort,
ProxyUsername = _package.ProxyUsername,
ProxyPassword = _package.ProxyPassword
};
if (!_installerServices.GetInstalledPackages().Any())
{
return;
}
if (!hubSettings.HasSettings())
{
_riskAnalysisStatus = Properties.Resources.MesageNoHubSettings;
status = false;
}
else
{
var client = Authenticate.EstablishHubSession(hubSettings);
if (client == null)
{
_riskAnalysisStatus = Properties.Resources.MessageConnectionUnsuccessful;
status = false;
}
else
{
String version = HubVersion.GetHubVersionNumberString(client);
bool hubLessThanFour = int.Parse(version.Split('.')[0]) < 4;
_packagesList.Clear();
_validProjectsList.Clear();
_validProjectsList.Add(Properties.Resources.ItemAll);
foreach (var project in projects)
{
List <IVsPackageMetadata> packages = null;
try
{
packages = _installerServices.GetInstalledPackages(project).ToList();
_validProjectsList.Add(project.Name);
}
catch { continue; }
var projectPath = project.Properties;
foreach (var package in packages)
{
var index =
_packagesList.FindIndex(
item => (item.Package == package.Id) && (item.Version == package.VersionString));
if (index < 0)
{
_packagesList.Add(new NuGetPackageViewModel.NuGetPackage
{
Forge = Properties.Resources.Forge,
Package = package.Id,
Version = package.VersionString,
VsProject = project.Name
});
}
else
{
_packagesList[index].VsProject = _packagesList[index].VsProject + "|" + project.Name;
}
}
}
foreach (var item in _packagesList)
{
try
{
ProcessItem(item, client, hubLessThanFour);
} catch (Exception e)
{
_riskAnalysisStatus = e.Message;
status = false;
}
}
if (_packagesList.Count > 0)
{
_packagesList = _packagesList.OrderBy(x => x.PackageStatus).ThenBy(y => y.Package).ToList();
}
_validProjectsList.Sort();
status = true;
Task.Run(() => CollectData.CallHome(client, hubSettings.ServerUrl, _dte.Version));
}
}
});
return(status);
}