Beispiel #1
0
        public async Task <IFileSource> GetFileAsync(VersionSpec version)
        {
            if (Credentials == null)
            {
                _logger.LogCritical("Repo details not found! Please add GitHubStorage to your app configuration and restart the server.");
                throw new UnauthorizedAccessException("Repository details not found in configuration!");
            }
            try
            {
                var releases = await Client.Repository.Release.GetAll(Credentials.Owner, Credentials.Repo);

                if (MatchStrategy == null)
                {
                    foreach (var release in releases)
                    {
                        var asset = release.Assets.FirstOrDefault(a => PatternMatcher.Match(a.Name, version));
                        if (asset != null)
                        {
                            var source = new GitHubFileSource(version, !release.Draft);
                            source.Build(asset);
                            return(source);
                        }
                    }
                    throw new VersionNotFoundException();
                }
                return(await MatchStrategy.MatchAsync(releases, version));
            }
            catch (RateLimitExceededException)
            {
                throw new VersionNotFoundException("GitHub API rate limit exceeded! Unable to fetch releases. Please add an API token to the `GitHubStorage/ApiToken` configuration key.");
            }
        }
Beispiel #2
0
        public override Task <IFileSource> MatchAsync(IEnumerable <Release> releases, VersionSpec version)
        {
            var release = _enableLatestTag
                ? releases
                          .Where(r => !r.Draft)
                          .Where(r => !r.Prerelease)
                          .OrderByDescending(r => r.PublishedAt)
                          .FirstOrDefault()
                : releases.FirstOrDefault(r => r.TagName == version)
                          ?? releases.FirstOrDefault(r => r.Name == version);

            if (release == null)
            {
                throw new VersionNotFoundException($"Could not find release for version '{version}'");
            }
            _logger.LogDebug("Found release {0} with {1} assets", release.Name, release.Assets.Count);
            var opts = release.Assets.ToDictionary(a => ParseSpec(a.Name, _splitCharacters.ToArray()), a => a);

            _logger.LogDebug("Found releases: {0}", opts.Keys.Select(k => k.Summary));
            var platforms = opts.Where(v => v.Key.Platform.ToLower() == version.Platform.ToLower()).ToList();

            if (!platforms.Any())
            {
                throw new PlatformNotFoundException($"Could not find platform '{version.Platform}' for version '{version}'");
            }
            _logger.LogDebug("Found platform match for {0} releases: {1}", platforms.Count, platforms.Select(p => p.Key.Summary));
            var archs = platforms.Where(a => a.Key.Architecture.ToLower() == version.Architecture.ToLower()).ToList();

            if (!archs.Any())
            {
                throw new ArchitectureNotFoundException($"Could not find requested architecture '{version.Architecture}' for version '{version}'");
            }
            _logger.LogDebug("Found architecture match for {0} assets: {1}", archs.Count, archs.Select(a => a.Key.Summary));
            var file = new GitHubFileSource(archs.First().Key, !release.Draft);

            file.Build(archs.First().Value);
            return(Task.FromResult(file as IFileSource));
        }