async Task <PackageAssembly> TryResolveInDependencyAsync(AssemblyNameReference name, PackageDependency dep, ConcurrentDictionary <string, bool> searchedPackages, CancellationTokenSource cts)
{
var lowerPackageId = dep.PackageId.ToLowerInvariant();
if (searchedPackages.ContainsKey(lowerPackageId))
{
return(null);
}
searchedPackages.TryAdd(lowerPackageId, true);
try {
var package = await PackageData.GetAsync(dep.PackageId, dep.VersionSpec, cts.Token).ConfigureAwait(false);
if (cts.Token.IsCancellationRequested)
{
return(null);
}
var fw = package.FindClosestTargetFramework(packageTargetFramework.Moniker);
if (fw != null)
{
return(await TryResolveInFrameworkAsync(name, fw, searchedPackages, cts).ConfigureAwait(false));
}
}
catch {}
return(null);
}
public async Task <Stream> OpenAsync()
{
Debug.WriteLine("Downloading: " + this.FullName + " " + this.CompressedSize);
var url = this.Package.DownloadUrl;
var client = this.Package.Client;
var req = new HttpRequestMessage()
{
Method = HttpMethod.Get,
RequestUri = new Uri(url, UriKind.Absolute),
Version = new Version(1, 1),
};
PackageData.AddDataRequestHeaders(req);
req.Headers.Add("Range", "bytes=" + EntryOffset + "-" + (EntryOffset + 30 - 1));
var resp = await client.SendAsync(req);
var buf = await resp.Content.ReadAsByteArrayAsync();
var fileNameLen = buf.GetInt16(26);
var fileExtraLen = buf.GetInt16(28);
var ms = new MemoryStream(this.ExpandedSize);
req = new HttpRequestMessage()
{
Method = HttpMethod.Get,
RequestUri = new Uri(url, UriKind.Absolute),
Version = new Version(1, 1),
};
PackageData.AddDataRequestHeaders(req);
var deflateStart = EntryOffset + 30 + fileNameLen + fileExtraLen;
req.Headers.Add("Range", "bytes=" + deflateStart + "-" + (deflateStart + CompressedSize - 1));
resp = await client.SendAsync(req);
Stream stream = await resp.Content.ReadAsStreamAsync();
if (Mode == 8) // deflate
{
stream = new DeflateStream(stream, CompressionMode.Decompress, false);
}
else
{
if (Mode != 0) // store
{
throw new NotSupportedException("Compression mode " + Mode + " not supported");
}
}
stream.CopyTo(ms);
ms.Position = 0;
stream.Dispose();
return(ms);
}
protected override async Task <ApiDiff> GetValueAsync(Tuple <string, string, string> packageSpec, string otherVersion, CancellationToken token)
{
var packageId = packageSpec.Item1;
var version = packageSpec.Item2;
var inputFramework = packageSpec.Item3;
var package = await PackageData.GetAsync(packageId, version, token).ConfigureAwait(false);
var otherPackage = await PackageData.GetAsync(packageId, otherVersion, token).ConfigureAwait(false);
var framework = package.FindClosestTargetFramework(inputFramework);
var otherFramework = otherPackage.FindClosestTargetFramework(inputFramework);
return(await Task.Run(() => new ApiDiff (package, framework, otherPackage, otherFramework)).ConfigureAwait(false));
}
async Task <PackageAssembly> TryResolveInDependencyAsync(
AssemblyNameReference name,
PackageDependency dep,
ConcurrentDictionary <string, bool> searchedPackages,
ConcurrentQueue <PackageAssembly> found)
{
if (found.Count > 0)
{
return(null);
}
var lowerPackageId = dep.PackageId.ToLowerInvariant();
if (!searchedPackages.TryAdd(lowerPackageId, true))
{
return(null);
}
try {
var package = await PackageData.GetAsync(dep.PackageId, dep.VersionSpec, httpClient, CancellationToken.None).ConfigureAwait(false);
if (found.Count > 0)
{
return(null);
}
var fw = package.FindClosestTargetFramework(packageTargetFramework.Moniker);
if (fw != null)
{
var r = await TryResolveInFrameworkAsync(name, fw, searchedPackages, found).ConfigureAwait(false);
if (r != null)
{
found.Enqueue(r);
}
return(r);
}
}
catch (Exception ex) {
Debug.WriteLine(ex);
}
return(null);
}
public ApiDiff(PackageData package, PackageTargetFramework framework, PackageData otherPackage, PackageTargetFramework otherFramework)
{
this.Package = package;
this.Framework = framework;
this.OtherPackage = otherPackage;
this.OtherFramework = otherFramework;
if (otherFramework == null)
{
Error = $"Could not find framework matching \"{framework?.Moniker}\" in {otherPackage?.Id} {otherPackage?.Version}.";
return;
}
var asmDiff = OtherFramework.PublicAssemblies.Diff(Framework.PublicAssemblies, (x, y) => x.Definition.Name.Name == y.Definition.Name.Name);
var types = new List <TypeDiffInfo> ();
foreach (var aa in asmDiff.Actions)
{
IEnumerable <Tuple <TypeDefinition, PackageTargetFramework> > srcTypes;
IEnumerable <Tuple <TypeDefinition, PackageTargetFramework> > destTypes;
switch (aa.ActionType)
{
case ListDiffActionType.Add:
srcTypes = Enumerable.Empty <Tuple <TypeDefinition, PackageTargetFramework> > ();
destTypes = aa.DestinationItem.PublicTypes.Select(x => Tuple.Create(x, Framework));
break;
case ListDiffActionType.Remove:
srcTypes = aa.SourceItem.PublicTypes.Select(x => Tuple.Create(x, OtherFramework));
destTypes = Enumerable.Empty <Tuple <TypeDefinition, PackageTargetFramework> > ();
break;
default:
srcTypes = aa.SourceItem.PublicTypes.Select(x => Tuple.Create(x, OtherFramework));
destTypes = aa.DestinationItem.PublicTypes.Select(x => Tuple.Create(x, Framework));
break;
}
if (aa.ActionType == ListDiffActionType.Remove)
{
continue;
}
var typeDiff = srcTypes.Diff(destTypes, (x, y) => x.Item1.FullName == y.Item1.FullName);
foreach (var ta in typeDiff.Actions)
{
var ti = new TypeDiffInfo {
Action = ta.ActionType
};
IEnumerable <IMemberDefinition> srcMembers;
IEnumerable <IMemberDefinition> destMembers;
switch (ta.ActionType)
{
case ListDiffActionType.Add:
ti.Type = ta.DestinationItem.Item1;
ti.Framework = ta.DestinationItem.Item2;
srcMembers = Enumerable.Empty <IMemberDefinition> ();
destMembers = ti.Type.GetPublicMembers();
break;
case ListDiffActionType.Remove:
ti.Type = ta.SourceItem.Item1;
ti.Framework = ta.SourceItem.Item2;
srcMembers = ti.Type.GetPublicMembers();
destMembers = Enumerable.Empty <IMemberDefinition> ();
break;
default:
ti.Type = ta.DestinationItem.Item1;
ti.Framework = ta.DestinationItem.Item2;
srcMembers = ta.SourceItem.Item1.GetPublicMembers();
destMembers = ta.DestinationItem.Item1.GetPublicMembers();
break;
}
if (ta.ActionType == ListDiffActionType.Remove)
{
types.Add(ti);
continue;
}
var memDiff = srcMembers.Diff(destMembers, (x, y) => x.FullName == y.FullName);
foreach (var ma in memDiff.Actions)
{
var mi = new MemberDiffInfo {
Action = ma.ActionType
};
switch (ma.ActionType)
{
case ListDiffActionType.Add:
mi.Member = ma.DestinationItem;
ti.Members.Add(mi);
break;
case ListDiffActionType.Remove:
mi.Member = ma.SourceItem;
ti.Members.Add(mi);
break;
default:
mi.Member = ma.DestinationItem;
break;
}
}
if (ta.ActionType == ListDiffActionType.Add || ti.Members.Count > 0)
{
types.Add(ti);
}
}
}
foreach (var ns in types.GroupBy(x => x.Type.Namespace))
{
var ni = new NamespaceDiffInfo {
Action = ListDiffActionType.Update
};
ni.Namespace = ns.Key;
ni.Types.AddRange(ns);
Namespaces.Add(ni);
}
Namespaces.Sort((x, y) => string.Compare(x.Namespace, y.Namespace, StringComparison.Ordinal));
}
public PackageTargetFramework(PackageData package)
{
Package = package;
AssemblyResolver = new PackageAssemblyResolver(package.IndexId, this);
}
async Task <string> DeepFindTypeUrlAsync(string typeFullName, ConcurrentDictionary <string, bool> tried, ConcurrentQueue <string> found)
{
var url = FindTypeUrl(typeFullName, shallow: true);
if (url != null)
{
return(url);
}
if (found.Count > 0)
{
return(null);
}
var depFrameworks = new List <PackageTargetFramework> ();
var shallowDepPackages = Dependencies.Select(async x => {
if (!tried.TryAdd(x.PackageId, true))
{
return(null);
}
//Console.WriteLine ("TRY " + x.PackageId);
var data = await PackageData.GetAsync(x.PackageId, x.VersionSpec, CancellationToken.None).ConfigureAwait(false);
if (found.Count > 0)
{
return(null);
}
var fw = data.FindClosestTargetFramework(this.Moniker);
if (fw == null)
{
return(null);
}
depFrameworks.Add(fw);
var r = fw.FindTypeUrl(typeFullName, shallow: true);
if (r != null)
{
found.Enqueue(r);
}
return(r);
});
var shallowResults = await Task.WhenAll(shallowDepPackages).ConfigureAwait(false);
var shallowResult = shallowResults.FirstOrDefault(x => x != null);
if (shallowResult != null)
{
return(shallowResult);
}
var deepDepPackages = depFrameworks.Select(async fw => {
var r = await fw.DeepFindTypeUrlAsync(typeFullName, tried, found).ConfigureAwait(false);
if (r != null)
{
found.Enqueue(r);
}
return(r);
});
var results = await Task.WhenAll(deepDepPackages).ConfigureAwait(false);
return(results.FirstOrDefault(x => x != null));
}
public PackageSearchResults(PackageData package)
{
this.package = package;
}
public PackageTargetFramework(PackageData package, HttpClient httpClient)
{
this.httpClient = httpClient;
Package = package;
AssemblyResolver = new PackageAssemblyResolver(package.IndexId, this);
}
