Write layer files out to zip files

Author: clareliguori

main.go

@@ -3,7 +3,6 @@ package main
 import (
 	"context"
 	"fmt"
-	"log"
 	"os"
 	"path/filepath"
 
@@ -60,7 +59,7 @@ func ConvertImage(name string) (retErr error) {
 	// Unpack and inspect each image layer, copy relevant files to new Lambda layer
 	dir, err := os.Getwd()
 	if err != nil {
-		log.Fatal(err)
+		return err
 	}
 	layerOutputDir := filepath.Join(dir, "image-output", name)
 	if err := os.MkdirAll(layerOutputDir, 0777); err != nil {

repack_layer.go

@@ -4,30 +4,46 @@ import (
 	"archive/tar"
 	"fmt"
 	"io"
-	"log"
+	"os"
 	"strings"
 
 	zglob "github.com/mattn/go-zglob"
 	"github.com/mholt/archiver"
+	"github.com/pkg/errors"
 )
 
 // Converts container image layer archive (tar) to Lambda layer archive (zip).
 // Filters files from the source and only writes a new archive if at least
 // one file in the source matches the filter (i.e. does not create empty archives).
-func RepackLayer(outputFilename string, layerContents io.Reader, filterPattern string) (created bool, err error) {
+func RepackLayer(outputFilename string, layerContents io.Reader, filterPattern string) (created bool, retError error) {
 	// TODO: support image types other than local Docker images (docker-daemon transport),
 	// where the layer format is tar. For example, layers directly from a Docker registry
 	// will be .tar.gz-formatted. OCI images can be either tar or tar.gz, based on the
 	// layer's media type.
 	t := archiver.NewTar()
 
-	err = t.Open(layerContents, 0)
+	err := t.Open(layerContents, 0)
 	if err != nil {
 		return false, fmt.Errorf("opening layer tar: %v", err)
 	}
 	defer t.Close()
 
 	// Walk the files in the tar
+	z := (*archiver.Zip)(nil)
+	out := (*os.File)(nil)
+	defer func() {
+		if z != nil {
+			if err := z.Close(); err != nil {
+				retError = errors.Wrapf(err, " (zip close error: %v)", err)
+			}
+		}
+		if out != nil {
+			if err := out.Close(); err != nil {
+				retError = errors.Wrapf(err, " (file close error: %v)", err)
+			}
+		}
+	}()
+
 	for {
 		// Get next file in tar
 		f, err := t.Read()
@@ -45,15 +61,38 @@ func RepackLayer(outputFilename string, layerContents io.Reader, filterPattern s
 			return false, fmt.Errorf("filtering file in layer tar: %v", err)
 		}
 		if repack {
-			err = repackLayerFile(f)
+			if z == nil {
+				z, out, err = startZipFile(outputFilename)
+				if err != nil {
+					return false, fmt.Errorf("starting zip file: %v", err)
+				}
+			}
+
+			err = repackLayerFile(f, z)
 		}
 
 		if err != nil {
 			return false, fmt.Errorf("walking %s in layer tar: %v", f.Name(), err)
 		}
 	}
 
-	return false, nil
+	return (z != nil), nil
+}
+
+func startZipFile(destination string) (zip *archiver.Zip, zipFile *os.File, err error) {
+	z := archiver.NewZip()
+
+	out, err := os.Create(destination)
+	if err != nil {
+		return nil, nil, fmt.Errorf("creating %s: %v", destination, err)
+	}
+
+	err = z.Create(out)
+	if err != nil {
+		return nil, nil, fmt.Errorf("creating zip: %v", err)
+	}
+
+	return z, out, nil
 }
 
 func shouldRepackLayerFile(f archiver.File, matchPattern string) (should bool, err error) {
@@ -62,19 +101,36 @@ func shouldRepackLayerFile(f archiver.File, matchPattern string) (should bool, e
 		return false, fmt.Errorf("expected header to be *tar.Header but was %T", f.Header)
 	}
 
-	if f.IsDir() {
+	if f.IsDir() || header.Typeflag == tar.TypeDir {
 		return false, nil
 	}
 
+	// Ignore whiteout files
 	if strings.HasPrefix(f.Name(), ".wh.") {
 		return false, nil
 	}
 
 	return zglob.Match(matchPattern, header.Name)
 }
 
-func repackLayerFile(f archiver.File) error {
-	log.Printf(f.Header.(*tar.Header).Name)
+func repackLayerFile(f archiver.File, z *archiver.Zip) error {
+	hdr, ok := f.Header.(*tar.Header)
+	if !ok {
+		return fmt.Errorf("expected header to be *tar.Header but was %T", f.Header)
+	}
 
-	return nil
+	switch hdr.Typeflag {
+	case tar.TypeReg, tar.TypeRegA, tar.TypeChar, tar.TypeBlock, tar.TypeFifo, tar.TypeSymlink, tar.TypeLink:
+		return z.Write(archiver.File{
+			FileInfo: archiver.FileInfo{
+				FileInfo:   f.FileInfo,
+				CustomName: hdr.Name,
+			},
+			ReadCloser: f,
+		})
+	case tar.TypeXGlobalHeader:
+		return nil // ignore
+	default:
+		return fmt.Errorf("%s: unknown type flag: %c", hdr.Name, hdr.Typeflag)
+	}
 }