Merge pull request #21605 from medyagh/preload_gh_asset

preload: download from github when gcs not available

Author: medyagh

pkg/minikube/download/download_test.go

@@ -25,6 +25,7 @@ import (
 	"time"
 
 	"k8s.io/minikube/pkg/minikube/constants"
+	"k8s.io/minikube/pkg/minikube/localpath"
 )
 
 // Force download tests to run in serial.
@@ -33,7 +34,6 @@ func TestDownload(t *testing.T) {
 	t.Run("PreloadDownloadPreventsMultipleDownload", testPreloadDownloadPreventsMultipleDownload)
 	t.Run("ImageToCache", testImageToCache)
 	t.Run("PreloadNotExists", testPreloadNotExists)
-	t.Run("PreloadChecksumMismatch", testPreloadChecksumMismatch)
 	t.Run("PreloadExistsCaching", testPreloadExistsCaching)
 	t.Run("PreloadWithCachedSizeZero", testPreloadWithCachedSizeZero)
 }
@@ -48,7 +48,31 @@ func mockSleepDownload(downloadsCounter *int) func(src, dst string) error {
 	}
 }
 
+//	point each subtest at an isolated MINIKUBE_HOME, pre-create the preload cache directory,
+//
+// and automatically restore the global download/preload mocks after each run.
+// Applied the helper across all download-related tests
+func setupTestMiniHome(t *testing.T) {
+	t.Helper()
+	tmpHome := t.TempDir()
+	t.Setenv(localpath.MinikubeHome, tmpHome)
+	if err := os.MkdirAll(targetDir(), 0o755); err != nil {
+		t.Fatalf("failed to create preload cache dir: %v", err)
+	}
+	origDownloadMock := DownloadMock
+	origCheckCache := checkCache
+	origCheckPreloadExists := checkPreloadExists
+	origGetChecksumGCS := getChecksumGCS
+	t.Cleanup(func() {
+		DownloadMock = origDownloadMock
+		checkCache = origCheckCache
+		checkPreloadExists = origCheckPreloadExists
+		getChecksumGCS = origGetChecksumGCS
+	})
+}
+
 func testBinaryDownloadPreventsMultipleDownload(t *testing.T) {
+	setupTestMiniHome(t)
 	downloadNum := 0
 	DownloadMock = mockSleepDownload(&downloadNum)
 
@@ -79,6 +103,8 @@ func testBinaryDownloadPreventsMultipleDownload(t *testing.T) {
 }
 
 func testPreloadDownloadPreventsMultipleDownload(t *testing.T) {
+	setupTestMiniHome(t)
+
 	downloadNum := 0
 	DownloadMock = mockSleepDownload(&downloadNum)
 	f, err := os.CreateTemp("", "preload")
@@ -97,8 +123,7 @@ func testPreloadDownloadPreventsMultipleDownload(t *testing.T) {
 		return os.Stat(f.Name())
 	}
 	checkPreloadExists = func(_, _, _ string, _ ...bool) bool { return true }
-	getChecksum = func(_, _ string) ([]byte, error) { return []byte("check"), nil }
-	ensureChecksumValid = func(_, _, _ string, _ []byte) error { return nil }
+	getChecksumGCS = func(_, _ string) ([]byte, error) { return []byte("check"), nil }
 
 	var group sync.WaitGroup
 	group.Add(2)
@@ -120,13 +145,13 @@ func testPreloadDownloadPreventsMultipleDownload(t *testing.T) {
 }
 
 func testPreloadNotExists(t *testing.T) {
+	setupTestMiniHome(t)
 	downloadNum := 0
 	DownloadMock = mockSleepDownload(&downloadNum)
 
 	checkCache = func(_ string) (fs.FileInfo, error) { return nil, fmt.Errorf("cache not found") }
 	checkPreloadExists = func(_, _, _ string, _ ...bool) bool { return false }
-	getChecksum = func(_, _ string) ([]byte, error) { return []byte("check"), nil }
-	ensureChecksumValid = func(_, _, _ string, _ []byte) error { return nil }
+	getChecksumGCS = func(_, _ string) ([]byte, error) { return []byte("check"), nil }
 
 	err := Preload(constants.DefaultKubernetesVersion, constants.Docker, "docker")
 	if err != nil {
@@ -138,27 +163,8 @@ func testPreloadNotExists(t *testing.T) {
 	}
 }
 
-func testPreloadChecksumMismatch(t *testing.T) {
-	downloadNum := 0
-	DownloadMock = mockSleepDownload(&downloadNum)
-
-	checkCache = func(_ string) (fs.FileInfo, error) { return nil, fmt.Errorf("cache not found") }
-	checkPreloadExists = func(_, _, _ string, _ ...bool) bool { return true }
-	getChecksum = func(_, _ string) ([]byte, error) { return []byte("check"), nil }
-	ensureChecksumValid = func(_, _, _ string, _ []byte) error {
-		return fmt.Errorf("checksum mismatch")
-	}
-
-	err := Preload(constants.DefaultKubernetesVersion, constants.Docker, "docker")
-	expectedErrMsg := "checksum mismatch"
-	if err == nil {
-		t.Errorf("Expected error when checksum mismatches")
-	} else if err.Error() != expectedErrMsg {
-		t.Errorf("Expected error to be %s, got %s", expectedErrMsg, err.Error())
-	}
-}
-
 func testImageToCache(t *testing.T) {
+	setupTestMiniHome(t)
 	downloadNum := 0
 	DownloadMock = mockSleepDownload(&downloadNum)
 
@@ -184,44 +190,72 @@ func testImageToCache(t *testing.T) {
 }
 
 // Validates that preload existence checks correctly caches values retrieved by remote checks.
+// testPreloadExistsCaching verifies the caching semantics of PreloadExists when
+// the local cache is absent and remote existence checks are required.
+// In summary, this test enforces that:
+// - PreloadExists performs remote checks only on cache misses.
+// - Negative and positive results are cached per (k8sVersion, containerVersion, runtime) key.
+// - GitHub is only consulted when GCS reports the preload as not existing.
+// - Global state is correctly restored after the test.
 func testPreloadExistsCaching(t *testing.T) {
+	setupTestMiniHome(t)
 	checkCache = func(_ string) (fs.FileInfo, error) {
 		return nil, fmt.Errorf("cache not found")
 	}
 	doesPreloadExist := false
-	checkCalled := false
-	checkRemotePreloadExists = func(_, _ string) bool {
-		checkCalled = true
+	gcsCheckCalls := 0
+	ghCheckCalls := 0
+	savedGCSCheck := checkRemotePreloadExistsGCS
+	savedGHCheck := checkRemotePreloadExistsGitHub
+	preloadStates = make(map[string]map[string]preloadState)
+	checkRemotePreloadExistsGCS = func(_, _ string) bool {
+		gcsCheckCalls++
 		return doesPreloadExist
 	}
+	checkRemotePreloadExistsGitHub = func(_, _ string) bool {
+		ghCheckCalls++
+		return false
+	}
+	t.Cleanup(func() {
+		checkRemotePreloadExistsGCS = savedGCSCheck
+		checkRemotePreloadExistsGitHub = savedGHCheck
+		preloadStates = make(map[string]map[string]preloadState)
+	})
+
 	existence := PreloadExists("v1", "c1", "docker", true)
-	if existence || !checkCalled {
-		t.Errorf("Expected preload not to exist and a check to be performed. Existence: %v, Check: %v", existence, checkCalled)
+	if existence || gcsCheckCalls != 1 || ghCheckCalls != 1 {
+		t.Errorf("Expected preload not to exist and checks to be performed. Existence: %v, GCS Calls: %d, GH Calls: %d", existence, gcsCheckCalls, ghCheckCalls)
 	}
-	checkCalled = false
+	gcsCheckCalls = 0
+	ghCheckCalls = 0
 	existence = PreloadExists("v1", "c1", "docker", true)
-	if existence || checkCalled {
-		t.Errorf("Expected preload not to exist and no check to be performed. Existence: %v, Check: %v", existence, checkCalled)
+	if existence || gcsCheckCalls != 0 || ghCheckCalls != 0 {
+		t.Errorf("Expected preload not to exist and no checks to be performed. Existence: %v, GCS Calls: %d, GH Calls: %d", existence, gcsCheckCalls, ghCheckCalls)
 	}
 	doesPreloadExist = true
-	checkCalled = false
+	gcsCheckCalls = 0
+	ghCheckCalls = 0
 	existence = PreloadExists("v2", "c1", "docker", true)
-	if !existence || !checkCalled {
-		t.Errorf("Expected preload to exist and a check to be performed. Existence: %v, Check: %v", existence, checkCalled)
+	if !existence || gcsCheckCalls != 1 || ghCheckCalls != 0 {
+		t.Errorf("Expected preload to exist via GCS. Existence: %v, GCS Calls: %d, GH Calls: %d", existence, gcsCheckCalls, ghCheckCalls)
 	}
-	checkCalled = false
+	gcsCheckCalls = 0
+	ghCheckCalls = 0
 	existence = PreloadExists("v2", "c2", "docker", true)
-	if !existence || !checkCalled {
-		t.Errorf("Expected preload to exist and a check to be performed. Existence: %v, Check: %v", existence, checkCalled)
+	if !existence || gcsCheckCalls != 1 || ghCheckCalls != 0 {
+		t.Errorf("Expected preload to exist via GCS for new runtime. Existence: %v, GCS Calls: %d, GH Calls: %d", existence, gcsCheckCalls, ghCheckCalls)
 	}
-	checkCalled = false
+	gcsCheckCalls = 0
+	ghCheckCalls = 0
 	existence = PreloadExists("v2", "c2", "docker", true)
-	if !existence || checkCalled {
-		t.Errorf("Expected preload to exist and no check to be performed. Existence: %v, Check: %v", existence, checkCalled)
+	if !existence || gcsCheckCalls != 0 || ghCheckCalls != 0 {
+		t.Errorf("Expected preload to exist and no checks to be performed. Existence: %v, GCS Calls: %d, GH Calls: %d", existence, gcsCheckCalls, ghCheckCalls)
 	}
 }
 
 func testPreloadWithCachedSizeZero(t *testing.T) {
+	setupTestMiniHome(t)
+
 	downloadNum := 0
 	DownloadMock = mockSleepDownload(&downloadNum)
 	f, err := os.CreateTemp("", "preload")
@@ -231,8 +265,7 @@ func testPreloadWithCachedSizeZero(t *testing.T) {
 
 	checkCache = func(_ string) (fs.FileInfo, error) { return os.Stat(f.Name()) }
 	checkPreloadExists = func(_, _, _ string, _ ...bool) bool { return true }
-	getChecksum = func(_, _ string) ([]byte, error) { return []byte("check"), nil }
-	ensureChecksumValid = func(_, _, _ string, _ []byte) error { return nil }
+	getChecksumGCS = func(_, _ string) ([]byte, error) { return []byte("check"), nil }
 
 	if err := Preload(constants.DefaultKubernetesVersion, constants.Docker, "docker"); err != nil {
 		t.Errorf("Expected no error with cached preload of size zero")

pkg/minikube/download/gh/gh.go

@@ -0,0 +1,68 @@
+/*
+Copyright 2025 The Kubernetes Authors All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+// Package gh provides helper utilities for interacting with the GitHub API
+package gh
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+	"os"
+	"strings"
+
+	"github.com/google/go-github/v74/github"
+	"golang.org/x/oauth2"
+)
+
+// ReleaseAssets retrieves a GitHub release by tag from org/project.
+// Try to not call this too often. preferably cache and re-use. to avoid rate limits.
+func ReleaseAssets(org, project, tag string) ([]*github.ReleaseAsset, error) {
+	ctx := context.Background()
+	// Use an authenticated client when GITHUB_TOKEN is set to avoid low rate limits.
+	httpClient := oauthClient(ctx, os.Getenv("GITHUB_TOKEN"))
+	ghc := github.NewClient(httpClient)
+
+	rel, _, err := ghc.Repositories.GetReleaseByTag(ctx, org, project, tag)
+	return rel.Assets, err
+}
+
+// AssetSHA256 returns the  SHA-256 digest for the asset with the given name
+// from the provided release assets from github API.
+// to avoid rate limits. encouraged to call pass results of ReleaseAssets here.
+func AssetSHA256(assetName string, assets []*github.ReleaseAsset) ([]byte, error) {
+	for _, asset := range assets {
+		if asset.GetName() != assetName {
+			continue
+		}
+		d := asset.GetDigest() // e.g. "sha256:fdcb..."
+		if d == "" {
+			return []byte(""), fmt.Errorf("asset %q has no digest; id=%d url=%s", assetName, asset.GetID(), asset.GetBrowserDownloadURL())
+		}
+		const prefix = "sha256:"
+		d = strings.TrimPrefix(d, prefix)
+		return []byte(d), nil
+	}
+	return []byte(""), fmt.Errorf("asset %q not found", assetName)
+}
+
+func oauthClient(ctx context.Context, token string) *http.Client {
+	if token == "" {
+		return nil // unauthenticated client (lower rate limit)
+	}
+	ts := oauth2.StaticTokenSource(&oauth2.Token{AccessToken: token})
+	return oauth2.NewClient(ctx, ts)
+}

pkg/minikube/download/gh/gh_test.go

@@ -0,0 +1,98 @@
+/*
+Copyright 2025 The Kubernetes Authors All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package gh
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/google/go-github/v74/github"
+)
+
+func TestAssetSHA256(t *testing.T) {
+	t.Run("found_with_sha256_prefix", func(t *testing.T) {
+		assets := []*github.ReleaseAsset{
+			{
+				Name:               github.Ptr("minikube-linux-amd64"),
+				Digest:             github.Ptr("sha256:abcdef123456"),
+				ID:                 github.Ptr(int64(101)),
+				BrowserDownloadURL: github.Ptr("http://example/minikube-linux-amd64"),
+			},
+		}
+		got, err := AssetSHA256("minikube-linux-amd64", assets)
+		if err != nil {
+			t.Fatalf("unexpected error: %v", err)
+		}
+		if string(got) != "abcdef123456" {
+			t.Fatalf("expected digest %q, got %q", "abcdef123456", string(got))
+		}
+	})
+
+	t.Run("found_without_prefix", func(t *testing.T) {
+		assets := []*github.ReleaseAsset{
+			{
+				Name:               github.Ptr("minikube-darwin-arm64"),
+				Digest:             github.Ptr("1234abcd"),
+				ID:                 github.Ptr(int64(102)),
+				BrowserDownloadURL: github.Ptr("http://example/minikube-darwin-arm64"),
+			},
+		}
+		got, err := AssetSHA256("minikube-darwin-arm64", assets)
+		if err != nil {
+			t.Fatalf("unexpected error: %v", err)
+		}
+		if string(got) != "1234abcd" {
+			t.Fatalf("expected digest %q, got %q", "1234abcd", string(got))
+		}
+	})
+
+	t.Run("asset_missing_digest", func(t *testing.T) {
+		assets := []*github.ReleaseAsset{
+			{
+				Name:               github.Ptr("minikube-windows-amd64.exe"),
+				Digest:             github.Ptr(""),
+				ID:                 github.Ptr(int64(103)),
+				BrowserDownloadURL: github.Ptr("http://example/minikube-windows-amd64.exe"),
+			},
+		}
+		_, err := AssetSHA256("minikube-windows-amd64.exe", assets)
+		if err == nil {
+			t.Fatalf("expected error, got nil")
+		}
+		if !strings.Contains(err.Error(), "has no digest") {
+			t.Fatalf("unexpected error message: %v", err)
+		}
+	})
+
+	t.Run("asset_not_found", func(t *testing.T) {
+		assets := []*github.ReleaseAsset{
+			{
+				Name:               github.Ptr("unrelated"),
+				Digest:             github.Ptr("sha256:deadbeef"),
+				ID:                 github.Ptr(int64(104)),
+				BrowserDownloadURL: github.Ptr("http://example/unrelated"),
+			},
+		}
+		_, err := AssetSHA256("missing", assets)
+		if err == nil {
+			t.Fatalf("expected error, got nil")
+		}
+		if !strings.Contains(err.Error(), `asset "missing" not found`) {
+			t.Fatalf("unexpected error message: %v", err)
+		}
+	})
+}