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); }