Add .zip file support

pkg/compress/types.go

@@ -29,3 +29,16 @@ func extraFile(name, targetName, tarFile string, header *tar.Header, tarReader *
 	_ = targetFile.Close()
 	return
 }
+
+// GetCompressor gets the compressor base on file extension
+func GetCompressor(extension string, additionBinaries []string) Compress {
+	// Select the right decompressor based on file type
+	switch extension {
+	case ".xz":
+		return NewXz(additionBinaries)
+	case ".zip":
+		return NewZip(additionBinaries)
+	default:
+		return NewGZip(additionBinaries)
+	}
+}

pkg/compress/types_test.go

@@ -0,0 +1,37 @@
+package compress
+
+import (
+	"reflect"
+	"testing"
+)
+
+func TestGetCompressor(t *testing.T) {
+	type args struct {
+		extension        string
+		additionBinaries []string
+	}
+	tests := []struct {
+		name string
+		args args
+		want Compress
+	}{{
+		name: "unknown type",
+		args: args{extension: ".xdf"},
+		want: NewGZip(nil),
+	}, {
+		name: ".zip",
+		args: args{extension: ".zip"},
+		want: NewZip(nil),
+	}, {
+		name: ".xz",
+		args: args{extension: ".xz"},
+		want: NewXz(nil),
+	}}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := GetCompressor(tt.args.extension, tt.args.additionBinaries); !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("GetCompressor() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}

pkg/compress/xz.go

@@ -20,6 +20,9 @@ func NewXz(additionBinaries []string) *Xz {
 	return &Xz{additionBinaries: additionBinaries}
 }
 
+// make sure Xz implements the interface Compress
+var _ Compress = &Xz{}
+
 // ExtractFiles extracts files from a target compress file
 func (x *Xz) ExtractFiles(sourceFile, targetName string) (err error) {
 	if targetName == "" {

pkg/compress/zip.go

@@ -0,0 +1,58 @@
+package compress
+
+import (
+	"archive/zip"
+	"fmt"
+	"io"
+	"os"
+	"path/filepath"
+	"strings"
+)
+
+// Zip implements a compress which is base on zip file
+type Zip struct {
+	additionBinaries []string
+}
+
+// NewZip creates an instance of zip
+func NewZip(additionBinaries []string) *Zip {
+	return &Zip{additionBinaries: additionBinaries}
+}
+
+// make sure Zip implements the interface Compress
+var _ Compress = &Zip{}
+
+// ExtractFiles extracts files from a target compress file
+func (z *Zip) ExtractFiles(sourceFile, targetName string) (err error) {
+	var archive *zip.ReadCloser
+	archive, err = zip.OpenReader(sourceFile)
+	defer func() {
+		_ = archive.Close()
+	}()
+
+	for _, f := range archive.File {
+		if f.FileInfo().IsDir() {
+			continue
+		}
+
+		if strings.HasPrefix(f.Name, "/"+targetName) {
+			var targetFile *os.File
+			if targetFile, err = os.OpenFile(fmt.Sprintf("%s/%s", filepath.Dir(sourceFile), targetName),
+				os.O_CREATE|os.O_RDWR, f.Mode()); err != nil {
+				return
+			}
+
+			var fileInArchive io.ReadCloser
+			fileInArchive, err = f.Open()
+			if err != nil {
+				return
+			}
+			if _, err = io.Copy(targetFile, fileInArchive); err != nil {
+				return
+			}
+			_ = targetFile.Close()
+			return
+		}
+	}
+	return
+}

pkg/installer/process.go

@@ -113,14 +113,6 @@ func (o *Installer) OverWriteBinary(sourceFile, targetPath string) (err error) {
 }
 
 func (o *Installer) extractFiles(tarFile, targetName string) (err error) {
-	// Select the right decompressor based on file type
-	extension := path.Ext(tarFile)
-	var compressor compress.Compress
-	if extension == ".xz" {
-		compressor = compress.NewXz(o.AdditionBinaries)
-	} else {
-		compressor = compress.NewGZip(o.AdditionBinaries)
-	}
-	err = compressor.ExtractFiles(tarFile, targetName)
+	err = compress.GetCompressor(path.Ext(tarFile), o.AdditionBinaries).ExtractFiles(tarFile, targetName)
 	return
 }