private void CreateNugetConfig()
{
var xml = new XmlDocument();
var configuration = xml.CreateNode(XmlNodeType.Element, "configuration", null);
var packageSources = xml.CreateNode(XmlNodeType.Element, "packageSources", null);
packageSources.InnerXml = "<clear/>";
xml.AppendChild(configuration);
xml.DocumentElement.AppendChild(packageSources);
var sources = AllPackages
.SelectAllSources()
.Concat(DebugSlnxItems.SelectMany(x => x.Value.AllPackages.SelectAllSources()))
.Prepend(new Uri(PackagesPath))
.Distinct()
.Select(x => x.CreateNugetConfigSource(xml));
foreach (var source in sources)
{
packageSources.AppendChild(source);
}
string prettyContent = XDocument.Parse(xml.OuterXml).ToString();
_fileWriter.WriteAllText(Path.Combine(SlnxDirectory, "nuget.config"), prettyContent);
}
private Dictionary <CsProject, XmlDocument> CreatPackageReferenceContent(Dictionary <NuGetPackageInfo, SlnxHandler> debugItems)
{
_logger?.Info($"Adding nuget package references to the CsProjects...");
var ret = new Dictionary <CsProject, XmlDocument>();
foreach (var p in _slnx.project.Where(x => x.@ref?.Count() > 0))
{
Assert(!p.name.Contains("*"), "Reference to projects with wildcards are not (yet?) supported");
var csProject = _projects.Where(x => x.Name == p.name).FirstOrDefault();
Assert(csProject != null, "The project {0} cannot be found in the list of known CsProjects", p.name);
var xml = new XmlDocument();
var root = xml.CreateNode(XmlNodeType.Element, "Project", null);
xml.AppendChild(root);
var itemGroup = xml.CreateNode(XmlNodeType.Element, "ItemGroup", null);
xml.DocumentElement.AppendChild(itemGroup);
foreach (var r in p.@ref)
{
var refPackage = AllPackages.Where(x => x.Identity.Id.ToLower() == r.ToLower()).FirstOrDefault();
Assert(refPackage != null, "The project {0} has a reference to an unknown package {1}. Add it as <package> to the slnx file [{2}]", p.name, r, _slnxFile);
AppendReference(debugItems, itemGroup, refPackage);
csProject.AddPackageReference(refPackage);
}
ret.Add(csProject, xml);
}
return(ret);
}
public async Task GetUpdates_IncludesSemVerV2PackageVersionsWhenSemVerLevel2OrHigher(string semVerLevel)
{
// Arrange
const string currentVersionString = "1.0.0";
var currentVersion = NuGetVersion.Parse(currentVersionString);
var expected = AllPackages.Where(p => NuGetVersion.Parse(p.Version) > currentVersion);
// Act
var resultSet = await GetCollection <V2FeedPackage>(
(controller, options) => controller.GetUpdates(options, TestPackageId, currentVersionString, includePrerelease: true, includeAllVersions: true, semVerLevel: semVerLevel),
$"/api/v2/GetUpdates()?packageIds='{TestPackageId}'&versions='{currentVersionString}'&includePrerelease=true&includeAllVersions=true&semVerLevel={semVerLevel}");
// Assert
foreach (var package in SemVer2Packages.Where(p => NuGetVersion.Parse(p.Version) > currentVersion))
{
// Assert all of the SemVer2 packages are included in the result.
// Whilst at it, also check the NormalizedVersion on the OData feed.
Assert.Single(resultSet.Where(feedPackage =>
string.Equals(feedPackage.Version, package.Version) &&
string.Equals(feedPackage.NormalizedVersion, package.NormalizedVersion) &&
string.Equals(feedPackage.Id, package.PackageRegistration.Id)));
}
foreach (var package in NonSemVer2Packages.Where(p => NuGetVersion.Parse(p.Version) > currentVersion))
{
// Assert all of the non-SemVer2 packages are included in the result.
// Whilst at it, also check the NormalizedVersion on the OData feed.
Assert.Single(resultSet.Where(feedPackage =>
string.Equals(feedPackage.Version, package.Version) &&
string.Equals(feedPackage.NormalizedVersion, package.NormalizedVersion) &&
string.Equals(feedPackage.Id, package.PackageRegistration.Id)));
}
Assert.Equal(expected.Count(), resultSet.Count);
}
public bool IsReleaseInstalled(ReleaseInfo info)
{
return(AllPackages
.Any(x => x.InstallInfo != null &&
x.InstallInfo.ReleaseInfo != null &&
x.InstallInfo.ReleaseInfo.Id == info.Id &&
x.InstallInfo.ReleaseInfo.VersionCode == info.VersionCode));
}
private async Task LoadPackages()
{
if (IsLoading)
{
// prevent concurrent loading
return;
}
IsLoading = true;
ErrorMessage = null;
AllPackages.Clear();
_downloadCancelSource = new CancellationTokenSource();
try
{
var versions = await _versionInfos();
var packageMetadataResource = await _repository.GetResourceAsync <PackageMetadataResource>(_downloadCancelSource.Token);
using (var sourceCacheContext = new SourceCacheContext())
{
var query = await packageMetadataResource.GetMetadataAsync(LatestPackageInfo.Id, ShowPrerelease, ShowPrerelease, sourceCacheContext, NullLogger.Instance, _downloadCancelSource.Token);
query = query.OrderByDescending(p => p.Identity.Version);
var packages = query.ToList();
var deprecations = await Task.WhenAll(packages.Select(p => p.GetDeprecationMetadataAsync()));
for (var i = 0; i < packages.Count; i++)
{
var package = packages[i];
var deprecationMetadata = deprecations[i];
AllPackages.Add(CreatePackageInfo(package, _feedType, versions, deprecationMetadata));
}
}
HasFinishedLoading = true;
}
catch (OperationCanceledException)
{
}
catch (Exception exception)
{
if (!(exception is FatalProtocolException) && !(exception is IOException) && !(exception is NullReferenceException) && !(exception is UnauthorizedAccessException))
{
DiagnosticsClient.TrackException(exception);
}
ErrorMessage = exception.GetBaseException().Message;
}
finally
{
_downloadCancelSource.Dispose();
_downloadCancelSource = null;
IsLoading = false;
}
}
public async Task SearchCount_IncludesSemVerV2PackageVersionsWhenSemVerLevel2OrHigher_ExcludePrerelease(string semVerLevel)
{
// Act
var searchCount = await GetInt <V2FeedPackage>(
async (controller, options) => await controller.SearchCount(options, _curatedFeedName, searchTerm: TestPackageId, semVerLevel: semVerLevel),
$"/api/v2/curated-feed/{_curatedFeedName}/Search/$count?searchTerm='{TestPackageId}'&semVerLevel={semVerLevel}");
// Assert
Assert.Equal(AllPackages.Where(p => !p.IsPrerelease).Count(), searchCount);
}
public async Task GetCount_IncludesSemVerV2PackageVersionsWhenSemVerLevel2OrHigher(string semVerLevel)
{
// Act
var count = await GetInt <V2FeedPackage>(
(controller, options) => controller.GetCount(options, _curatedFeedName, semVerLevel),
$"/api/v2/curated-feed/{_curatedFeedName}/Packages/$count?semVerLevel={semVerLevel}");
// Assert
Assert.Equal(AllPackages.Count(), count);
}
private async Task LoadPackages()
{
if (IsLoading)
{
// prevent concurrent loading
return;
}
IsLoading = true;
ErrorMessage = null;
AllPackages.Clear();
_downloadCancelSource = new CancellationTokenSource();
try
{
IQueryable <IPackage> query = _repository.GetPackagesById(LatestPackageInfo.Id, ShowPrerelease);
query = query.OrderByDescending(p => p.Published);
IQueryable <PackageInfo> packageInfos = GetPackageInfos(query, _repository);
PackageInfo[] packageInfoList = await LoadData(packageInfos, _downloadCancelSource.Token);
var dataServiceRepository = _repository as DataServicePackageRepository;
if (dataServiceRepository != null)
{
foreach (PackageInfo entity in packageInfoList)
{
entity.DownloadUrl = dataServiceRepository.GetReadStreamUri(entity);
}
}
foreach (var p in packageInfoList)
{
p.ShowAll = true;
}
// now show packages
AllPackages.AddRange(packageInfoList);
HasFinishedLoading = true;
}
catch (OperationCanceledException)
{
}
catch (Exception exception)
{
ErrorMessage = exception.GetBaseException().Message;
}
finally
{
_downloadCancelSource = null;
IsLoading = false;
}
}
public async Task FindPackagesById_IncludesSemVerV2PackageVersionsWhenSemVerLevel2OrHigher(string semVerLevel)
{
// Act
var resultSet = await GetCollection <V2FeedPackage>(
async (controller, options) => await controller.FindPackagesById(options, _curatedFeedName, id: TestPackageId, semVerLevel: semVerLevel),
$"/api/v2/curated-feed/{_curatedFeedName}/FindPackagesById?id='{TestPackageId}'?semVerLevel={semVerLevel}");
// Assert
AssertSemVer2PackagesIncludedInResult(resultSet, includePrerelease: true);
Assert.Equal(AllPackages.Count(), resultSet.Count);
}
public async Task Get_IncludesSemVerV2PackageVersionsWhenSemVerLevel2OrHigher(string semVerLevel)
{
// Act
var resultSet = await GetCollection <V2FeedPackage>(
(controller, options) => controller.Get(options, _curatedFeedName, semVerLevel),
$"/api/v2/curated-feed/{_curatedFeedName}/Packages?semVerLevel={semVerLevel}");
// Assert
AssertSemVer2PackagesIncludedInResult(resultSet, includePrerelease: true);
Assert.Equal(AllPackages.Count(), resultSet.Count);
}
public async Task Search_IncludesSemVerV2PackageVersionsWhenSemVerLevel2OrHigher_ExcludePrerelease(string semVerLevel)
{
// Act
var resultSet = await GetCollection <V2FeedPackage>(
async (controller, options) => await controller.Search(options, _curatedFeedName, searchTerm: TestPackageId, semVerLevel: semVerLevel),
$"/api/v2/curated-feed/{_curatedFeedName}/Search?searchTerm='{TestPackageId}'&semVerLevel={semVerLevel}");
// Assert
AssertSemVer2PackagesIncludedInResult(resultSet, includePrerelease: false);
Assert.Equal(AllPackages.Where(p => !p.IsPrerelease).Count(), resultSet.Count);
}
public async Task FindPackagesById_IncludesSemVerV2PackageVersionsWhenSemVerLevel2OrHigher(string semVerLevel)
{
// Act
var resultSet = await GetCollection <V2FeedPackage>(
(controller, options) => controller.FindPackagesById(options, id: TestPackageId, semVerLevel: semVerLevel),
$"/api/v2/FindPackagesById?id='{TestPackageId}'?semVerLevel={semVerLevel}");
// Assert
AssertSemVer2PackagesIncludedInResult(resultSet);
Assert.Equal(AllPackages.Count(), resultSet.Count);
}
public PackageGraph GetClosure(string packageId)
{
if (!AllPackages.TryGetValue(packageId, out var package))
{
return(null);
}
var allPackages = new Dictionary <string, Package>();
CollectPackages(package, allPackages);
return(new PackageGraph(PackageSources, allPackages, new[] { package }, Framework));
}
public void Update(float dt)
{
var packages = AllPackages.ToArray();
foreach (var resourcePackage in packages)
{
if (resourcePackage.ResourceRequestState != ResourceRequestState.OnItsWay)
{
continue;
}
resourcePackage.Update(dt);
}
}
public async Task SearchCount_IncludesSemVerV2PackageVersionsWhenSemVerLevel2OrHigher(string semVerLevel)
{
// Act
var searchCount = await GetInt <V2FeedPackage>(
async (controller, options) => await controller.SearchCount(
options,
searchTerm: TestPackageId,
includePrerelease: true,
semVerLevel: semVerLevel),
$"/api/v2/Search/$count?searchTerm='{TestPackageId}'&includePrerelease=true&semVerLevel={semVerLevel}");
// Assert
Assert.Equal(AllPackages.Count(), searchCount);
}
public async Task Search_IncludesSemVerV2PackageVersionsWhenSemVerLevel2OrHigher(string semVerLevel)
{
// Act
var resultSet = await GetCollection <V2FeedPackage>(
(controller, options) => controller.Search(
options,
searchTerm: TestPackageId,
includePrerelease: true,
semVerLevel: semVerLevel),
$"/api/v2/Search?searchTerm='{TestPackageId}'?includePrerelease=true&semVerLevel={semVerLevel}");
// Assert
AssertSemVer2PackagesIncludedInResult(resultSet);
Assert.Equal(AllPackages.Count(), resultSet.Count);
}
private async Task LoadPackages()
{
if (IsLoading)
{
// prevent concurrent loading
return;
}
IsLoading = true;
ErrorMessage = null;
AllPackages.Clear();
_downloadCancelSource = new CancellationTokenSource();
try
{
var versions = await _versionInfos();
var packageMetadataResource = await _repository.GetResourceAsync <PackageMetadataResource>(_downloadCancelSource.Token);
using (var sourceCacheContext = new SourceCacheContext())
{
var query = await packageMetadataResource.GetMetadataAsync(LatestPackageInfo.Id, ShowPrerelease, ShowPrerelease, sourceCacheContext, NullLogger.Instance, _downloadCancelSource.Token);
query = query.OrderByDescending(p => p.Identity.Version);
// now show packages
AllPackages.AddRange(query.Select(p => CreatePackageInfo(p, _feedType, versions)));
}
HasFinishedLoading = true;
}
catch (OperationCanceledException)
{
}
catch (Exception exception)
{
if (!(exception is FatalProtocolException) && !(exception is IOException) && !(exception is NullReferenceException))
{
DiagnosticsClient.TrackException(exception);
}
ErrorMessage = exception.GetBaseException().Message;
}
finally
{
_downloadCancelSource = null;
IsLoading = false;
}
}
public override bool Execute()
{
var pkgPath = Package.ItemSpec;
var defines = Defines.IsNullOrEmpty() ? new string[0] : Defines.Select(each => each.ItemSpec).ToArray();
try {
using (var script = new PackageScript(pkgPath)) {
if (PackageDirectory.Is())
{
script.AddNuGetPackageDirectory(PackageDirectory.GetFullPath());
}
if (defines != null)
{
foreach (var i in defines)
{
var p = i.IndexOf("=");
var k = p > -1 ? i.Substring(0, p) : i;
var v = p > -1 ? i.Substring(p + 1) : "";
script.AddMacro(k, v);
}
}
script.Save(PackageTypes.NuGet, true);
AllPackages = script.Packages.Select(each => (ITaskItem) new TaskItem(each)).ToArray();
RedistPackages = AllPackages.Where(each => each.ItemSpec.ToLower().IndexOf("redist") > -1).ToArray();
SymbolsPackages = AllPackages.Where(each => each.ItemSpec.ToLower().IndexOf("symbols") > -1).ToArray();
MainPackages = AllPackages.Where(each => each.ItemSpec.ToLower().IndexOf("redist") == -1 && each.ItemSpec.ToLower().IndexOf("symbols") == -1).ToArray();
foreach (var p in RedistPackages)
{
var n = Path.GetFileNameWithoutExtension(p.ItemSpec);
var o = n.IndexOf(".redist.");
p.SetMetadata("pkgIdentity", "{0} {1}".format(n.Substring(0, o + 7), n.Substring(o + 8)));
}
NuGetSuccess = true;
return(true);
}
} catch {
}
NuGetSuccess = false;
return(false);
}
public async Task GetUpdatesCount_IncludesSemVerV2PackageVersionsWhenSemVerLevel2OrHigher(string semVerLevel)
{
// Arrange
const string currentVersionString = "1.0.0";
var currentVersion = NuGetVersion.Parse(currentVersionString);
var expected = AllPackages.Where(p => NuGetVersion.Parse(p.Version) > currentVersion);
// Act
var searchCount = await GetInt <V2FeedPackage>(
(controller, options) => controller.GetUpdatesCount(
options,
packageIds: TestPackageId,
versions: currentVersionString,
includePrerelease: true,
includeAllVersions: true,
semVerLevel: semVerLevel),
$"/api/v2/GetUpdates()?packageIds='{TestPackageId}'&versions='{currentVersionString}'&includePrerelease=true&includeAllVersions=true&semVerLevel={semVerLevel}");
// Assert
Assert.Equal(expected.Count(), searchCount);
}
private async Task LoadPackages()
{
if (IsLoading)
{
// prevent concurrent loading
return;
}
IsLoading = true;
ErrorMessage = null;
AllPackages.Clear();
_downloadCancelSource = new CancellationTokenSource();
try
{
IQueryable <IPackage> query = _repository.GetPackagesById(LatestPackageInfo.Id, ShowPrerelease);
query = query.OrderByDescending(p => p.Published);
IQueryable <PackageInfo> packageInfos = GetPackageInfos(query, _repository);
PackageInfo[] packageInfoList = null;
bool resourceNotFoundError = false;
try
{
packageInfoList = await LoadData(packageInfos, _downloadCancelSource.Token);
}
catch (DataServiceQueryException ex)
{
resourceNotFoundError = IsResourceNotFoundError(ex);
if (!resourceNotFoundError)
{
throw;
}
}
// for a 404 error, use the legacy way to find packages by id,
// which requires filtering pre-release packages after the fact
if (resourceNotFoundError)
{
query = ((DataServicePackageRepository)_repository).LegacyGetPackagesById(LatestPackageInfo.Id);
packageInfos = GetPackageInfos(query, _repository);
packageInfoList = await LoadData(packageInfos, _downloadCancelSource.Token);
if (!ShowPrerelease)
{
packageInfoList = Array.FindAll(packageInfoList, p => !p.IsPrerelease);
}
}
var dataServiceRepository = _repository as DataServicePackageRepository;
if (dataServiceRepository != null)
{
foreach (PackageInfo entity in packageInfoList)
{
entity.DownloadUrl = dataServiceRepository.GetReadStreamUri(entity);
}
}
foreach (var p in packageInfoList)
{
p.ShowAll = true;
}
// now show packages
AllPackages.AddRange(packageInfoList);
HasFinishedLoading = true;
}
catch (OperationCanceledException)
{
}
catch (Exception exception)
{
ErrorMessage = exception.GetBaseException().Message;
}
finally
{
_downloadCancelSource = null;
IsLoading = false;
}
}
public IEnumerable <string> GetAssembliesFullPath() => AllPackages.SelectMany(p => p.Value.Assemblies.Select(a => a.ResolvedPath));
