assets_fetcher.go

// Copyright (C) 2023 Gobalsky Labs Limited
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.

package github

import (
	"context"
	"fmt"
	"io/ioutil"
	"net/http"
	"os"
	"path"
	"path/filepath"
	"time"

	"code.vegaprotocol.io/vega/visor/utils"
	"github.com/google/go-github/v50/github"
	"golang.org/x/sync/errgroup"
)

const zipMimeType = "application/zip"

type AssetsFetcher struct {
	repositoryOwner string
	repository      string

	assetNames map[string]struct{}

	*github.Client
}

func NewAssetsFetcher(
	repositoryOwner, repository string,
	assetsNames []string,
) *AssetsFetcher {
	return &AssetsFetcher{
		repositoryOwner: repositoryOwner,
		repository:      repository,
		assetNames:      utils.ToLookupMap(assetsNames),
		Client:          github.NewClient(nil),
	}
}

func (af *AssetsFetcher) GetReleaseID(ctx context.Context, releaseTag string) (int64, error) {
	nextPage := 1
	opts := &github.ListOptions{
		PerPage: 100,
		Page:    nextPage,
	}

	for nextPage > 0 {
		opts.Page = nextPage
		releases, resp, err := af.Client.Repositories.ListReleases(ctx, af.repositoryOwner, af.repository, opts)
		if err != nil {
			return 0, err
		}
		nextPage = resp.NextPage
		for _, r := range releases {
			if *r.TagName == releaseTag {
				return r.GetID(), nil
			}
		}
	}
	return 0, fmt.Errorf("release tag %q not found", releaseTag)
}

func (af *AssetsFetcher) GetAssets(ctx context.Context, releaseID int64) ([]*github.ReleaseAsset, error) {
	assets, _, err := af.Client.Repositories.ListReleaseAssets(ctx, af.repositoryOwner, af.repository, releaseID, nil)
	if err != nil {
		return nil, err
	}

	var filteredAssets []*github.ReleaseAsset
	for _, asset := range assets {
		if _, ok := af.assetNames[asset.GetName()]; ok {
			filteredAssets = append(filteredAssets, asset)
		}
	}

	return filteredAssets, nil
}

func (af *AssetsFetcher) DownloadAsset(ctx context.Context, assetID int64, assetType, path string) error {
	followClient := &http.Client{Timeout: time.Second * 120}

	ra, _, err := af.Client.Repositories.DownloadReleaseAsset(ctx, af.repositoryOwner, af.repository, assetID, followClient)
	if err != nil {
		return fmt.Errorf("failed to download release asset: %w", err)
	}
	defer ra.Close()

	all, err := ioutil.ReadAll(ra)
	if err != nil {
		return fmt.Errorf("failed to read  %q: %w", path, err)
	}

	if err := os.WriteFile(path, all, 0o770); err != nil {
		return fmt.Errorf("failed to write to %q: %w", path, err)
	}

	if assetType == zipMimeType {
		if err := utils.UnzipSource(path, filepath.Dir(path)); err != nil {
			return fmt.Errorf("failed to unzip asset: %w", err)
		}
	}

	return nil
}

func (af *AssetsFetcher) Download(ctx context.Context, releaseTag, downloadDir string) error {
	releaseID, err := af.GetReleaseID(ctx, releaseTag)
	if err != nil {
		return fmt.Errorf("failed to get release ID for tag %q: %q", releaseTag, err)
	}

	assetIDs, err := af.GetAssets(ctx, releaseID)
	if err != nil {
		return fmt.Errorf("failed to get assets ID for tag %q: %q", releaseTag, err)
	}

	eg, ctx := errgroup.WithContext(ctx)
	for _, asset := range assetIDs {
		assetID := asset.GetID()
		assetName := asset.GetName()
		assetType := asset.GetContentType()

		eg.Go(func() error {
			if err := af.DownloadAsset(ctx, assetID, assetType, path.Join(downloadDir, assetName)); err != nil {
				return fmt.Errorf("failed to download asset %q of type %q for tag %q: %w", assetName, releaseTag, assetType, err)
			}
			return nil
		})
	}

	return eg.Wait()
}