Initial commit

Author: sunshineplan

.gitattributes

@@ -0,0 +1,2 @@
+# Auto detect text files and perform LF normalization
+* text=auto

.gitignore

@@ -0,0 +1,2 @@
+go.mod
+go.sum

archive/archive.go

@@ -0,0 +1,33 @@
+package archive
+
+import "os"
+
+// File struct contains bytes body and the provided name field.
+type File struct {
+	Name  string
+	Body  []byte
+	IsDir bool
+}
+
+// Format represents the archive format.
+type Format int
+
+const (
+	// ZIP format
+	ZIP Format = iota
+	// TAR format
+	TAR
+)
+
+func readFiles(files ...string) (fs []File, err error) {
+	for _, f := range files {
+		var file File
+		file.Name = f
+		file.Body, err = os.ReadFile(f)
+		if err != nil {
+			return
+		}
+		fs = append(fs, file)
+	}
+	return
+}

archive/pack.go

@@ -0,0 +1,27 @@
+package archive
+
+import (
+	"errors"
+	"io"
+)
+
+// Pack creates an archive from File struct.
+func Pack(w io.Writer, format Format, files ...File) error {
+	switch format {
+	case ZIP:
+		return packZip(w, files...)
+	case TAR:
+		return packTar(w, files...)
+	default:
+		return errors.New("unknow format")
+	}
+}
+
+// PackFromFiles creates an archive from files.
+func PackFromFiles(w io.Writer, format Format, files ...string) error {
+	fs, err := readFiles(files...)
+	if err != nil {
+		return err
+	}
+	return Pack(w, format, fs...)
+}

archive/pack_test.go

@@ -0,0 +1,43 @@
+package archive
+
+import (
+	"bytes"
+	"testing"
+)
+
+var files = []File{
+	{Name: "testdata/1.txt", Body: []byte("1")},
+	{Name: "testdata/2.txt", Body: []byte("2")},
+}
+
+func TestPackZIP(t *testing.T) {
+	var buf1, buf2 bytes.Buffer
+	if err := Pack(&buf1, ZIP, files...); err != nil {
+		t.Fatal(err)
+	}
+	if err := PackFromFiles(&buf2, ZIP, "testdata/1.txt", "testdata/2.txt"); err != nil {
+		t.Fatal(err)
+	}
+	if !bytes.Equal(buf1.Bytes(), buf2.Bytes()) {
+		t.Error("expected equal zip archive; got not equal")
+	}
+	if !match(zipMagic, buf1.Bytes()[:len(zipMagic)]) {
+		t.Error("expected equal magic; got not equal")
+	}
+}
+
+func TestPackTAR(t *testing.T) {
+	var buf1, buf2 bytes.Buffer
+	if err := Pack(&buf1, TAR, files...); err != nil {
+		t.Fatal(err)
+	}
+	if !match(tarMagic, buf1.Bytes()[:len(tarMagic)]) {
+		t.Error("expected equal magic; got not equal")
+	}
+	if err := PackFromFiles(&buf2, TAR, "testdata/1.txt", "testdata/2.txt"); err != nil {
+		t.Fatal(err)
+	}
+	if !match(tarMagic, buf2.Bytes()[:len(tarMagic)]) {
+		t.Error("expected equal magic; got not equal")
+	}
+}

archive/tar.go

@@ -0,0 +1,73 @@
+package archive
+
+import (
+	"archive/tar"
+	"bytes"
+	"compress/gzip"
+	"io"
+	"log"
+)
+
+const tarMagic = "\x1f\x8b\x08\x00"
+
+func packTar(w io.Writer, files ...File) error {
+	gw := gzip.NewWriter(w)
+	tw := tar.NewWriter(gw)
+
+	for _, file := range files {
+		header := &tar.Header{
+			Name: file.Name,
+			Mode: 0600,
+			Size: int64(len(file.Body)),
+		}
+		if err := tw.WriteHeader(header); err != nil {
+			return err
+		}
+		if _, err := tw.Write(file.Body); err != nil {
+			return err
+		}
+	}
+
+	if err := tw.Close(); err != nil {
+		return err
+	}
+
+	return gw.Close()
+}
+
+func unpackTar(b []byte) ([]File, error) {
+	gr, err := gzip.NewReader(bytes.NewReader(b))
+	if err != nil {
+		return nil, err
+	}
+	tr := tar.NewReader(gr)
+
+	var fs []File
+	for {
+		header, err := tr.Next()
+		if err == io.EOF {
+			break
+		}
+		if err != nil {
+			return nil, err
+		}
+
+		switch header.Typeflag {
+		case tar.TypeDir:
+			fs = append(fs, File{Name: header.Name, IsDir: true})
+		case tar.TypeReg:
+			var buf bytes.Buffer
+			if _, err := io.Copy(&buf, tr); err != nil {
+				return nil, err
+			}
+			fs = append(fs, File{Name: header.Name, Body: buf.Bytes()})
+		default:
+			log.Printf(
+				"ExtractTarGz: uknown type: %v in %s",
+				header.Typeflag,
+				header.Name)
+		}
+	}
+
+	return fs, nil
+}

archive/testdata/1.txt

@@ -0,0 +1 @@
+1

archive/testdata/2.txt

@@ -0,0 +1 @@
+2

archive/testdata/folder.zip

@@ -0,0 +1,80 @@
+package archive
+
+import (
+	"errors"
+	"fmt"
+	"io"
+	"os"
+	"path/filepath"
+)
+
+func match(magic string, b []byte) bool {
+	if len(magic) != len(b) {
+		return false
+	}
+	for i, c := range b {
+		if magic[i] != c && magic[i] != '?' {
+			return false
+		}
+	}
+	return true
+}
+
+// Unpack decompresses an archive to File struct.
+func Unpack(r io.Reader) ([]File, error) {
+	b, err := io.ReadAll(r)
+	if err != nil {
+		return nil, err
+	}
+	switch {
+	case match(zipMagic, b[:len(zipMagic)]):
+		return unpackZip(b)
+	case match(tarMagic, b[:len(tarMagic)]):
+		return unpackTar(b)
+	default:
+		return nil, errors.New("unsupport file format")
+	}
+}
+
+// UnpackToFiles decompresses an archive to files.
+func UnpackToFiles(r io.Reader, dest string) error {
+	files, err := Unpack(r)
+	if err != nil {
+		return err
+	}
+
+	for _, file := range files {
+		fpath := filepath.Join(dest, file.Name)
+		if file.IsDir {
+			dir, err := os.Stat(fpath)
+			if err != nil {
+				if os.IsNotExist(err) {
+					if err := os.MkdirAll(fpath, 0755); err != nil {
+						return err
+					}
+				} else {
+					return err
+				}
+			} else if !dir.IsDir() {
+				return fmt.Errorf("cannot create directory %q: File exists", fpath)
+			}
+		} else {
+			if err := os.MkdirAll(filepath.Dir(fpath), 0755); err != nil {
+				return err
+			}
+
+			f, err := os.Create(fpath)
+			if err != nil {
+				return err
+			}
+			if _, err := f.Write(file.Body); err != nil {
+				return err
+			}
+			if err := f.Close(); err != nil {
+				return err
+			}
+		}
+	}
+
+	return nil
+}

archive/testdata/test

@@ -0,0 +1,36 @@
+package archive
+
+import (
+	"os"
+	"reflect"
+	"testing"
+)
+
+func TestUnPack(t *testing.T) {
+	tc := []string{"testdata/test.zip", "testdata/test.tar.gz"}
+	result := []File{
+		{Name: "1.txt", Body: []byte("1")},
+		{Name: "2.txt", Body: []byte("2")},
+	}
+	for _, i := range tc {
+		f, err := os.Open(i)
+		if err != nil {
+			t.Fatal(err)
+		}
+		fs, err := Unpack(f)
+		if err != nil {
+			t.Fatalf("Unpack %q failed: %v", i, err)
+		}
+		if !reflect.DeepEqual(fs, result) {
+			t.Errorf("expected %#v; got %#v", result, fs)
+		}
+	}
+
+	f, err := os.Open("testdata/folder.zip")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := UnpackToFiles(f, "testdata"); err == nil {
+		t.Error("expected error; got nil")
+	}
+}

archive/testdata/test.tar.gz

@@ -0,0 +1,61 @@
+package archive
+
+import (
+	"archive/zip"
+	"bytes"
+	"io"
+	"log"
+)
+
+const zipMagic = "PK\x03\x04"
+
+func packZip(w io.Writer, files ...File) error {
+	zw := zip.NewWriter(w)
+
+	for _, file := range files {
+		f, err := zw.Create(file.Name)
+		if err != nil {
+			return err
+		}
+		if _, err := f.Write(file.Body); err != nil {
+			return err
+		}
+	}
+
+	return zw.Close()
+}
+
+func unpackZip(b []byte) ([]File, error) {
+	r, err := zip.NewReader(bytes.NewReader(b), int64(len(b)))
+	if err != nil {
+		return nil, err
+	}
+
+	var fs []File
+	for _, f := range r.File {
+		switch {
+		case f.FileInfo().IsDir():
+			fs = append(fs, File{Name: f.Name, IsDir: true})
+		case f.FileInfo().Mode().IsRegular():
+			rc, err := f.Open()
+			if err != nil {
+				return nil, err
+			}
+			var buf bytes.Buffer
+			if _, err := io.Copy(&buf, rc); err != nil {
+				return nil, err
+			}
+			fs = append(fs, File{Name: f.Name, Body: buf.Bytes()})
+			if err := rc.Close(); err != nil {
+				return nil, err
+			}
+		default:
+			log.Printf(
+				"ExtractZip: uknown type: %d in %s",
+				f.FileInfo().Mode(),
+				f.Name)
+		}
+	}
+
+	return fs, nil
+}