cocos/internal/zip.go

// Copyright (c) Ultraviolet
// SPDX-License-Identifier: Apache-2.0
package internal

import (
	"archive/zip"
	"bytes"
	"io"
	"os"
	"path/filepath"
	"sort"
	"time"
)

func ZipDirectoryToMemory(sourceDir string) ([]byte, error) {
	buf := new(bytes.Buffer)
	zipWriter := zip.NewWriter(buf)

	var files []string
	err := filepath.Walk(sourceDir, func(path string, info os.FileInfo, err error) error {
		if err != nil {
			return err
		}
		if !info.IsDir() {
			files = append(files, path)
		}
		return nil
	})
	if err != nil {
		return nil, err
	}

	sort.Strings(files)

	for _, path := range files {
		info, err := os.Stat(path)
		if err != nil {
			return nil, err
		}

		relPath, err := filepath.Rel(sourceDir, path)
		if err != nil {
			return nil, err
		}

		zipHeader, err := zip.FileInfoHeader(info)
		if err != nil {
			return nil, err
		}
		zipHeader.Name = relPath
		zipHeader.Modified = time.Unix(0, 0) // Deterministic timestamp

		zipWriterEntry, err := zipWriter.CreateHeader(zipHeader)
		if err != nil {
			return nil, err
		}

		fileToZip, err := os.Open(path)
		if err != nil {
			return nil, err
		}
		defer fileToZip.Close()

		_, err = io.Copy(zipWriterEntry, fileToZip)
		if err != nil {
			return nil, err
		}
	}

	if err := zipWriter.Close(); err != nil {
		return nil, err
	}

	return buf.Bytes(), nil
}

func ZipDirectoryToTempFile(sourceDir string) (*os.File, error) {
	tmpFile, err := os.CreateTemp("", "dataset*.zip")
	if err != nil {
		return nil, err
	}

	zipWriter := zip.NewWriter(tmpFile)

	var files []string
	err = filepath.Walk(sourceDir, func(path string, info os.FileInfo, err error) error {
		if err != nil {
			return err
		}
		if !info.IsDir() {
			files = append(files, path)
		}
		return nil
	})
	if err != nil {
		zipWriter.Close()
		return nil, err
	}

	sort.Strings(files)

	for _, path := range files {
		info, err := os.Stat(path)
		if err != nil {
			zipWriter.Close()
			return nil, err
		}

		relPath, err := filepath.Rel(sourceDir, path)
		if err != nil {
			zipWriter.Close()
			return nil, err
		}

		zipHeader, err := zip.FileInfoHeader(info)
		if err != nil {
			zipWriter.Close()
			return nil, err
		}
		zipHeader.Name = relPath
		zipHeader.Modified = time.Unix(0, 0) // Deterministic timestamp

		zipWriterEntry, err := zipWriter.CreateHeader(zipHeader)
		if err != nil {
			zipWriter.Close()
			return nil, err
		}

		fileToZip, err := os.Open(path)
		if err != nil {
			zipWriter.Close()
			return nil, err
		}
		defer fileToZip.Close()

		_, err = io.Copy(zipWriterEntry, fileToZip)
		if err != nil {
			zipWriter.Close()
			return nil, err
		}
	}

	if err := zipWriter.Close(); err != nil {
		return nil, err
	}

	if _, err := tmpFile.Seek(0, 0); err != nil {
		return nil, err
	}

	return tmpFile, nil
}

func UnzipFromMemory(zipData []byte, targetDir string) error {
	reader := bytes.NewReader(zipData)
	zipReader, err := zip.NewReader(reader, int64(len(zipData)))
	if err != nil {
		return err
	}

	for _, file := range zipReader.File {
		filePath := filepath.Join(targetDir, file.Name)

		if file.FileInfo().IsDir() {
			if err := os.MkdirAll(filePath, os.ModePerm); err != nil {
				return err
			}
			continue
		}

		if err := os.MkdirAll(filepath.Dir(filePath), os.ModePerm); err != nil {
			return err
		}

		srcFile, err := file.Open()
		if err != nil {
			return err
		}
		defer srcFile.Close()

		dstFile, err := os.Create(filePath)
		if err != nil {
			return err
		}
		defer dstFile.Close()

		if _, err := io.Copy(dstFile, srcFile); err != nil {
			return err
		}
	}

	return nil
}