update references to images in the autoupdate code

Author: diogoasouza

tools/internal/autoupdate/config.go

@@ -38,12 +38,12 @@ type AutoUpdateOptions struct {
 	GithubClient *github.Client
 }
 
-// AutoupdateImageRef is used to map a given update image to an entry in config.yaml.
-// There may be multiple entries that have the same SourceImage, but different
-// TargetImageNames, so we need to choose which one receives the update image.
-type AutoupdateImageRef struct {
-	SourceImage     string
-	TargetImageName string `json:",omitempty"`
+// AutoupdateArtifactRef is used to map a given update artifact to an entry in config.yaml.
+// There may be multiple entries that have the same SourceArtifact, but different
+// TargetArtifactName, so we need to choose which one receives the update artifact.
+type AutoupdateArtifactRef struct {
+	SourceArtifact     string
+	TargetArtifactName string `json:",omitempty"`
 }
 
 func Parse(filePath string) ([]ConfigEntry, error) {
@@ -135,53 +135,53 @@ func (entry ConfigEntry) Validate() error {
 	return nil
 }
 
-// GetUpdateImages returns a slice of Artifacts that depends on the
+// GetUpdateArtifacts returns a slice of Artifacts that depends on the
 // configured update strategy. The returned Artifacts may be from
 // any source, and they may be gathered in any way. The intention
 // is that they are new Artifacts (or new tags of existing Artifacts) that
 // we want to mirror.
-func (entry ConfigEntry) GetUpdateImages() ([]*config.Artifact, error) {
+func (entry ConfigEntry) GetUpdateArtifacts() ([]*config.Artifact, error) {
 	switch {
 	case entry.GithubRelease != nil:
-		return entry.GithubRelease.GetUpdateImages()
+		return entry.GithubRelease.GetUpdateArtifacts()
 	case entry.HelmLatest != nil:
-		return entry.HelmLatest.GetUpdateImages()
+		return entry.HelmLatest.GetUpdateArtifacts()
 	case entry.Registry != nil:
-		return entry.Registry.GetUpdateImages()
+		return entry.Registry.GetUpdateArtifacts()
 	default:
 		return nil, errors.New("did not find update strategy")
 	}
 }
 
 func (entry ConfigEntry) Run(ctx context.Context, opts AutoUpdateOptions) error {
-	newImages, err := entry.GetUpdateImages()
+	newArtifacts, err := entry.GetUpdateArtifacts()
 	if err != nil {
-		return fmt.Errorf("failed to get latest images for %s: %w", entry.Name, err)
+		return fmt.Errorf("failed to get latest artifacts for %s: %w", entry.Name, err)
 	}
 
 	accumulator := config.NewArtifactAccumulator()
 	accumulator.AddArtifacts(opts.ConfigYaml.Artifacts...)
 
-	imagesToUpdate := make([]*config.Artifact, 0, len(newImages))
-	for _, latestImage := range newImages {
-		imageToUpdate, err := accumulator.TagDifference(latestImage)
+	artifactsToUpdate := make([]*config.Artifact, 0, len(newArtifacts))
+	for _, latestArtifact := range newArtifacts {
+		artifactToUpdate, err := accumulator.TagDifference(latestArtifact)
 		if err != nil {
-			return fmt.Errorf("failed to get tag difference for image %s: %w", latestImage.SourceArtifact, err)
+			return fmt.Errorf("failed to get tag difference for artifact %s: %w", latestArtifact.SourceArtifact, err)
 		}
-		if imageToUpdate != nil {
-			imagesToUpdate = append(imagesToUpdate, imageToUpdate)
+		if artifactToUpdate != nil {
+			artifactsToUpdate = append(artifactsToUpdate, artifactToUpdate)
 		}
 	}
-	if len(imagesToUpdate) == 0 {
+	if len(artifactsToUpdate) == 0 {
 		fmt.Printf("%s: no updates found\n", entry.Name)
 		return nil
 	}
 
-	imageSetHash, err := hashImageSet(imagesToUpdate)
+	artifactSetHash, err := hashArtifactSet(artifactsToUpdate)
 	if err != nil {
-		return fmt.Errorf("failed to hash set of images that need updates: %w", err)
+		return fmt.Errorf("failed to hash set of artifacts that need updates: %w", err)
 	}
-	branchName := fmt.Sprintf("autoupdate/%s/%s", entry.Name, imageSetHash)
+	branchName := fmt.Sprintf("autoupdate/%s/%s", entry.Name, artifactSetHash)
 
 	// When filtering pull requests by head branch, the github API
 	// requires that the head branch is in the format <owner>:<branch>.
@@ -213,62 +213,62 @@ func (entry ConfigEntry) Run(ctx context.Context, opts AutoUpdateOptions) error
 
 	if opts.DryRun {
 		msg := fmt.Sprintf("%s: would make PR under branch %s that adds:\n", entry.Name, branchName)
-		for _, imageToUpdate := range imagesToUpdate {
-			for _, fullImage := range imageToUpdate.CombineSourceArtifactAndTags() {
-				msg = msg + "  - " + fullImage + "\n"
+		for _, artifactToUpdate := range artifactsToUpdate {
+			for _, fullArtifact := range artifactToUpdate.CombineSourceArtifactAndTags() {
+				msg = msg + "  - " + fullArtifact + "\n"
 			}
 		}
 		fmt.Print(msg)
 		return nil
 	}
 
-	return entry.CreateImageUpdatePullRequest(ctx, opts, branchName, imagesToUpdate)
+	return entry.CreateArtifactUpdatePullRequest(ctx, opts, branchName, artifactsToUpdate)
 }
 
-func (entry ConfigEntry) CreateImageUpdatePullRequest(ctx context.Context, opts AutoUpdateOptions, branchName string, imagesToUpdate []*config.Artifact) error {
+func (entry ConfigEntry) CreateArtifactUpdatePullRequest(ctx context.Context, opts AutoUpdateOptions, branchName string, artifactsToUpdate []*config.Artifact) error {
 	accumulator := config.NewArtifactAccumulator()
 	accumulator.AddArtifacts(opts.ConfigYaml.Artifacts...)
 
 	if err := git.CreateAndCheckoutBranch(opts.BaseBranch, branchName); err != nil {
 		return fmt.Errorf("failed to create and checkout branch %s: %w", branchName, err)
 	}
-	for _, imageToUpdate := range imagesToUpdate {
+	for _, artifactToUpdate := range artifactsToUpdate {
 		// We can reuse the accumulator here because we are making a sequence
-		// of commits, each of which makes an addition from imagesToUpdate.
+		// of commits, each of which makes an addition from artifactsToUpdate.
 		configYaml := opts.ConfigYaml
-		accumulator.AddArtifacts(imageToUpdate)
+		accumulator.AddArtifacts(artifactToUpdate)
 		configYaml.Artifacts = accumulator.Artifacts()
 		if err := config.Write(paths.ConfigYaml, configYaml); err != nil {
 			return fmt.Errorf("failed to write %s: %w", paths.ConfigYaml, err)
 		}
 
 		regsyncYaml, err := configYaml.ToRegsyncConfig()
 		if err != nil {
-			return fmt.Errorf("failed to generate regsync config for commit for image %s: %w", imageToUpdate.SourceArtifact, err)
+			return fmt.Errorf("failed to generate regsync config for commit for artifact %s: %w", artifactToUpdate.SourceArtifact, err)
 		}
 		if err := regsync.WriteConfig(paths.RegsyncYaml, regsyncYaml); err != nil {
-			return fmt.Errorf("failed to write regsync config for commit for image %s: %w", imageToUpdate.SourceArtifact, err)
+			return fmt.Errorf("failed to write regsync config for commit for artifact %s: %w", artifactToUpdate.SourceArtifact, err)
 		}
 
-		tagString := strings.Join(imageToUpdate.Tags, ", ")
-		msg := fmt.Sprintf("Add tag(s) %s for image %s", tagString, imageToUpdate.SourceArtifact)
+		tagString := strings.Join(artifactToUpdate.Tags, ", ")
+		msg := fmt.Sprintf("Add tag(s) %s for artifact %s", tagString, artifactToUpdate.SourceArtifact)
 		if err := git.Commit(msg); err != nil {
-			return fmt.Errorf("failed to commit changes for image %s: %w", imageToUpdate.SourceArtifact, err)
+			return fmt.Errorf("failed to commit changes for artifact %s: %w", artifactToUpdate.SourceArtifact, err)
 		}
 	}
 	if err := git.PushBranch(branchName, "origin"); err != nil {
 		return fmt.Errorf("failed to push branch %s: %w", branchName, err)
 	}
 
 	tagCount := 0
-	for _, imageToUpdate := range imagesToUpdate {
-		tagCount = tagCount + len(imageToUpdate.Tags)
+	for _, artifactToUpdate := range artifactsToUpdate {
+		tagCount = tagCount + len(artifactToUpdate.Tags)
 	}
 	title := fmt.Sprintf("[autoupdate] Add %d tag(s) for `%s`", tagCount, entry.Name)
-	body := "This PR was created by the autoupdate workflow.\n\nIt adds the following image tags:"
-	for _, imageToUpdate := range imagesToUpdate {
-		for _, fullImage := range imageToUpdate.CombineSourceArtifactAndTags() {
-			body = body + "\n- `" + fullImage + "`"
+	body := "This PR was created by the autoupdate workflow.\n\nIt adds the following artifact tags:"
+	for _, artifactToUpdate := range artifactsToUpdate {
+		for _, fullArtifact := range artifactToUpdate.CombineSourceArtifactAndTags() {
+			body = body + "\n- `" + fullArtifact + "`"
 		}
 	}
 	maintainerCanModify := true
@@ -292,21 +292,21 @@ func (entry ConfigEntry) CreateImageUpdatePullRequest(ctx context.Context, opts
 	return nil
 }
 
-// hashImageSet computes a human-readable hash from a passed
+// hashArtifactSet computes a human-readable hash from a passed
 // set of Artifacts. Immune to different order of Artifacts, and
-// immune to the order of of the tags in those Artifacts.
-func hashImageSet(images []*config.Artifact) (string, error) {
-	for _, image := range images {
-		image.Sort()
+// immune to the order of the tags in those Artifacts.
+func hashArtifactSet(artifacts []*config.Artifact) (string, error) {
+	for _, artifact := range artifacts {
+		artifact.Sort()
 	}
-	slices.SortStableFunc(images, config.CompareArtifacts)
+	slices.SortStableFunc(artifacts, config.CompareArtifacts)
 
 	hasher := sha256.New()
-	for _, image := range images {
-		for _, fullImage := range image.CombineSourceArtifactAndTags() {
-			_, err := io.WriteString(hasher, fullImage)
+	for _, artifact := range artifacts {
+		for _, fullArtifact := range artifact.CombineSourceArtifactAndTags() {
+			_, err := io.WriteString(hasher, fullArtifact)
 			if err != nil {
-				return "", fmt.Errorf("failed to write full image %q: %w", fullImage, err)
+				return "", fmt.Errorf("failed to write full artifact %q: %w", fullArtifact, err)
 			}
 		}
 	}

tools/internal/autoupdate/config_test.go

@@ -23,7 +23,7 @@ func TestConfigEntry(t *testing.T) {
 					GithubRelease: &GithubRelease{
 						Owner:      "test-owner",
 						Repository: "test-repo",
-						Images:     []AutoupdateImageRef{{SourceImage: "rancher/rancher"}},
+						Artifacts:  []AutoupdateArtifactRef{{SourceArtifact: "rancher/rancher"}},
 					},
 					Reviewers: []string{"user", "org/team"},
 				},
@@ -50,7 +50,7 @@ func TestConfigEntry(t *testing.T) {
 				ConfigEntry: ConfigEntry{
 					Name: "test-entry",
 					Registry: &Registry{
-						Images:        []AutoupdateImageRef{{SourceImage: "rancher/rancher"}},
+						Artifacts:     []AutoupdateArtifactRef{{SourceArtifact: "rancher/rancher"}},
 						Latest:        false,
 						VersionFilter: "^v1\\.([3-9][0-9])\\.[0-9]+$",
 					},
@@ -65,7 +65,7 @@ func TestConfigEntry(t *testing.T) {
 					GithubRelease: &GithubRelease{
 						Owner:      "test-owner",
 						Repository: "test-repo",
-						Images:     []AutoupdateImageRef{{SourceImage: "rancher/rancher"}},
+						Artifacts:  []AutoupdateArtifactRef{{SourceArtifact: "rancher/rancher"}},
 					},
 				},
 				ExpectedError: "must specify Name",
@@ -84,8 +84,8 @@ func TestConfigEntry(t *testing.T) {
 					GithubRelease: &GithubRelease{
 						Owner:      "test-owner",
 						Repository: "test-repo",
-						Images: []AutoupdateImageRef{{
-							SourceImage: "rancher/rancher",
+						Artifacts: []AutoupdateArtifactRef{{
+							SourceArtifact: "rancher/rancher",
 						}},
 					},
 					HelmLatest: &HelmLatest{
@@ -106,7 +106,7 @@ func TestConfigEntry(t *testing.T) {
 					GithubRelease: &GithubRelease{
 						Owner:      "test-owner",
 						Repository: "test-repo",
-						Images:     []AutoupdateImageRef{{SourceImage: "rancher/rancher"}},
+						Artifacts:  []AutoupdateArtifactRef{{SourceArtifact: "rancher/rancher"}},
 					},
 					Reviewers: []string{"user", "org/team"},
 				},
@@ -119,7 +119,7 @@ func TestConfigEntry(t *testing.T) {
 					GithubRelease: &GithubRelease{
 						Owner:      "test-owner",
 						Repository: "test-repo",
-						Images:     []AutoupdateImageRef{{SourceImage: "rancher/rancher"}},
+						Artifacts:  []AutoupdateArtifactRef{{SourceArtifact: "rancher/rancher"}},
 					},
 					Reviewers: []string{"org/team/foo"},
 				},
@@ -132,7 +132,7 @@ func TestConfigEntry(t *testing.T) {
 					GithubRelease: &GithubRelease{
 						Owner:      "test-owner",
 						Repository: "test-repo",
-						Images:     []AutoupdateImageRef{{SourceImage: "rancher/rancher"}},
+						Artifacts:  []AutoupdateArtifactRef{{SourceArtifact: "rancher/rancher"}},
 					},
 					Reviewers: []string{"org/"},
 				},
@@ -145,7 +145,7 @@ func TestConfigEntry(t *testing.T) {
 					GithubRelease: &GithubRelease{
 						Owner:      "test-owner",
 						Repository: "test-repo",
-						Images:     []AutoupdateImageRef{{SourceImage: "rancher/rancher"}},
+						Artifacts:  []AutoupdateArtifactRef{{SourceArtifact: "rancher/rancher"}},
 					},
 					Reviewers: []string{"/team"},
 				},
@@ -158,7 +158,7 @@ func TestConfigEntry(t *testing.T) {
 					GithubRelease: &GithubRelease{
 						Owner:      "test-owner",
 						Repository: "test-repo",
-						Images:     []AutoupdateImageRef{{SourceImage: "rancher/rancher"}},
+						Artifacts:  []AutoupdateArtifactRef{{SourceArtifact: "rancher/rancher"}},
 					},
 					Reviewers: []string{},
 				},
@@ -171,7 +171,7 @@ func TestConfigEntry(t *testing.T) {
 					GithubRelease: &GithubRelease{
 						Owner:      "test-owner",
 						Repository: "test-repo",
-						Images:     []AutoupdateImageRef{{SourceImage: "rancher/rancher"}},
+						Artifacts:  []AutoupdateArtifactRef{{SourceArtifact: "rancher/rancher"}},
 					},
 					Reviewers: nil,
 				},
@@ -199,11 +199,11 @@ func TestGetBranchHash(t *testing.T) {
 		assert.Nil(t, err)
 
 		imageSet1 := []*config.Artifact{image1, image2}
-		hash1, err := hashImageSet(imageSet1)
+		hash1, err := hashArtifactSet(imageSet1)
 		assert.Nil(t, err)
 
 		imageSet2 := []*config.Artifact{image2, image1}
-		hash2, err := hashImageSet(imageSet2)
+		hash2, err := hashArtifactSet(imageSet2)
 		assert.Nil(t, err)
 
 		assert.Equal(t, hash1, hash2)
@@ -213,13 +213,13 @@ func TestGetBranchHash(t *testing.T) {
 		image1, err := config.NewArtifact("test-org/image", []string{"asdf", "qwer"}, "", nil, nil)
 		assert.Nil(t, err)
 		images1 := []*config.Artifact{image1}
-		hash1, err := hashImageSet(images1)
+		hash1, err := hashArtifactSet(images1)
 		assert.Nil(t, err)
 
 		image2, err := config.NewArtifact("test-org/image", []string{"qwer", "asdf"}, "", nil, nil)
 		assert.Nil(t, err)
 		images2 := []*config.Artifact{image2}
-		hash2, err := hashImageSet(images2)
+		hash2, err := hashArtifactSet(images2)
 		assert.Nil(t, err)
 
 		assert.Equal(t, hash1, hash2)
@@ -232,11 +232,11 @@ func TestGetBranchHash(t *testing.T) {
 		assert.Nil(t, err)
 
 		imageSet1 := []*config.Artifact{image1, image2}
-		hash1, err := hashImageSet(imageSet1)
+		hash1, err := hashArtifactSet(imageSet1)
 		assert.Nil(t, err)
 
 		imageSet2 := []*config.Artifact{image1, image2}
-		hash2, err := hashImageSet(imageSet2)
+		hash2, err := hashArtifactSet(imageSet2)
 		assert.Nil(t, err)
 
 		assert.Equal(t, hash1, hash2)
@@ -246,13 +246,13 @@ func TestGetBranchHash(t *testing.T) {
 		image1, err := config.NewArtifact("test-org/image", []string{"asdf", "qwer"}, "", nil, nil)
 		assert.Nil(t, err)
 		images1 := []*config.Artifact{image1}
-		hash1, err := hashImageSet(images1)
+		hash1, err := hashArtifactSet(images1)
 		assert.Nil(t, err)
 
 		image2, err := config.NewArtifact("test-org/image", []string{"asdf", "qwer", "zxcv"}, "", nil, nil)
 		assert.Nil(t, err)
 		images2 := []*config.Artifact{image2}
-		hash2, err := hashImageSet(images2)
+		hash2, err := hashArtifactSet(images2)
 		assert.Nil(t, err)
 
 		assert.NotEqual(t, hash1, hash2)