示例#1
0
        private async Task AddTransitivePackages(string project, PackageList licenses, Package result)
        {
            var groups = result.Metadata?.Dependencies?.Group;

            if (_packageOptions.IncludeTransitive && groups != null)
            {
                foreach (var group in groups)
                {
                    var dependant =
                        group
                        .Dependency
                        .Select(e => $"{e.Id},{e.Version}")
                        .Where(e => !licenses.Keys.Contains(e));

                    var dependantPackages = await GetNugetInformationAsync(project, dependant);

                    foreach (var dependantPackage in dependantPackages)
                    {
                        if (!licenses.ContainsKey(dependantPackage.Key))
                        {
                            licenses.Add(dependantPackage.Key, dependantPackage.Value);
                        }
                    }
                }
            }
        }
示例#2
0
        private async Task ReadNuspecFile(string project, PackageList licenses, string packageWithVersion, Tuple <string, string> lookupKey, StreamReader textReader)
        {
            if (_serializer.Deserialize(new NamespaceIgnorantXmlTextReader(textReader)) is Package result)
            {
                licenses.Add(packageWithVersion, result);
                await this.AddTransitivePackages(project, licenses, result);

                _requestCache[lookupKey] = result;
                await HandleLicensing(result);
            }
        }
示例#3
0
        /// <summary>
        /// Get Nuget References per project
        /// </summary>
        /// <param name="project">project name</param>
        /// <param name="packages">List of projects</param>
        /// <returns></returns>
        public async Task <PackageList> GetNugetInformationAsync(string project, IEnumerable <string> packages)
        {
            WriteOutput(Environment.NewLine + "project:" + project + Environment.NewLine, logLevel: LogLevel.Information);
            var licenses = new PackageList();

            foreach (var packageWithVersion in packages)
            {
                try
                {
                    var split         = packageWithVersion.Split(',');
                    var packageId     = split[0];
                    var versionNumber = split[1];

                    if (string.IsNullOrWhiteSpace(packageId) || string.IsNullOrWhiteSpace(versionNumber))
                    {
                        WriteOutput($"Skipping invalid entry {packageWithVersion}", logLevel: LogLevel.Verbose);
                        continue;
                    }

                    if (_packageOptions.PackageFilter.Any(p => string.Compare(p, packageId, StringComparison.OrdinalIgnoreCase) == 0))
                    {
                        WriteOutput(packageId + " skipped by filter.", logLevel: LogLevel.Verbose);
                        continue;
                    }

                    var lookupKey = Tuple.Create(packageId, versionNumber);

                    if (_requestCache.TryGetValue(lookupKey, out var package))
                    {
                        WriteOutput(packageWithVersion + " obtained from request cache.", logLevel: LogLevel.Information);
                        licenses.TryAdd(packageWithVersion, package);
                        continue;
                    }

                    // Search nuspec in local cache
                    string userDir    = Environment.GetFolderPath(Environment.SpecialFolder.UserProfile);
                    var    nuspecPath = Path.Combine(userDir, ".nuget", "packages", packageId, versionNumber, packageId + ".nuspec");
                    if (File.Exists(nuspecPath))
                    {
                        try
                        {
                            using (var textReader = new StreamReader(nuspecPath))
                            {
                                await ReadNuspecFile(project, licenses, packageWithVersion, lookupKey, textReader);
                            }
                            continue;
                        }
                        catch
                        {
                            // Ignore errors in local cache, try online call
                        }
                    }

                    // Try dowload nuspec
                    using (var request = new HttpRequestMessage(HttpMethod.Get, $"{packageId}/{versionNumber}/{packageId}.nuspec"))
                        using (var response = await _httpClient.SendAsync(request))
                        {
                            if (!response.IsSuccessStatusCode)
                            {
                                WriteOutput($"{request.RequestUri} failed due to {response.StatusCode}!", logLevel: LogLevel.Warning);
                                var fallbackResult = await GetNuGetPackageFileResult <Package>(packageId, versionNumber, $"{packageId}.nuspec");

                                if (fallbackResult is Package)
                                {
                                    licenses.Add(packageWithVersion, fallbackResult);
                                    await this.AddTransitivePackages(project, licenses, fallbackResult);

                                    _requestCache[lookupKey] = fallbackResult;
                                    await HandleLicensing(fallbackResult);
                                }
                                else
                                {
                                    licenses.Add(packageWithVersion, new Package {
                                        Metadata = new Metadata {
                                            Version = versionNumber, Id = packageId
                                        }
                                    });
                                }

                                continue;
                            }

                            WriteOutput($"Successfully received {request.RequestUri}", logLevel: LogLevel.Information);
                            using (var responseText = await response.Content.ReadAsStreamAsync())
                                using (var textReader = new StreamReader(responseText))
                                {
                                    try
                                    {
                                        await ReadNuspecFile(project, licenses, packageWithVersion, lookupKey, textReader);
                                    }
                                    catch (Exception e)
                                    {
                                        WriteOutput(e.Message, e, LogLevel.Error);
                                        throw;
                                    }
                                }
                        }
                }
                catch (Exception ex)
                {
                    WriteOutput(ex.Message, ex, LogLevel.Error);
                }
            }

            return(licenses);
        }
示例#4
0
        /// <summary>
        /// Get Nuget References per project
        /// </summary>
        /// <param name="project">project name</param>
        /// <param name="packages">List of projects</param>
        /// <returns></returns>
        public async Task <PackageList> GetNugetInformationAsync(string project, IEnumerable <string> packages)
        {
            WriteOutput(Environment.NewLine + "project:" + project + Environment.NewLine, logLevel: LogLevel.Information);
            var licenses = new PackageList();

            foreach (var packageWithVersion in packages)
            {
                try
                {
                    var split         = packageWithVersion.Split(',');
                    var packageId     = split[0];
                    var versionNumber = split[1];

                    if (string.IsNullOrWhiteSpace(packageId) || string.IsNullOrWhiteSpace(versionNumber))
                    {
                        WriteOutput($"Skipping invalid entry {packageWithVersion}", logLevel: LogLevel.Verbose);
                        continue;
                    }

                    if (_packageOptions.PackageFilter.Any(p => string.Compare(p, packageId, StringComparison.OrdinalIgnoreCase) == 0))
                    {
                        WriteOutput(packageId + " skipped by filter.", logLevel: LogLevel.Verbose);
                        continue;
                    }

                    var lookupKey = Tuple.Create(packageId, versionNumber);

                    if (_requestCache.TryGetValue(lookupKey, out var package))
                    {
                        WriteOutput(packageWithVersion + " obtained from request cache.", logLevel: LogLevel.Information);
                        licenses.TryAdd(packageWithVersion, package);
                        continue;
                    }

                    using (var request = new HttpRequestMessage(HttpMethod.Get, $"{packageId}/{versionNumber}/{packageId}.nuspec"))
                        using (var response = await _httpClient.SendAsync(request))
                        {
                            if (!response.IsSuccessStatusCode)
                            {
                                WriteOutput($"{request.RequestUri} failed due to {response.StatusCode}!", logLevel: LogLevel.Warning);
                                var fallbackResult = await GetNuGetPackageFileResult <Package>(packageId, versionNumber, $"{packageId}.nuspec");

                                if (fallbackResult is Package)
                                {
                                    licenses.Add(packageWithVersion, fallbackResult);
                                    _requestCache[lookupKey] = fallbackResult;
                                    await HandleLicensing(fallbackResult);
                                }

                                continue;
                            }

                            WriteOutput($"Successfully received {request.RequestUri}", logLevel: LogLevel.Information);
                            using (var responseText = await response.Content.ReadAsStreamAsync())
                                using (var textReader = new StreamReader(responseText))
                                {
                                    try
                                    {
                                        if (_serializer.Deserialize(new NamespaceIgnorantXmlTextReader(textReader)) is Package result)
                                        {
                                            licenses.Add(packageWithVersion, result);
                                            _requestCache[lookupKey] = result;
                                            await HandleLicensing(result);
                                        }
                                    }
                                    catch (Exception e)
                                    {
                                        WriteOutput(e.Message, e, LogLevel.Error);
                                        throw;
                                    }
                                }
                        }
                }
                catch (Exception ex)
                {
                    WriteOutput(ex.Message, ex, LogLevel.Error);
                }
            }

            return(licenses);
        }
示例#5
0
        /// <summary>
        /// Get Nuget References per project
        /// </summary>
        /// <param name="project">project name</param>
        /// <param name="packages">List of projects</param>
        /// <returns></returns>
        public async Task <PackageList> GetNugetInformationAsync(string project, IEnumerable <PackageNameAndVersion> packages)
        {
            WriteOutput(Environment.NewLine + "project:" + project + Environment.NewLine, logLevel: LogLevel.Information);
            var licenses = new PackageList();

            foreach (var packageWithVersion in packages)
            {
                var versions = packageWithVersion.Version.Trim(new char[] { '[', ']', '(', ')' }).Split(",");
                foreach (var version in versions)
                {
                    try
                    {
                        if (string.IsNullOrWhiteSpace(packageWithVersion.Name) || string.IsNullOrWhiteSpace(version))
                        {
                            WriteOutput($"Skipping invalid entry {packageWithVersion}", logLevel: LogLevel.Verbose);
                            continue;
                        }

                        if (_packageOptions.PackageFilter.Any(p => string.Compare(p, packageWithVersion.Name, StringComparison.OrdinalIgnoreCase) == 0) ||
                            _packageOptions.PackageRegex?.IsMatch(packageWithVersion.Name) == true)
                        {
                            WriteOutput(packageWithVersion.Name + " skipped by filter.", logLevel: LogLevel.Verbose);
                            continue;
                        }

                        var lookupKey = Tuple.Create(packageWithVersion.Name, version);

                        if (_requestCache.TryGetValue(lookupKey, out var package))
                        {
                            WriteOutput(packageWithVersion + " obtained from request cache.", logLevel: LogLevel.Information);
                            licenses.TryAdd($"{packageWithVersion.Name},{version}", package);
                            continue;
                        }

                        // Search nuspec in local cache (Fix for linux distro)
                        string userDir = Environment.GetFolderPath(Environment.SpecialFolder.UserProfile);

                        var nuspecPath = CreateNuSpecPath(userDir, version, packageWithVersion.Name);
                        //Linux: package file name could be lowercase
                        if (IsLinux())
                        {
                            //Check package file
                            if (!File.Exists(nuspecPath))
                            {
                                //Try lowercase
                                nuspecPath = CreateNuSpecPath(userDir, version, packageWithVersion.Name?.ToLowerInvariant());
                            }
                        }

                        if (File.Exists(nuspecPath))
                        {
                            try
                            {
                                using var textReader = new StreamReader(nuspecPath);
                                await ReadNuspecFile(project, licenses, packageWithVersion.Name, version, lookupKey, textReader);

                                continue;
                            }
                            catch (Exception exc)
                            {
                                // Ignore errors in local cache, try online call
                                WriteOutput($"ReadNuspecFile error, package '{packageWithVersion.Name}'", exc, LogLevel.Verbose);
                            }
                        }
                        else
                        {
                            WriteOutput($"Package '{packageWithVersion.Name}' not found in local cache ({nuspecPath})..", logLevel: LogLevel.Verbose);
                        }

                        // Try dowload nuspec
                        using var request  = new HttpRequestMessage(HttpMethod.Get, $"{packageWithVersion.Name}/{version}/{packageWithVersion.Name}.nuspec");
                        using var response = await _httpClient.SendAsync(request);

                        if (!response.IsSuccessStatusCode)
                        {
                            WriteOutput($"{request.RequestUri} failed due to {response.StatusCode}!", logLevel: LogLevel.Warning);
                            var fallbackResult = await GetNuGetPackageFileResult <Package>(packageWithVersion.Name, version, $"{packageWithVersion.Name}.nuspec");

                            if (fallbackResult is Package)
                            {
                                licenses.Add($"{packageWithVersion.Name},{version}", fallbackResult);
                                await this.AddTransitivePackages(project, licenses, fallbackResult);

                                _requestCache[lookupKey] = fallbackResult;
                                await HandleLicensing(fallbackResult);
                            }
                            else
                            {
                                licenses.Add($"{packageWithVersion.Name},{version}", new Package {
                                    Metadata = new Metadata {
                                        Version = version, Id = packageWithVersion.Name
                                    }
                                });
                            }

                            continue;
                        }

                        WriteOutput($"Successfully received {request.RequestUri}", logLevel: LogLevel.Information);
                        using (var responseText = await response.Content.ReadAsStreamAsync())
                            using (var textReader = new StreamReader(responseText))
                            {
                                try
                                {
                                    await ReadNuspecFile(project, licenses, packageWithVersion.Name, version, lookupKey, textReader);
                                }
                                catch (Exception e)
                                {
                                    WriteOutput(e.Message, e, LogLevel.Error);
                                    throw;
                                }
                            }
                    }
                    catch (Exception ex)
                    {
                        WriteOutput(ex.Message, ex, LogLevel.Error);
                    }
                }
            }

            return(licenses);