public void SetPreviewedPackage(NugetPackage package)
{
m_nugetPackage = package;
var model = ScriptableObject.CreateInstance <PackageViewModel>();
model.Package = package;
SerializedObject serializedObject = new SerializedObject(model);
LogPropertyPaths(serializedObject);
this.Bind(serializedObject);
this.Query <Label>("package-view--title").First().text = package.Title;
this.Query <Label>("package-view--author-text").First().text = package.Authors;
this.Query <Label>("package-view--description-text").First().text = package.Description;
this.Query <Label>("package-view--license-text").First().text = package.LicenseUrl;
this.Query <VisualElement>("package-view--image").First().style.backgroundImage = package.Icon;
bool isInstalled = NugetHelper.IsInstalled(package);
this.Query <Button>("package-view--primary-action").First().text =
isInstalled
? "Remove Package from Project"
: "Add Package to Project";
}
private static void AddReferencesToNugetPackages(string solutionFolder)
{
var packageFolders = Directory.GetDirectories(solutionFolder + "/packages/");
var packages = new List <NugetPackage>();
foreach (var packageFolder in packageFolders)
{
var pattern = new Regex(@"(.+)\.(\d+\.\d+\.\d+.*)");
var captureGroups =
pattern.Matches(packageFolder).GetEnumerator().Current as Match; // There can only be one
var name = captureGroups.Groups[1].Value;
var version = captureGroups.Groups[2].Value;
var libFolder = packageFolder + "/lib/net45/";
var dllNames = Directory.GetFiles(libFolder).Where(f => f.EndsWith(".dll")).Select(Path.GetFileNameWithoutExtension);
var package = new NugetPackage()
{
Name = name,
Version = version,
DllNames = dllNames.ToList()
};
}
}
[TestCase("CommonServiceLocator", "1.3", "portable-net4+sl5+netcore45+wpa81+wp8", "https://api.nuget.org/v3/index.json")] //Short version format.
public void InstallPackage(string id, string version, string target, string source)
{
var p = new NugetPackage(id, version, target, source, null, NugetPackageType.DotNetImplementationAssembly, GetNugetCachePath());
var installed = NugetHelper.InstallPackages(new[] { p }, false, null);
Assert.AreEqual(1, installed.Count(), "Invalid number of installed packages");
}
public MockGenerator MockToolsAndContentDlls()
{
var packageId = Path.GetFileNameWithoutExtension(NupkgFile);
NugetPackage.Setup(x => x.GetSupportedFrameworks()).Returns(PackageFrameworks);
NugetPackage.Setup(x => x.Id).Returns(packageId);
NugetPackage.Setup(x => x.Version).Returns(new SemanticVersion("1.0.0.0"));
var mockPackageFileTools = new Mock <IPackageFile>(MockBehavior.Strict);
mockPackageFileTools.Setup(x => x.Path).Returns(@"tOols\myToolsSample.dLl");
var mockPackageFileContent = new Mock <IPackageFile>(MockBehavior.Strict);
mockPackageFileContent.Setup(x => x.Path).Returns(@"contenT\myToolsSample.dLl");
PackageFiles.Add(mockPackageFileTools);
PackageFiles.Add(mockPackageFileContent);
var packageDir = Path.GetDirectoryName(NupkgFile);
FileSystem.Setup(x => x.DirectoryGetFiles(packageDir, "*.dll", SearchOption.AllDirectories))
.Returns(PackageFiles.Select(x => Path.Combine(packageDir, x.Object.Path)).ToArray());
return(this);
}
private void CreateNugetPackage(AgentComponents components, AgentComponents x86Components, string nuspecPath)
{
var rootDir = $@"{StagingDirectory}\Nuget{components.Platform}";
var stagingDir = $@"{rootDir}\content\newrelic";
FileHelpers.CopyFile(nuspecPath, rootDir);
var package = new NugetPackage(rootDir, FilesToZipFolderName);
package.SetVersion(components.Version);
var configFilePath = $@"{rootDir}\content\newrelic\newrelic.config";
package.CopyToContent(components.RootInstallDirectoryComponents, @"newrelic");
package.CopyToContent(components.RootInstallDirectoryComponents.Where(x => !x.Contains("newrelic.config") && !x.Contains("newrelic.xsd")), @"newrelic\ProgramFiles\NewRelic\NetAgent");
package.CopyToContent(components.ExtensionDirectoryComponents.Where(x => x.Contains(".dll")), @"newrelic\ProgramFiles\NewRelic\NetAgent\Extensions");
package.CopyToContent(x86Components.RootInstallDirectoryComponents.Where(x => x.Contains("NewRelic.Profiler.dll")), @"newrelic\ProgramFiles\NewRelic\NetAgent\x86");
package.CopyToContent(components.WrapperXmlFiles, $@"newrelic\ProgramData\NewRelic\NetAgent\Extensions");
package.CopyToContent(components.ExtensionXsd, $@"newrelic\ProgramData\NewRelic\NetAgent\Extensions");
package.CopyToContent(components.NewRelicXsd, $@"newrelic\ProgramData\NewRelic\NetAgent");
package.CopyToContent(configFilePath, $@"newrelic\ProgramData\NewRelic\NetAgent");
//not sure why we create these folders
Directory.CreateDirectory($@"{stagingDir}\Extensions");
Directory.CreateDirectory($@"{stagingDir}\ProgramData\NewRelic\NetAgent\NewRelic\NetAgent\Extensions");
Directory.CreateDirectory($@"{stagingDir}\ProgramData\NewRelic\NetAgent\NewRelic\NetAgent\Logs");
File.Delete(configFilePath);
package.Pack();
}
public XamarinAndroidAppProject(string assemblyName, string appName, string packageName, Guid assemblyGuid, XamarinAndroidPlatform targetFrameworkVersion, int minSdkVersion, int targetSdkVersion,
NugetPackage xamarinPackage, string rootNamespace = "") :
base(assemblyName, assemblyGuid, "Library", targetFrameworkVersion, rootNamespace)
{
_minSdkVersion = minSdkVersion;
_targetSdkVersion = targetSdkVersion;
_packageName = packageName;
_appName = appName;
SupportedBuildConfigurations.Add(new SupportedBuildConfiguration("Ad-Hoc", "Any CPU"));
SupportedBuildConfigurations.Add(new SupportedBuildConfiguration("Ad-Hoc", "iPhone"));
SupportedBuildConfigurations.Add(new SupportedBuildConfiguration("Ad-Hoc", "iPhoneSimulator"));
SupportedBuildConfigurations.Add(new SupportedBuildConfiguration("AppStore", "Any CPU"));
SupportedBuildConfigurations.Add(new SupportedBuildConfiguration("AppStore", "iPhone"));
SupportedBuildConfigurations.Add(new SupportedBuildConfiguration("AppStore", "iPhoneSimulator"));
SupportedBuildConfigurations.Add(new SupportedBuildConfiguration("Debug", "Any CPU"));
SupportedBuildConfigurations.Add(new SupportedBuildConfiguration("Debug", "iPhone"));
SupportedBuildConfigurations.Add(new SupportedBuildConfiguration("Debug", "iPhoneSimulator"));
SupportedBuildConfigurations.Add(new SupportedBuildConfiguration("Release", "Any CPU"));
SupportedBuildConfigurations.Add(new SupportedBuildConfiguration("Release", "iPhone"));
SupportedBuildConfigurations.Add(new SupportedBuildConfiguration("Release", "iPhoneSimulator"));
WithNugetPackage(xamarinPackage);
WithNugetPackage(References.Nuget.Xamarin_Android_Support_Design__27_0_2_1);
WithNugetPackage(References.Nuget.Xamarin_Android_Support_v7_AppCompat__27_0_2_1);
WithNugetPackage(References.Nuget.Xamarin_Android_Support_v4__27_0_2_1);
WithNugetPackage(References.Nuget.Xamarin_Android_Support_v7_CardView__27_0_2_1);
WithNugetPackage(References.Nuget.Xamarin_Android_Support_v7_MediaRouter__27_0_2_1);
AddDefaultAssemblyReferences();
AddDefaultFoldersAndFiles();
}
public static PackageResult Success(NugetPackage package, IReadOnlyList <PackageResult> dependencies, Option <MoreInformation> moreInformation)
{
var isAggregationPackage = package.SupportType == SupportType.NoDotNetLibraries &&
dependencies.Any() &&
dependencies.All(d => d.SupportType == SupportType.PreRelease ||
d.SupportType == SupportType.Supported ||
d.SupportType == SupportType.KnownReplacementAvailable ||
d.SupportType == SupportType.Unsupported
);
var isSupportedAggregationPackage = isAggregationPackage &&
dependencies.All(d => d.SupportType == SupportType.PreRelease || d.SupportType == SupportType.Supported);
var supportType = isSupportedAggregationPackage
? (package.IsPrerelease ? SupportType.Supported : SupportType.PreRelease)
: (isAggregationPackage ? SupportType.Unsupported : package.SupportType);
return(new PackageResult()
{
PackageName = package.Id,
Dependencies = dependencies,
SupportType = supportType,
ProjectUrl = package.ProjectUrl,
MoreInformation = moreInformation
});
}
/// <summary>
/// Loads a list of all currently installed packages by reading the packages.config file.
/// </summary>
/// <returns>A newly created <see cref="PackagesConfigFile"/>.</returns>
public static PackagesConfigFile Load(string filepath)
{
PackagesConfigFile configFile = new PackagesConfigFile();
configFile.Packages = new List<NugetPackageIdentifier>();
// Create a package.config file, if there isn't already one in the project
if (!File.Exists(filepath))
{
Debug.LogFormat("No packages.config file found. Creating default at {0}", filepath);
configFile.Save(filepath);
AssetDatabase.Refresh();
}
XDocument packagesFile = XDocument.Load(filepath);
foreach (var packageElement in packagesFile.Root.Elements())
{
NugetPackage package = new NugetPackage();
package.Id = packageElement.Attribute("id").Value;
package.Version = packageElement.Attribute("version").Value;
configFile.Packages.Add(package);
}
return configFile;
}
public NugetAnalyzedPackage AnalyzePackage(string xml, Dictionary <string, INugetPackage> packagesOnConfig, params string[] relativePaths)
{
var nugetPackage = new NugetPackage()
{
Id = "TestPkg", Version = "1.999"
};
var paths = new List <RelativePath>();
paths.Add(RelativePath.Create(m_context.StringTable, nugetPackage.Id + ".nuspec"));
foreach (var relativePath in relativePaths)
{
paths.Add(RelativePath.Create(m_context.StringTable, relativePath));
}
var packageOnDisk = new PackageOnDisk(
m_context.PathTable,
nugetPackage,
PackageDownloadResult.FromRemote(
new PackageIdentity("nuget", nugetPackage.Id, nugetPackage.Version, nugetPackage.Alias),
AbsolutePath.Create(m_context.PathTable, A("X", "Pkgs", "TestPkg", "1.999", "TestPkg.nuspec")),
paths));
return(NugetAnalyzedPackage.TryAnalyzeNugetPackage(m_context, m_monikers, XDocument.Parse(xml), packageOnDisk, packagesOnConfig, false));
}
public void CheckPackageLibraryContent()
{
var p = new NugetPackage("Unity", "4.0.1", "net45", "https://api.nuget.org/v3/index.json", null, NugetPackageType.DotNetImplementationAssembly, GetNugetCachePath());
var installed = NugetHelper.InstallPackages(new[] { p }, false, null).First();
Assert.AreEqual(6, installed.Libraries.Count());
}
/// <summary>
/// New instance of <see cref="PackageMeta"/> from a nuget package <paramref name="metadata"/>.
/// </summary>
/// <param name="metadata">The nuget metadata used to initialized an instance of <see cref="PackageMeta"/>.</param>
public static PackageMeta PackageMetaFromNugetPackage(NugetPackage metadata)
{
var meta = new PackageMeta
{
Name = metadata.Id,
Version = new PackageVersion(metadata.Version.ToString()),
Title = metadata.Title,
IconUrl = metadata.IconUrl,
LicenseUrl = metadata.LicenseUrl,
ProjectUrl = metadata.ProjectUrl,
RequireLicenseAcceptance = metadata.RequireLicenseAcceptance,
Description = metadata.Description,
Summary = metadata.Summary,
Tags = metadata.Tags,
Listed = metadata.Listed,
Published = metadata.Published,
ReportAbuseUrl = metadata.ReportAbuseUrl,
DownloadCount = metadata.DownloadCount
};
meta.Authors.AddRange(metadata.Authors);
meta.Owners.AddRange(metadata.Owners);
if (metadata.DependencySetsCount > 1)
{
throw new InvalidOperationException("Metadata loaded from nuspec cannot have more than one group of dependency");
}
return(meta);
}
public void CheckFramework()
{
var p = new NugetPackage("Unity.Container", "5.11.10", "net472", "https://api.nuget.org/v3/index.json", null, NugetPackageType.DotNetImplementationAssembly, GetNugetCachePath());
var ex = Assert.Throws <Exceptions.PackageInstallationException>(() => NugetHelper.InstallPackages(new[] { p }, false, null));
Assert.IsInstanceOf <Exceptions.TargetFrameworkNotFoundException>(ex.InnerException.InnerException);
}
public NugetViewModel(NugetPackage nugetPackage, TreeViewItemViewModel parent, ISolutionManager solutionManager) : base(parent, true)
{
NugetPackage = nugetPackage;
Name = $"{nugetPackage.Name} [{nugetPackage.Version}]";
FullName = Name;
_solutionManager = solutionManager;
}
public void Store(NugetPackage package)
{
if (package.Version.None)
{
return;
}
try
{
const string sql = "INSERT INTO dbo.NugetResultCache (Id, SupportType, Version, ProjectUrl, Dependencies, Frameworks) VALUES (@Id, @SupportType, @Version, @ProjectUrl, @Dependencies, @Frameworks)";
using (var con = new SqlConnection(_connectionString))
{
con.Open();
using (var cmd = new SqlCommand(sql, con))
{
cmd.Parameters.AddWithValue("Id", package.Id);
cmd.Parameters.AddWithValue("SupportType", package.SupportType.ToString());
cmd.Parameters.AddWithValue("Version", package.Version.Value.ToNormalizedString());
cmd.Parameters.AddWithValue("ProjectUrl", (object)package.ProjectUrl ?? DBNull.Value);
cmd.Parameters.AddWithValue("Dependencies", string.Join("|", package.Dependencies));
cmd.Parameters.AddWithValue("Frameworks", string.Join("|", package.Frameworks.Select(f => f.FullName)));
cmd.ExecuteNonQuery();
}
}
}
catch (Exception ex)
{
Log.Warning(ex, "Could not store {id} {version} in Nuget Package Cache", package.Id, package.Version.Value);
}
}
public HashSet <NugetPackage> GetNugetPackages(string projectFilePath, string projectAssetsFilePath, bool isTestProject)
{
var packages = new HashSet <NugetPackage>();
if (_fileSystem.File.Exists(projectAssetsFilePath))
{
var assetFileReader = _assetFileReaderFactory();
var assetsFile = assetFileReader.Read(projectAssetsFilePath);
foreach (var targetRuntime in assetsFile.Targets)
{
var directPackageDependencies = GetDirectPackageDependencies(targetRuntime.Name, projectFilePath);
var runtimePackages = new HashSet <NugetPackage>();
foreach (var library in targetRuntime.Libraries.Where(lib => lib.Type != "project"))
{
var package = new NugetPackage
{
Name = library.Name,
Version = library.Version.ToNormalizedString(),
Scope = Component.ComponentScope.Required,
Dependencies = new Dictionary <string, string>(),
};
var topLevelReferenceKey = (package.Name, package.Version);
if (directPackageDependencies.Contains(topLevelReferenceKey))
{
package.IsDirectReference = true;
}
// is this a test project dependency or only a development dependency
if (
isTestProject ||
(
library.CompileTimeAssemblies.Count == 0 &&
library.ContentFiles.Count == 0 &&
library.EmbedAssemblies.Count == 0 &&
library.FrameworkAssemblies.Count == 0 &&
library.NativeLibraries.Count == 0 &&
library.ResourceAssemblies.Count == 0 &&
library.ToolsAssemblies.Count == 0
)
)
{
package.Scope = Component.ComponentScope.Excluded;
}
// include direct dependencies
foreach (var dep in library.Dependencies)
{
package.Dependencies.Add(dep.Id, dep.VersionRange?.ToNormalizedString());
}
runtimePackages.Add(package);
}
ResolveDependecyVersionRanges(runtimePackages);
packages.UnionWith(runtimePackages);
}
}
return(packages);
}
public MockGenerator MockPackageId()
{
var packageId = Path.GetFileNameWithoutExtension(NupkgFile);
NugetPackage.Setup(x => x.Id).Returns(packageId);
return(this);
}
public void InstallPackageRecursively(string id, string version, string target, string source)
{
var p = new NugetPackage(id, version, target, source, null, NugetPackageType.DotNetImplementationAssembly, GetNugetCachePath());
var installed = NugetHelper.InstallPackages(new[] { p }, true, null).ToList();
Assert.AreEqual(4, installed.Count(), "Invalid number of installed packages");
NugetHelper.CheckPackagesConsistency(installed);
}
static string NugetResponse(NugetPackage package)
{
return(@"<?xml version=""1.0"" encoding=""utf-8""?>
<package xmlns=""http://schemas.microsoft.com/packaging/2013/05/nuspec.xsd"">
<metadata>
<id>" + package.Name + @"</id>
<version>" + package.Version + @"</version>
</metadata>
</package>");
}
private static async Task UninstallPackage(NugetStore store, NugetPackage package, ProgressReport progressReport)
{
await store.UninstallPackage(package, progressReport);
// If package is GameStudio, then recursively delete its Stride/Xenko dependencies to save more disk space
if (store.MainPackageIds.Contains(package.Id))
{
await UninstallDependencies(store, package);
}
}
protected override void InternalBuild()
{
var rootDirectory = $@"{StagingDirectory}\content\newrelic";
var frameworkAgentComponents = AgentComponents.GetAgentComponents(AgentType.Framework, Configuration, "x64", RepoRootDirectory, HomeRootDirectory);
var frameworkAgentX86Components = AgentComponents.GetAgentComponents(AgentType.Framework, Configuration, "x86", RepoRootDirectory, HomeRootDirectory);
var coreAgentComponents = AgentComponents.GetAgentComponents(AgentType.Core, Configuration, "x64", RepoRootDirectory, HomeRootDirectory);
var coreAgentX86Components = AgentComponents.GetAgentComponents(AgentType.Core, Configuration, "x86", RepoRootDirectory, HomeRootDirectory);
frameworkAgentComponents.ValidateComponents();
frameworkAgentX86Components.ValidateComponents();
coreAgentComponents.ValidateComponents();
coreAgentX86Components.ValidateComponents();
var package = new NugetPackage(StagingDirectory, OutputDirectory);
frameworkAgentComponents.CopyComponents($@"{package.ContentDirectory}\newrelic");
FileHelpers.CopyFile(frameworkAgentX86Components.WindowsProfiler, $@"{package.ContentDirectory}\newrelic\x86");
Directory.CreateDirectory($@"{rootDirectory}\logs");
System.IO.File.Create($@"{rootDirectory}\logs\placeholder").Dispose();
frameworkAgentComponents.CopyComponents($@"{package.GetContentFilesDirectory("any", "net45")}\newrelic");
FileHelpers.CopyFile(frameworkAgentX86Components.WindowsProfiler, $@"{package.GetContentFilesDirectory("any", "net45")}\newrelic\x86");
Directory.CreateDirectory($@"{StagingDirectory}\contentFiles\any\net45\newrelic\logs");
System.IO.File.Create($@"{StagingDirectory}\contentFiles\any\net45\newrelic\logs\placeholder").Dispose();
coreAgentComponents.CopyComponents($@"{package.GetContentFilesDirectory("any", "netstandard2.0")}\newrelic");
FileHelpers.CopyFile(coreAgentX86Components.WindowsProfiler, $@"{package.GetContentFilesDirectory("any", "netstandard2.0")}\newrelic\x86");
package.CopyToContentFiles(coreAgentComponents.LinuxProfiler, @"any\netstandard2.0\newrelic");
package.CopyToContentFiles(coreAgentComponents.GRPCExtensionsLibLinux, @"any\netstandard2.0\newrelic");
Directory.CreateDirectory($@"{StagingDirectory}\contentFiles\any\netstandard2.0\newrelic\logs");
System.IO.File.Create($@"{StagingDirectory}\contentFiles\any\netstandard2.0\newrelic\logs\placeholder").Dispose();
package.CopyAll(PackageDirectory);
var agentInfo = new AgentInfo
{
InstallType = "NugetAgent"
};
var newRelicConfigPaths = new[]
{
$@"{rootDirectory}\newrelic.config",
$@"{StagingDirectory}\contentFiles\any\net45\newrelic\newrelic.config",
$@"{StagingDirectory}\contentFiles\any\netstandard2.0\newrelic\newrelic.config",
};
foreach (var newRelicConfigPath in newRelicConfigPaths)
{
TransformNewRelicConfig(newRelicConfigPath);
agentInfo.WriteToDisk(Path.GetDirectoryName(newRelicConfigPath));
}
package.SetVersion(frameworkAgentComponents.Version);
package.Pack();
}
protected override void InternalBuild()
{
var targetFrameworkMoniker = "netstandard2.0";
var component = $@"{RepoRootDirectory}\src\AwsLambda\AwsLambdaOpenTracer\bin\{Configuration}\{targetFrameworkMoniker}-ILRepacked\NewRelic.OpenTracing.AmazonLambda.Tracer.dll";
var package = new NugetPackage(StagingDirectory, OutputDirectory);
package.CopyAll($@"{PackageDirectory}");
package.CopyToLib(component, "netstandard2.0");
package.SetVersionFromDll(component);
package.Pack();
}
public void NullNugetPackages_AreSortedFirst()
{
var nugetPackage = new NugetPackage
{
Name = "Package1",
Version = "1.2.3",
};
// cast null as string to flex CompareTo(object obj) and CompareTo(NugetPackage other)
Assert.Equal(1, nugetPackage.CompareTo((string)null));
}
public void NullNugetPackage_IsNotEqual()
{
var nugetPackage1 = new NugetPackage
{
Name = "Package",
Version = "1.2.3",
};
// cast null as string to flex Equals(object obj) and Equals(NugetPackage other)
Assert.False(nugetPackage1.Equals((string)null));
}
public MockGenerator MockPackageInfo()
{
var packageId = Path.GetFileNameWithoutExtension(NupkgFile);
NugetPackage.Setup(x => x.GetSupportedFrameworks()).Returns(PackageFrameworks);
NugetPackage.Setup(x => x.Id).Returns(packageId);
NugetPackage.Setup(x => x.Version).Returns(new SemanticVersion("1.0.0.0"));
NugetPackage.Setup(x => x.PackageAssemblyReferences).Returns(new List <PackageReferenceSet>());
return(this);
}
protected override void InternalBuild()
{
var version = ReadVersionFromFile();
var package = new NugetPackage(StagingDirectory, OutputDirectory);
package.CopyAll($@"{PackageDirectory}");
package.CopyToContent($@"{RepoRootDirectory}\build\NewRelic.NuGetHelper\bin\NewRelic.NuGetHelper.dll");
package.CopyToContent($@"{RepoRootDirectory}\build\NewRelic.NuGetHelper\bin\NuGet.Core.dll");
package.CopyToContent($@"{RepoRootDirectory}\build\NewRelic.NuGetHelper\bin\Microsoft.Web.XmlTransform.dll");
package.SetVersion(version);
package.Pack();
}
public void VersionComparison(string smallerVersion, string greaterVersion)
{
var smallerPackage = new NugetPackage {
Id = "TestPackage", Version = smallerVersion
};
var greaterPackage = new NugetPackage {
Id = "TestPackage", Version = greaterVersion
};
Assert.IsTrue(smallerPackage.CompareTo(greaterPackage) < 0, "{0} was NOT smaller than {1}", smallerVersion, greaterVersion);
Assert.IsTrue(greaterPackage.CompareTo(smallerPackage) > 0, "{0} was NOT greater than {1}", greaterVersion, smallerVersion);
}
public HashSet <NugetPackage> GetNugetPackages(string projectAssetsFilePath, bool isTestProject)
{
var packages = new HashSet <NugetPackage>();
if (_fileSystem.File.Exists(projectAssetsFilePath))
{
var assetFileReader = new AssetFileReader();
var assetsFile = assetFileReader.Read(projectAssetsFilePath);
foreach (var targetRuntime in assetsFile.Targets)
{
foreach (var library in targetRuntime.Libraries)
{
if (library.Type != "project")
{
var package = new NugetPackage
{
Name = library.Name,
Version = library.Version.ToNormalizedString(),
Scope = Component.ComponentScope.Required,
Dependencies = new Dictionary <string, string>(),
};
// is this a test project dependency or only a development dependency
if (
isTestProject ||
(
library.CompileTimeAssemblies.Count == 0 &&
library.ContentFiles.Count == 0 &&
library.EmbedAssemblies.Count == 0 &&
library.FrameworkAssemblies.Count == 0 &&
library.NativeLibraries.Count == 0 &&
library.ResourceAssemblies.Count == 0 &&
library.ToolsAssemblies.Count == 0
)
)
{
package.Scope = Component.ComponentScope.Excluded;
}
// include direct dependencies
foreach (var dep in library.Dependencies)
{
//Get the version from the nuget package as described here: https://github.com/NuGet/NuGet.Client/blob/ad81306fe7ada265cf44afb2a60a31fbfca978a2/src/NuGet.Core/NuGet.ProjectModel/JsonUtility.cs#L54
package.Dependencies.Add(dep.Id, dep.VersionRange?.ToLegacyShortString());
}
packages.Add(package);
}
}
}
}
return(packages);
}
/// <summary>
/// Analyzes a single Project file for NuGet package references.
/// </summary>
/// <param name="projectFilePath"></param>
/// <returns></returns>
public async Task <HashSet <NugetPackage> > GetProjectNugetPackagesAsync(string projectFilePath)
{
if (!_fileSystem.File.Exists(projectFilePath))
{
Console.Error.WriteLine($"Project file \"{projectFilePath}\" does not exist");
return(new HashSet <NugetPackage>());
}
Console.WriteLine();
Console.WriteLine($"» Analyzing: {projectFilePath}");
Console.WriteLine(" Getting packages");
var packages = new HashSet <NugetPackage>();
using (StreamReader fileReader = _fileSystem.File.OpenText(projectFilePath))
{
using (XmlReader reader = XmlReader.Create(fileReader, _xmlReaderSettings))
{
while (await reader.ReadAsync())
{
if (reader.IsStartElement() && reader.Name == "PackageReference")
{
var package = new NugetPackage
{
Name = reader["Include"],
Version = reader["Version"],
};
if (!string.IsNullOrEmpty(package.Name) && !string.IsNullOrEmpty(package.Version))
{
packages.Add(package);
}
}
}
}
}
// if there are no project file package references look for a packages.config
if (!packages.Any())
{
Console.WriteLine(" No packages found");
var directoryPath = _fileSystem.Path.GetDirectoryName(projectFilePath);
var packagesPath = _fileSystem.Path.Combine(directoryPath, "packages.config");
if (_fileSystem.File.Exists(packagesPath))
{
Console.WriteLine(" Found packages.config. Will attempt to process");
packages = await _packagesFileService.GetNugetPackagesAsync(packagesPath);
}
}
return(packages);
}
public void SameNugetPackageVersions_AreEqual()
{
var nugetPackage1 = new NugetPackage
{
Name = "Package",
Version = "1.2.3",
};
var nugetPackage2 = new NugetPackage
{
Name = "Package",
Version = "1.2.3",
};
Assert.True(nugetPackage1.Equals((object)nugetPackage2));
}
public void DifferentNugetPackages_WithSameVersions_AreNotEqual()
{
var nugetPackage1 = new NugetPackage
{
Name = "Package1",
Version = "1.2.3",
};
var nugetPackage2 = new NugetPackage
{
Name = "Package2",
Version = "1.2.3",
};
Assert.False(nugetPackage1.Equals((object)nugetPackage2));
}
public void NugetPackages_AreSortedByName()
{
var nugetPackage1 = new NugetPackage
{
Name = "Package1",
Version = "1.2.3",
};
var nugetPackage2 = new NugetPackage
{
Name = "Package2",
Version = "1.2.3",
};
Assert.Equal(-1, nugetPackage1.CompareTo(nugetPackage2));
}
private static void AddReferencesToNugetPackages(string solutionFolder)
{
var packageFolders = Directory.GetDirectories(solutionFolder + "/packages/");
var packages = new List<NugetPackage>();
foreach (var packageFolder in packageFolders)
{
var pattern = new Regex(@"(.+)\.(\d+\.\d+\.\d+.*)");
var captureGroups =
pattern.Matches(packageFolder).GetEnumerator().Current as Match; // There can only be one
var name = captureGroups.Groups[1].Value;
var version = captureGroups.Groups[2].Value;
var libFolder = packageFolder + "/lib/net45/";
var dllNames = Directory.GetFiles(libFolder).Where(f => f.EndsWith(".dll")).Select(Path.GetFileNameWithoutExtension);
var package = new NugetPackage()
{
Name = name,
Version = version,
DllNames = dllNames.ToList()
};
}
}
private void DrawPackage(NugetPackage package)
{
if (package.Dependencies != null && package.Dependencies.Count > 0)
{
expanded[package] = EditorGUILayout.Foldout(expanded[package], string.Format("{0} {1}", package.Id, package.Version));
if (expanded[package])
{
EditorGUI.indentLevel++;
foreach (NugetPackageIdentifier dependency in package.Dependencies)
{
DrawDepencency(dependency);
}
EditorGUI.indentLevel--;
}
}
else
{
EditorGUILayout.LabelField(string.Format("{0} {1}", package.Id, package.Version));
}
}
/// <summary>
/// Installs the given package.
/// </summary>
/// <param name="package">The package to install.</param>
/// <param name="refreshAssets">True to refresh the Unity asset database. False to ignore the changes (temporarily).</param>
public static void Install(NugetPackage package, bool refreshAssets = true)
{
try
{
LogVerbose("Installing: {0} {1}", package.Id, package.Version);
// update packages.config
PackagesConfigFile.AddPackage(package);
PackagesConfigFile.Save(PackagesConfigFilePath);
if (refreshAssets)
EditorUtility.DisplayProgressBar(string.Format("Installing {0} {1}", package.Id, package.Version), "Installing Dependencies", 0.1f);
foreach (var dependency in package.Dependencies)
{
LogVerbose("Installing Dependency: {0} {1}", dependency.Id, dependency.Version);
InstallIdentifier(dependency);
}
// look to see if the package (any version) is already installed
foreach (var installedPackage in installedPackages)
{
if (installedPackage.Id == package.Id)
{
if (installedPackage < package)
{
LogVerbose("{0} {1} is installed, but need {2} or greater. Updating to {3}", installedPackage.Id, installedPackage.Version, package.Version, package.Version);
Update(installedPackage, package, false);
}
else if (installedPackage > package)
{
LogVerbose("{0} {1} is installed. {2} or greater is needed, so using installed version.", installedPackage.Id, installedPackage.Version, package.Version);
}
else
{
LogVerbose("Already installed: {0} {1}", package.Id, package.Version);
}
return;
}
}
string cachedPackagePath = Path.Combine(PackOutputDirectory, string.Format("./{0}.{1}.nupkg", package.Id, package.Version));
if (NugetConfigFile.InstallFromCache && File.Exists(cachedPackagePath))
{
LogVerbose("Cached package found for {0} {1}", package.Id, package.Version);
}
else
{
if (package.PackageSource.IsLocalPath)
{
LogVerbose("Caching local package {0} {1}", package.Id, package.Version);
// copy the .nupkg from the local path to the cache
File.Copy(Path.Combine(package.PackageSource.Path, string.Format("./{0}.{1}.nupkg", package.Id, package.Version)), cachedPackagePath, true);
}
else
{
// Mono doesn't have a Certificate Authority, so we have to provide all validation manually. Currently just accept anything.
// See here: http://stackoverflow.com/questions/4926676/mono-webrequest-fails-with-https
// remove all handlers
//if (ServicePointManager.ServerCertificateValidationCallback != null)
// foreach (var d in ServicePointManager.ServerCertificateValidationCallback.GetInvocationList())
// ServicePointManager.ServerCertificateValidationCallback -= (d as System.Net.Security.RemoteCertificateValidationCallback);
ServicePointManager.ServerCertificateValidationCallback = null;
// add anonymous handler
ServicePointManager.ServerCertificateValidationCallback += (sender, certificate, chain, policyErrors) => true;
LogVerbose("Downloading package {0} {1}", package.Id, package.Version);
if (refreshAssets)
EditorUtility.DisplayProgressBar(string.Format("Installing {0} {1}", package.Id, package.Version), "Downloading Package", 0.3f);
HttpWebRequest getRequest = (HttpWebRequest)WebRequest.Create(package.DownloadUrl);
Stream objStream = getRequest.GetResponse().GetResponseStream();
using (Stream file = File.Create(cachedPackagePath))
{
CopyStream(objStream, file);
}
}
}
if (refreshAssets)
EditorUtility.DisplayProgressBar(string.Format("Installing {0} {1}", package.Id, package.Version), "Extracting Package", 0.6f);
if (File.Exists(cachedPackagePath))
{
// unzip the package
using (ZipFile zip = ZipFile.Read(cachedPackagePath))
{
foreach (ZipEntry entry in zip)
{
entry.Extract(Path.Combine(NugetConfigFile.RepositoryPath, string.Format("{0}.{1}", package.Id, package.Version)), ExtractExistingFileAction.OverwriteSilently);
}
}
// copy the .nupkg inside the Unity project
File.Copy(cachedPackagePath, Path.Combine(NugetConfigFile.RepositoryPath, string.Format("{0}.{1}/{0}.{1}.nupkg", package.Id, package.Version)), true);
}
else
{
Debug.LogErrorFormat("File not found: {0}", cachedPackagePath);
}
if (refreshAssets)
EditorUtility.DisplayProgressBar(string.Format("Installing {0} {1}", package.Id, package.Version), "Cleaning Package", 0.9f);
// clean
Clean(package);
// update the installed packages list
installedPackages.Add(package);
}
catch (Exception e)
{
Debug.LogErrorFormat("{0}", e.ToString());
}
finally
{
if (refreshAssets)
{
EditorUtility.DisplayProgressBar(string.Format("Installing {0} {1}", package.Id, package.Version), "Importing Package", 0.95f);
AssetDatabase.Refresh();
EditorUtility.ClearProgressBar();
}
}
}
/// <summary>
/// Draws the given <see cref="NugetPackage"/>.
/// </summary>
/// <param name="package">The <see cref="NugetPackage"/> to draw.</param>
private void DrawPackage(NugetPackage package)
{
EditorGUILayout.BeginHorizontal();
{
// The Unity GUI system (in the Editor) is terrible. This probably requires some explanation.
// Every time you use a Horizontal block, Unity appears to divide the space evenly.
// (i.e. 2 components have half of the window width, 3 components have a third of the window width, etc)
// GUILayoutUtility.GetRect is SUPPOSED to return a rect with the given height and width, but in the GUI layout. It doesn't.
// We have to use GUILayoutUtility to get SOME rect properties, but then manually calculate others.
EditorGUILayout.BeginHorizontal();
{
const int iconSize = 32;
const int leftPadding = 5;
Rect rect = GUILayoutUtility.GetRect(iconSize, iconSize);
// only use GetRect's Y position. It doesn't correctly set the width or X position.
rect.x = leftPadding;
rect.y += 3;
rect.width = iconSize;
rect.height = iconSize;
if (package.Icon != null)
{
GUI.DrawTexture(rect, package.Icon, ScaleMode.StretchToFill);
}
else
{
GUI.DrawTexture(rect, defaultIcon, ScaleMode.StretchToFill);
}
rect = GUILayoutUtility.GetRect(position.width / 2 - (iconSize + leftPadding), 20);
rect.x = iconSize + leftPadding;
rect.y += 10;
EditorStyles.label.fontStyle = FontStyle.Bold;
EditorStyles.label.fontSize = 14;
////EditorGUILayout.LabelField(string.Format("{1} [{0}]", package.Version, package.Id), GUILayout.Height(20), GUILayout.Width(position.width / 2 - 32));
GUI.Label(rect, string.Format("{1} [{0}]", package.Version, package.Title), EditorStyles.label);
EditorStyles.label.fontSize = 10;
EditorStyles.label.fontStyle = FontStyle.Normal;
}
EditorGUILayout.EndHorizontal();
if (installedPackages.Contains(package))
{
// This specific version is installed
if (GUILayout.Button("Uninstall", installButtonWidth))
{
// TODO: Perhaps use a "mark as dirty" system instead of updating all of the data all the time?
NugetHelper.Uninstall(package);
UpdateInstalledPackages();
UpdateUpdatePackages();
}
}
else
{
var installed = installedPackages.FirstOrDefault(p => p.Id == package.Id);
if (installed != null)
{
if (installed < package)
{
// An older version is installed
if (GUILayout.Button(string.Format("Update [{0}]", installed.Version), installButtonWidth))
{
NugetHelper.Update(installed, package);
UpdateInstalledPackages();
UpdateUpdatePackages();
}
}
else if (installed > package)
{
// A newer version is installed
if (GUILayout.Button(string.Format("Downgrade [{0}]", installed.Version), installButtonWidth))
{
NugetHelper.Update(installed, package);
UpdateInstalledPackages();
UpdateUpdatePackages();
}
}
}
else
{
if (GUILayout.Button("Install", installButtonWidth))
{
NugetHelper.Install(package);
AssetDatabase.Refresh();
UpdateInstalledPackages();
UpdateUpdatePackages();
}
}
}
}
EditorGUILayout.EndHorizontal();
// Show the package description
EditorStyles.label.wordWrap = true;
//EditorStyles.label.fontStyle = FontStyle.Bold;
//EditorGUILayout.LabelField(string.Format("Description:"));
EditorStyles.label.fontStyle = FontStyle.Normal;
EditorGUILayout.LabelField(string.Format("{0}", package.Description));
// Show the package release notes
if (!string.IsNullOrEmpty(package.ReleaseNotes))
{
EditorStyles.label.wordWrap = true;
EditorStyles.label.fontStyle = FontStyle.Bold;
EditorGUILayout.LabelField(string.Format("Release Notes:"));
EditorStyles.label.fontStyle = FontStyle.Normal;
EditorGUILayout.LabelField(string.Format("{0}", package.ReleaseNotes));
}
// Show the dependencies
if (package.Dependencies.Count > 0)
{
EditorStyles.label.wordWrap = true;
EditorStyles.label.fontStyle = FontStyle.Italic;
StringBuilder builder = new StringBuilder();
foreach (var dependency in package.Dependencies)
{
builder.Append(string.Format(" {0} {1};", dependency.Id, dependency.Version));
}
EditorGUILayout.Space();
EditorGUILayout.LabelField(string.Format("Depends on:{0}", builder.ToString()));
EditorStyles.label.fontStyle = FontStyle.Normal;
}
// Show the license button
if (!string.IsNullOrEmpty(package.LicenseUrl) && package.LicenseUrl != "http://your_license_url_here")
{
if (GUILayout.Button("View License", GUILayout.Width(120)))
{
Application.OpenURL(package.LicenseUrl);
}
}
EditorGUILayout.Separator();
EditorGUILayout.Separator();
}
public override void Context()
{
repositoryMock = MockRepository.GenerateStub<IRepository>();
repository = new NugetPackageRepository(repositoryMock);
expectedPackage = new NugetPackage();
}
public override void Because()
{
package = repository.FindOrCreate(0);
}
/// <summary>
/// Builds a list of NugetPackages from the XML returned from the HTTP GET request issued at the given URL.
/// Note that NuGet uses an Atom-feed (XML Syndicaton) superset called OData.
/// See here http://www.odata.org/documentation/odata-version-2-0/uri-conventions/
/// </summary>
/// <param name="url"></param>
/// <returns></returns>
private List<NugetPackage> GetPackagesFromUrl(string url)
{
NugetHelper.LogVerbose("Getting packages from: {0}", url);
Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();
HttpWebRequest getRequest = (HttpWebRequest)WebRequest.Create(url);
getRequest.Timeout = 5000;
getRequest.ReadWriteTimeout = 5000;
Stream responseStream = getRequest.GetResponse().GetResponseStream();
StreamReader objReader = new StreamReader(responseStream);
SyndicationFeed atomFeed = SyndicationFeed.Load(XmlReader.Create(objReader));
List<NugetPackage> packages = new List<NugetPackage>();
foreach (var item in atomFeed.Items)
{
var propertiesExtension = item.ElementExtensions.First();
var reader = propertiesExtension.GetReader();
var properties = (XElement)XDocument.ReadFrom(reader);
NugetPackage package = new NugetPackage();
package.PackageSource = this;
package.DownloadUrl = ((UrlSyndicationContent)item.Content).Url.ToString();
package.Id = item.Title.Text;
package.Title = (string)properties.Element(XName.Get("Title", "http://schemas.microsoft.com/ado/2007/08/dataservices")) ?? string.Empty;
package.Version = (string)properties.Element(XName.Get("Version", "http://schemas.microsoft.com/ado/2007/08/dataservices")) ?? string.Empty;
package.Description = (string)properties.Element(XName.Get("Description", "http://schemas.microsoft.com/ado/2007/08/dataservices")) ?? string.Empty;
package.ReleaseNotes = (string)properties.Element(XName.Get("ReleaseNotes", "http://schemas.microsoft.com/ado/2007/08/dataservices")) ?? string.Empty;
package.LicenseUrl = (string)properties.Element(XName.Get("LicenseUrl", "http://schemas.microsoft.com/ado/2007/08/dataservices")) ?? string.Empty;
string iconUrl = (string)properties.Element(XName.Get("IconUrl", "http://schemas.microsoft.com/ado/2007/08/dataservices")) ?? string.Empty;
if (!string.IsNullOrEmpty(iconUrl))
{
package.Icon = NugetHelper.DownloadImage(iconUrl);
}
// if there is no title, just use the ID as the title
if (string.IsNullOrEmpty(package.Title))
{
package.Title = package.Id;
}
// Get dependencies
package.Dependencies = new List<NugetPackageIdentifier>();
string rawDependencies = (string)properties.Element(XName.Get("Dependencies", "http://schemas.microsoft.com/ado/2007/08/dataservices")) ?? string.Empty;
if (!string.IsNullOrEmpty(rawDependencies))
{
string[] dependencies = rawDependencies.Split('|');
foreach (var dependencyString in dependencies)
{
string[] details = dependencyString.Split(':');
string id = details[0];
string version = details[1];
string framework = string.Empty;
if (details.Length > 2)
{
framework = details[2];
}
// some packages (ex: FSharp.Data - 2.1.0) have inproper "semi-empty" dependencies such as:
// "Zlib.Portable:1.10.0:portable-net40+sl50+wp80+win80|::net40"
// so we need to only add valid dependencies and skip invalid ones
if (!string.IsNullOrEmpty(id) && !string.IsNullOrEmpty(version))
{
// only use the dependency if there is no framework specified, or it is explicitly .NET 3.0
if (string.IsNullOrEmpty(framework) || framework == "net30")
{
NugetPackageIdentifier dependency = new NugetPackageIdentifier(id, version);
package.Dependencies.Add(dependency);
}
}
}
}
packages.Add(package);
}
stopwatch.Stop();
NugetHelper.LogVerbose("Retreived {0} packages in {1} ms", packages.Count, stopwatch.ElapsedMilliseconds);
return packages;
}
/// <summary>
/// Updates a package by uninstalling the currently installed version and installing the "new" version.
/// </summary>
/// <param name="currentVersion">The current package to uninstall.</param>
/// <param name="newVersion">The package to install.</param>
/// <param name="refreshAssets">True to refresh the assets inside Unity. False to ignore them (for now). Defaults to true.</param>
public static void Update(NugetPackageIdentifier currentVersion, NugetPackage newVersion, bool refreshAssets = true)
{
LogVerbose("Updating {0} {1} to {2}", currentVersion.Id, currentVersion.Version, newVersion.Version);
Uninstall(currentVersion, false);
Install(newVersion, refreshAssets);
}
