public static bool IsMatchRegistrationsBaseUrl(
this INugetServerProvider provider,
HttpContext context)
{
if (!provider.IsMatchVerbs(context,
HttpMethods.IsHead,
HttpMethods.IsGet))
{
return(false);
}
return(provider.IsMatchResources(
context,
NugetServerResourceType.RegistrationsBaseUrl,
NugetServerResourceType.RegistrationsBaseUrl_3_0_0_beta,
NugetServerResourceType.RegistrationsBaseUrl_3_0_0_rc
/*
* Gzip does NOT work.
*/
//,
//NugetServerResourceType.RegistrationsBaseUrl_3_4_0,
//NugetServerResourceType.RegistrationsBaseUrl_3_6_0
) &&
provider.IsMatchExtensionName(context, ".json"));
}
GetRequstingPackageBaseAddressModel(
this INugetServerProvider provider,
HttpContext context)
=> new PackageBaseAddressInputModel(
context.GetBaseUrl(), context.Request.Path,
provider.GetResourceUrlPath(
NugetServerResourceType.PackageBaseAddress));
ParseResource(this INugetServerProvider provider,
HttpContext context)
{
var resources = provider
?.NugetServerOptions
?.Resources
?.Select(r => r.Key);
if (resources == null)
{
yield break;
}
var baseUrl = context.GetBaseUrl();
foreach (var resource in resources)
{
var model = new ServerIndexResourceModel
{
Type = resource.GetText(),
Id = baseUrl + provider
.GetResourceUrlPath(resource)
};;
yield return(model);
}
}
public static async Task RespondPackagePublishAsync(
this INugetServerProvider provider,
HttpContext context)
{
var req = provider.GetRequestingModel(context);
if (!req.IsValid())
{
provider.RespondNotFound(context);
return;
}
if (!provider.IsValidApiKey(req))
{
provider.RespondNotFound(context);
return;
}
if (req.IsPush())
{
await provider
.RespondPutPackageAsync(context, req);
return;
}
if (req.IsDelete())
{
await provider
.RespondDeletePackageAsync(context, req);
return;
}
provider.RespondNotFound(context);
}
RedirectToCurrentApiVersion(
this INugetServerProvider provider,
HttpContext context,
bool permanent = true)
{
var currentVersion = provider.GetApiMajorVersionUrl();
var paths = context.Request.Path
.ToString()
.Split(new[] { '/' },
StringSplitOptions.RemoveEmptyEntries);
string newPath = currentVersion;
if (paths.Length > 0)
{
var otherPaths = paths.Skip(1);
if (otherPaths.Any())
{
newPath = newPath + "/" + string.Join("/", otherPaths);
}
}
if (context.Request.QueryString.HasValue)
{
newPath += context.Request.QueryString.Value;
}
context.Response.Redirect(newPath, permanent);
}
public static async Task RespondPackageBaseAddressAsync(
this INugetServerProvider provider,
HttpContext context)
{
var req = provider
.GetRequstingPackageBaseAddressModel(
context);
if (!req.IsValid())
{
provider.RespondNotFound(context);
return;
}
if (req.IsRequestingVersions())
{
await provider.RespondVersionsAsync(context, req);
return;
}
if (req.IsRequestingNuspec())
{
await provider.RespondNuspecAsync(context, req);
return;
}
if (req.IsRequestingNupkg())
{
await provider.RespondNupkgAsync(context, req);
return;
}
provider.RespondNotFound(context);
}
GetRequestingModel(
this INugetServerProvider provider,
HttpContext context)
=> new PackageInputModel(
context.Request.Method,
context.Request.GetTypedHeaders(),
context.Request.Path);
public static Task RespondPackagePublishV2CompatibleAsync(
this INugetServerProvider provider,
HttpContext context)
{
provider.RedirectToCurrentApiVersion(context);
return(Task.CompletedTask);
}
RespondDeletePackageAsync(
this INugetServerProvider provider,
HttpContext context,
PackageInputModel request)
{
var packages =
provider
.NuspecProvider
.GetAll()
.Where(n => n.Metadata != null)
.Where(n => string.Equals(
n.Metadata.Id, request.Id,
StringComparison
.InvariantCultureIgnoreCase))
.Where(n =>
(NuGetVersionString)n.Metadata.Version
== request.Version)
.ToList();
if (packages.Count < 1)
{
provider.RespondNotFound(context);
return;
}
foreach (var package in packages)
{
await provider.NupkgProvider
.DeleteAsync(package,
context.RequestAborted);
}
}
CreateJsonSerializerForServiceIndex(
this INugetServerProvider provider)
{
var serializer = provider.CreateJsonSerializer();
serializer.ContractResolver
= new ServerIndexContractResolver();
return(serializer);
}
private static RegistrationInputModel GetRequestingMetadata(
this INugetServerProvider provider,
HttpContext context)
{
var model = new RegistrationInputModel(
context.GetBaseUrl(),
context.Request.Path);
return(model);
}
public static async Task RespondRegistrationsBaseUrlAsync(
this INugetServerProvider provider,
HttpContext context)
{
var excludeSemVer2Package = true;
var useGzip = false;
/*
* Gzip does NOT work.
*/
//if (provider.IsMatchResource(context,
// NugetServerResourceType.RegistrationsBaseUrl_3_6_0))
//{
// useGzip = true;
// excludeSemVer2Package = false;
//}
//if (provider.IsMatchResource(context,
// NugetServerResourceType.RegistrationsBaseUrl_3_4_0))
//{
// useGzip = true;
//}
var req = provider.GetRequestingMetadata(context);
if (!req.IsValid())
{
provider.RespondNotFound(context);
return;
}
var nuspecs = provider.NuspecProvider.GetAll()
.Where(nuspec => nuspec.Metadata != null)
.Where(n => n.Metadata.Id.ToLowerInvariant()
== req.Id)
.Where(n => excludeSemVer2Package == false ||
!((NuGetVersionString)n.Metadata.Version).IsSemVer2);
if (!nuspecs.Any())
{
provider.RespondNotFound(context);
return;
}
if (req.IsRequestingIndex())
{
await provider.RespondRegistrationIndexAsync(
context, req, nuspecs,
useGzip : useGzip);
return;
}
if (req.IsRequestingPage())
{
//Do some stuff...
return;
}
provider.RespondNotFound(context);
}
private static PathString GetServiceIndexUrlPath(
this INugetServerProvider provider)
{
var majorVersion = provider
.GetApiMajorVersionUrl();
var path = provider
?.NugetServerOptions
?.ServiceIndex
?? throw new InvalidOperationException(
"Nuget server index not specified.");
return(majorVersion + path);
}
private static async Task RespondNuspecAsync(
this INugetServerProvider provider,
HttpContext context,
PackageBaseAddressInputModel request)
{
var nuspec = provider.NuspecProvider
.GetAll()
.Where(n => n.Metadata != null)
.Where(n => n.Metadata.Id.ToLowerInvariant() == request.Id)
.FirstOrDefault(n => n.Metadata.Version == request.Version);
var nuspecRaw = await Zip.ReadNuspecRawAsync(nuspec);
await provider.WriteRawResponseAsync(
context, "application/xml; charset=utf8", nuspecRaw);
}
public static bool IsMatchServerIndex(
this INugetServerProvider provider,
HttpContext context)
{
if (!provider.IsMatchVerbs(context,
HttpMethods.IsHead,
HttpMethods.IsGet))
{
return(false);
}
return(provider.IsMatchPath(context,
provider.GetServiceIndexUrlPath()) &&
provider
.IsMatchExtensionName(context, ".json"));
}
public static bool IsMatchPackagePublishV2Compatible(
this INugetServerProvider provider,
HttpContext context)
{
if (!provider.IsMatchVerbs(context,
HttpMethods.IsPut,
HttpMethods.IsDelete))
{
return(false);
}
return(provider.IsMatchResourceIgnoreApiVersion(
context,
NugetServerResourceType.PackagePublish
));
}
private static async Task RespondVersionsAsync(
this INugetServerProvider provider,
HttpContext context,
PackageBaseAddressInputModel request)
{
var model = new PackageBaseAddressVersionsOutputModel
{
Versions = provider.NuspecProvider
.GetAll()
.Where(n => n.Metadata != null)
.Where(n => n.Metadata.Id.ToLowerInvariant() == request.Id)
.Select(n => n.Metadata.Version)
.OrderBy(x => (NuGetVersionString)x)
.ToList()
};
await provider.WriteJsonResponseAsync(context, model);
}
public static bool IsMatchPackageBaseAddress(
this INugetServerProvider provider,
HttpContext context
)
{
if (!provider.IsMatchVerbs(context,
HttpMethods.IsHead,
HttpMethods.IsGet))
{
return(false);
}
return(provider.IsMatchResource(
context,
NugetServerResourceType.PackageBaseAddress
));
}
public static JsonSerializer CreateJsonSerializer(
this INugetServerProvider provider)
{
return(new JsonSerializer
{
NullValueHandling
= NullValueHandling.Ignore,
Formatting =
#if DEBUG
Formatting.Indented,
#else
provider
.MvcJsonOptions
.SerializerSettings.Formatting,
#endif
ContractResolver
= new CamelCasePropertyNamesContractResolver()
});
public static async Task RespondServerIndexAsync(
this INugetServerProvider provider,
HttpContext context)
{
var serverIndex = new ServerIndexModel(
provider.ParseResource(context))
{
Version = provider
.NugetServerOptions
.ApiVersion
.ToFullString(),
Context = ServerIndexContext.Default
};
await provider
.WriteJsonResponseAsync(
context, serverIndex, provider
.CreateJsonSerializerForServiceIndex());
}
public static bool IsMatchSearchQueryService(
this INugetServerProvider provider,
HttpContext context)
{
if (!provider.IsMatchVerbs(context,
HttpMethods.IsHead,
HttpMethods.IsGet))
{
return(false);
}
return(provider.IsMatchResources(
context,
NugetServerResourceType
.SearchQueryService,
NugetServerResourceType
.SearchQueryService_3_0_0_beta,
NugetServerResourceType
.SearchQueryService_3_0_0_rc
));
}
private static async Task RespondNupkgAsync(
this INugetServerProvider provider,
HttpContext context,
PackageBaseAddressInputModel request)
{
var nupkg = provider.NuspecProvider
.GetAll()
.Where(n => n.Metadata != null)
.Where(n => n.Metadata.Id.ToLowerInvariant() == request.Id)
.Where(n => n.Metadata.Version == request.Version)
.FirstOrDefault()
;
if (nupkg == null)
{
provider.RespondNotFound(context);
return;
}
var fileInfo = new PhysicalFileInfo(
new FileInfo(nupkg.FilePath));
await context.Response.SendFileAsync(
fileInfo, context.RequestAborted);
}
RespondPutPackageAsync(
this INugetServerProvider provider,
HttpContext context,
PackageInputModel request)
{
if (!context.Request.HasFormContentType)
{
provider.RespondWithStatusCode(
context, HttpStatusCode.BadRequest);
return;
}
try
{
var form = await context.Request.ReadFormAsync(context.RequestAborted);
var formFile = form?.Files?.FirstOrDefault();
if (formFile == null)
{
provider.RespondWithStatusCode(
context, HttpStatusCode.BadRequest);
return;
}
using (var formFileStream = formFile.OpenReadStream())
using (var inputStream = new MemoryStream())
{
await formFileStream
.CopyToAsync(inputStream);
inputStream.Seek(0, SeekOrigin.Begin);
var nuspec = await
Zip.ReadNuspecFromPackageAsync(
inputStream);
if (nuspec?.Metadata == null)
{
provider.RespondWithStatusCode(
context, HttpStatusCode.BadRequest);
return;
}
var packages =
provider
.NuspecProvider
.GetAll()
.Where(n => n.Metadata != null)
.Where(n => string.Equals(
n.Metadata.Id, nuspec.Metadata.Id,
StringComparison
.InvariantCultureIgnoreCase))
.Where(n =>
(NuGetVersionString)n.Metadata.Version
== nuspec.Metadata.Version)
.ToList();
if (packages.Count != 0)
{
provider.RespondWithStatusCode(
context, HttpStatusCode.Conflict);
return;
}
inputStream.Seek(0, SeekOrigin.Begin);
var isAdded = await provider.NupkgProvider.AddAsync(
nuspec.Metadata,
inputStream, context.RequestAborted);
if (isAdded)
{
provider.RespondWithStatusCode(
context, HttpStatusCode.Created);
return;
}
}
}
catch
{
}
provider.RespondWithStatusCode(
context,
HttpStatusCode.InternalServerError);
}
public NugetServerPackageBaseAddressMiddleware(
INugetServerProvider nugetServerProvider)
{
this._nugetServerProvider = nugetServerProvider;
}
public NugetServerIndexMiddleware(
INugetServerProvider nugetServerProvider)
{
this._nugetServerProvider = nugetServerProvider;
}
public NugetServerSearchQueryServiceMiddleware(
INugetServerProvider nugetServerProvider)
{
this._nugetServerProvider = nugetServerProvider;
}
public RegistrationsBaseUrlMiddleware(
INugetServerProvider nugetServerProvider)
{
this._nugetServerProvider = nugetServerProvider;
}
public NugetServerPackagePublishMiddleware(
INugetServerProvider nugetServerProvider)
{
this._nugetServerProvider = nugetServerProvider;
}
private static async Task RespondRegistrationIndexAsync(
this INugetServerProvider provider,
HttpContext context,
RegistrationInputModel registrationInput,
IEnumerable <Nuspec> nuspecs,
bool useGzip = false)
{
var nuspecList = nuspecs
.Select(x => new { Nuspec = x, Version = (NuGetVersionString)x.Metadata.Version })
.OrderBy(x => x.Version)
.Select(x => x.Nuspec)
.ToList();
var lowest = nuspecList.First().Metadata;
var uppest = nuspecList.Last().Metadata;
var parent = registrationInput.BaseUrl + registrationInput.Path;
var lowestVersion = SemanticVersion.Parse(lowest.Version).ToFullString();
var uppestVersion = SemanticVersion.Parse(uppest.Version).ToFullString();
var packageContentBase = registrationInput.BaseUrl +
provider.GetResourceUrlPath(NugetServerResourceType.PackageBaseAddress);
var model = new RegistrationIndexOutputModel
{
Count = nuspecList.Count
};
foreach (var nuspec in nuspecList)
{
var publishTime = new DateTimeOffset(new FileInfo(nuspec.FilePath).LastWriteTimeUtc);
var metadata = nuspec.Metadata;
var modelItem = new RegistrationPageOutputModel()
{
Id = $"{registrationInput.BaseUrl}{registrationInput.Path}#page/{metadata.Version}/{metadata.Version}",
Count = nuspecList.Count,
Lower = lowestVersion,
Upper = uppestVersion,
};
// If present Items, MUST also present Parent,Id need NOT be used.
modelItem.Parent = parent;
modelItem.Items = new List <RegistrationLeafOutputModel>()
{
new RegistrationLeafOutputModel
{
Id = registrationInput.BaseUrl +
registrationInput.PathBase +
$"/{metadata.Version}.json",
PackageContent = packageContentBase +
$"/{metadata.Id.ToLowerInvariant()}" +
$"/{metadata.Version.ToLowerInvariant()}" +
$"/{metadata.Id.ToLowerInvariant()}" +
$".{metadata.Version.ToLowerInvariant()}.nupkg",
Registration = registrationInput.BaseUrl +
registrationInput.Path,
CatalogEntry = new RegistrationCatalogEntryOutputModel
{
Id_alias = registrationInput.BaseUrl +
registrationInput.PathBase +
$"/{metadata.Version}.json",
Id = metadata.Id,
Authors = metadata.Authors,
Description = metadata.Description,
ProjectUrl = metadata.ProjectUrl,
IconUrl = metadata.IconUrl,
Summary = metadata.ReleaseNotes ?? metadata.Description,
Tags = metadata.Tags?.Split(
new[] { ',' },
StringSplitOptions.RemoveEmptyEntries)
?.ToList() ?? new List <string>(0),
Title = metadata.Id,
Version = metadata.Version,
LicenseUrl = metadata.LicenseUrl,
Listed = !provider.PackageStatusProvider.IsDeleted(metadata.Id, metadata.Version),
RequireLicenseAcceptance = metadata.RequireLicenseAcceptance,
PackageContent = packageContentBase +
$"/{metadata.Id.ToLowerInvariant()}" +
$"/{metadata.Version.ToLowerInvariant()}" +
$"/{metadata.Id.ToLowerInvariant()}" +
$".{metadata.Version.ToLowerInvariant()}.nupkg",
Published = publishTime,
DependencyGroups = metadata.Dependencies
.Select(deps =>
new RegistrationDependencyGroupOutputModel
{
//Id_alias = ""
TargetFramework = deps.TargetFramework,
Dependencies = deps.Dependency.Select(dep =>
new RegistrationDependencyOutputModel
{
Id = dep.Id,
//Id_Alias = "",
Range = dep.Version,
Registration = registrationInput.BaseUrl +
registrationInput.Path
}).ToList()
}).ToList()
}
}
};
model.Items.Add(modelItem);
}
await provider.WriteJsonResponseAsync(context, model, useGzip : useGzip);
}
RespondSearchQueryServiceAsync(
this INugetServerProvider provider,
HttpContext context)
{
var registrationsBaseUrl = context.GetBaseUrl() +
provider.GetResourceUrlPath(
NugetServerResourceType.RegistrationsBaseUrl);
var searchInputModel = context.FromQueryString
<SearchInputModel>();
var searchOutputModel = new SearchOutputModel();
var metadata_versions =
provider.NuspecProvider
.GetAll()
.Where(nuspec => nuspec.Metadata != null)
.Select(nuspec => new
{
nuspec.Metadata,
Version = (NuGetVersionString)
nuspec.Metadata.Version
})
.Where(mv =>
searchInputModel.SemVerLevel?.Major != 1
? true
: !mv.Version.IsSemVer2)
.Where(mv =>
searchInputModel.PreRelease
? true
: !mv.Version.IsPrerelease)
.OrderBy(mv => mv.Metadata.Id)
.GroupBy(mv => mv.Metadata.Id)
.Where(mv => string.IsNullOrWhiteSpace(
searchInputModel.Q) ||
mv.Key.ToLowerInvariant()
.Contains(searchInputModel.Q
.ToLowerInvariant()))
.ToList();
var takes = metadata_versions
.Skip(searchInputModel.Skip)
.Take(searchInputModel.Take)
.ToList();
searchOutputModel.TotalHits =
metadata_versions.Count;
foreach (var path_metadata in takes)
{
var packageId = path_metadata.Key;
var packageIdLowerInvariant =
packageId.ToLowerInvariant();
var metadatas = path_metadata
.Select(x => x.Metadata)
.OrderBy(x => x.Version)
.ToList();
var latest = metadatas.Last();
searchOutputModel.Data.Add(new SearchResultModel
{
Id = latest.Id,
Authors = latest.Authors?.Split(
new[] { ',' },
StringSplitOptions.RemoveEmptyEntries)
?.ToList() ?? new List <string>(0),
Description = latest.Description,
Owners = latest.Owners?.Split(
new[] { ',' },
StringSplitOptions.RemoveEmptyEntries)
?.ToList() ?? new List <string>(0),
ProjectUrl = latest.ProjectUrl,
IconUrl = latest.IconUrl,
Registration = $"{registrationsBaseUrl}/{packageIdLowerInvariant}/index.json",
Id_alias = $"{registrationsBaseUrl}/{packageIdLowerInvariant}/index.json",
Summary = latest.ReleaseNotes
?? latest.Description,
Tags = latest.Tags?.Split(
new[] { ',' },
StringSplitOptions.RemoveEmptyEntries)
?.ToList() ?? new List <string>(0),
Title = latest.Id,
Version = (NuGetVersionString)latest.Version,
LicenseUrl = latest.LicenseUrl,
Versions = metadatas.Select(m => new
SearchResultPackageVersionModel
{
Id = $"{registrationsBaseUrl}/{packageIdLowerInvariant}/{m.Version}.json",
Version = (NuGetVersionString)m.Version
}).ToList(),
});
}
await provider
.WriteJsonResponseAsync(
context, searchOutputModel);
}
