feature: Automatically set CI VCS properties on uploaded artifacts (#348)

Author: bhanurp

artifactory/commands/buildinfo/civcs_props.go

@@ -0,0 +1,204 @@
+package buildinfo
+
+import (
+	"path"
+	"strings"
+	"time"
+
+	buildinfo "github.com/jfrog/build-info-go/entities"
+	"github.com/jfrog/jfrog-client-go/artifactory"
+	"github.com/jfrog/jfrog-client-go/artifactory/services"
+	artclientutils "github.com/jfrog/jfrog-client-go/artifactory/services/utils"
+	"github.com/jfrog/jfrog-client-go/utils/io/content"
+	"github.com/jfrog/jfrog-client-go/utils/log"
+)
+
+const (
+	maxRetries     = 3
+	retryDelayBase = time.Second
+)
+
+// extractArtifactPathsWithWarnings extracts Artifactory paths from build info artifacts.
+// Returns the list of paths (may be complete or partial) and count of skipped artifacts.
+// Paths are constructed using OriginalDeploymentRepo + Path when available, or Path directly as fallback.
+// If property setting fails later due to incomplete paths, warnings will be logged at that point.
+func extractArtifactPathsWithWarnings(buildInfo *buildinfo.BuildInfo) ([]string, int) {
+	var paths []string
+	var skippedCount int
+
+	for _, module := range buildInfo.Modules {
+		for _, artifact := range module.Artifacts {
+			fullPath := constructArtifactPathWithFallback(artifact)
+			if fullPath == "" {
+				// No path information at all - skip silently (nothing to try)
+				skippedCount++
+				continue
+			}
+			paths = append(paths, fullPath)
+		}
+	}
+	return paths, skippedCount
+}
+
+// constructArtifactPathWithFallback builds the full Artifactory path for an artifact.
+// Strategy:
+//  1. If OriginalDeploymentRepo is present: use OriginalDeploymentRepo + "/" + Path
+//  2. If OriginalDeploymentRepo is missing: use Path directly (it may or may not work)
+//  3. If neither available: return empty string (caller should warn and skip)
+func constructArtifactPathWithFallback(artifact buildinfo.Artifact) string {
+	// Primary: Use OriginalDeploymentRepo if available
+	if artifact.OriginalDeploymentRepo != "" {
+		if artifact.Path != "" {
+			return artifact.OriginalDeploymentRepo + "/" + artifact.Path
+		}
+		if artifact.Name != "" {
+			return artifact.OriginalDeploymentRepo + "/" + artifact.Name
+		}
+	}
+
+	// Fallback: Use Path directly - it might be a complete path or might fail
+	// If it fails, setPropsOnArtifacts will warn and move on
+	if artifact.Path != "" {
+		return artifact.Path
+	}
+
+	// Last resort: just the name (unlikely to work, but let it try)
+	if artifact.Name != "" {
+		return artifact.Name
+	}
+
+	// Nothing available
+	return ""
+}
+
+// constructArtifactPath builds the full Artifactory path for an artifact (legacy function).
+func constructArtifactPath(artifact buildinfo.Artifact) string {
+	if artifact.OriginalDeploymentRepo == "" {
+		return ""
+	}
+	if artifact.Path != "" {
+		return artifact.OriginalDeploymentRepo + "/" + artifact.Path
+	}
+	if artifact.Name != "" {
+		return artifact.OriginalDeploymentRepo + "/" + artifact.Name
+	}
+	return ""
+}
+
+// setPropsOnArtifacts sets properties on multiple artifacts in a single API call with retry logic.
+// This is a major performance optimization over setting properties one by one.
+// If property setting fails after retries, logs a warning and continues (does not fail the build).
+func setPropsOnArtifacts(
+	servicesManager artifactory.ArtifactoryServicesManager,
+	artifactPaths []string,
+	props string,
+) {
+	if len(artifactPaths) == 0 {
+		return
+	}
+
+	var lastErr error
+	for attempt := 0; attempt < maxRetries; attempt++ {
+		if attempt > 0 {
+			// Exponential backoff: 1s, 2s, 4s
+			delay := retryDelayBase * time.Duration(1<<(attempt-1))
+			log.Debug("Retrying property set for artifacts (attempt", attempt+1, "/", maxRetries, ") after", delay)
+			time.Sleep(delay)
+		}
+
+		// Create reader for all artifacts
+		reader, err := createArtifactsReader(artifactPaths)
+		if err != nil {
+			log.Debug("Failed to create reader for CI VCS properties:", err)
+			return
+		}
+
+		params := services.PropsParams{
+			Reader: reader,
+			Props:  props,
+		}
+
+		successCount, err := servicesManager.SetProps(params)
+		if closeErr := reader.Close(); closeErr != nil {
+			log.Debug("Failed to close reader:", closeErr)
+		}
+
+		if err == nil {
+			log.Info("CI VCS: Successfully set properties on", successCount, "artifacts")
+			return
+		}
+
+		// Check if error is 404 - artifact path might be incorrect, skip silently
+		if is404Error(err) {
+			log.Info("CI VCS: SetProps returned 404 - some artifacts not found (path may be incomplete)")
+			return
+		}
+
+		// Check if error is 403 - permission issue, skip silently
+		if is403Error(err) {
+			if attempt >= 1 {
+				log.Info("CI VCS: SetProps returned 403 - permission denied")
+				return
+			}
+		}
+
+		lastErr = err
+		log.Info("CI VCS: Batch attempt", attempt+1, "failed:", err)
+	}
+
+	log.Info("CI VCS: Failed to set properties after", maxRetries, "attempts:", lastErr)
+}
+
+// createArtifactsReader creates a ContentReader containing all artifact paths for batch processing.
+func createArtifactsReader(artifactPaths []string) (*content.ContentReader, error) {
+	writer, err := content.NewContentWriter("results", true, false)
+	if err != nil {
+		return nil, err
+	}
+
+	for _, artifactPath := range artifactPaths {
+		// Parse path into repo/path/name
+		parts := strings.SplitN(artifactPath, "/", 2)
+		if len(parts) < 2 {
+			log.Debug("Invalid artifact path skipped during reader creation:", artifactPath)
+			continue
+		}
+
+		repo := parts[0]
+		pathAndName := parts[1]
+		dir, name := path.Split(pathAndName)
+
+		writer.Write(artclientutils.ResultItem{
+			Repo: repo,
+			Path: strings.TrimSuffix(dir, "/"),
+			Name: name,
+			Type: "file",
+		})
+	}
+
+	if err := writer.Close(); err != nil {
+		return nil, err
+	}
+
+	return content.NewContentReader(writer.GetFilePath(), "results"), nil
+}
+
+// is404Error checks if the error indicates a 404 Not Found response.
+func is404Error(err error) bool {
+	if err == nil {
+		return false
+	}
+	errStr := strings.ToLower(err.Error())
+	return strings.Contains(errStr, "404") ||
+		strings.Contains(errStr, "not found")
+}
+
+// is403Error checks if the error indicates a 403 Forbidden response.
+func is403Error(err error) bool {
+	if err == nil {
+		return false
+	}
+	errStr := strings.ToLower(err.Error())
+	return strings.Contains(errStr, "403") ||
+		strings.Contains(errStr, "forbidden")
+}

artifactory/commands/buildinfo/publish.go

@@ -3,15 +3,17 @@ package buildinfo
 import (
 	"errors"
 	"fmt"
-	"github.com/jfrog/jfrog-cli-core/v2/artifactory/utils/commandsummary"
 	"net/url"
 	"strconv"
 	"strings"
 	"time"
 
 	buildinfo "github.com/jfrog/build-info-go/entities"
+	"github.com/jfrog/build-info-go/utils/cienv"
 	"github.com/jfrog/jfrog-cli-artifactory/artifactory/formats"
+	"github.com/jfrog/jfrog-cli-artifactory/artifactory/utils/civcs"
 	"github.com/jfrog/jfrog-cli-core/v2/artifactory/utils"
+	"github.com/jfrog/jfrog-cli-core/v2/artifactory/utils/commandsummary"
 	"github.com/jfrog/jfrog-cli-core/v2/common/build"
 	"github.com/jfrog/jfrog-cli-core/v2/utils/config"
 	"github.com/jfrog/jfrog-cli-core/v2/utils/coreutils"
@@ -197,6 +199,11 @@ func (bpc *BuildPublishCommand) Run() error {
 		return err
 	}
 
+	// Set CI VCS properties on artifacts from build info.
+	// This only runs if we're in a supported CI environment (GitHub Actions, GitLab CI, etc.)
+	// Note: This never returns an error - it only logs warnings on failure
+	bpc.setCIVcsPropsOnArtifacts(servicesManager, buildInfo)
+
 	majorVersion, err := utils.GetRtMajorVersion(servicesManager)
 	if err != nil {
 		return err
@@ -309,6 +316,54 @@ func (bpc *BuildPublishCommand) getNextBuildNumber(buildName string, servicesMan
 	return strconv.Itoa(latestBuildNumber), nil
 }
 
+// setCIVcsPropsOnArtifacts sets CI VCS properties on all artifacts in the build info.
+// This method:
+// - Only runs when in a supported CI environment (GitHub Actions, GitLab CI, etc.)
+// - Never fails the build publish - only logs warnings on errors
+// - Retries transient failures but not 404 errors
+// - Does nothing if CI VCS props collection is disabled via JFROG_CLI_CI_VCS_PROPS_DISABLED
+func (bpc *BuildPublishCommand) setCIVcsPropsOnArtifacts(
+	servicesManager artifactory.ArtifactoryServicesManager,
+	buildInfo *buildinfo.BuildInfo,
+) {
+	// Check if CI VCS props collection is disabled
+	if civcs.IsCIVcsPropsDisabled() {
+		return
+	}
+	// Check if running in a supported CI environment
+	// This requires CI=true AND a registered provider (GitHub, GitLab, etc.)
+	ciVcsInfo := cienv.GetCIVcsInfo()
+	if ciVcsInfo.IsEmpty() {
+		// Not in CI or no registered provider - silently skip
+		return
+	}
+	log.Info("CI VCS: Detected provider:", ciVcsInfo.Provider, ", org:", ciVcsInfo.Org, ", repo:", ciVcsInfo.Repo)
+
+	// Build props string
+	props := civcs.BuildCIVcsPropsString(ciVcsInfo)
+	if props == "" {
+		log.Info("CI VCS: Empty props string, skipping")
+		return
+	}
+
+	// Extract artifact paths from build info (with warnings for missing repo paths)
+	artifactPaths, skippedCount := extractArtifactPathsWithWarnings(buildInfo)
+	log.Info("CI VCS: Extracted", len(artifactPaths), "artifact paths,", skippedCount, "skipped")
+	if len(artifactPaths) == 0 && skippedCount == 0 {
+		log.Info("CI VCS: No artifacts found in build info")
+		return
+	}
+	if len(artifactPaths) == 0 {
+		// All artifacts were skipped due to missing repo paths
+		log.Info("CI VCS: All artifacts skipped due to missing repo paths")
+		return
+	}
+	log.Info("CI VCS: Setting properties on", len(artifactPaths), "artifacts with props:", props)
+	// Set properties on all artifacts in a single batch call
+	setPropsOnArtifacts(servicesManager, artifactPaths, props)
+	log.Info("CI VCS: Property setting completed")
+}
+
 func recordCommandSummary(buildInfo *buildinfo.BuildInfo, buildLink string) (err error) {
 	if !commandsummary.ShouldRecordSummary() {
 		return