asset/download: support arch aliases

Some assets have multiple ways to refer to the same arch.

e.g: amd64 -> x86_64

To support this, users can add fallback arch to the Downloader.

release/asset/download.go

@@ -28,9 +28,10 @@ type Info struct {
 }
 
 type downloader struct {
-	os             string
-	arch           string
-	executablePath string
+	os                 string
+	arch               string
+	lookupArchFallback map[string]string
+	executablePath     string
 }
 
 var _ Downloader = (*downloader)(nil)
@@ -49,11 +50,18 @@ func WithArch(arch string) AssetDownloadOpt {
 	}
 }
 
+func WithLookupArchFallback(lookupArchFallback map[string]string) AssetDownloadOpt {
+	return func(d *downloader) {
+		d.lookupArchFallback = lookupArchFallback
+	}
+}
+
 func NewAssetDownloader(executablePath string, opts ...AssetDownloadOpt) Downloader {
 	d := &downloader{
-		os:             runtime.GOOS,
-		arch:           runtime.GOARCH,
-		executablePath: executablePath,
+		os:                 runtime.GOOS,
+		arch:               runtime.GOARCH,
+		executablePath:     executablePath,
+		lookupArchFallback: map[string]string{},
 	}
 	for _, opt := range opts {
 		opt(d)
@@ -66,12 +74,35 @@ var ErrNoAsset = errors.New("no asset found")
 func (d *downloader) DownloadAsset(ctx context.Context, assets []release.Asset) (*Info, cleanupFn, error) {
 	// iterate through the assets and find the one that matches the os and arch
 	suffix := d.os + "_" + d.arch
+	asset, found := d.assetForSuffix(assets, suffix)
+	if found {
+		return d.downloadAsset(ctx, asset.BrowserDownloadURL)
+	}
+	// if asset not found, try a fallback. e.g amd64 -> x86_64
+	if d.lookupArchFallback == nil || len(d.lookupArchFallback) == 0 {
+		return nil, nil, fmt.Errorf("%w: os:%s arch:%s", ErrNoAsset, d.os, d.arch)
+	}
+
+	fallbackArch, ok := d.lookupArchFallback[d.arch]
+	if !ok {
+		return nil, nil, fmt.Errorf("%w: os:%s arch:%s", ErrNoAsset, d.os, d.arch)
+	}
+
+	fallbackSuffix := d.os + "_" + fallbackArch
+	asset, found = d.assetForSuffix(assets, fallbackSuffix)
+	if found {
+		return d.downloadAsset(ctx, asset.BrowserDownloadURL)
+	}
+	return nil, nil, fmt.Errorf("%w: os:%s arch:%s", ErrNoAsset, d.os, d.arch)
+}
+
+func (d *downloader) assetForSuffix(assets []release.Asset, suffix string) (release.Asset, bool) {
 	for _, asset := range assets {
 		if strings.HasSuffix(asset.BrowserDownloadURL, suffix) {
-			return d.downloadAsset(ctx, asset.BrowserDownloadURL)
+			return asset, true
 		}
 	}
-	return nil, nil, fmt.Errorf("%w: os:%s arch:%s", ErrNoAsset, d.os, d.arch)
+	return release.Asset{}, false
 }
 
 func (d *downloader) downloadAsset(ctx context.Context, url string) (*Info, cleanupFn, error) {

release/asset/download_test.go

@@ -70,4 +70,27 @@ func TestAssetDownloader(t *testing.T) {
 			assert.NoFileExists(t, tmpFile)
 		})
 	})
+	t.Run("VerifyFallback", func(t *testing.T) {
+		srv := setupTestServer(t, http.HandlerFunc(downloadDataHandler))
+		ctx := context.Background()
+		t.Run("DownloadFailsWithoutFallback", func(t *testing.T) {
+			downloader := NewAssetDownloader(executablePath, WithOS("os"), WithArch("amd64"))
+			asset, cleanupFn, err := downloader.DownloadAsset(ctx, []release.Asset{
+				{BrowserDownloadURL: srv.URL + "/download_os_x86_64"},
+			})
+			assert.ErrorIs(t, err, ErrNoAsset)
+			assert.Nil(t, asset)
+			assert.Nil(t, cleanupFn)
+		})
+		t.Run("DownloadSucceedsWithFallback", func(t *testing.T) {
+			downloader := NewAssetDownloader(executablePath, WithOS("os"), WithArch("amd64"), WithLookupArchFallback(map[string]string{"amd64": "x86_64"}))
+			asset, cleanupFn, err := downloader.DownloadAsset(ctx, []release.Asset{
+				{BrowserDownloadURL: srv.URL + "/download_os_x86_64"},
+			})
+			assert.NoError(t, err)
+			assert.NotNil(t, asset)
+			assert.NotNil(t, cleanupFn)
+			assert.Equal(t, downloadDataChecksum, asset.Checksum)
+		})
+	})
 }