Xray download indexer api (#1191)

Co-authored-by: Assaf Attias <[email protected]>

Author: ehl-jf

artifactory/services/utils/tests/xray/server.go

@@ -5,6 +5,7 @@ import (
 	"io"
 	"net/http"
 	"os"
+	"runtime"
 	"strconv"
 	"strings"
 	"testing"
@@ -277,6 +278,20 @@ func enrichGetResults(t *testing.T) func(w http.ResponseWriter, r *http.Request)
 	}
 }
 
+func indexerDownloadHandler(t *testing.T) func(w http.ResponseWriter, r *http.Request) {
+	return func(w http.ResponseWriter, r *http.Request) {
+		if r.Method == http.MethodGet {
+			// Simulate downloading a binary file by sending a simple text response
+			w.Header().Set("Content-Disposition", "attachment; filename=\"indexer\"")
+			w.Header().Set("Content-Type", "application/octet-stream")
+			_, err := fmt.Fprint(w, "This is a mock indexer binary content.")
+			assert.NoError(t, err)
+			return
+		}
+		http.Error(w, "Invalid indexer download request", http.StatusBadRequest)
+	}
+}
+
 type MockServerParams struct {
 	MSI         string
 	XrayVersion string
@@ -302,6 +317,7 @@ func StartXrayMockServerWithParams(t *testing.T, params MockServerParams) int {
 	handlers[fmt.Sprintf("/xray/api/v1/scan/graph/%s", params.MSI)] = enrichGetResults(t)
 	handlers["/xray/api/v1/configuration/jas"] = getJasConfig(t)
 	handlers[fmt.Sprintf("/%s/", services.BuildScanAPI)] = buildScanHandler
+	handlers[fmt.Sprintf("/xray/api/v1/indexer-resources/download/%s/%s", runtime.GOOS, runtime.GOARCH)] = indexerDownloadHandler(t)
 	handlers[fmt.Sprintf("/%s/", services.ReportsAPI)] = reportHandler
 	// Xsc handlers
 	handlers["/xsc/api/v1/system/version"] = xscGetVersionHandlerFunc(t, params.XscVersion)

tests/xraybinmgr_test.go

@@ -4,9 +4,12 @@ package tests
 
 import (
 	"fmt"
+	"slices"
 	"testing"
+	"time"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestXrayBinMgr(t *testing.T) {
@@ -16,20 +19,29 @@ func TestXrayBinMgr(t *testing.T) {
 
 func addBuildsToIndexing(t *testing.T) {
 	buildName := fmt.Sprintf("%s-%s", "build1", getRunId())
-	defer func() {
-		assert.NoError(t, deleteBuildIndex(buildName))
-		assert.NoError(t, deleteBuild(buildName))
-	}()
+	t.Cleanup(func() {
+		if err := deleteBuildIndex(buildName); err != nil {
+			t.Logf("Failed to delete build index: %v", err)
+		}
+		if err := deleteBuild(buildName); err != nil {
+			t.Logf("Failed to delete build: %v", err)
+		}
+	})
 	// Create a build
 	err := createDummyBuild(buildName)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	// Index build
 	err = testXrayBinMgrService.AddBuildsToIndexing([]string{buildName})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	// Assert build contained in the indexed build list
-	indexedBuilds, err := getIndexedBuilds()
-	assert.NoError(t, err)
-	assert.Contains(t, indexedBuilds, buildName)
+	assert.Eventuallyf(t, func() bool {
+		indexedBuilds, err := getIndexedBuilds()
+		if err != nil {
+			t.Logf("Failed to get indexed builds: %v", err)
+			return false
+		}
+		return slices.Contains(indexedBuilds, buildName)
+	}, time.Second*5, time.Millisecond*150, "Build %s not found in indexed builds", buildName)
 }

tests/xrayindexer_test.go

@@ -0,0 +1,46 @@
+//go:build itest
+
+package tests
+
+import (
+	"path/filepath"
+	"strconv"
+	"testing"
+
+	"github.com/jfrog/jfrog-client-go/utils/io/fileutils"
+	"github.com/stretchr/testify/require"
+
+	"github.com/jfrog/jfrog-client-go/artifactory/services/utils/tests/xray"
+	"github.com/jfrog/jfrog-client-go/http/jfroghttpclient"
+	"github.com/jfrog/jfrog-client-go/xray/services"
+)
+
+func TestXrayDownloadIndexer(t *testing.T) {
+	initXrayTest(t)
+	// Create temp dir for downloading the indexer binary
+	outputDir, err := fileutils.CreateTempDir()
+	require.NoError(t, err)
+	defer func() {
+		require.NoError(t, fileutils.RemoveTempDir(outputDir))
+	}()
+	// Create mock Xray server
+	xrayServerPort := xray.StartXrayMockServer(t)
+	xrayDetails := GetXrayDetails()
+	client, err := jfroghttpclient.JfrogClientBuilder().
+		SetClientCertPath(xrayDetails.GetClientCertPath()).
+		SetClientCertKeyPath(xrayDetails.GetClientCertKeyPath()).
+		AppendPreRequestInterceptor(xrayDetails.RunPreRequestFunctions).
+		Build()
+	require.NoError(t, err)
+	// Create indexer service
+	indexerService := services.NewIndexerService(client)
+	indexerService.XrayDetails = xrayDetails
+	indexerService.XrayDetails.SetUrl("http://localhost:" + strconv.Itoa(xrayServerPort) + "/xray/")
+	// Download the indexer binary
+	downloadedFilePath, err := indexerService.Download(outputDir, "test-indexer")
+	require.NoError(t, err)
+	require.Equal(t, filepath.Join(outputDir, "test-indexer"), downloadedFilePath) // Verify the indexer binary was downloaded successfully
+	exists, err := fileutils.IsFileExists(downloadedFilePath, false)
+	require.NoError(t, err)
+	require.True(t, exists)
+}

xray/manager.go

@@ -269,3 +269,10 @@ func (sm *XrayServicesManager) GetArtifactStatus(repo, path string) (*services.A
 	artifactService.ScopeProjectKey = sm.scopeProjectKey
 	return artifactService.GetStatus(repo, path)
 }
+
+func (sm *XrayServicesManager) DownloadIndexer(localDirPath, localFileName string) (string, error) {
+	indexerService := services.NewIndexerService(sm.client)
+	indexerService.XrayDetails = sm.config.GetServiceDetails()
+	indexerService.ScopeProjectKey = sm.scopeProjectKey
+	return indexerService.Download(localDirPath, localFileName)
+}

xray/services/indexer.go

@@ -0,0 +1,56 @@
+package services
+
+import (
+	"fmt"
+	"net/http"
+	"os"
+	"path/filepath"
+	"runtime"
+
+	"github.com/jfrog/jfrog-client-go/auth"
+	"github.com/jfrog/jfrog-client-go/http/httpclient"
+	"github.com/jfrog/jfrog-client-go/http/jfroghttpclient"
+	"github.com/jfrog/jfrog-client-go/utils"
+	"github.com/jfrog/jfrog-client-go/utils/errorutils"
+)
+
+const (
+	downloadIndexerAPI = "api/v1/indexer-resources/download"
+)
+
+type IndexerService struct {
+	client          *jfroghttpclient.JfrogHttpClient
+	XrayDetails     auth.ServiceDetails
+	ScopeProjectKey string
+}
+
+func NewIndexerService(client *jfroghttpclient.JfrogHttpClient) *IndexerService {
+	return &IndexerService{client: client}
+}
+
+func (is *IndexerService) Download(localDirPath, localBinaryName string) (string, error) {
+	httpClientDetails := is.XrayDetails.CreateHttpClientDetails()
+	url := is.getUrlForDownloadApi()
+	// Download the indexer from Xray to the provided directory
+	downloadFileDetails := &httpclient.DownloadFileDetails{DownloadPath: url, LocalPath: localDirPath, LocalFileName: localBinaryName}
+	resp, err := is.client.DownloadFile(downloadFileDetails, "", &httpClientDetails, false, false)
+	if err != nil {
+		return "", fmt.Errorf("failed while attempting to download %q: %w", url, err)
+	}
+	if err = errorutils.CheckResponseStatus(resp, http.StatusOK); err != nil {
+		if resp.StatusCode == http.StatusUnauthorized {
+			err = fmt.Errorf("%s\nHint: It appears that the credentials provided do not have sufficient permissions for JFrog Xray. This could be due to either incorrect credentials or limited permissions restricted to Artifactory only", err.Error())
+		}
+		return "", fmt.Errorf("failed to download %q: %w", url, err)
+	}
+	// Add execution permissions to the indexer binary
+	downloadedFilePath := filepath.Join(localDirPath, localBinaryName)
+	if err = os.Chmod(downloadedFilePath, 0o755); err != nil {
+		return "", errorutils.CheckError(err)
+	}
+	return downloadedFilePath, errorutils.CheckError(err)
+}
+
+func (is *IndexerService) getUrlForDownloadApi() string {
+	return utils.AppendScopedProjectKeyParam(fmt.Sprintf("%s%s/%s/%s", is.XrayDetails.GetUrl(), downloadIndexerAPI, runtime.GOOS, runtime.GOARCH), is.ScopeProjectKey)
+}