root: add --registry-mirror flag

README.md

@@ -59,6 +59,7 @@ _If you are interested in contributing to kaniko, see [DEVELOPMENT.md](DEVELOPME
     - [--insecure](#--insecure)
     - [--insecure-pull](#--insecure-pull)
     - [--no-push](#--no-push)
+    - [--registry-mirror](#--registry-mirror)
     - [--reproducible](#--reproducible)
     - [--single-snapshot](#--single-snapshot)
     - [--skip-tls-verify](#--skip-tls-verify)
@@ -476,6 +477,10 @@ Set this flag if you want to pull images from a plain HTTP registry. It is suppo
 
 Set this flag if you only want to build the image, without pushing to a registry.
 
+#### --registry-mirror
+
+Set this flag if you want to use a registry mirror instead of default `index.docker.io`.
+
 #### --reproducible
 
 Set this flag to strip timestamps out of the built image and make it reproducible.

cmd/executor/cmd/root.go

@@ -144,6 +144,7 @@ func addKanikoOptionsFlags() {
 	RootCmd.PersistentFlags().DurationVarP(&opts.CacheTTL, "cache-ttl", "", time.Hour*336, "Cache timeout in hours. Defaults to two weeks.")
 	RootCmd.PersistentFlags().VarP(&opts.InsecureRegistries, "insecure-registry", "", "Insecure registry using plain HTTP to push and pull. Set it repeatedly for multiple registries.")
 	RootCmd.PersistentFlags().VarP(&opts.SkipTLSVerifyRegistries, "skip-tls-verify-registry", "", "Insecure registry ignoring TLS verify to push and pull. Set it repeatedly for multiple registries.")
+	RootCmd.PersistentFlags().StringVarP(&opts.RegistryMirror, "registry-mirror", "", "", "Registry mirror to use has pull-through cache instead of docker.io.")
 }
 
 // addHiddenFlags marks certain flags as hidden from the executor help text

integration/dockerfiles/Dockerfile_test_run_3

@@ -0,0 +1,20 @@
+# Copyright 2018 Google, Inc. 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.
+
+# Test to make sure the executor builds an image correctly
+# when no files are changed
+
+FROM google-appengine/debian9@sha256:1d6a9a6d106bd795098f60f4abb7083626354fa6735e81743c7f8cfca11259f0
+RUN echo "hey" 
+MAINTAINER kaniko

integration/integration_test.go

@@ -65,6 +65,7 @@ const (
        }
      }
    ]`
+	dockerfileTestRun = "integration/dockerfiles/Dockerfile_test_run_2"
 )
 
 func TestMain(m *testing.M) {
@@ -183,7 +184,6 @@ func TestRun(t *testing.T) {
 
 func TestGitBuildcontext(t *testing.T) {
 	repo := "github.com/GoogleContainerTools/kaniko"
-	dockerfile := "integration/dockerfiles/Dockerfile_test_run_2"
 
 	// Build with docker
 	dockerImage := GetDockerImage(config.imageRepo, "Dockerfile_test_git")
@@ -226,14 +226,55 @@ func TestGitBuildcontext(t *testing.T) {
 
 func TestGitBuildContextWithBranch(t *testing.T) {
 	repo := "github.com/GoogleContainerTools/kaniko#refs/tags/v0.10.0"
-	dockerfile := "integration/dockerfiles/Dockerfile_test_run_2"
 
 	// Build with docker
 	dockerImage := GetDockerImage(config.imageRepo, "Dockerfile_test_git")
 	dockerCmd := exec.Command("docker",
 		append([]string{"build",
 			"-t", dockerImage,
+			"-f", dockerfileTestRun,
+			repo})...)
+	out, err := RunCommandWithoutTest(dockerCmd)
+	if err != nil {
+		t.Errorf("Failed to build image %s with docker command \"%s\": %s %s", dockerImage, dockerCmd.Args, err, string(out))
+	}
+
+	// Build with kaniko
+	kanikoImage := GetKanikoImage(config.imageRepo, "Dockerfile_test_git")
+	kanikoCmd := exec.Command("docker",
+		append([]string{"run",
+			"-v", os.Getenv("HOME") + "/.config/gcloud:/root/.config/gcloud",
+			ExecutorImage,
 			"-f", dockerfile,
+			"-d", kanikoImage,
+			"-c", fmt.Sprintf("git://%s", repo)})...)
+
+	out, err = RunCommandWithoutTest(kanikoCmd)
+	if err != nil {
+		t.Errorf("Failed to build image %s with kaniko command \"%s\": %v %s", dockerImage, kanikoCmd.Args, err, string(out))
+	}
+
+	// container-diff
+	daemonDockerImage := daemonPrefix + dockerImage
+	containerdiffCmd := exec.Command("container-diff", "diff", "--no-cache",
+		daemonDockerImage, kanikoImage,
+		"-q", "--type=file", "--type=metadata", "--json")
+	diff := RunCommand(containerdiffCmd, t)
+	t.Logf("diff = %s", string(diff))
+
+	expected := fmt.Sprintf(emptyContainerDiff, dockerImage, kanikoImage, dockerImage, kanikoImage)
+	checkContainerDiffOutput(t, diff, expected)
+}
+
+func TestBuildViaRegistryMirror(t *testing.T) {
+	repo := "github.com/GoogleContainerTools/kaniko"
+
+	// Build with docker
+	dockerImage := GetDockerImage(config.imageRepo, "Dockerfile_test_git")
+	dockerCmd := exec.Command("docker",
+		append([]string{"build",
+			"-t", dockerImage,
+			"-f", dockerfileTestRun,
 			repo})...)
 	out, err := RunCommandWithoutTest(dockerCmd)
 	if err != nil {
@@ -242,12 +283,14 @@ func TestGitBuildContextWithBranch(t *testing.T) {
 
 	// Build with kaniko
 	kanikoImage := GetKanikoImage(config.imageRepo, "Dockerfile_test_git")
+	dockerfile = "integration/dockerfiles/Dockerfile_test_run_3"
 	kanikoCmd := exec.Command("docker",
 		append([]string{"run",
 			"-v", os.Getenv("HOME") + "/.config/gcloud:/root/.config/gcloud",
 			ExecutorImage,
 			"-f", dockerfile,
 			"-d", kanikoImage,
+			"--registry-mirror", "gcr.io",
 			"-c", fmt.Sprintf("git://%s", repo)})...)
 
 	out, err = RunCommandWithoutTest(kanikoCmd)

pkg/config/options.go

@@ -52,6 +52,7 @@ type KanikoOptions struct {
 	Cleanup                 bool
 	InsecureRegistries      multiArg
 	SkipTLSVerifyRegistries multiArg
+	RegistryMirror          string
 }
 
 // WarmerOptions are options that are set by command line arguments to the cache warmer.

pkg/util/image_util.go

@@ -109,11 +109,26 @@ func remoteImage(image string, opts *config.KanikoOptions) (v1.Image, error) {
 
 func prepareRemoteRequest(ref name.Reference, opts *config.KanikoOptions) ([]remote.Option, error) {
 	registryName := ref.Context().RegistryStr()
+	var newReg name.Registry
+	var err error
+
+	if opts.RegistryMirror != "" && registryName == name.DefaultRegistry {
+		registryName = opts.RegistryMirror
+
+		newReg, err = name.NewRegistry(opts.RegistryMirror, name.StrictValidation)
+		if err != nil {
+			return nil, err
+		}
+	}
+
 	if opts.InsecurePull || opts.InsecureRegistries.Contains(registryName) {
-		newReg, err := name.NewRegistry(registryName, name.WeakValidation, name.Insecure)
+		newReg, err = name.NewRegistry(registryName, name.WeakValidation, name.Insecure)
 		if err != nil {
 			return nil, err
 		}
+	}
+
+	if newReg != ref.Context().Registry {
 		if tag, ok := ref.(name.Tag); ok {
 			tag.Repository.Registry = newReg
 			ref = tag

pkg/util/image_util_test.go

@@ -60,6 +60,7 @@ func Test_StandardImage(t *testing.T) {
 	}, &config.KanikoOptions{})
 	testutil.CheckErrorAndDeepEqual(t, false, err, nil, actual)
 }
+
 func Test_ScratchImage(t *testing.T) {
 	stages, err := parse(dockerfile)
 	if err != nil {
@@ -93,6 +94,20 @@ func Test_TarImage(t *testing.T) {
 	testutil.CheckErrorAndDeepEqual(t, false, err, nil, actual)
 }
 
+func Test_ScratchImageFromMirror(t *testing.T) {
+	stages, err := parse(dockerfile)
+	if err != nil {
+		t.Error(err)
+	}
+	actual, err := RetrieveSourceImage(config.KanikoStage{
+		Stage: stages[1],
+	}, &config.KanikoOptions{
+		RegistryMirror: "mirror.gcr.io",
+	})
+	expected := empty.Image
+	testutil.CheckErrorAndDeepEqual(t, false, err, expected, actual)
+}
+
 // parse parses the contents of a Dockerfile and returns a list of commands
 func parse(s string) ([]instructions.Stage, error) {
 	p, err := parser.Parse(bytes.NewReader([]byte(s)))