fix(kaniko): set cpe consistently (#3545)

cmd/kanikoExecute.go

@@ -151,6 +151,9 @@ func runKanikoExecute(config *kanikoExecuteOptions, telemetryData *telemetry.Cus
 				}
 
 				return nil
+			} else {
+				commonPipelineEnvironment.container.imageNames = append(commonPipelineEnvironment.container.imageNames, config.ContainerImageName)
+				commonPipelineEnvironment.container.imageNameTags = append(commonPipelineEnvironment.container.imageNameTags, fmt.Sprintf("%v:%v", config.ContainerImageName, containerImageTag))
 			}
 
 			log.Entry().Debugf("Single image build for image name '%v'", config.ContainerImageName)
@@ -165,14 +168,41 @@ func runKanikoExecute(config *kanikoExecuteOptions, telemetryData *telemetry.Cus
 				return errors.Wrapf(err, "invalid registry part in image %v", config.ContainerImage)
 			}
 			// errors are already caught with previous call to docker.ContainerRegistryFromImage
+			containerImageName, _ := docker.ContainerImageNameFromImage(config.ContainerImage)
 			containerImageNameTag, _ := docker.ContainerImageNameTagFromImage(config.ContainerImage)
 			dest = []string{"--destination", config.ContainerImage}
 			commonPipelineEnvironment.container.registryURL = fmt.Sprintf("https://%v", containerRegistry)
 			commonPipelineEnvironment.container.imageNameTag = containerImageNameTag
+			commonPipelineEnvironment.container.imageNameTags = append(commonPipelineEnvironment.container.imageNameTags, containerImageNameTag)
+			commonPipelineEnvironment.container.imageNames = append(commonPipelineEnvironment.container.imageNames, containerImageName)
 		}
 		config.BuildOptions = append(config.BuildOptions, dest...)
 	} else {
 		log.Entry().Infof("Running Kaniko build with destination defined via buildOptions: %v", config.BuildOptions)
+
+		destination := ""
+
+		for i, o := range config.BuildOptions {
+			if o == "--destination" && i+1 < len(config.BuildOptions) {
+				destination = config.BuildOptions[i+1]
+				break
+			}
+		}
+
+		containerRegistry, err := docker.ContainerRegistryFromImage(destination)
+
+		if err != nil {
+			log.SetErrorCategory(log.ErrorConfiguration)
+			return errors.Wrapf(err, "invalid registry part in image %v", destination)
+		}
+
+		containerImageName, _ := docker.ContainerImageNameFromImage(destination)
+		containerImageNameTag, _ := docker.ContainerImageNameTagFromImage(destination)
+
+		commonPipelineEnvironment.container.registryURL = fmt.Sprintf("https://%v", containerRegistry)
+		commonPipelineEnvironment.container.imageNameTag = containerImageNameTag
+		commonPipelineEnvironment.container.imageNameTags = append(commonPipelineEnvironment.container.imageNameTags, containerImageNameTag)
+		commonPipelineEnvironment.container.imageNames = append(commonPipelineEnvironment.container.imageNames, containerImageName)
 	}
 
 	// no support for building multiple containers

cmd/kanikoExecute_test.go

@@ -87,6 +87,11 @@ func TestRunKanikoExecute(t *testing.T) {
 
 		assert.Contains(t, commonPipelineEnvironment.custom.buildSettingsInfo, `"mavenExecuteBuild":[{"dockerImage":"maven"}]`)
 		assert.Contains(t, commonPipelineEnvironment.custom.buildSettingsInfo, `"kanikoExecute":[{"dockerImage":"gcr.io/kaniko-project/executor:debug"}]`)
+
+		assert.Equal(t, "myImage:tag", commonPipelineEnvironment.container.imageNameTag)
+		assert.Equal(t, "https://index.docker.io", commonPipelineEnvironment.container.registryURL)
+		assert.Equal(t, []string{"myImage"}, commonPipelineEnvironment.container.imageNames)
+		assert.Equal(t, []string{"myImage:tag"}, commonPipelineEnvironment.container.imageNameTags)
 	})
 
 	t.Run("success case - image params", func(t *testing.T) {
@@ -127,6 +132,51 @@ func TestRunKanikoExecute(t *testing.T) {
 		cwd, _ := fileUtils.Getwd()
 		assert.Equal(t, []string{"--dockerfile", "Dockerfile", "--context", cwd, "--skip-tls-verify-pull", "--destination", "my.registry.com:50000/myImage:1.2.3-a-x"}, runner.Calls[1].Params)
 
+		assert.Equal(t, "myImage:1.2.3-a-x", commonPipelineEnvironment.container.imageNameTag)
+		assert.Equal(t, "https://my.registry.com:50000", commonPipelineEnvironment.container.registryURL)
+		assert.Equal(t, []string{"myImage"}, commonPipelineEnvironment.container.imageNames)
+		assert.Equal(t, []string{"myImage:1.2.3-a-x"}, commonPipelineEnvironment.container.imageNameTags)
+	})
+
+	t.Run("success case - image params with custom destination", func(t *testing.T) {
+		config := &kanikoExecuteOptions{
+			BuildOptions:                []string{"--skip-tls-verify-pull", "--destination", "my.other.registry.com:50000/myImage:3.2.1-a-x"},
+			ContainerPreparationCommand: "rm -f /kaniko/.docker/config.json",
+			CustomTLSCertificateLinks:   []string{"https://test.url/cert.crt"},
+			DockerfilePath:              "Dockerfile",
+			DockerConfigJSON:            "path/to/docker/config.json",
+		}
+
+		runner := &mock.ExecMockRunner{}
+		commonPipelineEnvironment := kanikoExecuteCommonPipelineEnvironment{}
+
+		certClient := &kanikoMockClient{
+			responseBody: "testCert",
+		}
+		fileUtils := &mock.FilesMock{}
+		fileUtils.AddFile("path/to/docker/config.json", []byte(`{"auths":{"custom":"test"}}`))
+		fileUtils.AddFile("/kaniko/ssl/certs/ca-certificates.crt", []byte(``))
+
+		err := runKanikoExecute(config, &telemetry.CustomData{}, &commonPipelineEnvironment, runner, certClient, fileUtils)
+
+		assert.NoError(t, err)
+
+		assert.Equal(t, "rm", runner.Calls[0].Exec)
+		assert.Equal(t, []string{"-f", "/kaniko/.docker/config.json"}, runner.Calls[0].Params)
+
+		assert.Equal(t, config.CustomTLSCertificateLinks, certClient.urlsCalled)
+		c, err := fileUtils.FileRead("/kaniko/.docker/config.json")
+		assert.NoError(t, err)
+		assert.Equal(t, `{"auths":{"custom":"test"}}`, string(c))
+
+		assert.Equal(t, "/kaniko/executor", runner.Calls[1].Exec)
+		cwd, _ := fileUtils.Getwd()
+		assert.Equal(t, []string{"--dockerfile", "Dockerfile", "--context", cwd, "--skip-tls-verify-pull", "--destination", "my.other.registry.com:50000/myImage:3.2.1-a-x"}, runner.Calls[1].Params)
+
+		assert.Equal(t, "myImage:3.2.1-a-x", commonPipelineEnvironment.container.imageNameTag)
+		assert.Equal(t, "https://my.other.registry.com:50000", commonPipelineEnvironment.container.registryURL)
+		assert.Equal(t, []string{"myImage"}, commonPipelineEnvironment.container.imageNames)
+		assert.Equal(t, []string{"myImage:3.2.1-a-x"}, commonPipelineEnvironment.container.imageNameTags)
 	})
 
 	t.Run("no error case - when cert update skipped", func(t *testing.T) {

pkg/docker/container.go

@@ -3,6 +3,7 @@ package docker
 import (
 	"fmt"
 	"net/url"
+	"regexp"
 	"strings"
 
 	containerName "github.com/google/go-containerregistry/pkg/name"
@@ -39,3 +40,17 @@ func ContainerImageNameTagFromImage(fullImage string) (string, error) {
 	registryOnly := fmt.Sprintf("%v/", ref.Context().RegistryStr())
 	return strings.ReplaceAll(fullImage, registryOnly, ""), nil
 }
+
+// ContainerImageNameFromImage returns the image name of a given docker reference
+func ContainerImageNameFromImage(fullImage string) (string, error) {
+	imageNameTag, err := ContainerImageNameTagFromImage(fullImage)
+
+	if err != nil {
+		return "", err
+	}
+
+	r := regexp.MustCompile(`([^:@]+)`)
+	m := r.FindStringSubmatch(imageNameTag)
+
+	return m[0], nil
+}

pkg/docker/container_test.go

@@ -105,3 +105,36 @@ func TestContainerImageNameTagFromImage(t *testing.T) {
 		})
 	}
 }
+
+func TestContainerImageNameFromImage(t *testing.T) {
+	tt := []struct {
+		image         string
+		expected      string
+		expectedError string
+	}{
+		{image: "", expected: "", expectedError: "failed to parse image name"},
+		{image: "onlyImage", expected: "onlyImage"},
+		{image: "onlyimage", expected: "onlyimage"},
+		{image: "onlyimage:withTag", expected: "onlyimage"},
+		{image: "onlyimage@sha256:152f65865ae43b143b1e42dacdb5e9c473dd70b3adc5b79af7cf585cc8605205", expected: "onlyimage"},
+		{image: "path/to/image", expected: "path/to/image"},
+		{image: "my.registry.com/onlyimage", expected: "onlyimage"},
+		{image: "my.registry.com:50000/onlyimage", expected: "onlyimage"},
+		{image: "my.registry.com:50000/onlyimage:withTag", expected: "onlyimage"},
+		{image: "my.registry.com:50000/onlyimage@sha256:152f65865ae43b143b1e42dacdb5e9c473dd70b3adc5b79af7cf585cc8605205", expected: "onlyimage"},
+		{image: "my.registry.com:50000/path/to/image:withTag", expected: "path/to/image"},
+		{image: "my.registry.com:50000/path/to/image@sha256:152f65865ae43b143b1e42dacdb5e9c473dd70b3adc5b79af7cf585cc8605205", expected: "path/to/image"},
+	}
+
+	for _, test := range tt {
+		t.Run(test.image, func(t *testing.T) {
+			got, err := ContainerImageNameFromImage(test.image)
+			if len(test.expectedError) > 0 {
+				assert.Contains(t, fmt.Sprint(err), test.expectedError)
+			} else {
+				assert.NoError(t, err)
+			}
+			assert.Equal(t, test.expected, got)
+		})
+	}
+}