feat: add support of local '.tar.gz' file inside the kaniko container

README.md

@@ -145,6 +145,7 @@ When running kaniko, use the `--context` flag with the appropriate prefix to spe
 | Source | Prefix | Example |
 |---------|---------|---------|
 | Local Directory | dir://[path to a directory in the kaniko container] | `dir:///workspace` |
+| Local Tar Gz | tar://[path to a .tar.gz in the kaniko container] | `tar://path/to/context.tar.gz` |
 | GCS Bucket | gs://[bucket name]/[path to .tar.gz] | `gs://kaniko-bucket/path/to/context.tar.gz` |
 | S3 Bucket | s3://[bucket name]/[path to .tar.gz] | `s3://kaniko-bucket/path/to/context.tar.gz` |
 | Azure Blob Storage| https://[account].[azureblobhostsuffix]/[container]/[path to .tar.gz] | `https://myaccount.blob.core.windows.net/container/path/to/context.tar.gz` |

cmd/executor/cmd/root.go

@@ -230,7 +230,7 @@ func copyDockerfile() error {
  return nil
 }
 
-// resolveSourceContext unpacks the source context if it is a tar in a bucket
+// resolveSourceContext unpacks the source context if it is a tar in a bucket or in kaniko container
 // it resets srcContext to be the path to the unpacked build context within the image
 func resolveSourceContext() error {
  if opts.SrcContext == "" && opts.Bucket == "" {

integration/integration_test.go

@@ -33,11 +33,10 @@ import (
  "github.com/google/go-containerregistry/pkg/name"
  "github.com/google/go-containerregistry/pkg/v1/daemon"
 
- "github.com/pkg/errors"
-
  "github.com/GoogleContainerTools/kaniko/pkg/timing"
  "github.com/GoogleContainerTools/kaniko/pkg/util"
  "github.com/GoogleContainerTools/kaniko/testutil"
+ "github.com/pkg/errors"
 )
 
 var config *integrationTestConfig

pkg/buildcontext/buildcontext.go

@@ -24,6 +24,10 @@ import (
  "github.com/GoogleContainerTools/kaniko/pkg/util"
 )
 
+const (
+ TarBuildContextPrefix = "tar://"
+)
+
 // BuildContext unifies calls to download and unpack the build context.
 type BuildContext interface {
  // Unpacks a build context and returns the directory where it resides
@@ -51,6 +55,8 @@ func GetBuildContext(srcContext string) (BuildContext, error) {
  return &AzureBlob{context: srcContext}, nil
  }
  return nil, errors.New("url provided for https context is not in a supported format, please use the https url for Azure Blob Storage")
+ case TarBuildContextPrefix:
+ return &Tar{context: context}, nil
  }
- return nil, errors.New("unknown build context prefix provided, please use one of the following: gs://, dir://, s3://, git://, https://")
+ return nil, errors.New("unknown build context prefix provided, please use one of the following: gs://, dir://, tar://, s3://, git://, https://")
 }

pkg/buildcontext/tar.go

@@ -0,0 +1,40 @@
+/*
+Copyright 2018 Google LLC
+
+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.
+*/
+
+package buildcontext
+
+import (
+ "os"
+
+ "github.com/GoogleContainerTools/kaniko/pkg/constants"
+ "github.com/GoogleContainerTools/kaniko/pkg/util"
+ "github.com/pkg/errors"
+)
+
+// Tar unifies calls to download and unpack the build context.
+type Tar struct {
+ context string
+}
+
+// UnpackTarFromBuildContext unpack the compressed tar file
+func (t *Tar) UnpackTarFromBuildContext() (string, error) {
+ directory := constants.BuildContextDir
+ if err := os.MkdirAll(directory, 0750); err != nil {
+ return "", errors.Wrap(err, "unpacking tar from build context")
+ }
+
+ return directory, util.UnpackCompressedTar(t.context, directory)
+}

pkg/buildcontext/tar_test.go

@@ -0,0 +1,158 @@
+/*
+Copyright 2018 Google LLC
+
+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.
+*/
+
+package buildcontext
+
+import (
+ "bytes"
+ "compress/gzip"
+ "fmt"
+ "io/ioutil"
+ "os"
+ "path/filepath"
+ "runtime"
+ "sync"
+ "testing"
+
+ "github.com/GoogleContainerTools/kaniko/pkg/util"
+ "github.com/GoogleContainerTools/kaniko/testutil"
+)
+
+func TestBuildWithLocalTar(t *testing.T) {
+ _, ex, _, _ := runtime.Caller(0)
+ cwd := filepath.Dir(ex)
+
+ testDir := "test_dir"
+ testDirLongPath := filepath.Join(cwd, testDir)
+ dirUnpack := filepath.Join(testDirLongPath, "dir_where_to_unpack")
+
+ if err := os.MkdirAll(dirUnpack, 0750); err != nil {
+ t.Errorf("Failed to create dir_where_to_extract: %v", err)
+ }
+
+ validDockerfile := "Dockerfile_valid"
+ invalidDockerfile := "Dockerfile_invalid"
+ nonExistingDockerfile := "Dockerfile_non_existing"
+
+ files := map[string]string{
+ validDockerfile: "FROM debian:9.11\nRUN echo \"valid\"",
+ invalidDockerfile: "FROM debian:9.11\nRUN echo \"invalid\"",
+ }
+
+ if err := testutil.SetupFiles(testDir, files); err != nil {
+ t.Errorf("Failed to setup files %v on %s: %v", files, testDir, err)
+ }
+
+ if err := os.Chdir(testDir); err != nil {
+ t.Fatalf("Failed to Chdir on %s: %v", testDir, err)
+ }
+
+ validTarPath := fmt.Sprintf("%s.tar.gz", validDockerfile)
+ invalidTarPath := fmt.Sprintf("%s.tar.gz", invalidDockerfile)
+ nonExistingTarPath := fmt.Sprintf("%s.tar.gz", nonExistingDockerfile)
+
+ var wg sync.WaitGroup
+ wg.Add(1)
+ // Create Tar Gz File with dockerfile inside
+ go func(wg *sync.WaitGroup) {
+ defer wg.Done()
+ validTarFile, err := os.Create(validTarPath)
+ if err != nil {
+ t.Errorf("Failed to create %s: %v", validTarPath, err)
+ }
+ defer validTarFile.Close()
+
+ invalidTarFile, err := os.Create(invalidTarPath)
+ if err != nil {
+ t.Errorf("Failed to create %s: %v", invalidTarPath, err)
+ }
+ defer invalidTarFile.Close()
+
+ gw := gzip.NewWriter(validTarFile)
+ defer gw.Close()
+
+ tw := util.NewTar(gw)
+ defer tw.Close()
+
+ if err := tw.AddFileToTar(validDockerfile); err != nil {
+ t.Errorf("Failed to add %s to %s: %v", validDockerfile, validTarPath, err)
+ }
+ }(&wg)
+
+ // Waiting for the Tar Gz file creation to be done before moving on
+ wg.Wait()
+
+ tests := []struct {
+ dockerfile string
+ srcContext string
+ unpackShouldErr bool
+ srcShaShouldErr bool
+ destShaShouldErr bool
+ }{
+ {
+ dockerfile: validDockerfile,
+ srcContext: filepath.Join(testDir, validTarPath),
+ unpackShouldErr: false,
+ srcShaShouldErr: false,
+ destShaShouldErr: false,
+ },
+ {
+ dockerfile: invalidDockerfile,
+ srcContext: filepath.Join(testDir, invalidTarPath),
+ unpackShouldErr: true,
+ srcShaShouldErr: false,
+ destShaShouldErr: true,
+ },
+ {
+ dockerfile: nonExistingDockerfile,
+ srcContext: filepath.Join(testDir, nonExistingTarPath),
+ unpackShouldErr: true,
+ srcShaShouldErr: true,
+ destShaShouldErr: true,
+ },
+ }
+
+ for _, tt := range tests {
+ t.Run(tt.dockerfile, func(t *testing.T) {
+ err := util.UnpackCompressedTar(filepath.Join(cwd, tt.srcContext), dirUnpack)
+ testutil.CheckError(t, tt.unpackShouldErr, err)
+ srcSHA, err := getSHAFromFilePath(tt.dockerfile)
+ testutil.CheckError(t, tt.srcShaShouldErr, err)
+ destSHA, err := getSHAFromFilePath(filepath.Join(dirUnpack, tt.dockerfile))
+ testutil.CheckError(t, tt.destShaShouldErr, err)
+ if err == nil {
+ testutil.CheckDeepEqual(t, srcSHA, destSHA)
+ }
+ })
+ }
+
+ if err := os.RemoveAll(testDirLongPath); err != nil {
+ t.Errorf("Failed to remove %s: %v", testDirLongPath, err)
+ }
+}
+
+func getSHAFromFilePath(f string) (string, error) {
+ data, err := ioutil.ReadFile(f)
+ if err != nil {
+ return "", err
+ }
+ sha, err := util.SHA256(bytes.NewReader(data))
+ if err != nil {
+ return "", err
+ }
+
+ return sha, nil
+}